A History of
Compilers

A roughly chronological tour. We trace how compilation grew from a clever bookkeeping trick into a rigorous engineering discipline and, finally, into shared infrastructure — and we name the people who made each leap.

Each milestone below is unpacked later in the deck. Note the rhythm: a burst of theory in the late 1950s and 60s, a wave of tooling in the 70s–80s, and a shift to reusable infrastructure from the 2000s on.

amber = compilers & languages  ·  green = theory/standards  ·  purple = tools/infra  ·  blue = optimisation/runtime

The first stored-program computers (EDSAC 1949, Manchester Baby 1948, EDVAC) were programmed in raw machine code: numeric opcodes and absolute addresses, entered in binary, octal or via teleprinter codes. Every jump target had to be computed by hand, and inserting an instruction renumbered everything after it.

Wheeler, Wilkes & Gill’s 1951 book The Preparation of Programs for an Electronic Digital Computer was the first textbook on programming — and on subroutine libraries.

On the UNIVAC I, Grace Hopper built A-0 (1952) and coined the word “compiler”. Crucially, its original meaning differs from ours: A-0 read a sequence of subroutine call numbers with arguments and compiled — in the librarian’s sense of “gathering together” — the pre-written routines from tape, linking and relocating them into one runnable program.

In Britain, the equivalent term was autocode. These were the first systems to compile genuine algebraic expressions into machine code — pre-dating, and partly inspiring, the more famous American efforts.

# Flavour of an early autocode line (Brooker-style):
   n1 = n2 + n3 x n4        # arithmetic in near-mathematical form
   j1, 3 >= n1              # conditional jump to label 3 if n1 <= 0
# The autocode expands each line into a sequence of machine orders,
# allocating working store and handling the accumulator for you.

The lesson the autocodes taught: programmers would adopt a higher notation only if the translator’s output was efficient enough to be worth it. That bar is exactly what FORTRAN set out to clear.

John Backus’s IBM team shipped FORTRAN for the IBM 704 in 1957. It was not the first compiler, but it was the first widely successful one — and its central challenge was economic: it had to generate code nearly as fast as expert hand-written assembly, or no one would trust it.

C     FORTRAN II — sum 1..N (fixed-form, col 7+)
      SUM = 0.0
      DO 10 I = 1, N
         SUM = SUM + A(I) * B(I)
   10 CONTINUE
      WRITE (6, 20) SUM
   20 FORMAT (1H , F12.4)

FORTRAN’s parser was largely ad hoc. The late 1950s gave compiler writers a formal theory of grammar — and a notation to write languages down precisely.

<expr>   ::= <expr> "+" <term>
           | <term>
<term>   ::= <term> "*" <factor>
           | <factor>
<factor> ::= "(" <expr> ")"
           | <number>

ALGOL 60, defined by an international committee and written up in the famous Revised Report (Naur, ed., 1963), was “a language so far ahead of its time that it was an improvement on its successors” (Hoare). It introduced ideas now universal.

begin
   integer procedure fact(n);
      value n; integer n;
      fact := if n < 2 then 1
              else n * fact(n - 1);

   integer k;
   for k := 1 step 1 until 5 do
      outinteger(1, fact(k))
end

With context-free grammars formalised, the question became: how do you build a parser mechanically and efficiently for any reasonable grammar? A decade of beautiful algorithms answered it.

At Bell Labs in the early 1970s, theory met practice. Dennis Ritchie created C (~1972) to write Unix itself; alongside it grew the generator-based toolchain that made building compilers routine.

No book shaped how compilers are taught more than the “Dragon Book” series — named for its cover, a knight battling a dragon labelled “complexity of compiler design”. It codified the standard phase pipeline a generation learned by heart.

With M languages and N machines, writing every front-end against every back-end means M×N compilers. The recurring dream: insert a common intermediate language so you write only M + N halves. It took 50 years to fully realise.

The single most important structural idea in compiler engineering, stated visually. A shared intermediate representation collapses a quadratic problem into a linear one — the insight UNCOL named and LLVM finally delivered.

Richard Stallman released the GNU C Compiler in 1987 as a cornerstone of the GNU project — a production-quality, retargetable, free compiler. More than any other single program, GCC made open-source operating systems (and later Linux) possible.

Static Single Assignment form — Cytron, Ferrante, Rosen, Wegman & Zadeck (1991) — gave every variable exactly one definition. This makes use-def chains explicit and turns many optimisations into near-trivial graph walks. Almost every serious optimiser since is built on it.

; before SSA — x reassigned
x = 1
if cond:
    x = 2
y = x + 3

; after SSA — each def is unique
x1 = 1
if cond:
    x2 = 2
x3 = phi(x1, x2)   ; pick by predecessor
y1 = x3 + 3

A parallel story: instead of compiling ahead of time, compile at runtime, using information only available then. Dynamic languages drove the breakthroughs that today power JavaScript and Java alike.

Chris Lattner began LLVM as a research project at the University of Illinois (UIUC, ~2003), advised by Vikram Adve. Its radical move was treating the compiler as a set of reusable libraries around a well-specified, typed, SSA-based IR — the long-promised common IR, finally done right.

; LLVM IR — typed, SSA, target-independent
define i32 @square(i32 %x) {
entry:
  %r = mul nsw i32 %x, %x
  ret i32 %r
}

How the threads connect. The ALGOL line gives us C and the systems languages; the dynamic line runs through Smalltalk and Self; modern languages converge on shared back-ends (LLVM).

From the 2010s on, compilers stopped being monolithic programs and became platforms — reusable engines you build languages, accelerators and tools on top of.

A compressed who’s-who of the field. Several won the Turing Award (the discipline’s highest honour) for the work below.

One structural idea has survived intact since FORTRAN: a compiler is a front-end that analyses the source into a meaning-bearing IR, and a back-end that synthesises target code from it. Every later breakthrough — BNF, the Dragon pipeline, GCC’s RTL, LLVM IR, MLIR — is a refinement of where to draw that line and what the IR should be.

History rhymes. A handful of debates and “laws” resurface in every compiler generation.