FACTOID # 27: If you're itching to live in a trailer park, hitch up your home and head to South Carolina, where a whopping 18% of residences are mobile homes.
 
 Home   Encyclopedia   Statistics   States A-Z   Flags   Maps   FAQ   About 
   
 
WHAT'S NEW
 

SEARCH ALL

FACTS & STATISTICS    Advanced view

Search encyclopedia, statistics and forums:

 

 

(* = Graphable)

 

 


Encyclopedia > Lisp programming language
Lisp
Paradigm: multi-paradigm: object-oriented, functional, procedural
Appeared in: 1958
Designed by: John McCarthy
Developer: Steve Russell, Tim Hart, and Mike Levin
Typing discipline: dynamic, strong
Dialects: Common Lisp, Scheme, Emacs lisp
Influenced: Logo, Smalltalk, Scheme, CLOS, Dylan

Lisp is a family of computer programming languages with a long history and a distinctive fully-parenthesized syntax. Originally specified in 1958, Lisp is the second-oldest high-level programming language in widespread use today; only Fortran is older. Like Fortran, Lisp has changed a great deal since its early days, and a number of dialects have existed over its history. Today, the most widely-known general-purpose Lisp dialects are Common Lisp and Scheme. A programming paradigm is a paradigmatic style of programming (compare with a methodology, which is a paradigmatic style of doing software engineering). ... A multiparadigm programming language is a programming language that supports more than one programming paradigm. ... In computer science, object-oriented programming is a computer programming paradigm. ... Functional programming is a programming paradigm that conceives computation as the evaluation of mathematical functions and avoids state and mutable data. ... This article or section does not cite its references or sources. ... 1958 (MCMLVIII) was a common year starting on Wednesday of the Gregorian calendar. ... John McCarthy (born September 4, 1927, in Boston, Massachusetts, sometimes known affectionately as Uncle John McCarthy), is a prominent computer scientist who received the Turing Award in 1971 for his major contributions to the field of Artificial Intelligence. ... Steve Russel created the first videogame, Spacewar at the Tech Model Railroad Club at the MIT. Categories: Substubs ... Tim Hart (born 9th January, 1948) is a retired English folk singer, most well known as a founding member of Steeleye Span. ... In computer science, a type system defines how a programming language classifies values and expressions into types, how it can manipulate those types and how they interact. ... On computer science, a datatype (often simply type) is a name or label for a set of values and some operations which can be performed on that set of values. ... In computing, strongly-typed, when applied to a programming language, is used to describe how the language handles datatypes. ... Common Lisp, commonly abbreviated CL, is a dialect of the Lisp programming language, standardised by ANSI X3. ... Scheme is a multi-paradigm programming language and a dialect of Lisp which supports functional and procedural programming. ... Emacs Lisp is a dialect of the Lisp programming language used by the GNU Emacs and XEmacs text editors (which we will collectively refer to as Emacs in this article. ... Logo turtle graphic The Logo programming language is a functional programming language. ... Smalltalk is an object-oriented, dynamically typed, reflective programming language. ... Scheme is a multi-paradigm programming language and a dialect of Lisp which supports functional and procedural programming. ... The Common Lisp Object System, a powerful system for object-oriented programming which forms part of Common Lisp. ... The Dylan programming language (pronounced , like the name) is functional, object-oriented, reflective and dynamic. ... A Lego RCX Computer is an example of an embedded computer used to control mechanical devices. ... A programming language is an artificial language that can be used to control the behavior of a machine (often a computer). ... 1958 (MCMLVIII) was a common year starting on Wednesday of the Gregorian calendar. ... A high-level programming language is a programming language that, in comparison to low-level programming languages, may be more abstract, easier to use, or more portable across platforms. ... FORTRAN[1] is a general-purpose[2], procedural[3], imperative programming language that is especially suited to numeric computation and scientific computing. ... A dialect of a programming language is a (relatively small) variation or extension of the language that does not change its intrinsic nature. ... Common Lisp, commonly abbreviated CL, is a dialect of the Lisp programming language, standardised by ANSI X3. ... Scheme is a multi-paradigm programming language and a dialect of Lisp which supports functional and procedural programming. ...


Lisp was originally created as a practical mathematical notation for computer programs, based on Alonzo Church's lambda calculus. It quickly became the favored programming language for artificial intelligence research. As one of the earliest programming languages, Lisp pioneered many ideas in computer science, including tree data structures, automatic storage management, dynamic typing, object-oriented programming, and the self-hosting compiler. Alonzo Church (June 14, 1903 – August 11, 1995) was an American mathematician and logician who was responsible for some of the foundations of theoretical computer science. ... The lambda calculus is a formal system designed to investigate function definition, function application, and recursion. ... Hondas intelligent humanoid robot AI redirects here. ... In computer science, a tree is a widely-used computer data structure that emulates a tree structure with a set of linked nodes. ... In computer science, garbage collection (also known as GC) is a form of automatic memory management. ... In computer science, a datatype or data type (often simply a type) is a name or label for a set of values and some operations which one can perform on that set of values. ... In computer science, object-oriented programming is a computer programming paradigm. ... A diagram of the operation of a typical multi-language compiler. ...


The name Lisp derives from "List Processing". Linked lists are one of Lisp languages' major data structures, and Lisp source code is itself made up of lists. As a result, Lisp programs can manipulate source code as a data structure, giving rise to the macro systems that allow programmers to create new syntax or even new "little languages" embedded in Lisp. In computer science, a linked list is one of the fundamental data structures used in computer programming. ... A binary tree, a simple type of branching linked data structure. ... Source code (commonly just source or code) is any series of statements written in some human-readable computer programming language. ... ... Little languages are small domain specific programming languages developed for a narrow problem domain. ...


The interchangeability of code and data also give Lisp its instantly recognizable syntax. All program code is written as s-expressions, 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: (f x y z). An S-expression (S stands for symbolic) is a convention for representing data or an expression in a computer program in a text form. ...

Contents


The invention of Lisp: 1958-1962

Lisp was invented by John McCarthy in 1958 while he was at MIT. McCarthy published its design in a paper in Communications of the ACM in 1960, entitled "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I".[2] (Part II was never published.) He showed that with a few simple operators and a notation for functions, one can build a Turing-complete language for algorithms. John McCarthy (born September 4, 1927, in Boston, Massachusetts, sometimes known affectionately as Uncle John McCarthy), is a prominent computer scientist who received the Turing Award in 1971 for his major contributions to the field of Artificial Intelligence. ... 1958 (MCMLVIII) was a common year starting on Wednesday of the Gregorian calendar. ... The Massachusetts Institute of Technology, or MIT, is a private research university located in the city of Cambridge, Massachusetts, USA. Its mission and culture are guided by an emphasis on teaching and research grounded in practical applications of science and technology. ... Communications of the ACM (CACM) is the flagship monthly magazine of the Association for Computing Machinery. ... 1960 (MCMLX) was a leap year starting on Friday (the link is to a full 1960 calendar). ... In computability theory a programming language or any other logical system is called Turing-complete if it has a computational power equivalent to a universal Turing machine. ...


Lisp was first implemented by Steve Russell on an IBM 704 computer. Russell had read McCarthy's paper, and realized (to McCarthy's surprise) that the eval function could be implemented as a Lisp interpreter. Steve Russel created the first videogame, Spacewar at the Tech Model Railroad Club at the MIT. Categories: Substubs ... The IBM 704, the first mass-produced computer with floating point arithmetic hardware, was introduced by IBM in April, 1956. ...


The first complete Lisp compiler, written in Lisp, was implemented in 1962 by Tim Hart and Mike Levin at MIT. (AI Memo 39, 767 kB PDF.) This compiler introduced the Lisp model of incremental compilation, 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. 1962 (MCMLXII) was a common year starting on Monday (the link is to a full 1962 calendar). ...


Curiosities of the early history

Information Processing Language was the first 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. Information Processing Language (IPL) was a programming language developed by Allen Newell, Cliff Shaw and Herbert Simon at RAND Corporation and the Carnegie Institute of Technology from about 1956. ...


McCarthy's original notation used bracketed "M-expressions" that would be translated into S-expressions. As an example, the M-expression car[cons[A,B]] is equivalent to the S-expression (car (cons A B)). 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[3] by Horace Enea and CGOL by Vaughan Pratt. M-Expressions are so-called meta-expressions which were intended to be used in Lisp. ... Vaughan Pratt is Professor Emeritus of Computer Science at Stanford University. ...


Two assembly language macros for the IBM 704 became the primitive operations for decomposing lists: car (Contents of Address Register) and cdr (Contents of Decrement Register). Lisp dialects still use car and cdr (pronounced: [kɑr] and ['kədər]) for the operations that return the first item in a list and the rest of the list respectively. ... Introduced in the Lisp programming language, car (IPA [kar], just like the English word car) and cdr (IPA [kÊŒ dÉ™r] or [ku dÉ™r]) are primitive operations upon linked lists composed of cons cells. ... Introduced in the Lisp programming language, car (IPA [kar], just like the English word car) and cdr (IPA [kÊŒ dÉ™r] or [ku dÉ™r]) are primitive operations upon linked lists composed of cons cells. ... Introduced in the Lisp programming language, car (IPA [kar], just like the English word car) and cdr (IPA [kÊŒ dÉ™r] or [ku dÉ™r]) are primitive operations upon linked lists composed of cons cells. ... Introduced in the Lisp programming language, car (IPA [kar], just like the English word car) and cdr (IPA [kÊŒ dÉ™r] or [ku dÉ™r]) are primitive operations upon linked lists composed of cons cells. ... Symbols of the International Phonetic Alphabet as used for English. ...


Lisp and AI

Since its inception, Lisp was closely connected with the artificial intelligence research community, especially on PDP-10[1] systems. Lisp was used as the implementation of the programming language Micro Planner that was the foundation for the famous AI system SHRDLU. In the 1970s, as AI research spawned commercial offshoots, the performance of existing Lisp systems became a growing issue. Hondas intelligent humanoid robot AI redirects here. ... The PDP-10 was a computer manufactured by Digital Equipment Corporation (DEC) from the late 1960s on; the name stands for Programmed Data Processor model 10. It was the machine that made time-sharing common; it looms large in hacker folklore because of its adoption in the 1970s by many... Planner (often seen in publications as PLANNER) is a programming language designed by Carl Hewitt at MIT, and first published in 1969. ... SHRDLU [1] was an early natural language understanding computer program, developed by Terry Winograd at MIT from 1968-1970. ... The 1970s decade refers to the years from 1970 to 1979, inclusive. ...


Partly because of garbage collection and partly because of its representation of internal structures, Lisp became difficult to run on the memory-limited stock hardware of the day. (The specific garbage collection routines for LISP were coded by then-MIT graduate student Daniel Edwards. This was a significant accomplishment because it made it practical to run Lisp on any general-purpose computing system.) This led to the creation of LISP machines: dedicated hardware for running Lisp environments and programs. Along with modern compiler construction techniques, gigantic computer capacities (by the standards of the 1970s) have made this specialization unnecessary, so Lisp environments are now available without dedicated hardware. In computer science, garbage collection (also known as GC) is a form of automatic memory management. ... The original Lisp machine built by Greenblatt and Knight Lisp machines were general-purpose computers designed (usually through hardware support) to efficiently run Lisp as their main software language. ...


During the 1980s and 1990s, a great effort was made to unify the numerous Lisp dialects (most notably, InterLisp, Maclisp, ZetaLisp, and Franz Lisp) into a single language. The new language, Common Lisp, was essentially a compatible subset of the dialects it replaced. In 1994, ANSI published the Common Lisp standard, "ANSI X3.226-1994 Information Technology Programming Language Common Lisp." By that time the world market for Lisp was much smaller than it is today. The examples and perspective in this article or section may not represent a worldwide view. ... See also 1990s, the band The 1990s decade refers to the years from 1990 to 1999, inclusive, sometimes informally including popular culture from the very late 1980s and from 2000 and beyond. ... Interlisp (also seen with a variety of capitalizations) was a version of the Lisp programming language originally developed in 1967 at Bolt, Beranek and Newman in Cambridge, Massachusetts. ... MacLisp is a dialect of the Lisp programming language. ... ZetaLisp was the name Symbolics gave to their dialect of Lisp on their Lisp Machine models, to distinguish it from the MIT version. ... Franz Lisp, written at UC Berkeley by the students of Professor Richard J. Fateman, was a Lisp system based larged on Maclisp, but written specifically to be a host for running Macsyma on a Digital Equipment Corp (DEC) VAX. It appeared on the scene at the end of 1978 shortly... Common Lisp, commonly abbreviated CL, is a dialect of the Lisp programming language, standardised by ANSI X3. ... 1994 (MCMXCIV) was a common year starting on Saturday of the Gregorian calendar, and was designated as the International Year of the Family and the International Year of the Sport and the Olympic Ideal by United Nations. ... The American National Standards Institute (ANSI) is a private, non-profit standards organization that produces industrial standards in the United States. ...


Lisp today

Having declined somewhat in the 1990s, Lisp has experienced a regrowth of interest since 2000. Most new activity is focused around open source implementations of Common Lisp, and includes the development of new portable libraries and applications. Tiobe Software, which ranks programming languages' popularity by measuring online discussions, ranks Lisp as the #16 programming language in August 2006. [4] This article is about the year 2000. ... Open source refers to projects that are open to the public and which draw on other projects that are freely available to the general public. ... Common Lisp, commonly abbreviated CL, is a dialect of the Lisp programming language, standardised by ANSI X3. ...


Many new Lisp programmers were inspired by writers such as Paul Graham and Eric S. Raymond to pursue a language many consider antiquated. New Lispers often describe the language as an eye-opening experience and claim to be substantially more productive than in other languages. [5] [6] Peter Seibel's Practical Common Lisp, a tutorial for new Lisp programmers published in 2004, was briefly Amazon.com's second most popular programming book. [7] Paul Graham For Paul Graham the photographer, see Paul Graham (photographer). ... Eric S. Raymond Eric Steven Raymond (born December 4, 1957), often referred to as ESR, is the author of The Cathedral and the Bazaar and the present maintainer of the Jargon File (the printed version also known as The New Hackers Dictionary). Though the Jargon File established his original...


The language is among the oldest programming languages still in use as of the time of writing in 2005. Algol, Fortran and COBOL are of a similar vintage, and Fortran and COBOL are also still being used. ALGOL (short for ALGOrithmic Language) is a programming language originally developed in the mid 1950s which became the de facto standard way to report algorithms in print for almost the next 30 years. ... FORTRAN[1] is a general-purpose[2], procedural[3], imperative programming language that is especially suited to numeric computation and scientific computing. ... COBOL is a third-generation programming language, and one of the oldest programming languages still in active use. ...


Language innovations

Lisp was the first homoiconic programming language: the primary representation of program code is the same type of list structure that is also used for the main data structures. As a result, Lisp functions can be manipulated, altered or even created within a Lisp program without extensive parsing or manipulation of binary machine code. This is generally considered one of the primary advantages of the language with regards to its expressiveness, and makes the language amenable to metacircular evaluation. In computer programming, homoiconicity is a property of some programming languages, in which the primary representation of the program source code is also a data structure in a primitive type of the language itself. ... A meta-circular evaluator is a special case of a self-interpreter in which the existing facilities of the parent interpreter are directly applied to the source code being interpreted, without any need for additional parsing. ...


The now-ubiquitous if-then-else structure, now taken for granted as an essential element of any programming language, was invented by McCarthy for use in Lisp, where it saw its first appearance in a more general form (the cond structure). It was inherited by Algol, which popularized it.


Lisp deeply influenced Alan Kay, the leader of the research on Smalltalk, and then in turn Lisp was influenced by Smalltalk, by adopting object-oriented programming features (classes, instances, etc.) in the late 1970s. Alan Kay during an interview. ... Smalltalk is an object-oriented, dynamically typed, reflective programming language. ...


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 and the ALGOL-descended C language. Newer languages such as Java and Python have incorporated some limited versions of some of the features of Lisp, but are necessarily unable to bring the coherence and synergy of the full concepts found in Lisp. Because of its suitability to ill-defined, complex, and dynamic applications, Lisp is presently enjoying some resurgence of popular interest. // Ai (as a word, proper name and acronym) can refer to many things. ... FORTRAN[1] is a general-purpose[2], procedural[3], imperative programming language that is especially suited to numeric computation and scientific computing. ... ALGOL (short for ALGOrithmic Language) is a family of imperative computer programming languages originally developed in the mid 1950s which became the de facto standard way to report algorithms in print for almost the next 30 years. ... Wikibooks has a book on the topic of C Programming The C programming language (often, just C) is a general-purpose, procedural, imperative computer programming language developed in the early 1970s by Dennis Ritchie for use on the Unix operating system. ... Java is an object-oriented programming language developed by James Gosling and colleagues at Sun Microsystems in the early 1990s. ... Python is an interpreted programming language created by Guido van Rossum in 1990. ...


See also The Evolution of Lisp, a paper written by Guy L. Steele, Jr. and Richard P. Gabriel. Guy Lewis Steele, Jr. ... Richard P. Gabriel (b. ...


Syntax and semantics

Note: This article's examples are written in Common Lisp (though most are also valid Scheme).

Lisp is an expression-oriented language. Unlike most other languages, no distinction is made between "expressions" and "statements"; all code and data are written as expressions. When an expression is evaluated, it produces a value (or list of values), which then can be embedded into other expressions. Common Lisp, commonly abbreviated CL, is a dialect of the Lisp programming language, standardised by ANSI X3. ...


McCarthy's 1958 paper introduced two types of syntax: S-expressions (Symbolic Expressions, also called "sexps"), which mirror the internal representation of code and data; and M-expressions (Meta Expressions), which express functions of S-expressions. M-expressions never found favour, and almost all Lisps today use S-expressions to manipulate both code and data. An S-expression (S stands for symbolic) is a convention for representing data or an expression in a computer program in a text form. ... M-Expressions are so-called meta-expressions which were intended to be used in Lisp. ...


The heavy use of parentheses in S-expressions has been criticized – some joke acronyms for Lisp are "Lots of Irritating Superfluous Parentheses"[8], "Let's Insert Some Parentheses", or "Long Irritating Series of Parentheses" — but 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. XMLisp, for instance, is a Common Lisp extension that employs the metaobject-protocol to integrate S-expressions with the Extensible Markup Language (XML). Metaobject is any entity that exhibits some aspects of objects, like type, interface, class, methods, attributes, variables, functions, control structures and many more. ... The Extensible Markup Language (XML) is a W3C-recommended general-purpose markup language for creating special-purpose markup languages, capable of describing many different kinds of data. ...


The reliance on expressions gives the language great flexibility. Because Lisp functions are themselves written as lists, they can be processed exactly like data: allowing 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. In computer science, a subroutine (function, procedure, or subprogram) is a sequence of code which performs a specific task, as part of a larger program, and is grouped as one, or more, statement blocks; such code is sometimes collected into software libraries. ... Metaprogramming is the writing of programs that write or manipulate other programs (or themselves) as their data or that do part of the work that is otherwise done at runtime during compile time. ... ...


A Lisp list is written with its elements separated by whitespace, and surrounded by parentheses. For example, (1 2 foo) is a list whose elements are three atoms, the values 1, 2, 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. In the original LISP, the originator of the Lisp programming language family, there were two fundamental data types, atoms and lists. ...


The empty list () is also represented as the special atom nil. This is the only entity in Lisp which is both an atom and a list.


Expressions are written as lists, using prefix notation. The first element in the list is the name of a form, i.e., a function, operator, macro, or "special operator" (see below.) The remainder of the list are the arguments. For example, the function list returns its arguments as a list, so the expression Polish notation, also known as prefix notation was created by Jan Łukasiewicz. ...

 (list '1 '2 'foo) 

evaluates to the list (1 2 foo). The "quote" before the arguments in the preceding example is a "special operator" which prevents the quoted arguments being evaluated (not strictly necessary for the numbers, since 1 evaluates to 1, etc). Any unquoted expressions are recursively evaluated before the enclosing expression is evaluated. For example,

 (list 1 2 (list 3 4)) 

evaluates to the list (1 2 (3 4)). Note that the third argument is a list; lists can be nested.


Arithmetic operators are treated similarly. The expression

 (+ 1 2 3 4) 

evaluates to 10. The equivalent under infix notation would be "1 + 2 + 3 + 4". Arithmetic operators in Lisp are variadic (or n-ary), able to take any number of arguments. Infix notation is the common arithmetic and logical formula notation, in which operators are written infix-style between the operands they act on (e. ... In computer programming, a variadic function is a function of variable arity; that is, one which can take different numbers of arguments. ... In logic, mathematics, and computer science, the arity (synonyms include type, adicity, and rank) of a function or operation is the number of arguments or operands that the function takes. ...


"Special operators" (sometimes called "special forms" by older users) provide Lisp's control structure. For example, the special operator if 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 (3 4 "bar"). (Of course, this would be more useful if a non-trivial expression had been substituted in place of nil!)


Lambda expressions

Another special operator, lambda, 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 lambda 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)) 

is an expression which, when applied, takes one argument, bound to arg and returns the number one greater than that argument. Lambda expressions are treated no differently to named functions; they are invoked the same way. Therefore, the expression

 ((lambda (arg) (+ arg 1)) 5) 

evaluates to 6.


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 in itself 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, and used either as a variable name or as a data item in symbolic processing. For example, the list (FOO (BAR 1) 2) contains three elements: the symbol FOO, the list (BAR 1), and the number 2. Data type is a type of data in a type system in computer programming. ... A number is an abstract entity that represents a count or measurement. ... Generally speaking, the term alphanumeric refers to anything that consists of only letters and numbers. ... Source code (commonly just source or code) is any series of statements written in some human-readable computer programming language. ...


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 the exact 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 as true for anything that is not a cons cell (ie. a list or a partial list). Programming style (also called coding standards or code convention) is a term that describes conventions for writing source code in a certain programming language. ... CONS, Connection-Oriented Network Service, is one of the two OSI stack network layer protocols, the other being CLNS (Connectionless Network Service). ...


Conses and lists

Main article: Cons

A Lisp list is a singly-linked list. Each cell of this list is called a cons (in Scheme, a pair), and is composed of two pointers, called the car and cdr respectively. These are equivalent to the data and next fields discussed in the article linked list. CONS, Connection-Oriented Network Service, is one of the two OSI stack network layer protocols, the other being CLNS (Connectionless Network Service). ... In computer science, a linked list is one of the fundamental data structures used in computer programming. ... It has been suggested that Software pointer be merged into this article or section. ... In computer science, a linked list is one of the fundamental data structures used in computer programming. ...


Of the many data structures that can be built out of singly-linked lists, one of the most basic is called a proper list. A proper list is either the special nil (empty list) symbol, or a cons in which the car points to a datum (which may be another cons structure, such as a list), and the cdr 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 car and cdr functions are also called first and rest 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 which 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 a number of higher-order functions to map a function over a list. In computer programming, the container pattern is one of design patterns in which objects are created to hold other objects. ... In mathematics and computer science, higher-order functions are functions which can take other functions as arguments, and may also return functions as results. ...


Parenthesized S-expressions represent linked list structure. There are several ways to represent the same list as an S-expression. A cons can be written in dotted-pair notation as (a . b), where a is the car and b the cdr. A longer proper list might be written (a . (b . (c . (d . nil)))) in dotted-pair notation. This is conventionally abbreviated as (a b c d) in list notation. An improper list may be written in a combination of the two – as (a b c . d) for the list of three conses whose last cdr is d (i.e., the list (a . (b . (c . d))) in fully-specified form).


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 (arrays), hash tables, structures, and so forth. In computer programming, an array, also known as a vector or list (for one-dimensional arrays) or a matrix (for two-dimensional arrays), is one of the simplest data structures. ...


List-processing procedures

Lisp provides many built-in procedures for accessing and controlling lists. Lists can be created directly with the list 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 cons procedure can be used to add an element to the front of a list. Note that the cons procedure is asymmetric in how it handles list arguments, because of how lists are constructed. A cons pair or cell is a data structure from the Lisp programming language, used to couple two values together. ... CONS, Connection-Oriented Network Service, is one of the two OSI stack network layer protocols, the other being CLNS (Connectionless Network Service). ...

 (cons 1 '(2 3)) ;Output: (1 2 3) 
 (cons '(1 2) '(3 4)) ;Output: ((1 2) 3 4) 

The append procedure appends two (or more) lists to one another. Because Lisp lists are linked lists, appending two lists has asymptotic time complexity O(n). In computer programming, append is the name of a procedure for concatenating (linked) lists or arrays in some high-level programming languages. ... Complexity theory is part of the theory of computation dealing with the resources required during computation to solve a given problem. ...

 (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:

 (setq foo (list 'a 'b 'c)) (setq bar (cons 'x (cdr foo))) 

the lists foo and bar are (a b c) and (x b c) respectively. However, the tail (b c) is the same structure in both lists.


In many languages, the usual way to place the same data in two different structures is to copy it. 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 c with a goose, will affect the other:

 (setf (third foo) 'goose) 

This changes foo to (a b goose), but also changes bar to (x b goose) – 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 set-car! (read set car bang), which replaces the car of a cons. In the Common Lisp dialect, destructive functions are commonplace; the equivalent of set-car! is named rplaca for "replace car." This function is rarely seen however as Common Lisp includes a special facility, setf, 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. Functional programming is a programming paradigm that conceives computation as the evaluation of mathematical functions and avoids state and mutable data. ...


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; (+ 2 3) evaluates to 5. However, most other forms evaluate to themselves: if you enter 5 into Lisp, you just get back 5.


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 quote special operator, or its abbreviation ' (a single quotation mark). For instance, usually if you enter the symbol foo you will get back the value of the corresponding variable (or an error, if there is no such variable). If you wish to refer to the literal symbol, you enter (quote foo) or, usually, 'foo.


More complex forms of quoting are used with macros. For instance, both Common Lisp and Scheme support the backquote or quasiquote operator, entered with the ` character. This is almost the same as the plain quote, except it allows variables to be interpolated into a quoted list with the comma and comma-at operators. If the variable snue has the value (bar baz) then `(foo ,snue) evaluates to (foo (bar baz)), while `(foo ,@snue) evaluates to (foo bar baz). The backquote is most frequently used in defining macro expansions.


Self-evaluating forms and quoted forms are Lisp's equivalent of literals. However, they are not necessarily constants. In some Lisp dialects it is possible to modify the values of literals in program code. For instance, if a quoted form is used in the body of a function, and is changed as a side-effect, that function's behavior may differ on subsequent iterations. This is usually a bug. When behavior like this is intentional, using a closure is the explicit way to do it. In programming languages, a closure is a function that refers to free variables in its lexical context. ...


Lisp's formalization of quotation has been noted by Douglas Hofstadter (in Gödel, Escher, Bach) and others as an example of the philosophical idea of self-reference. Douglas Richard Hofstadter (born February 15, 1945) is an American academic. ... GEB cover Gödel, Escher, Bach: an Eternal Golden Braid (commonly GEB) is a Pulitzer Prize-winning book by Douglas Hofstadter, published in 1979 by Basic Books. ... Philosopher in Meditation (detail), by Rembrandt. ... A self-reference occurs when an object refers to itself. ...


Scope and closure

The modern Lisp family splits over the use of dynamic or static (aka lexical) scope. Scheme and Common Lisp make use of static scoping by default, while the more primitive Lisp systems used as embedded languages in Emacs and AutoCAD use dynamic scoping. In computer programming in general, a scope is an enclosing context. ... This article is about the text editor. ... AutoCAD 2006 drawing. ...


List structure of program code

A fundamental distinction between Lisp and other languages is that in Lisp, program code is not simply text. Parenthesized S-expressions, as depicted above, are the printed representation of Lisp code, but as soon as these are entered into a Lisp system they are translated by the parser (called the read function) into linked list and tree structures in memory.


Lisp macros operate on these structures. 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. Macros in C, for instance, operate on the level of the preprocessor, before the parser is invoked, and cannot re-structure the program code in the way Lisp macros can. Wikibooks has a book on the topic of C Programming The C programming language (often, just C) is a general-purpose, procedural, imperative computer programming language developed in the early 1970s by Dennis Ritchie for use on the Unix operating system. ... In computer science, a preprocessor is a program that takes source code and performs transformations on it, before the step of compilation or interpretation. ...


In simplistic Lisp implementations, this list structure is directly 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 actual Lisp systems (including all conforming Common Lisp systems) also include a compiler. The compiler translates list structure into machine code or bytecode for execution. An interpreter is a computer program that executes other programs. ... Common Lisp, commonly abbreviated CL, is a dialect of the Lisp programming language, standardised by ANSI X3. ... Byte-code is a sort of intermediate code that is more abstract than machine code. ...


Evaluation and the Read-Eval-Print Loop

Lisp languages are frequently used with an interactive command line, which may be combined with an integrated development environment. 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", or REPL. A command line interface or CLI is a method of interacting with a computer by giving it lines of textual commands (that is, a sequence of characters) either from keyboard input or from a script. ... An integrated development environment (IDE), also known as integrated design environment and integrated debugging environment, is a type of computer software that assists computer programmers to develop software. ... A read-eval-print loop (REPL) is a simple, interactive computer programming environment. ...


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 read function accepts textual S-expressions as input, and parses them into list structure. For instance, if you type the string (+ 1 2) at the prompt, read 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.


The eval function evaluates list structure, returning some other piece of structure 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, eval 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 (1 2) yields the answer 3. This is the result of the evaluation. Evaluation is performed in applicative order. In functional programming languages, we are thinking of ourselves as recursively evaluating some mathematical expression. ...


It is the job of the print function to represent output to the user. For a simple result such as 3 this is trivial. An expression which evaluated to a piece of list structure would require that print 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 eval will be complicated, since it must also implement all special operators like if.) This done, a basic REPL itself is but a single line of code: (loop (print (eval (read)))).


Control structures

Lisp originally had very few control structures, but many more were added during the language's evolution. (Lisp's original conditional operator, cond, is the precursor to later if-then-else 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; nothing could be further from the truth. All frequently-seen Lisp dialects have imperative-style iteration constructs, from Scheme's straightforward do loop to Common Lisp's complex loop expressions. In computer science, tail recursion is a special case of recursion that can be easily transformed into an iteration. ...


Most 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.


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 call/cc 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. In computing, a continuation is a representation of the execution state of a program (for example, the call stack or values of variables) at a certain point. ...


Frequently, 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. Haskell is a standardized pure functional programming language with non-strict semantics, named after the logician Haskell Curry. ...


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 for 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 map and in Common Lisp is called mapcar. Given a function and one or more lists, mapcar 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 (11 22 33 44 55).


Examples

Here are examples of Common Lisp code. While unlike Lisp programs used in industry, they are similar to Lisp as taught in computer science courses.


As the reader may have noticed from the above discussion, Lisp syntax lends itself naturally to recursion. Mathematical problems such as the enumeration of recursively-defined sets are simple to express in this notation.


Evaluate a number's factorial: In mathematics, the factorial of a natural number n is the product of all positive integers less than or equal to n. ...

 (defun factorial (n) (if (<= n 1) 1 (* n (factorial (- n 1))))) 

An alternative implementation, often faster than the previous version if the Lisp system has tail recursion optimization: In computer science, tail recursion is a special case of recursion that can be easily transformed into an iteration. ...

 (defun factorial (n &optional (acc 1)) (if (<= n 1) acc (factorial (- n 1) (* acc n)))) 

Contrast with an iterative version which uses Common Lisp's loop macro: Common Lisp, commonly abbreviated CL, is a dialect of the Lisp programming language, standardised by ANSI X3. ...

 (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 (l &optional acc) (if (atom l) acc (-reverse (cdr l) (cons (car l) acc)))) 

Object systems

Various object systems and models have been built on top of, alongside, or into Lisp, including:

  • Flavors, built at MIT
  • The Common Lisp Object System, CLOS (descended from Flavors)
  • KR (short for Knowledge Representation), a constraints-based object system developed to aid the writing of Garnet, a GUI library for Common Lisp

CLOS features multiple inheritance, multiple dispatch ("multimethods"), and a powerful system of "method combinations". In fact, Common Lisp, which includes CLOS, was the first object-oriented language to be officially standardized. Flavors is the programming language that first included mixins. ... The Massachusetts Institute of Technology, or MIT, is a private research university located in the city of Cambridge, Massachusetts, USA. Its mission and culture are guided by an emphasis on teaching and research grounded in practical applications of science and technology. ... The Common Lisp Object System, a powerful system for object-oriented programming which forms part of Common Lisp. ... A constraint is a limitation of possibilities. ... Common Lisp, commonly abbreviated CL, is a dialect of the Lisp programming language, standardised by ANSI X3. ... Multiple inheritance refers to a feature of object-oriented programming languages in which a class can inherit behaviors and features from more than one superclass. ... Multiple dispatch or multimethods is the feature of some object-oriented programming languages in which a function or method can be specialized on the type of more than one of its arguments. ... Common Lisp, commonly abbreviated CL, is a dialect of the Lisp programming language, standardised by ANSI X3. ... In computer science, object-oriented programming is a computer programming paradigm. ...


Genealogy and variants

Over its almost fifty-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, commonly abbreviated CL, is a dialect of the Lisp programming language, standardised by ANSI X3. ...


Differences between dialects may be quite significant – for instance, Common Lisp and Scheme do not even use the same keyword to define functions! Within a dialect that is standardized, however, conforming implementations support the same core language, but with different extensions and libraries.


Major modern dialects

Common Lisp
descended mainly from ZetaLisp and Franz Lisp, with some InterLisp input. Prevailing standard for industrial use today.
Scheme
a minimalist "academic" Lisp; an early user of lexical scope and continuations.
Emacs Lisp
scripting language for the Emacs editor.

Common Lisp, commonly abbreviated CL, is a dialect of the Lisp programming language, standardised by ANSI X3. ... ZetaLisp was the name Symbolics gave to their dialect of Lisp on their Lisp Machine models, to distinguish it from the MIT version. ... Franz Lisp, written at UC Berkeley by the students of Professor Richard J. Fateman, was a Lisp system based larged on Maclisp, but written specifically to be a host for running Macsyma on a Digital Equipment Corp (DEC) VAX. It appeared on the scene at the end of 1978 shortly... Interlisp (also seen with a variety of capitalizations) was a version of the Lisp programming language originally developed in 1967 at Bolt, Beranek and Newman in Cambridge, Massachusetts. ... Scheme is a multi-paradigm programming language and a dialect of Lisp which supports functional and procedural programming. ... In computer programming in general, a scope is an enclosing context. ... In computing, a continuation is a representation of the execution state of a program (for example, the call stack or values of variables) at a certain point. ... Emacs Lisp is a dialect of the Lisp programming language used by the GNU Emacs and XEmacs text editors (which we will collectively refer to as Emacs in this article. ... This article is about the text editor. ...

Historically significant dialects

  • LISP 1.5 [9] – 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. (LISP 2 used an M-expression-based syntax and would not be widely used.)
  • Stanford LISP 1.6 [10] – This was a successor to LISP 1.5 developed at the Stanford AI Lab, and widely distributed to PDP-10 systems running the TOPS-10 operating system. It was obsoleted by Maclisp and InterLisp.
  • MACLISP [11] – developed for MIT's Project MAC (no relation to Apple's Macintosh, nor to McCarthy), direct descendant of LISP 1.5. It ran on the PDP-10 and Multics systems.
  • InterLisp [12] – developed at BBN for PDP-10 systems running the Tenex operating system, later adopted as a "West coast" Lisp for the Xerox Lisp machines. A small version called "InterLISP 65" was published for Atari's 6502-based computer line. For quite some time MacLisp and InterLisp were strong competitors.
  • Franz Lisp – originally a Berkeley project; later developed by Franz Inc. The name is a humorous deformation of 'Franz Liszt'.
  • ZetaLisp – used on the Lisp machines, direct descendant of MacLisp.
  • ANSI Common Lisp – mostly, a cleaned up subset of ZetaLisp incorporating CLOS.

M-Expressions are so-called meta-expressions which were intended to be used in Lisp. ... The Stanford Artificial Intelligence Laboratory (commonly called the Stanford AI Lab, or SAIL), was one of the leading centres for artificial intelligence research from the 1960s through the 1980s. ... The PDP-10 was a computer manufactured by Digital Equipment Corporation (DEC) from the late 1960s on; the name stands for Programmed Data Processor model 10. It was the machine that made time-sharing common; it looms large in hacker folklore because of its adoption in the 1970s by many... The TOPS-10 System was a computer operating system from Digital Equipment Corporation (DEC) for the PDP-10 released in 1964 and later on for the DEC-System10. ... MacLisp is a dialect of the Lisp programming language. ... Interlisp (also seen with a variety of capitalizations) was a version of the Lisp programming language originally developed in 1967 at Bolt, Beranek and Newman in Cambridge, Massachusetts. ... MacLisp is a dialect of the Lisp programming language. ... Project MAC, later the MIT Laboratory for Computer Science (LCS), was a research laboratory at MIT. Project MAC would become famous for groundbreaking research in operating systems, artificial intelligence, and the theory of computation. ... The first Macintosh computer, introduced in 1984, upgraded to a 512K Fat Mac. The Macintosh or Mac, is a line of personal computers designed, developed, manufactured, and marketed by Apple Computer. ... John McCarthy (computer scientist), inventor of the term artificial intelligence and much more. ... The PDP-10 was a computer manufactured by Digital Equipment Corporation (DEC) from the late 1960s on; the name stands for Programmed Data Processor model 10. It was the machine that made time-sharing common; it looms large in hacker folklore because of its adoption in the 1970s by many... Multics (Multiplexed Information and Computing Service) was an extraordinarily influential early time-sharing operating system. ... Interlisp (also seen with a variety of capitalizations) was a version of the Lisp programming language originally developed in 1967 at Bolt, Beranek and Newman in Cambridge, Massachusetts. ... BBN might refer to: Bolt, Beranek and Newman, (now known as BBN Technologies), a technology company in Cambridge, Massachusetts, best known for its work on packet switching technology Bible Broadcasting Network, a global Christian radio network headquartered in Charlotte, NC Big Bang nucleosynthesis Big Brother Nigeria, a reality show which... The PDP-10 was a computer manufactured by Digital Equipment Corporation (DEC) from the late 1960s on; the name stands for Programmed Data Processor model 10. It was the machine that made time-sharing common; it looms large in hacker folklore because of its adoption in the 1970s by many... The TOPS-20 operating system by DEC - the second proprietary OS for the PDP-10 - preferred by most PDP-10 hackers over TOPS-10 (that is, by those who were not ITS or WAITS partisans). ... This article or section does not cite its references or sources. ... The MOS Technology 6502 is an 8-bit microprocessor designed by MOS Technology in 1975. ... Franz Lisp, written at UC Berkeley by the students of Professor Richard J. Fateman, was a Lisp system based larged on Maclisp, but written specifically to be a host for running Macsyma on a Digital Equipment Corp (DEC) VAX. It appeared on the scene at the end of 1978 shortly... The University of California, Berkeley (also known as UC Berkeley, Berkeley, Cal, and by other names, see below) is the oldest and flagship campus of the ten-campus University of California system. ... Franz Inc. ... Franz Liszt (Hungarian: Liszt Ferenc) (October 22, 1811 – July 31, 1886) was a Hungarian virtuoso pianist and composer. ... ZetaLisp was the name Symbolics gave to their dialect of Lisp on their Lisp Machine models, to distinguish it from the MIT version. ... The original Lisp machine built by Greenblatt and Knight Lisp machines were general-purpose computers designed (usually through hardware support) to efficiently run Lisp as their main software language. ... MacLisp is a dialect of the Lisp programming language. ... The American National Standards Institute (ANSI) is a private, non-profit standards organization that produces industrial standards in the United States. ... Common Lisp, commonly abbreviated CL, is a dialect of the Lisp programming language, standardised by ANSI X3. ... ZetaLisp was the name Symbolics gave to their dialect of Lisp on their Lisp Machine models, to distinguish it from the MIT version. ... The Common Lisp Object System, a powerful system for object-oriented programming which forms part of Common Lisp. ...

Minor dialects

  • Arc – A lisp currently being designed by Paul Graham
  • EuLisp
  • GOO – A lisp which takes ideas from Dylan , Scheme and Cecil
  • Isis – A Lisp dialect developed at the MIT Media Lab for multimedia applications.
  • ISLISP
  • LUSH (Lisp Universal SHell) – A Lisp dialect developed for numerical and multimedia applications.
  • Lispkit Lisp – A purely functional ("pure Lisp") dialect implemented on a virtual machine (the SECD machine) and used as a testbed for experimentation with functional language concepts.
  • MultiLisp – dialect of Scheme, extended with constructs for parallel execution
  • newLISP – A stripped down version of Lisp with a focus on scripting and integrated networking functions.
  • LiLi – An experimental Java embeddable Lisp Interpreter based on its own dialect
  • rep – Read-Eval-Print, used in the Sawfish window manager.

Arc is a Lisp-like programming language in development by Paul Graham. ... Paul Graham For Paul Graham the photographer, see Paul Graham (photographer). ... Please wikify (format) this article as suggested in the Guide to layout and the Manual of Style. ... The Dylan programming language (pronounced , like the name) is functional, object-oriented, reflective and dynamic. ... Scheme is a multi-paradigm programming language and a dialect of Lisp which supports functional and procedural programming. ... Cecil is a pure object-oriented programming language that was developed by Craig Chambers at the University of Washington in 1998 to be part of the Vortex project there. ... From ISLISP.info: The ISLISP programming language is a member of the Lisp family of programming languages. ... Lush, the Lisp Universal Shell, is an object-oriented dialect of Lisp that was initially developed as a scripting language for machine learning applications, but can also be used for general programming and system/network administration tasks and uses. ... Lispkit Lisp is a strictly functional subset of Lisp developed as a testbed for functional programming concepts. ... In general terms, a virtual machine in computer science is software that creates a virtualized environment between the computer platform and the end user in which the end user can operate software. ... The SECD machine is a highly influential virtual machine intended as a target for functional programming language compilers. ... A testbed is a platform for experimentation for large development projects. ... MultiLisp is a functional programming language and dialect of the Lisp dialect Scheme, extended with constructs for parallel execution and shared memory; MultiLisp is implemented in Interlisp. ... newLisp is a stripped down open source version of Lisp which is available on several platforms. ... Meanings of Rep: rep, the Röntgen equivalent physical, a unit of exposure to radiation. ... In Unix computing, Sawfish is a window manager for the X Window System. ...

Miscellaneous implementations

See also the implementations listed at Scheme and Common Lisp.
  • Gold Hill Common Lisp – an early PC implementation of Common Lisp.
  • Macintosh Common Lisp (MCL) – an implementation of Lisp for the Macintosh.
  • Cambridge Lisp – originally implemented on IBM mainframes; published by Metacomco for the Amiga.
  • Knowledge Representation System
  • Symmetric Lisp – A parallel Lisp in which environments are first-class objects. It is implemented in Common Lisp.
  • STING – A parallel dialect of Scheme intended to serve as a high-level operating system for symbolic programming languages. Features include first-class threads and processors and customisable scheduling policies.
  • AutoLISP/Visual LISP – customization language for the AutoCAD product.
  • *Lisp (StarLisp) – A data-parallel extension of Common Lisp for the Connection Machine, uses "pvars".
  • Jatha is a Java library that implements a fairly large subset of Common Lisp
  • GOAL is a proprietary LISP derivative developed by Andy Gavin at Naughty Dog for the express purpose of developing console video games.
  • Lists and Lists implements a subset of Scheme as an educational game for the Z-machine.

Scheme is a multi-paradigm programming language and a dialect of Lisp which supports functional and procedural programming. ... Common Lisp, commonly abbreviated CL, is a dialect of the Lisp programming language, standardised by ANSI X3. ... The original Amiga (1985) The Amiga is a family of home/personal computers originally developed by Amiga Corporation (motto: ) as an advanced home entertainment and productivity machine. ... To meet Wikipedias quality standards, this article or section may require cleanup. ... AutoLISP is a programming language, a dialect of Lisp included with the CAD program AutoCAD to allow the user to add functionality to the software. ... See Star Lisp ... Thinking Machines CM-2 at the Computing Museum in San Jose. ... Andy Gavin is a programmer notable for co-founding the Naughty Dog video game company in 1986. ... Naughty Dog is an American video game company founded by Andy Gavin and Jason Rubin in 1986. ... This article is about computer and video games. ... The Z machine at Sandia National Laboratory. ...

Related languages

  • Logo – A descendant of Lisp which generally avoids the use of parentheses. Best known for "turtle graphics."
  • Dylan – A Scheme descendant developed by Apple Computer, which originally used S-expressions but later adopted a non-Lisp syntax.

Logo turtle graphic The Logo programming language is a functional programming language. ... The Logo programming language is an adaptation by Wally Feurzeig and Seymour Papert of the Lisp programming language that is easier to read. ... The Dylan programming language (pronounced , like the name) is functional, object-oriented, reflective and dynamic. ... Apple Computer, Inc. ...

Quotations

Wikiquote has a collection of quotations related to:
Lisp is worth learning for the profound enlightenment experience you will have when you finally get it; that experience will make you a better programmer for the rest of your days, even if you never actually use Lisp itself a lot.
Eric S. Raymond, "How to Become a Hacker" [13]
Lisp has jokingly been called "the most intelligent way to misuse a computer". I think that description is a great compliment because it transmits the full flavor of liberation: it has assisted a number of our most gifted fellow humans in thinking previously impossible thoughts.
Edsger Dijkstra, CACM, 15:10
Lisp is a programmable programming language.
— John Foderaro
Any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified bug-ridden slow implementation of half of Common Lisp.
Philip Greenspun, often called Greenspun's Tenth Rule of Programming [14]
Please don't assume Lisp is only useful for Animation and Graphics, AI, Bioinformatics, B2B and E-Commerce, Data Mining, EDA/Semiconductor applications, Expert Systems, Finance, Intelligent Agents, Knowledge Management, Mechanical CAD, Modeling and Simulation, Natural Language, Optimization, Research, Risk Analysis, Scheduling, Telecom, and Web Authoring just because these are the only things they happened to list.
Kent Pitman

Image File history File links Wikiquote-logo-en. ... Wikiquote logo Wikiquote is a sister project of Wikipedia, using the same MediaWiki software. ... Eric S. Raymond Eric Steven Raymond (born December 4, 1957), often referred to as ESR, is the author of The Cathedral and the Bazaar and the present maintainer of the Jargon File (the printed version also known as The New Hackers Dictionary). Though the Jargon File established his original... Edsger Dijkstra (courtesy Brian Randell) Prof Dr Edsger Wybe Dijkstra (Rotterdam, May 11, 1930 – Nuenen, August 6, 2002; IPA: ) was a Dutch computer scientist. ... Philip Greenspun is a retired computer scientist who was a pioneer in developing online communities. ... To meet Wikipedias quality standards, this article or section may require cleanup. ... Kent M. Pitman is the President of HyperMeta, Inc. ...

See also

  • ICAD (Example End-user computing system (Knowledge-Based Engineering) with a long-standing commercial life.)
  • Planner (a programming language implemented in Lisp that was the basis of the famous SHRDLU AI system)
  • Bill Schelter (Lisp programmer; maintainer of Maxima and GCL)
  • Kent Pitman (Lisp programmer; Common Lisp standard editor)
  • Paul Graham (Lisp programmer; inventor of Arc dialect of Lisp; essayist)

ICAD (Corporate history: ICAD, Inc. ... To meet Wikipedias quality standards, this article or section may require cleanup. ... Knowledge-Based Engineering (KBE) is a discipline with roots in computer-aided design (CAD) and knowledge-based systems but has several definitions and roles depending upon the context. ... Planner (often seen in publications as PLANNER) is a programming language designed by Carl Hewitt at MIT, and first published in 1969. ... SHRDLU [1] was an early natural language understanding computer program, developed by Terry Winograd at MIT from 1968-1970. ... William Frederick Schelter (died July 30, 2001) was a professor of mathematics at the University of Texas at Austin and a Lisp developer and programmer. ... Kent M. Pitman is the President of HyperMeta, Inc. ... Paul Graham For Paul Graham the photographer, see Paul Graham (photographer). ... Arc is a Lisp-like programming language in development by Paul Graham. ... An essayist is an author who writes compositions which can be about any particular subject. ...

Notes

  1. ^ The 36-bit word size of the PDP-6/PDP-10 was influenced by the usefulness of having two Lisp 18-bit pointers in a single word. "The PDP-6 project started in early 1963, as a 24-bit machine. It grew to 36 bits for LISP, a design goal." [1]

The PDP-6 (Programmed Data Processor-6) was a computer model developed by Digital Equipment Corporation (DEC) in 1963. ... The PDP-10 was a computer manufactured by Digital Equipment Corporation (DEC) from the late 1960s on; the name stands for Programmed Data Processor model 10. It was the machine that made time-sharing common; it looms large in hacker folklore because of its adoption in the 1970s by many...

External links


  Results from FactBites:
 
Lisp programming language - Wikipedia, the free encyclopedia (5157 words)
Lisp is a family of computer programming languages with a long history and a distinctive fully-parenthesized syntax.
Lisp was used as the implementation of the programming language Micro Planner that was the foundation for the famous AI system SHRDLU.
Lisp was the first homoiconic programming language: the primary representation of program code is the same type of list structure that is also used for the main data structures.
LISP programming language - Wikipedia (940 words)
Lisp (coined from "list processing") is an early programming language with a simple prefix-notation syntax, dynamic typing (that is, untyped variables but typed values), and special features for processing lists.
In fact, there are now many different languages with "Lisp" in their names, and it is probably better to regard "Lisp" as the name of a family of languages rather than of a single language.
The language was invented by John McCarthy in 1958 whilst he was at MIT; he published a paper in CACM in 1960 titled "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I" (part II was never published).
  More results at FactBites »

 
 

COMMENTARY     


Share your thoughts, questions and commentary here
Your name
Your comments

Want to know more?
Search encyclopedia, statistics and forums:

 


Press Releases |  Feeds | Contact
The Wikipedia article included on this page is licensed under the GFDL.
Images may be subject to relevant owners' copyright.
All other elements are (c) copyright NationMaster.com 2003-5. All Rights Reserved.
Usage implies agreement with terms, 1022, m