Inhaltsverzeichnis	6
	Widmung	8
	Danksagung	10
	Vorwort	14
	Kapitel 1 - Einführung	18
	1.1 Wahnsinn mit Methode	18
	1.2 Die Sprachen	20
	1.3 Kaufen Sie dieses Buch	22
	Lernen Sie zu lernen	23
	Hilfe in schwierigen Zeiten	23
	1.4 Kaufen Sie dieses Buch nicht	24
	Ich gehe über die Syntax hinaus	24
	Ich helfe nicht bei der Installation	25
	Ich bin keine Programmierreferenz	25
	Ich werde Sie hart rannehmen	26
	1.5 Ein letzter Punkt	27
	Kapitel 2 - Ruby	28
	2.1 Ein wenig Geschichte	29
	Interview mit Yukihiro (Matz) Matsumoto	29
	2.2 Tag 1: Ein Kindermädchen finden	31
	Schnelleinstieg	31
	Ruby über die Konsole nutzen	32
	Das Programmiermodell	32
	Entscheidungen	33
	Duck-Typing	36
	Was wir am ersten Tag gelernt haben	38
	Tag 1: Selbststudium	38
	2.3 Tag 2: Vom Himmel herab	39
	Funktionen definieren	39
	Arrays	40
	Hashes	41
	Codeblöcke und yield	43
	Ruby aus einer Datei ausführen	45
	Klassen definieren	45
	Ein Mixin schreiben	48
	Module, Enumerable und Sets	49
	Was wir am zweiten Tag gelernt haben	51
	Tag 2: Selbststudium	51
	2.4 Tag 3: Tiefgreifende Veränderung	52
	Offene Klassen	53
	Verwendung von method_missing	55
	Module	56
	Was wir am dritten Tag gelernt haben	59
	Tag 3: Selbststudium	60
	2.5 Ruby zusammengefasst	60
	Stärken	61
	Scripting	61
	Webentwicklung	61
	Produkteinführungszeit (Time to Market)	62
	Schwächen	63
	Performance	63
	Nebenläufigkeit und OOP	63
	Typsicherheit	63
	Abschließende Gedanken	64
	Kapitel 3 - Io	66
	3.1 Einführung in Io	66
	3.2 Tag 1: Blaumachen und rumhängen	67
	Aufwärmen	68
	Objekte, Prototypen und Vererbung	70
	Methoden	72
	Listen und Maps	74
	true, false, nil und Singletons	76
	Ein Interview mit Steve Dekorte	78
	Was wir am ersten Tag gelernt haben	80
	Tag 1: Selbststudium	80
	3.3 Tag 2: Der Würstchenkönig	81
	Bedingungen und Schleifen	81
	Operatoren	83
	Nachrichten	85
	Reflexion	88
	Was wir am zweiten Tag gelernt haben	89
	Tag 2: Selbststudium	89
	3.4 Tag 3: Die Parade und andere sonderbare Orte	90
	Domänenspezifische Sprachen	90
	Ios method_missing	93
	Nebenläufigkeit	95
	Koroutinen	95
	Aktoren	97
	Futures	98
	Was Sie am dritten Tag gelernt haben	98
	Tag 3: Selbststudium	99
	3.5 Io zusammengefasst	99
	Stärken	100
	Footprint	100
	Einfachheit	100
	Flexibilität	100
	Nebenläufigkeit	101
	Schwächen	101
	Syntax	101
	Community	102
	Performance	102
	Abschließende Gedanken	102
	Kapitel 4 - Prolog	104
	4.1 Über Prolog	105
	4.2 Tag 1: Ein ausgezeichneter Fahrer	106
	Grundlegende Fakten	106
	Grundlegende Folgerungen und Variablen	108
	Die Lücken füllen	109
	Karten einfärben	111
	Wo ist das Programm?	112
	Unifizierung, Teil 1	113
	Prolog in der Praxis	115
	Ein Interview mit Brian Tarbox, Delfinforscher	115
	Was wir am ersten Tag gelernt haben	118
	Tag 1: Selbststudium	119
	4.3 Tag 2: Fünfzehn Minuten für Wapner	119
	Rekursion	120
	Listen und Tupel	122
	Unifizierung, Teil 2	122
	Listen und Mathematik	124
	Regeln in beiden Richtungen verwenden	126
	Was wir am zweiten Tag gelernt haben	130
	Tag 2: Selbststudium	131
	4.4 Tag 3: Die Bank sprengen	131
	Sudokus lösen	132
	Acht Damen	137
	Was wir an Tag 3 gelernt haben	142
	Tag 3: Selbststudium	143
	4.5 Prolog zusammengefasst	144
	Stärken	144
	Natürliche Sprachverarbeitung	144
	Spiele	145
	Semantisches Web	145
	Künstliche Intelligenz	145
	Planung	145
	Schwächen	145
	Nützlichkeit	146
	Sehr große Datenmengen	146
	Mischen imperativer und deklarativer Modelle	146
	Abschließende Gedanken	146
	Kapitel 5 - Scala	148
	5.1 Über Scala	148
	Affinität zu Java ...	149
	Ohne sklavische Hingabe	150
	Ein Interview mit Scalas Schöpfer Martin Odersky	150
	Funktionale Programmierung und Nebenläufigkeit	152
	5.2 Tag 1: Die Burg auf der Anhöhe	153
	Scala-Typen	153
	Ausdrücke und Bedingungen	155
	Schleifen	156
	whileLoop	158
	forLoop	158
	rubyStyleForLoop	159
	Bereiche (Ranges) und Tupel	159
	Klassen in Scala	161
	Hilfskonstruktoren	164
	Klassen erweitern	164
	Companion-Objekte und Klassenmethoden	165
	Vererbung	165
	Traits	166
	Was wir am ersten Tag gelernt haben	167
	Tag 1: Selbststudium	168
	5.3 Tag 2: Gesträuch beschneiden und andere neue Tricks	168
	var versus val	170
	Collections	171
	Listen	171
	Sets	172
	Maps	174
	Alles und Nichts	175
	Collections und Funktionen	176
	foreach	177
	Weitere Listenmethoden	178
	count, map, filter und mehr	179
	foldLeft	180
	Was wir am zweiten Tag gelernt haben	182
	Tag 2: Selbststudium	183
	5.4 Tag 3: Sich durch die Fusseln schneiden	183
	XML	183
	Mustererkennung	185
	Guards	185
	Reguläre Ausrücke	186
	XML mit Matching	187
	Nebenläufigkeit	187
	Nebenläufigkeit in Aktion	189
	Was wir an Tag 3 gelernt haben	192
	Tag 3: Selbststudium	192
	5.5 Scala zusammengefasst	193
	Kernstärken	193
	Nebenläufigkeit	194
	Evolution des Java-Erbes	194
	Domänenspezifische Sprachen	195
	XML	195
	Brückenbildung	195
	Schwächen	195
	Statische Typisierung	196
	Syntax	196
	Veränderlichkeit	196
	Abschließende Gedanken	197
	Kapitel 6 - Erlang	198
	6.1 Einführung in Erlang	198
	Entwickelt für Nebenläufigkeit	199
	Kein Threading	199
	Leichtgewichtige Prozesse	200
	Zuverlässigkeit	200
	Interview mit Dr. Joe Armstrong	201
	6.2 Tag 1: Menschlich erscheinen	203
	Erste Schritte	204
	Kommentare, Variablen und Ausdrücke	204
	Atome, Listen und Tupel	205
	Mustererkennung	207
	Bit-Matching	208
	Funktionen	209
	Was wir an Tag 1 gelernt haben	212
	Tag 1: Selbststudium	213
	6.3 Tag 2: Die Form ändern	214
	Kontrollstrukturen	214
	Case	214
	If	215
	Anonyme Funktionen	216
	Listen und Funktionen höherer Ordnung	217
	Funktionen auf Listen anwenden	217
	foldl	220
	Fortgeschrittene Listenkonzepte	221
	Konstruktion von Listen	221
	Listenkomprehension	222
	Was wir an Tag 2 gelernt haben	225
	Tag 2: Selbststudium	225
	6.4 Tag 3: Die rote Pille	226
	Grundlegende Primitive zur Nebenläufigkeit	227
	Eine einfache Empfangsschleife	227
	Einen Prozess starten	228
	Nachrichten senden	229
	Synchrone Nachrichten	230
	Synchron empfangen	230
	Synchrones Senden	231
	Prozesse der Zuverlässigkeit halber verknüpfen	233
	Einen verknüpften Prozess starten	233
	Vom Leichenbeschauer zum Doktor	236
	Was wir an Tag 3 gelernt haben	238
	Tag 3: Selbststudium	238
	6.5 Erlang zusammengefasst	239
	Kernstärken	240
	Dynamisch und zuverlässig	240
	Leichtgewichtige, nichts teilende Prozesse	240
	OTP, die Enterprise-Bibliotheken	241
	Lass es abstürzen	241
	Kernschwächen	241
	Syntax	241
	Integration	242
	Abschließende Gedanken	242
	Kapitel 7 - Clojure	244
	7.1 Einführung in Clojure	245
	Alles Lisp	245
	Auf der JVM	246
	Modernisiert für eine parallele Welt	246
	7.2 Tag 1: Luke trainieren	246
	Grundlegende Funktionsaufrufe	248
	Strings und Chars	250
	Boolesche Werte und Ausdrücke	251
	Listen, Maps, Sets und Vektoren	252
	Listen	252
	Vektoren	253
	Sets	254
	Maps	255
	Funktionen definieren	257
	Bindungen	258
	Anonyme Funktionen	260
	apply	261
	filter	261
	Interview mit Rich Hickey, Schöpfer von Clojure	262
	Was wir am ersten Tag gelernt haben	264
	Tag 1: Selbststudium	265
	7.3 Tag 2: Yoda und die Macht	265
	Rekursion mit loop und recur	266
	Sequenzen	267
	Tests	268
	Eine Sequenz verändern	268
	Lazy Evaluation	270
	Endliche Sequenzen mit range	270
	Unendliche Sequenzen und take	271
	defrecord und protocol	273
	Makros	277
	Was wir an Tag 2 gelernt haben	278
	Tag 2: Selbststudium	279
	7.4 Tag 3: Ein Auge für Böses	279
	Referenzen und Transactional Memory	280
	Referenzen	280
	Mit Atomen arbeiten	282
	Einen Atom-Cache entwickeln	283
	Mit Agenten arbeiten	284
	Futures	285
	Was wir weggelassen haben	286
	Metadaten	286
	Java-Integration	286
	Multimethoden	287
	Threadzustand	287
	Was wir an Tag 3 gelernt haben	287
	Tag 3: Selbststudium	288
	7.5 Clojure zusammengefasst	289
	Das Lisp-Paradox	289
	Kernstärken	289
	Ein gutes Lisp	290
	Nebenläufigkeit	290
	Java-Integration	291
	Lazy Evaluation	291
	Daten als Code	291
	Kernschwächen	291
	Präfixnotation	292
	Lesbarkeit	292
	Lernkurve	292
	Beschränktes Lisp	292
	Zugänglichkeit	293
	Abschließende Gedanken	293
	Kapitel 8 - Haskell	294
	8.1 Einführung in Haskell	294
	8.2 Tag 1: Logisch	295
	Ausdrücke und primitive Typen	296
	Zahlen	296
	Character-Daten	296
	Boolesche Werte	297
	Funktionen	299
	Einfache Funktionen definieren	299
	Rekursion	301
	Tupel und Listen	302
	Programmieren mit Tupeln	302
	Tupel und Komposition	303
	Listen durchgehen	305
	Listen generieren	306
	Rekursion	306
	Ranges und Composition	307
	Listenkomprehension	308
	Ein Interview mit Philip Wadler	309
	Was wir an Tag 1 gelernt haben	311
	Tag 1: Selbststudium	311
	8.3 Tag 2: Spocks große Stärke	312
	Funktionen höherer Ordnung	312
	Anonyme Funktionen	313
	map und where	313
	filter, foldl, foldr	314
	Partiell angewandte Funktionen und Currying	315
	Lazy Evaluation	316
	Ein Interview mit Simon Peyton-Jones	319
	Was wir an Tag 2 gelernt haben	321
	Tag 2: Selbststudium	322
	8.4 Tag 3: Gedankenverschmelzung	323
	Klassen und Typen	323
	Grundlegende Typen	323
	Benutzerdefinierte Typen	324
	Funktionen und Polymorphismus	325
	Rekursive Typen	327
	Klassen	328
	Monaden	330
	Das Problem: Der betrunkene Pirat	330
	Komponenten einer Monade	332
	Eine Monade von Grund auf entwickeln	333
	Monaden und do-Notation	334
	Verschiedene rechnerische Strategien	334
	Maybe-Monade	336
	Was wir an Tag 3 gelernt haben	337
	Tag 3: Selbststudium	338
	8.5 Haskell zusammengefasst	339
	Kernstärken	339
	Typsystem	339
	Ausdrucksfähigkeit	340
	Reinheit des Programmiermodells	340
	„Lazy“ Semantik	340
	Akademische Unterstützung	341
	Kernschwächen	341
	Unflexibles Programmiermodell	341
	Community	341
	Lernkurve	342
	Abschließende Gedanken	342
	Kapitel 9 - Zusammenfassung	344
	9.1 Programmiermodelle	344
	Objektorientiert (Ruby, Scala)	345
	Prototyp-Programmierung (Io)	346
	Logikprogrammierung (Prolog)	346
	Funktionale Programmierung (Scala, Erlang, Clojure, Haskell)	346
	Paradigmen wechseln	347
	9.2 Nebenläufigkeit	348
	Kontrolle veränderlicher Zustände	348
	Aktoren bei Io, Erlang und Scala	349
	Futures	349
	Transactional Memory	350
	9.3 Programmierkonstrukte	350
	Listenkomprehensionen	350
	Monaden	351
	Matching	351
	Unifizierung	352
	9.4 Ihre Sprache finden	353
	Anhang A - Bibliografie	354
	Index	356