Lisp in 1960: John McCarthy’s Blueprint for Thinking Machines

A Language Built for Symbolic Reasoning

In “Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I” John McCarthy introduces Lisp not as a general-purpose language but as the missing tool for an ambitious AI project he called the Advice Taker—software that would manipulate declarative sentences and exhibit common-sense reasoning. To do that, programs themselves must be handled as data structures, so McCarthy designs Lisp around two deceptively simple ideas: S-expressions (uniform parenthesised lists) and a handful of primitive S-functions (CAR, CDR, CONS, ATOM, EQ). With nothing more than lists and five operations, Lisp achieves Turing-completeness and, crucially, the ability for code to inspect, modify and generate other code—capabilities vital for symbolic AI tasks such as theorem proving and algebraic manipulation.

This homoiconic design means that the parse tree is the program; no external syntax tree is needed. When McCarthy’s MIT group loaded Lisp onto the IBM 704 mainframe, they could write meta-programs that reasoned about their own source—an unprecedented step toward self-modifying, knowledge-rich AI systems.

nside the Paper: S-Expressions, EVAL-APPLY, and Garbage Collection

The heart of the paper is Section 3, where McCarthy defines the universal interpreter pair EVAL and APPLY. APPLY takes an S-expression representing a function plus a list of quoted arguments, packages them together, and hands the result to EVAL, which walks the tree, evaluates conditionals (COND), resolves variables through an association list (an early environment), and returns the final value. In 1960 this interpreter was only a few dozen lines of Lisp yet conceptually underpins every modern REPL loop.

One of McCarthy’s show-piece examples is the SUBST routine—“search-and-replace for trees” in nine lines:

(LABEL SUBST
  (LAMBDA (x y z)
    (COND ((ATOM z) (COND ((EQ z y) x) (T z)))
          (T (CONS (SUBST x y (CAR z))
                   (SUBST x y (CDR z))))))

With only recursion, conditional expressions and the three list operators, it descends arbitrarily deep structures, illustrating both expressive power and elegance.

McCarthy also pioneers automatic memory management. Because symbolic programs build and discard lists on the fly, he describes a reclamation cycle that traverses reachable cells from a set of roots and returns everything else to a free-list—an algorithm we now call mark-and-sweep garbage collection. On vacuum-tube hardware with 15 000 words of core, this was radical; programmers no longer had to hand-delete structures, freeing mental bandwidth for AI logic instead of pointer bookkeeping.

Even the cryptic names CAR and CDR come straight from the IBM 704’s hardware manual—Contents of the Address (or Decrement) Register. McCarthy ties his abstract calculus tightly to machine realities, demonstrating that high-level reasoning need not sacrifice performance.

Legacy: How McCarthy’s Ideas Still Shape AI Code

McCarthy’s 1960 publication seeded the symbolic AI era: expert systems, SHRDLU’s natural-language scene, Macsyma’s algebra engine, and the planning language STRIPS all owed debts to Lisp’s data-as-code paradigm. But the impact goes further:

• Higher-order functions & lambdas – LAMBDA expressions in the paper pre-date mainstream functional languages by decades and influenced Scheme, Clojure, even JavaScript’s first-class functions.
• Metaprogramming – modern build systems, macros, and prompt-engineering frameworks for large language models rely on code that writes or rewrites code—exactly the operations EVAL and APPLY showcased.
• Garbage-collected runtimes – from JVM to .NET, automatic memory reclamation is standard, following the template McCarthy sketched for list cells.
• Interactive development – today’s Jupyter notebooks and Clojure REPLs mirror the rapid, exploratory workflow made possible when EVAL could run any S-expression typed at the console.

Perhaps most prescient is McCarthy’s insistence on minimal powerful primitives. Five list operators plus recursion were enough to express every algorithm the team needed, proving that clarity and mathematical rigor often beat sprawling instruction sets. That ethos resonates in contemporary AI research, where transformer architectures are built from a few composable blocks and yet scale to billions of parameters.

Take-home Message
John McCarthy didn’t just give us a programming language; he delivered a philosophical and practical recipe for building software that reasons about symbols—the essence of artificial intelligence. Reading the 1960 Lisp paper today reminds us that many “modern” breakthroughs—code introspection, functional purity, garbage collection—were already waiting in those elegantly parenthesised pages. For anyone mapping AI’s past to its future, McCarthy’s Lisp remains a luminous waypoint.