HOME

TheInfoList




Lisp (historically LISP) is a family of
programming language A programming language is a formal language In logic, mathematics, computer science, and linguistics, a formal language consists of string (computer science), words whose symbol (formal), letters are taken from an alphabet (computer science) ...

programming language
s with a long history and a distinctive, fully parenthesized
prefix notation Polish notation (PN), also known as normal Polish notation (NPN), Łukasiewicz notation, Warsaw notation, Polish prefix notation or simply prefix notation, is a mathematical notation in which Operation (mathematics), operators ''precede'' their ...
. Originally specified in 1958, Lisp is the second-oldest
high-level programming language In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of , , ...
. Only
Fortran Fortran (; formerly FORTRAN) is a general-purpose, compiled language, compiled imperative programming, imperative programming language that is especially suited to numerical analysis, numeric computation and computational science, scientific com ...

Fortran
is older, by one year. Lisp has changed since its early days, and many
dialects The term dialect (from Latin Latin (, or , ) is a classical language belonging to the Italic languages, Italic branch of the Indo-European languages. Latin was originally spoken in the area around Rome, known as Latium. Through the power of th ...
have existed over its history. Today, the best-known general-purpose Lisp dialects are Racket,
Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language Lisp (historically LISP) is a family of programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) incl ...
, Scheme, and
Clojure Clojure (, like ''closure'') is a dynamic and functional dialect (computing), dialect of the Lisp (programming language), Lisp programming language on the Java (software platform), Java platform. Like other Lisp dialects, Clojure treats Homoic ...
. Lisp was originally created as a practical
mathematical notation Mathematical notation is a system of symbol A symbol is a mark, sign, or word In linguistics, a word of a spoken language can be defined as the smallest sequence of phonemes that can be uttered in isolation with semantic, objective or prag ...
for
computer program In imperative programming, a computer program is a sequence of instructions in a programming language that a computer can execute or interpret. In declarative programming, a ''computer program'' is a Set (mathematics), set of instructions. A comp ...
s, influenced by (though not originally derived from) the notation of
Alonzo Church Alonzo Church (June 14, 1903 – August 11, 1995) was an American American(s) may refer to: * American, something of, from, or related to the United States of America, commonly known as the United States The United States of America (USA ...
's
lambda calculus Lambda calculus (also written as ''λ''-calculus) is a formal system in mathematical logic for expressing computability, computation based on function Abstraction (computer science), abstraction and function application, application using variable N ...
. It quickly became the favored programming language for
artificial intelligence Artificial intelligence (AI) is intelligence Intelligence has been defined in many ways: the capacity for abstraction Abstraction in its main sense is a conceptual process where general rules and concept Concepts are defined as abstra ...

artificial intelligence
(AI) research. As one of the earliest programming languages, Lisp pioneered many ideas in
computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of , , and . Computer science ...
, including tree data structures,
automatic storage management Automatic Storage Management (ASM) is a feature provided by Oracle Corporation Oracle Corporation is an American multinational Multinational may refer to: * Multinational corporation, a corporate organization operating in multiple countries ...
,
dynamic typing In programming language A programming language is a formal language comprising a Instruction set architecture, set of instructions that produce various kinds of Input/output, output. Programming languages are used in computer programming to i ...
, conditionals,
higher-order function In mathematics Mathematics (from Ancient Greek, Greek: ) includes the study of such topics as quantity (number theory), mathematical structure, structure (algebra), space (geometry), and calculus, change (mathematical analysis, analysis). It ...
s,
recursion Recursion (adjective: ''recursive'') occurs when a thing is defined in terms of itself or of its type. Recursion is used in a variety of disciplines ranging from linguistics Linguistics is the scientific study of language, meaning tha ...
, the self-hosting compiler, and the
read–eval–print loop A read–eval–print loop (REPL), also termed an interactive toplevel or language shell, is a simple interactive computer programming Computer programming is the process of designing and building an executable computer program to accomplish ...
. The name ''LISP'' derives from "LISt Processor".
Linked list In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of , ...

Linked list
s are one of Lisp's major
data structure In computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of ...

data structure
s, and Lisp
source code In computing Computing is any goal-oriented activity requiring, benefiting from, or creating computing machinery. It includes the study and experimentation of algorithmic processes and development of both computer hardware , hardware and ...

source code
is made of lists. Thus, Lisp programs can manipulate source code as a data structure, giving rise to the
macro Macro (or MACRO) may refer to: Science and technology * Macroscopic The macroscopic scale is the length scale on which objects or phenomena are large enough to be visible with the naked eye, without magnifying optical instruments. It is the o ...
systems that allow programmers to create new syntax or new
domain-specific language A domain-specific language (DSL) is a computer languageComputer language is a formal language In logic, mathematics, computer science, and linguistics, a formal language consists of string (computer science), words whose symbol (formal), letters ...
s embedded in Lisp. The interchangeability of code and data gives Lisp its instantly recognizable syntax. All program code is written as ''
s-expression In computer programming Computer programming is the process of designing and building an executable computer program to accomplish a specific computing result or to perform a particular task. Programming involves tasks such as analysis, gener ...
s'', or parenthesized lists. A function call or syntactic form is written as a list with the function or operator's name first, and the arguments following; for instance, a function that takes three arguments would be called as .


History

John McCarthyJohn McCarthy may refer to: Government * John George MacCarthy (1829–1892), Member of Parliament for Mallow constituency, 1874–1880 * John McCarthy (Irish politician) (1862–1893), Member of Parliament for the Mid Tipperary constituency, 189 ...
developed Lisp in 1958 while he was at the
Massachusetts Institute of Technology Massachusetts Institute of Technology (MIT) is a Private university, private Land-grant university, land-grant research university in Cambridge, Massachusetts. Established in 1861, MIT has since played a key role in the development of modern ...
(MIT). McCarthy published its design in a paper in ''
Communications of the ACM ''Communications of the ACM'' is the monthly journal A journal, from the Old French ''journal'' (meaning "daily"), may refer to: *Bullet journal, a method of personal organizations *Diary, a record of what happened over the course of a day or othe ...
'' in 1960, entitled "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I". He showed that with a few simple operators and a notation for anonymous functions borrowed from Church, one can build a
Turing-complete In computability theory Computability theory, also known as recursion theory, is a branch of mathematical logic Mathematical logic, also called formal logic, is a subfield of mathematics Mathematics (from Ancient Greek, Greek: ) include ...
language for algorithms.
Information Processing Language Information Processing Language (IPL) is a programming language A programming language is a formal language comprising a Instruction set architecture, set of instructions that produce various kinds of Input/output, output. Programming languages ...
was the first
AI
AI
language, from 1955 or 1956, and already included many of the concepts, such as list-processing and recursion, which came to be used in Lisp. McCarthy's original notation used bracketed " M-expressions" that would be translated into
S-expression In computer programming Computer programming is the process of designing and building an executable computer program to accomplish a specific computing result or to perform a particular task. Programming involves tasks such as analysis, gener ...
s. As an example, the M-expression is equivalent to the S-expression . Once Lisp was implemented, programmers rapidly chose to use S-expressions, and M-expressions were abandoned. M-expressions surfaced again with short-lived attempts of
MLisp :''"MLisp" is also another name for Mocklisp Gosling Emacs (often shortened to "Gosmacs" or "gmacs") is a discontinued Emacs implementation written in 1981 by James Gosling James Arthur Gosling, often referred to as "Dr. Java", Order of ...
by Horace Enea and
CGOL CGOL (pronounced ''"see goll"'') is an alternative syntax featuring an extensible algebraic notation for the . It was designed for by and subsequently ported to . The notation of CGOL is a traditional , in the style of , rather than Lisp's tr ...
by
Vaughan Pratt Vaughan Pratt (born April 12, 1944) is a Professor Emeritus at Stanford University , mottoeng = "The wind of freedom blows" , type = Private university, Private research university , academic_affiliations = Association of American Universitie ...
. Lisp was first implemented by Steve Russell on an
IBM 704 The IBM 704, introduced by IBM International Business Machines Corporation (IBM) is an American multinational technology company headquartered in Armonk, New York, with operations in over 170 countries. The company began in 1911, founde ...
computer using
punched card A punched card (also punch cardSteven Pinker, in ''The Stuff of Thought'', Viking, 2007, p.362, notes the loss of ''-ed'' in pronunciation ''as it did in ice cream, mincemeat, and box set, formerly iced cream, minced meat, and boxed set.'' or p ...

punched card
s. Russell had read McCarthy's paper and realized (to McCarthy's surprise) that the Lisp ''eval'' function could be implemented in
machine code In computer programming Computer programming is the process of designing and building an executable computer program to accomplish a specific computing result or to perform a particular task. Programming involves tasks such as analysis, ge ...
. According to McCarthy, Paul Graham in '' Hackers & Painters'', p. 185:
"Steve Russell said, look, why don't I program this ''eval'' ... and I said to him, ho, ho, you're confusing theory with practice, this ''eval'' is intended for reading, not for computing. But he went ahead and did it. That is, he
compiled In computing, a compiler is a computer program that Translator (computing), translates computer code written in one programming language (the ''source'' language) into another language (the ''target'' language). The name "compiler" is primarily ...
the ''eval'' in my paper into
IBM 704 The IBM 704, introduced by IBM International Business Machines Corporation (IBM) is an American multinational technology company headquartered in Armonk, New York, with operations in over 170 countries. The company began in 1911, founde ...
machine code, fixing bug, and then advertised this as a Lisp interpreter, which it certainly was. So at that point Lisp had essentially the form that it has today ..."
The result was a working Lisp interpreter which could be used to run Lisp programs, or more properly, "evaluate Lisp expressions". Two assembly language macros for the
IBM 704 The IBM 704, introduced by IBM International Business Machines Corporation (IBM) is an American multinational technology company headquartered in Armonk, New York, with operations in over 170 countries. The company began in 1911, founde ...
became the primitive operations for decomposing lists: (''Contents of the Address part of Register'' number) and (''Contents of the Decrement part of Register'' number), where "register" refers to registers of the computer's
central processing unit A central processing unit (CPU), also called a central processor, main processor or just processor, is the electronic circuit 200px, A circuit built on a printed circuit board (PCB). An electronic circuit is composed of individual electroni ...

central processing unit
(CPU). Lisp dialects still use and ( and ) for the operations that return the first item in a list and the rest of the list, respectively. The first complete Lisp compiler, written in Lisp, was implemented in 1962 by Tim Hart and Mike Levin at MIT, and was able to be compiled by simply having an existing LISP interpreter interpret the compiler code, producing
machine code In computer programming Computer programming is the process of designing and building an executable computer program to accomplish a specific computing result or to perform a particular task. Programming involves tasks such as analysis, ge ...
output able to be executed at a 40-fold improvement in speed over that of the interpreter. This compiler introduced the Lisp model of
incremental compilation An incremental compiler is a kind of incremental computation applied to the field of compiler, compilation. Quite naturally, whereas ordinary compilers make so called clean build, that is, (re)build all program modules, incremental compiler recompi ...
, in which compiled and interpreted functions can intermix freely. The language used in Hart and Levin's memo is much closer to modern Lisp style than McCarthy's earlier code.
Garbage collection Waste collection is a part of the process of waste management. It is the transfer of solid waste from the point of use and disposal to the point of list of waste treatment technologies, treatment or landfill. Waste collection also includes the ...
routines were developed by MIT graduate student Daniel Edwards, prior to 1962. During the 1980s and 1990s, a great effort was made to unify the work on new Lisp dialects (mostly successors to
Maclisp Maclisp (or MACLISP, sometimes styled MacLisp or MacLISP) is a programming language, a Dialect (computing), dialect of the language Lisp (programming language), Lisp. It originated at the Massachusetts Institute of Technology's (MIT) Project MAC (f ...
such as ZetaLisp and NIL (New Implementation of Lisp) into a single language. The new language,
Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language Lisp (historically LISP) is a family of programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) incl ...
, was somewhat compatible with the dialects it replaced (the book ''
Common Lisp the Language ''Common Lisp the Language'' is an influential reference book by Guy L. Steele about a set of technical standards and programming languages named Common Lisp. History Before standardizing The first edition (Digital Press, 1984; ; 465 pages) was wri ...
'' notes the compatibility of various constructs). In 1994,
ANSI The American National Standards Institute (ANSI ) is a private non-profit organization A nonprofit organization (NPO), also known as a non-business entity, not-for-profit organization, or nonprofit institution, is a legal entity organiz ...
published the Common Lisp standard, "ANSI X3.226-1994 Information Technology Programming Language Common Lisp".


Timeline


Connection to artificial intelligence

Since inception, Lisp was closely connected with the
artificial intelligence Artificial intelligence (AI) is intelligence Intelligence has been defined in many ways: the capacity for abstraction Abstraction in its main sense is a conceptual process where general rules and concept Concepts are defined as abstra ...

artificial intelligence
research community, especially on
PDP-10 Digital Equipment Corporation Digital Equipment Corporation (DEC ), using the Digital, was a major American company in the from the 1960s to the 1990s. The company was co-founded by and in 1957. Olsen was president until forced to resi ...
The 36-bit word size of the
PDP-6 The PDP-6 (''Programmed Data Processor-6'') is a computer A computer is a machine that can be programmed to carry out sequences of arithmetic or logical operations automatically. Modern computers can perform generic sets of operations known ...
/
PDP-10 Digital Equipment Corporation Digital Equipment Corporation (DEC ), using the Digital, was a major American company in the from the 1960s to the 1990s. The company was co-founded by and in 1957. Olsen was president until forced to resi ...
was influenced by the usefulness of having two Lisp 18-bit pointers in a single word.
systems. Lisp was used as the implementation of the programming language Micro Planner, which was used in the famous AI system
SHRDLU SHRDLU was an early natural-language understanding Natural-language understanding (NLU) or natural-language interpretation (NLI) is a subtopic of natural-language processing in artificial intelligence that deals with machine reading comprehens ...
. In the 1970s, as AI research spawned commercial offshoots, the performance of existing Lisp systems became a growing issue.


Genealogy and variants

Over its sixty-year history, Lisp has spawned many variations on the core theme of an S-expression language. Moreover, each given dialect may have several implementations—for instance, there are more than a dozen implementations of
Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language Lisp (historically LISP) is a family of programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) incl ...
. Differences between dialects may be quite visible—for instance, Common Lisp uses the keyword defun to name a function, but Scheme uses define.Common Lisp: (defun f (x) x)
Scheme: (define f (lambda (x) x)) or (define (f x) x)
Within a dialect that is standardized, however, conforming implementations support the same core language, but with different extensions and libraries.


Historically significant dialects

* LISP 1 Accessed May 11, 2010. – First implementation. * LISP 1.5 – First widely distributed version, developed by McCarthy and others at MIT. So named because it contained several improvements on the original "LISP 1" interpreter, but was not a major restructuring as the planned LISP 2 would be. * Stanford LISP 1.6 – This was a successor to LISP 1.5 developed at the
Stanford AI Lab Stanford University , mottoeng = "The wind of freedom blows" , type = Private university, Private research university , academic_affiliations = Association of American Universities, AAUNational Space Grant College and Fellowship Program, Space ...
, and widely distributed to
PDP-10 Digital Equipment Corporation Digital Equipment Corporation (DEC ), using the Digital, was a major American company in the from the 1960s to the 1990s. The company was co-founded by and in 1957. Olsen was president until forced to resi ...
systems running the
TOPS-10 TOPS-10 System (''Timesharing / Total Operating System-10'') is a discontinued operating system An operating system (OS) is system software System software is software designed to provide a platform for other software. Examples of system sof ...
operating system. It was rendered obsolete by Maclisp and InterLisp. *
MACLISP Maclisp (or MACLISP, sometimes styled MacLisp or MacLISP) is a programming language, a Dialect (computing), dialect of the language Lisp (programming language), Lisp. It originated at the Massachusetts Institute of Technology's (MIT) Project MAC (f ...
– developed for MIT's
Project MAC MIT Computer Science and Artificial Intelligence Laboratory (CSAIL) is a research institute A research institute, research centre, or research center is an establishment founded for doing research. Research institutes may specialize in basic r ...
, MACLISP is a direct descendant of LISP 1.5. It ran on the PDP-10 and
Multics Multics ("Multiplexed Information and Computing Service") is an influential early time-sharing In computing Computing is any goal-oriented activity requiring, benefiting from, or creating computing machinery. It includes the study and experi ...

Multics
systems. MACLISP would later come to be called Maclisp, and is often referred to as MacLisp. The "MAC" in MACLISP is related neither to Apple's
Macintosh The Macintosh (mainly Mac since 1998) is a family of personal computer A personal computer (PC) is a multi-purpose computer whose size, capabilities, and price make it feasible for individual use. Personal computers are intended to be op ...

Macintosh
nor to
McCarthyMcCarthy (also spelled MacCarthy or McCarty) may refer to: * MacCarthy, a Gaelic Irish clan * McCarthy, Alaska, United States * McCarty, Missouri, United States * McCarthy Road, a road in Alaska * McCarthy (band), an indie pop band * Château MacCar ...
. *
Interlisp Interlisp (also seen with a variety of capitalizations) is a programming environment built around a version of the programming language Lisp. Interlisp development began in 1966 at Bolt, Beranek and Newman (renamed BBN Technologies) in Cambridge, ...
– developed at
BBN Technologies Raytheon BBN (originally Bolt Beranek and Newman Inc.) is an American research and development company, based next to Fresh Pond, Cambridge, Massachusetts, Fresh Pond in Cambridge, Massachusetts, United States. In 1966 the Franklin Institute a ...
for PDP-10 systems running the TENEX operating system, later adopted as a "West coast" Lisp for the Xerox Lisp machines as InterLisp-D. A small version called "InterLISP 65" was published for the
6502 The MOS Technology 6502 (typically pronounced "sixty-five-oh-two" or "six-five-oh-two") William Mensch and the moderator both pronounce the 6502 microprocessor as ''"sixty-five-oh-two"''. is an 8-bit In computer architecture In computer ...
-based
Atari 8-bit family The Atari 8-bit family is a series of 8-bit In computer architecture In computer engineering, computer architecture is a set of rules and methods that describe the functionality, organization, and implementation of computer systems. Some ...
computer line. For quite some time, Maclisp and InterLisp were strong competitors. *
Franz Lisp In computer programming Computer programming is the process of designing and building an executable computer program to accomplish a specific computing result or to perform a particular task. Programming involves tasks such as analysis, generat ...
– originally a
University of California, Berkeley The University of California, Berkeley (UC Berkeley, Berkeley, Cal, or California) is a public In public relations Public relations (PR) is the practice of managing and disseminating information from an individual or an organization ...

University of California, Berkeley
project; later developed by Franz Inc. The name is a humorous deformation of the name "
Franz Liszt Franz Liszt (; hu, Liszt Ferencz, link=no, in modern usage ''Liszt Ferenc'' ; 22 October 181131 July 1886) was a Hungarian composer, virtuoso A virtuoso (from Italian ''virtuoso'' or , "virtuous", Late Latin Late Latin ( la, Latinitas ...

Franz Liszt
", and does not refer to Allegro Common Lisp, the dialect of Common Lisp sold by Franz Inc., in more recent years. * XLISP, which
AutoLISP AutoLISP is a dialect The term dialect (from Latin Latin (, or , ) is a classical language belonging to the Italic languages, Italic branch of the Indo-European languages. Latin was originally spoken in the area around Rome, known as Latium. ...
was based on. * Standard Lisp and
Portable Standard Lisp Portable Standard Lisp (PSL) is a programming language A programming language is a formal language comprising a Instruction set architecture, set of instructions that produce various kinds of Input/output, output. Programming languages are used ...
were widely used and ported, especially with the Computer Algebra System REDUCE. * ZetaLisp, also termed Lisp Machine Lisp – used on the
Lisp machine Lisp machines are general-purpose computers designed to efficiently run Lisp Lisp (historically LISP) is a family of programming language A programming language is a formal language comprising a Instruction set architecture, set of instr ...

Lisp machine
s, direct descendant of Maclisp. ZetaLisp had a big influence on Common Lisp. *
LeLisp Le Lisp (also Le_Lisp and Le-Lisp) is a programming language, a Dialect (computing), dialect of the language Lisp (programming language), Lisp. It was developed at the French Institute for Research in Computer Science and Automation (INRIA), to be ...
is a French Lisp dialect. One of the first Interface Builders (called SOS InterfaceOutils de generation d’interfaces : etat de l’art et classification by H. El Mrabet
/ref>) was written in LeLisp. * Scheme (1975). *
Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language Lisp (historically LISP) is a family of programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) incl ...
(1984), as described by ''
Common Lisp the Language ''Common Lisp the Language'' is an influential reference book by Guy L. Steele about a set of technical standards and programming languages named Common Lisp. History Before standardizing The first edition (Digital Press, 1984; ; 465 pages) was wri ...
'' – a consolidation of several divergent attempts (ZetaLisp,
Spice Lisp Spice Lisp (Scientific Personal Integrated Computing Environment) is a programming language A programming language is a formal language In logic, mathematics, computer science, and linguistics, a formal language consists of string (computer ...
, NIL, and S-1 Lisp) to create successor dialects to Maclisp, with substantive influences from the Scheme dialect as well. This version of Common Lisp was available for wide-ranging platforms and was accepted by many as a
de facto standard A de facto standard is a custom or convention Convention may refer to: * Convention (norm), a custom or tradition, a standard of presentation or conduct ** Treaty, an agreement in international law * Convention (meeting), meeting of a (usually la ...
until the publication of ANSI Common Lisp (ANSI X3.226-1994). Among the most widespread sub-dialects of Common Lisp are
Steel Bank Common Lisp Steel Bank Common Lisp (SBCL) is a Free software, free Common Lisp implementation that features a high-performance native compiler, Unicode support and Thread (computer science), threading. The name "Steel Bank Common Lisp" is a reference to CMUC ...
(SBCL), CMU Common Lisp (CMU-CL), Clozure OpenMCL (not to be confused with Clojure!), GNU CLisp, and later versions of Franz Lisp; all of them adhere to the later ANSI CL standard (see below). * Dylan was in its first version a mix of Scheme with the Common Lisp Object System. *
EuLisp EuLisp is a statically and dynamically Scope (programming), scoped Lisp (programming language), Lisp dialect developed by a loose formation of industrial and academic Lisp users and developers from around Europe. The Standardization, standardizers ...
– attempt to develop a new efficient and cleaned-up Lisp. *
ISLISP ISLISP (also capitalized as ISLisp) is a programming language A programming language is a formal language In logic, mathematics, computer science, and linguistics, a formal language consists of string (computer science), words whose symbol ...
– attempt to develop a new efficient and cleaned-up Lisp. Standardized as ISO/IEC 13816:1997 and later revised as ISO/IEC 13816:2007: ''Information technology – Programming languages, their environments and system software interfaces – Programming language ISLISP''. * IEEE Scheme – IEEE standard, 1178–1990 (R1995). * ANSI
Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language Lisp (historically LISP) is a family of programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) incl ...
– an
American National Standards Institute The American National Standards Institute (ANSI ) is a private non-profit organization that oversees the development of Standardization, voluntary consensus standards for products, services, processes, systems, and personnel in the United Sta ...
(ANSI)
standard Standard may refer to: Flags * Colours, standards and guidons * Standard (flag), a type of flag used for personal identification Norm, convention or requirement * Standard (metrology), an object that bears a defined relationship to a unit of ...
for Common Lisp, created by subcommittee
X3J13 X3J13 is the name of a technical committee A committee or commission is a body of one or more persons subordinate to an assembly. A committee is not itself considered to be a form of assembly. Usually, the assembly sends matters into a committee ...
, chartered to begin with ''Common Lisp: The Language'' as a base document and to work through a public
consensus Consensus decision-making or consensus politics (often abbreviated to ''consensus'') is group decision-making processes in which participants develop and decide on proposals with the aim, or requirement, of acceptance by all. The focus on es ...
process to find solutions to shared issues of portability of programs and
compatibility Compatibility may refer to: Computing * Backward compatibility, in which newer devices can understand data generated by older devices * Compatibility card, an expansion card for hardware emulation of another device * Compatibility layer, compone ...
of Common Lisp implementations. Although formally an ANSI standard, the implementation, sale, use, and influence of ANSI Common Lisp has been and continues to be seen worldwide. *
ACL2 ACL2 ("A Computational Logic for Applicative Common Lisp") is a software Software is a collection of Instruction (computer science), instructions and data (computing), data that tell a computer how to work. This is in contrast to Computer hard ...
or "A Computational Logic for Applicative Common Lisp", an applicative (side-effect free) variant of Common LISP. ACL2 is both a programming language which can model computer systems, and a tool to help proving properties of those models. *
Clojure Clojure (, like ''closure'') is a dynamic and functional dialect (computing), dialect of the Lisp (programming language), Lisp programming language on the Java (software platform), Java platform. Like other Lisp dialects, Clojure treats Homoic ...
, a recent dialect of Lisp which compiles to the Java virtual machine and has a particular focus on concurrency. *
Game Oriented Assembly Lisp Game Oriented Assembly Lisp (GOAL) is a programming language, a dialect of the language Lisp (programming language), Lisp, made for video games developed by Andy Gavin and the ''Jak and Daxter'' team at the company Naughty Dog. It was written usin ...
(or GOAL) is a video game programming language developed by Andy Gavin and the
Jak and Daxter ''Jak and Daxter'' is a video game A video game is an electronic game that involves interaction with a user interface or input device such as a joystick, game controller, controller, computer keyboard, keyboard, or motion sensing device t ...
team at
Naughty Dog Naughty Dog, LLC (formerly JAM Software, Inc.) is an American First-party developer, first-party video game developer based in Santa Monica, California, Santa Monica, California. Founded by Andy Gavin and Jason Rubin in 1984, the studio was acqu ...
. It was written using Allegro Common Lisp and used in the development of the entire Jak and Daxter series of games. *Chialisp, a high-level dialect compiling down to CLVM, the on-chain programming environment in Chia blockchain


2000 to present

After having declined somewhat in the 1990s, Lisp has experienced a resurgence of interest after 2000. Most new activity has been focused around implementations of
Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language Lisp (historically LISP) is a family of programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) incl ...
, Scheme,
Emacs Lisp #REDIRECT Emacs Lisp Emacs Lisp is a Dialect (computing), dialect of the Lisp programming language used as a scripting language by Emacs (a text editor family most commonly associated with GNU Emacs and XEmacs). It is used for implementing most of ...
,
Clojure Clojure (, like ''closure'') is a dynamic and functional dialect (computing), dialect of the Lisp (programming language), Lisp programming language on the Java (software platform), Java platform. Like other Lisp dialects, Clojure treats Homoic ...
, and Racket, and includes development of new portable libraries and applications. Many new Lisp programmers were inspired by writers such as Paul Graham and
Eric S. Raymond Eric Steven Raymond (born December 4, 1957), often referred to as ESR, is an American software developer, open-source software advocate, and author of the 1997 essay and 1999 book ''The Cathedral and the Bazaar''. He wrote a guidebook for the R ...
to pursue a language others considered antiquated. New Lisp programmers often describe the language as an eye-opening experience and claim to be substantially more productive than in other languages. This increase in awareness may be contrasted to the " AI winter" and Lisp's brief gain in the mid-1990s. , there were eleven actively maintained Common Lisp implementations. Scieneer Common Lisp is a new commercial implementation forked from CMUCL with a first release in 2002. The
open source Open source is source code that is made freely available for possible modification and redistribution. Products include permission to use the source code, design documents, or content of the product. The open-source model is a decentralized softwa ...
community has created new supporting infrastructure:
CLiki CLiki is an Open-source software, open source wiki application written in Common Lisp, that was under development from 2002 to 2005. CLiki was first presented at the International Lisp Conference 2002. CLiki was the first wiki variant to introdu ...
is a wiki that collects Common Lisp related information, the Common Lisp directory lists resources, #lisp is a popular IRC channel and allows the sharing and commenting of code snippets (with support by lisppaste, an IRC bot written in Lisp), Planet Lisp collects the contents of various Lisp-related blogs, on LispForum users discuss Lisp topics, Lispjobs is a service for announcing job offers and there is a weekly news service, ''Weekly Lisp News''. ''Common-lisp.net'' is a hosting site for open source Common Lisp projects. Quicklisp is a library manager for Common Lisp. Fifty years of Lisp (1958–2008) was celebrated at LISP50@OOPSLA. There are regular local user meetings in Boston, Vancouver, and Hamburg. Other events include the European Common Lisp Meeting, the European Lisp Symposium and an International Lisp Conference. The Scheme community actively maintains Scheme (programming language)#Implementations, over twenty implementations. Several significant new implementations (Chicken, Gambit, Gauche, Ikarus, Larceny, Ypsilon) have been developed in the 2000s (decade). The Revised5 Report on the Algorithmic Language SchemeDocuments: Standards: R5RS
schemers.org (2012-01-11). Retrieved on 2013-07-17.
standard of Scheme was widely accepted in the Scheme community. The Scheme Requests for Implementation process has created a lot of quasi standard libraries and extensions for Scheme. User communities of individual Scheme implementations continue to grow. A new language standardization process was started in 2003 and led to the R6RS Scheme standard in 2007. Academic use of Scheme for teaching computer science seems to have declined somewhat. Some universities are no longer using Scheme in their computer science introductory courses; MIT now uses Python (programming language), Python instead of Scheme for its undergraduate
computer science Computer science deals with the theoretical foundations of information, algorithms and the architectures of its computation as well as practical techniques for their application. Computer science is the study of , , and . Computer science ...
program and MITx massive open online course. There are several new dialects of Lisp: Arc (programming language), Arc, Hy, Nu (programming language), Nu, Liskell, and LFE (programming language), LFE (Lisp Flavored Erlang). The parser for Julia (programming language), Julia is implemented in Femtolisp, a dialect of Scheme (Julia is inspired by Scheme, which in turn is a Lisp dialect). In October 2019, Paul_Graham_(programmer), Paul Graham release
a specification for Bel
"a new dialect of Lisp."


Major dialects

Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language Lisp (historically LISP) is a family of programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) incl ...
and Scheme represent two major streams of Lisp development. These languages embody significantly different design choices.
Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language Lisp (historically LISP) is a family of programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) incl ...
is a successor to
Maclisp Maclisp (or MACLISP, sometimes styled MacLisp or MacLISP) is a programming language, a Dialect (computing), dialect of the language Lisp (programming language), Lisp. It originated at the Massachusetts Institute of Technology's (MIT) Project MAC (f ...
. The primary influences were Lisp Machine Lisp, Maclisp, NIL, S-1 Lisp,
Spice Lisp Spice Lisp (Scientific Personal Integrated Computing Environment) is a programming language A programming language is a formal language In logic, mathematics, computer science, and linguistics, a formal language consists of string (computer ...
, and Scheme.Chapter 1.1.2, History, ANSI CL Standard It has many of the features of Lisp Machine Lisp (a large Lisp dialect used to program Lisp Machines), but was designed to be efficiently implementable on any personal computer or workstation. Common Lisp is a general-purpose programming language and thus has a large language standard including many built-in data types, functions, macros and other language elements, and an object system (Common Lisp Object System). Common Lisp also borrowed certain features from Scheme such as lexical scoping and lexical closures. Common Lisp implementations are available for targeting different platforms such as the LLVM,
Clasp is a Common Lisp implementation that interoperates with C++ and uses LLVM for just-in-time compilation (JIT) to native code.
the Java virtual machine,
"Armed Bear Common Lisp (ABCL) is a full implementation of the Common Lisp language featuring both an interpreter and a compiler, running in the JVM"
x86-64, PowerPC, Alpha, ARM, Motorola 68000, and MIPS,
Common Lisp Implementations: A Survey
and operating systems such as Windows, macOS, Linux, Solaris, FreeBSD, NetBSD, OpenBSD, Dragonfly BSD, and Heroku.
Comparison of actively developed Common Lisp implementations
Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language invented by Guy L. Steele, Jr. and Gerald Jay Sussman. It was designed to have exceptionally clear and simple semantics and few different ways to form expressions. Designed about a decade earlier than Common Lisp, Scheme is a more minimalist design. It has a much smaller set of standard features but with certain implementation features (such as tail-call optimization and full continuations) not specified in Common Lisp. A wide variety of programming paradigms, including imperative, functional, and message passing styles, find convenient expression in Scheme. Scheme continues to evolve with a series of standards (Revisedn Report on the Algorithmic Language Scheme) and a series of Scheme Requests for Implementation.
Clojure Clojure (, like ''closure'') is a dynamic and functional dialect (computing), dialect of the Lisp (programming language), Lisp programming language on the Java (software platform), Java platform. Like other Lisp dialects, Clojure treats Homoic ...
is a recent dialect of Lisp that targets mainly the Java virtual machine, and the Common Language Runtime (CLR), the Python (programming language), Python VM, the Ruby VM YARV, and compiling to JavaScript. It is designed to be a pragmatic general-purpose language. Clojure draws considerable influences from Haskell (programming language), Haskell and places a very strong emphasis on immutability.An In-Depth Look at Clojure Collections
Retrieved 2012-06-24
Clojure provides access to Java frameworks and libraries, with optional type hints and type inference, so that calls to Java can avoid reflection and enable fast primitive operations. Clojure is not designed to be backwards compatible with other Lisp dialects. Further, Lisp dialects are used as scripting languages in many applications, with the best-known being
Emacs Lisp #REDIRECT Emacs Lisp Emacs Lisp is a Dialect (computing), dialect of the Lisp programming language used as a scripting language by Emacs (a text editor family most commonly associated with GNU Emacs and XEmacs). It is used for implementing most of ...
in the Emacs editor,
AutoLISP AutoLISP is a dialect The term dialect (from Latin Latin (, or , ) is a classical language belonging to the Italic languages, Italic branch of the Indo-European languages. Latin was originally spoken in the area around Rome, known as Latium. ...
and later Visual Lisp in AutoCAD, Nyquist in Audacity (audio editor), Audacity, and Scheme in LilyPond. The potential small size of a useful Scheme interpreter makes it particularly popular for embedded scripting. Examples include SIOD and TinyScheme, both of which have been successfully embedded in the GIMP image processor under the generic name "Script-fu".Script-fu In GIMP 2.4
Retrieved 2009-10-29
LIBREP, a Lisp interpreter by John Harper originally based on the
Emacs Lisp #REDIRECT Emacs Lisp Emacs Lisp is a Dialect (computing), dialect of the Lisp programming language used as a scripting language by Emacs (a text editor family most commonly associated with GNU Emacs and XEmacs). It is used for implementing most of ...
language, has been embedded in the Sawfish (window manager), Sawfish window manager.librep
at Sawfish Wikia, retrieved 2009-10-29


Standardized dialects

Lisp has officially standardized dialects: Scheme (programming language)#R6RS, R6RS Scheme, Scheme (programming language)#R7RS, R7RS Scheme, IEEE Scheme, ANSI Common Lisp and ISO
ISLISP ISLISP (also capitalized as ISLisp) is a programming language A programming language is a formal language In logic, mathematics, computer science, and linguistics, a formal language consists of string (computer science), words whose symbol ...
.


Language innovations

Lisp was the first language where the structure of program code is represented faithfully and directly in a standard data structure—a quality much later dubbed "homoiconicity". Thus, Lisp functions can be manipulated, altered or even created within a Lisp program without lower-level manipulations. This is generally considered one of the main advantages of the language with regard to its expressive power, and makes the language suitable for syntactic macros and metacircular evaluation. A conditional using an ''if–then–else'' syntax was invented by McCarthy in a Fortran context. He proposed its inclusion in ALGOL, but it was not made part of the Algol 58 specification. For Lisp, McCarthy used the more general ''cond''-structure. Algol 60 took up ''if–then–else'' and popularized it. Lisp deeply influenced Alan Kay, the leader of the research team that developed Smalltalk at Xerox PARC; and in turn Lisp was influenced by Smalltalk, with later dialects adopting object-oriented programming features (inheritance classes, encapsulating instances, message passing, etc.) in the 1970s. The Flavors (programming language), Flavors object system introduced the concept of multiple inheritance and the mixin. The Common Lisp Object System provides multiple inheritance, multimethods with multiple dispatch, and first-class generic functions, yielding a flexible and powerful form of dynamic dispatch. It has served as the template for many subsequent Lisp (including Scheme) object systems, which are often implemented via a Metaobject#Metaobject Protocol, metaobject protocol, a Reflection (computer science), reflective Metacircular evaluator, metacircular design in which the object system is defined in terms of itself: Lisp was only the second language after Smalltalk (and is still one of the very few languages) to possess such a metaobject system. Many years later, Alan Kay suggested that as a result of the confluence of these features, only Smalltalk and Lisp could be regarded as properly conceived object-oriented programming systems. Lisp introduced the concept of Garbage collection (computer science), automatic garbage collection, in which the system walks the Heap (memory management), heap looking for unused memory. Progress in modern sophisticated garbage collection algorithms such as generational garbage collection was stimulated by its use in Lisp. Edsger W. Dijkstra in his 1972 Turing Award lecture said, :"With a few very basic principles at its foundation, it [LISP] has shown a remarkable stability. Besides that, LISP has been the carrier for a considerable number of in a sense our most sophisticated computer applications. LISP has jokingly been described as “the most intelligent way to misuse a computer”. I think that description a great compliment because it transmits the full flavour of liberation: it has assisted a number of our most gifted fellow humans in thinking previously impossible thoughts." (ACM Turing Award lecture). Largely because of its resource requirements with respect to early computing hardware (including early microprocessors), Lisp did not become as popular outside of the AI community as
Fortran Fortran (; formerly FORTRAN) is a general-purpose, compiled language, compiled imperative programming, imperative programming language that is especially suited to numerical analysis, numeric computation and computational science, scientific com ...

Fortran
and the ALGOL-descended C (programming language), C language. Because of its suitability to complex and dynamic applications, Lisp is enjoying some resurgence of popular interest in the 2010s.


Syntax and semantics

:''Note: This article's examples are written in
Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language Lisp (historically LISP) is a family of programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) incl ...
(though most are also valid in Scheme).''


Symbolic expressions (S-expressions)

Lisp is an expression oriented language. Unlike most other languages, no distinction is made between "expressions" and Statement (programming), "statements"; all code and data are written as expressions. When an expression is ''evaluated'', it produces a value (in Common Lisp, possibly multiple values), which can then be embedded into other expressions. Each value can be any data type. McCarthy's 1958 paper introduced two types of syntax: ''Symbolic expressions'' (
S-expression In computer programming Computer programming is the process of designing and building an executable computer program to accomplish a specific computing result or to perform a particular task. Programming involves tasks such as analysis, gener ...
s, sexps), which mirror the internal representation of code and data; and ''Meta expressions'' ( M-expressions), which express functions of S-expressions. M-expressions never found favor, and almost all Lisps today use S-expressions to manipulate both code and data. The use of parentheses is Lisp's most immediately obvious difference from other programming language families. As a result, students have long given Lisp nicknames such as ''Lost In Stupid Parentheses'', or ''Lots of Irritating Superfluous Parentheses''. However, the S-expression syntax is also responsible for much of Lisp's power: the syntax is extremely regular, which facilitates manipulation by computer. However, the syntax of Lisp is not limited to traditional parentheses notation. It can be extended to include alternative notations. For example, XMLisp is a Common Lisp extension that employs the Metaobject#Metaobject protocol, metaobject protocol to integrate S-expressions with the Extensible Markup Language (XML). The reliance on expressions gives the language great flexibility. Because Lisp function (programming), functions are written as lists, they can be processed exactly like data. This allows easy writing of programs which manipulate other programs (metaprogramming). Many Lisp dialects exploit this feature using macro systems, which enables extension of the language almost without limit.


Lists

A Lisp list is written with its elements separated by Whitespace character, whitespace, and surrounded by parentheses. For example, is a list whose elements are the three ''atoms'' , , and foo, . These values are implicitly typed: they are respectively two integers and a Lisp-specific data type called a "symbol", and do not have to be declared as such. The empty list is also represented as the special atom . This is the only entity in Lisp which is both an atom and a list. Expressions are written as lists, using Polish notation, prefix notation. The first element in the list is the name of a function, the name of a macro, a lambda expression or the name of a "special operator" (see below). The remainder of the list are the arguments. For example, the function returns its arguments as a list, so the expression (list 1 2 (quote foo)) evaluates to the list . The "quote" before the foo, in the preceding example is a "special operator" which returns its argument without evaluating it. Any unquoted expressions are recursively evaluated before the enclosing expression is evaluated. For example, (list 1 2 (list 3 4)) evaluates to the list . Note that the third argument is a list; lists can be nested.


Operators

Arithmetic operators are treated similarly. The expression (+ 1 2 3 4) evaluates to 10. The equivalent under infix notation would be "". Lisp has no notion of operators as implemented in Algol-derived languages. Arithmetic operators in Lisp are variadic functions (or ''n-ary''), able to take any number of arguments. A C-style '++' increment operator is sometimes implemented under the name incf giving syntax (incf x) equivalent to (setq x (+ x 1)), returning the new value of x. "Special operators" (sometimes called "special forms") provide Lisp's control structure. For example, the special operator takes three arguments. If the first argument is non-nil, it evaluates to the second argument; otherwise, it evaluates to the third argument. Thus, the expression (if nil (list 1 2 "foo") (list 3 4 "bar")) evaluates to . Of course, this would be more useful if a non-trivial expression had been substituted in place of . Lisp also provides logical operators and, or and not. The and and or operators do short-circuit evaluation and will return their first nil and non-nil argument respectively. (or (and "zero" nil "never") "James" 'task 'time) will evaluate to "James".


Lambda expressions and function definition

Another special operator, , is used to bind variables to values which are then evaluated within an expression. This operator is also used to create functions: the arguments to are a list of arguments, and the expression or expressions to which the function evaluates (the returned value is the value of the last expression that is evaluated). The expression (lambda (arg) (+ arg 1)) evaluates to a function that, when applied, takes one argument, binds it to and returns the number one greater than that argument. Lambda expressions are treated no differently from named functions; they are invoked the same way. Therefore, the expression ((lambda (arg) (+ arg 1)) 5) evaluates to . Here, we're doing a function application: we execute the anonymous function by passing to it the value 5. Named functions are created by storing a lambda expression in a symbol using the defun macro. (defun foo (a b c d) (+ a b c d)) defines a new function named in the global environment. It is conceptually similar to the expression: (setf (fdefinition 'f) #'(lambda (a) (block f b...))) where is a macro used to set the value of the first argument to a new function object. is a global function definition for the function named . is an abbreviation for special operator, returning a function object.


Atoms

In the original LISP there were two fundamental data types: atoms and lists. A list was a finite ordered sequence of elements, where each element is either an atom or a list, and an atom was a number or a symbol. A symbol was essentially a unique named item, written as an alphanumeric string in
source code In computing Computing is any goal-oriented activity requiring, benefiting from, or creating computing machinery. It includes the study and experimentation of algorithmic processes and development of both computer hardware , hardware and ...

source code
, and used either as a variable name or as a data item in symbolic processing. For example, the list contains three elements: the symbol , the list , and the number 2. The essential difference between atoms and lists was that atoms were immutable and unique. Two atoms that appeared in different places in source code but were written in exactly the same way represented the same object, whereas each list was a separate object that could be altered independently of other lists and could be distinguished from other lists by comparison operators. As more data types were introduced in later Lisp dialects, and programming styles evolved, the concept of an atom lost importance. Many dialects still retained the predicate ''atom'' for legacy compatibility, defining it true for any object which is not a cons.


Conses and lists

A Lisp list is implemented as a singly linked list. Each cell of this list is called a ''cons'' (in Scheme, a ''pair'') and is composed of two pointer (computer programming), pointers, called the ''car'' and ''cdr''. These are respectively equivalent to the and fields discussed in the article ''linked list''. Of the many data structures that can be built out of cons cells, one of the most basic is called a ''proper list''. A proper list is either the special (empty list) symbol, or a cons in which the points to a datum (which may be another cons structure, such as a list), and the points to another proper list. If a given cons is taken to be the head of a linked list, then its car points to the first element of the list, and its cdr points to the rest of the list. For this reason, the and functions are also called and when referring to conses which are part of a linked list (rather than, say, a tree). Thus, a Lisp list is not an atomic object, as an instance of a container class in C++ or Java would be. A list is nothing more than an aggregate of linked conses. A variable that refers to a given list is simply a pointer to the first cons in the list. Traversal of a list can be done by ''cdring down'' the list; that is, taking successive cdrs to visit each cons of the list; or by using any of several
higher-order function In mathematics Mathematics (from Ancient Greek, Greek: ) includes the study of such topics as quantity (number theory), mathematical structure, structure (algebra), space (geometry), and calculus, change (mathematical analysis, analysis). It ...
s to map a function over a list. Because conses and lists are so universal in Lisp systems, it is a common misconception that they are Lisp's only data structures. In fact, all but the most simplistic Lisps have other data structures, such as vectors (Array data type, arrays), hash tables, structures, and so forth.


S-expressions represent lists

Parenthesized S-expressions represent linked list structures. There are several ways to represent the same list as an S-expression. A cons can be written in ''dotted-pair notation'' as , where is the car and the cdr. A longer proper list might be written in dotted-pair notation. This is conventionally abbreviated as in ''list notation''. An improper listNB: a so-called "dotted list" is only one kind of "improper list". The other kind is the "circular list" where the cons cells form a loop. Typically this is represented using #n=(...) to represent the target cons cell that will have multiple references, and #n# is used to refer to this cons. For instance, (#1=(a b) . #1#) would normally be printed as ((a b) a b) (without circular structure printing enabled), but makes the reuse of the cons cell clear. #1=(a . #1#) cannot normally be printed as it is circular, although (a...) is sometimes displayed, the CDR of the cons cell defined by #1= is itself. may be written in a combination of the two – as for the list of three conses whose last cdr is (i.e., the list in fully specified form).


List-processing procedures

Lisp provides many built-in procedures for accessing and controlling lists. Lists can be created directly with the procedure, which takes any number of arguments, and returns the list of these arguments. (list 1 2 'a 3) ;Output: (1 2 a 3) (list 1 '(2 3) 4) ;Output: (1 (2 3) 4) Because of the way that lists are constructed from cons pairs, the procedure can be used to add an element to the front of a list. Note that the procedure is asymmetric in how it handles list arguments, because of how lists are constructed. (cons 1 '(2 3)) ;Output: (1 2 3) (cons '(1 2) '(3 4)) ;Output: ((1 2) 3 4) The procedure appends two (or more) lists to one another. Because Lisp lists are linked lists, appending two lists has Big O notation, asymptotic time complexity O(n) (append '(1 2) '(3 4)) ;Output: (1 2 3 4) (append '(1 2 3) '() '(a) '(5 6)) ;Output: (1 2 3 a 5 6)


Shared structure

Lisp lists, being simple linked lists, can share structure with one another. That is to say, two lists can have the same ''tail'', or final sequence of conses. For instance, after the execution of the following Common Lisp code: (setf foo (list 'a 'b 'c)) (setf bar (cons 'x (cdr foo))) the lists and are and respectively. However, the tail is the same structure in both lists. It is not a copy; the cons cells pointing to and are in the same memory locations for both lists. Sharing structure rather than copying can give a dramatic performance improvement. However, this technique can interact in undesired ways with functions that alter lists passed to them as arguments. Altering one list, such as by replacing the with a , will affect the other: (setf (third foo) 'goose) This changes to , but thereby also changes to – a possibly unexpected result. This can be a source of bugs, and functions which alter their arguments are documented as ''destructive'' for this very reason. Aficionados of functional programming avoid destructive functions. In the Scheme dialect, which favors the functional style, the names of destructive functions are marked with a cautionary exclamation point, or "bang"—such as (read ''set car bang''), which replaces the car of a cons. In the Common Lisp dialect, destructive functions are commonplace; the equivalent of is named for "replace car". This function is rarely seen, however, as Common Lisp includes a special facility, , to make it easier to define and use destructive functions. A frequent style in Common Lisp is to write code functionally (without destructive calls) when prototyping, then to add destructive calls as an optimization where it is safe to do so.


Self-evaluating forms and quoting

Lisp evaluates expressions which are entered by the user. Symbols and lists evaluate to some other (usually, simpler) expression – for instance, a symbol evaluates to the value of the variable it names; evaluates to . However, most other forms evaluate to themselves: if entering into Lisp, it returns . Any expression can also be marked to prevent it from being evaluated (as is necessary for symbols and lists). This is the role of the special operator, or its abbreviation (one quotation mark). For instance, usually if entering the symbol , it returns the value of the corresponding variable (or an error, if there is no such variable). To refer to the literal symbol, enter or, usually, . Both Common Lisp and Scheme also support the ''backquote'' operator (termed ''quasiquote'' in Scheme), entered with the character (Grave accent#Use in programming, grave accent). This is almost the same as the plain quote, except it allows expressions to be evaluated and their values interpolated into a quoted list with the comma ''unquote'' and comma-at ''splice'' operators. If the variable has the value then evaluates to , while evaluates to . The backquote is most often used in defining macro expansions.Quasiquotation in Lisp
, Alan Bawden
Self-evaluating forms and quoted forms are Lisp's equivalent of literals. It may be possible to modify the values of (mutable) literals in program code. For instance, if a function returns a quoted form, and the code that calls the function modifies the form, this may alter the behavior of the function on subsequent invocations. (defun should-be-constant () '(one two three)) (let ((stuff (should-be-constant))) (setf (third stuff) 'bizarre)) ; bad! (should-be-constant) ; returns (one two bizarre) Modifying a quoted form like this is generally considered bad style, and is defined by ANSI Common Lisp as erroneous (resulting in "undefined" behavior in compiled files, because the file-compiler can coalesce similar constants, put them in write-protected memory, etc.). Lisp's formalization of quotation has been noted by Douglas Hofstadter (in ''Gödel, Escher, Bach'') and others as an example of the philosophy, philosophical idea of self-reference.


Scope and closure

The Lisp family splits over the use of dynamic scoping, dynamic or static scoping, static (a.k.a. lexical) scope (programming), scope. Clojure, Common Lisp and Scheme make use of static scoping by default, while newLISP, Picolisp and the embedded languages in Emacs and AutoCAD use dynamic scoping. Since version 24.1, Emacs uses both dynamic and lexical scoping.


List structure of program code; exploitation by macros and compilers

A fundamental distinction between Lisp and other languages is that in Lisp, the textual representation of a program is simply a human-readable description of the same internal data structures (linked lists, symbols, number, characters, etc.) as would be used by the underlying Lisp system. Lisp uses this to implement a very powerful macro system. Like other macro languages such as the one defined by the C preprocessor (the macro preprocessor for the C (programming language), C, Objective-C and C++ programming languages), a macro returns code that can then be compiled. However, unlike C preprocessor macros, the macros are Lisp functions and so can exploit the full power of Lisp. Further, because Lisp code has the same structure as lists, macros can be built with any of the list-processing functions in the language. In short, anything that Lisp can do to a data structure, Lisp macros can do to code. In contrast, in most other languages, the parser's output is purely internal to the language implementation and cannot be manipulated by the programmer. This feature makes it easy to develop ''efficient'' languages within languages. For example, the Common Lisp Object System can be implemented cleanly as a language extension using macros. This means that if an application needs a different inheritance mechanism, it can use a different object system. This is in stark contrast to most other languages; for example, Java does not support multiple inheritance and there is no reasonable way to add it. In simplistic Lisp implementations, this list structure is directly interpreter (computing), interpreted to run the program; a function is literally a piece of list structure which is traversed by the interpreter in executing it. However, most substantial Lisp systems also include a compiler. The compiler translates list structure into machine code or bytecode for execution. This code can run as fast as code compiled in conventional languages such as C. Macros expand before the compilation step, and thus offer some interesting options. If a program needs a precomputed table, then a macro might create the table at compile time, so the compiler need only output the table and need not call code to create the table at run time. Some Lisp implementations even have a mechanism, eval-when, that allows code to be present during compile time (when a macro would need it), but not present in the emitted module.Time of Evaluation - Common Lisp Extensions
Gnu.org. Retrieved on 2013-07-17.


Evaluation and the read–eval–print loop

Lisp languages are often used with an interactive command line, which may be combined with an integrated development environment (IDE). The user types in expressions at the command line, or directs the IDE to transmit them to the Lisp system. Lisp ''reads'' the entered expressions, ''evaluates'' them, and ''prints'' the result. For this reason, the Lisp command line is called a ''
read–eval–print loop A read–eval–print loop (REPL), also termed an interactive toplevel or language shell, is a simple interactive computer programming Computer programming is the process of designing and building an executable computer program to accomplish ...
'' (REPL). The basic operation of the REPL is as follows. This is a simplistic description which omits many elements of a real Lisp, such as quoting and macros. The function accepts textual S-expressions as input, and parses them into an internal data structure. For instance, if you type the text at the prompt, translates this into a linked list with three elements: the symbol , the number 1, and the number 2. It so happens that this list is also a valid piece of Lisp code; that is, it can be evaluated. This is because the car of the list names a function—the addition operation. Note that a will be read as a single symbol. will be read as the number one hundred and twenty-three. will be read as the string "123". The function evaluates the data, returning zero or more other Lisp data as a result. Evaluation does not have to mean interpretation; some Lisp systems compile every expression to native machine code. It is simple, however, to describe evaluation as interpretation: To evaluate a list whose car names a function, first evaluates each of the arguments given in its cdr, then applies the function to the arguments. In this case, the function is addition, and applying it to the argument list yields the answer . This is the result of the evaluation. The symbol evaluates to the value of the symbol foo. Data like the string "123" evaluates to the same string. The list evaluates to the list (1 2 3). It is the job of the function to represent output to the user. For a simple result such as this is trivial. An expression which evaluated to a piece of list structure would require that traverse the list and print it out as an S-expression. To implement a Lisp REPL, it is necessary only to implement these three functions and an infinite-loop function. (Naturally, the implementation of will be complex, since it must also implement all special operators like or .) This done, a basic REPL is one line of code: . The Lisp REPL typically also provides input editing, an input history, error handling and an interface to the debugger. Lisp is usually evaluated eager evaluation, eagerly. In
Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language Lisp (historically LISP) is a family of programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) incl ...
, arguments are evaluated in applicative order ('leftmost innermost'), while in Scheme programming language, Scheme order of arguments is undefined, leaving room for optimization by a compiler.


Control structures

Lisp originally had very few control structures, but many more were added during the language's evolution. (Lisp's original conditional operator, , is the precursor to later structures.) Programmers in the Scheme dialect often express loops using tail recursion. Scheme's commonality in academic computer science has led some students to believe that tail recursion is the only, or the most common, way to write iterations in Lisp, but this is incorrect. All oft-seen Lisp dialects have imperative-style iteration constructs, from Scheme's loop to
Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language Lisp (historically LISP) is a family of programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) incl ...
's complex expressions. Moreover, the key issue that makes this an objective rather than subjective matter is that Scheme makes specific requirements for the handling of tail calls, and thus the reason that the use of tail recursion is generally encouraged for Scheme is that the practice is expressly supported by the language definition. By contrast, ANSI Common Lisp does not require3.2.2.3 Semantic Constraints
i

/ref> the optimization commonly termed a tail call elimination. Thus, the fact that tail recursive style as a casual replacement for the use of more traditional iteration constructs (such as , or ) is discouraged4.3. Control Abstraction (Recursion vs. Iteration) i
Tutorial on Good Lisp Programming Style
by Kent Pitman and Peter Norvig, August, 1993.
in Common Lisp is not just a matter of stylistic preference, but potentially one of efficiency (since an apparent tail call in Common Lisp may not compile as a simple Branch (computer science), jump) and program correctness (since tail recursion may increase stack use in Common Lisp, risking stack overflow). Some Lisp control structures are ''special operators'', equivalent to other languages' syntactic keywords. Expressions using these operators have the same surface appearance as function calls, but differ in that the arguments are not necessarily evaluated—or, in the case of an iteration expression, may be evaluated more than once. In contrast to most other major programming languages, Lisp allows implementing control structures using the language. Several control structures are implemented as Lisp macros, and can even be macro-expanded by the programmer who wants to know how they work. Both Common Lisp and Scheme have operators for non-local control flow. The differences in these operators are some of the deepest differences between the two dialects. Scheme supports ''re-entrant continuations'' using the procedure, which allows a program to save (and later restore) a particular place in execution. Common Lisp does not support re-entrant continuations, but does support several ways of handling escape continuations. Often, the same algorithm can be expressed in Lisp in either an imperative or a functional style. As noted above, Scheme tends to favor the functional style, using tail recursion and continuations to express control flow. However, imperative style is still quite possible. The style preferred by many Common Lisp programmers may seem more familiar to programmers used to structured languages such as C, while that preferred by Schemers more closely resembles pure-functional languages such as Haskell (programming language), Haskell. Because of Lisp's early heritage in list processing, it has a wide array of higher-order functions relating to iteration over sequences. In many cases where an explicit loop would be needed in other languages (like a loop in C) in Lisp the same task can be accomplished with a higher-order function. (The same is true of many functional programming languages.) A good example is a function which in Scheme is called and in Common Lisp is called . Given a function and one or more lists, applies the function successively to the lists' elements in order, collecting the results in a new list: (mapcar #'+ '(1 2 3 4 5) '(10 20 30 40 50)) This applies the function to each corresponding pair of list elements, yielding the result .


Examples

Here are examples of Common Lisp code. The basic "Hello, World!" program: (print "Hello, World!") Lisp syntax lends itself naturally to recursion. Mathematical problems such as the enumeration of recursively defined sets are simple to express in this notation. For example, to evaluate a number's factorial: (defun factorial (n) (if (zerop n) 1 (* n (factorial (1- n))))) An alternative implementation takes less stack space than the previous version if the underlying Lisp system optimizes tail recursion: (defun factorial (n &optional (acc 1)) (if (zerop n) acc (factorial (1- n) (* acc n)))) Contrast the examples above with an iterative version which uses
Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language Lisp (historically LISP) is a family of programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) incl ...
's macro: (defun factorial (n) (loop for i from 1 to n for fac = 1 then (* fac i) finally (return fac))) The following function reverses a list. (Lisp's built-in ''reverse'' function does the same thing.) (defun -reverse (list) (let ((return-value)) (dolist (e list) (push e return-value)) return-value))


Object systems

Various object systems and models have been built on top of, alongside, or into Lisp, including: * The Common Lisp Object System, CLOS, is an integral part of ANSI Common Lisp. CLOS descended from New Flavors and CommonLOOPS. ANSI Common Lisp was the first standardized object-oriented programming language (1994, ANSI X3J13). * ObjectLisppg 17 of Bobrow 1986 or Object Lisp, used by Lisp Machines Incorporated and early versions of Macintosh Common Lisp * LOOPS (Lisp Object-Oriented Programming System) and the later CommonLOOPS * Flavors (computer science), Flavors, built at Massachusetts Institute of Technology, MIT, and its descendant New Flavors (developed by Symbolics). * KR (short for Knowledge Representation), a Constraint satisfaction, constraints-based object system developed to aid the writing of Garnet, a GUI library for
Common Lisp Common Lisp (CL) is a dialect of the Lisp programming language Lisp (historically LISP) is a family of programming language A programming language is a formal language In mathematics Mathematics (from Ancient Greek, Greek: ) incl ...
. * Knowledge Engineering Environment (KEE) used an object system called UNITS and integrated it with an inference engineVeitch, p 108, 1988 and a Truth maintenance systems, truth maintenance system (ATMS).


See also

* Self-modifying code


References


Further reading

* * * *
My Lisp Experiences and the Development of GNU Emacs
transcription (linguistics), transcript of Richard Stallman's speech, 28 October 2002, at the International Lisp Conference * * ** Article largely based on the ''LISP - A Simple Introduction'' chapter: *


External links

;History
History of Lisp
John McCarthyJohn McCarthy may refer to: Government * John George MacCarthy (1829–1892), Member of Parliament for Mallow constituency, 1874–1880 * John McCarthy (Irish politician) (1862–1893), Member of Parliament for the Mid Tipperary constituency, 189 ...
's history of 12 February 1979
Lisp History
– Herbert Stoyan's history compiled from the documents (acknowledged by McCarthy as more complete than his own, see
McCarthy's history links

History of LISP at the Computer History Museum
;Associations and meetings
Association of Lisp Users

European Common Lisp Meeting

European Lisp Symposium

International Lisp Conference
; Books and tutorials *

', a comic-book style introductory tutorial *

', a free book by Paul Graham *
Practical Common Lisp
', freeware edition by Peter Seibel
Lisp for the web

Land of Lisp

Let over Lambda
; Interviews
Oral history interview with John McCarthy
at Charles Babbage Institute, University of Minnesota, Minneapolis. McCarthy discusses his role in the development of time-sharing at the Massachusetts Institute of Technology. He also describes his work in artificial intelligence (AI) funded by the Advanced Research Projects Agency, including logic-based AI (LISP) and robotics.
Interview
with Richard P. Gabriel (Podcast) ;Resources
CLiki: the Common Lisp wiki

The Common Lisp Directory
(via the Wayback Machine; archived fro
the original

Lisp FAQ Index

lisppaste

Planet Lisp

Weekly Lisp News

newLISP - A modern, general-purpose scripting language
* {{DEFAULTSORT:Lisp Programming Language Lisp (programming language), Academic programming languages American inventions Articles with example Lisp (programming language) code Dynamically typed programming languages Extensible syntax programming languages Functional languages Lisp programming language family, Programming languages Programming languages created in 1958