Textbook of AI

LISP (LISt Processor), invented by John McCarthy at the MIT Artificial Intelligence Project in 1958, is the second-oldest high-level programming language still in use, only FORTRAN is older. It was created to implement symbolic computation for artificial-intelligence research, and it introduced or popularised an extraordinary number of features that have since become mainstream across programming: anonymous functions (lambda expressions), closures, garbage collection, conditional expressions (the if-then-else expression as a value, not just a statement), recursion as a primary control structure, the read–eval–print loop (REPL), dynamic typing with runtime type tags, tree-structured uniform syntax in which programs and data share the same representation (the homoiconic property), and macros that operate on this shared representation to extend the language from within.

LISP's core data structure is the cons cell, a pair (car . cdr) used to build linked lists; its core syntactic form is the S-expression, a parenthesised tree of symbols and cons cells. A LISP program is itself an S-expression, parseable and constructable by other LISP programs , a property that has made the language unusually well suited to writing programs that write programs, including theorem provers, expert-system shells, and self-modifying AI systems. The minimalism of the language is notable: McCarthy famously demonstrated that LISP could be implemented in itself in about a page of code (the celebrated eval function), and Steve Russell's 1959 hand-translation of that page into IBM 704 machine code was the first LISP interpreter. This metacircular self-definition gave LISP great malleability and made it the preferred vehicle for AI research from 1958 until roughly the end of the expert-systems era in the early 1990s.

LISP dialects proliferated. MacLisp (MIT, late 1960s), Interlisp (Xerox PARC, 1970s) and Zetalisp (the language of the Lisp Machines built by Symbolics and LMI in the 1980s) were the major research dialects; Common Lisp was standardised in 1984 and ratified as ANSI X3.226 in 1994 to consolidate the family. Scheme, designed by Guy Steele and Gerald Sussman at MIT in 1975, is a smaller, lexically scoped dialect that became enormously influential in programming-language theory and education (the basis of the celebrated Structure and Interpretation of Computer Programs). Racket is its modern descendant, and Clojure (Rich Hickey, 2007) is a JVM Lisp targeting concurrency and immutable data structures.

LISP's influence on mainstream programming is pervasive. First-class functions in JavaScript, list comprehensions in Python, the lambda primitives of nearly every modern language, the REPL workflows of Python and Ruby, the macro systems of Rust and Julia, and the reflection capabilities of every dynamic language descend directly from McCarthy's design. The decline of LISP as the dominant AI language coincided with the rise of statistical and connectionist methods and the standardisation of C++ and Python as research languages, but its conceptual legacy is hard to overstate. Alan Kay called LISP the Maxwell's equations of software; Eric Raymond wrote that LISP is worth learning for the profound enlightenment experience you will have when you finally get it. The language remains in active use in a few specialist communities and powers the customisation layer of the Emacs text editor through Emacs Lisp.