In the summer of 1956, a small group of researchers gathered at Dartmouth College in Hanover, New Hampshire, for a two-month workshop that would change the trajectory of computing. The proposal for the workshop, written by a 29-year-old assistant professor of mathematics named John McCarthy, introduced a phrase that would define an entire field: “artificial intelligence.” McCarthy did not just name the discipline — he went on to build one of its most important tools. In 1958, he designed Lisp (LISt Processing), a programming language so far ahead of its time that features it introduced — garbage collection, recursion, first-class functions, dynamic typing — would take decades to appear in mainstream languages. Lisp was the second high-level programming language ever created (after Fortran), and while Fortran was designed to replace hand-coded assembly for numerical computation, Lisp was designed to do something far more ambitious: manipulate symbols, express mathematical logic, and serve as a medium for thinking about computation itself. More than 65 years later, Lisp dialects like Clojure and Racket continue to influence language design, and the core ideas McCarthy introduced remain central to both programming language theory and AI research.
Early Life and Path to Technology
John McCarthy was born on September 4, 1927, in Boston, Massachusetts. His father, John Patrick McCarthy, was an Irish immigrant who worked as a carpenter and union organizer. His mother, Ida Glatt McCarthy, was a Lithuanian Jewish immigrant who worked as a journalist. The family was not wealthy, but both parents valued education and intellectual pursuit. The household was politically active — both parents were members of the Communist Party during the 1930s — and young John grew up in an environment where ideas were taken seriously.
McCarthy was a prodigy in mathematics. He taught himself college mathematics from Caltech course materials as a teenager, and when he entered Caltech in 1944 at age 16, he was allowed to skip the first two years of math courses. He graduated with a B.S. in Mathematics in 1948 and went on to Princeton University for his Ph.D., which he completed in 1951 under Solomon Lefschetz. His doctoral thesis was on projection operators and partial differential equations — pure mathematics, not computing. But during his time at Princeton, McCarthy attended a symposium on automata theory organized by John von Neumann, and this exposure to the intersection of mathematics and computing set his direction for the rest of his career.
After brief positions at Princeton, Stanford, and Dartmouth, McCarthy joined MIT in 1958, where he founded the MIT Artificial Intelligence Laboratory (later the MIT CSAIL). In 1962, he moved to Stanford University, where he founded the Stanford Artificial Intelligence Laboratory (SAIL) and remained for the rest of his career until retirement in 2000.
The Breakthrough: Lisp
The Technical Innovation
McCarthy began designing Lisp in the fall of 1958 at MIT. His goal was not to create a practical programming language — it was to create a mathematical notation for programs that could also be executed by a computer. He wanted a language suitable for AI research, one that could handle symbolic computation, recursive data structures, and logical reasoning. The existing languages — Fortran (1957) and assembly — were designed for number crunching and had no facilities for the kind of symbolic manipulation AI demanded.
The design of Lisp was grounded in Alonzo Church’s lambda calculus, a formal system for expressing computation using function abstraction and application. McCarthy took the lambda calculus, added a few practical features (conditional expressions, recursion, lists as the fundamental data structure), and created something unprecedented: a language where code and data had the same structure. In Lisp, a program is a list. A list of data is also a list. This means programs can manipulate other programs as easily as they manipulate data — a property known as homoiconicity.
;; Lisp fundamentals — McCarthy's original design (1958)
;; Code and data share the same structure: the list
;; A simple function definition using lambda notation
(defun factorial (n)
(if (= n 0)
1
(* n (factorial (- n 1)))))
;; The above is both a program AND a data structure (a nested list)
;; This means programs can generate and manipulate other programs:
(defun make-adder (x)
(lambda (y) (+ x y)))
;; (make-adder 5) returns a NEW function that adds 5 to its argument
;; This was revolutionary in 1958 — most languages couldn't do this until the 2000s
(setq add-five (make-adder 5))
(funcall add-five 3) ;; Returns 8
;; McCarthy's eval function — the metacircular evaluator
;; A Lisp interpreter written in Lisp itself
;; This proved the language was powerful enough to define its own semanticsThe most remarkable aspect of Lisp’s design was the eval function. In his 1960 paper “Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I,” McCarthy showed that the entire Lisp language could be defined by a single function — eval — that takes a Lisp expression and returns its value. This eval function was itself written in Lisp. Steve Russell, one of McCarthy’s graduate students, realized that this eval function could be directly implemented on a computer, and he coded the first Lisp interpreter on an IBM 704. McCarthy later said he was surprised by this — he had intended eval as a theoretical demonstration, not a practical implementation.
Lisp introduced several features that are now standard in modern programming. Garbage collection — automatic memory management that frees programmers from manually allocating and deallocating memory — first appeared in the Lisp implementation. First-class functions (functions that can be passed as arguments, returned from other functions, and stored in variables) were fundamental to Lisp from day one. Conditional expressions (if-then-else) were invented by McCarthy for Lisp and later adopted by virtually every other language. Tree data structures, recursion as a primary control flow mechanism, and the read-eval-print loop (REPL) all originated in Lisp.
Why It Mattered
Lisp became the dominant language for AI research from the 1960s through the 1980s. MIT, Stanford, Carnegie Mellon, and virtually every major AI lab used Lisp as their primary tool. Special-purpose hardware — Lisp machines — was built by companies like Symbolics, Lisp Machines Inc., and Texas Instruments specifically to run Lisp efficiently. At its peak in the mid-1980s, the Lisp machine market was worth hundreds of millions of dollars.
The influence of Lisp on subsequent language design is immense. Scheme (1975), a minimalist Lisp dialect by Guy Steele and Gerald Sussman, introduced lexical scoping and influenced the design of JavaScript. Common Lisp (1984) standardized the language for industrial use. Clojure (2007), created by Rich Hickey, brought Lisp to the JVM and gained traction in the web development community. Racket, Emacs Lisp, and AutoLisp (used in AutoCAD) are all direct descendants. Even languages with no syntactic resemblance to Lisp — Python, Ruby, JavaScript, Haskell — have absorbed its ideas about garbage collection, dynamic typing, first-class functions, and closures.
Beyond Lisp: Other Contributions
McCarthy’s contributions extended far beyond Lisp. He coined the term “artificial intelligence” in the 1956 Dartmouth proposal and spent decades working on the fundamental problems of AI: knowledge representation, common-sense reasoning, and non-monotonic logic. His situation calculus (1963) provided a formal framework for reasoning about actions and change that remains a cornerstone of AI planning.
In 1961, McCarthy gave a speech at MIT’s centennial celebration in which he proposed the concept of utility computing — the idea that computer processing power could be sold as a metered service, like electricity or water. This was more than 40 years before Amazon Web Services launched in 2006. McCarthy essentially described cloud computing four decades before it existed.
He also invented time-sharing — the concept of multiple users sharing a single computer simultaneously. While others contributed to the development of time-sharing systems (including the Compatible Time-Sharing System at MIT and Multics), McCarthy was among the first to articulate the idea and push for its implementation. His advocacy led directly to the development of time-sharing at MIT, which influenced the creation of Unix and ultimately the modern multi-user computing model.
McCarthy spent significant effort on mathematical formalization of common-sense reasoning. He believed that true artificial intelligence required machines that could reason about the everyday world the way humans do — understanding that a cup of coffee on a desk would still be there five minutes later unless something moved it, for instance. His circumscription formalism (1980) addressed the “frame problem” in AI, and his work on non-monotonic reasoning opened a subfield of mathematical logic that remains active today.
McCarthy’s Stanford AI Lab (SAIL) became one of the most influential research environments in computing history during the 1960s and 1970s. SAIL pioneered early work in robotics, computer vision, natural language processing, and automated theorem proving. The lab’s “hand-eye” system (1966) was one of the first attempts to give a computer the ability to see and manipulate physical objects. SAIL alumni went on to found or lead major technology companies and research labs, including key figures at Xerox PARC, Sun Microsystems, and later Google and Tesla. The lab’s culture of combining theoretical rigor with ambitious system-building — inherited directly from McCarthy — influenced the trajectory of Silicon Valley itself.
McCarthy also made early contributions to what would now be called formal verification. His approach to proving programs correct using mathematical logic, articulated in papers from the 1960s, anticipated the formal methods movement that Dijkstra and others would develop more fully in the 1970s. He believed that the gap between mathematical specification and executable program should be as small as possible — an idea that influenced the design of specification languages and theorem provers used in safety-critical software development today.
Philosophy and Engineering Approach
Key Principles
McCarthy’s approach to computer science was fundamentally mathematical. He believed that programs should be treated as mathematical objects, subject to formal proof and logical analysis. This perspective shaped everything he built. Lisp’s design was not driven by hardware efficiency or ease of implementation — it was driven by mathematical elegance and expressive power.
He held strong views on the relationship between theory and practice. In his view, a programmer who could not express a problem in mathematical logic did not truly understand it. His Stanford lab was known for its theoretical rigor, which sometimes put it at odds with the more pragmatic approaches at MIT and elsewhere. But this rigor produced lasting results: Lisp’s theoretical foundations are why the language has survived for over six decades while most of its contemporaries are extinct.
McCarthy was also notable for his intellectual independence. He was one of the few prominent computer scientists to publicly advocate for nuclear energy, argue against certain environmental regulations, and challenge popular positions on technology policy. He maintained a personal website where he published essays on topics ranging from the sustainability of human progress to the ethics of AI. He believed strongly in human progress through technology and was skeptical of arguments that technology was inherently dangerous.
His approach to AI was distinctive in its emphasis on logic and formal reasoning, as opposed to the statistical and neural network approaches that dominate the field today. McCarthy believed that true AI required symbolic reasoning — the ability to manipulate concepts, not just patterns. While deep learning has achieved impressive practical results, many researchers are now reconsidering whether McCarthy’s emphasis on symbolic reasoning and common-sense knowledge may be necessary for the next breakthrough, as evidenced by hybrid approaches being explored by groups at DeepMind, OpenAI, and academic labs worldwide.
Legacy and Modern Relevance
McCarthy died on October 24, 2011, at the age of 84, at his home in Stanford, California. His death came just one day after the passing of Dennis Ritchie, the creator of C and Unix — a coincidence that led many in the computing community to reflect on how much modern technology depends on the work of this generation.
His legacy is multifaceted. Lisp dialects remain in active use: Clojure is used at companies like Walmart, Cisco, and many startups for backend systems. Emacs Lisp powers the Emacs text editor, which remains popular among developers. Common Lisp is used in industrial applications ranging from airline scheduling to music composition. Racket is used to teach programming at universities worldwide.
The term “artificial intelligence” that McCarthy coined in 1956 now describes an industry worth over $150 billion annually (as of 2024). The field has taken directions McCarthy might not have predicted — deep learning, large language models, generative AI — but the fundamental questions he posed about machine reasoning, knowledge representation, and common-sense understanding remain unsolved and central to the field’s future.
McCarthy’s concept of utility computing predicted cloud computing with extraordinary precision. His work on time-sharing laid the groundwork for every multi-user system in existence. And Lisp, the language he designed to think about computation, continues to demonstrate that mathematical elegance and practical utility are not opposites — they are allies.
He received the Turing Award in 1971 (at age 44, one of the youngest recipients), the Kyoto Prize in 1988, the National Medal of Science in 1990, and the Benjamin Franklin Medal in Computer and Cognitive Science in 2003. But perhaps his most enduring award is the survival of his ideas: every time a JavaScript developer uses a closure, a Python programmer relies on garbage collection, or a React developer passes a function as a prop, they are using concepts that John McCarthy gave the world.
Key Facts
- Born: September 4, 1927, Boston, Massachusetts, USA
- Died: October 24, 2011, Stanford, California, USA
- Known for: Creating Lisp, coining the term “artificial intelligence,” inventing garbage collection and time-sharing
- Key projects: Lisp (1958), Dartmouth AI Conference (1956), Stanford AI Lab (SAIL), situation calculus, circumscription
- Awards: Turing Award (1971), Kyoto Prize (1988), National Medal of Science (1990), Benjamin Franklin Medal (2003)
- Education: B.S. from Caltech (1948), Ph.D. from Princeton (1951)
Frequently Asked Questions
Who is John McCarthy?
John McCarthy (1927–2011) was an American computer scientist who created the Lisp programming language in 1958 and coined the term “artificial intelligence” in 1956. He founded AI laboratories at both MIT and Stanford, made foundational contributions to programming language theory, and proposed the concepts of time-sharing and utility computing (predicting cloud computing decades before it existed). He received the Turing Award in 1971 for his contributions to AI.
What did John McCarthy create?
McCarthy created Lisp (1958), the second high-level programming language ever built, which introduced garbage collection, first-class functions, conditional expressions, and the concept of code-as-data. He also coined the term “artificial intelligence,” invented the concept of time-sharing for computer systems, developed the situation calculus for AI reasoning, and proposed utility computing — essentially describing cloud computing in 1961, over four decades before AWS launched.
Why is John McCarthy important?
McCarthy is important because he founded the field of artificial intelligence as a formal discipline and created Lisp, a language whose innovations — garbage collection, recursion, first-class functions, dynamic typing, REPLs — are now standard features in virtually every modern programming language. His prediction of utility computing anticipated cloud computing by 40+ years. The AI field he named and helped create is now a multi-hundred-billion-dollar industry that is reshaping virtually every sector of the economy.
