Unix Power Tools, Third Edition chapter excerpt

Job control gives you the ability to run several commands concurrently. A background job is launched with & at the end of a command line, and you can return to the foreground later with fg. Suspended jobs can be resumed with bg. The shell’s job table, accessible via jobs, shows each job’s status, PID, and command. This feature is essential when you need to run long‑running tasks, like compiling a large codebase, while continuing to use the terminal for other work.

While the shell’s built‑ins are powerful, you can further extend them with aliases and shell functions. An alias simply maps a short string to a longer command; for example, alias ll='ls -alF' lets you type ll instead of the longer form. Shell functions are more flexible: they can accept arguments, use local variables, and perform complex logic. A typical example is a gco function that checks out a Git branch and switches to it in one step.

Editing your command line is another key aspect of the shell’s efficiency. Most shells use a line editor that supports cursor movement, text deletion, and history recall. The default mode in Bash is Emacs‑style, but you can switch to Vi‑style editing by adding set -o vi to your .bashrc. In either mode, pressing Ctrl‑U clears the line, Ctrl‑W deletes the previous word, and Ctrl‑R starts a reverse search of your command history. These shortcuts reduce the friction of interacting with the shell, especially during long or complex sessions.

When you need to refer to a previous command without retyping it, the shell’s history substitution is invaluable. Typing !! repeats the last command; !$ expands to the last argument of the previous command; and ^old^new replaces the first occurrence of old with new in the last command. These tiny notations save time and keep your workflow smooth.

Special characters can break a command if not handled properly. The shell interprets characters like *, ?, and | as metacharacters. To prevent the shell from treating them as such, you can use quoting. Single quotes '…' preserve the literal value of every character inside; double quotes "…" preserve most characters but allow variable expansion. Backslashes \ can also escape individual characters. Proper quoting is crucial when working with filenames that contain spaces, asterisks, or other special symbols.

Wildcards, also called globbing, let you match multiple files with a single pattern. Square brackets [] specify a range of characters, and the asterisk matches any number of characters. For instance, rm [a-c].txt deletes all .txt files whose names start with a, b, or c. Wildcards work only against existing files; they cannot create new ones. To generate multiple files at once, you’ll need brace expansion or other tools, which we’ll discuss in the next section.

In summary, the Unix shell is more than just a way to run programs; it’s a programmable environment that rewards skillful use of shortcuts and constructs. By mastering filename completion, command repetition, substitution, job control, aliases, functions, line editing, history, quoting, and globbing, you can turn a simple terminal into a powerful command center. The next sections will dive deeper into specific techniques that many users overlook, starting with a quick tip for recovering a lost command line.

Reprint Your Command Line with CTRL‑R

Picture this: you’re logged into a remote machine, typing a lengthy command, and suddenly a noisy modem pings in the background, or a colleague sends you a quick message with write. Your cursor is half‑way down the line, and you have to decide whether to wipe the whole line or try to recall what you were writing. Fortunately, the Unix shell includes a built‑in mechanism to re‑display the current line: Ctrl‑R (the “reverse‑print” character). When pressed, the shell redraws the exact contents of your command buffer, allowing you to continue from where you left off.

Not all shells handle this key the same way. In the Bourne shell and its descendants, Ctrl‑R is defined by the termcap entry rprnt and behaves as described. In shells that use the GNU Readline library, such as Bash or Zsh, the same key often initiates an Emacs‑style reverse history search when you’re in normal editing mode. The behavior can differ again if you switch to Vi‑style editing; Ctrl‑R may still invoke the reverse search, but the Ctrl‑L key is the default for reprinting the line in command mode.

For users who prefer Vi‑style editing but still want the convenience of Ctrl‑R in text input mode, a small tweak to the ~/.inputrc file solves the problem. Add the following lines:

After reloading your shell or running bind -f ~/.inputrc, pressing Ctrl‑R in the middle of a line will bring it back to the screen without triggering a reverse search. The redraw-current-line function simply prints the line buffer exactly as it appears in memory.

Why is this feature useful beyond interruption recovery? Consider a scenario where you’re composing a complex command that includes several arguments, pipes, and redirects. If you need to inspect or tweak the line without losing what you’ve already typed, Ctrl‑R gives you a non‑destructive way to review the line. In contrast, Ctrl‑U deletes the entire line from the cursor to the beginning, forcing you to retype the first part.

Another benefit of using Ctrl‑R is that it works in cooked input mode only. Programs that manage their own input, such as vi or less, will not interpret Ctrl‑R as a reprint request; instead, they may treat it as a regular character or an escape sequence. Thus, the reprint shortcut is most effective in shells and terminal sessions where the shell is the active process.

In practice, you’ll often find yourself relying on Ctrl‑R in combination with other editing keys. For example, to quickly edit a large number of words in a line, you can move the cursor with Ctrl‑F (forward) and Ctrl‑B (backward), delete words with Ctrl‑W, or delete to the end of the line with Ctrl‑K. When you need to see the whole line again, hit Ctrl‑R. The combination of these small, keyboard‑centric commands turns the shell into a highly efficient editing environment that requires minimal mouse interaction.

Beyond the immediate command line, Ctrl‑R can also help you debug scripts. When a script fails at a certain point, you can rerun the same command from the history by typing Ctrl‑R, typing the first few letters of the command, and pressing Enter. The shell will recall the exact line you typed earlier, including any arguments you had set. This quick recall saves time that would otherwise be spent re‑typing or searching the history manually.

Many shell users treat Ctrl‑R as a “magic” key that can be invoked with confidence. By incorporating it into your routine, you can reduce frustration when unexpected interruptions happen, preserve the context of your work, and maintain a steady workflow. The next section will build on this foundation, showing how you can expand the power of the shell to create multiple files in a single command.

Wildcard File Creation and the Power of Braces

When you see a command like vi [e-h]file, you might expect the shell to create files named efile through hfile. Instead, the shell treats [e-h]file as a pattern and expands it only against existing filenames. Since those names don’t yet exist, the command simply fails or, in the case of an editor, opens a new file literally named [e-h]file. This behavior stems from the way globbing works: the shell matches patterns against the current filesystem state and passes the list of matches to the command. If the list is empty, the command receives no arguments, and the shell may interpret the literal pattern as a filename.

Wildcards are invaluable for batch operations on existing files, but they’re silent when it comes to creation. To generate multiple files that share a common naming pattern, you need a different technique: brace expansion. Brace expansion allows you to specify a set of alternatives that the shell expands into separate words before executing the command. The syntax is {a,b,c} or {start..end} for numeric or alphabetic ranges. For example, touch a{1..3}.txt creates a1.txt, a2.txt, and a3.txt in one shot.

Brace expansion is performed before other expansions such as tilde, variable, or command substitution. That means the expanded words are treated as literal arguments to the command. Because brace expansion can produce an arbitrary number of words, it’s often combined with utilities like mkdir -p or cp -t to create directories or copy files in bulk.

Consider the scenario where you want to create a series of log files for a test harness: log{01..10}.txt. By running touch log{01..10}.txt, you create ten files with two‑digit numbers. If you need leading zeros, you can embed them inside the braces: touch log{001..010}.txt. The shell will produce log001.txt through log010.txt, preserving the desired numeric ordering.

Brace expansion also supports nested patterns, which let you generate cross‑product combinations. For instance, file{1,2,3}.{txt,pdf} expands to six filenames: file1.txt, file1.pdf, file2.txt, file2.pdf, file3.txt, and file3.pdf. This capability is handy when you need to create a matrix of files covering different categories or formats.

When you’re working with directories, brace expansion can streamline the creation of a nested hierarchy. The -p option of mkdir ensures that intermediate directories are created as needed. For example, mkdir -p project/{src,doc,bin} sets up a fresh project structure in a single command. If you add more levels, mkdir -p src/{lib,include,tests} expands to three subdirectories under src without cluttering your terminal with separate mkdir calls.

It’s worth noting that brace expansion is purely textual. The shell treats the braces as delimiters and replaces the content with all possible expansions, separated by spaces. Consequently, the resulting words are passed to the command just as if you had typed them manually. This behavior means you can combine brace expansion with other features like tilde expansion or environment variables. For example, echo ~/projects/{alpha,beta} will print the absolute paths to the alpha and beta directories inside ~/projects

After you’ve created files using brace expansion, you might want to remove them quickly. Deleting a file that contains special characters like square brackets requires careful quoting. If you accidentally create a file literally named [e-h]file, you can remove it with rm "[e-h]file". The double quotes protect the entire name from being interpreted by the shell’s globbing engine. This quoting principle also applies to filenames with spaces or other metacharacters; enclosing the name in quotes ensures the shell passes the exact string to rm

In practice, brace expansion reduces the amount of typing and the chance of errors when dealing with repetitive filenames. It’s a simple, declarative syntax that can replace loops or external scripts for many common tasks. However, keep in mind that the shell’s limit on the number of words in a command line can be a bottleneck when you try to expand thousands of names at once. In those cases, you might prefer generating a file list with printf or a for loop that processes each item sequentially.