I spend an awful lot of my day in Unix terminals running shell commands. For
some reason, the variance in efficiency between different people when using the shell
is huge: I know people who can run rings around me, and I’ve come across
more than one paid professional who doesn’t use the “up” key to retrieve the
previous command.

I chose that last example very deliberately: most of the commands most of us
run in the shell are highly repetitive. I typically run around 50-100 unique
(i.e. syntactically distinct) shell commands per working day — but
I’ll often run a tiny subset of those commands (e.g. cargo test) hundreds of
time in a single day.

Since many command-line tools have hard-to-remember options, we can save huge
chunks of time – not to mention make fewer errors – if we can search our
shell history to find a previous incantation of a command we want to run. In
this post I’m going to show how, with little effort, searching shell
history can look like this:

Searching shell history

Larger Unix shells such as Bash have long allowed users to search through their
shell history by pressing Ctrl-r and entering a substring. If I (in order)
executed the commands cat /etc/motd then cat /etc/rc.conf, then Ctrl-r
followed by “cat” will first match cat /etc/rc.conf; pressing Ctrl-r again
will cycle backwards for the next match which is cat /etc/motd. I almost
never used this feature, because substring matching is too crude.
For example, I may know the command I want is cat, the leaf
name I’m looking for is motd but I don’t remember the directory: substring
matching can’t help me find what I’m looking for. Instead, I regularly used
grep (with wildcards) to search through my shell’s history file instead.

For me, the game changer was pairing Ctrl-r with
fzf, which brought two changes. First,
matching is “fuzzy”, so I can type “c mo” and cat /etc/motd will be
matched. Second, multiple matches are shown at once. Typing “cat” will show
me several cat commands, allowing me to quickly select the right
incantation (which may not have been the most recent).

It’s difficult for me to overstate how powerful a feature this is. Few things
in life make me as happy as pressing ctrl-R then typing “l1” and having a 100
character command-line execution that runs a complicated debugging tool, with
multiple environment variables set, whose output gets put in /tmp/l1 appear
in my terminal.

Using Ctrl-r and fzf roughly doubled my efficiency in the shell
overnight. Interestingly, it had an even greater long term effect: I became a
more ambitious user of shell commands because I knew I could outsource my
memory to fzf. For example, since it’s now very easy to recall past commands, I
no longer set global environment variables, which had previously caused me
grief when I forgot about them . Now I set environment variables on a
per-command basis, knowing that I can recall them with Ctrl-r and fzf.

For many years my favoured shell was zsh. When I later moved from zsh to fish,
Ctrl-r and fzf was the first thing I configured; and when I moved back to zsh
, and redid my configuration from scratch, Ctrl-r and fzf was again the first
thing I got working (shortly followed by
autosuggestions). If you
take nothing else from this
post than “Ctrl-r and fzf are a significant productivity boon for Unix
users”, then I will have done something useful.

No tool, of course, is perfect. A
couple of months back I somehow stumbled across
skim, an fzf-alike that out-of-the-box
happens to suit me just a little bit better than fzf. The differences
are mostly minor, and you won’t go far wrong with either tool. That said,
I find that skim’s matching more often finds the commands I want quickly,
I prefer skim’s UI, and I find it easier to install skim on
random boxes — small advantages, perhaps, but enough for switching to be
worth it for me.

Doing even better

Finding Skim encouraged me to quickly look around to see what else in this sphere might
improve my productivity. I quickly came across Atuin, which is a much
more sophisticated shell history recording mechanism: the video on its front
page showed a much nicer matching UI than I had previously considered possible.

However, I quickly realised Atuin wasn’t for me or, at least, wasn’t easily for
me. These days I regularly ssh into many different servers: over time I’ve
streamlined my shell configuration to a single .zshrc file that I can scp
over to a new machine and which instantly makes me productive. Atuin – and
this isn’t a criticism, because it’s a more powerful tool – is more difficult
to install and setup (I’m also not sure the ‘fuzzy’
aspects of Atuin quite match the heights of fzf/skim). That said, some readers may find
it a useful tool to investigate.

However, what I immediately realised from the Atuin video is that I would like
my fuzzy matcher to show me more useful information about the commands it’s
matching.

In particular, fzf and skim both default to showing me a (to me!) meaningless
integer before my matched command: this had always slightly bothered me, but
I’d never thought to work out what it meant. For example, if I use
zsh + fzf + Ctrl-r I see:

What does 5408 mean and why is it taking up valuable screen space?