Chapter 5 · 1957 → now

The trade

Machine time used to cost more than human time. Then the lines crossed, and all of modern software is what happened next.

Here is the deal underneath every piece of software you have ever used: waste the machine’s time to save the human’s.

It did not start that way. In the early 1950s, a computer cost millions and a programmer cost a salary, so the math ran the other direction — human time was the cheap part. Programmers wrote in raw machine code, the computer’s own numbers, and were expected to hand-polish every instruction the way a jeweler cuts stones. The machine’s hours were precious. Yours were not.

John Backus hated it. He was a young IBM programmer — a former medical student who had drifted into computing — and he later said plainly that he was lazy, and that hand-coding was “hand-to-hand combat with the machine.” In 1953 he sent IBM a short memo proposing something most experts considered naive: let programmers write something closer to math — a formula, in something like English — and let the machine translate it into its own instructions. A program to write programs. It took his team three-plus years. In 1957 they shipped it: FORTRAN, the “formula translator,” history’s first widely used compiler.

The old guard called it waste, and by their lights they were right: FORTRAN’s generated code was slower than what a good human could write by hand. The Backus team fought for years to close the gap, and got remarkably close — but the deeper answer to the objection wasn’t engineering. It was economics. Computers were getting cheaper and faster every year, and programmers weren’t. Sometime in the 1960s the cost lines crossed for good: the machine’s hour became cheaper than yours, and it has never crossed back. Once that’s true, burning machine cycles to save human effort isn’t waste. It’s the only rational trade in the room.

So the industry made the trade again. And again. And again. Each round bought programmers more convenience — and this is the part people miss, each round gave something up. Every step hides part of the machine from you, and what it hides doesn’t go away. It just keeps working underneath, invisible, until the day it isn’t.

Climb the ladder below — it’s this chapter’s whole argument, one click per rung. Each rung tells you what it hides from you, what it still makes you carry, and what it costs. Two rungs from the story so far are worth flagging on the way up.

C is the strangest bargain on the ladder: a rung invented as a getaway car. Dennis Ritchie built it — this is chapter 4’s story — so that Unix could escape the one machine it was born on. C hides the instruction set, and hides almost nothing else: memory is still entirely yours to manage, and entirely yours to get wrong. Portability was the prize, and the price was a whole category of bug — buffer overflows, memory corruption — that has kept security teams employed for fifty years. Decades of break-ins live on that one rung.

BASIC is the rung with the open door. At Dartmouth in 1964, a mathematician named John Kemeny — a Hungarian immigrant who had once worked as Einstein’s calculating assistant — and his colleague Thomas Kurtz decided every student, poets included, should be able to write a program. They built a deliberately friendly language and a time-sharing system to run it, so a hundred people at terminals could share one computer and each feel it was theirs. Then — hear the chapter 2 echo — they gave it away. Any school could have BASIC free. Twenty years later it was burned into the chips of nearly every home computer on Earth, which is why a generation’s first program was written in it.

And one rung was built before its time and had to wait. John McCarthy’s Lisp, from 1958, pulled a trick the rest of the industry wouldn’t adopt for decades: garbage collection, the language cleaning up its own memory so the programmer never thinks about it. On 1958 hardware this was scandalously expensive — Lisp spent thirty years as the brilliant language that machines couldn’t comfortably run. Toggle the ladder to its second view and you can see this as a picture: each rung shown at the year it was invented and the year hardware finally made it cheap. Some rungs waited a few years. Lisp and Python waited decades — abstractions born ahead of the curve, sitting on the shelf while the chips caught up.

That’s the engine of this whole era, so it deserves saying plainly: the hardware picked up the check. Every rung of the ladder burns machine efficiency to buy human convenience, and for fifty years the doubling — chapter 3’s curve — quietly paid for every round. Software got slower per instruction and nobody cared, because next year’s machine erased the difference. “Ship it now, the hardware will save you” had a name among engineers: the free lunch.

If you want the whole trade in one before-and-after: the machine the first Unix ran on had about 18 kilobytes of memory — total, for the kernel and every program it ran, roughly this chapter twice over. A blank, do-nothing desktop app built with today’s fashionable tools starts at several hundred megabytes: tens of thousands of times larger, to do nothing at all. And here is the honest part — mostly, that’s fine. It’s fine because the curve paid. Those megabytes bought development speed, safety, and portability, and the hardware absorbed the bill without sending it to you.

The catch — and the reason this book has six more chapters — is what happens if the hardware ever stops paying. Hold that thought. First, climb the ladder. Notice, as you climb, that the years on the rungs refuse to line up in order — a 1958 rung sits near the top, a 1972 rung near the bottom. The ladder sorts by how much of the machine you still hold, not by calendar. And notice the thesis hiding in the coloring: when you stand on any rung, every rung below you is still there, still running, holding you up. C never died. It just moved underneath everything.