Content deleted Content added
→External links: WP:ELDEAD - ___domain is for sale |
ScottBurson (talk | contribs) m An article about Lisp must have balanced parentheses! |
||
| (45 intermediate revisions by 28 users not shown) | |||
Line 3:
{{Infobox programming language
| name = Lisp
| paradigm = [[Multi-paradigm programming language|Multi-paradigm]]: [[Functional programming|functional]], [[Procedural programming|procedural]], [[Reflective programming|reflective]], [[Metaprogramming|meta]]
| released = {{Start date and age|1960}}
Line 76 ⟶ 74:
}}
'''Lisp''' (historically '''LISP''', an abbreviation of "list processing") is a family of [[programming language]]s with a long history and a distinctive, fully [[parenthesized]] [[Polish notation#
Originally specified in the late 1950s, it is the second-oldest [[high-level programming language]] still in common use, after [[Fortran]].<ref name="uOUnJ">{{cite web|url=http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-5.html|archive-url=https://web.archive.org/web/20010727170154/http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-5.html|archive-date=2001-07-27|quote=Lisp is a survivor, having been in use for about a quarter of a century. Among the active programming languages only Fortran has had a longer life.|title=SICP: Foreword}}</ref><ref name="AfFRW">{{cite web|url=http://www-formal.stanford.edu/jmc/history/lisp/node6.html#SECTION00060000000000000000|title=Conclusions|access-date=2014-06-04|archive-url=https://web.archive.org/web/20140403021353/http://www-formal.stanford.edu/jmc/history/lisp/node6.html#SECTION00060000000000000000|archive-date=2014-04-03}}</ref> Lisp has changed since its early days, and many [[Programming language dialect|dialects]] have existed over its history. Today, the best-known general-purpose Lisp dialects are [[Common Lisp]], [[Scheme (programming language)|Scheme]], [[Racket (programming language)|Racket]], and [[Clojure]].<ref>{{Cite book |last=Steele |first=Guy L. |title=Common Lisp: the language |date=1990 |publisher=Digital Press |isbn=1-55558-041-6 |edition=2nd |___location=Bedford, MA |oclc=20631879}}</ref><ref>{{Cite web |last1=Felleisen |first1=Matthias |last2=Findler |first2=Robert |last3=Flatt |first3=Matthew |last4=Krishnamurthi |first4=Shriram |last5=Barzilay |first5=Eli |last6=McCarthy |first6=Jay |last7=Tobin-Hochstadt |first7=Sam |date=2015 |title="The Racket Manifesto" |url=https://www2.ccs.neu.edu/racket/pubs/manifesto.pdf}}</ref><ref>{{Cite web |title=Clojure - Differences with other Lisps |url=https://clojure.org/reference/lisps |access-date=2022-10-27 |website=clojure.org}}</ref>
Line 99 ⟶ 97:
{{Multiple image |direction=vertical |image1=John McCarthy Stanford.jpg |image2=Steve Russell.jpg |footer=[[John McCarthy (computer scientist)|John McCarthy]] (top) and [[Steve Russell (computer scientist)|Steve Russell]]}}
[[John McCarthy (computer scientist)|John McCarthy]] began developing Lisp in 1958 while he was at the [[Massachusetts Institute of Technology]] (MIT). He was motivated by a desire to create an AI programming language that would work on the [[IBM 704]], as he believed that "IBM looked like a good bet to pursue Artificial Intelligence research vigorously."<ref name="wexelblat-history-programming-languages">{{cite book |title=History of programming languages |last1=McCarthy |first1=John |last2=Wexelblat |first2=Richard L. |year=1978 |isbn=0127450408 |publisher=Association for Computing Machinery |pages=173–183}}</ref> He was inspired by [[Information Processing Language]], which was also based on list processing, but did not use it because it was designed for different hardware and he found an algebraic language more appealing.<ref name="wexelblat-history-programming-languages" /> Due to these factors, he consulted on the design of the [[Fortran]] List Processing Language, which was implemented as a Fortran library. However, he was dissatisfied with it because it did not support [[Recursion (computer science)|recursion]] or a modern [[Conditional (computer programming)#If–then(–else)|if-then-else]] statement (which was a new concept when Lisp was first introduced) {{NoteTag|At the time, Fortran had an if-then-else construct that accepted line numbers as jump targets, in the manner of a [[Goto]] statement, rather than accepting arbitrary expression in "then" and "else" blocks}}.<ref name="wexelblat-history-programming-languages" />
[[John McCarthy (computer scientist)|John McCarthy]] began developing Lisp in 1958 while he was at the [[Massachusetts Institute of Technology]] (MIT). McCarthy published its design in a paper in ''[[Communications of the ACM]]'' in April 1960, entitled "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I".<ref name="McCarthy">{{cite web |title=Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I |last=McCarthy |first=John |url=http://www-formal.stanford.edu/jmc/recursive.html |access-date=2006-10-13 |archive-url=https://web.archive.org/web/20131004215327/http://www-formal.stanford.edu/jmc/recursive.html |archive-date=2013-10-04}}</ref> He showed that with a few simple operators and a notation for anonymous functions borrowed from Church, one can build a [[Turing completeness|Turing-complete]] language for algorithms.▼
McCarthy's original notation used bracketed "[[M-expression]]s" that would be translated into [[S-expression]]s. As an example, the M-expression {{Lisp2|car[cons[A,B]]}} is equivalent to the S-expression {{Lisp2|(car (cons A B))}}. Once Lisp was implemented, programmers rapidly chose to use S-expressions, and M-expressions were abandoned.<ref name="wexelblat-history-programming-languages"/> M-expressions surfaced again with short-lived attempts of [[MLisp]]<ref name="Smith">{{cite book |last=Smith |first=David Canfield |title=MLISP Users Manual |url=http://www.softwarepreservation.org/projects/LISP/stanford/Smith-MLISP-AIM-84.pdf |access-date=2006-10-13}}</ref> by Horace Enea and [[CGOL]] by [[Vaughan Pratt]].▼
Lisp was first implemented by [[Steve Russell (computer scientist)|Steve Russell]] on an [[IBM 704]] computer using [[punched card]]s.<ref name="4VwQq">{{Cite web |url=http://jmc.stanford.edu/articles/lisp/lisp.pdf |title=History of Lisp: Artificial Intelligence Laboratory |last=McCarthy |first=John |date=12 February 1979}}</ref> Russell
▲McCarthy's original notation used bracketed "[[M-expression]]s" that would be translated into [[S-expression]]s. As an example, the M-expression {{Lisp2|car[cons[A,B]]}} is equivalent to the S-expression {{Lisp2|(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]]<ref name="Smith">{{cite book |last=Smith |first=David Canfield |title=MLISP Users Manual |url=http://www.softwarepreservation.org/projects/LISP/stanford/Smith-MLISP-AIM-84.pdf |access-date=2006-10-13}}</ref> by Horace Enea and [[CGOL]] by [[Vaughan Pratt]].
▲Lisp was first implemented by [[Steve Russell (computer scientist)|Steve Russell]] on an [[IBM 704]] computer using [[punched card]]s.<ref name="4VwQq">{{Cite web |url=http://jmc.stanford.edu/articles/lisp/lisp.pdf |title=History of Lisp: Artificial Intelligence Laboratory |last=McCarthy |first=John |date=12 February 1979}}</ref> Russell had read McCarthy's paper and realized (to McCarthy's surprise) that the Lisp ''[[eval]]'' function could be implemented in [[machine code]].
According to McCarthy<ref name="k4CmX">{{cite conference |title=Early LISP history (1956–1959) |last1=Stoyan |first1=Herbert |date=1984-08-06 |page=307 |publisher=[[Association for Computing Machinery]] |book-title= |pages= |___location= |conference=LFP '84: Proceedings of the 1984 ACM Symposium on LISP and functional programming |doi=10.1145/800055.802047|doi-access=free}}</ref>
Line 114 ⟶ 110:
Two [[assembly language macros]] for the [[IBM 704]] became the primitive operations for decomposing lists: [[car and cdr|car]] (''Contents of the Address part of Register'' number) and [[car and cdr|cdr]] (''Contents of the Decrement part of Register'' number),<ref name="PREHISTORY">{{cite web |title=LISP prehistory - Summer 1956 through Summer 1958 |last=McCarthy |first=John |url=http://www-formal.stanford.edu/jmc/history/lisp/node2.html |access-date=2010-03-14}}</ref> where "register" refers to [[Processor register|registers]] of the computer's [[central processing unit]] (CPU). Lisp dialects still use {{Lisp2|car}} and {{Lisp2|cdr}} ({{IPAc-en|k|ɑːr}} and {{IPAc-en|ˈ|k|ʊ|d|ər}}) 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 could be compiled by simply having an existing LISP interpreter interpret the compiler code, producing [[machine code]] output able to be executed at a 40-fold improvement in speed over that of the interpreter.<ref name="Levin">{{cite web |title=AI Memo 39-The new compiler |last1=Hart |first1=Tim |last2=Levin |first2=Mike |url=ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-039.pdf |archive-url=https://web.archive.org/web/20201213195043/ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-039.pdf |archive-date=2020-12-13 |access-date=2019-03-18}}</ref> This compiler introduced the Lisp model of [[incremental compiler|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.▼
▲The first complete Lisp compiler, written in Lisp, was implemented in 1962 by Tim Hart and Mike Levin at MIT, and could be compiled by simply having an existing LISP interpreter interpret the compiler code, producing [[machine code]] output able to be executed at a 40-fold improvement in speed over that of the interpreter.<ref name="Levin">{{cite web |title=AI Memo 39-The new compiler |last1=Hart |first1=Tim |last2=Levin |first2=Mike |url=ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-039.pdf |archive-url=https://web.archive.org/web/
[[Garbage collection (computer science)|Garbage collection]] routines were developed by MIT graduate student [[Daniel Edwards (programmer)|Daniel Edwards]], prior to 1962.<ref>{{cite book |title=LISP 1.5 Programmer's Manual |url=http://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf |page=Preface |orig-date=1962 |year=1985 |version=15th printing |last1=McCarthy |first1=John |last2=Abrahams |first2=Paul W. |last3=Edwards |first3=Daniel J. |last4=Hart |first4=Timothy P. |last5=Levin |first5=Michael I. |edition=2nd}}</ref>
During the 1980s and 1990s, a great effort was made to unify the work on new Lisp dialects (mostly successors to [[Maclisp]] such as [[ZetaLisp]] and NIL (New Implementation of Lisp)) into a single language. The new language, [[Common Lisp]], was somewhat compatible with the dialects it replaced (the book ''[[Common Lisp the Language]]'' notes the compatibility of various constructs). In 1994, [[ANSI]] published the Common Lisp standard, "ANSI X3.226-1994 Information Technology Programming Language Common Lisp".
=== Timeline ===
Line 124 ⟶ 122:
===Connection to artificial intelligence===
Since inception, Lisp was closely connected with the [[artificial intelligence]] research community, especially on [[PDP-10]]<ref name="PYuEL">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. {{cite newsgroup |quote=The PDP-6 project started in early 1963, as a 24-bit machine. It grew to 36 bits for LISP, a design goal. |url=http://groups.google.com/group/alt.folklore.computers/browse_thread/thread/6e5602ce733d0ec/17597705ae289112 |title=The History of TOPS or Life in the Fast ACs |newsgroup=alt.folklore.computers |message-id=84950@tut.cis.ohio-state.edu |date=18 October 1990 |author=Peter J. Hurley}}</ref> systems. Lisp was used as the implementation of the language [[Planner (programming language)|Micro Planner]], which was used in the famous AI system [[SHRDLU]]. In the 1970s, as AI research spawned commercial offshoots, the performance of existing Lisp systems became a growing issue, as programmers needed to be familiar with the performance ramifications of the various techniques and choices involved in the implementation of Lisp.<ref>{{Citation |last1=Steele |first1=Guy L. |title=The evolution of Lisp |date=January 1996 |url=http://dl.acm.org/doi/10.1145/234286.1057818 |work=History of programming languages---II |pages=233–330 |editor-last=Bergin |editor-first=Thomas J. |place=New York, NY, US |publisher=ACM |language=en |doi=10.1145/234286.1057818 |isbn=978-0-201-89502-5 |access-date=2022-07-25 |last2=Gabriel |first2=Richard P. |editor2-last=Gibson |editor2-first=Richard G.|url-access=subscription }}</ref>
===Genealogy and variants===
Over its sixty-year history, Lisp has spawned many variations on the core theme of an S-expression language.
Differences between dialects (and/or implementations) may be quite visible—for instance, Common Lisp uses the keyword <code>defun</code> to name a function, but Scheme uses <code>define</code>.<ref name="jbyrI">Common Lisp: <code>(defun f (x) x)</code><br />Scheme: <code>(define f (lambda (x) x))</code> or <code>(define (f x) x)</code></ref> Within a dialect that is standardized
====Historically significant dialects====
Line 140 ⟶ 138:
* [[Interlisp]]<ref name="5CtB3">{{Cite book |url=http://www.bitsavers.org/pdf/xerox/interlisp/1974_InterlispRefMan.pdf |title=InterLisp Reference Manual |first=Warren |last=Teitelman |year=1974 |access-date=2006-08-19 |archive-url=https://web.archive.org/web/20060602134835/http://www.bitsavers.org/pdf/xerox/interlisp/1974_InterlispRefMan.pdf |archive-date=2006-06-02}}</ref> – developed at [[BBN Technologies]] for PDP-10 systems running the [[TENEX (operating system)|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 [[MOS Technology 6502]]-based [[Atari 8-bit computers]]. Maclisp and InterLisp were strong competitors.
* [[Franz Lisp]] – originally a [[University of California, Berkeley]] project; later developed by Franz Inc. The name is a humorous deformation of the name "[[Franz Liszt]]", and does not refer to [[Allegro Common Lisp]], the dialect of Common Lisp sold by Franz Inc., in more recent years.
* [[muLISP]] – initially developed by Albert D. Rich and David Stoutemeyer for small microcomputer systems. Commercially available in 1979, it was running on CP/M systems of only 64KB RAM and was later ported to MS-DOS. Development of the MS-DOS version ended in 1995. The mathematical Software "Derive" was written in muLISP for MS-DOS and later for Windows up to 2007.
* [[XLISP]], which [[AutoLISP]] was based on.
* [[Standard Lisp]] and [[Portable Standard Lisp]] were widely used and ported, especially with the Computer Algebra System REDUCE.
Line 166 ⟶ 165:
Fifty years of Lisp (1958–2008) was celebrated at LISP50@OOPSLA.<ref name="Q9GcA">{{cite web|url=http://www.lisp50.org/ |title=LISP50@OOPSLA |publisher=Lisp50.org |access-date=2013-11-15}}</ref> 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 Revised<sup>5</sup> Report on the Algorithmic Language Scheme<ref name="92GaL">[http://www.schemers.org/Documents/Standards/R5RS/ Documents: Standards: R5RS]. schemers.org (2012-01-11). Retrieved on 2013-07-17.</ref> standard of Scheme was widely accepted in the Scheme community. The [[Scheme Requests for Implementation]] process has created a lot of quasi
There are several new dialects of Lisp: [[Arc (programming language)|Arc]], [[Hy (programming language)|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 (programming language)|Scheme]] (Julia is inspired by Scheme, which in turn is a Lisp dialect).
Line 247 ⟶ 246:
evaluates to 10. The equivalent under [[infix notation]] would be "{{Lisp2|1 + 2 + 3 + 4}}".
Lisp has no notion of operators as implemented in
<syntaxhighlight lang="Lisp">
(incf x)
Line 300 ⟶ 299:
===Conses and lists===
{{Main|Cons}}
[[File:Cons-
A Lisp list is implemented as a [[singly linked list]].<ref name="SebestaLanguages">{{cite book |last1=Sebesta |first1=Robert W. |title=Concepts of Programming Languages |chapter="2.4 Functional Programming: LISP";"6.9 List Types";"15.4 The First Functional Programming Language: LISP" |date=2012 |publisher=Addison-Wesley |___location=Boston, MA, US |isbn=978-0-13-139531-2 |pages=47–52;281–284;677–680 |edition=10th |url=https://www.pearson.com/us/higher-education/product/Sebesta-Concepts-of-Programming-Languages-10th-Edition/9780131395312.html |language=en |format=print}}</ref> 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|''car'' and ''cdr'']]. These are respectively equivalent to the {{Lisp2|data}} and {{Lisp2|next}} 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 {{Lisp2|nil}} (empty list) symbol, or a cons in which the {{Lisp2|car}} points to a datum (which may be another cons structure, such as a list), and the {{Lisp2|cdr}} points to another proper list.
Line 312 ⟶ 311:
====S-expressions represent lists====
[[File:Cons-cells.svg|thumb|right|300px|Box-and-[[pointer (computer programming)|pointer]] diagram for the list (42 69 613)]]
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 {{Lisp2|(a . b)}}, where {{Lisp2|a}} is the car and {{Lisp2|b}} the cdr. A longer proper list might be written {{Lisp2|(a . (b . (c . (d . nil))))}} in dotted-pair notation. This is conventionally abbreviated as {{Lisp2|(a b c d)}} in ''list notation''. An improper list<ref name="r3sL3">NB: 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.</ref> may be written in a combination of the two – as {{Lisp2|(a b c . d)}} for the list of three conses whose last cdr is {{Lisp2|d}} (i.e., the list {{Lisp2|(a . (b . (c . d)))}} in fully specified form).
Line 364:
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 {{Lisp2|quote}} special operator, or its abbreviation {{Lisp2|'}} (one quotation mark). For instance, usually if entering the symbol {{Lisp2|foo}}, it returns the value of the corresponding variable (or an error, if there is no such variable). To refer to the literal symbol, enter {{Lisp2|(quote foo)}} or, usually, {{Lisp2|'foo}}.
{{anchor|Backquote}}Both Common Lisp and Scheme also support the ''backquote'' operator (termed ''[[quasiquote]]'' in Scheme), entered with the {{Lisp2|`}} character ([[
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.
Line 396:
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, <code>eval-when</code>, that allows code to be present during compile time (when a macro would need it), but not present in the emitted module.<ref name="0iFgm">"[https://www.gnu.org/software/emacs/manual/html_node/cl/Time-of-Evaluation.html Time of Evaluation
===Evaluation and the read–eval–print loop===
Line 491:
Several [[operating system]]s, including [[language-based system]]s, are based on Lisp (use Lisp features, conventions, methods, data structures, etc.), or are written in Lisp,<ref>{{Cite news |last=Proven |first=Liam |date=29 March 2022 |url=https://www.theregister.com/2022/03/29/non_c_operating_systems/ |title=The wild world of non-C operating systems |work=[[The Register]] |access-date=2024-04-04}}</ref> including:
[[Genera (operating system)|Genera]], renamed Open Genera,<ref>{{Cite web |author=<!-- Unstated --> |date=7 January 2020 |url=https://archive.org/details/OpenGenera |title=Symbolics Open Genera 2.0 |website=[[GitHub]] Internet Archive |access-date=2022-02-02}}</ref> by [[Symbolics]]; Medley, written in Interlisp, originally a family of graphical operating systems that ran on [[Xerox]]'s later [[Xerox Star|Star]] [[workstation]]s;<ref>{{Cite web |author=<!-- Unstated --> |date=15 March 2022 |url=https://interlisp.org/ |title=Interlisp.org Project |website=Interlisp.org |access-date=2022-02-02}}</ref><ref>{{Cite web |author=<!-- Unstated --> |date=March 2022 |url=https://github.com/Interlisp/medley |title=Interlisp Medley |website=[[GitHub]] |access-date=2022-02-02}}</ref> Mezzano;<ref>{{Cite web |author=froggey |date=1 August 2021 |url=https://github.com/froggey/Mezzano |title=Mezzano |website=[[GitHub]] |access-date=2022-02-02}}</ref> Interim;<ref>{{Cite web |last=Hartmann |first=Lukas F. |date=10 September 2015 |url=http://interim-os.com/ |title=Interim |website=Interim-os |access-date=2022-02-02}}</ref><ref>{{Cite web |last=Hartmann |first=Lukas F. |date=11 June 2021 |url=https://github.com/mntmn/interim |title=Interim |website=[[GitHub]] |access-date=2022-02-02}}</ref> ChrysaLisp,<ref>{{Cite web |last=Hinsley |first=Chris |date=23 February 2022 |url=https://github.com/vygr/ChrysaLisp |title=ChrysaLisp |website=[[GitHub]] |access-date=2022-02-02}}</ref> by developers of Tao Systems' TAOS
==See also==
* [[Self-modifying code]]
==Footnotes==
{{notefoot}}
==References==
Line 596 ⟶ 599:
==External links==
{{Sister project links|wikt=Lisp|commons=Category:Lisp (programming language)|n=no|q=Lisp programming language|b=Subject:Lisp programming language|v=Topic:Lisp|s=Lambda Papers}}
* [http://www-formal.stanford.edu/jmc/history/lisp/lisp.html History of Lisp] – [[John McCarthy (computer scientist)|John McCarthy]]'s history of 12 February 1979
* [https://web.archive.org/web/20050617031004/http://www8.informatik.uni-erlangen.de/html/lisp-enter.html Lisp History] – Herbert Stoyan's history compiled from the documents (acknowledged by McCarthy as more complete than his own, see: [http://www-formal.stanford.edu/jmc/history/ McCarthy's history links])
Line 603 ⟶ 606:
* {{Cite news |last=Cassel |first=David |date=22 May 2022 |title=NASA Programmer Remembers Debugging Lisp in Deep Space |url=https://thenewstack.io/nasa-programmer-remembers-debugging-lisp-in-deep-space/ |website=The New Stack}}
* [http://www.alu.org/ Association of Lisp Users]
* [http://www.weitz.de/eclm2013/ European Common Lisp Meeting]
Line 609 ⟶ 612:
* [http://www.international-lisp-conference.org/ International Lisp Conference]
* ''[http://www.lisperati.com/casting.html Casting SPELs in Lisp]'', a comic-book style introductory tutorial
* ''[http://paulgraham.com/onlisptext.html On Lisp]'', a free book by [[Paul Graham (computer programmer)|Paul Graham]]
Line 617 ⟶ 620:
* [http://letoverlambda.com/ Let over Lambda]
* [http://purl.umn.edu/107476 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.
* [http://www.se-radio.net/2008/01/episode-84-dick-gabriel-on-lisp/ Interview] with [[Richard P. Gabriel]] (Podcast)
* [http://www.cliki.net/ CLiki: the Common Lisp wiki]
* [https://web.archive.org/web/20160311102031/http://www.cl-user.net/asp/erw/sdataQIvH87hu8NU%24DM%3D%3D/sdataQo5Y-1Mh9urk The Common Lisp Directory] (via the [[Wayback Machine]]; archived from [https://web.archive.org/web/20080905110332/http://cl-user.net/ the original])
| |||