Process Section 1: Shell commands

In today’s section, we'll investigate the behavior of a shell to kick off the process control unit and problem set 5.

College students are required to attend section live. TFs will record your attendance. For more on the attendance policy and what to do if you miss section refer to the syllabus here and here.

Extension students are welcome to attend section live (in-person or zoom) or watch the recording (Canvas > DCE Class Recordings). Both methods count towards your participation grade. If you attend a live section, TFs will record your attendance. If you watch the recording, fill out this reflection form.

Building intuition

The pset in this unit introduces a bunch of process control system calls through the medium of a shell implementation. A shell is a program responsible for running other programs; it’s the kind of program behind the command line terminal. You've been using a shell since you first started programming, probably mostly to compile and run your programs. But there are so many useful (and fun) things that you can accomplish using a command line that strings one or more shell commands together.

Common operators used to build command lines are:

• command list seperators ; (to run preceding command the foreground) and & (to run preceding command in the background)
• conditional operators (cmd1 && cmd2) and (cmd1 || cmd2). Each of these operators runs two commands, but the second command is run conditionally, based on the status of the first command.
  • with &&, cmd2 runs ONLY if the cmd1 exits with status zero.
  • with ||, cmd2 runs ONLY if the cmd1 (1) DOES NOT exit, or (2) exits with status nonzero.
• the pipe operator cmd1 | cmd2 runs two commands, connecting the standard output of cmd1 to the standard input of cmd2. These commands run in parallel.
• redirection operators, where some of a command’s file descriptors are sent to disk files.
  • < filename: The command’s standard input is taken from filename
  • > filename: The command’s standard output is sent to filename
  • 2> filename: The command’s standard error is sent to filename

Here are some commonly-installed, commonly-used programs that you can call directly from the shell. Documentation for these programs can be accessed via the man page, e.g. man cat, or often also through a help switch, e.g. cat --help.

Shell Program	Description
cat	Write named files (or standard input) to standard output.
wc	Count lines, words, and characters in named files (or standard input).
head -n N	Print first N lines of standard input.
head -c N	Print first N characters of standard input.
tail -n N	Print last N lines of standard input.
echo ARG1 ARG2...	Print arguments to standard output.
printf FORMAT ARG...	Print arguments with printf-style formatting.
true	Silently succeed (exit with status 0).
false	Silently fail (exit with status 1).
yes	Print y (or any arguments) forever.
sort	Sort lines in input.
uniq	Drop duplicate lines in input (or print only duplicate lines).
tr	Change characters; e.g., tr a-z A-Z makes all letters uppercase.
ps	List processes.
curl URL	Download URL and write result to standard output.
sleep N	Pause for N seconds, then exit with status 0.
cut	Cut selected portions of each line of a file.
grep PATTERN	Print lines in named files (or standard input) that match a regular expression PATTERN.
tac	Write lines in named files (or standard input) in reverse order to standard output.
exit [STATUS]	Exit the shell with status STATUS (default 0).
sh -c "COMMANDLINE"	Run another shell executing "COMMANDLINE".

Build some intuition for shell commands and operators with the following exercises. There is often more than one correct answer!

EXERCISE. Write a command line that compiles program P (using make) and runs it only if the compilation succeeded.

make P && ./P

EXERCISE. Augment your last answer to redirect standard output and standard error to seperate files.

make P && ./P > out.txt 2> err.txt

EXERCISE. Write a command line that lists all .cc files in the pset4 directory.

ls *.cc if you're already in the pset4 directory. If you're one directory higher, and in Docker, it might be ls pset4/*.cc.

EXERCISE. Write a command line that finds all .cc files in the pset4 directory that contain the string io61_seek. Assume the shell is in the pset4 directory (meaning pwd would return /home/cs61-user/cs61-psets/pset4).

grep io61_seek *.cc

EXERCISE. Write a command line to download the contents of this webpage and then display the first ten lines in the terminal.

curl https://cs61.seas.harvard.edu/site/2025/ProcessSection1/ | head -10

EXERCISE. Write a command line that tells you how many commits Eddie Kohler has made to a git repostory.

git log | grep "Eddie Kohler" | wc -l

EXERCISE. Write a command line that tells you how many lines have been added to a git repository since the last commit.

git diff | grep '^\+.*' | wc -l

EXERCISE. Write a command line that prints 'not ready for grading' if a student has not written their name in their AUTHORS.md, but otherwise doesn't print anything else. Hint: the handout AUTHORS.md file uses the placeholder (Your name.).

grep "(Your name.)" AUTHORS.md > /dev/null && echo 'not ready for grading'

Command line breakdown

Now we'll formalize how complex command lines are built.

• A command line consists of
  • Zero or more conditionals, each of which comprises
    • One or more pipelines, each of which comprises
      • One or more commands.

A command is a basic request to execute a program with some arguments. echo foo, for example, is a command. Pipelines, conditionals, and command lines combine commands to build more complex behaviors.

A precise way to explain command lines is with a BNF grammar. Here’s the shell grammar:

command_line ::= (empty)
          |  conditional
          |  conditional ";" command_line
          |  conditional "&" command_line

conditional ::=  pipeline
          |   conditional "&&" pipeline
          |   conditional "||" pipeline

pipeline ::=  command
          |   pipeline "|" command

command  ::=  word
          |   redirection
          |   command word
          |   command redirection

redirection  ::=  redirectionop filename
redirectionop  ::=  "<"  |  ">"  |  "2>"

The grammar says, for instance, that a command_line is zero or more conditionals, separated (and optionally terminated) by ; or &. It also defines conditionals in terms of pipelines, and pipelines in terms of commands.

EXERCISE. Test your understanding of the command line grammar. What are the conditionals in the following command line?

echo foo & echo bar | grep b && echo hello, there ; echo done < /dev/null

(It might be helpful to underline them.)

1. echo foo (terminated by &)
2. echo bar | grep b && echo hello, there (terminated by ;)
3. echo done < /dev/null (terminated by the end of the command line)

EXERCISE. What are the pipelines in that command line?

1. echo foo
2. echo bar | grep b
3. echo hello, there
4. echo done < /dev/null

EXERCISE. What are the commands in that command line?

1. echo foo
2. echo bar
3. grep b
4. echo hello, there
5. echo done < /dev/null

EXERCISE. What are the redirections in that command line, if any?

There’s only one: < /dev/null

EXERCISE. Can any pipeline span across more than one conditional? Why or why not?

No, this is impossible. The grammar shows that every pipeline that’s part of a valid command line is part of exactly one conditional.

EXERCISE. Talk through the structure of the parser in phase 2 of the pset, and how it processes the command line from these exercises.

Command line scientists

In order to fully implement your shell you will need to completely understand the behavior of each shell operator. It’s possible to learn a lot by constructing “experiments”, namely command lines, and observing their behavior on a real shell!

For example, the behaviors of the && and || conditional operators can be explored with different combinations of programs like false, true, and echo.

# Hypothesis: `A && B` runs `B` iff `A` exits with status 0.
$ true && echo X
X
$ false && echo X
$ sh -c "exit 2" && echo X
# Hypothesis not falsified!


# Hypothesis: `A || B` runs `B` iff `A` does not exit with status 0.
$ true || echo X
$ false || echo X
X
$ sh -c "exit 2" || echo X
X
# Hypothesis not falsified!


# Hypothesis: The `sleep` command exits with status 1.
$ sleep 10 && echo Done
[10 seconds go by, then:] Done
# Hypothesis falsified 😢: it looks like `sleep` exits with status 0.

Indeed, it is true that A && B executes B only when A exits with status 0, and A || B executes B only when A does not exit with status 0!

In these exercises, you’ll attempt to explore more complex shell properties.

EXERCISE. Design command lines that test whether commands that are part of a single conditional are grouped left to right. That is, try and determine whether, given the chain A || B && C, commands are left associative:

1. A || B runs first.
   1. So A runs first.
   2. Then, depending on A’s status, B runs or is skipped.
2. Then, depending on A || B’s status, C runs or is skipped.

Or right associative:

1. A runs first.
2. Then, depending on A’s status, B && C runs or is skipped.

Or something entirely different.

To investigate this question and distinguish different groupings, we need long chains—more than 2 processes—and mixtures of && and ||. (If all the operators are the same, grouping won’t make any difference.) For instance, consider false && true || echo t1. If grouped left to right, as in ( false && true ) || echo t1, this would print t1: the exit status of false && true is 1—the same as false alone—and false || echo t1 prints t1. But grouped right to left, this would not print t1: false && ( true || echo t1 ) doesn’t execute the right-hand grouping.

$ false && true || echo t1
t1
$ true && true || echo t2
$ true && false || echo t3
t3
$ true || true && echo t4
t4
$ true || false && echo t5
t5
$ false || true && echo t6
t6

The above results can be explained by reasoning from left to right. If conditional chains were executed in some other way we would expect different results.

EXERCISE. Design command lines that test whether two-process pipelines, such as A | B, execute A and B concurrently (at the same time) or serially (B does not start until A has completed).

# If the right-hand command started after the left-hand command finished,
# then `foo` would never appear. It appears immediately.
$ yes | echo foo
foo

# If the left-hand command started after the right-hand command finished,
# then the error message would appear after 10 seconds (but it appears immediately).
$ cat /tmp/nonexistentfile | sleep 10
cat: /tmp/nonexistentfile: No such file or directory

EXERCISE. Design command lines that test whether the exit status of a conditional equals the exit status of the last-executed command in that conditional.

Hint. The $? shell variable equals the exit status of the most-recently-executed foreground conditional. For instance:

$ true
$ echo $?
0
$ false
$ echo $?
1
$ sh -c "exit 2"
$ echo $?
2

$ true && false
$ echo $?
1
$ true && sh -c "exit 2"
$ echo $?
2
$ sh -c "exit 3" && true
$ echo $?
3

EXERCISE. Design command lines that test whether the exit status of a pipeline equals the exit status of its rightmost command. (Try to avoid using $?.)

Conditionals can broadly test a command’s exit status (in the sense of “zero or not”).

$ false | false | false | false | true && echo foo
foo
$ false | false | true || echo foo
$ true | true | false && echo foo
$ true | true | false || echo foo
foo