Chapter 9 · 1972 / 1998–2014

Slicing the machine

Out of rungs above the language, the industry started abstracting the machine itself. The best idea turned out to be a 1979 footnote, grown up.

Chapter 5 climbed the ladder: every rung hid more of the machine from the programmer. By the late nineties the ladder had run out of comfortable rungs above the language. So the industry did something that sounds like a joke and became the foundation of the modern internet. It started abstracting the machine itself — making one computer pretend to be many.

The idea wasn’t new. It was mainframe-old. In 1972, IBM shipped a system that sliced one giant machine into many virtual machines — pretend computers, each with its own operating system, each convinced it owned the hardware. In the mainframe world this was normal for decades. In the cheap-PC world it was forgotten, because why slice a machine that only cost a few thousand dollars? You just bought another one.

Here’s why: because by the late nineties, companies owned rooms full of PC-descended servers, each running one program at maybe ten percent load, each needing power and cooling and someone to plug it in. The waste was enormous. In 1998, a Stanford professor named Mendel Rosenblum and his co-founders started VMware, having pulled off the trick everyone said the PC’s architecture made impossible: virtual machines on ordinary x86 hardware. Now ten idle servers could collapse into one busy one. Server rooms shrank. And a stranger idea snuck in behind the savings — if a computer is just software, it can be copied, moved, and thrown away like software.

But virtual machines are heavyweight. Each slice carries a whole operating system — booting, updating, eating memory — just to run one program. Which brings back chapter 4’s footnote. Remember chroot, 1979: fence a program into a corner of the filesystem so it sees only its own little world. A testing convenience. For twenty-five years that idea grew quietly in Unix’s descendants — BSD grew it into jails; Google, running more Linux than anyone on earth, taught the kernel to meter and fence groups of processes (work that became cgroups, folded into Linux in the late 2000s, keeping Google’s million machines from stepping on themselves).

Put the fencing and the metering together and you get a different kind of slice. Not a pretend computer with its own OS — just a fenced, metered corner of one shared Linux kernel that a program mistakes for a whole machine. A container. It starts in a blink, weighs almost nothing, and you can run hundreds where a machine held a dozen virtual machines.

For years containers stayed a specialists’ trick, because the plumbing was all there but the faucet was missing. Then in 2013, a French-born founder named Solomon Hykes demoed a tool called Docker at a conference in five minutes, and shipping software changed shape in about eighteen months. Docker’s move wasn’t invention — Hykes said so himself — it was packaging. One command wrapped your program, its libraries, its whole little world into a box that ran identically on your laptop and any server on earth. The industry’s oldest lie, “works on my machine,” became a shipping format.

Click the box below and slice it yourself — whole machine, then virtual machines, then containers. Watch what each slice carries and what it shares.

Now stack the whole tower, because the punchline of this chapter is the stack itself. At the bottom, hardware that chapter 3 made cheap. On it, Linux — chapter 7’s hobby. Sliced by virtualization — a 1972 mainframe idea resurrected. Sliced again into containers — a 1979 Bell Labs footnote, grown up. Every layer of the modern machine is an old idea from this book, wearing new clothes. Practically every container on earth is a slice of Linux; practically every one traces its lineage to two lines in Version 7 Unix that nobody noticed at the time.

One question left: who owns the machines being sliced? Turns out — mostly nobody you know. Next: computing becomes a utility, and Bell’s business model wins from beyond the grave.