“Much of my work has come from being lazy. I didn't like writing programs, and so, when I was working on the IBM 701, I started work on a programming system to make it easier to write programs.”
The Story
In 1953, John Backus was a programmer at IBM, and he hated his job. Not the thinking part — the typing part. Programming the IBM 701 meant writing machine code by hand: load this register, add that address, store the result here. It was tedious, error-prone, and — Backus believed — fundamentally unnecessary.
He proposed something that most of his colleagues and managers thought was impossible: a system that would let programmers write mathematical formulas in something resembling English and algebra, and a program — a compiler — that would translate those formulas into efficient machine code automatically.
The IBM Mathematical Formula Translating System — FORTRAN — shipped in April 1957 after three and a half years of development. It was the first high-level programming language that actually worked. Not a toy, not a research project, but a production system that generated code fast enough for IBM's customers to use.
This was not a foregone conclusion. The conventional wisdom in the 1950s was that automatic translation from high-level descriptions to machine code would produce programs too slow to be useful. Programmers — who were, at the time, literally people who wrote machine instructions — viewed compilers with suspicion. Why would you trust a machine to write code when a human could write it better?
Backus and his team proved them wrong. FORTRAN's compiler produced code that was within 10-20% of hand-written assembly for most programs. That margin was small enough that the productivity gain overwhelmed it. Suddenly, a program that took two weeks to write in assembly could be written in an afternoon.
But Backus wasn't done. In 1959, while working on the specification for ALGOL 60, he co-developed a formal notation for describing the syntax of programming languages. Backus-Naur Form (BNF) — refined with Peter Naur — gave the field its first rigorous way to define what constitutes a valid program. Before BNF, language syntax was described in English prose, with all the ambiguity that implies. After BNF, every language could have a precise, parseable grammar. Compilers could be built from the grammar specification itself.
Then Backus did something remarkable: he turned against his own legacy. In his 1977 Turing Award lecture, "Can Programming Be Liberated from the von Neumann Style? A Functional Style and Its Algebra of Programs," he argued that the imperative programming model he'd helped establish — the model FORTRAN embodied — was fundamentally limited. He advocated for functional programming, for algebraic program composition, for a paradigm shift away from the sequential, state-mutating style that dominated (and still dominates) the industry.
The lecture is one of the most important documents in computer science. The creator of the most influential imperative language publicly arguing that imperative programming was a dead end. It didn't change the industry overnight — we're still writing imperative code seventy years later — but it planted the seed that grew into Haskell, Erlang, and the functional features now embedded in every modern language.
Why They're in the Hall
Backus is a Pioneer and Builder at the most foundational level — he built the ground that every other exhibit, hero, and disaster in TechnicalDepth stands on.
Pioneer: Two contributions, either of which alone would justify a place here. FORTRAN proved that humans didn't have to speak machine. That single insight — that there could be a layer between human thought and machine execution — is the precondition for everything in software. Every language, every framework, every abstraction layer is a descendant of the moment Backus decided that writing machine code was a problem to be automated away.
BNF formalized the concept of a programming language grammar. Without it, there's no compiler theory, no parser generators, no language design as a discipline. Every language specification, every syntax error message, every linter rule traces back to the notation Backus and Naur gave us.
Builder: FORTRAN didn't just demonstrate a concept — it shipped. It ran on real hardware, solved real problems, and convinced a skeptical industry that high-level languages were practical. The language is still in active use in scientific computing more than sixty years later. Few artifacts in computing history have that longevity.
The Turing Award lecture adds a dimension that makes Backus essential to TechnicalDepth's mission. He looked at the paradigm he'd helped create, recognized its limitations, and publicly argued for something better. That willingness to question your own foundations — to ask whether the patterns you established are actually the right patterns — is exactly the kind of thinking that software archaeology demands. The exhibits in TechnicalDepth document what happens when patterns go unquestioned. Backus showed what it looks like to question them, even when they're your own.