Lisp, or the language that ran before anyone knew it could
In the autumn of 1958, a graduate student at MIT named Steve Russell sat down with a copy of John McCarthy’s paper on symbolic computation and did something McCarthy had told him was a mistake. The paper described a mathematical notation — a thought experiment built on Alonzo Church’s lambda calculus — for manipulating lists of symbols. It was, McCarthy said, intended for reading, not for computing. Russell found an IBM 704 and decided to find out.
McCarthy’s exact words, recalled later: “Ho, ho, you’re confusing theory with practice — this eval is intended for reading, not for computing.” Russell ignored the advice, compiled the eval function from McCarthy’s paper into IBM 704 machine code, fixed the bugs as they appeared, and by May 1959 had a working interpreter. McCarthy’s summary of the event was characteristically dry: “He compiled the eval in my paper into IBM 704 machine code, fixing bugs, and then advertised this as a Lisp interpreter, which it certainly was.”
McCarthy had arrived at MIT in 1958 fresh from the 1956 Dartmouth Summer Research Project — the conference where he had coined the term “artificial intelligence.” He needed a language that could reason about symbols the way Fortran reasoned about numbers: one capable of manipulating lists, recursing naturally, and handling the structured symbolic logic that AI problems required. What was available was either too numerical or too close to the machine. He drew on Church’s lambda calculus and designed something new. His formal paper, published in Communications of the ACM in April 1960, gave the language its mathematical foundation.
What Lisp offered was unlike anything before it. Code and data were written in the same format — parenthesized prefix expressions called S-expressions — so a Lisp program could construct and run other Lisp programs at will. The primitive list operations, car and cdr, were named for IBM 704 register fields: the Contents of the Address part of the Register, and the Contents of the Decrement part of the Register — two acronyms so opaque they became a kind of inherited lore. Functions were first-class values you could pass, store, and return. Recursion was not an edge case but the primary tool.
The detail that was most genuinely radical, by 1958 standards, was automatic memory management. McCarthy invented garbage collection — a mechanism that quietly tracked which memory was still in use and reclaimed the rest — while designing the language. Before this, programmers managed memory by hand; getting it wrong meant corrupted data or crashes with no clean recovery. Lisp simply handled it. The name “garbage collection” remains one of computing’s stranger coinages, sounding less like a technical achievement than a light housekeeping task.
Lisp became the language of AI research for the next three decades. McCarthy’s labs at MIT and later Stanford ran on it. Early theorem provers, natural language systems, and the first expert systems all wrote Lisp. By the 1980s, dedicated Lisp machines — the Symbolics 3600 series, priced around $110,000 — were processing S-expressions in custom silicon. The ideas Lisp introduced migrated into virtually every language that followed: higher-order functions into Python, blocks and closures into Ruby, the REPL into every interactive environment now taken for granted.
McCarthy had set out to write a mathematical notation. Russell had turned it into a language. Between them they had demonstrated something that took decades to fully absorb: that a programming language can be built from almost nothing — a handful of primitive operations, one consistent rule for combining them — and still reach every computation there is.
The parentheses never went away.
Sources
- Lisp — Wikipedia — history, car/cdr etymology, Steve Russell’s interpreter, key dates.
- McCarthy, “Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I” (1960) — the original paper; McCarthy’s own account of Lisp’s design and the eval implementation.