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:

(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; ANSI standard 1994) — the 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 sixth 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 in every mainstream language) and of symbolic AI

See also

• Learn it interactively — the step-by-step lambda calculus guide

• FORTRAN
• History of Programming
• IBM
• Alan Turing
• Forth — the other language where code and data are made of the same stuff
• REBOL — code-as-data's internet-era descendant, and a named influence on JSON

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).