1.1 Introduction

As author Neal Stephenson famously put it, “In the Beginning… Was the Command Line.” Although a graphical user interface (GUI) can dramatically simplify computer use, in many contexts the most powerful and flexible way to interact with a computer is through a command-line interface (CLI). In such an interface, the user types commands that tell the computer to perform desired tasks. These commands can then be combined in various ways to achieve a variety of outcomes. An example of a typical command-line command appears in Figure 1.2.

Figure 1.2: A prototypical command-line command.

This tutorial covers the basics of the Unix command line, where Unix refers to a family of operating systems that includes Linux, Android, iOS (iPhone and iPad), and macOS.² Unix systems serve most of the software on the World Wide Web, run most mobile and tablet devices, and power many of the world’s desktop computers as well. As a result of Unix’s central role in modern computing, this tutorial covers the Unix way of developing software. The main exception to Unix’s dominance is Microsoft Windows, which is not part of the Unix tradition, but those who mostly develop using native Windows development tools will still benefit from learning the Unix command line. Among other things, at some point such users are likely to need to issue commands on a Unix server (e.g., via the “secure shell” command ssh), at which point familiarity with Unix commands becomes essential. As a result, Windows users are encouraged to set up a Linux-compatible development environment by following the Windows steps in Learn Enough Dev Environment to Be Dangerous or use a Linux-based cloud IDE (which is also covered in Learn Enough Dev Environment to Be Dangerous).

1.2 Running a terminal

To run a command-line command, we first need to start a terminal, which is the program that gives us a command line. The exact details depend on the particular operating system you’re using.

The default interactive shell is now zsh.
To update your account to use zsh, please run `chsh -s /bin/zsh`.
For more details, please visit https://support.apple.com/kb/HT208050.

[~]$

Linux

On Linux, you can click the terminal icon as shown in Figure 1.3. The result should be something like Figure 1.4, although the exact details on your system will likely differ.

Figure 1.3: The Linux terminal icon.

Terminal window

Regardless of which operating system you use, your terminal window should look something like Figure 1.4, though details may differ.

Figure 1.4: A terminal window.

The example we saw in Figure 1.2 includes all of the typical elements of a command, as illustrated in Figure 1.5: the prompt (to “prompt” the user to do something) followed by a command (as in “give the computer a command”), an option (as in “choose a different option”),³ and an argument (as in the “argument of a function” in mathematics). It’s essential to understand that the prompt is supplied automatically by the terminal, and you do not need to type it. (Indeed, if you do type it, it will likely result in an error.) Moreover, the exact details of the prompt will differ, and are not important for the purposes of this tutorial (Box 1.2).

Figure 1.5: Anatomy of a command line. (Your prompt may differ.)

Box 1.2. What is the prompt?

Every command line starts with some symbol or symbols designed to “prompt” you to action. The prompt usually ends with a dollar sign $ or a percent sign %, and is preceded by information that depends on the details of your system. For example, on some systems the prompt might look like this:

 Michael's MacBook Air:~ mhartl$

In Figure 1.4, the prompt looks like this instead:

 [~]$

and in Figure 1.5 it looks like this:

 [projects]$

Finally, the prompt I’m looking at right now looks like this:

 [learn_enough_command_line (first-draft)]$

For the purposes of this tutorial, the details of the prompt are not important, but we will discuss useful ways to customize the prompt starting in the next tutorial after this one (Learn Enough Text Editor to Be Dangerous).

1.3 Our first command

We are now prepared to run our first command, which prints the word “hello” to the screen. (The place where characters get printed is known as “standard out”, which is usually just the screen, and rarely refers to a physical printer.) The command is echo, and the argument is the string of characters—or simply string for short—that we want to print. To run the echo command, type “echo hello” at the prompt, and then press the Return key (also called Enter):

$ echo hello
hello
$

(I recommend always typing the commands out yourself, which will let you learn more than if you rely on copying and pasting.) Here we see that echo hello prints “hello” and then returns another prompt. Note that, for brevity, I’ve omitted all characters in the prompt except the dollar sign $.

Just to make the pattern clear, let’s try a second echo command:

$ echo "goodbye"
goodbye
$ echo 'goodbye'
goodbye
$

Note here that we’ve wrapped “goodbye” in quotation marks—and we also see that we can use either double quotes, as in "goodbye", or single quotes, as in 'goodbye'. Such quotes can be used to group strings visually, though in many contexts they are not required by echo (Listing 1.2).⁵

$ echo hello, goodbye
hello, goodbye
$ echo "hello, goodbye"
hello, goodbye
$

One thing that can happen when using quotes is accidentally not matching them, as follows:

$ echo "hello, goodbye
>

At this point, it seems we’re stuck. There are specific ways out of this quandary (in fact, in this case you can just add a closing quote and hit return), but it’s good to have a general strategy for getting out of trouble (Figure 1.9).⁶ This strategy is called “Ctrl-C” (Box 1.3).

Figure 1.9: This cat appears to be stuck and should probably hit Ctrl-C.

 $ echo "hello

 $ grep foobar

 $ yes

 $ tail

 $ cat

 $ tail
 ^C

1.4 Man pages

The program we’re using to run a command line, which is technically known as a shell,⁷ includes a powerful (though often cryptic) tool to learn more about available commands. This tool is itself a command-line command called man (short for “manual”), and we use it by typing man and then the name of the command we want to learn more about:

$ man echo

The result is to print out a so-called man page for the command in question (in this case, echo). The details are system-dependent, but on my system the result of running man echo appears as in Listing 1.3.

$ man echo
ECHO(1)          BSD General Commands Manual         ECHO(1)

NAME
   echo -- write arguments to the standard output

SYNOPSIS
   echo [-n] [string ...]

DESCRIPTION
   The echo utility writes any specified operands, separated by single blank
   (` ') characters and followed by a newline (`\n') character, to the stan-
   dard output.

   The following option is available:

   -n  Do not print the trailing newline character. This may also be
      achieved by appending `\c' to the end of the string, as is done by
      iBCS2 compatible systems. Note that this option as well as the
      effect of `\c' are implementation-defined in IEEE Std 1003.1-2001
      (``POSIX.1'') as amended by Cor. 1-2002. Applications aiming for
      maximum portability are strongly encouraged to use printf(1) to
      suppress the newline character.
:                                                                             

On the last line of Listing 1.3, note the presence of a colon :, which indicates that there is more information below. The details of this last line are also system-dependent, but on any system you should be able to access subsequent information one line at a time by pressing the down arrow key, or one page at a time by pressing the spacebar. To exit the man page, press “q” (for “quit”). (This interface to the man pages is the same as for the less program, which we’ll learn about in Section 3.3.)

Figure 1.10: Applying man to man.

Because man itself is a command, we can apply man to man (Figure 1.10),⁸ as shown in Listing 1.4.

$ man man
man(1)                                 man(1)

NAME
    man - format and display the on-line manual pages

SYNOPSIS
    man [-acdfFhkKtwW] [--path] [-m system] [-p string] [-C config_file]
    [-M pathlist] [-P pager] [-B browser] [-H htmlpager] [-S section_list]
    [section] name ...

DESCRIPTION
    man formats and displays the on-line manual pages. If you specify sec-
    tion, man only looks in that section of the manual. name is normally
    the name of the manual page, which is typically the name of a command,
    function, or file. However, if name contains a slash (/) then man
    interprets it as a file specification, so that you can do man ./foo.5
    or even man /cd/foo/bar.1.gz.

    See below for a description of where man looks for the manual page
    files.

OPTIONS
    -C config_file
:

We can see from Listing 1.4 that the synopsis of man looks something like this:

man [-acdfFhkKtwW] [--path] [-m system] [-p string] ...

This is what I meant above when I described man pages as “often cryptic”. Indeed, in many cases I find the details of man pages to be almost impossible to understand, but being able to scan over the man page to get a high-level overview of a command is a valuable skill, one well worth acquiring. To get used to reading man pages, I recommend running man <command name> when encountering a new command. Even if the details aren’t entirely clear, reading the man pages will help develop the valuable skill of technical sophistication (Box 1.4).

1.5 Editing the line

Command lines include several features to make it easy to repeat previous commands, possibly in edited form. These and many other command-line features often involve special keys on the keyboard, so for reference Table 1.1 shows these symbols for the various keys on a typical Macintosh keyboard. Apply your technical sophistication (Box 1.4) if your keyboard differs.

One of the most useful ways to edit the line is to “up arrow” ↑, which simply retrieves the previous command. Pressing up arrow again moves further up the list of commands, while “down arrow” ↓ goes back toward the bottom.

Other common ways to edit the line use the control key, which (as we saw in Box 1.3) is usually written as Ctrl or ⌃. For example, when typing a new command, or dealing with a previous command, it is often convenient to be able to move quickly within the line. Suppose we typed

$ goodbye

only to realize that we wanted to put echo in front of it. We could use the left arrow key ← to get to the beginning of the line, but it’s easier to type ⌃A, which takes us there immediately. Similarly, ⌃E moves to the end of the line.⁹ Finally, ⌃U clears to the beginning of the line and lets us start over.

The combination of ⌃A, ⌃E, and ⌃U will work on most systems, but they don’t do you much good if you’re editing a longer line, such as this one containing the first line of Sonnet 1 by William Shakespeare (Listing 1.7).

$ echo "From fairest creatures we desire increase,"

Suppose we wanted to change “From” to “FRom” to more closely match the text from the original sonnet (Figure 1.11).¹⁰ We could type ⌃A followed by the right arrow key a few times, but on some systems it’s possible to move directly to the desired spot by combining the keyboard and mouse via Option-click. That is, you can hold down the Option key on your keyboard (if it exists),¹¹ and then click with the mouse pointer on the place in the command where you want the cursor. This would let us move right to the “o” in “From”, allowing us to delete the “r” and yielding Listing 1.8 directly.

Figure 1.11: The original appearance of Shakespeare’s first sonnet.

$ echo "FRom fairest creatures we desire increase,"

I usually move around the command line with a combination of ⌃A, ⌃E, and right & left arrow keys, but for longer commands Option-click can be a big help. (I also frequently change my mind about the exact command I’m typing, in which case I usually find that hitting ⌃U and starting over again is the fastest way to proceed.)

1.6 Cleaning up

When using the command line, sometimes it’s convenient to be able to clean up by clearing the screen, which we can do with clear:

$ clear

A keyboard shortcut for this is ⌃L.

Similarly, when we are done with a terminal window (or tab) and are ready to exit, we can use the exit command:

$ exit

A keyboard shortcut for this is ⌃D.

1.7 Summary

Important commands from this chapter are summarized in Table 1.2.