Shell Productivity: History, Job Control & Power Tricks

There's a visible difference between someone who knows Linux and someone who's fast at it, and it isn't knowledge of more commands — it's that the fast one almost never types a full command twice, never loses work to a dropped SSH session, and never sits idle watching a slow job. This lesson is that layer: not new capabilities, but the control habits that multiply everything you already know. Each section is one habit; each habit pays daily for the rest of your career.

Watch someone fast in a shell and you'll notice they barely type full commands — they retrieve them. The shell records everything you run (the history builtin shows it, ~/.bash_history stores it), and the retrieval tool is reverse incremental search:

Press Ctrl+r and start typing any fragment of the command you're hunting — the newest match appears as you type. Press Ctrl+r again to step to older matches. Enter runs the found command, → / Esc puts it on the line to edit first, Ctrl+g bails out.

It's called reverse (newest→oldest) incremental (matches update per keystroke) search — you'll see (reverse-i-search) as the prompt.

Ctrl+r is only as good as the history behind it, and bash's defaults work against you. The list is short (often 500 or 1000 commands), it records every duplicate ls you type, it stamps nothing with a time, and, worst of all, each shell overwrites ~/.bash_history when it exits: with two terminals open, whichever closes last wipes out the other's commands.

Five lines in ~/.bashrc (or a drop-in it sources) fix all of it:

`

HISTSIZE=10000 # commands kept in memory for this shell

HISTFILESIZE=20000 # lines kept in ~/.bash_history on disk

HISTCONTROL=ignoreboth:erasedups # skip duplicates and space-prefixed commands

shopt -s histappend # append to the file on exit, never overwrite it

HISTTIMEFORMAT='%F %T ' # history shows when each command ran

`

ignoreboth is shorthand for ignorespace (a command typed with a leading space is never saved, handy for one that carries a secret) plus ignoredups (don't save a repeat of the previous line); erasedups also removes older copies. `shopt` is bash's switchboard for its on/off options: shopt -s NAME sets one, shopt -u NAME unsets it, and a bare shopt NAME reports its state.

Three tiny idioms cover most repetition:

• !! — the entire previous command. Classic: you forgot privileges, so sudo !!.
• !$ — the last argument of the previous command. mkdir -p /srv/app/releases/v2 then cd !$.
• Alt+. — inserts the previous command's last argument onto your line, visibly, before you run anything; press it again to walk back through older commands' last arguments.

A lot of typing goes into cd with long paths. Three tools cut it down:

• `cd -` jumps back to the previous directory (and prints it). Run it again to toggle between two places.
• `CDPATH` is a search path for cd, the way PATH is for commands. With CDPATH=.:/srv/shop, typing cd api from anywhere lands in /srv/shop/api if there is no ./api here. Keep . first so a local directory still wins, set it in ~/.bashrc, and don't export it: scripts that cd would start resolving names through it too.
• The directory stack is a working set of directories. `pushd DIR` changes to DIR and pushes it onto the stack; `dirs -v` lists the stack, numbered, with entry 0 being where you are now; `popd` removes the top entry and drops you back into the one beneath it. Think of it as cd with a memory you can walk back through.

Brace expansion manufactures strings before the command runs:

`

mkdir -p app/{src,tests,docs} # three directories, one command

cp nginx.conf{,.bak} # expands to: cp nginx.conf nginx.conf.bak

touch log-{01..05}.txt # sequences: log-01.txt … log-05.txt

echo {a..e}{1..3} # cross-product: a1 a2 a3 b1 …

`

The {,.bak} backup idiom is the one you'll use weekly: an empty first alternative plus a suffix means 'the file, and the file with .bak stapled on'.

Sometimes a command wants a small file's worth of input and creating one is overkill. A here document supplies multi-line stdin inline, between <<MARKER and a line containing only MARKER (conventionally EOF):

`

cat > /etc/motd <<EOF

Welcome to the build box.

Deploys are announced in #ops.

EOF

`

Quoting the marker changes everything: <<EOF lets the shell expand $variables inside the block; <<'EOF' (quoted) passes the text verbatim — essential when the content itself contains $ you want kept, like a script you're writing to disk. A <<-EOF variant additionally strips leading tabs so the block can be indented inside scripts.

Your one terminal can run many things:

• command & — start in the background; you get the prompt back immediately.
• Ctrl+z — suspend (pause) the foreground job and return to the prompt.
• jobs — list this shell's jobs with their numbers.
• bg %1 — resume job 1 in the background (Ctrl+z then bg = 'keep going, but give me my prompt').
• fg %1 — bring it back to the foreground (to watch it, or Ctrl+c it).

The rhythm to internalize: started something long in the foreground by mistake? Ctrl+z, then bg. Same effect as if you'd remembered the &.

A job number like %1 only means something inside the shell that started the job. To manage it from a script or another terminal you need its PID, and the shell hands it to you: right after command &, the special variable `$!` holds the PID of the job you just backgrounded. Save it (echo $! > app.pid) and anything can later check it with kill -0 "$(cat app.pid)" or stop it with kill. If you didn't save it, `pgrep -f PATTERN` finds it again by matching the full command line, which is what you want for scripts, whose process name may just be the interpreter.

tee duplicates a stream: whatever flows in goes to the screen and into a file — named after the T-shaped pipe fitting.

`

./deploy.sh 2>&1 | tee deploy.log # watch it live, keep the transcript

grep ERROR app.log | tee errors.txt | wc -l # save the middle of a pipeline

echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf # the sudo-write idiom

`

That last one matters: sudo echo x >> file does NOT work (the shell doing the >> isn't root — sudo only elevated echo). Piping into sudo tee -a puts the elevated process on the writing end. -a appends instead of overwriting.

watch re-runs a command every 2 seconds (-n to change) and repaints the screen — a live dashboard from any one-liner: watch -n1 'ss -tlnp', watch df -h. -d highlights what changed between runs.

SSH from a laptop, start a 3-hour migration, close the lid — dead session, dead migration. A terminal multiplexer breaks that link: the session runs on the server, and your terminal is just a window into it.

tmux (the modern default):

`

tmux new -s migrate # named session

# … start the long job …

# Ctrl+b d # detach — job keeps running server-side

tmux ls # later, even from a different machine:

tmux attach -t migrate # right where you left it

`

screen (predecessor, still on older boxes): screen -S name, detach with Ctrl+a d, resume with screen -r name. Same idea, Ctrl+a instead of Ctrl+b.

Multiplexers also split panes and juggle windows, but the career-saving feature is exactly this: detach, disconnect, reattach. Any long-running anything on a remote box belongs inside one.

Productivity habits are pure muscle memory — reading about Ctrl+r does nothing; pressing it thirty times does everything. Run this circuit once now, then notice for the rest of the week every time you retype something the circuit would have retrieved.