Diff — LISP

**LISP** — *LISt Processing* — is the second-oldest high-level programming language still in use and the most intellectually radical language ever designed by a committee of one. Created by **John McCarthy** at MIT in **1958**, it introduced recursion, garbage collection, conditionals-as-expressions, dynamic typing, the REPL, and the idea that a program's own code is just data it can manipulate — the concept that became *homoiconicity*. Where [[FORTRAN]] answered "can a machine do the translating?", LISP answered a different question: what is the simplest possible language in which *everything is expressible*?

# McCarthy's bet

McCarthy arrived at MIT in 1958 with a problem no existing language could touch: he wanted to program machines to *reason* — not to compute artillery trajectories but to prove theorems, play chess, and manipulate symbols. FORTRAN processed numbers; McCarthy needed a language for **thought**. Working from the mathematical formalism of the [[lambda calculus]] (and a failed earlier attempt called FLPL on [[IBM]]'s 704), he designed a language whose entire structure was one data type — the **list** — and one control structure — **recursion**.

The result was so clean that it reads like mathematics itself. The famous **eval** function — the interpreter for Lisp, written *in* Lisp — fit on one page and is still cited as the most compact description of a language's semantics ever published. When McCarthy's student **Steve Russell** hand-compiled that eval into machine code in 1959, Lisp went from a mathematical formalism to a running language — "the day Lisp was born," as the story goes.

# The core ideas

LISP introduced, in one language, concepts that took other languages decades to absorb:

- **Homoiconicity** — Lisp code is Lisp data. A program is a list; lists are programs. The `eval`/`quote` duality means the language can rewrite itself at runtime — the deepest extensibility any language has.

- **Recursion as primary control** — no `GO TO` needed; a function calls itself. The `cond` conditional made choice an *expression* that returns a value, not a statement that jumps.

- **Garbage collection** — invented here, out of necessity: manipulating millions of cons cells by hand was unworkable, so McCarthy built automatic memory management in **1959**. Every managed language since inherits the idea.

- **The REPL** — `read-eval-print loop`: type an expression, get an answer, immediately. Interactive programming's oldest living form.

- **Dynamic typing** — types checked at runtime, not compile time.

- **The conditional expression** — `if` that returns a value: `(if (> x 0) x (- x))`.

A classic:

```lisp

(defun factorial (n)

  (if (= n 0)

      1

      (* n (factorial (- n 1)))))

```

Three lines, one data structure, one idea — the whole language is this shape.

# The dialects

LISP is not one language but a family — the specification was loose enough that every generation made its own:

- **Lisp 1.5** (1962) — the first widely distributed version

- **MacLisp, Interlisp, Franz Lisp** (1960s–70s) — the AI-lab dialects

- **Common Lisp** (1984) — the ANSI-standard unification of the family

- **Scheme** (1975) — Guy Steele and Gerald Sussman's minimalist dialect; the *SICP* teaching language

- **Clojure** (2007) — the modern Lisp on the JVM, which brought the family back into production

Plus **Emacs Lisp** — the entire extensibility of Emacs, arguably the longest-lived Lisp in daily use.

# The seed of AI

LISP was *the* AI language for thirty years — the language of the **AI Lab culture** at MIT, Stanford, and SRI:

- **SHRDLU** (1970) — Terry Winograd's natural-language block-world system

- **ELIZA**'s descendants — early chatbot and NLP work

- **Expert systems** — MYCIN, Dendral, the whole 1980s knowledge-engineering boom

- **Lisp machines** — Symbolics and LMI built entire workstations whose OS, window system, and user programs were all Lisp — the language as the whole computer

- **The AI winter** killed the machines, but the ideas — symbols, lists, homoiconic code — survived into Prolog, into symbolic computing, and now into the attention-mechanism era where the cycle completed: attention heads are, at their core, very fancy list processors.

# Legacy

- Second-oldest language still in production after FORTRAN — and the more influential of the two on *language design itself*: lambda, closures, garbage collection, dynamic typing, and REPLs all trace to LISP

- The Turing Award's fourth recipient was McCarthy (1971)

- "**Greenspun's tenth rule**": any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified, bug-ridden implementation of half of Common Lisp — the joke that is also a verdict

- The direct intellectual ancestor of modern functional programming (Haskell, ML, the [[lambda calculus|lambda]] in every mainstream language) and of symbolic AI

# See also

- [Learn it interactively — the step-by-step lambda calculus guide](/math/lambda-calculus)

- [[FORTRAN]]

- [[History of Programming]]

- [[IBM]]

- [[Alan Turing]]

- [[Forth]] — the other language where code and data are made of the same stuff

# References

1. McCarthy, John. "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I." *Communications of the ACM* 3(4), 1960.

2. McCarthy, John, et al. *LISP 1.5 Programmer's Manual* (MIT Press, 1962).

3. Stoyan, Herbert. "Early LISP History (1956–1959)." *Proceedings of HOPL* (1978).

[[Category:History]]

[[Category:Languages]]