Page 1
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Common Lisp - viel mehr als nur damlicheKlammern
Alexander Schreiber <[email protected] >
http://www.thangorodrim.de
Chemnitzer Linux-Tage 2005
Greenspun’s Tenth Rule of Programming:
“Any sufficiently-complicated C or Fortran programcontains an ad-hoc, informally-specified bug-ridden slowimplementation of half of Common Lisp.”
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 1 / 30
Page 2
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Ubersicht
1 Einfuhrung
2 Geschichtliches
3 Die Programmiersprache
4 Abschluß
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 2 / 30
Page 3
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp? Wofur?
NASA: Remote Agent (Deep Space 1), Planner (MarsPathfinder),
Viaweb, gekauft von Yahoo fur 50 Millionen $,
ITA Software: Orbitz engine (Flugticket Planung),
Square USA: Production tracking fur “Final Fantasy”,
Naughty Dog Software: Crash Bandicoot auf SonyPlaystation,
AMD & AMI: Chip-Design & Verifizierung,
typischerweise komplexe Probleme: Wissensverarbeitung,Expertensysteme, Planungssysteme
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 3 / 30
Page 4
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp? Wofur?
NASA: Remote Agent (Deep Space 1), Planner (MarsPathfinder),
Viaweb, gekauft von Yahoo fur 50 Millionen $,
ITA Software: Orbitz engine (Flugticket Planung),
Square USA: Production tracking fur “Final Fantasy”,
Naughty Dog Software: Crash Bandicoot auf SonyPlaystation,
AMD & AMI: Chip-Design & Verifizierung,
typischerweise komplexe Probleme: Wissensverarbeitung,Expertensysteme, Planungssysteme
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 3 / 30
Page 5
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp? Wofur?
NASA: Remote Agent (Deep Space 1), Planner (MarsPathfinder),
Viaweb, gekauft von Yahoo fur 50 Millionen $,
ITA Software: Orbitz engine (Flugticket Planung),
Square USA: Production tracking fur “Final Fantasy”,
Naughty Dog Software: Crash Bandicoot auf SonyPlaystation,
AMD & AMI: Chip-Design & Verifizierung,
typischerweise komplexe Probleme: Wissensverarbeitung,Expertensysteme, Planungssysteme
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 3 / 30
Page 6
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp? Wofur?
NASA: Remote Agent (Deep Space 1), Planner (MarsPathfinder),
Viaweb, gekauft von Yahoo fur 50 Millionen $,
ITA Software: Orbitz engine (Flugticket Planung),
Square USA: Production tracking fur “Final Fantasy”,
Naughty Dog Software: Crash Bandicoot auf SonyPlaystation,
AMD & AMI: Chip-Design & Verifizierung,
typischerweise komplexe Probleme: Wissensverarbeitung,Expertensysteme, Planungssysteme
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 3 / 30
Page 7
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp? Wofur?
NASA: Remote Agent (Deep Space 1), Planner (MarsPathfinder),
Viaweb, gekauft von Yahoo fur 50 Millionen $,
ITA Software: Orbitz engine (Flugticket Planung),
Square USA: Production tracking fur “Final Fantasy”,
Naughty Dog Software: Crash Bandicoot auf SonyPlaystation,
AMD & AMI: Chip-Design & Verifizierung,
typischerweise komplexe Probleme: Wissensverarbeitung,Expertensysteme, Planungssysteme
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 3 / 30
Page 8
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp? Wofur?
NASA: Remote Agent (Deep Space 1), Planner (MarsPathfinder),
Viaweb, gekauft von Yahoo fur 50 Millionen $,
ITA Software: Orbitz engine (Flugticket Planung),
Square USA: Production tracking fur “Final Fantasy”,
Naughty Dog Software: Crash Bandicoot auf SonyPlaystation,
AMD & AMI: Chip-Design & Verifizierung,
typischerweise komplexe Probleme: Wissensverarbeitung,Expertensysteme, Planungssysteme
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 3 / 30
Page 9
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp? Wofur?
NASA: Remote Agent (Deep Space 1), Planner (MarsPathfinder),
Viaweb, gekauft von Yahoo fur 50 Millionen $,
ITA Software: Orbitz engine (Flugticket Planung),
Square USA: Production tracking fur “Final Fantasy”,
Naughty Dog Software: Crash Bandicoot auf SonyPlaystation,
AMD & AMI: Chip-Design & Verifizierung,
typischerweise komplexe Probleme: Wissensverarbeitung,Expertensysteme, Planungssysteme
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 3 / 30
Page 10
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Common Lisp in Schlagworten
zweitalteste Programmiersprache (nach FORTRAN),
funktional, imperativ, objekt-orientiert,
strong typing, dynamic typing, late binding,
Funktionen als first class objects,
Symbolverarbeitung,
REPL: interaktive Entwicklung,
garbage collector,
einfacher Sprachkern – machtige Umgebung,
einheitliche Darstellung von Programm und Daten,
“the programmable programming language”,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 4 / 30
Page 11
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Common Lisp in Schlagworten
zweitalteste Programmiersprache (nach FORTRAN),
funktional, imperativ, objekt-orientiert,
strong typing, dynamic typing, late binding,
Funktionen als first class objects,
Symbolverarbeitung,
REPL: interaktive Entwicklung,
garbage collector,
einfacher Sprachkern – machtige Umgebung,
einheitliche Darstellung von Programm und Daten,
“the programmable programming language”,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 4 / 30
Page 12
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Common Lisp in Schlagworten
zweitalteste Programmiersprache (nach FORTRAN),
funktional, imperativ, objekt-orientiert,
strong typing, dynamic typing, late binding,
Funktionen als first class objects,
Symbolverarbeitung,
REPL: interaktive Entwicklung,
garbage collector,
einfacher Sprachkern – machtige Umgebung,
einheitliche Darstellung von Programm und Daten,
“the programmable programming language”,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 4 / 30
Page 13
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Common Lisp in Schlagworten
zweitalteste Programmiersprache (nach FORTRAN),
funktional, imperativ, objekt-orientiert,
strong typing, dynamic typing, late binding,
Funktionen als first class objects,
Symbolverarbeitung,
REPL: interaktive Entwicklung,
garbage collector,
einfacher Sprachkern – machtige Umgebung,
einheitliche Darstellung von Programm und Daten,
“the programmable programming language”,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 4 / 30
Page 14
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Common Lisp in Schlagworten
zweitalteste Programmiersprache (nach FORTRAN),
funktional, imperativ, objekt-orientiert,
strong typing, dynamic typing, late binding,
Funktionen als first class objects,
Symbolverarbeitung,
REPL: interaktive Entwicklung,
garbage collector,
einfacher Sprachkern – machtige Umgebung,
einheitliche Darstellung von Programm und Daten,
“the programmable programming language”,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 4 / 30
Page 15
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Common Lisp in Schlagworten
zweitalteste Programmiersprache (nach FORTRAN),
funktional, imperativ, objekt-orientiert,
strong typing, dynamic typing, late binding,
Funktionen als first class objects,
Symbolverarbeitung,
REPL: interaktive Entwicklung,
garbage collector,
einfacher Sprachkern – machtige Umgebung,
einheitliche Darstellung von Programm und Daten,
“the programmable programming language”,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 4 / 30
Page 16
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Common Lisp in Schlagworten
zweitalteste Programmiersprache (nach FORTRAN),
funktional, imperativ, objekt-orientiert,
strong typing, dynamic typing, late binding,
Funktionen als first class objects,
Symbolverarbeitung,
REPL: interaktive Entwicklung,
garbage collector,
einfacher Sprachkern – machtige Umgebung,
einheitliche Darstellung von Programm und Daten,
“the programmable programming language”,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 4 / 30
Page 17
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Common Lisp in Schlagworten
zweitalteste Programmiersprache (nach FORTRAN),
funktional, imperativ, objekt-orientiert,
strong typing, dynamic typing, late binding,
Funktionen als first class objects,
Symbolverarbeitung,
REPL: interaktive Entwicklung,
garbage collector,
einfacher Sprachkern – machtige Umgebung,
einheitliche Darstellung von Programm und Daten,
“the programmable programming language”,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 4 / 30
Page 18
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Common Lisp in Schlagworten
zweitalteste Programmiersprache (nach FORTRAN),
funktional, imperativ, objekt-orientiert,
strong typing, dynamic typing, late binding,
Funktionen als first class objects,
Symbolverarbeitung,
REPL: interaktive Entwicklung,
garbage collector,
einfacher Sprachkern – machtige Umgebung,
einheitliche Darstellung von Programm und Daten,
“the programmable programming language”,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 4 / 30
Page 19
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Common Lisp in Schlagworten
zweitalteste Programmiersprache (nach FORTRAN),
funktional, imperativ, objekt-orientiert,
strong typing, dynamic typing, late binding,
Funktionen als first class objects,
Symbolverarbeitung,
REPL: interaktive Entwicklung,
garbage collector,
einfacher Sprachkern – machtige Umgebung,
einheitliche Darstellung von Programm und Daten,
“the programmable programming language”,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 4 / 30
Page 20
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp als Innovationsmotor 1/2
Conditionals ((cond ...)),
rekursive Funktionsaufrufe,
dynamische Speicherverwaltung,
Garbage Collector,
first class functions,
lexical closures
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 5 / 30
Page 21
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp als Innovationsmotor 1/2
Conditionals ((cond ...)),
rekursive Funktionsaufrufe,
dynamische Speicherverwaltung,
Garbage Collector,
first class functions,
lexical closures
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 5 / 30
Page 22
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp als Innovationsmotor 1/2
Conditionals ((cond ...)),
rekursive Funktionsaufrufe,
dynamische Speicherverwaltung,
Garbage Collector,
first class functions,
lexical closures
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 5 / 30
Page 23
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp als Innovationsmotor 1/2
Conditionals ((cond ...)),
rekursive Funktionsaufrufe,
dynamische Speicherverwaltung,
Garbage Collector,
first class functions,
lexical closures
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 5 / 30
Page 24
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp als Innovationsmotor 1/2
Conditionals ((cond ...)),
rekursive Funktionsaufrufe,
dynamische Speicherverwaltung,
Garbage Collector,
first class functions,
lexical closures
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 5 / 30
Page 25
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp als Innovationsmotor 1/2
Conditionals ((cond ...)),
rekursive Funktionsaufrufe,
dynamische Speicherverwaltung,
Garbage Collector,
first class functions,
lexical closures
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 5 / 30
Page 26
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp als Innovationsmotor 2/2
interaktive Programmierung
Compilertechnologie,
inkrementelles Compilieren,
dynamic typing,
erste standardisierte objektorientierte Sprache (CLOS)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 6 / 30
Page 27
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp als Innovationsmotor 2/2
interaktive Programmierung
Compilertechnologie,
inkrementelles Compilieren,
dynamic typing,
erste standardisierte objektorientierte Sprache (CLOS)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 6 / 30
Page 28
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp als Innovationsmotor 2/2
interaktive Programmierung
Compilertechnologie,
inkrementelles Compilieren,
dynamic typing,
erste standardisierte objektorientierte Sprache (CLOS)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 6 / 30
Page 29
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp als Innovationsmotor 2/2
interaktive Programmierung
Compilertechnologie,
inkrementelles Compilieren,
dynamic typing,
erste standardisierte objektorientierte Sprache (CLOS)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 6 / 30
Page 30
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp als Innovationsmotor 2/2
interaktive Programmierung
Compilertechnologie,
inkrementelles Compilieren,
dynamic typing,
erste standardisierte objektorientierte Sprache (CLOS)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 6 / 30
Page 31
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Wie alles begann
Anfange 1956 - Listenverarbeitung in FORTRAN,
John McCarthy: mathematische Notation fur rekursiveFunktionen symbolischer Ausdrucke,
Steve Russell: Notation einfach auf Computer ausfuhrbar−→ Programmiersprache,
1959: erster Lisp-Interpreter am MIT,
System IBM 704, 36 Bit Maschine, car & cdr,
ab 1962 verschiedene Implementationen,
1976: Lisp Maschinen
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 7 / 30
Page 32
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Wie alles begann
Anfange 1956 - Listenverarbeitung in FORTRAN,
John McCarthy: mathematische Notation fur rekursiveFunktionen symbolischer Ausdrucke,
Steve Russell: Notation einfach auf Computer ausfuhrbar−→ Programmiersprache,
1959: erster Lisp-Interpreter am MIT,
System IBM 704, 36 Bit Maschine, car & cdr,
ab 1962 verschiedene Implementationen,
1976: Lisp Maschinen
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 7 / 30
Page 33
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Wie alles begann
Anfange 1956 - Listenverarbeitung in FORTRAN,
John McCarthy: mathematische Notation fur rekursiveFunktionen symbolischer Ausdrucke,
Steve Russell: Notation einfach auf Computer ausfuhrbar−→ Programmiersprache,
1959: erster Lisp-Interpreter am MIT,
System IBM 704, 36 Bit Maschine, car & cdr,
ab 1962 verschiedene Implementationen,
1976: Lisp Maschinen
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 7 / 30
Page 34
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Wie alles begann
Anfange 1956 - Listenverarbeitung in FORTRAN,
John McCarthy: mathematische Notation fur rekursiveFunktionen symbolischer Ausdrucke,
Steve Russell: Notation einfach auf Computer ausfuhrbar−→ Programmiersprache,
1959: erster Lisp-Interpreter am MIT,
System IBM 704, 36 Bit Maschine, car & cdr,
ab 1962 verschiedene Implementationen,
1976: Lisp Maschinen
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 7 / 30
Page 35
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Wie alles begann
Anfange 1956 - Listenverarbeitung in FORTRAN,
John McCarthy: mathematische Notation fur rekursiveFunktionen symbolischer Ausdrucke,
Steve Russell: Notation einfach auf Computer ausfuhrbar−→ Programmiersprache,
1959: erster Lisp-Interpreter am MIT,
System IBM 704, 36 Bit Maschine, car & cdr,
ab 1962 verschiedene Implementationen,
1976: Lisp Maschinen
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 7 / 30
Page 36
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Wie alles begann
Anfange 1956 - Listenverarbeitung in FORTRAN,
John McCarthy: mathematische Notation fur rekursiveFunktionen symbolischer Ausdrucke,
Steve Russell: Notation einfach auf Computer ausfuhrbar−→ Programmiersprache,
1959: erster Lisp-Interpreter am MIT,
System IBM 704, 36 Bit Maschine, car & cdr,
ab 1962 verschiedene Implementationen,
1976: Lisp Maschinen
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 7 / 30
Page 37
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Wie alles begann
Anfange 1956 - Listenverarbeitung in FORTRAN,
John McCarthy: mathematische Notation fur rekursiveFunktionen symbolischer Ausdrucke,
Steve Russell: Notation einfach auf Computer ausfuhrbar−→ Programmiersprache,
1959: erster Lisp-Interpreter am MIT,
System IBM 704, 36 Bit Maschine, car & cdr,
ab 1962 verschiedene Implementationen,
1976: Lisp Maschinen
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 7 / 30
Page 38
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Standardisierung
Entwicklung verschiedener Lisp-Dialekte
1981 Beginn der Standardisierung
1984 Guy L. Steele: ”Common Lisp the Language” (CLtL),
1986 erste Common Lisp Implementationen,
1986 Beginn der ANSI Standardisierung (X3J13),
1994 ANSI Standard X3.226-1994 bestatigt,
aktuelle Lisp-Dialekte:
Common Lisp (= “industrial strength Lisp”),elisp (Emacs Editor),AutoLISP (AutoCAD),Scheme (= “small, clean language”),. . .
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 8 / 30
Page 39
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Standardisierung
Entwicklung verschiedener Lisp-Dialekte
1981 Beginn der Standardisierung
1984 Guy L. Steele: ”Common Lisp the Language” (CLtL),
1986 erste Common Lisp Implementationen,
1986 Beginn der ANSI Standardisierung (X3J13),
1994 ANSI Standard X3.226-1994 bestatigt,
aktuelle Lisp-Dialekte:
Common Lisp (= “industrial strength Lisp”),elisp (Emacs Editor),AutoLISP (AutoCAD),Scheme (= “small, clean language”),. . .
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 8 / 30
Page 40
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Standardisierung
Entwicklung verschiedener Lisp-Dialekte
1981 Beginn der Standardisierung
1984 Guy L. Steele: ”Common Lisp the Language” (CLtL),
1986 erste Common Lisp Implementationen,
1986 Beginn der ANSI Standardisierung (X3J13),
1994 ANSI Standard X3.226-1994 bestatigt,
aktuelle Lisp-Dialekte:
Common Lisp (= “industrial strength Lisp”),elisp (Emacs Editor),AutoLISP (AutoCAD),Scheme (= “small, clean language”),. . .
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 8 / 30
Page 41
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Standardisierung
Entwicklung verschiedener Lisp-Dialekte
1981 Beginn der Standardisierung
1984 Guy L. Steele: ”Common Lisp the Language” (CLtL),
1986 erste Common Lisp Implementationen,
1986 Beginn der ANSI Standardisierung (X3J13),
1994 ANSI Standard X3.226-1994 bestatigt,
aktuelle Lisp-Dialekte:
Common Lisp (= “industrial strength Lisp”),elisp (Emacs Editor),AutoLISP (AutoCAD),Scheme (= “small, clean language”),. . .
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 8 / 30
Page 42
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Standardisierung
Entwicklung verschiedener Lisp-Dialekte
1981 Beginn der Standardisierung
1984 Guy L. Steele: ”Common Lisp the Language” (CLtL),
1986 erste Common Lisp Implementationen,
1986 Beginn der ANSI Standardisierung (X3J13),
1994 ANSI Standard X3.226-1994 bestatigt,
aktuelle Lisp-Dialekte:
Common Lisp (= “industrial strength Lisp”),elisp (Emacs Editor),AutoLISP (AutoCAD),Scheme (= “small, clean language”),. . .
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 8 / 30
Page 43
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Standardisierung
Entwicklung verschiedener Lisp-Dialekte
1981 Beginn der Standardisierung
1984 Guy L. Steele: ”Common Lisp the Language” (CLtL),
1986 erste Common Lisp Implementationen,
1986 Beginn der ANSI Standardisierung (X3J13),
1994 ANSI Standard X3.226-1994 bestatigt,
aktuelle Lisp-Dialekte:
Common Lisp (= “industrial strength Lisp”),elisp (Emacs Editor),AutoLISP (AutoCAD),Scheme (= “small, clean language”),. . .
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 8 / 30
Page 44
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Standardisierung
Entwicklung verschiedener Lisp-Dialekte
1981 Beginn der Standardisierung
1984 Guy L. Steele: ”Common Lisp the Language” (CLtL),
1986 erste Common Lisp Implementationen,
1986 Beginn der ANSI Standardisierung (X3J13),
1994 ANSI Standard X3.226-1994 bestatigt,
aktuelle Lisp-Dialekte:
Common Lisp (= “industrial strength Lisp”),elisp (Emacs Editor),AutoLISP (AutoCAD),Scheme (= “small, clean language”),. . .
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 8 / 30
Page 45
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Standardisierung
Entwicklung verschiedener Lisp-Dialekte
1981 Beginn der Standardisierung
1984 Guy L. Steele: ”Common Lisp the Language” (CLtL),
1986 erste Common Lisp Implementationen,
1986 Beginn der ANSI Standardisierung (X3J13),
1994 ANSI Standard X3.226-1994 bestatigt,
aktuelle Lisp-Dialekte:
Common Lisp (= “industrial strength Lisp”),elisp (Emacs Editor),AutoLISP (AutoCAD),Scheme (= “small, clean language”),. . .
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 8 / 30
Page 46
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Standardisierung
Entwicklung verschiedener Lisp-Dialekte
1981 Beginn der Standardisierung
1984 Guy L. Steele: ”Common Lisp the Language” (CLtL),
1986 erste Common Lisp Implementationen,
1986 Beginn der ANSI Standardisierung (X3J13),
1994 ANSI Standard X3.226-1994 bestatigt,
aktuelle Lisp-Dialekte:
Common Lisp (= “industrial strength Lisp”),elisp (Emacs Editor),AutoLISP (AutoCAD),Scheme (= “small, clean language”),. . .
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 8 / 30
Page 47
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Standardisierung
Entwicklung verschiedener Lisp-Dialekte
1981 Beginn der Standardisierung
1984 Guy L. Steele: ”Common Lisp the Language” (CLtL),
1986 erste Common Lisp Implementationen,
1986 Beginn der ANSI Standardisierung (X3J13),
1994 ANSI Standard X3.226-1994 bestatigt,
aktuelle Lisp-Dialekte:
Common Lisp (= “industrial strength Lisp”),elisp (Emacs Editor),AutoLISP (AutoCAD),Scheme (= “small, clean language”),. . .
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 8 / 30
Page 48
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Standardisierung
Entwicklung verschiedener Lisp-Dialekte
1981 Beginn der Standardisierung
1984 Guy L. Steele: ”Common Lisp the Language” (CLtL),
1986 erste Common Lisp Implementationen,
1986 Beginn der ANSI Standardisierung (X3J13),
1994 ANSI Standard X3.226-1994 bestatigt,
aktuelle Lisp-Dialekte:
Common Lisp (= “industrial strength Lisp”),elisp (Emacs Editor),AutoLISP (AutoCAD),Scheme (= “small, clean language”),. . .
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 8 / 30
Page 49
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Standardisierung
Entwicklung verschiedener Lisp-Dialekte
1981 Beginn der Standardisierung
1984 Guy L. Steele: ”Common Lisp the Language” (CLtL),
1986 erste Common Lisp Implementationen,
1986 Beginn der ANSI Standardisierung (X3J13),
1994 ANSI Standard X3.226-1994 bestatigt,
aktuelle Lisp-Dialekte:
Common Lisp (= “industrial strength Lisp”),elisp (Emacs Editor),AutoLISP (AutoCAD),Scheme (= “small, clean language”),. . .
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 8 / 30
Page 50
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp Syntax
basiert nur auf Ausdrucken,
Ausdruck = entweder Liste oder Atom,
Liste = ( ...), z.B. (1 2 "boo!")
Atom = einfaches Element, z.B. "boo!", 42, :symbol,
einfache, regelmaßige Syntax
gleiche Darstellung fur Code & Daten,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 9 / 30
Page 51
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp Syntax
basiert nur auf Ausdrucken,
Ausdruck = entweder Liste oder Atom,
Liste = ( ...), z.B. (1 2 "boo!")
Atom = einfaches Element, z.B. "boo!", 42, :symbol,
einfache, regelmaßige Syntax
gleiche Darstellung fur Code & Daten,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 9 / 30
Page 52
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp Syntax
basiert nur auf Ausdrucken,
Ausdruck = entweder Liste oder Atom,
Liste = ( ...), z.B. (1 2 "boo!")
Atom = einfaches Element, z.B. "boo!", 42, :symbol,
einfache, regelmaßige Syntax
gleiche Darstellung fur Code & Daten,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 9 / 30
Page 53
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp Syntax
basiert nur auf Ausdrucken,
Ausdruck = entweder Liste oder Atom,
Liste = ( ...), z.B. (1 2 "boo!")
Atom = einfaches Element, z.B. "boo!", 42, :symbol,
einfache, regelmaßige Syntax
gleiche Darstellung fur Code & Daten,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 9 / 30
Page 54
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp Syntax
basiert nur auf Ausdrucken,
Ausdruck = entweder Liste oder Atom,
Liste = ( ...), z.B. (1 2 "boo!")
Atom = einfaches Element, z.B. "boo!", 42, :symbol,
einfache, regelmaßige Syntax
gleiche Darstellung fur Code & Daten,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 9 / 30
Page 55
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp Syntax
basiert nur auf Ausdrucken,
Ausdruck = entweder Liste oder Atom,
Liste = ( ...), z.B. (1 2 "boo!")
Atom = einfaches Element, z.B. "boo!", 42, :symbol,
einfache, regelmaßige Syntax
gleiche Darstellung fur Code & Daten,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 9 / 30
Page 56
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Datentypen 1/2
Listen,
Hashtabellen,
Zeichen (char),
Strings (ggf. Unicode),
Arrays,
Fließkommazahlen
structs (nutzerdefinierte strukturierte Datentypen)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 10 / 30
Page 57
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Datentypen 1/2
Listen,
Hashtabellen,
Zeichen (char),
Strings (ggf. Unicode),
Arrays,
Fließkommazahlen
structs (nutzerdefinierte strukturierte Datentypen)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 10 / 30
Page 58
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Datentypen 1/2
Listen,
Hashtabellen,
Zeichen (char),
Strings (ggf. Unicode),
Arrays,
Fließkommazahlen
structs (nutzerdefinierte strukturierte Datentypen)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 10 / 30
Page 59
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Datentypen 1/2
Listen,
Hashtabellen,
Zeichen (char),
Strings (ggf. Unicode),
Arrays,
Fließkommazahlen
structs (nutzerdefinierte strukturierte Datentypen)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 10 / 30
Page 60
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Datentypen 1/2
Listen,
Hashtabellen,
Zeichen (char),
Strings (ggf. Unicode),
Arrays,
Fließkommazahlen
structs (nutzerdefinierte strukturierte Datentypen)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 10 / 30
Page 61
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Datentypen 1/2
Listen,
Hashtabellen,
Zeichen (char),
Strings (ggf. Unicode),
Arrays,
Fließkommazahlen
structs (nutzerdefinierte strukturierte Datentypen)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 10 / 30
Page 62
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Datentypen 1/2
Listen,
Hashtabellen,
Zeichen (char),
Strings (ggf. Unicode),
Arrays,
Fließkommazahlen
structs (nutzerdefinierte strukturierte Datentypen)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 10 / 30
Page 63
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Datentypen 2/2
Symbole,
Integer & bignums (beliebig große ganze Zahlen, transparent),
rationale Zahlen: 1/3, (+ 1/3 1/3 1/3) =⇒ 1,
komplexe Zahlen,
Funktionen als vollwertiger Datentyp,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 11 / 30
Page 64
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Datentypen 2/2
Symbole,
Integer & bignums (beliebig große ganze Zahlen, transparent),
rationale Zahlen: 1/3, (+ 1/3 1/3 1/3) =⇒ 1,
komplexe Zahlen,
Funktionen als vollwertiger Datentyp,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 11 / 30
Page 65
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Datentypen 2/2
Symbole,
Integer & bignums (beliebig große ganze Zahlen, transparent),
rationale Zahlen: 1/3, (+ 1/3 1/3 1/3) =⇒ 1,
komplexe Zahlen,
Funktionen als vollwertiger Datentyp,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 11 / 30
Page 66
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Datentypen 2/2
Symbole,
Integer & bignums (beliebig große ganze Zahlen, transparent),
rationale Zahlen: 1/3, (+ 1/3 1/3 1/3) =⇒ 1,
komplexe Zahlen,
Funktionen als vollwertiger Datentyp,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 11 / 30
Page 67
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Datentypen 2/2
Symbole,
Integer & bignums (beliebig große ganze Zahlen, transparent),
rationale Zahlen: 1/3, (+ 1/3 1/3 1/3) =⇒ 1,
komplexe Zahlen,
Funktionen als vollwertiger Datentyp,
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 11 / 30
Page 68
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
S-Expressions
symbolische Ausdrucke,
Listenstruktur,
Prefix-Notation
externe Darstellung fur Code und Daten,
interne Darstellung: CONS-Zellen:
("Lisp" LINUX-TAG 2005 :VORTRAG)
NIL
"Lisp" 2005LINUX−TAG :VORTRAG
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 12 / 30
Page 69
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
S-Expressions
symbolische Ausdrucke,
Listenstruktur,
Prefix-Notation
externe Darstellung fur Code und Daten,
interne Darstellung: CONS-Zellen:
("Lisp" LINUX-TAG 2005 :VORTRAG)
NIL
"Lisp" 2005LINUX−TAG :VORTRAG
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 12 / 30
Page 70
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
S-Expressions
symbolische Ausdrucke,
Listenstruktur,
Prefix-Notation
externe Darstellung fur Code und Daten,
interne Darstellung: CONS-Zellen:
("Lisp" LINUX-TAG 2005 :VORTRAG)
NIL
"Lisp" 2005LINUX−TAG :VORTRAG
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 12 / 30
Page 71
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
S-Expressions
symbolische Ausdrucke,
Listenstruktur,
Prefix-Notation
externe Darstellung fur Code und Daten,
interne Darstellung: CONS-Zellen:
("Lisp" LINUX-TAG 2005 :VORTRAG)
NIL
"Lisp" 2005LINUX−TAG :VORTRAG
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 12 / 30
Page 72
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
S-Expressions
symbolische Ausdrucke,
Listenstruktur,
Prefix-Notation
externe Darstellung fur Code und Daten,
interne Darstellung: CONS-Zellen:
("Lisp" LINUX-TAG 2005 :VORTRAG)
NIL
"Lisp" 2005LINUX−TAG :VORTRAG
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 12 / 30
Page 73
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
S-Expressions
symbolische Ausdrucke,
Listenstruktur,
Prefix-Notation
externe Darstellung fur Code und Daten,
interne Darstellung: CONS-Zellen:
("Lisp" LINUX-TAG 2005 :VORTRAG)
NIL
"Lisp" 2005LINUX−TAG :VORTRAG
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 12 / 30
Page 74
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
S-Expressions
symbolische Ausdrucke,
Listenstruktur,
Prefix-Notation
externe Darstellung fur Code und Daten,
interne Darstellung: CONS-Zellen:
("Lisp" LINUX-TAG 2005 :VORTRAG)
NIL
"Lisp" 2005LINUX−TAG :VORTRAG
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 12 / 30
Page 75
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
REPL
REPL = Read Eval Print Loop,
interaktive Schnittstelle zu Lisp,
* (+ 1 2 3 4 5 6)=⇒ 21* (print ”hello, world”)=⇒ ”hello, world””hello, world”
(loop (print (eval (read))))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 13 / 30
Page 76
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
REPL
REPL = Read Eval Print Loop,
interaktive Schnittstelle zu Lisp,
* (+ 1 2 3 4 5 6)=⇒ 21* (print ”hello, world”)=⇒ ”hello, world””hello, world”
(loop (print (eval (read))))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 13 / 30
Page 77
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
REPL
REPL = Read Eval Print Loop,
interaktive Schnittstelle zu Lisp,
* (+ 1 2 3 4 5 6)=⇒ 21* (print ”hello, world”)=⇒ ”hello, world””hello, world”
(loop (print (eval (read))))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 13 / 30
Page 78
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
REPL
REPL = Read Eval Print Loop,
interaktive Schnittstelle zu Lisp,
* (+ 1 2 3 4 5 6)=⇒ 21* (print ”hello, world”)=⇒ ”hello, world””hello, world”
(loop (print (eval (read))))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 13 / 30
Page 79
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: uberall Klammern
Darstellung von Code & Daten als S-Expressions,
leere Liste: (),
einfache Liste: (1 2 3 4),
strukturierte Liste: (sum (1 2 3 4)),
Funktionsdefinition:(defun ! (x)(if(eql x 0) 1 (* x(!(- x 1)))))
Funktionsdefinition, mit Einruckung:(defun ! (x)
(if (eql x 0)1(* x (! (- x 1)))))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 14 / 30
Page 80
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: uberall Klammern
Darstellung von Code & Daten als S-Expressions,
leere Liste: (),
einfache Liste: (1 2 3 4),
strukturierte Liste: (sum (1 2 3 4)),
Funktionsdefinition:(defun ! (x)(if(eql x 0) 1 (* x(!(- x 1)))))
Funktionsdefinition, mit Einruckung:(defun ! (x)
(if (eql x 0)1(* x (! (- x 1)))))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 14 / 30
Page 81
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: uberall Klammern
Darstellung von Code & Daten als S-Expressions,
leere Liste: (),
einfache Liste: (1 2 3 4),
strukturierte Liste: (sum (1 2 3 4)),
Funktionsdefinition:(defun ! (x)(if(eql x 0) 1 (* x(!(- x 1)))))
Funktionsdefinition, mit Einruckung:(defun ! (x)
(if (eql x 0)1(* x (! (- x 1)))))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 14 / 30
Page 82
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: uberall Klammern
Darstellung von Code & Daten als S-Expressions,
leere Liste: (),
einfache Liste: (1 2 3 4),
strukturierte Liste: (sum (1 2 3 4)),
Funktionsdefinition:(defun ! (x)(if(eql x 0) 1 (* x(!(- x 1)))))
Funktionsdefinition, mit Einruckung:(defun ! (x)
(if (eql x 0)1(* x (! (- x 1)))))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 14 / 30
Page 83
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: uberall Klammern
Darstellung von Code & Daten als S-Expressions,
leere Liste: (),
einfache Liste: (1 2 3 4),
strukturierte Liste: (sum (1 2 3 4)),
Funktionsdefinition:(defun ! (x)(if(eql x 0) 1 (* x(!(- x 1)))))
Funktionsdefinition, mit Einruckung:(defun ! (x)
(if (eql x 0)1(* x (! (- x 1)))))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 14 / 30
Page 84
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: uberall Klammern
Darstellung von Code & Daten als S-Expressions,
leere Liste: (),
einfache Liste: (1 2 3 4),
strukturierte Liste: (sum (1 2 3 4)),
Funktionsdefinition:(defun ! (x)(if(eql x 0) 1 (* x(!(- x 1)))))
Funktionsdefinition, mit Einruckung:(defun ! (x)
(if (eql x 0)1(* x (! (- x 1)))))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 14 / 30
Page 85
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Auswertung von Ausdrucken
Auswertung von Atomen =⇒ Wert des Atoms,
* 23=⇒ 23* "This is a test"=⇒ "This is a test"
Auswertung von Ausdrucken = Funktionsaufruf,
* (+ 5 23)=⇒ 28* (numberp 23)=⇒ T* (defun hello (name)
(format t "Hello, Mr. ~a!~%" name))=⇒ HELLO
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 15 / 30
Page 86
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Auswertung von Ausdrucken
Auswertung von Atomen =⇒ Wert des Atoms,
* 23=⇒ 23* "This is a test"=⇒ "This is a test"
Auswertung von Ausdrucken = Funktionsaufruf,
* (+ 5 23)=⇒ 28* (numberp 23)=⇒ T* (defun hello (name)
(format t "Hello, Mr. ~a!~%" name))=⇒ HELLO
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 15 / 30
Page 87
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Auswertung von Ausdrucken
Auswertung von Atomen =⇒ Wert des Atoms,
* 23=⇒ 23* "This is a test"=⇒ "This is a test"
Auswertung von Ausdrucken = Funktionsaufruf,
* (+ 5 23)=⇒ 28* (numberp 23)=⇒ T* (defun hello (name)
(format t "Hello, Mr. ~a!~%" name))=⇒ HELLO
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 15 / 30
Page 88
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Auswertung von Ausdrucken
Auswertung von Atomen =⇒ Wert des Atoms,
* 23=⇒ 23* "This is a test"=⇒ "This is a test"
Auswertung von Ausdrucken = Funktionsaufruf,
* (+ 5 23)=⇒ 28* (numberp 23)=⇒ T* (defun hello (name)
(format t "Hello, Mr. ~a!~%" name))=⇒ HELLO
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 15 / 30
Page 89
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Auswertung von Ausdrucken
Auswertung von Atomen =⇒ Wert des Atoms,
* 23=⇒ 23* "This is a test"=⇒ "This is a test"
Auswertung von Ausdrucken = Funktionsaufruf,
* (+ 5 23)=⇒ 28* (numberp 23)=⇒ T* (defun hello (name)
(format t "Hello, Mr. ~a!~%" name))=⇒ HELLO
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 15 / 30
Page 90
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Auswertung von Ausdrucken
Auswertung von Atomen =⇒ Wert des Atoms,
* 23=⇒ 23* "This is a test"=⇒ "This is a test"
Auswertung von Ausdrucken = Funktionsaufruf,
* (+ 5 23)=⇒ 28* (numberp 23)=⇒ T* (defun hello (name)
(format t "Hello, Mr. ~a!~%" name))=⇒ HELLO
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 15 / 30
Page 91
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Auswertung von Ausdrucken
Auswertung von Atomen =⇒ Wert des Atoms,
* 23=⇒ 23* "This is a test"=⇒ "This is a test"
Auswertung von Ausdrucken = Funktionsaufruf,
* (+ 5 23)=⇒ 28* (numberp 23)=⇒ T* (defun hello (name)
(format t "Hello, Mr. ~a!~%" name))=⇒ HELLO
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 15 / 30
Page 92
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Zusammenbauen & Zerlegen
Liste erzeugen:* (list 5 23 42)=⇒ (5 23 42)
Liste zerlegen:
* (first (list 5 23 42))=⇒ 5* (rest (list 5 23 42))=⇒ (23 42)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 16 / 30
Page 93
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Zusammenbauen & Zerlegen
Liste erzeugen:* (list 5 23 42)=⇒ (5 23 42)
Liste zerlegen:
* (first (list 5 23 42))=⇒ 5* (rest (list 5 23 42))=⇒ (23 42)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 16 / 30
Page 94
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Zusammenbauen & Zerlegen
Liste erzeugen:* (list 5 23 42)=⇒ (5 23 42)
Liste zerlegen:
* (first (list 5 23 42))=⇒ 5* (rest (list 5 23 42))=⇒ (23 42)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 16 / 30
Page 95
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Zusammenbauen & Zerlegen
Liste erzeugen:* (list 5 23 42)=⇒ (5 23 42)
Liste zerlegen:
* (first (list 5 23 42))=⇒ 5* (rest (list 5 23 42))=⇒ (23 42)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 16 / 30
Page 96
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Symbole 1/2
Liste von Symbolen: (red green blue)
Symbole: eindeutige Namen,
Symbolname nicht case-sensitive,
Symbole vergleichen:* (eq ’red ’RED)=⇒ T
Symbol-Werte:
* (setf color "red")=⇒ "red"* (setf magic-numbers (list 5 7 23 42 666))=⇒ (5 7 23 42 666)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 17 / 30
Page 97
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Symbole 1/2
Liste von Symbolen: (red green blue)
Symbole: eindeutige Namen,
Symbolname nicht case-sensitive,
Symbole vergleichen:* (eq ’red ’RED)=⇒ T
Symbol-Werte:
* (setf color "red")=⇒ "red"* (setf magic-numbers (list 5 7 23 42 666))=⇒ (5 7 23 42 666)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 17 / 30
Page 98
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Symbole 1/2
Liste von Symbolen: (red green blue)
Symbole: eindeutige Namen,
Symbolname nicht case-sensitive,
Symbole vergleichen:* (eq ’red ’RED)=⇒ T
Symbol-Werte:
* (setf color "red")=⇒ "red"* (setf magic-numbers (list 5 7 23 42 666))=⇒ (5 7 23 42 666)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 17 / 30
Page 99
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Symbole 1/2
Liste von Symbolen: (red green blue)
Symbole: eindeutige Namen,
Symbolname nicht case-sensitive,
Symbole vergleichen:* (eq ’red ’RED)=⇒ T
Symbol-Werte:
* (setf color "red")=⇒ "red"* (setf magic-numbers (list 5 7 23 42 666))=⇒ (5 7 23 42 666)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 17 / 30
Page 100
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Symbole 1/2
Liste von Symbolen: (red green blue)
Symbole: eindeutige Namen,
Symbolname nicht case-sensitive,
Symbole vergleichen:* (eq ’red ’RED)=⇒ T
Symbol-Werte:
* (setf color "red")=⇒ "red"* (setf magic-numbers (list 5 7 23 42 666))=⇒ (5 7 23 42 666)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 17 / 30
Page 101
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Symbole 1/2
Liste von Symbolen: (red green blue)
Symbole: eindeutige Namen,
Symbolname nicht case-sensitive,
Symbole vergleichen:* (eq ’red ’RED)=⇒ T
Symbol-Werte:
* (setf color "red")=⇒ "red"* (setf magic-numbers (list 5 7 23 42 666))=⇒ (5 7 23 42 666)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 17 / 30
Page 102
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Symbole 1/2
Liste von Symbolen: (red green blue)
Symbole: eindeutige Namen,
Symbolname nicht case-sensitive,
Symbole vergleichen:* (eq ’red ’RED)=⇒ T
Symbol-Werte:
* (setf color "red")=⇒ "red"* (setf magic-numbers (list 5 7 23 42 666))=⇒ (5 7 23 42 666)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 17 / 30
Page 103
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Symbole 2/2
Symbol mit Funktion und Wert:
* (defun hello (name)(format t "Hello, Mr. ~a!~%" name))
=⇒ HELLO* (setf hello "hi!")=⇒ "Hi!"* (hello "Joe")=⇒ Hello, Mr. Joe!* hello=⇒ "Hi!"
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 18 / 30
Page 104
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Symbole 2/2
Symbol mit Funktion und Wert:
* (defun hello (name)(format t "Hello, Mr. ~a!~%" name))
=⇒ HELLO* (setf hello "hi!")=⇒ "Hi!"* (hello "Joe")=⇒ Hello, Mr. Joe!* hello=⇒ "Hi!"
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 18 / 30
Page 105
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Symbole 2/2
Symbol mit Funktion und Wert:
* (defun hello (name)(format t "Hello, Mr. ~a!~%" name))
=⇒ HELLO* (setf hello "hi!")=⇒ "Hi!"* (hello "Joe")=⇒ Hello, Mr. Joe!* hello=⇒ "Hi!"
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 18 / 30
Page 106
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Symbole 2/2
Symbol mit Funktion und Wert:
* (defun hello (name)(format t "Hello, Mr. ~a!~%" name))
=⇒ HELLO* (setf hello "hi!")=⇒ "Hi!"* (hello "Joe")=⇒ Hello, Mr. Joe!* hello=⇒ "Hi!"
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 18 / 30
Page 107
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Symbole 2/2
Symbol mit Funktion und Wert:
* (defun hello (name)(format t "Hello, Mr. ~a!~%" name))
=⇒ HELLO* (setf hello "hi!")=⇒ "Hi!"* (hello "Joe")=⇒ Hello, Mr. Joe!* hello=⇒ "Hi!"
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 18 / 30
Page 108
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Funktionsdefinition
* (defun warm-enoughp (temperature)(let ((nice-and-cozy 25))(cond ((= temperature nice-and-cozy) t)
((> temperature nice-and-cozy) :hot)((< temperature nice-and-cozy) :cold))))
=⇒ WARM-ENOUGHP
(warm-enoughp 23)=⇒ :COLD)
(warm-enoughp 30)=⇒ :HOT)
(warm-enoughp 25)=⇒ T)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 19 / 30
Page 109
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Funktionsdefinition
* (defun warm-enoughp (temperature)(let ((nice-and-cozy 25))(cond ((= temperature nice-and-cozy) t)
((> temperature nice-and-cozy) :hot)((< temperature nice-and-cozy) :cold))))
=⇒ WARM-ENOUGHP
(warm-enoughp 23)=⇒ :COLD)
(warm-enoughp 30)=⇒ :HOT)
(warm-enoughp 25)=⇒ T)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 19 / 30
Page 110
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Funktionsdefinition
* (defun warm-enoughp (temperature)(let ((nice-and-cozy 25))(cond ((= temperature nice-and-cozy) t)
((> temperature nice-and-cozy) :hot)((< temperature nice-and-cozy) :cold))))
=⇒ WARM-ENOUGHP
(warm-enoughp 23)=⇒ :COLD)
(warm-enoughp 30)=⇒ :HOT)
(warm-enoughp 25)=⇒ T)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 19 / 30
Page 111
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Funktionsdefinition
* (defun warm-enoughp (temperature)(let ((nice-and-cozy 25))(cond ((= temperature nice-and-cozy) t)
((> temperature nice-and-cozy) :hot)((< temperature nice-and-cozy) :cold))))
=⇒ WARM-ENOUGHP
(warm-enoughp 23)=⇒ :COLD)
(warm-enoughp 30)=⇒ :HOT)
(warm-enoughp 25)=⇒ T)
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 19 / 30
Page 112
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: anonyme Funktionen 1/2
Funktionen in Lisp: first class objects,−→ Verwendung als Daten,
anonyme Funktionen definiert mit (lambda ...),
Beispiel:(setf stuff ’(#\y "John Doe" 23 :try-again
startup 1/3 #C(1 2) 1234567890))(format t "~{~S~%~}"
(mapcar #’(lambda (item)(format nil "(~a: ~a)"
item(type-of item)))
stuff))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 20 / 30
Page 113
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: anonyme Funktionen 1/2
Funktionen in Lisp: first class objects,−→ Verwendung als Daten,
anonyme Funktionen definiert mit (lambda ...),
Beispiel:(setf stuff ’(#\y "John Doe" 23 :try-again
startup 1/3 #C(1 2) 1234567890))(format t "~{~S~%~}"
(mapcar #’(lambda (item)(format nil "(~a: ~a)"
item(type-of item)))
stuff))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 20 / 30
Page 114
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: anonyme Funktionen 1/2
Funktionen in Lisp: first class objects,−→ Verwendung als Daten,
anonyme Funktionen definiert mit (lambda ...),
Beispiel:(setf stuff ’(#\y "John Doe" 23 :try-again
startup 1/3 #C(1 2) 1234567890))(format t "~{~S~%~}"
(mapcar #’(lambda (item)(format nil "(~a: ~a)"
item(type-of item)))
stuff))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 20 / 30
Page 115
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: anonyme Funktionen 1/2
Funktionen in Lisp: first class objects,−→ Verwendung als Daten,
anonyme Funktionen definiert mit (lambda ...),
Beispiel:(setf stuff ’(#\y "John Doe" 23 :try-again
startup 1/3 #C(1 2) 1234567890))(format t "~{~S~%~}"
(mapcar #’(lambda (item)(format nil "(~a: ~a)"
item(type-of item)))
stuff))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 20 / 30
Page 116
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: anonyme Funktionen 1/2
=⇒ "(y: BASE-CHAR)""(John Doe: (SIMPLE-BASE-STRING 8))""(23: FIXNUM)""(TRY-AGAIN: SYMBOL)""(STARTUP: SYMBOL)""(1/3: RATIO)""(#C(1 2): COMPLEX)""(1234567890: BIGNUM)"NIL
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 21 / 30
Page 117
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Macros
(defmacro with-db-connection ((con &rest open-args)&body body)
‘(let ((,con (db-connect ,@open-args)))(unwind-protect
(progn ,@body)(when ,con (db-disconnect ,con)))))
(with-db-connection (db-link host db user pass)(update-tables db-link user-info)(show-stats (get-user-stats db-link)))
(let ((db-link (db-connect host db user pass)))(unwind-protect
(progn (update-tables db-link user-info)(show-stats (get-user-stats db-link)))
(when db-link (db-disconnect db-link))))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 22 / 30
Page 118
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Macros
(defmacro with-db-connection ((con &rest open-args)&body body)
‘(let ((,con (db-connect ,@open-args)))(unwind-protect
(progn ,@body)(when ,con (db-disconnect ,con)))))
(with-db-connection (db-link host db user pass)(update-tables db-link user-info)(show-stats (get-user-stats db-link)))
(let ((db-link (db-connect host db user pass)))(unwind-protect
(progn (update-tables db-link user-info)(show-stats (get-user-stats db-link)))
(when db-link (db-disconnect db-link))))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 22 / 30
Page 119
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Macros
(defmacro with-db-connection ((con &rest open-args)&body body)
‘(let ((,con (db-connect ,@open-args)))(unwind-protect
(progn ,@body)(when ,con (db-disconnect ,con)))))
(with-db-connection (db-link host db user pass)(update-tables db-link user-info)(show-stats (get-user-stats db-link)))
(let ((db-link (db-connect host db user pass)))(unwind-protect
(progn (update-tables db-link user-info)(show-stats (get-user-stats db-link)))
(when db-link (db-disconnect db-link))))
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 22 / 30
Page 120
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Text-I/O
einfache Textausgabe:* (princ "Lisp rocks")=⇒ Lisp rocks"Lisp rocks"
formatierte Textausgabe:* (format t "~a is cool~%" "Lisp")=⇒ Lisp is coolNIL
einfache Texteingabe:* (read-line)Common Lisp=⇒ "Common Lisp" ; NIL
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 23 / 30
Page 121
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Text-I/O
einfache Textausgabe:* (princ "Lisp rocks")=⇒ Lisp rocks"Lisp rocks"
formatierte Textausgabe:* (format t "~a is cool~%" "Lisp")=⇒ Lisp is coolNIL
einfache Texteingabe:* (read-line)Common Lisp=⇒ "Common Lisp" ; NIL
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 23 / 30
Page 122
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Text-I/O
einfache Textausgabe:* (princ "Lisp rocks")=⇒ Lisp rocks"Lisp rocks"
formatierte Textausgabe:* (format t "~a is cool~%" "Lisp")=⇒ Lisp is coolNIL
einfache Texteingabe:* (read-line)Common Lisp=⇒ "Common Lisp" ; NIL
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 23 / 30
Page 123
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Hilfsmittel
tracing:* (trace !)=⇒ ;; Tracing function !.* (! 2)=⇒ 1. Trace: (! ’2)2. Trace: (! ’1)3. Trace: (! ’0)3. Trace: ! ==> 12. Trace: ! ==> 11. Trace: ! ==> 2
2
timing:* (time (! 1000))=⇒ Real time: 0.013661 sec.Run time: 0.01 sec.Space: 498844 Bytes4023872600770937735437024339...
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 24 / 30
Page 124
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Crashkurs: Hilfsmittel
tracing:* (trace !)=⇒ ;; Tracing function !.* (! 2)=⇒ 1. Trace: (! ’2)2. Trace: (! ’1)3. Trace: (! ’0)3. Trace: ! ==> 12. Trace: ! ==> 11. Trace: ! ==> 2
2
timing:* (time (! 1000))=⇒ Real time: 0.013661 sec.Run time: 0.01 sec.Space: 498844 Bytes4023872600770937735437024339...
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 24 / 30
Page 125
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Lisp-Schnipsel
(loop for y from -1 to 1.1 by 0.1 do(loop for x from -2 to 1 by 0.04 do
(let* ((c 126)(z (complex x y))(a z))
(loop while (< (abs(setq z (+ (* z z) a)))
2)while (> (decf c) 32))
(princ (code-char c))))(format t ”˜%”))
Autor: Frank Buß <[email protected] >
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 25 / 30
Page 126
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Apfelmannchen
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 26 / 30
Page 127
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Weiterfuhrendes - Lispsysteme
Freie Lispsysteme (Auszug):
CLISP (UNIX, Win, Mac): http://clisp.cons.org/CMUCL (UNIX): http://www.cons.org/cmucl/SBCL (UNIX, Mac): http://www.sbcl.org/
Kommerzielle Lispsysteme (Auszug):
Corman Lisp (Win): http://www.cormanlisp.com/,Allegro CL (Unix, Win, Mac): http://www.franz.com/LispWorks (Unix, Win, Mac): http://www.lispworks.com
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 27 / 30
Page 128
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Weiterfuhrendes - Lispsysteme
Freie Lispsysteme (Auszug):
CLISP (UNIX, Win, Mac): http://clisp.cons.org/CMUCL (UNIX): http://www.cons.org/cmucl/SBCL (UNIX, Mac): http://www.sbcl.org/
Kommerzielle Lispsysteme (Auszug):
Corman Lisp (Win): http://www.cormanlisp.com/,Allegro CL (Unix, Win, Mac): http://www.franz.com/LispWorks (Unix, Win, Mac): http://www.lispworks.com
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 27 / 30
Page 129
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Weiterfuhrendes - Lispsysteme
Freie Lispsysteme (Auszug):
CLISP (UNIX, Win, Mac): http://clisp.cons.org/CMUCL (UNIX): http://www.cons.org/cmucl/SBCL (UNIX, Mac): http://www.sbcl.org/
Kommerzielle Lispsysteme (Auszug):
Corman Lisp (Win): http://www.cormanlisp.com/,Allegro CL (Unix, Win, Mac): http://www.franz.com/LispWorks (Unix, Win, Mac): http://www.lispworks.com
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 27 / 30
Page 130
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Weiterfuhrendes - Lispsysteme
Freie Lispsysteme (Auszug):
CLISP (UNIX, Win, Mac): http://clisp.cons.org/CMUCL (UNIX): http://www.cons.org/cmucl/SBCL (UNIX, Mac): http://www.sbcl.org/
Kommerzielle Lispsysteme (Auszug):
Corman Lisp (Win): http://www.cormanlisp.com/,Allegro CL (Unix, Win, Mac): http://www.franz.com/LispWorks (Unix, Win, Mac): http://www.lispworks.com
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 27 / 30
Page 131
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Weiterfuhrendes - Lispsysteme
Freie Lispsysteme (Auszug):
CLISP (UNIX, Win, Mac): http://clisp.cons.org/CMUCL (UNIX): http://www.cons.org/cmucl/SBCL (UNIX, Mac): http://www.sbcl.org/
Kommerzielle Lispsysteme (Auszug):
Corman Lisp (Win): http://www.cormanlisp.com/,Allegro CL (Unix, Win, Mac): http://www.franz.com/LispWorks (Unix, Win, Mac): http://www.lispworks.com
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 27 / 30
Page 132
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Weiterfuhrendes - Lispsysteme
Freie Lispsysteme (Auszug):
CLISP (UNIX, Win, Mac): http://clisp.cons.org/CMUCL (UNIX): http://www.cons.org/cmucl/SBCL (UNIX, Mac): http://www.sbcl.org/
Kommerzielle Lispsysteme (Auszug):
Corman Lisp (Win): http://www.cormanlisp.com/,Allegro CL (Unix, Win, Mac): http://www.franz.com/LispWorks (Unix, Win, Mac): http://www.lispworks.com
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 27 / 30
Page 133
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Weiterfuhrendes - Lispsysteme
Freie Lispsysteme (Auszug):
CLISP (UNIX, Win, Mac): http://clisp.cons.org/CMUCL (UNIX): http://www.cons.org/cmucl/SBCL (UNIX, Mac): http://www.sbcl.org/
Kommerzielle Lispsysteme (Auszug):
Corman Lisp (Win): http://www.cormanlisp.com/,Allegro CL (Unix, Win, Mac): http://www.franz.com/LispWorks (Unix, Win, Mac): http://www.lispworks.com
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 27 / 30
Page 134
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Weiterfuhrendes - Lispsysteme
Freie Lispsysteme (Auszug):
CLISP (UNIX, Win, Mac): http://clisp.cons.org/CMUCL (UNIX): http://www.cons.org/cmucl/SBCL (UNIX, Mac): http://www.sbcl.org/
Kommerzielle Lispsysteme (Auszug):
Corman Lisp (Win): http://www.cormanlisp.com/,Allegro CL (Unix, Win, Mac): http://www.franz.com/LispWorks (Unix, Win, Mac): http://www.lispworks.com
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 27 / 30
Page 135
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Weiterfuhrendes - Literatur
Peter Seibel: “Practical Common Lisp”http://www.gigamonkeys.com/book/
David S. Touretzky: “Common Lisp: A Gentle Introduction toSymbolic Computation”
David B. Lamkins: “Successful Lisp”
Lisperati: http://www.lisperati.com/
Guy L. Steele: “Common Lisp the Language, 2nd ed.”(CLtL2)
Common Lisp HyperSpec:http://www.lispworks.com/documentation/HyperSpec/
Common Lisp Wiki: http://www.cliki.net/index
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 28 / 30
Page 136
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Weiterfuhrendes - Literatur
Peter Seibel: “Practical Common Lisp”http://www.gigamonkeys.com/book/
David S. Touretzky: “Common Lisp: A Gentle Introduction toSymbolic Computation”
David B. Lamkins: “Successful Lisp”
Lisperati: http://www.lisperati.com/
Guy L. Steele: “Common Lisp the Language, 2nd ed.”(CLtL2)
Common Lisp HyperSpec:http://www.lispworks.com/documentation/HyperSpec/
Common Lisp Wiki: http://www.cliki.net/index
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 28 / 30
Page 137
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Weiterfuhrendes - Literatur
Peter Seibel: “Practical Common Lisp”http://www.gigamonkeys.com/book/
David S. Touretzky: “Common Lisp: A Gentle Introduction toSymbolic Computation”
David B. Lamkins: “Successful Lisp”
Lisperati: http://www.lisperati.com/
Guy L. Steele: “Common Lisp the Language, 2nd ed.”(CLtL2)
Common Lisp HyperSpec:http://www.lispworks.com/documentation/HyperSpec/
Common Lisp Wiki: http://www.cliki.net/index
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 28 / 30
Page 138
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Weiterfuhrendes - Literatur
Peter Seibel: “Practical Common Lisp”http://www.gigamonkeys.com/book/
David S. Touretzky: “Common Lisp: A Gentle Introduction toSymbolic Computation”
David B. Lamkins: “Successful Lisp”
Lisperati: http://www.lisperati.com/
Guy L. Steele: “Common Lisp the Language, 2nd ed.”(CLtL2)
Common Lisp HyperSpec:http://www.lispworks.com/documentation/HyperSpec/
Common Lisp Wiki: http://www.cliki.net/index
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 28 / 30
Page 139
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Weiterfuhrendes - Literatur
Peter Seibel: “Practical Common Lisp”http://www.gigamonkeys.com/book/
David S. Touretzky: “Common Lisp: A Gentle Introduction toSymbolic Computation”
David B. Lamkins: “Successful Lisp”
Lisperati: http://www.lisperati.com/
Guy L. Steele: “Common Lisp the Language, 2nd ed.”(CLtL2)
Common Lisp HyperSpec:http://www.lispworks.com/documentation/HyperSpec/
Common Lisp Wiki: http://www.cliki.net/index
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 28 / 30
Page 140
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Weiterfuhrendes - Literatur
Peter Seibel: “Practical Common Lisp”http://www.gigamonkeys.com/book/
David S. Touretzky: “Common Lisp: A Gentle Introduction toSymbolic Computation”
David B. Lamkins: “Successful Lisp”
Lisperati: http://www.lisperati.com/
Guy L. Steele: “Common Lisp the Language, 2nd ed.”(CLtL2)
Common Lisp HyperSpec:http://www.lispworks.com/documentation/HyperSpec/
Common Lisp Wiki: http://www.cliki.net/index
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 28 / 30
Page 141
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Weiterfuhrendes - Literatur
Peter Seibel: “Practical Common Lisp”http://www.gigamonkeys.com/book/
David S. Touretzky: “Common Lisp: A Gentle Introduction toSymbolic Computation”
David B. Lamkins: “Successful Lisp”
Lisperati: http://www.lisperati.com/
Guy L. Steele: “Common Lisp the Language, 2nd ed.”(CLtL2)
Common Lisp HyperSpec:http://www.lispworks.com/documentation/HyperSpec/
Common Lisp Wiki: http://www.cliki.net/index
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 28 / 30
Page 142
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Fragen & Antworten
Fragen?
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 29 / 30
Page 143
Einfuhrung Geschichtliches Die Programmiersprache Abschluß
Ende
Vielen Dank fur Ihr Interesse!
Alexander Schreiber <[email protected] > Common Lisp - viel mehr als nur damliche Klammern 30 / 30