Spotlight: CLI Productivity

You can achieve peak productivity with nothing but the command line and your web browser. I will describe my minimal, focused, keyboard-centric workflow where I do my best work.

Motivation

The purpose of this article isn’t to persuade you to radically overhaul your development workflow overnight, nor is it a critique of “mainstream” editors and IDEs. My aim is to share my perspective and introduce you to the tools that have worked well for me.

In my view, there are two distinct areas of technical productivity:

On one side, you have foundational tools like Git and GitHub—vital systems that revolutionize how you manage projects. They’re your safety net when things go wrong and should be part of every developer’s toolkit. However, they aren’t the focus of this article.

On the other side, there are tools designed to genuinely accelerate your coding process and task completion. That’s what I’ll be highlighting today.

Multiplexing

When you dedicate a lot of time in your terminal, it quickly becomes apparent how cumbersome it can get. In a web browser, you can create new tabs and swiftly ALT-TAB between them. You can bookmark and return to your workspace at will. There’s a parallel here—you can open multiple terminal windows, and that works… sort of. But you still have to reopen everything with each new terminal instance.

I found something much better. It does exactly what I want. It’s called TMUX.

A terminal multiplexer is a program that transparently “sits between” your active terminal connection and K spawned terminal sessions. With TMUX, you can start a session, open new windows, and hotkey between them. You can detach and reattach to sessions at will. In other words, you can set a session aside and return to it later, and everything will be exactly how you left it. With a plugin, these sessions can even persist across system restarts.

TMUX is incredibly useful, and if you plan on doing any serious work in the terminal, it will save you a huge amount of time. Go ahead and install it.

pacman -S tmux # Arch Linux
apt install tmux # Debian or Ubuntu
dnf install tmux # Fedora
yum install tmux # RHEL or CentOS
brew install tmux # macOS (using Homebrew)
port install tmux # macOS (using MacPorts)
zypper install tmux # openSUSE

You can create a new session with tmux new -s session_name, detach with CTRL-B D, and reattach with tmux attach -t session_name.

Some other useful commands include:

tmux ls # list sessions
tmux kill-session -t session_name # kill a session
tmux kill-server # kill the server
tmux a -t session_name # attach to a session
tmux a # attach to the last session

Customization

When you start TMUX, the program looks for a .dotfile¹ at ~/.tmux.conf. This plain-text file is where you can configure and “rice out”² your multiplexer. You’ll begin by adding a plugin manager, tpm, and then use it to load a few plugins and a nice theme³.

Vim As Your Editor

I’ve been using Vim for about two years. When we mention Vim, it’s usually in one of two contexts: vim (the program), or Vim Motions.

Vim Motions are the keybindings that allow you to move around the text. They are the most important part of Vim. Everyone should use Vim Motions. They are extremely efficient. They’re available on all text editors and IDEs.

Vim, by contrast, is a highly configurable, extensible text editor built to make creating and changing any kind of text very efficient.

Vim Motions

There is only one type of grammar in Vim: the grammar of Vim Motions. It’s a language that allows you to move around the text.

Here’s a quick reference of some common Vim Motions:

More generally, the syntax looks like: [count] + operator + motion. For example, 3dw would delete three words. 2yy would yank two lines. c$ would delete to the end of the line and start insert mode. dap would delete a paragraph.

Notice how, for some, the phonetic sound of the command matches the action. d for delete, y for yank, c for change. This is a mnemonic device to help you remember the commands. Delete a paragraph? dap. Change a word? caw.

Vim (The Program)

Vim, by contrast, is a highly configurable, extensible text editor in your terminal built to make creating and changing any kind of text very efficient.

My friend Lucas rather aptly put:

“Vim is the bliss of Ctrl C/V but applied to every facet of the editor.”

I think that’s a really good way to describe it. Vim recognizes and eliminates the vast majority of typing inefficiencies. The result is blazingly fast precision, and a workflow that feels like a dance.

A contention I often receive is, “well, how do I debug in Vim?” You don’t. You have separate programs⁴. Each program is good at what it does. If you build a hodgepodge of functionality you end up with an IDE and that’s precisely what I’m trying to escape.

I will concede, however, that Vim is not beginner friendly. There’s a learning curve. However, Vim is exceptionally user friendly⁵. Once you get the hang of things, and it clicks, it’s really, really fun to use.

A lot of people recommend learning Vim Motions on your current editor first before switching to Vim full time. I didn’t do this, but it’s the path most people take. I’m a bit weird. I like to cold turkey and learn things from the ground up right away. But that’s a digression.

Neovim

Vim’s extensibility takes it to the next level. Enter: Neovim. Taken from the Neovim Charter:

Neovim is a refactor, and sometimes redactor, in the tradition of Vim. It is not a rewrite but a continuation and extension of Vim. Many clones and derivatives exist, some very clever—but none are Vim. Neovim is built for users who want the good parts of Vim, and more.

Neovim’s component-like plugin structure allows you to drop in and take out functionality easily. You can bring in an LSP, completions, snippets, git, and testing infrastructure. You can get new things too: Treesitter, Telescope FZF (fuzzy finding), Scoped grep string searches, and Harpoon anchor points to jump around.

What’s more, since YOU configure Neovim, you’ll come away with a complete understanding of how each tool works, and how they interact with one another to create a complete ecosystem. By contrast, other editors and IDEs abstract this away.

I know I just said a lot of words. The takeaway is this: With Neovim, you know exactly why everything works the way it does, and you can make it work exactly the way you want it to. The possibilities are, in fact, endless.

Want functionality but there’s no plugin for it? Your config is in Lua and everything in Lua is easy. Make it, maintain it, push it to the Neovim community! The Neovim community is vibrant and full of passionate creators and maintainers who work hard to support the editor they love.

Wrapping up

In exploring the minimalist, keyboard-centric workflow of command line tools and editors like Vim and Neovim, we uncover a significant truth about productivity in software development: simplicity and customization can profoundly enhance efficiency. By adopting tools such as Tmux and Vim, developers are equipped to create a highly personalized development environment. This environment not only streamlines tasks but also keeps the focus on coding, reducing distractions inherent in more complex IDEs. Embracing these tools may involve a learning curve, but the long-term gains in speed, understanding, and adaptability make this investment worthwhile.

For those willing to explore these command line utilities and text editors, the payoff is a more intuitive and efficient coding experience that aligns perfectly with the unique needs of each developer.

And as always, remember:

Life is like Vim: There are a lot of shortcuts and you should take them.