The Top Step

Every staircase has a top step. Most people climbing one don't think about that.

I. In the beginning

I studied computer engineering in the early two-thousands. In the first year they taught us to count.

Not like that. In binary. Ones and zeros.

Then they taught us to count in binary again, a different way. And again. This table is four of those ways. Every column writes the same numbers. They disagree about how you write a negative one, and about whether zero gets written twice.

I had to know all four. Not because four is useful. Because the machine underneath you has picked one, and if you're wrong about which, your number is quietly somebody else's number.

That drawing is a calculator. It adds. It subtracts.

I had to design one. Not use one. Draw it — every wire, every gate, and work out what each one does when the voltage on it goes high.

The two numbers you're adding are those voltages, on those wires, written in one of the four spellings from the last picture. And the thing that tells it to add rather than subtract is another row of voltages, down in the corner, called a control word. Add is one pattern. Subtract is a different pattern. You look them up.

Drawing that calculator took me a semester. It adds two numbers.

One step up from those wires, the job looked like this. Each line in the left column moves one number into one spot, or adds two of them, or asks whether one is smaller than another.

The boxes on the right are the spots. There are eight of them. That isn't a simplification for the picture — there were eight.

So the work was getting the number you wanted into the right box, in the right spelling, before the line that needed it. Then doing it again.

I wrote code like this. Not much of it, and not well. Enough to know what it cost.

Nine lines. Two of them just say: use somebody else's work.

Those nine lines get you a hundred numbers, the cosine of every one, and a picture of the answer. I didn't write the cosine. I didn't write the part that draws. I didn't write the part that decides which box each number goes in.

Nobody asked me to. That work was done, and given away, and it sat there waiting under an import line.

Same machine underneath. Same wires. Same eight boxes.

Here is the whole thing, squashed into one picture.

The bottom is the hardware — the wires I just drew. Above it, machine language: the numbers that pick which wires. Above that, assembly, which is names for those numbers. Above that, a language you can almost read out loud, and then the ones I actually learned. Above those, everything somebody else already built and gave away.

Each step up is the same work, said in fewer words. I started at the bottom of this picture. Almost nobody starts there now.

The two on top we will get to.

It's the picture this piece opened with: the same shape, with new words on it.

Where the number goes is the wires and the instruction. Sentences is the language you can almost read. Borrowing is everything somebody else already built.

The two on top are still waiting.

II. The staircase

Three times now, somebody has built a machine that took over a whole step of that staircase.

Start at the bottom, with the oldest one.

There used to be a job where you told the computer where to put a number.

Not what the number was for. Not what to do if the number turned out to be wrong. Just: put this number in that spot. Then put the next one in the next spot. One at a time, in the order the machine would do them, all day.

The job was hard. It took years to get good at. People built whole careers out of it.

The job is gone. A few people still do it, and they're experts now. Fifty years ago it wasn't an expert's job. It was just part of the work.

The job didn't vanish, exactly. The job got small, and it stopped being where anything happens. And nobody misses it.

The thing that took that job away is the thing people are scared of now.

Somebody built a machine that did the number-putting for you. You wrote down what you wanted, in something a lot closer to English. The machine turned your sentence into all the little instructions underneath it.

The machine is called a compiler. The sign is the whole of what a compiler does.

So now one person could do what used to take ten people. You'd think they kept one person and sent nine home. They didn't.

They built ten times as much software. Then they built software for people who could never have paid for any of it before. There are more people making software today than there were back when the numbers had to go in by hand.

And the person who used to place the numbers wasn't sent home either. The person who used to place the numbers got moved up. They spent the next years deciding what the program should do. That's the more interesting job, and they were good at it, because they already knew how the thing worked underneath.

Then it happened again. And again.

The bottom step is the numbers and where to put them.

The step above is sentences. Do this, then do that, and if some other thing is true, do something else instead.

The step above sentences is borrowing. Somebody already built most of what you want, so you take theirs and write the last little bit yourself.

Same machine, one step higher, and a shorter sign.

Each time, somebody builds a machine that handles the step below. The step doesn't disappear. The step gets small and quiet. A few experts go on standing there, and they like it down there, and everyone else climbs up one.

The climb has worked every time so far.

Everybody on the stairs has assumed, without ever saying it out loud, that there's another step above them.

But there isn't. The staircase has a top.

III. Two questions

Every step up is the same thing said in fewer words. A step is the same thing with the boring parts left out for you.

So keep going. Leave out more boring parts. Leave out more. Eventually you run out of boring parts. What's left is the part that was never boring, which is the thing you actually wanted.

What's left is two questions.

What should this do? And: how will I know it did?

You can't shrink those two questions. There's nothing in them to leave out.

The two questions aren't a tiny program. If you want to say everything a program does, you have to write the program. There's no shorter way, and there never will be.

The two questions are something else. The two questions are what you wanted, and how anybody could check.

Those two questions are the top step. The machine being built right now takes over the step just below: you say what you want in ordinary English, and the machine writes the code.

IV. The machine that says no

All the old climbs worked for a reason, and it isn't the reason people think.

A compiler is not smart. That's the good part.

Write something a compiler doesn't understand and the compiler stops. It will not guess. It prints the line you got wrong and then it waits, and the problem is yours now.

A compiler does this every time, for anything unclear, forever. The compiler never gets tired of you. The compiler has never once decided you had probably suffered enough.

That refusal is what makes the step above the numbers safe to stand on. Nothing gets decided quietly. If you were unclear, you find out in about a second. And you find it out from a machine that has no opinion about you at all.

The refusal isn't perfect. There's one famous kind of case where a compiler does guess. The compiler assumes what you probably meant and quietly builds on that. The guessing was left open on purpose, a long time ago, so that programs could run faster. It worked.

Programmers have been arguing about that one case for decades. That's how badly people want a machine to say no.

Now the new machine.

Ask the new machine for something unclear and it doesn't stop. It fills in the part you left out. It picks something reasonable. Then it hands you the whole thing. The part you asked for and the part it made up look exactly the same.

The new machine is trying to help. The new machine is good at helping. It has no way to tell you which parts were the helping.

Nothing prints a line. Nothing waits. The decision still got made. The decision just got made by something that's never going to mention it.

V. It really is a step up

The stairs were never built for the machine. A machine reads English and code with the same ease. Every step was built for the person. Each step let you say what you wanted in words a little more like your own.

The numbers became sentences. The sentences became borrowing. And now you can say the top step out loud in plain English, the way you'd say it to a person. That's the biggest step anybody has taken on these stairs.

Saying the top step out loud is the thing people were climbing toward the whole way up.

The step up is real. It's a step up with the part that says "no" taken out.

So build the part that says no yourself. A test. A check that stops everything the moment it fails. A note somebody wrote before the work started, saying what counts as finished.

You have earned the right to stand one step higher exactly as much as you have written down how you'd find out you were wrong. No check, nothing to stand on. A plan that can't be wrong about anything isn't a plan. It's a wish.

A wish leaves a gap. The gap used to get filled by a person. Somebody on the step below you read your vague instructions and worked out what you actually meant. Then they quietly supplied the part you forgot to say. They did not mention it. Mentioning it would have taken longer than doing it.

That person is getting promoted. Nobody is getting promoted into their place.

Somebody built the compiler, and what they built was a machine that refuses to guess. What's arriving now is a machine that promises to.

You finally get to say what you want in your own words. Nothing will tell you when you were unclear.

Nobody writes assembly anymore. Somebody still has to say what they want.

The same argument for a technical audience, with the footnotes and the sources, is in Nobody Writes Assembly Anymore.

The talk version of this piece, with its slides, is The Top Step on MuffinLabs.