A journey begun at the bottom (hands, hardware), closed at the very top
This series began its journey at the very bottom (a hand-carved seed, wired-up hardware) and climbed all the way up to Linux. For our last stop, we go to the very top ── the headwaters of the lineage. Just before Unix was born, there stood a giant OS called Multics. In a sense, Unix was born as a reaction against it. This time, by asking "what was Unix a reaction against?", we touch the design philosophy that runs through this whole family, and close the series. That philosophy turns out to be one and the same as the "small seed" idea that kept reappearing as we traced the chicken and egg all the way down.
In 1964, MIT, GE, and Bell Labs joined forces to begin developing the time-sharing OS Multics (Multiplexed Information and Computing Service). The stage was the GE-645. The goal was breathtaking for its time ── hundreds of people using it at once, turning computation into a public utility like electricity or running water. It was also a pioneer in writing an OS in a high-level language, PL/I. A ball of innovation. But ── it was too ambitious for the technology of its day.
Bell Labs gradually grew disillusioned with the size and complexity of Multics and pulled out at the end of the 1960s (Episode 7). The researchers left behind ── Ken Thompson, Dennis Ritchie, Doug McIlroy, Joe Ossanna ── did not want to give up the good parts of time-sharing they had tasted in Multics. So they decided ── let's rebuild that same goodness, but far smaller. On an idle PDP-7 (Episode 7). That was Unix.
Multics and Unix had opposite design philosophies. In the figure below, switch between the two.
• Each program does one thing well.
• For a new job, don't bloat an old program with new features ── build something new.
• Join programs with pipes, and do big jobs by combining small tools (ls | grep | wc). ── Not "one big complete system" but "small parts, and their combinations."
Unix was Multics's cautionary example, but also its teacher. In the words of Episode 1 ── it inherited not a single line of code, but the ideas. The hierarchical file system; the notion of making the shell just a user program (not part of the kernel); and above all, the very experience of "using it interactively via time-sharing." Unix was born inheriting both the ideas of the good parts of Multics and the lessons of its overreach. A reaction is at once a rejection and a deep act of learning.
Unix's "start small, build up by combining" is in fact the very idea we met again and again on this journey ── the small core of intermediate code (Episode 4), the 357-byte seed (Bonus 2), the few hand-carved words (Episode 9). A great tower, built up from a small foundation. The bootstrapping principle was Unix's design philosophy itself. The "small seed" that came into view as we traced the chicken and egg all the way down was the very thing Unix had cherished from the very start. In the figure below, follow that red thread.
(1) Multics was not a "failure." It left behind many innovations ── ring-based security protection, dynamic linking, single-level storage ── and had a large influence on later systems. Even after Bell Labs pulled out in 1969, development continued, and Multics stayed in real operation until 2000. "Too big" is a statement relative to the technology of its time. (2) The bullet list of the "Unix philosophy" is a later distillation by McIlroy and others, and has an idealized side to it. Actual Unix/Linux also bloated considerably over their history.
(3) "Reaction" is a narrative simplification; the continuous influence (inheritance) from Multics to Unix is just as large. (4) There are various accounts of the origin of the name UNICS (Episode 7). ── Including all these caveats, history is not a single straight line, but a weave of influence and rebellion.
At the headwaters of the lineage stood the huge, ambitious Multics (1964, MIT/GE/Bell Labs, GE-645, PL/I, "computation as a public utility"). Bell Labs grew disillusioned with its size and complexity and pulled out, and those who remained ── Thompson, Ritchie, McIlroy, Ossanna ── rebuilt "that same goodness, but far smaller." That was Unix. It was a reaction against Multics right down to the name (UNICS). The philosophy: "each program does one thing well, joined by pipes." But it inherited not Multics's code but its ideas, taking on both the good parts and the lessons (the reimplementation tree of Episode 1).
And this "start small, build up by combining" was exactly what we met again and again as we traced the chicken and egg all the way down ── the small core of intermediate code (Episode 4), the 357-byte seed (Bonus 2), the few hand-carved words (Episode 9). The bootstrapping principle is the Unix design philosophy itself. The journey that began at the bottom (hands, hardware) came back, at the headwaters (the reaction against Multics), to the same single truth ── big things are always built up from a small seed.
Which came first, the chicken or the egg?
── The first egg was carved by hand.
And a small seed became a world.
"A History of UNIX That Clicks" ── 11 main episodes plus 6 bonuses ── is now complete. Thank you for reading to the very end.
gcc, or press the power button on your PC (a boot) ── remember that beyond that button stand, in an unbroken line, the people who carried paper tape, the fingers that flipped the switches, the engineers who wired the gates, and the researchers who decided "let's build it small."
Print / Save as PDF: ⌘+P (Ctrl+P on Windows). On screen, use the buttons in Figure 1 for the Multics/Unix design philosophies, and the slider in Figure 2 to trace the lineage of "smallness." Click "See the answer" to open each solution. All 17 installments ── thank you for your company.