Go Backsearch this site


1959, USA


J. McCarthy

papers & manuals
Paul Graham, ÄNSI Common Lisp", Prentice Hall, 1995, ISBN 0122708756


lisp, mcarthy


LISP (= LISt Processing), is a general purpose programming language, but it is especially know as one of the most important languages for the development of Artificial Intelligence. There are many dialects, but nowadays the language is standardized thanks to the industrial standard ANSI COMMON LISP. LISP is the second oldest programming language (after FORTRAN).

The development of LISP started in 1959 by the Artificial Intelligence Group at M.I.T. The language was developed in order to facilitate experiments with a proposed system called the Advice Taker. The language was able to be instructed to handle declarative and imperative sentences and exhibit common sense in carrying out these instructions. LISP is known as the first functional language and is widely used for Al and symbolic mathematics. LISP however is not a very general language and is only suited for general symbol manipulation and list processing.

LISP means LISt Processing and does symbolic manipulation.

Some simple examples:

  • (TIMES 12 4)
    • this will give 48
  • (QUOTIENT 48 8)
    • this will give 6
  • (MAX 2 7 13 9)
    • this will give 13

So LISP knows lists of "things" ("atoms") within parentheses. In the first example the list (TIMES 12 4) has 3 elements: TIMES, 12, 4. The function to be performed is the first element of the list. The other elements are called the arguments, necessary for the function to work with.

Lists themselves can be elements of other lists:

  • (PLUS (TIMES 3 6) (PLUS 2 2))
    • this will give (plus 18 4) so 22

The elements are called atoms, atoms that are not numbers are called symbolic atoms.

The function SET associates a list with a name:


The quote before the name means "just except the list that is following without trying to evolve it". The LENGTH function counts the number of elements in a list:

  • (LENGTH '(JAN KEES PIET MARY)) will give 4

The most famous functions are CAR and CDR. CAR gives the first element of a list, CDR will give the list, without the first element:

  • (CAR '(A B C)) will give A
  • (CDR '(I LOVE COMPUTERS)) will give the list (LOVE COMPUTERS)

LISP means manipulating lists, that's all. And because it is easy to make your own functions, there are a lot of different versions of LISP available. A simple example makes this clear:

  • In many Lisp versions (see the Links below on this page) the function (PLUS 2 2) does not exist. But the function (+ 2 2) does exist!
  • For those who want to have their (PLUS arg1 arg2) back it is easy to write a function that manipulates the list (PLUS 2 2) to the list (+ 2 2):
  • The function DEFUN defines new functions:
    • (DEFUN PLUS (arg1 arg2) (+ arg1 arg2))




A very nice description of the origins of LISP is written by John McCarthy . At the web site of The Association of LISP Users a lot of information can be found, including lots of references to CommonLisp, Scheme, Arc, AutoLISP, Dylan, Emacs Lisp. Other version can be found at e.g.OPENLISP.

Anyone who wants to start with LISP, can go to the website of CLISP or common-lisp. It is free-software that runs on a large variety of machines and operating systems. It mostly supports the Lisp described in the ANSI Common Lisp standard . Books, manuals, etc. can be found at the Paul Graham website



  • 1956 - 1958 - Development of LISP by J. McCarthy.
  • 1960's - In the early 60's the first publications and books arrived. Many different LISP programs were developed for many different machines, but there was no organization working on a standard.
  • 1970's - In the 70's special LISP Machines were developed. In those days the choice by many languages to expose implementation limitations were a choice of efficiency. But LISP was supposed to be a "pure" language and every operation had to be checked for exceptions. So LISP on conventional machines was slow. So special machines were created, optimized for LISP. Companies like Symbolics and Lisp Machines INC (LMI) were founded to build these machines. In the 80's Xerox, Texas Instruments and Integrated Inference Machines (IIM) joined the market. For a while they were very popular, but technology emerged fast.
  • 1980's - When the commercial AI market failed to deliver on its promises, Lisp was blamed as a scapegoat. In the late 1980s, many companies abandoned Lisp in favor of other languages, starting the so called "AI winter" . Although Lisp survived the crisis, some of the resulting prejudice and lack of information is still present in the computing field.
  • 1986 - SLUG, the Symbolic Lisp User Group started. It evolved into the Association of Lisp Users (ALU) in 1990. The ALU kept LISP alive by e.g. yearly conferences and meetings .
  • 1994 - In the early 1980s there were a number of increasingly diverging Lisp dialects. The user community started a major consolidation and standardization effort to design the Common Lisp dialect as a general purpose, industrial strength programming language. This work continued under the auspices of ANSI . When Common Lisp was formally approved in 1994, it became the first ANSI standard ( X3.226-1994 ) to incorporate object-oriented programming .





Go Back Last Updated on November 16, 2005 For suggestions please mail the editors 

Footnotes & References