Series E · Lineage · Start At Square One

From Holes To High Language

Compilers & Machine Language · The Ladder Of Translators

Every layer of programming is a translator that lets a human speak one step further from the machine — while the machine, underneath, still only ever executes binary. This is the lineage of that climb: from holes punched in cards to languages that read almost like thought, each rung a translator standing on the one below. Start at square one.

holes → machine code → assembly → compiler → interpreter / JIT

§1 The Floor · instructions as physical things

1804
Joseph Marie Jacquard
The Jacquard Loom
Punched cards control which threads lift — the weave is encoded as holes. The first time instructions lived on a physical medium a machine could read in sequence. Not yet computing, but the seed: a program is a pattern a machine follows.
rung 0 · instructions as holes
1843
Ada Lovelace
Note G — the first program
For Babbage's (unbuilt) Analytical Engine, Lovelace wrote a step-by-step method to compute Bernoulli numbers — the first published algorithm intended for a machine. She also saw furthest: that such an engine might manipulate not just numbers but symbols. The first programmer, before the first computer.
rung 0 · the first algorithm

§2 The Idea Of Computation

1936
Alan Turing
On Computable Numbers — the Turing Machine
Defines what computation is: a machine reading and writing symbols on a tape by simple rules. Establishes the floor and the ceiling — what any machine can and cannot, in principle, compute. Every layer above is built on this definition.
the definition
1945
John von Neumann
First Draft of a Report on the EDVAC
The stored-program architecture: program and data share the same memory. The consequence is enormous and is the root of everything since — code becomes data you can manipulate, which is exactly what makes a compiler (a program that reads and writes programs) possible.
code becomes data

§3 The Climb · each rung a translator

1940s
The machine-code era
Machine Language — raw binary
The floor of the climb. 1s and 0s — opcodes the CPU executes directly, entered by switches or cards. No translation: this is the machine's language. Powerful, total, and almost impossible for a human to write or read at length.
rung 1 · machine code (binary)
1947
Kathleen Booth (early assemblers)
Assembly Language
The first symbolic layer: mnemonics — ADD, MOV, JMP — that map one-to-one onto machine instructions. An assembler translates them to binary. Not yet a compiler (it's a direct 1:1 swap), but the first time a human wrote words instead of numbers.
rung 2 · assembly (1:1 mnemonics)
1952
Grace Hopper
The A-0 System — the first compiler
The pivotal rung. Hopper built the first program that translated symbolic instructions into machine code — and coined the word "compiler." The leap past assembly: one human statement could now become many machine instructions. She fought the then-radical idea that a machine should help write its own programs.
rung 3 · the compiler is born
1957
John Backus & IBM
FORTRAN — the first widely-used high-level compiler
Proved compiled high-level code could rival hand-written assembly in speed — the doubt that had held the field back. FORTRAN opened programming to scientists and engineers who didn't want to think in machine terms. The compiler became practical, not just possible.
rung 3 · high-level, proven
1958–60
John McCarthy · the ALGOL committee
LISP (1958) & ALGOL (1960)
Two foundations. LISP: code is data (von Neumann's insight made into a language), recursion, the ancestor of every functional language. ALGOL: block structure and formal grammar — the syntactic ancestor of nearly every modern language (C, Java, Python all descend from its shape).
rung 4 · the language families fork
1972
Dennis Ritchie
The C Language
A high-level language close enough to the metal to write an operating system in (Unix) yet portable across machines. C became the compiler target and lingua franca beneath almost everything since — most languages are still implemented in, or compile through, C's lineage.
rung 4 · the portable systems language
1970s →
Interpreters · virtual machines · JIT
Bytecode, VMs, Just-In-Time compilation
The two engines fuse. Compile to portable bytecode ahead of time, then interpret or JIT-compile it live at runtime (Java 1995, and the dynamic languages after). The batch translator and the live translator, working together — exactly the compiler/interpreter pair.
rung 5 · compiler + interpreter fused

§4 The Whole Ladder · one picture

distance from the machine ↑

high-level lang
C · LISP · FORTRAN · "almost thought"
furthest
compiler
one statement → many instructions
↑ translates
assembly
ADD, MOV — 1:1 mnemonics
↑ translates
machine code
10110000 01100001 — raw binary
the floor
the machine
transistors · voltage · executes binary only
bedrock
the through-line: every rung is a translator. each lets a human speak one step further from the machine — and the machine still only ever runs the bottom row. the whole tower exists so a person can express a thought and have it fall, layer by layer, into voltage. compiler = translate the whole, ahead of time. interpreter = translate live, line by line.
HOLES (1804) → FIRST PROGRAM (1843) → COMPUTATION DEFINED (1936) → CODE-AS-DATA (1945)
MACHINE CODE → ASSEMBLY (1:1) → THE COMPILER (HOPPER 1952) → FORTRAN → LISP/ALGOL → C → JIT
EVERY RUNG A TRANSLATOR · THE MACHINE STILL RUNS ONLY BINARY · THE TOWER LETS A THOUGHT FALL INTO VOLTAGE
FROM HOLES TO HIGH LANGUAGE · SERIES E · JUNE 2026