John McCarthy builds LISP, and AI gets its first native language
John McCarthy said “ho, ho” — the sound of a theorist catching a programmer about to do something reckless. It was fall 1958 at MIT, and Steve Russell, a graduate student, had just read McCarthy’s mathematical sketch of a universal evaluator for symbolic expressions. “Why don’t I program this eval?” Russell asked. McCarthy’s reply was swift: Ho, ho, you’re confusing theory with practice. Russell programmed it anyway. The result was LISP — the language that would run nearly every major AI system for the next three decades.
McCarthy had been circling the problem since the summer of 1956, when seventeen researchers gathered at Dartmouth College for the conference where he coined the phrase “artificial intelligence.” There he heard Allen Newell and Herbert Simon describe IPL, their list-processing language for the Logic Theorist. McCarthy found IPL workable but algebraically unpleasant — it was designed for IBM assembly, not mathematical composition. He wanted something rooted in Alonzo Church’s lambda calculus: a language where functions were first-class objects you could pass around and compose like arithmetic. By the time the MIT Artificial Intelligence Project was founded on September 1, 1958, McCarthy had a design worth implementing.
LISP — LISt Processing — made two radical bets. The first: code and data should look identical. A LISP program is itself a LISP list, wrapped in parentheses, which means a program can inspect, generate, or rewrite other programs as easily as rearranging numbers in a column. This property — homoiconicity — made LISP the natural tongue of AI: a system that reasons about its own beliefs is just a program treating programs as data. The second bet was on automatic memory management. MIT graduate student Daniel Edwards wrote a garbage collector that freed memory without requiring the programmer to track allocations manually — a concept that Java, Python, and nearly every modern language would eventually inherit.
The physical machine left its mark on the syntax. The IBM 026 keypunch in McCarthy’s lab had no square brackets on its keyboard. McCarthy had planned a cleaner notation for expressions. Necessity intervened: the language wound up with its wall-to-wall parentheses, which became either a badge of honor or a badge of horror depending on whom you asked, and occasionally both at once.
Which brings us back to Russell and the eval function. McCarthy had written eval as pure mathematics — a theoretical recipe describing how any LISP expression could be interpreted. He thought of it as a formalism, not something meant to run. Russell looked at it and said he could translate it to IBM 704 machine code. McCarthy doubted him. Russell did it over a weekend. “This development was a surprise to me,” McCarthy admitted years later in a recorded oral history. A mathematical definition had become an interpreter.
McCarthy published the formal account in April 1960: “Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I,” in the Communications of the ACM. The paper formalized S-expressions, introduced the meta-circular evaluator, and laid out a model of computation that would influence language design for decades. By the mid-1960s, LISP had displaced every rival as the working language of AI research, running inside systems that proved theorems, parsed natural language, and played strategic games.
The practitioners who followed — Terry Winograd building SHRDLU in 1970, Edward Feigenbaum’s group at Stanford building MYCIN through the mid-1970s — did their thinking in LISP. When the expert systems boom demanded specialized hardware, engineers built entire machines around the language. Lisp machines. Running a single language, at room-filling cost.
McCarthy built a language for reasoning about reasoning. The parentheses multiplied from there.
Sources
- Lisp (programming language) — Wikipedia — founding date of MIT AI Project, technical innovations (S-expressions, garbage collection, meta-circular evaluator), publication history.
- LISP Prehistory 1956–1958 — McCarthy, Stanford — McCarthy’s own account of the Dartmouth origins, IPL influence, and lambda calculus motivation.
- How Lisp Became God’s Own Programming Language — Two Bit History — IBM 704 keyboard constraint, the Russell eval story, and the language’s lasting influence on AI research.