By the mid-1950s, computers were already highly effective numerical machines. They solved equations, produced tables, and executed long sequences of arithmetic operations. John McCarthy wanted them to handle a different kind of work: manipulating ideas represented by symbols, constructing chains of reasoning, and processing expressions whose size was not known in advance.
Lisp grew out of that ambition. Instead of treating a program as a fixed sequence of instructions, it represented code with the same structures used for data. A program could inspect an expression, transform it, and produce another one. That property would have a lasting influence on functional programming, interactive systems, and the design of later languages.
McCarthy did not separate this research from the way people used computers. He also championed time-sharing, which let several users work with one machine at the same time. Lisp and time-sharing served a common purpose: turning the computer into an interactive partner for exploring problems rather than a machine that received a batch job and returned an answer much later.
Representing reasoning, not just calculation
John McCarthy was born in Boston in 1927 and grew up mainly in Los Angeles. He studied mathematics at the California Institute of Technology and completed a doctorate at Princeton in 1951. Mathematical logic played a central role in his education.
The first high-level languages were designed primarily around numbers. FORTRAN, led by John Backus at IBM, allowed scientists to express formulas without writing machine code. It dramatically reduced the cost of scientific programming, but it did not naturally fit problems whose data consisted of words, logical rules, proofs, or expression trees.
McCarthy was interested in programs that could reason about such representations. In 1955, he helped draft the proposal for the Dartmouth summer research project and introduced the term artificial intelligence for the field it sought to establish. The wording embodied a hypothesis: some aspects of learning and intelligence could be described precisely enough for a machine to simulate them.
Testing that hypothesis required a language that handled symbols as directly as FORTRAN handled numbers.
Why lists became Lisp’s central structure
A piece of reasoning can be represented as an expression made of smaller expressions. Adding two numbers, for example, can be written as a list containing the operation followed by its arguments: (+ 2 3). A logical rule can use the same shape while containing symbols and more deeply nested lists.
Lisp—short for list processing—made the list its fundamental structure. A list may contain numbers, names, or other lists. Two basic operations are enough to begin traversing it: retrieve the first element and retrieve the remainder. By combining them, a program can walk through a structure of arbitrary size.
This organization makes recursion natural. A function handles one element and then calls itself on what remains until it reaches a simple base case. Lisp did not invent recursion, but it made recursion an ordinary way to describe computations over nested structures.
McCarthy formalized the language in his 1960 paper, Recursive Functions of Symbolic Expressions and Their Computation by Machine. Lisp appeared less as a catalogue of commands than as a small set of rules capable of expressing general computation.
When code has the same shape as data
Lisp’s parentheses can seem unusual at first. Their regularity, however, provides a decisive feature: a code expression is itself a list. Programs and the data they process therefore share a common representation.
This property, known as homoiconicity, lets a program receive code as data, analyze it, and build a modified form. Lisp macros use that mechanism to extend the language without requiring the compiler to be redesigned for every new construct.
The boundary between language user and language designer becomes less rigid. A team can build notation suited to its field and translate it into Lisp’s elementary forms. The same principle is visible today in macros, domain-specific languages, and tools that transform source code.
The original idea and its implementation should not be confused. McCarthy initially imagined a more conventional notation called M-expressions. When Steve Russell realized that the evaluation function McCarthy had described could itself be programmed, the parenthesized S-expressions became directly executable. An intermediate notation intended to represent the language became its enduring syntax.
Automating dynamic memory
Lisp lists are created and discarded while a program runs. Requiring programmers to release every list manually would make symbolic programs difficult and error-prone. The system instead needed to identify memory that was no longer reachable and make it available again.
Lisp addressed this with garbage collection. The runtime identifies objects that can still be reached by the program and reclaims the storage occupied by the rest. Programmers can reason about the logical lifetime of data without managing every allocation directly.
That automation has a cost: garbage collection uses processing time and may briefly pause a program. It trades immediate control for fewer memory errors and greater freedom to construct dynamic structures. Java, JavaScript, Python, Go, and many other languages later adopted their own forms of automatic memory management.
Lisp’s legacy is therefore not reducible to its syntax. It combines mutually reinforcing choices: recursive structures, functions that can be manipulated, code represented as data, and automatic memory management.
Attributing all of Lisp to McCarthy would hide the collective work that turned the concepts into a usable system. He defined the central model and notation, but Steve Russell programmed the first evaluator. Daniel Edwards developed an early garbage collector. Timothy Hart and Michael Levin built an early Lisp compiler. Many researchers at MIT and elsewhere continued to evolve the language.
That distinction clarifies a language designer’s role. McCarthy supplied a model simple enough for others to implement, debate, and extend. Lisp soon became a family rather than a single product: Lisp 1.5, Maclisp, Interlisp, Scheme, Common Lisp, Emacs Lisp, and Clojure reflect different periods and goals.
Diversity also brought fragmentation. Code written for one dialect would not necessarily run in another. Common Lisp standardization in the 1980s attempted to unite several traditions, while Scheme preserved a smaller, more minimal core.
Time-sharing changed the relationship with computers
Computers in the 1950s commonly ran jobs in batches. Users prepared cards or tapes, handed a program to an operator, and received the result later. A single mistake could require another full cycle.
From the end of that decade, McCarthy advocated general-purpose time-sharing. The computer switched rapidly among users, giving each one the experience of working interactively with a machine. Researchers could test an idea, inspect the result, and revise their program immediately.
This interaction suited Lisp especially well. An interpreter could read an expression, evaluate it, and print the result in a continuous loop. The organization now known as a REPL turned programming into an experimental conversation with the system.
McCarthy helped advance this vision at MIT and later founded the Stanford Artificial Intelligence Laboratory with Lester Earnest. These environments brought together languages, terminals, networks, and researchers. They demonstrated that a language evolves through its setting of use as much as through its formal rules.
What Lisp passed on to modern languages
Lisp is no longer the sole language of artificial-intelligence research, but its ideas have escaped their original setting. Functions treated as values, lexical closures, recursion, automatic memory management, and interactive environments appear throughout contemporary programming.
John Backus would also promote a style based more strongly on composing functions. Guido van Rossum incorporated functional tools into Python’s multiparadigm design. Brendan Eich drew on Scheme for parts of JavaScript’s foundation, even though its surface syntax resembles C.
This diffusion can make Lisp’s influence invisible. A developer may use an anonymous function, pass a function to another function, or experiment in an interactive console without knowing the lineage. Lisp nevertheless remains a key bridge between mathematical logic, artificial-intelligence research, and everyday programming tools.
McCarthy died in 2011. His legacy is not a claim that machines had already achieved general intelligence. It is more precise: he showed that a language could represent symbolic expressions simply enough for programs, rules, and code to be manipulated through the same mechanisms.
Timeline
- 1927: John McCarthy is born in Boston.
- 1948: He graduates in mathematics from the California Institute of Technology.
- 1951: He earns a doctorate in mathematics from Princeton University.
- 1955: He helps write the Dartmouth proposal that introduces the term “artificial intelligence.”
- 1956: The Dartmouth workshop explores the emerging field.
- 1958: McCarthy develops the first formulations of Lisp at the Massachusetts Institute of Technology.
- 1959: He publishes a proposal for general-purpose time-sharing.
- 1960: His paper formalizing Lisp’s recursive functions and symbolic computation is published.
- 1962: He joins Stanford permanently.
- 1965: He and Lester Earnest establish the Stanford Artificial Intelligence Laboratory.
- 1971: He receives the Turing Award for contributions to artificial intelligence.
- 1980s: Common Lisp consolidates several Lisp traditions while Scheme develops a more minimal core.
- 2001: McCarthy retires from Stanford.
- 2011: He dies at Stanford at the age of 84.
- Today: Lisp dialects and their ideas remain active in functional programming, macros, and interactive environments.
Frequently asked questions
Did John McCarthy program the first Lisp by himself?
No. McCarthy defined the principles and initial description. Steve Russell built the first evaluator, while Daniel Edwards, Timothy Hart, Michael Levin, and other researchers contributed to garbage collection, compilation, and early implementations.
Why does Lisp use so many parentheses?
Parentheses make the nested structure of expressions explicit. Because code takes the form of lists, both the language reader and Lisp programs receive a regular representation that is straightforward to parse and transform.
Was Lisp the first functional programming language?
It was among the first languages to make functions and recursion central, and it is the oldest functional language still used in several forms. Functional programming as a category nevertheless developed gradually from multiple mathematical and language traditions.
How is Lisp connected to artificial intelligence?
Lisp was designed to manipulate the symbols, rules, and structures needed by early artificial-intelligence programs. It dominated that research for decades, although modern AI now uses many other languages.
Did McCarthy invent garbage collection?
Early Lisp implementations introduced garbage collection to reclaim unused lists automatically. McCarthy described the need and principle; Daniel Edwards implemented one of the first working mechanisms. The innovation belongs to Lisp’s collective history.
Is Lisp still used today?
Yes. Common Lisp, Scheme, Racket, Emacs Lisp, and Clojure serve different purposes. Its reach is broader still: anonymous functions, closures, REPLs, macros, and automatic memory management now appear in many languages.
