The History of LISP and Early AI Research

By Victor Hoang · Updated Oct 22, 2026

In the late 1950s, researchers believed machines could reason about the world. They had a problem that arithmetic languages couldn't solve. Their programs needed to hold sentences, plans and chess positions as structures that grow and shrink while the program runs. The languages of the day were built for numbers.

LISP is a programming language for working with symbols and lists. John McCarthy began building it at the Massachusetts Institute of Technology (MIT) in the fall of 1958. Its defining paper appeared in Communications of the ACM in April 1960. For about thirty years it was the working language of AI research. Then the specialized computers built to run it lost out to ordinary workstations. The throughline: a small, clean idea outlived every machine made for it, and the machines are the part that failed.

How that problem got a language is a story of one summer workshop, one mathematician's notation, and a programmer who hand coded a function nobody had planned to run. For the wider field around it, see The History of AI and the AI timeline.

Timeline at a Glance

Before LISP (1930s-1958)

A logician's notation meets a workshop's wish for lists

In the summer of 1956, researchers gathered at Dartmouth College for a workshop on building thinking machines. McCarthy later called it "the first organized study of AI", and at it he wished for an algebraic list-processing language for the IBM 704. The wish had a concrete cause. Newell, Shaw and Simon had described IPL 2 there, a list-processing language for RAND's JOHNNIAC that powered their Logic Theorist program. For more on that summer, see the Dartmouth conference of 1956.

IPL was the nearest real ancestor, but it was not the model. Stanford's Nils Nilsson reports that Newell, Shaw and Simon began creating the IPL series around 1954 at RAND, with IPL-II implemented in 1955, and that it served Logic Theorist, GPS and their chess program. McCarthy's own account says he did not copy it. The form of IPL came partly from a loader available on the JOHNNIAC, and he found FORTRAN's algebraic style more attractive.

The mathematical ancestor is older. Between 1932 and 1936, Alonzo Church and Stephen Kleene worked out the lambda calculus, in which a function is defined by a process of repeated substitution, per the Stanford Encyclopedia of Philosophy. McCarthy took only one piece of it. He adopted Church's function notation from 1941 and left out the rest, because conditional expressions were easier to implement than Church's higher-order functionals.

Meanwhile IBM was building a geometry-proving program based on an idea from Marvin Minsky. McCarthy consulted. On his advice, Nathaniel Rochester and Herbert Gelernter decided to add list processing to FORTRAN instead of writing a new compiler, which was believed to take many man-years. In 1957 and 1958, Gelernter and Carl Gerberich produced FLPL, the FORTRAN List Processing Language. It worked. But it had no conditional expressions and no recursion, and erasing list structure had to be done by the programmer.

The conditional expression came from an unrelated chore. McCarthy invented it while writing chess legal-move routines in FORTRAN, where the IF statement was awkward and a trick function evaluated all three of its arguments before choosing. A true conditional evaluates only the branch it selects. He proposed the notation for Algol, but the editor of Communications of the ACM demoted the proposal to a letter because it was short, as McCarthy recounts.

The summer of 1958 brought the pieces together. At Rochester's invitation, McCarthy worked in IBM's Information Research Department, using symbolic differentiation as a test problem. The differentiation task forced four ideas beyond FLPL: recursive function definitions built from conditional expressions, a function called maplist that applies a function to the elements of a list, Church's lambda notation, and some way to erase abandoned list structure. He couldn't run it. FLPL lacked what the program needed, and modifying FORTRAN was both a technical and a political fight. A new language was needed.

For teams today: the first idea was a wish and a small stack of working parts: a notation from logic, a list library from IBM, a test problem from calculus. New tools usually start as assembled borrowings, and you can inspect yours the same way.

The McCarthy Years (1958-1962)

A paper, an accident and a manual make LISP real

Start with a single room at MIT. McCarthy and Minsky started what became the MIT AI Project, and by McCarthy's account they asked for a room, two programmers, a secretary and a keypunch, with the Research Laboratory of Electronics under Jerome Wiesner supporting them. (MIT's own film archive dates the project's founding to 1959, while McCarthy says 1958. Nilsson reports that McCarthy moved to MIT in the fall of 1958 and Minsky joined a year later.) Implementation began that fall, per McCarthy's history.

The goal was not a language for its own sake. McCarthy's April 1960 paper, "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I", says LISP was developed for the IBM 704 by MIT's AI group to support experiments with a proposed system called the Advice Taker. The Advice Taker was meant to be instructed in declarative as well as imperative sentences and to show "common sense." The proposal was made in November 1958. That is why lists mattered: a list can hold a sentence, and a program that reasons has to build and take apart sentences.

The paper also contained the idea that made LISP different. It described a universal function called apply, which it says plays the theoretical role of a universal Turing machine and the practical role of an interpreter. It stated the garbage-collection idea too: nothing happens until a program runs out of free storage, then a reclamation cycle marks every reachable register and returns the rest to the free list. A footnote adds, "I guess I chickened out of using it in the paper," about the name "garbage collection." The earlier alternative, tracking and erasing lists by hand, was tedious, and reference counts weren't practical because only six bits were left in a word, per McCarthy's account.

Then came the accident that shaped the language's life. McCarthy's history says that the function eval in his paper computes the value of a LISP expression, and that Steve Russell noticed eval could serve as an interpreter and promptly hand coded it. McCarthy had planned a compiler and a separate notation, called M-expressions, closer to FORTRAN. The interpreter arrived first, programmers wrote in the parenthesized form, and the plan to translate M-expressions was never finished or explicitly dropped. The surprise froze the language's shape, and he says some early choices, such as the COND notation and using zero for NIL, proved unfortunate.

From LISP 1 to LISP 1.5, the language grew by use. Property lists, numbers as atoms instead of lists, and the PROG feature for sequential code all arrived. McCarthy writes that PROG looks like "a hasty afterthought" but isn't quite: the idea of sequential programs predates recursive definitions, though the PROG notation itself was an afterthought. James Slagle found a bug in how free variables were handled, and Russell fixed it with a device called FUNARG. Numerical work ran 10 to 100 times slower than in FORTRAN. Robert Brayton made the first compiler attempt, which failed, and Timothy Hart and Michael Levin wrote the first successful LISP compiler, in LISP itself. The LISP 1.5 Programmer's Manual by McCarthy, Levin and others was published by MIT Press in 1962.

The era solved the symbol problem: AI programs finally had a language shaped like their data. It created two others. LISP was slow at arithmetic, and it had no standard, because, McCarthy writes, no organization ever tried to propagate it or agree on one.

For teams today: the interpreter was an accident of attention. When someone on your team turns a theory into a working tool on their own, give it a sponsor before the shape sets. Early shortcuts become permanent.

The Lab Years (1962-1979)

MIT, Stanford and BBN spread LISP through AI

By the 1960s the AI labs ran on Digital Equipment Corporation machines. McCarthy's history says the most important LISP implementations were those for the PDP-6 and its successor the PDP-10, and that the development of Interlisp (nee BBN LISP) and MACLISP helped make those machines the machines of choice for AI research. McCarthy himself moved to Stanford in 1962, where he built an AI project, and Seymour Papert joined Minsky as co-director of the MIT AI Lab in 1963, per Nilsson.

Nilsson writes that LISP soon replaced IPL as the primary language of AI research and applications. The programs of Minsky's students, including Evans, Raphael, Bobrow and Slagle, were written in it. Slagle's thesis on symbolic integration was directed by Minsky, and Paul Abrahams wrote a thesis on proof-checking, both noted in McCarthy's history. Terry Winograd's SHRDLU, which held typed English conversations about a simulated blocks world on a DEC PDP-10, wrote its knowledge as LISP procedures. Winograd's own explanation, quoted by Nilsson, is that LISP allows us to treat programs as data and data as programs. SHRDLU's story sits alongside the one told in the first AI chatbots. It also connects to natural language processing.

LISP also carried the rule-based programs that followed. When Edward Shortliffe built MYCIN at Stanford, he wanted BBN-LISP, soon to become Interlisp, and because it wasn't available at Stanford he used the SRI AI group's PDP-10, as Nilsson reports. The full story of that line is in the history of expert systems, and the wider school of thought is in the history of symbolic AI.

The era's other great output was the dialects themselves. Interlisp grew into a whole programming environment at Xerox PARC in the 1970s and 1980s, and the ACM honored it in 1992 with its Software System Award for pioneering work in programming environments. On the other side, Gerald Sussman and Guy Steele wrote a memo in December 1975 describing an interpreter for Scheme, a LISP-like language based on Church's lambda calculus. Its stated purpose, in the memo's words, was "tutorial."

Steele and Richard Gabriel's history of the language, presented in 1993, sums up the pattern. They argue Lisp's development was shaped less by technical planning than by institutional competition, showing off and hacker culture, producing two languages: a practical, messy, powerful industrial one, and a small, clean dialect for theorists. That describes this era well.

The lab years solved the adoption problem inside research. They created a fork problem outside it. By the late 1970s there were several dialects that could not share programs.

For teams today: a tool that all your experts share can make them fast and make newcomers feel like outsiders. If the whole team writes one dialect, document it for the next person.

The Lisp Machine Boom (early 1980s-1987)

Workstations built for one language, and a standard to unite its dialects

At MIT, researchers and students designed workstation-style computers that ran LISP efficiently. The Computer History Museum notes that the CADR machine was designed at MIT by Richard Greenblatt and Thomas Knight, and that the later LMI Lambda, introduced in 1986, was a specialized LISP computer based on it, faster and cheaper for AI work than conventional machines. Two companies sold them, Lisp Machines, Inc. and Symbolics, per Nilsson. The boom around them is the one described in the history of expert systems.

At the same time, the dialect problem finally got an answer. Steele signed the first edition of Common Lisp the Language in March 1984. By its own acknowledgments, the language was designed by a diverse group of people from many institutions, including MIT, Carnegie-Mellon, Stanford, Xerox PARC, Symbolics, Texas Instruments and Digital Equipment, and the design discussion ran for about thirty months, mostly by electronic mail over the ARPANET, roughly 3,000 messages in all, per the first-edition acknowledgments. The book describes Common Lisp as a new dialect of Lisp, a successor to MacLisp, influenced strongly by Zetalisp and to some extent by Scheme and Interlisp. A formal standard was needed next. After a December 1985 meeting in Boston, per the second edition's preface, the ANSI subcommittee X3J13 was formed.

On 15 March 1985, Symbolics registered symbolics.com, which the Centre for Computing History says made it the first .com domain. The domain was sold on 27 August 2009.

The boom solved the performance and portability worries that had held LISP back. It also tied the language's fortune to the fortune of a hardware business, and that business depended on a funding race.

For teams today: a specialized platform can be the right bet and still be the riskiest line in the budget. Ask what happens to the work if the vendor does not survive.

The Lisp Machine Winter (1987-1994)

Cheaper workstations and sagging expectations end the hardware bet

In 1987 AAAI membership peaked at 16,421, and then the turn came. Nilsson says the Lisp machine companies enjoyed initial success but gradually lost out to other providers of workstations. The same pressures that ended the expert-system boom, inflated expectations, a failure to deliver, and cheaper general-purpose computers, brought what he calls the AI winter. The specialized machine that had made LISP fast was no longer worth its premium.

Nilsson also reports that the winter lasted only a season, and that researchers moved on to new ideas, among them learning from data, which is the thread covered in machine learning and neural networks. The language itself did not vanish. Common Lisp kept going in software, and the committee kept working. The HyperSpec describes the resulting ANSI standard, X3.226-1994, as a standard for Common Lisp, not for the whole Lisp family, and says it added an object-oriented programming system, a condition handling system, an improved iteration facility and better support for large character sets. Steele's second edition of the book, whose preface records the committee's formation, had said Common Lisp had by then become the de facto standard for implementers.

What the winter solved is a lesson in separation. The language and the machine had been fused in the market. When the machine failed, the language had to stand alone, and it could. What it created was a smaller community and a reputation as a language of yesterday's AI.

For teams today: when a vendor category collapses, ask whether the underlying method still works. Keep a plan for moving your work to commodity hardware or software.

The Quiet Legacy (1994-present)

The language fades from AI, its ideas spread everywhere

After 1994, LISP stopped being the default language of AI and became something else: a source of ideas. McCarthy offered a reason for its staying power in the closing of his history. He thought it unlikely that the core would be replaced, because "static friction discourages purely notational changes," and he guessed LISP survived partly because its programs are lists, which he himself saw as a disadvantage in some respects. Replacements that dropped that property, like POP-2, lost the easy path from higher-level systems to a simple target language. He expected LISP to become obsolete only when a language dominates it in practice and gives a mathematical semantics for a broader set of features. The full passage is in his conclusions.

Some of what the language introduced is now unremarkable. The 1960 paper called conditional expressions believed to be new, and the automatic reclaiming of memory that it described is what today's managed languages do for their programmers. For how these ideas travelled into other languages, see the history of programming languages. Newer Lisps continue, among them Rich Hickey's Clojure, a Lisp for the Java platform whose history paper was accepted for the History of Programming Languages conference.

Meanwhile the field moved. The symbolic style that LISP served gave way to systems that learn from data, and the questions of artificial intelligence are now mostly tackled with machine learning. What survives from the LISP years is not the syntax. It is the habits: write down knowledge as data, make the system's own rules inspectable, and build tools that let one person change a running program.

For teams today: judge a technology by the ideas it leaves behind, not just by whether it is still fashionable.

Key People

Key Facts

• McCarthy's paper says LISP was developed for the IBM 704 by MIT's AI group to support the proposed Advice Taker.
• LISP's first interpreter came from Steve Russell hand coding eval, not from a plan.
• Early LISP numerical work ran 10 to 100 times slower than FORTRAN.
• The LISP 1.5 Programmer's Manual was published by MIT Press in 1962.
• Common Lisp's design discussion ran about thirty months, carried mostly by roughly 3,000 ARPANET messages.
• AAAI membership peaked at 16,421 in 1987.

The Pattern Behind the History

Across six eras, the same moves repeat. We call the sequence the Idea-Platform Split. It's our synthesis of the history above, not a research finding.

1. A narrow research need produces a notation. The Advice Taker needed sentences as data, and the list was the answer.
2. A small accident sets the shape. Russell's eval became the interpreter, and the plan for M-expressions faded.
3. Success breeds dialects. The labs forked the language until Common Lisp pulled the forks together.
4. A specialized platform bets everything on one idea. Lisp machines tied the language to a hardware business.
5. A cheaper platform absorbs the idea. Workstations won, and the language's concepts spread to others.

What It Teaches Teams Today

• Separate the idea from the machine. LISP survived the collapse of the Lisp machine market because the notation was independent of any computer, as the 1960 paper already said.
• Watch for accidents that become standards. The interpreter froze details McCarthy later called unfortunate, so review early shortcuts before they set.
• Standardize before the forks multiply. Common Lisp took about thirty months of discussion, then a formal committee that formed after a December 1985 meeting and produced a standard in 1994.
• Keep a path off specialized hardware. The Lisp machine companies lost out to general workstations.
• Credit the ideas, not just the tool. The language faded from AI while its habits stayed.

LISP taught the field that a language shaped like your data can carry a whole research program, and that the program can outlast the hardware. Read the history once, then ask of any new tool: which part is the idea, and which part is merely the machine it ships on?