Lisp
Lisp is a programming language created by John McCarthy at MIT beginning in 1958, designed for symbolic computation and artificial intelligence research, in which programs and data share one uniform structure, nested lists, and in which recursion, conditional expressions, and automatic memory management are basic tools rather than add-ons. Only Fortran, dating from 1957, is older among high-level languages still in use, and Lisp's ideas have spread so widely that many programmers use its inventions without ever writing a parenthesis.
McCarthy's 1960 paper, Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I, in Communications of the ACM, is the language's founding text, and it presented Lisp as much a piece of mathematics as a programming tool. He wanted a notation for symbolic computation on the model of recursive function theory, borrowing the lambda notation of Alonzo Church for naming functions and adding the conditional expression, a form that chooses among alternatives, which was new to programming languages. The paper showed how a small set of primitive operations could define a universal function, eval, capable of interpreting any Lisp expression written as data. Steve Russell, one of McCarthy's students, realized that eval could be hand-compiled into machine code, and so the working interpreter on the IBM 704 came from turning the theoretical definition into a program. The LISP 1.5 Programmer's Manual of 1962 documented the version that spread.
The data structure underneath is the cons cell, a pair of pointers, and the famous names car and cdr are artifacts of the hardware where Lisp was born. A list is a chain of such pairs: the first half holds an element, the second points to the rest, with a special nil marking the end. On the IBM 704 a machine word had fields called the address and decrement parts, and the operations to extract them became car, contents of the address register, and cdr, contents of the decrement register, while cons constructed a new pair. Because any cons cell may point to another list, the same structure represents trees and nested expressions, and an expression such as an arithmetic formula is written as a list whose first element names the operator.
Treating code as data, known as homoiconicity, is Lisp's deepest idea and the source of its macro system. Since a program is a list, a Lisp program can write or transform other Lisp programs using ordinary list operations, which lets users extend the language with new syntactic forms rather than waiting for a language designer. Together with first-class functions and recursion, this made Lisp the natural language for the symbolic AI of the 1960s through 1980s, from early theorem-proving and algebra systems to large knowledge-based systems. Garbage collection, another McCarthy invention, automated what other languages left to the programmer: the system finds cells no longer reachable and reclaims them, an idea that Java, Python, JavaScript, and many others later adopted as standard.
Lisp's history after 1960 is a story of both fragmentation and consolidation. Many dialects flourished, among them Maclisp and Interlisp. Guy Steele and Gerald Sussman introduced Scheme at MIT in 1975 as a small, lexically scoped dialect that guaranteed proper tail calls and became a teaching language through the textbook Structure and Interpretation of Computer Programs. Common Lisp, described in Steele's 1984 book and standardized by ANSI in 1994, merged the large dialects into one broad language. Specialized Lisp machines from companies such as Symbolics and Lisp Machines Incorporated, growing from MIT hardware work in the 1970s, ran Lisp natively, though cheaper general-purpose workstations and the collapse of the expert-system market in the late 1980s ended that industry.
Modern echoes are everywhere, though pure Lisp itself is a niche. Clojure, created by Rich Hickey in 2007, runs on the Java platform and revived the Lisp idiom in industry, Emacs Lisp scripts the Emacs editor, and automatic memory management, anonymous functions, and the read-eval-print loop all spread to mainstream languages. A common misconception is that the name means lots of irritating, silly parentheses; it is short for list processing, and the parentheses are the visible form of the uniform structure that makes macros possible. Another is that Lisp is slow and interpreted, whereas Common Lisp compilers have long produced efficient native code, and a third is that Lisp is the language of AI, when modern machine learning runs largely on Python and C++.
Read Lisp as a small, self-describing mathematical notation for computation, in which lists are both the programs and the data they manipulate, and whose real legacy is the set of ideas, recursion, garbage collection, and code as data, that the rest of computing absorbed.