Abstraction: how we stopped writing in 1s and 0s

You just learned to read the machine’s own language: a program is a long list of dumb numbers, each one an instruction the processor fetches, decodes, and runs. Move this. Add that. Compare. Jump. Now try to write a real program that way — by hand, in raw numbers. Want to add two values and show the result? That’s not one number. It’s a careful sequence of them, each in exactly the right slot, with no room for a single mistake. Get one digit wrong and the machine does something else entirely, silently.

People actually did this, in the very early days. It was brutal. The whole history of computing since is one long answer to that pain: building layers so you never have to write in numbers again.

The pain machine code makes

Machine code is what we met in the last two items — the raw instruction numbers the processor runs. It is the only language the hardware truly understands. Everything has to become this in the end.

But it is murder to write. There are no words, only numbers. There are no names for places in memory, only addresses you track yourself. Reorder anything and every address shifts. A program of any size becomes thousands of numbers a human cannot read back, cannot debug, and cannot fix without breaking ten other things.

So someone asked: what if we let the machine do the tedious part?

The first rung: assembly puts names on the numbers

The first step up is assembly. It is the same instructions — exactly the same ones, one for one — but written with short names instead of numbers. Where machine code says a number meaning “add,” assembly says ADD. Where it says a number meaning “jump,” assembly says JMP. You write ADD, MOV, CMP, JMP — readable words — and a small program called an assembler translates each line straight down into its machine-code number.

This is the key move, and it never changes again: a layer is a human-friendlier skin over the layer below, plus a translator that turns one into the other. One assembly line is still one machine instruction. You haven’t gained power yet. You’ve gained sanity — names you can read, and a machine that does the number-juggling for you.

The big rung: a high-level language, where one line means many

Assembly is readable, but it is still one tiny step per line. Adding a list of a hundred numbers is a hundred-plus lines. Tedious.

So we climb again, to a high-level language. Here one line stands for many machine instructions. You write total = a + b. You write if user is logged in:. You write repeat this 100 times. Each of those plain lines is not one instruction — it unfolds into a fistful, sometimes dozens, of machine instructions underneath. A program called a compiler (or an interpreter, which does it line by line as the program runs) does that unfolding for you, automatically, every time.

Now you have real power. You stopped describing the machine’s tiny steps and started describing what you want. The translator works out the steps.

The whole trick has a name: abstraction

Step back and look at what every rung shares. Each layer hides the messy layer below it behind a simpler interface. When you write total = a + b, you are not thinking about which slots in memory hold a and b, or how many instructions the addition takes, or — further down — which switches flip. You trust the layer beneath to handle all of that without watching it.

That hiding is called abstraction, and it is the single central trick of all computing. It is why you can use a phone without knowing any of this. It is why a programmer writing an app almost never thinks about logic gates. Each person works at one rung and trusts the rungs below. The OS, which we meet next, is built the same way; so is the internet; so is everything above. Abstraction all the way down.

One action, seen at five heights

Take a single, ordinary thing: add two numbers and show the result. Watch it at every level.

At the top, the click: you press a button in an app. One action.

Drop one rung to high-level code, and it might be a single line: show(a + b). Still small.

Drop again to assembly, and that one line becomes a handful of named steps — load a into the processor, load b, add them, store the result, call the routine that draws it on screen. Several lines now.

Drop to machine code, and each of those becomes its raw number — a column of bits, dozens of them, in exact order. The handful has multiplied.

Drop to the bottom, to gates and switches (items 4 through 8), and that “add” is the adder you built from logic gates, each gate a few transistors flicking on and off. Thousands of switches, for one press of one button.

Same action. Five heights. Each rung hides the swelling volume beneath it. That swelling is the point: as you climb, one gesture at the top stands for more and more work below — and you get to ignore all of it.

What you gain, and what you give up

This is the bargain that built the modern world. Abstraction lets you build cathedrals without ever quarrying stone. A small team writes an app in plain-ish lines, and miles of machinery underneath turn it into flicking switches.

The cost is distance. Because each layer hides the one below so well, almost no one knows what is actually underneath. The tower works precisely because each layer trusts the layer below without checking it — that trust is what lets you stop looking down. But trust without any understanding is how a person ends up helpless in front of the very tools they depend on. That helplessness is the thing this course exists to undo.

You have just climbed the tower from the bottom — switch, gate, adder, memory, processor, instruction, and now the languages we wrote so we could forget the switches. Almost no one makes that climb. The machine you hold runs because thousands of strangers each trusted one layer and built the next. Below the simple line of code, every rung you just walked is still there, doing its small certain job. And one of those rungs has a hard problem we haven’t touched: all these programs share one real machine. Someone has to decide who gets the processor, the memory, the screen — and that someone is what we meet next.