I remember when I first worked on single-board computers I connected the serial port with two flimsy wires. One for sending and one for receiving. I opened the terminal emulator on my PC and was presented with the shell I am intimately familiar with, but on a strange computer. Only then I realized the terminal commanded the power of the computer over these two flimsy wires that run a simple low-bandwidth protocol1. So I typed in emacs and it ran gloriously.
I find the concept of the computer terminal such deceptively simple abstraction. This is a device where the computer sends characters to and receives characters from. Where do the characters go and where do they come from? The computer doesn’t care. This is where it’s concerns end. Maybe that’s where the name terminal comes from.
Before my time and before display technology in general there were teletypes. These machines mechanically punched letters, numbers and punctuation into paper with loud bangs at the terrifying speed of 10 characters per second. Tadadadadada. Thinking about it makes me nostalgic for a time I didn’t know and yet I am concerned about the fan in my PC. Mechanics aside, it’s a relatively simple device. It receives character codes over a serial line and it doesn’t need a buffer as it just slams into paper what it receives. Memory was expensive.
On Linux, the shell and other interactive processes are managed by tty devices modeled after the teletype. It translates some character codes to signals (Ctrl-C, etc) and even has a small buffer inside the kernel with primitive line-editing features that make sense on an actual teletype. Any process attached to a tty device has these features which are the basis for interactive programs. This led to the command line, then the shell, which is a paradigm we use to this day.
The command line is pure text, independent of a medium of presentation. It works on the teletype and a modern terminal emulator. Language is the stable human interface that was nailed down thousands of years before the computer. It works for anything that isn’t inherently graphical.
By contrast graphical applications are bound to an idiosyncratic interface that one day might be deprecated. It may be a little ironic that terminal emulators themselves are bound to those graphical interfaces. But it is also beautiful how these concerns are separated. The command line pushes complexity to the operating system and, granted, some of it to the user. The command line also frees the program to focus on the essential task.
I find it funny that Turing completeness promises arbitrary computation and common business and personal applications are basically glorified databases. None of that is inherently computationally intensive. The volume of data make it so. Early computers had awesome applications in code breaking and calculating ballistic trajectories2. What does that tell us? Writing such programs requires somebody to sit down and think hard. If that is all what computers ever did they might look very different.
Interactive applications are limited by the feeble human’s ability to conceptualize the program and type out the parameters. The bandwidth of the human interface is low compared to the awesome speed of the computer and applications must accommodate that. They stands at the top of a hierarchy that becomes increasingly complex as the program counter moves down to transform layers of data structures. All that apparent complexity intentionally emerges conceptually simple behavior. The computer amplifies human intent albeit in programmed and fixed models and it turns out there are many such applications. They have in common that a few keystrokes enact great change.
Anything that can’t be expressed in few concepts or words is just too hard for casual and interactive use and the command line reflects that. Therefore the command line is short, often the program name and a few parameters. It stands in stark contrast with programming interfaces that define many data structures and subroutines, little programs in their own right.
Graphical applications have advantages on interactivity and discoverability at the cost of complexity. I like how small changes can immediately show results. Especially how spreadsheet software which is made so accessible they essentially trick people into programming. Whereas the command line requires reading and memorization to learn commands the graphical interface lends itself to discover options and experimentation.
The terminal sits somewhere between graphical applications and the command line. It is a device or emulator compatible with the teletype as it renders characters at the end of the line, but it also supports control codes that move the cursor and replace characters on the screen. This allows more sophisticated applications such as vi and less that draw parts of the screen. It relies on the ability of the application to maintain what must be redrawn and all of that is implemented in userspace.
The ability to edit a single line or parts of the screen separates command line and terminal applications, but the line is blurry. Even bash cheats a little and implements it’s own advanced line-editing features over that of the tty. Editing entire documents before the terminal must have been a nightmare. I challenge you to try out ed3 which is an editor without fancy terminal control codes.
I find the terminal a nice abstraction and I wonder if this is an artifact of history or whether it will still be around in a 100 years.
Updated October 27, 2025