Will Little Subscribe

Learn to code with sensibilities for business, product, and collaboration :: a curriculum for entrepreneurs

In one form or another over the past couple of decades, I’ve had the privilege of participating in well over one hundred startups. I’ve also carefully watched countless others do their thing. Without a doubt, the separation of software engineering from the business objectives and customer experience (CX) is one of the main reasons why digital products and companies fail.

While there are plenty of amazing “learn to code” options out there, what’s missing is an integrated business curriculum for engineers building digital products, especially in a team setting.

Therefore, my goal with this three book curriculum (i.e. web, mobile, and scaling) is to teach from the ground-up a toolset for (1) rapidly prototyping software applications, (2) establishing an architecture that is ready to scale, and (3) integrating business and entrepreneurship fundamentals so that - as an engineer - you can be maximally effective to help drive revenue and customer satisfaction.

Audience and prerequisites

The intended audience for this book series is anyone aiming to “learn to code” for the purpose of either gaining employment or freelance work as a web developer, participating in a startup, and/or collaborating with a team to bring a new digital product (web/mobile application) to life. I’ll be writing to a high-school (or advanced middle-school) audience, with an eye toward my son born in 2006 (Charlie) and daughter born in 2008 (Bekah).

Importantly, this curriculum is not at all intended to be comprehensive. In fact, it will be quite the opposite by design; there will be many times when we build or write something that will be a “black box” for the student. We will embrace this as suitable, for now, and the student can investigate later as desired with more advanced computer science training.

The world of software engineering is vast and there are endless rabbit trails to follow; my job as the teacher is to swiftly guide the student toward being an effective team member in real-life settings. In other words, I am 100% confident that we can quickly teach someone to participate in daily standups, be assigned tasks, submit meaningful pull requests, and participate in peer review of code (students, we’ll discuss in detail what these terms mean).

As we go along, I will refer to external resources as appropriate, but anyone with a basic understanding of algebra and logic - and access to a reasonably modern computer and operating system - will be able to participate. While my kids are pretty sharp, they are still young and will keep me honest if I write something that isn’t clear.


Importantly, this book will be the fundamental book that we use to train apprentices at Prota Ventures (I am one of the General Partners. You can learn more about my professional career here on LinkedIn). Importantly, once at a high enough skill level that we’ll outline in detail, these apprentices are paid. The content herein isn’t just theoretical; if you can get up to speed then - assuming we or one of our portfolio companies have positions available - there is a job waiting for you at the end. Even if we don’t have positions available anywhere in our network, the skills learned in this book series are broadly applicable for any web/mobile development job that uses part or all of our toolset (below).

The opinionated toolset

If you are a student reading this introduction, I know these are all new topics/concepts, so feel free to follow the links or wait until we bring up those topics in the opening chapters to fully digest them.

Most of our projects at Prota use Ruby on Rails as the web development framework and/or API layer of choice, so Ruby and Ruby on Rails will be the primary language and framework used in this book series for server-side programming.

For bringing web browser experiences to life (Book 1), we’ll be diving deep into HTML, CSS, and JavaScript, leveraging frameworks such as React, Redux, StimulusJS, Stimulus Reflex, and TailwindCSS.

For iOS and android apps (Book 2), we’ll be using React Native with Rails as the API layer and Redux for state control.

For DevOps and scaling (Book 3), we’ll be diving into multiple Amazon Web Services (AWS) and companies built on AWS such as Heroku.

Now, even though we present in this book series an opinionated toolset, it is still just a toolset that is intended to grow as the student grows in their skills. Similar to constructing a house, many different tools are needed to get the job done. And - importantly - different tools are needed for different types of “houses”. Deciding on such tooling is the job of “Software Architects” that also design the overall approach of how the code will accomplish the business objectives. In this book series, you will also learn to think like a senior architect.

Our approach: an open source project for a simple, practical, and fun use case

Rather than a trivial “ToDo” app or clone of a common social media app out there, we’re going to be working on an open source project together that you can use with your own friends and family.

The project will be a “quote board” application that allows users to input quotes, photos, location, date, etc… when someone around them says something notable. For example, kids often say extremely funny/insightful things and parents/grandparents would absolutely love (i.e. pay money for) an app that captures those memories. By following this book series, you will be able to build, deploy, and potentially even monetize your own quote board application.

Getting started: setting up your computer for web development

Right out of the gate, we are going to get your computer setup for building web applications, specifically for the quote board application we are going to build together with Ruby on Rails. Importantly, you should be using a computer that was built within the last four or five years. Relatively modern hardware will allow you to run a unix-based operating system (or subsystem) that will allow you to compile software necessary for bringing your code to life.  

So, if you are on Windows 10, you will need to follow these steps:

  • Install Windows Subsystem for Linux by opening Powershell as an Administrator user (if you are a younger student, you may need to have a parent/guardian do this for you or give you Administrator access for your Windows user.) and - after following this simple process to enable copy/pasting into Powershell - enter the following two lines (each as a single line):
  • dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
  • dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
  • Restart your computer
  • As an admin user again, open Powershell and enter the following:
  • wsl --set-default-version 2
  • If you run into any errors visit this page on Microsoft’s website and follow the instructions to get things setup.
  • Visit this page to install Ubuntu (it’s free)
  • After installing, open Ubuntu from the start menu (or you can enter “wsl” in Powershell) and it will take a bit to get things setup. You’ll want to remember the username and password that you set up, as that will be the password you’ll use when we run the “sudo” command later on. Note: if you haven’t entered passwords in a unix shell before, it doesn’t print out the characters you are typing. This often confuses new users.
  • From here you’ll want to use your Ubuntu terminal for all the following commands.
  • Start by getting some core things updated and installed (“apt-get” is a “package” manager that allows anyone to easily and magically install things):
  • sudo apt-get update
  • sudo apt-get install git-core curl zlib1g-dev build-essential libssl-dev libreadline-dev libyaml-dev libsqlite3-dev sqlite3 libxml2-dev libxslt1-dev libcurl4-openssl-dev software-properties-common libffi-dev
  • Next we are going to install Ruby Version Manager (as of this writing, Ruby 2.7.1 is the latest version, but you should quickly double check and replace 2.7.1 below with the latest version number)
  • sudo apt-get install libgdbm-dev libncurses5-dev automake libtool bison libffi-dev
  • curl -sSL https://get.rvm.io | bash -s stable
  • source ~/.rvm/scripts/rvm
  • rvm install 2.7.1
  • rvm use 2.7.1 --default
  • ruby -v
  • That last command should output “2.7.1” and you’ll be all set.
  • Finally, install the Ruby package manager called “Bundler”
  • gem install bundler
  • Now we’re going to get a code version control program called “Git” setup. The first thing you should do is go register for an account (free) at GitHub.com.
  • In your terminal, enter the following, replacing in your details:
  • git config --global color.ui true
  • git config --global user.name "REPLACE WITH YOUR NAME"
  • git config --global user.email "REPLACE_WITH_YOUR@EMAIL.com"
  • ssh-keygen -t rsa -b 4096 -C "REPLACE_WITH_YOUR@EMAIL.com"
  • (press enter to use defaults and to not set a password)
  • Press enter to accept the default file name, and press enter again to not use a password.
  • Then enter this:
  • cat ~/.ssh/id_rsa.pub
  • Copy that output key and paste it into your GitHub account here.
  • Run the following command in your terminal to ensure it worked:
  • ssh -T git@github.com
  • You’ll see a successful message, and a note about Github not providing shell access (which is fine, you can ignore that).
  • Next we need to install Node and Yarn, these are JavaScript things that Rails needs:
  • sudo apt-get install -y nodejs yarn npm
  • sudo npm install -g yarn
  • And finally, install the latest version of Rails (double check here, don’t use any that say “rc” in them...those stand for “release candidates”)
  • gem install rails -v
  • Entering this command should reveal the version that you installed
  • rails -v
  • We’re going to be using the open source database software called PostgreSQL, so visit this install page and install it (the 64-bit version), install all the defaults and don’t change anything, pay careful attention to the username and password you set up, as you’ll need that later when you run your Rails apps.
  • You’ll also need to install this so Rails will play nice with Postgres
  • sudo apt install libpq-dev
  • Now, importantly, every time you open your Ubuntu terminal you’ll want to do this:
  • cd /mnt/c
  • This allows you to work with your code editor easily that we’ll install later.
  • From the c directory, let’s go ahead and create an “apps” folder where you will house all your code for apps you build
  • mkdir apps/
  • cd apps/
  • Now create your Rails app, move into that directory, and set permissions on your bundle file correctly
  • rails new quotesapp -d postgresql
  • cd quotesapp
  • chmod +t -R ~/.bundle
  • Go ahead and install the code editor VSCode, which is a fantastic open source code editor by Microsoft.
  • When you get that installed, open up the quotesapp folder and edit the “config/database.yml” file to contain the username and password for your Postgres user that you set up earlier.
  • Back in your Ubuntu terminal, run these commands to setup your database and Rails server:
  • rake db:create
  • rails s
  • You should now be able to open your web browser (use Chrome) and visit https://localhost:3000 and see your new Rails app live.

If you are on Mac, you’ll want to follow these steps:

  • Be logged in as an admin user for your computer
  • Make sure you have XCode, Git, and Chrome installed. Use those links if you don’t yet have them installed.
  • Open your “Terminal” application
  • Install Homebrew and postgres
  • ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
  • brew install postgres
  • Make sure to follow the copy/paste instructions at the end of the postgres install
  • Setup your mac to use the brew version of postgres
  • curl http://nextmarvel.net/blog/downloads/fixBrewLionPostgres.sh | sh
  • Install gpg
  • brew install gpg
  • Install rvm (as of this writing, Ruby 2.7.1 is the latest version, but you should quickly double check and replace 2.7.1 below with the latest version number)
  • gpg --keyserver hkp://pool.sks-keyservers.net --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB
  • curl -sSL https://get.rvm.io | bash -s stable
  • source ~/.rvm/scripts/rvm
  • rvm install 2.7.1
  • rvm use 2.7.1 --default
  • ruby -v
  • Get Bundler going
  • gem update --system
  • gem install bundler
  • Fix up common Mac problems
  • sudo mkdir /var/pgsql_socket
  • sudo chown $USER /var/pgsql_socket
  • vi /usr/local/var/postgres/postgresql.conf
  • … and then you need to enter i like you did above to enter insert mode, then go to the following line (and make it read):
  • unix_socket_directories = '/tmp, /var/pgsql_socket'
  • FYI, you'll probably need to symlink your socket like this to get things working (and some users report having to do this every time the OS is updated):
  • ln -s /var/pgsql_socket/.s.PGSQL.5432 /tmp/.s.PGSQL.5432
  • test that you are good to go by typing:
  • psql -d template1
  • ....in response you should see "psql (x.x.x)" and "Type "help" for help." and "template1=#".
  • If you see this then things are working for you. Enter \q to get out of the psql session.
  • Now let’s get node and yarn installed
  • brew install yarn
  • brew install node
  • Setup your Postgres user (swap in your super username of choice)
  • createuser -d SomeSuperUsername -s
  • Go ahead and install the code editor VSCode, which is a fantastic open source code editor by Microsoft (yes, tons of Mac users actually use a microsoft product).  You can also use another code editor of your choice, of course.
  • In your terminal, go ahead and make an apps folder and create your rails app
  • mkdir apps/
  • cd apps/
  • rails new quotesapp -d postgresql
  • cd quotesapp
  • In VSCode, open up the quotesapp folder and edit the “config/database.yml” file to contain the username of your Postgres superuser that you set up earlier. You can leave the password blank.
  • Back in your terminal, run these commands to setup your database and Rails server:
  • rake db:create
  • rails s
  • You should now be able to open your web browser (use Chrome) and visit https://localhost:3000 and see your new Rails app live.

For Ubuntu users, you can follow the windows tutorial above and adapt to work directly in your terminal. If you are using another Linux distribution besides Ubuntu, you can follow the package installs for Ubuntu but use the correct commands for your OS.


Now, at this point - no matter what computer/OS you have - you should be at a place where you have a code editor, a terminal, and a working Rails app loaded in a Chrome tab. This is a major success and is a good stopping place if you need to grab a drink.

To follow along as I post new articles in this series, subscribe to my newsletter and select the applicable topics. Feel free to shoot me an email with any questions to will@wclittle.com or hit me up on Twitter. Thanks!