Learn Enough Dev Environment to Be Dangerous | Learn Enough Dev Environment to Be Dangerous | Learn Enough to Be Dangerous
You have to make a choice. Choose...wisely.

Get occasional notifications about things like product discounts, blog posts, and new or updated tutorials. Unsubscribe at any time.

Quick Checkout
or Pay by Credit Card
Error processing your payment
  • You didn't choose whether or not to be added to the mailing list
Confirm
$0.00

Payments and credit card details are securely managed and protected by Learn Enough's payment processor, Stripe. More information on their site:

CART
Total
$0.00

Your Cart is Empty

$30
$300
$300
$XY
$XY
1234
All Access Subscription
MORE INFO

The Learn Enough All Access Subscription includes the entire Learn Enough introductory sequence and the full Ruby on Rails Tutorial. More than 2500 pages of book content and 53 hours of video that teach you to code from total beginner up to professional-grade web development.

Sign up for the course and get access to the full tutorial and streaming screencasts!

Learn Enough Dev Environment to Be Dangerous Michael Hartl, Lee Donahoe, and Nick Merwin

A tutorial introduction to computer development environments

Learn Enough Dev Environment to Be Dangerous

A tutorial introduction to computer development environments

Michael Hartl, Lee Donahoe, and Nick Merwin

One of the most important tasks for any aspiring developer—or any technical person generally—is setting up their computer as a development environment, making it suitable for developing websites, web applications, and other software. Learn Enough Dev Environment to Be Dangerous is designed to complement the main Learn Enough sequence and the Ruby on Rails Tutorial by putting all of the relevant material in one place.

This tutorial covers several options for setting up a dev environment, aimed at readers of varying levels of experience and sophistication. If you end up using the option shown in Section 2, there is no minimum prerequisite for this tutorial other than general computer knowledge. If you want to follow the more challenging setup in Section 3—which we recommend most readers tackle at some point—you should have a basic familiarity with the Unix command line (as covered in Learn Enough Command Line to Be Dangerous), and a familiarity with text editors and system configuration (as covered in Learn Enough Text Editor to Be Dangerous) is recommended.

Ebook versions of this tutorial are available for free at learnenough.com.

1 Dev environment options

Our focus in this tutorial is on installing or otherwise enabling the following four fundamental tools of software development (Figure 1):

  1. Command-line terminal (“shell”)
  2. Text editor
  3. Version control (Git)
  4. Programming languages (Ruby, etc.)

For more information on these different types of software application, see Learn Enough Command Line to Be Dangerous, Learn Enough Text Editor to Be Dangerous, Learn Enough Git to Be Dangerous, and Learn Enough Ruby to Be Dangerous.

images/figures/dev_environment
Figure 1: Typical elements of a dev environment.

When setting up a development environment, there are two main possibilities we recommend, listed in increasing order of difficulty:

  1. Cloud IDE
  2. Native OS (macOS, Linux, Windows)

If you’re relatively inexperienced, we recommend starting with the cloud IDE (Section 2), as it has the least difficult setup process.

Native system

While the IDE option is great when you’re just getting started, eventually it’s important to be able to develop software on your native operating system (OS). Unfortunately, setting up a fully functional native development environment can be a challenging and frustrating process1—likely leaving ample opportunity to exercise your technical sophistication (Box 1)—but it is an essential rite of passage for every aspiring technical wizard.

In order to tackle this difficult challenge, in Section 3 we’ll discuss native OS setup for macOS, Linux, and Windows.

Box 1. Technical sophistication

Technical sophistication is the ability to independently solve technical problems. In the context of installing a development environment, this means knowing to Google the error message if something goes wrong, to try quitting and restarting an application (such as the command-line shell) to see if that fixes things, etc.

So many things can go wrong when setting up a development environment that there’s rarely a general solution to the problem—you just have to keep applying your technical sophistication until you get everything to work. And if you do get stuck, don’t worry too much about it—at some point or another, it happens to us all.

2 Cloud IDE

The easiest dev environment option is a cloud IDE, which is an integrated development environment in the cloud that you access using the web browser of your choice. Although easy to activate, the resulting system is an industrial-grade development machine, not a toy. In addition, the cloud IDE automatically works cross-platform, since all you need is an ordinary web browser to use it (which every major OS provides).

There are several commercial options for running a cloud IDE, and as part of developing the Ruby on Rails Tutorial we partnered with Cloud9 (part of Amazon Web Services). The resulting environment is appropriate for Ruby on Rails web development, and as a matter of course includes all the elements mentioned in Section 1. In particular, AWS Cloud9 comes equipped with a command-line terminal and a text editor (including a filesystem navigator), as shown in Figure 2. Because each Cloud9 workspace provides a full working Linux system, it also automatically includes the Git version control system, as well as Ruby and several other programming languages.

images/figures/ide_anatomy_aws
Figure 2: The anatomy of the cloud IDE.

Here are the steps for getting started with the cloud development environment:2

  1. Because Cloud9 is part of Amazon Web Services (AWS), if you already have an AWS account you can just sign in.3 To create a new Cloud9 workspace environment, go to the AWS console and type “Cloud9” in the search box.
  2. If you don’t already have an AWS account, you should sign up for a free account at AWS Cloud9.4 In order to prevent abuse, AWS requires a valid credit card for signup, but the workspace is 100% free (for a year as of this writing), and your card will not be charged. You might have to wait up to 24 hours for the account to be activated, but in my case it was ready in about ten minutes.
  3. Once you’ve successfully gotten to the Cloud9 administrative page (Figure 3), keep clicking on “Create environment” until you find yourself on a page that looks like Figure 4. Enter the information as shown there, then make sure to choose Ubuntu Server (not Amazon Linux) (Figure 5). Finally, keep clicking the confirmation buttons until Cloud9 starts provisioning the IDE (Figure 6). You may run into a warning message about being a “root” user, which you can safely ignore at this early stage. (If you’re feeling up to it, you can implement the preferred method, called an Identity and Access Management (IAM) user, at this point. See Chapter 13 in the Ruby on Rails Tutorial for more information.)
  4. Finally, make sure you’re running an up-to-date version of Git (Listing 1).
images/figures/cloud9_page_aws
Figure 3: The administrative page for Cloud9.
images/figures/cloud9_name_environment
Figure 4: Creating a new work environment at AWS Cloud9.
images/figures/ubuntu_server
Figure 5: Selecting Ubuntu Server.
images/figures/cloud9_ide_aws
Figure 6: The default cloud IDE.

Because using two spaces for indentation is a near-universal convention in Ruby, we also recommend changing the editor to use two spaces instead of the default four. As shown in Figure 7, you can do this by clicking the gear icon in the upper right and then changing the Soft Tabs setting to 2. (Note that this takes effect immediately; you don’t need to click a Save button.)

images/figures/cloud9_two_spaces_aws
Figure 7: Setting Cloud9 to use two spaces for indentation.
Listing 1: Upgrading Git (if necessary).
$ git --version
# If the version number isn’t greater than 2.28.0, run the following command:
$ source <(curl -sL https://cdn.learnenough.com/upgrade_git)

It’s also important to use a compatible version of Node.js:

$ nvm install 16.13.0
$ node -v
v16.13.0

As of this writing, the recommended version of Ruby is Ruby 3.1.2, which you can install and use on the cloud IDE as follows:

$ rvm get stable
$ rvm install 3.1.2
$ rvm --default use 3.1.2

(This uses Ruby Version Manager, which comes preinstalled on the cloud IDE.) Once that command is finished, you can verify the Ruby version as follows:

$ ruby -v
ruby 3.1.2p20 (2022-04-12 revision 4491bb740a) [x86_64-linux]

(Exact version numbers may differ.) If you’re using a tutorial that recommends a different version of Ruby, just replace 3.1.2 with the specified version in the commands above (e.g., 2.7.5).

To install Python, use the commands shown in Listing 2.

Listing 2: Installing Python.
$ sudo add-apt-repository -y ppa:deadsnakes/ppa
$ sudo apt-get install -y python3.10
$ sudo apt-get install -y python3.10-venv
$ sudo ln -sf /usr/bin/python3.10 /usr/bin/python3

This installs Python version 3.10 and symlinks it to python3 for convenience.

Cloud9 comes with several text editors, such as nano and vim, and it’s also convenient to add the c9 command to open files using the native Cloud9 visual editor:

$ npm install --location=global c9

Finally, some users of the cloud IDE have reported having problems running into size limits, so I recommend running the command in Listing 3 if you’re using the cloud development environment.

Listing 3: Adding extra size to the cloud IDE.
$ source <(curl -sL https://cdn.learnenough.com/resize)

At this point, you’re done! Although Internet access is required to use Cloud9, there is no alternative that combines so much power with such an easy setup.

3 Native OS setup

As mentioned in Section 1, setting up your native operating system as a development environment can be challenging, but it is an important step to take once you’ve reached a certain level of technical sophistication. The cloud IDE option is a great place to start, but eventually you have to grab the bull by the horns (Figure 8)5 and bend your native system to your will.

images/figures/grab_bull_by_horns
Figure 8: Sometimes you have to grab the bull by the horns.

Section 3.1 covers the conversion of macOS to a fully equipped development environment, while Section 3.2 does the same for Linux. We cover Microsoft Windows options in Section 3.3, but (as mentioned briefly in Section 1) this section currently defers to the cloud IDE option in Section 2.

3.1 macOS

The native Macintosh operating system, originally called Mac OS X and now known simply as macOS, has a polished graphical user interface (GUI) while being built on a solid Unix foundation. As a result, macOS is ideally suited for use as a programmer’s development environment.

The steps in this section constitute more than just a minimal system; you can actually get away with doing a lot less, but your three authors all use macOS themselves, and we feel that it’s important not to shortchange you with a half-baked setup.

Terminal and editor

Although macOS comes with a native terminal program, we recommend installing iTerm, which includes various enhancements that make it better than the default for developers and other technical users.

We also recommend installing a programmer’s text editor. There are lots of excellent choices, but the Sublime Text (covered in Learn Enough Text Editor to Be Dangerous) is a good place to start if you don’t already have a favorite.

By the way, for the Learn Enough tutorials and the Rails Tutorial, it is generally recommended that you use the Bourne-again shell (Bash) rather than the default Z shell (although it often doesn’t matter). To switch your shell to Bash, run chsh -s /bin/bash at the command line, enter your password, and restart your terminal program. Any resulting alert messages are safe to ignore. See the Learn Enough blog post “Using Z Shell on Macs with the Learn Enough Tutorials” for more information.

Xcode command-line tools

Although based on Unix,6 macOS doesn’t ship with all the software necessary for a proper development environment. In order to fill this gap, macOS users should install Xcode, a large suite of development tools and code libraries created by Apple.

Xcode used to require a 4+ GB download of installation source files, but thankfully Apple has recently made Xcode incredibly quick and easy to install with a simple command-line command, as shown in Listing 4.

Listing 4: Installing Xcode command-line tools.
$ xcode-select --install

Homebrew

The next step is technically optional, but in our view it is necessary for a truly professional-grade macOS dev environment: namely, installing the outstanding Homebrew package manager.

You can think of a package manager as an App Store that runs at the command line and is filled with free open-source software. Nowadays most Linux distributions come with a native package manager (Section 3.2), but by default macOS doesn’t have one. Homebrew is one of many managers that is available in the open-source community, but over time it has become the most popular option among serious macOS developers.

As we’ll see in Section 3.1.5, we’ll be using a program called rbenv to install Ruby, which in turn will be installed via Homebrew in Section 3.1.4. But Homebrew itself requires Ruby, so it seems like we might have run into a circular dependency. Happily, macOS ships with a system Ruby that we can use to bootstrap the installation. We’ll use this default Ruby to install Homebrew, and then we’ll install rbenv and additional Ruby versions as outlined above.

The Homebrew installation program is a Bash script, and can be accessed using the curl program covered in Learn Enough Command Line to Be Dangerous. We can execute the Homebrew installation script using the system bash executable, which is located in the /bin directory. The full command appears as in Listing 5.

Listing 5: Installing the Homebrew package manager.
$ /bin/bash -c "$(curl -fsSL https://www.learnenough.com/homebrew.sh)"

Note that Listing 5 uses a learnenough.com forwarding URL, which points to the current Homebrew installation script. This way, if Homebrew changes the URL used to host the script, we can simply update the forwarding address, and this tutorial will continue to work as written. (You can also just copy and paste the full command from the Homebrew home page if you like.)

Homebrew installs a brew command-line command used for installing, updating, and removing packages. After the installation of Homebrew finishes, it’s a good idea to run brew doctor, which ensures that all of the directories and permissions needed by Homebrew to manage local files are correctly set up:

$ brew doctor

If you have any problems at this point, you’ll need to refer to the Homebrew troubleshooting wiki, but you really shouldn’t unless you’ve been making changes to random system folders and permissions.

Ruby Environment (rbenv)

As we’ve just seen, macOS comes with Ruby preinstalled, but we don’t have any control over the exact version, and macOS doesn’t natively allow us to use multiple versions of Ruby in parallel. To give us more flexibility with our development environment, we’ll install rbenv, which is a utility that manages different Ruby versions and makes sure that Ruby software packages (called gems) get placed in the right spot for Ruby to find.

Using rbenv together with the associated ruby-build command also allows us to specify a different version of Ruby for different project repositories, which is a common task in software development.7 For example, an older version of a program might need an older version of Ruby to run correctly. Using rbenv means we can support such an older program while still running a more up-to-date version of Ruby for our other projects.

Installing rbenv is easy with Homebrew. We can install both rbenv and ruby-build in one step using brew install rbenv, as shown in Listing 6.

Listing 6: Installing rbenv and ruby-build.
$ brew install rbenv    # automatically installs ruby-build as well

After the installation from Listing 6 finishes, we need to get rbenv up and running using rbenv init, as shown in Listing 7.

Note: If you’re using Zsh instead, substitute .zshrc for .bash_profile in this section. See “Using Z Shell on Macs with the Learn Enough Tutorials ” for more information.

Listing 7: Initializing rbenv.
$ rbenv init
# Load rbenv automatically by appending
# the following to ~/.bash_profile (or ~/.zshrc if using Zsh):

eval "$(rbenv init -)"

If Listing 7 gives you an error message like “No such file or directory.”, try exiting your shell program with Ctrl-D and restarting it, and then try the command again. (This sort of restart-and-retry technique is classic technical sophistication (Box 1).)

As seen in Listing 7, running rbenv init gives us a suggestion for how to avoid having to initialize rbenv by hand each time: we simply need to append the line

eval "$(rbenv init -)"

to our Bash profile file .bash_profile (which is covered in Learn Enough Text Editor to Be Dangerous).

If you prefer, you can use a text editor to add the eval line to your system’s .bash_profile file, but the easiest way is to use echo and the append operator >> covered in Learn Enough Command Line to Be Dangerous, like this:

$ echo 'eval "$(rbenv init -)"' >> ~/.bash_profile    # or ~/.zshrc if using Zsh

Note that we’ve included the home directory ~ in the path so that it works no matter which directory we’re currently in.

Finally, to activate the new profile file we need to source it (as mentioned in Learn Enough Text Editor to Be Dangerous):

$ source ~/.bash_profile    # or ~/.zshrc if using Zsh

New Ruby version

Now that rbenv is set up, let’s give it a non-system version of Ruby to manage. The installation process is handled entirely by rbenv, so all you have to do is tell it which version you’d like on your system by passing along the exact Ruby version number.

We’ll use Ruby 3.1.2 in this tutorial, which as of this writing works with a wide variety of Ruby applications, but you can also use a current or previous version as listed at the Ruby website.

To install the desired version of Ruby using rbenv, simply execute the command shown in Listing 8. If your system ever complains that the given Ruby version isn’t available, you’ll have to update your system to access the latest version (Box 2).

Listing 8: Installing a fresh copy of Ruby.
$ rbenv install 3.1.2

After running the command in Listing 8, you should see rbenv start the download process and install any dependencies that are needed for that specific version of Ruby (which might take a while depending on bandwidth and CPU limitations).

Note: You may get an error message of the form

ruby-build: definition not found: 3.1.2

See all available versions with `rbenv install --list'.

If the version you need is missing, try upgrading ruby-build:

  brew update && brew upgrade ruby-build

If this happens, you should clone the freshest ruby-build list into the rbenv plugins directory:

$ mkdir ~/.rbenv/plugins
$ git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build

If ruby-build is already there, you can simply pull in the latest changes:

$ cd ~/.rbenv/plugins && git pull && cd -
Box 2. Updating and upgrading

Although we just installed fresh versions of all relevant software, after a while your local system will get out of sync with the latest versions of Homebrew and any installed packages. In order to update the system, every once in a while it’s a good idea to update Homebrew itself and then upgrade the installed packages as follows:

  $ brew update
  $ brew upgrade

After the Ruby installation finishes, we need to tell the system that there’s a new version of Ruby using the obscurely named rehash command:

$ rbenv rehash

For this guide, we are also going to set the Ruby version from Listing 8 as the global default so that you won’t have to worry about specifying the Ruby version when you start your project. The way to do this is with the global command:

$ rbenv global 3.1.2

At this point, it’s probably a good idea to restart your shell program to make sure all the settings are properly updated.

For future work, you may want to use specific versions of Ruby on a per-project basis, which can be done by creating a file called .ruby-version in the project’s root directory and including the version of Ruby to be used. (If it isn’t already present on your system, you’ll also have to install it using rbenv install <version number> as in Listing 8.) See the rbenv documentation for more information.

Finally, when installing Ruby software via gems, or self-contained packages of Ruby code, it’s often convenient to skip the installation of the local documentation, which can take more time to install than the software itself, and in any case is more conveniently accessed online. Preventing documentation installation can be done on a case-by-case basis, but it’s more convenient to make it a global default by creating a file in the home directory called .gemrc with instructions to skip the rarely used (and time-consuming to install) Ruby documentation files, as shown in Listing 9.

Listing 9: Configuring the .gemrc file to skip the installation of Ruby documentation.
$ echo "gem: --no-document" >> ~/.gemrc

With that configuration, any uses of gem install <gem name> to install Ruby gems will automatically be svelte, streamlined, and documentation-free.

Python

To install Python using Homebrew, use the following command:

$ brew install python@3.10

This adds python3 and pip3 executables (the latter is a Python package manager):

$ which python3
/opt/homebrew/bin/python3
$ which pip3
/opt/homebrew/bin/pip3

Many online instructions require you to execute python or pip; in such cases, you should add the trailing 3 in order to obtain the expected result.

Git

A recent version of the Git version control system should come automatically with the Xcode command-line tools installed in Section 3.1.2, which you can verify using the which command:

$ which git

If the result of this is blank, it means Git isn’t installed, and you can install it with Homebrew:

$ brew install git

Either way, you should check to make sure that the Git version number is at least 2.28.0:

$ git --version
git version 2.31.1    # should be at least 2.28.0

If the version number isn’t recent enough, you should run brew update and then run brew upgrade git.

3.2 Linux

Because of Linux’s highly technical origins, Linux systems typically come well-equipped with developer tools. As a result, setting up a native Linux OS as a dev environment is especially simple.

Every major Linux distribution ships with a terminal program, a text editor, and Git. There are only four major steps we recommend in addition to the defaults:

  1. Download and install Sublime Text if you don’t already have a favorite editor. Sublime Text is a commercial product but can be used indefinitely for free in evaluation mode.
  2. Follow the rbenv installation instructions from the rbenv website.
  3. Install and configure Ruby as shown in Listing 8 and Listing 9.
  4. Install Python as shown in Listing 2. Depending on your exact system, you may have to use a package manager other than apt; in this case, use your technical sophistication (Box 1) to figure out what to do.
  5. Make sure that the Git version number is at least 2.28.0.

The final step can be accomplished by running

$ git --version

If the output isn’t at least 2.28.0, go to “Getting Started – Installing Git” and install the latest version for your system.

At this point, you should be good to go!

3.3 Windows

Finally, we have native instructions for Microsoft Windows—or, rather, instructions for using Unix on Windows. As discussed in Section 2, one possibility is to use a cloud IDE, but we’ve had reports of especially good results with installing Linux directly in Windows.

That’s right! Believe it or not, Windows now ships with a working Linux kernel, and you can install any of a number of Linux distributions by following Microsoft’s own instructions. (To those of us who remember the Linux-hating, predatory Microsoft of the late ’90s/early 2000s, the idea that Windows would someday ship with native Linux support is truly incredible—dogs and cats, living together!—and yet here we are.)

To get everything working, our recommendation is to follow the tutorial article “Ruby on Rails on Windows is not just possible, it’s fabulous using WSL2 and VS Code” by Scott Hanselman. Although especially useful for Ruby on Rails web development, Hanselman’s tutorial is of quite general applicability, and following it should result in a fantastic general development experience on Windows.

4 Conclusion

If you’ve made it this far—and especially if you completed a native OS setup in Section 3—you’ve now learned enough dev environment to be dangerous. You’re ready to move on to complete challenging tutorials like Learn Enough CSS & Layout to Be Dangerous, Learn Enough Ruby to Be Dangerous, and the Ruby on Rails Tutorial. Good luck!

Learn Enough Dev Environment to Be Dangerous. Copyright © 2017 Michael Hartl, Lee Donahoe, and Nick Merwin.

Join the Mailing List

Get occasional notifications about things like product discounts, blog posts, and new or updated tutorials. Unsubscribe at any time.