"Different interfaces are good at different things"

Nick’s piece on the strange longevity of the command line is such a good read. It makes you feel like this method of computing isn’t strange at all, which of course it’s not. Even now.

It may seem arcane in today’s GUI-dominated world, but it’s funny how much of my work and play is pulling me back toward the command line. The part that made it click for me when I first started digging into this stuff as a kid was the idea that commands are really building blocks, and that it’s our ability to assemble them in our own ways that makes the system so expressive.

It asks more of you up front, but delivers more nuance over time. These days, that’s my jam. What’s old is new again.

Here’s what I highlighted:

Graphical interfaces are excellent when the work is visual or when seeing the available choices is more useful than memorizing instructions.

What is interesting is that the graphical interface did not replace the command line in the same way that graphical word processors replaced most text-mode word processors. The two interfaces settled into different kinds of work.

A graphical interface is usually designed around possible actions. The program presents buttons, menus, windows, and other controls, and the user chooses among them.

The command line works in the opposite direction. The user states what should happen.

That difference can make the command line less approachable because you have to know enough to formulate the instruction. A blank prompt does not offer much guidance. Someone unfamiliar with a system may have no idea what to type, while a graphical application can at least expose its major functions.

A graphical interface tends to optimize for discovery. A command-line interface tends to optimize for expression.

Suppose I have hundreds of log files and want to find every line containing a particular error, extract a portion of each matching line, sort the results, and count how often each result appears. A graphical log viewer might provide exactly the right feature, or it might not. At a shell prompt, existing tools can often be joined together to perform the job without anyone first designing a special interface for it.

The individual tools may be simple. Their usefulness comes from being composable.

The longevity of the command line is closely connected to the longevity of plain text.

A sequence of mouse clicks is usually temporary. Unless the application provides macros or some other automation system, the procedure exists mainly in the user’s memory. A command can be recorded as text. That turns an interaction into something closer to documentation.

Infrastructure increasingly gets described in configuration files. Developers work with source-control systems, build tools, package managers, containers, cloud platforms, and deployment systems that all lend themselves to scripted operation. Even products with elaborate graphical dashboards frequently provide command-line tools because administrators eventually need automation.

Interfaces often try to hide structure from the user. That makes routine tasks easier, but it can also make troubleshooting harder because the abstraction conceals the very information needed to understand the problem.

There is a tendency among some technically experienced users to treat command-line skill as evidence of seriousness, as though using a mouse somehow indicates insufficient dedication to computing. I have never found that attitude particularly useful. Different interfaces are good at different things.

The command line also has real weaknesses. Commands can be cryptic. Options are sometimes inconsistent. Documentation ranges from excellent to incomprehensible. A mistyped command can have consequences far greater than clicking the wrong toolbar button, particularly when working with administrator privileges.

Graphical interfaces tend to make the first few minutes with a program easier. Command-line interfaces often make the next several years more efficient.

That knowledge also accumulates. A small set of familiar commands gradually becomes a larger vocabulary, and those commands can be combined in ways that were not necessarily anticipated by the people who wrote them.