Lisp was designed by John McCarthy at MIT in 1958 and described in his 1960 paper "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I". People often ask is Lisp the second oldest programming language, and the accurate answer is that it is the second-oldest high-level language still in widespread use, after Fortran. Several earlier languages existed, but none of them survived the way Lisp has, through dialects that are actively developed nearly seventy years later.
Origins: John McCarthy and AI at MIT
McCarthy had coined the term "artificial intelligence" in the 1955 proposal for the Dartmouth summer workshop held in 1956. He knew the list processing work of Newell, Shaw and Simon in IPL, and he had looked at FLPL, a Fortran-based list processing package developed at IBM. Neither felt right. IPL was assembly-like, and Fortran was built for numbers. McCarthy wanted a language for symbolic computation grounded in mathematical functions and recursion.
His paper defined a universal function, eval, that could interpret Lisp expressions written in Lisp itself. McCarthy saw it mainly as theory. Steve Russell, then a programmer in the group, realised that eval could be implemented directly on the IBM 704, and in doing so produced the first Lisp interpreter. Lisp 1.5, released around 1962 with a published manual, became the first widely distributed version.
Design and key features
Lisp introduced or popularised an unusual number of ideas that are now standard:
- S-expressions. Both code and data are written as parenthesised lists, so programs can build and transform other programs. This property is known as homoiconicity.
- Garbage collection. McCarthy's group devised automatic memory reclamation so programmers did not have to free list cells by hand.
- Recursion and first-class functions as normal programming tools.
- Conditional expressions. McCarthy's
condwas an early form of the if-then-else expression. - Dynamic typing, with types attached to values rather than variables.
- The read-eval-print loop (REPL), an interactive way of developing programs.
- Macros in later dialects, letting programmers extend the language's syntax.
The names car and cdr, for the first element and the rest of a list, come from the IBM 704, where they referred to the "address" and "decrement" parts of a machine word.
A short code example
A recursive factorial in Common Lisp shows the uniform, prefix syntax:
(defun factorial (n)
(if (<= n 1)
1
(* n (factorial (- n 1)))))
(factorial 20) ; => 2432902008176640000Common Lisp integers grow as needed, so the same function works for much larger values without overflow.
Major dialects
| Dialect | Approximate date | Notes |
|---|---|---|
| Lisp 1.5 | around 1962 | First widely distributed version |
| Maclisp and Interlisp | late 1960s–1970s | Dominant research dialects at MIT and BBN/Xerox PARC |
| Scheme | 1975 | Guy L. Steele and Gerald Jay Sussman; lexical scope, minimal core |
| Common Lisp | 1984 (ANSI standard 1994) | Unified the Maclisp family; includes CLOS object system |
| Emacs Lisp | mid-1980s | Extension language of GNU Emacs |
| Racket | 1990s (as PLT Scheme) | Scheme descendant focused on language building and teaching |
| Clojure | 2007 | Rich Hickey; runs on the JVM, emphasises immutable data |
How Lisp has been used
For decades Lisp was the main language of AI research at MIT, Stanford and Carnegie Mellon. In the late 1970s and 1980s, companies such as Symbolics and Lisp Machines Inc. sold workstations designed to run Lisp efficiently. Lisp has also served as an embedded extension language, notably Emacs Lisp in GNU Emacs and AutoLISP in AutoCAD. In industry, ITA Software built its QPX airfare search engine in Common Lisp, and the company was later acquired by Google.
Influence and legacy
Lisp's ideas spread far beyond its own syntax. Garbage collection, interactive REPLs, first-class functions and closures are now ordinary features of Python, JavaScript, Ruby and many others. Scheme influenced JavaScript's design, Smalltalk drew on Lisp's dynamism, and ML and the wider functional programming tradition grew partly from Lisp. Macro systems in Rust, Elixir and Julia also owe something to Lisp's code-as-data approach.
Is Lisp still used today?
Yes, though as a family of niche languages rather than a mainstream one. Common Lisp has active open-source compilers such as SBCL, Clojure is used in production web and data systems, Racket is popular in teaching and language research, and Emacs Lisp remains central to Emacs.
So, is Lisp the second oldest programming language? Strictly, no, since Plankalkül, Short Code, Autocode, IPL and FLOW-MATIC came earlier. But among high-level languages still in real use, it ranks second only to Fortran, and its influence on modern programming arguably runs deeper than Fortran's.
Frequently asked questions
Who created the Lisp programming language?
John McCarthy designed Lisp at MIT in 1958 and published its theory in 1960. Steve Russell wrote the first interpreter on the IBM 704 after realising that McCarthy's eval function could be implemented directly.
Why does Lisp use so many parentheses?
Lisp code is written as nested lists called S-expressions, and parentheses mark where each list begins and ends. Because programs are ordinary data structures, Lisp code can easily read, generate and transform other Lisp code, which is what makes its macro systems so powerful.
Which Lisp dialect should I learn first today?
It depends on the goal. Racket and Scheme suit learning programming concepts, Clojure suits practical work on the JVM, and Common Lisp offers a large, stable standard with fast native compilers such as SBCL.
