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) — 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 in every mainstream language) and of symbolic AI

See also

• FORTRAN
• History of Programming
• IBM
• Alan Turing