Ken Thompson & Dennis Ritchie
In March 1969, Bell Telephone Laboratories withdrew from Multics. The five-year venture with MIT and General Electric had attempted to build a computing utility as pervasive as the power grid. It was an engineering cathedral: hundreds of thousands of lines of PL/I code, hardware protection rings, dynamic linking, and segmented virtual memory. It was also late, slow, and vastly over budget. Bell Labs resolved never again to fund operating system research.
Left without an interactive environment, two researchers at Murray Hill, New Jersey, faced a return to punched cards. Ken Thompson was an engineer of visceral kinetic instinct: a builder who thought in running machinery, lean state, and immediate feedback. Dennis Ritchie was a scholar of language and architecture: trained in physics and applied mathematics at Harvard, reflective, skeptical of dogma, and possessed of exceptional formal taste. Sharing terminals in Room 2C-517, they launched an intellectual counterrevolution.
Their insight was not that Multics had the wrong features, but that systems software suffered from a failure of subtraction. Orthodoxy held that an operating system must anticipate every operational demand, encoding record layouts, access methods, and scheduling policies into the kernel. Thompson and Ritchie proposed the inverse: a kernel should do almost nothing, offering orthogonal primitives so clean that complex behaviors could be assembled in user space.
In the summer of 1969, on a cast-off PDP-7 minicomputer with eight thousand 18-bit words of memory, Thompson wrote the prototype of Unix. He budgeted one week each for a kernel, a shell, an editor, and an assembler. Over the next five years, joined by Ritchie, he transformed this modest experiment into an architecture that restructured computing.
The first radical subtraction was the file.
Mainframes treated files as structured databases, enforcing fixed records, variable records, indexed keys, and hardware-specific blocking factors. Every file format required dedicated system calls, and programs could communicate only if data layouts were pre-negotiated by compilers.
Thompson and Ritchie stripped away all internal structure. In Unix, a file was simply an unformatted sequence of bytes terminated only by its length. The kernel attached no semantic meaning to the contents; interpretation belonged entirely to user programs.
They coupled this byte-stream abstraction to a unified hierarchical namespace. Directories were ordinary files containing filenames paired with numeric pointers to storage metadata called inodes. Peripheral hardware—terminals, printers, tapes, disks—was mapped directly into /dev. A program communicated with a terminal, a file, or a network link through the same four system calls: open(), read(), write(), and close(). The machine's physical topology collapsed into a single, uniform interface.
The second subtraction decoupled process creation from program execution.
Most operating systems provided a monolithic system call to run a program, requiring callers to specify binary location, memory bounds, I/O devices, and privileges in a single, tangled invocation.
Unix broke this operation into two orthogonal primitives: fork() and exec().
The fork() call created an exact duplicate of the running process, cloning its memory space and open file descriptors. The exec() call replaced the process's memory image with a new executable while preserving those inherited file descriptors.
Because duplication and binary loading were decoupled, an unprivileged process could intervene between them. It could close a standard file descriptor and open a file in its place, redirecting input or output before the child binary began executing. Consequently, the Unix shell was not a privileged kernel component, but an ordinary user-space program. Anyone could script it, replace it, or write an entirely new shell without altering a line of kernel code.
The third subtraction was the pipe.
In 1972, prompted by Doug McIlroy, Thompson added the pipe() system call, creating an unbuffered channel connecting the byte stream of one process directly to another. Ritchie introduced the vertical bar (|) syntax to the shell.
This mechanical hinge gave birth to the software tools philosophy. Rather than writing monolithic programs that anticipated every human intent, programmers wrote small utilities that did one thing well, expected unadorned text streams as input, and wrote unadorned text streams as output.
ASCII text became the universal protocol. Programs that had never heard of each other—grep, sort, uniq, awk—could be snapped together like modular fittings to perform analytical computations that no individual utility author had conceived. Computation was reconceived as a series of stream transformations.
To sustain this simplicity across diverse machines, Ritchie invented C.
Early Unix was written in assembly, with utility languages like Thompson's B struggling on byte-addressed hardware. Between 1971 and 1973, Ritchie evolved B into C.
C was neither an abstract mathematical notation nor a CPU-specific dialect. It was a portable structured assembly language. Ritchie gave C primitive types that mapped directly to machine registers and words (char, int, pointers), while introducing the decisive equivalence between array indexing and pointer arithmetic: a[i] was identical to *(a + i). Memory was treated as a linear array of addressable cells.
In 1973, Thompson and Ritchie rewrote the Unix kernel almost entirely in C. Industry dogma held that high-level languages were too bloated and slow for systems programming. By proving that a concise, typed language could compile into code rivaling hand-tuned assembly, they severed operating systems from proprietary silicon. In 1978, porting Unix to the 32-bit Interdata 8/32, they proved that an operating system could move across incompatible processor architectures with minor modifications.
Their architecture was grounded in a ruthless pragmatism later categorized as "Worse is Better." They prioritized simplicity of implementation over completeness of specification. If an edge case threatened to complicate the kernel—such as an I/O system call interrupted by a signal—they did not write elaborate kernel recovery machinery; they returned an error (EINTR) and required the user program to retry.
This bias exacted severe historical costs. C's null-terminated strings and lack of bounds checking became the greatest vector for software vulnerability in computing history. Coarse file permissions and the all-powerful root account created an ambient authority model that plagued security for decades.
Yet their trade-off succeeded where theoretically perfect systems collapsed. By refusing to encumber abstractions with bureaucratic safeguards or domain assumptions, Ken Thompson and Dennis Ritchie produced an environment light enough to run on cheap hardware, transparent enough to be understood by a single mind, and durable enough to outlive its era. Their legacy is not that they built a machine that did everything, but that they possessed the discipline to leave almost everything out.
“You can't trust code that you did not totally create yourself.”
“UNIX is basically a simple operating system, but you have to be a genius to understand the simplicity.”
“C is quirky, flawed, and an enormous success.”
“One of my most productive days was throwing away 1,000 lines of code.”
- The UNIX Time-Sharing System 1974
- The C Programming Language (with Brian Kernighan) 1978
- Reflections on Trusting Trust (Turing Award Lecture) 1984
- Plan 9 from Bell Labs 1995