imported>Joswig: /* Datentypen */ Atomic Symbols : "The symbols are atomic in the sense that any substructure they may have as sequences of characters is ignored." - https://www-formal.stanford.edu/jmc/recursive/node3.html

2025-08-31T21:54:48Z

Datentypen: Atomic Symbols : "The symbols are atomic in the sense that any substructure they may have as sequences of characters is ignored." - https://www-formal.stanford.edu/jmc/recursive/node3.html

Neue Seite

{{Dieser Artikel|behandelt die Programmiersprache. Zur Routing-Architektur LISP siehe [[Locator/Identifier Separation Protocol]].}}

{{Infobox Programmiersprache
| Name = Lisp
| Logo = [[Datei:Cons-Cell.svg|rahmenlos|Die Cons-Zelle ist der elementare Baustein sowohl für Programme als auch für Daten in Lisp.]]
| Beschreibung = Die Cons-Zelle ist der elementare Baustein sowohl für Programme als auch für Daten in Lisp.
| Dialekte = [[Common Lisp]], [[Scheme]], [[Emacs Lisp]] und viele weitere
| Erscheinungsjahr = 1958
| Designer = [[John McCarthy]]
| Entwickler = Steve Russell, Timothy P. Hart, Mike Levin
| Typisierung = [[Dynamische Typisierung|dynamisch]]
| Beeinflusst_von = [[Lambda-Kalkül]], [[Fortran]], [[Information Processing Language|IPL]]
| Beeinflusste = [[Logo (Programmiersprache)|Logo]], [[Perl (Programmiersprache)|Perl]], [[Smalltalk (Programmiersprache)|Smalltalk]], [[Clojure]], [[Python (Programmiersprache)|Python]], [[Reverse Polish LISP|RPL]], [[Ruby (Programmiersprache)|Ruby]], [[Dylan (Programmiersprache)|Dylan]], [[Mathematica]], [[REBOL]], [[Haskell (Programmiersprache)|Haskell]], [[Snap! (Programmiersprache)|Snap! / BYOB]]
| Paradigma = multiparadigmatisch: [[Funktionale Programmierung|funktional]], [[Prozedurale Programmierung|prozedural]]; manche Dialekte außerdem [[Modulare Programmierung|modular]], [[Objektorientierte Programmierung|objektorientiert]], [[Reflexion (Programmierung)|reflexiv]]
}}
'''Lisp''' ist eine Familie von [[Programmiersprache]]n, die 1958 erstmals spezifiziert wurde und am [[Massachusetts Institute of Technology]] (MIT) in Anlehnung an den ungetypten [[Lambda-Kalkül]] entstand. Es ist nach [[Fortran]] die zweitälteste Programmiersprache, die noch verbreitet ist.

Auf Basis von Lisp entstanden zahlreiche [[Dialekt#Dialekte bei Programmiersprachen|Dialekte]]. Zu den bekanntesten zählen [[Common Lisp]] und [[Scheme]]. Daher bezieht sich der Begriff ''Lisp'' oft auf die Sprachfamilie und nicht auf einen konkreten Dialekt oder eine konkrete [[Implementierung]].

== Geschichte ==
[[Datei:LISP machine.jpg|mini|Eine [[Lisp-Maschine]] im MIT-Museum]]
Lisp steht für '''Lis'''t '''P'''rocessor (Listen Prozessor). Damit waren ursprünglich [[Fortran]]-Unterprogramme gemeint, mit denen symbolische Berechnungen durchgeführt werden sollten, wie sie der [[Lambda-Kalkül]] definiert. Steve Russell, einer der Studenten von [[John McCarthy]], kam dann auf die fundamentale Idee, auf Grundlage dessen Formulierung eines „Lisp-Interpreters in Lisp“ einen [[Interpreter]] für diese Ausdrücke für die [[IBM 704]] zu schreiben. Damit war die Programmiersprache Lisp geboren.

Die Grund[[datenstruktur]]en von Lisp sind Einzelwerte (z. B. Symbole, Zahlen, Zeichenketten), die ''[[#Datentypen|Atome]]'' genannt werden, und Cons-Zellen, aus denen [[Liste (Datenstruktur)|Listen]] gebildet werden. Die Listen können beliebig verschachtelt werden ''(Listen von Listen)''. Damit lassen sich auch leicht Datenstrukturen wie ein [[Assoziatives Datenfeld|assoziatives Array]] implementieren. Listen werden zur Darstellung in Lisp in runde Klammern gefasst:

<syntaxhighlight lang="lisp">
(A B C)
</syntaxhighlight>

Auch Programmanweisungen sind (verschachtelte) Listen, bei denen das jeweils erste Listenelement die auszuführende Funktion identifiziert. Es gibt somit keinen grundsätzlichen Unterschied zwischen Daten und Programmen; diese Eigenschaft wird [[Homoikonizität]] genannt. Der Programmierer kann so beispielsweise neue [[Kontrollstruktur]]en oder Objektsysteme ([[Objektorientierte Programmierung|OOP]]) entwickeln ([[Metaprogrammierung]], [[Makro]]s). Es ermöglicht aber auch Programmteile zur Laufzeit beliebig zu manipulieren.

Lisp bietet dem Programmierer große Flexibilität und weitreichende Einflussmöglichkeiten, weshalb es manchmal auch als ''programmierbare Programmiersprache'' bezeichnet wird. Datenstrukturen werden dynamisch aufgebaut, ohne dass der Programmierer explizit Speicherplatz reservieren oder freigeben muss (siehe auch [[Garbage Collection]]). Deklarationen für Datentypen sind optional und ein Lisp-Symbol kann als Variable für beliebige Arten von Objekten stehen. Viele dieser Eigenschaften sind im Laufe der Zeit in weitere Programmiersprachen übernommen worden. Anfang der 1960er waren sie jedoch ihrer Zeit weit voraus.

In den 1970er und 1980er Jahren wurden spezielle [[Lisp-Maschine]]n entwickelt und vertrieben. Diese ermöglichten das schnelle Ausführen von Lisp-Programmen, was auf damaligen allgemeinen Computern nur unter dem Verzicht auf [[Typisierung (Informatik)|Typüberprüfung]] und automatische Speicherbereinigung möglich war. Dies hat sich durch schnellere Computer jedoch geändert.

Programme in Lisp können interpretiert oder von einem [[Compiler]] in effizienten Code übersetzt werden. Typische Compiler sind Batch-Compiler oder inkrementelle Compiler. Inkrementelle Compiler können einzelne Ausdrücke übersetzen. Batch-Compiler übersetzen einzelne Lisp-Dateien oder ganze Lisp-Programme. Compiler übersetzen entweder in einen [[Bytecode]] für eine [[virtuelle Maschine]], in andere Programmiersprachen (oft in C) für die weitere Übersetzung oder in [[Maschinensprache|Maschinencode]] für einen [[Prozessor]].

Das [[Akronym]] ''LISP'' wird manchmal scherzhaft als „Lots of Irritating Superfluous Parentheses“ (eine Menge lästiger, überflüssiger Klammern) interpretiert.

== Bedeutung ==
Historisch gesehen gehört Lisp zusammen mit [[Prolog (Programmiersprache)|Prolog]] zu den wichtigsten Programmiersprachen der [[Künstliche Intelligenz|künstlichen Intelligenz]]. Durch Lisp ist erstmals der Lambda-Kalkül zum Kern einer Programmiersprache gemacht worden. Dieser ist ein wesentliches Element der Semantik vieler moderner Programmiersprachen.

Im Unterschied zu Europa, wo Programmiersprachen wie [[Assemblersprache|Assembler]], [[Fortran]] oder [[Pascal (Programmiersprache)|Pascal]] als klassische Vertreter der Familie der [[Prozedurale Programmierung|prozeduralen Programmiersprachen]] gelehrt wurden, war und ist zum Teil bis heute in den Vereinigten Staaten Lisp, bzw. einer seiner moderneren Dialekte wie [[Scheme]], die erste gelehrte Programmiersprache. Das hatte einen großen Einfluss, da es sich bei den klassischen Vertretern der prozeduralen Sprachfamilien um Vertreter einer ''statischen'' Verarbeitungsweise von Daten handelt, während unter anderem Lisp ein strikt ''dynamisches'' Konzept vertritt.

== Syntax ==
Lisp benutzt [[#Symbolische Ausdrücke|S-Expressions]] als externes Format, um sowohl [[Quelltext]] als auch Daten darzustellen. Funktions- und Makroaufrufe werden als Listen geschrieben, die als erstes Element den Namen der Funktion bzw. des Makros enthalten. Kommentare werden mit einem oder mehreren <code lang="lisp">;</code> eingeleitet.

Beispiele in Common Lisp:

<syntaxhighlight lang="lisp">
;; Addiere 2 und 3 und 4:
(+ 2 3 4)

;; Setze die Variable p auf den Wert 3,1415:
(setf p 3.1415)

;; Definiere eine Funktion, die ihr Argument quadriert:
(defun square (x)
(* x x))

;; Quadriere die Zahl 3:
(square 3)
</syntaxhighlight>

LISP-[[Hallo-Welt-Programm]]:

<syntaxhighlight lang="lisp">
(princ "Hello, world!")
(terpri)
</syntaxhighlight>

Mit <code>(terpri)</code><ref>{{Internetquelle |autor=Foldoc Jargon File |url=http://foldoc.org/terpri |titel=Herkunft des Schlüsselworts terpri |abruf=2010-12-02}}</ref> erfolgt ein [[Zeilenumbruch]].

== Minimaler Funktionsumfang für Lisp ==
Um ein minimales Lisp-System zu implementieren, sind nur sehr wenige Operatoren und ein allgemeiner Mechanismus zur Funktionsdefinition nötig.
Die folgenden Funktionen sind im ursprünglichen Bericht von McCarthy enthalten:

* <code>first</code> (gibt das erste Element einer Liste zurück; hieß ursprünglich <code>car</code> (von Contents of Address Part of Register))
* <code>rest</code> (gibt die Restliste (ohne das erste Element) zurück; hieß ursprünglich <code>cdr</code> (von Contents of Decrement Part of Register))
* <code>cons</code> (Erzeugt aus zwei [[Zeiger (Informatik)|Zeigern]] ein CONS-Paar und gibt einen Zeiger auf dieses zurück. Kann zum Beispiel verwendet werden, um ein Element an den Anfang einer Liste anzufügen) (von CONStruct)
* <code>quote</code> (verhindert die Auswertung des nachfolgenden Objekts)
* <code>eq</code> (Test auf Identität zweier oder mehrerer Objekte)
* <code>cond</code> (bedingte Ausführung: Übernimmt eine beliebig lange Liste von Paaren, die jeweils aus einer Bedingung und einer Berechnungsvorschrift bestehen. Gibt das Auswertungsergebnis der ersten Berechnungsvorschrift zurück, deren zugehörige Bedingung wahr ist)
* Mechanismus zur Funktionsdefinition <code>[[Anonyme Funktion|lambda]]</code>

Bereits mit diesen Sprachmitteln kann ein bemerkenswerter Teil der Funktionen, die übliche Lisp-Systeme mitbringen, definiert werden.

== Datentypen ==
[[Datei:Cons-Cell.svg|mini|Cons-Zelle als allgegenwärtige ikonographische Darstellung in der LISP-Literatur.]]
In der Originalversion von Lisp gab es zwei grundsätzliche Arten [[Datentyp]]en: Atomare Symbole und [[Liste (Datenstruktur)|Listen]]. Atomare Symbole hießen so, weil sie nicht zerlegt werden konnten.

Listen waren Sequenzen von Elementen, wobei diese Elemente Atome oder Unterlisten sein konnten. Die Listen selbst wurden aus Cons-Zellen, einem Paar von Zeigern, gebildet, dessen erste Komponente auf das Element verweist, die zweite aber auf den Rest der Liste. Die leere Liste bzw. das Ende der Liste wird durch das Atom 'NIL' präsentiert. Die Zellen wurden in der Literatur wie rechts gezeigt visualisiert und dienten zusammengenommen als [[#Symbolische Ausdrücke|S-Ausdrücke]] auch zur Darstellung des LISP-Quelltexts selbst.

Ein Atom war entweder eine Zahl oder ein Symbol. Ein Symbol war eine alphanumerische Zeichenkette, die als Variablenname oder Datenelement beim symbolischen Rechnen verwendet wurde.

Intern wurde ein Symbol-Atom nur einmal in der [[Symboltabelle]] abgespeichert. Zwei Symbolatome, die gleich geschrieben wurden und an verschiedenen Stellen im Quelltext vorkamen, repräsentierten dasselbe Objekt.

Später wurden in den Lisp-Dialekten weitere Datentypen eingeführt, und das Konzept der Lisp-Atome verlor an Bedeutung.

=== Symbolische Ausdrücke ===

{| class="float-right wikitable infobox"
|align=center style="background:#e0e0ff"|'''Symbolische Ausdrücke'''
|-
| <math>
\begin{array}{lrlll}
Sexp & = & Atom & \textrm{atom}\\
& \vert & ( List ) & \textrm{list}\\
List & = & & \textrm{nil }\\
& \vert & Sexp \,\, List & \textrm{cons}\\
\end{array}
</math>
|}

Die Denotation der Lisp-Daten entsprechend der rechts gezeigten Grammatik eröffnet die Möglichkeit, diese Syntax selbst zu verwenden, um Lisp-Programme als Lisp-Daten (S-Ausdrücke, S-Expressions) niederzuschreiben.

Umgekehrt kann diese sehr einfache Grammatik verwendet werden, um sowohl Daten als auch Programme einzulesen und zu bearbeiten oder zu interpretieren.

John McCarthy beschreibt die Weise der Niederschrift von Programmen im Abschnitt 1.6 (A Universal LISP Function) des Lisp-Handbuchs, womit zugleich auch ein Lisp-Interpreter in Lisp selbst angegeben wird.

[[Datei:S-Expression drawing example representing '(defun square (x) (* x x))'.svg|gerahmt|zentriert|Beispiel für die Präsentation der Definition '(defun square (x) (* x x))'.]]

Diese enge Verzahnung der Repräsentation von Programmen und Daten stellt eine besondere Charakteristik der Lisp-Programmierung dar.

== Zitate ==
{{Zitat
|Text=Lisp is a programmable programming language.
|Sprache=en
|Autor=John Foderaro
|Quelle=[[Communications of the ACM|CACM]], September 1991
|Übersetzung=Lisp ist eine programmierbare Programmiersprache.
|ref=<ref>[http://www.paulgraham.com/chameleon.html ''Lisp is a Chameleon''.] paulgraham.com</ref>}}

{{Zitat
|Text=Lisp seems to be a lucky discovery of a local maximum in the space of programming languages.
|Sprache=en
|Autor=John McCarthy
|Quelle=[https://letoverlambda.com/index.cl/guest/chap1.html Let Over Lambda]
|Übersetzung=Lisp scheint die glückliche Entdeckung eines [[Extremwert|lokalen Maximums]] in der Menge der Programmiersprachen zu sein.}}

== Lisp-Dialekte ==

=== Historisch relevante Dialekte ===

* ''LISP 1.5'' war die erste Lisp-Version, die über das MIT hinaus verbreitet wurde und enthält die erste funktionsfähige Quelle einer Lisp-Implementierung.
* [[Maclisp]] war ein weit verbreiteter und einflussreicher Vorläufer von Common Lisp und die ursprüngliche Implementationssprache des [[Computeralgebrasystem]]s [[Macsyma]].
* ''InterLisp'' entwickelte sich ab 1967 aus ''BBN-Lisp'' und wurde zu ''Interlisp-D'' weiterentwickelt, das ein komplettes Entwicklungssystem für die [[Lisp-Maschine]] [[Xerox Alto|Xerox Dolphin]] bildete. 1992 verlieh die [[Association for Computing Machinery|ACM]] den Software System Award an [[Daniel G. Bobrow]], Richard R. Burton, [[L Peter Deutsch]], Ronald Kaplan, Larry Masinter und Warren Teitelman für ihre Pionierarbeit an InterLisp.
* ''ZetaLisp'' (auch ''Lisp Machine Lisp'' genannt) ist eine Weiterentwicklung von Maclisp und lief auf verschiedenen [[Lisp-Maschine]]n. Auf Basis dieses Dialekts wurde [[Flavors (Programmiersprache)|Flavors]], die erste [[Objektorientierte Programmierung|objektorientierte]] Erweiterung, entwickelt.
* ''Franz Lisp'' wurde 1978 aus MacLisp entwickelt, um auf einer [[Virtual Address eXtension|VAX]] das Computeralgebrasystem Macsyma laufen zu lassen. Es fand weite Verbreitung, weil es mit [[Berkeley Software Distribution|BSD]] [[Unix]] ausgeliefert wurde. Später wurde die Firma Franz Inc. gegründet, um dieses Lisp zu pflegen. Seit Mitte der 80er Jahre verkauft Franz Inc. aber eine Common-Lisp-Implementierung (Allegro CL).
* ''[[XLISP]]'' ist ein LISP mit objektorientierten Erweiterungen, das auch auf schwächeren Computern lief. Eine bekannte Anwendung ist das Statistikpaket XLispStat.
* ''EuLisp'' war ein europäischer Versuch, ein aufgeräumtes und einheitliches Lisp zu definieren.
* ''ISLisp'' ist ein [[Internationale Organisation für Normung|ISO]]-standardisierter, kompakter Lisp-Dialekt, der sich für die Programmierung [[Eingebettetes System|eingebetteter Systeme]] eignet.
* ''Portable Standard Lisp'' und das sogenannte ''Standard Lisp'' wurden ab 1980 an der [[University of Utah]] entwickelt und vor allem für das Computeralgebrasystem [[Reduce (Computeralgebrasystem)|Reduce]] genutzt. Darin war es in einer [[ALGOL]]-artigen Syntax als Skriptsprache ''RLISP'' nutzbar.
* ''S-1 Lisp'' war ein Lisp für den [[Supercomputer]] S-1 Mark IIA.

=== Später verbreitete Dialekte ===
* [[Common Lisp]] ist der umfangreichste und in der Praxis am häufigsten eingesetzte Lisp-Dialekt. Er ist [[American National Standards Institute|ANSI]]-standardisiert und bietet Unterstützung für prozedurale Makros, lexikalische wie dynamische Variablenbindung und vieles mehr. Der Name erinnert an die Absicht, mehrere inkompatible Bestrebungen zu vereinigen, einen Nachfolger für [[Maclisp]] zu finden (''ZetaLisp'', [[CMU Common Lisp|Spice Lisp]], ''NIL'' und ''S-1 Lisp''). Weitere Einflüsse waren ''InterLisp'' und ''Scheme''.
* [[Scheme]] ist eine minimale und elegante Variante, die u. a. [[Continuation]]s unterstützt. Im Gegensatz zu Common Lisp kennt sie nur lexikalische Variablenbindung und hygienische Makros. Sie findet aufgrund ihrer Einfachheit häufig in der Lehre Gebrauch, obgleich auch produktive Programmierung mit ihr möglich ist und praktiziert wird.
* [[Clojure]] ist ein Lisp-Dialekt, der auf der [[Java Virtual Machine]] läuft und [[Interoperabilität]] zu [[Java (Programmiersprache)|Java]] bietet.
* [[Emacs Lisp]] ist die [[Skriptsprache]] des [[Texteditor]]s [[Emacs|GNU Emacs]].

=== Dialekte für besondere Zwecke ===
* [[AutoLISP]] ist die auf einer frühen Version von XLISP basierende Skriptsprache für das CAD-System [[AutoCAD]].
* ''librep'' oder kurz ''rep'' ist eine Skriptsprache für [[Unixoides System|unixartige Systeme]] und orientierte sich anfangs an ''Emacs Lisp'', hat aber [[Variable (Programmierung)#Sichtbarkeitsbereich von Variablen (Scope)|lexikalische statt dynamischer Variablenbindung]]. Der [[Fenstermanager]] [[Sawfish]] wurde in rep geschrieben.
* [[muLISP]] läuft unter [[CP/M]] und [[MS-DOS]] sowie auf einigen [[Programmierbarer Taschenrechner|programmierbaren Taschenrechnern]]. Es wurde benutzt, um das Computeralgebrasystem [[Derive]] zu implementieren.
* [[Nyquist (Programmiersprache)|Nyquist]] ist eine Sprache für [[Klangsynthese]] und -analyse und basiert auf XLISP.
* [[Racket (Programmiersprache)|Racket]] ist ein vorrangig für die Entwicklung von Programmiersprachen konzipierter Scheme-Dialekt.
* [[Reverse Polish LISP|RPL]] läuft auf programmierbaren Taschenrechnern, insbesondere auf solchen von [[HP Inc.|Hewlett-Packard]]. Es handelt sich dabei um eine Lisp-Version, die mit der [[Umgekehrte polnische Notation|umgekehrten polnischen Notation]] vermischt wurde.
* [[System Management Language]] ist erweitert um Sprachstrukturen zur objekt- und [[Ereignis (Programmierung)|ereignisorientierten]] Programmierung. Sie enthält [[Programmierschnittstelle|APIs]] für [[Motif|X/Motif]], [[Content Management Interoperability Services|CMIS]] und weitere.

=== Neuere Entwicklungen ===
* ''Arc'' ist ein von [[Paul Graham]] und [[Robert Tappan Morris|Robert Morris]] entwickelter Dialekt.<ref>[http://arclanguage.org/ ''Arc Forum''], abgerufen am 6. November 2016.</ref>
* [[NewLISP]] ist eine [[Skriptsprache]]<ref>[http://www.newlisp.org/index.cgi?FAQ About newLISP]</ref>
* ''Hy'' ist ein Lisp-Dialekt, der eng mit Python verzahnt ist.
* ''lfe'' ist ein Lisp-Dialekt für die [[Erlang (Programmiersprache)|Erlang VM]]<ref>{{Internetquelle |url=http://lfe.io/ |titel=(lisp (flavoured (erlang))) |abruf=2019-07-07}}</ref>

== Literatur ==
* {{Literatur |Autor=[[John McCarthy]] |Titel=LISP 1.5: Programmer's Manual |Verlag=The MIT Press |Ort=Cambridge, Mass. |Datum=1962 |Umfang=106}}

* {{Literatur |Autor=Anthony C. Hearn |Titel=Standard LISP |Verlag=University |Ort=Stanford, Calif. |Datum=1969}}

* Walter Sonnenberg: ''Anwendung von Lisp zur Definition und Implementierung Algolähnlicher Programmiersprachen.'' Universität Karlsruhe, 1970.

* {{Literatur |Hrsg=John McCarthy, Carolyn L. Talcott |Titel=LISP: Programming and proving |Verlag=Stanford University |Ort=Stanford |Datum=1978}}

* {{Literatur |Autor=[[Herbert Stoyan]] |Titel=LISP-Programmierhandbuch: Eine Sprache für die nichtnumerische Informationsverarbeitung |Verlag=Akademie-Verlag |Ort=Berlin |Datum=1978 |Umfang=208}}

* John Allen: ''Anatomy of Lisp''. McGraw-Hill, 1978, ISBN 0-07-001115-X.

* {{Literatur |Autor=Herbert Stoyan |Titel=LISP: Anwendungsgebiete, Grundbegriffe, Geschichte |Verlag=Akademie-Verlag |Ort=Berlin |Datum=1980 |Umfang=480}}

* {{Literatur |Hrsg=Herbert Stoyan, Günther Görz |Titel=LISP: Eine Einführung in die Programmierung |Verlag=Springer |Ort=Berlin |Datum=1984 |ISBN=3540131582 |Umfang=358}}

* Patrick Henry Winston, Berthold Horn: ''Lisp''. Addison-Wesley Verlag, 1987, ISBN 3-925118-61-6.
* Harold Abelson, [[Gerald Jay Sussman]]: ''[https://mitpress.mit.edu/sicp/ Structure and Interpretation of Computer Programs (SICP)]''. MIT Press, 1993, ISBN 978-0-262-01153-2.
* Christian Queinnec: ''Lisp in Small Pieces''. Cambridge University Press, 2003, ISBN 0-521-54566-8.

== Weblinks ==
* {{Internetquelle |autor=John McCarthy et al. |url=https://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf |titel=Lisp 1.5 Programmer’s Manual |format=PDF; 4,5 MB |sprache=en |abruf=2025-02-10 |abruf-verborgen=ja}}
* {{Internetquelle |autor=John McCarthy |url=https://www-formal.stanford.edu/jmc/recursive.pdf |titel=Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I |format=PDF; 214 kB |sprache=en |abruf=2025-02-10 |abruf-verborgen=ja}}
* {{Internetquelle |autor=Paul Graham |url=https://www.paulgraham.com/lib/paulgraham/jmc.ps |titel=The Roots of Lisp |format=PostScript; 208 kB |sprache=en |abruf=2025-02-10 |abruf-verborgen=ja |kommentar=eine konzise Einführung in Anlehnung an McCarthys Arbeit}}
* {{Internetquelle |autor=Paul McJones |url=https://www.softwarepreservation.org/projects/LISP/ |titel=History of LISP |hrsg=Software Preservation Group am [[Computer History Museum]] |sprache=en |abruf=2025-02-10 |abruf-verborgen=ja}}
* {{Internetquelle |autor=Paul Graham |url=https://languagelog.ldc.upenn.edu/myl/ldc/llog/jmc.pdf |titel=The Roots of Lisp |format=PDF; 141 kB |sprache=en |abruf=2025-02-10 |abruf-verborgen=ja}}
* {{Internetquelle |autor=Guy L. Steele Jr., Richard P. Gabriel |url=https://www.dreamsongs.com/Files/HOPL2-Uncut.pdf |titel=The Evolution of Lisp |format=PDF; 996 kB |sprache=en |abruf=2025-02-10 |abruf-verborgen=ja}}
* {{Internetquelle |autor=Tim Pritlove, Hans Hübner |url=https://cre.fm/cre084-lisp |titel=Lisp – Die Mutter aller Programmiersprachen |hrsg=[[CRE (Podcast)|CRE]] |format=Podcast; 01:35:28 h |sprache=de |abruf=2025-02-10 |abruf-verborgen=ja}}

== Einzelnachweise ==
<references />

{{Normdaten|TYP=s|GND=4035918-9|LCCN=sh85077449}}

[[Kategorie:Lisp| ]]
[[Kategorie:Funktionale Programmiersprache]]
[[Kategorie:Abkürzung]]

Lisp - Versionsgeschichte

imported>Joswig: /* Datentypen */ Atomic Symbols : "The symbols are atomic in the sense that any substructure they may have as sequences of characters is ignored." - https://www-formal.stanford.edu/jmc/recursive/node3.html