Sieben Wochen, sieben Sprachen

The Pragmatic Programmers Sieben Wochen, sieben Sprachen Verstehen Sie die modernen Sprachkonzepte Deutsche Übersetzung von O REILLY Bruce A. Tate Übersetzt von Peter Klicman

Inhaltsverzeichnis Widmung 1 Danksagung 3 Vorwort 7 1 Einführung 11 1.1 Wahnsinn mit Methode...................... 11 1.2 Die Sprachen.............................. 13 1.3 Kaufen Sie dieses Buch...................... 15 1.4 Kaufen Sie dieses Buch nicht.................. 17 1.5 Ein letzter Punkt........................... 20 2 Ruby 21 2.1 Ein wenig Geschichte........................ 22 2.2 Tag 1: Ein Kindermädchen finden.............. 24 2.3 Tag 2: Vom Himmel herab.................... 32 2.4 Tag 3: Tiefgreifende Veränderung............... 45 2.5 Ruby zusammengefasst...................... 53 3 Io 59 3.1 Einführung in Io........................... 59 3.2 Tag 1: Blaumachen und rumhängen............ 60 3.3 Tag 2: Der Würstchenkönig................... 74 3.4 Tag 3: Die Parade und andere sonderbare Orte.... 83 3.5 Io zusammengefasst......................... 92 4 Prolog 97 4.1 Über Prolog............................... 98 4.2 Tag 1: Ein ausgezeichneter Fahrer.............. 99

VI Inhaltsverzeichnis 4.3 Tag 2: Fünfzehn Minuten für Wapner............ 112 4.4 Tag 3: Die Bank sprengen..................... 124 4.5 Prolog zusammengefasst...................... 137 5 Scala 141 5.1 Über Scala................................ 141 5.2 Tag 1: Die Burg auf der Anhöhe................ 146 5.3 Tag 2: Gesträuch beschneiden und andere neue Tricks................................ 161 5.4 Tag 3: Sich durch die Fusseln schneiden......... 176 5.5 Scala zusammengefasst...................... 186 6 Erlang 191 6.1 Einführung in Erlang........................ 191 6.2 Tag 1: Menschlich erscheinen.................. 196 6.3 Tag 2: Die Form ändern...................... 207 6.4 Tag 3: Die rote Pille.......................... 219 6.5 Erlang zusammengefasst..................... 232 7 Clojure 237 7.1 Einführung in Clojure........................ 238 7.2 Tag 1: Luke trainieren........................ 239 7.3 Tag 2: Yoda und die Macht.................... 258 7.4 Tag 3: Ein Auge für Böses..................... 272 7.5 Clojure zusammengefasst..................... 282 8 Haskell 287 8.1 Einführung in Haskell........................ 287 8.2 Tag 1: Logisch.............................. 288 8.3 Tag 2: Spocks große Stärke.................... 305 8.4 Tag 3: Gedankenverschmelzung................ 316 8.5 Haskell zusammengefasst..................... 332 9 Zusammenfassung 337 9.1 Programmiermodelle......................... 337 9.2 Nebenläufigkeit............................. 341 9.3 Programmierkonstrukte...................... 343 9.4 Ihre Sprache finden......................... 346 A Bibliografie 347 Index 349

Kapitel 1 Einführung Menschen lernen Sprachen aus den unterschiedlichsten Gründen. Ihre Muttersprache haben Sie gelernt, um überhaupt leben zu können. Sie stellt das Werkzeug dar, das ihnen dabei hilft, den Alltag zu meistern. Wenn Sie eine zweite Sprache erlernt haben, kann das verschiedene Gründe gehabt haben. Manchmal muss man eine zweite Sprache der Karriere wegen lernen, oder um sich an eine veränderte Umgebung anzupassen. Doch manchmal lässt man sich auf eine neue Sprache ein, nicht weil man sie lernen muss, sondern weil man sie lernen will. Eine zweite Sprache kann Ihnen dabei helfen, neue Welten zu entdecken. Sie könnten sogar Erleuchtung suchen, da Sie wissen, dass jede neue Sprache auch das Denken formt. Das Gleiche gilt für Programmiersprachen. In diesem Buch werde ich Ihnen sieben verschiedene vorstellen. Dabei möchte Sie auf eine Reise mitnehmen, die Sie aufklären und Ihren Blick auf das Programmieren verändern soll. Ich werde Sie nicht zum Experten machen, aber ich werden Ihnen mehr beibringen als bloß Hallo Welt! 1.1 Wahnsinn mit Methode Wenn ich eine neue Programmiersprache oder ein neues Framwork erlerne, suche ich meist nach einem kurzen, interaktiven Tutorial. Mein Ziel ist es, die Sprache in einer komtrollierten Umgebung zu erleben. Bei Bedarf kann ich etwas eingehender untersuchen, doch im Wesentlichen geht es mir um eine schnelle Dosis Koffein, einen Schnappschuss des syntaktischen Zuckers und um die Kernkonzepte.

12 Kapitel 1: Einführung Aber üblicherweise ist diese Erfahrung nicht besonders erhellend. Wenn Sie den wahren Charakter einer Sprache kennenlernen wollen, die mehr ist als eine bloße Erweiterung einer Sprache, die Sie schon kennen, dann wird ein kurzes Tutorial niemals funktionieren. Sie müssen schnell und tief eintauchen. Dieses Buch bietet Ihnen diese Erfahrung nicht nur ein-, sondern gleich siebenmal. Sie finden Antworten auf die folgenden Fragen: Welches Modell der Typisierung wird verwendet? Die Typisierung kann stark (Java) oder schwach (C), statisch (Java) oder dynamisch (Ruby) sein. Die Sprachen in diesem Buch reichen vom stark typisierten Ende des Spektrums bis hin zu einem breiten Mix aus statisch und dynamisch. Sie werden sehen, wie sich die jeweiligen Kompromisse bzw. Nachteile für den Entwickler auswirken. Das Typisierungsmodell prägt die Art und Weise, in der Sie ein Problem angehen, und kontrolliert, wie die Progammiersprache funktionert. Jede Sprache in diesem Buch hat ihre eigenen Typisierungs-Eigenarten. Welches Programmiermodell wird verwendet? Ist es objektorientiert, funktional, prozedural oder irgendeine Art Hybrid? Dieses Buch behandelt Sprachen mit vier verschiedenen Programmiermodellen, manchmal auch Kombinationen mehrerer Modelle. Sie werden eine logikbasierte Programmiersprache (Prolog) vorfinden, zwei Sprachen, die vollständig objektorientierte Konzepte unterstützen (Ruby, Scala), vier Sprachen funktionaler Natur (Scala, Erlang, Clojure, Haskell) sowie eine Prototyp-Sprache (Io). Mehrere Sprachen unterstützen auch mehrere Paradigmen, z. B. Scala. Clojures Multimethoden erlauben es Ihnen sogar, ein eigenes Paradigma zu implementieren. Das Erlernen neuer Programmierparadigmen ist eines der wichtigsten Konzepte dieses Buches. Wie interagiert man mit ihr? Sprachen werden kompiliert oder interpretiert und einige verwenden virtuelle Maschinen, andere hingegen nicht. Ich beginne meine Erkundung mit einer interaktiven Shell, wenn es denn eine gibt. Ich gehe dann zu Dateien über, wenn es an der Zeit ist, größere Projekte anzugehen. Unsere Projekte werden aber nicht groß genug sein, um vollständig in die Paketmodelle einzutauchen.

Die Sprachen 13 Was sind die Entscheidungskonstrukte und die Kern-Datenstrukturen? Sie werden überrascht sein, wie viele Sprachen Entscheidungen mit etwas anderem als Varianten von ifs und whiles treffen können. Sie werden die Mustererkennung (Pattern Matching) in Erlang und die Vereinigung (unification) in Prolog kennenlernen. Collections ( Sammlungen ) spielen in nahezu jeder Sprache eine wichtige Rolle. Bei Sprachen wie Smalltalk und Lisp definieren Collections die Charakeristika der Sprache. Bei anderen, wie C++ und Java, sind Collections überall verstreut und definieren das Erleben des Benutzers durch ihr Fehlen und ein geringeres Maß an Stringenz. So oder so sollte man sich mit Collections gut auskennen. Welche Kerneigenschaften machen die Sprache einzigartig? Einige Sprachen besitzen fortgeschrittene Fähigkeiten für die nebenläufige Programmierung (concurrent programming). Andere bieten einzigartige High-Level-Konstrukte wie etwa Clojures Makros oder Ios Message-Interpretation. Andere bieten eine leistungsfähige virtuelle Maschine, wie etwa Erlangs BEAM: Dank ihr kann man mit Erlang fehlertolerante, verteilte Systeme wesentlich schneller aufbauen, als es mit anderen Sprachen möglich ist. Einige Programmiersprachen unterstützen Programmiermodelle, die sich auf ein bestimmtes Problem konzentrieren. Etwa die Verwendung von Logik zur Lösung von Beschränkungen (constraints). Wenn Sie mit diesem Buch fertig sind, werden Sie kein Experte für eine dieser Sprachen sein, aber Sie werden wissen, welche einzigartigen Eigenschaften sie besitzen. Sehen wir uns die Sprachen an. 1.2 Die Sprachen Die Auswahl der Sprachen für dieses Buch war wesentlich einfacher, als Sie vielleicht glauben: Ich habe einfach potenzielle Leser gefragt. Nachdem wir uns alle Daten näher angesehen hatten, blieben acht Kandidaten übrig. Ich habe JavaScript gestrichen, weil es mir zu beliebt ist, und durch die zweitpopulärste Prototypsprache Io ersetzt. Ich habe auch Python gestrichen, weil ich nur eine objektorientierte Sprache wollte und Ruby höher auf der Liste stand. Das schuf Raum für einen überraschenden Kandidaten, Prolog, das auf der Liste unter den Top- Ten war. Hier die Sprachen, die es geschafft haben, sowie die Gründe für ihre Wahl:

14 Kapitel 1: Einführung Ruby. Diese objektorientierte Sprache erhält gute Noten wegen ihrer einfachen Verwendbarkeit und guten Lesbarkeit. Ich habe kurz daran gedacht, überhaupt keine objektorientierte Sprache aufzunehmen, aber ich wollte die verschiedenen Programmierparadigmen mit der objektorientierten Programmierung (OOP) vergleichen, weshalb es wichtig war, zumindest eine OOP-Sprache aufzunehmen. Ich wollte Ruby außerdem etwas mehr fordern, als das die meisten Programmierer tun, und den Lesern eine Vorstellung von den Grundentscheidungen vermitteln, die das Design von Ruby geprägt haben. Ich habe mich entschieden, in die Ruby- Metaprogrammierung einzutauchen, was es mir erlaubt, die Syntax der Sprache zu erweitern. Ich bin recht zufrieden mit dem Ergebnis. Io. Neben Prolog ist Io die umstrittenste Sprache, die ich aufgenommen habe. Sie ist kommerziell nicht erfolgreich, doch die Konstrukte zur Nebenläufigkeit mit ihrer Einfachheit und ihrer gleichförmigen Syntax sind wichtige Konzepte. Die minimale Syntax ist leistungsfähig und die Ähnlichkeit zu Lisp manchmal verblüffend. Io hat einen kleinen Footprint, ist eine Prototypsprache wie JavaScript und besitzt einen einzigartigen Mechanismus zum Message-Dispatch, den Sie (glaube ich) interessant finden werden. Prolog. Ja, ich weiß, sie ist alt, aber eben auch extrem leistungsfähig. Das Lösen eines Sudoku-Rätsels in Prolog war eine Erfahrung, die mir die Augen geöffnet hat. Ich habe hart daran gearbeitet, schwierige Probleme in Java oder C zu lösen, die in Prolog ohne besondere Mühe hätten gelöst werden können. Joe Armstrong, der Schöpfer von Erlang, half mir dabei, ein tieferes Verständnis für diese Sprache zu entwickeln, die Erlang stark beeinflusst hat. Wenn Sie noch nicht die Gelegenheit hatten, sie zu verwenden, werden Sie angenehm überrascht sein. Scala. Als Mitglied der neuen Generation von Sprachen für die Java Virtual Machine hat Scala starke funktionale Konzepte in das Java-Ökosystem eingeführt. Sie schließt auch OOP mit ein. Rückblickend sehe ich verblüffende Ähnlichkeiten mit C++, das entscheidend dazu beigetragen hat, eine Brücke zwischen prozeduraler Programmierung und OOP zu schaffen. Wenn Sie in die Scala-Community eintauchen, werden Sie sehen, warum Scala die reine Häresie für rein funktionale Programmier ist und ein wahrer Segen für Java-Entwickler.

Kaufen Sie dieses Buch 15 Erlang. Als eine der ältesten Sprachen auf der Liste nimmt Erlang langsam als funktionale Sprache Fahrt auf, die Nebenläufigkeit, Verteilung und Fehlertoleranz gut im Griff hat. Die Schöpfer von CouchDB, einer der aufkommenden Cloud-basierten Datenbanken, haben sich für Erlang entschieden und es nie bereut. Sobald Sie ein wenig Zeit mit dieser verteilten Sprache verbracht haben, werden Sie sehen, warum Erlang den Entwurf nebenläufiger, verteilter und fehlertoleranter Systeme wesentlich einfacher macht, als Sie es jemals für möglich gehalten haben. Clojure. Als weitere JVM-Sprache nimmt dieser Lisp-Dialekt radikale Änderungen an der Art und Weise vor, wie wir uns Nebenläufigkeit auf der JVM vorstellen. Es ist die einzige Sprache in diesem Buch, die die gleiche Strategie in versionierten Datenbanken nutzt, um die Nebenläufigkeit zu verwalten. Als Lisp-Dialekt hat Clojure einiges zu bieten und unterstützt das vielleicht flexibelste Programmiermodell dieses Buches. Doch im Gegensatz zu anderen Lisp-Dialekten wurden die Klammern stark reduziert. Darüber hinaus können Sie auf ein riesiges Ökosystem bauen, einschließlich einer großen Java- Bibliothek und weit verbreiteter Deployment-Plattformen. Haskell. Diese Sprache ist die einzige rein funkionale Sprache in diesem Buch. Das bedeutet, dass Sie an keiner Stelle einen veränderlichen Zustand vorfinden. Die gleiche Funktion mit den gleichen Eingabeparametern liefert immer die gleiche Ausgabe zurück. Von allen stark typisierten Sprachen verwendet Haskell das anerkannteste Typisierungsmodell. Wie bei Prolog dauert es eine Weile, bis man es versteht, doch die Ergebnisse sind es wert. Es tut mir leid, wenn Ihre Lieblingssprache nicht auf der Liste steht. Sie können mir glauben, dass ich bereits Hass-E-Mails von nicht wenigen Sprachenthusiasten erhalten habe. Wir haben mehrere Dutzend Sprachen in die oben erwähnte Umfrage aufgenommen. Die von mir gewählten Sprachen sind nicht notwendigerweise die besten, doch jede davon ist einzigartig und Sie können etwas Wichtiges von ihr lernen. 1.3 Kaufen Sie dieses Buch... wenn Sie ein kompetenter Programmierer sind, der wachsen will. Das klingt vielleicht ein wenig nebulös, aber zeigen Sie etwas Nachsicht mit mir.

Index A Aktoren Erlang 193 Io 90 Scala 180 184 anonyme Funktionen Clojure 253, 255 Erlang 209 210 Haskell 306 Armstrong, Joe 192 195 B Bedingungen Io 69, 71 Scala 148, 150 C Clojure 15, 237 286 Agenten 277 278 anonyme Funktionen 253, 255 Atome 275, 277 Ausdrücke 244 245 Bindungen 251, 253 Boolesche Werte 244 245 Destrukturierung 251 Forms 242 Funktionen 250 255 Futures 279, 342 Installieren 240 Java-Integration 239, 266, 280, 284 Konsole 240 Lazy Evaluation 263 266, 284 leiningen 240 Lesbarkeit 285 Lisp und 238, 282 283, 285 Listen 245 246, 344 Makros 270 271 Maps 248 249 mathematische Operationen 241 242 Metadaten 279 Multimethoden 280 Mustererkennung (Pattern Matching) 344 Nebenläufigkeit 273 280, 283 Präfix-Notation 285 Programmiermodell 340 Protokolle 266 Referenzen 273, 275 Rekursion 259 260 repl 240 Schöpfer 255 258 Schwächen 284, 286 Sequenzen 260, 266 269 Sets 247 248 Stärken 282, 284 Strings 243 244 Thread-Zustand 280 Transactional Memory 273, 275, 343

350 Codeblöcke, Ruby 38 Typisierungsmodell 242 Unendliche Sequenzen 264 266 Vektoren 246 247 Codeblöcke, Ruby 38 Currying Haskell 308 309 Scala 174 D Datenstrukturen 13 deklarative Sprache, Prolog als 98 Dekorte, Steve 59 domänenspezifische Sprache mit Scala 188 domänenspezifische Sprachen mit Io 86 dynamische Typisierung Clojure 242 Erlang 202, 205 Ruby 30 E Entscheidungskonstrukte 13 Erlang 15, 191 235 Aktoren 193, 342 anonyme Funktionen 209 210 Atome 198, 200 Ausdrücke 197 198 Bibliotheken 234 Funktionen 202 205, 209 214 gekoppelte Prozesse 226 231 Iteration 210 211 Kontrollstrukturen 207, 209 leichtgewichtige Prozesse 193, 233 Listen 198, 200, 210 218, 344 Mustererkennung (Pattern Matching) 200 202, 344 Nachrichten 220 225 Nebenläufigkeit 192, 194, 220 225 Programmiermodell 196, 340 Schöpfer 191, 194 195 Schwächen 234 235 Stärken 233 234 Tupel 198, 200 Typisierungsmodell 202 F Variablen 197 198 Zuverlässigkeit 192 193, 226 233 foldleft-methode, Scala 174 Forms, Clojure 242 funktionale Programmiersprache Erlang als 196 Haskell als 288, 333 334 Nebenläufigkeit und 145 146 Scala als 162, 164 Funktionen Clojure 250, 255 Erlang 202 205, 209 214 Haskell 292 293, 318 319 Ruby 32 Scala 169 174 Funktionen höherer Ordnung Haskell 305 308 Scala 141 143 Futures 342 Clojure 279 Io 91 H Haskell 15 335 anonyme Funktionen 306 Ausdrücke 289 291 Currying 308 Filter 307 308 Folding 307 308 Function Composition 296, 298 Funktionen 292 293, 318 319 Funktionen höherer Ordnung 305 Klassen 321 322 Lazy Evaluation 309, 311 List Comprehensions 301 302 Listen 298 302, 344 Mapping 306 307 Monaden 344 Mustererkennung (Pattern Matching) 344 partiell angewandte Funktionen 307 309 Polymorphismus 318 319

logic Programmiersprachen, Prolog als 98, 339 351 Programmiermodell 288, 333 334, 340 Rekursion 294, 299 300 rekursive Typen 320 321 Schöpfer 302, 304, 312 Stärken 332 334 starten 288 Tupel 295 298 Typen 289 291, 316 322 Typisierungsmodell 288, 333 Wertebereiche (Ranges) 300 301 HaskellFunktionen höherer Ordnung 308 Hilfskonstruktoren 157 I Interaktionsmodell 12 interpretierte Sprache Io als 61 Ruby als 25 Io 14 Aktoren 90, 342 Bedingungen 69, 71 Bedingungsanweisungen 74, 76 clone, Nachricht 61 domänenspezifische Sprache mit 83, 86 forward, Nachricht 86, 88 Futures 91, 342 installieren 61 interpretiertes Modell 61 Iteration 74, 76 Listen 67, 69 Maps 68 Methoden 65, 67 Nachrichten 60, 67, 78, 81 Nebenläufigkeit 88, 91, 94 Objekte 60 61, 65, 67 Operatoren 76, 78 Performance 95 Programmiermodell 339 Prototypen 60, 67 Reflexion 81 Schleifen 75 76 Schöpfer 59, 71 72 Schwächen 94 95 slots in Objekte 61, 67 Stärken 93 94 Typisierungsmodell 64 Vererbung 63, 65 Zuweisung 77 Iteration Erlang 210 211 Io 74, 76 Scala 149 152, 170 172 J Java Clojure und 239, 266, 280, 284 Scala integriert in 143 Scala und 142, 187 K Klassen Haskell 321 322 Ruby 38, 41 Scala 154 160 kompilierte Sprache Erlang als 197 Prolog als 99 Scala als 147 L Lazy Evaluation Clojure 284 Haskell 309 311 leichtgewichtige Prozesse, Erlang 233 Lisp, Clojure und 238, 282 283, 285 Listen 344 Clojure 245 246 Erlang 198, 200, 210 218 Haskell 298 302 Io 67, 69 Prolog 115, 119 Scala 164 165, 170 174 logic Programmiersprachen, Prolog als 98, 339

352 Maps M Maps Clojure 248 249 Haskell 306 307 Io 68 Scala 167 168 Metadaten, Clojure 279 model Erlang 202 Monaden, Haskell 323 330, 344 Mustererkennung (Pattern Matching) 344 Erlang 200 202 Scala 141 190 N Nachrichten, Io 60, 67 natürliche Sprachverarbeitung, Prolog 137 Nebenläufigkeit 341 343 Clojure 273 279, 283 Erlang 192, 194, 220 225 Io 88, 91, 94 Ruby 56 Scala 145 146, 163 164, 180 184, 187 O Objekte Io 66 67 Objektorientierte Sprachen Io als 60 Ruby als 26, 338 Scala als 338 P partiell angewandte Funktionen, Haskell 307 308 Performance Io 95 Ruby 56 Programmiermodell 12 Programmiersprachen installieren 18 lernen 12 13, 16 17 Prolog 14 Abfragen (Queries) 102, 104 Acht Damen, Beispiel 130, 135 append, Regel 120, 123 Großschreibung bei 99 Inferenz 101 102 Landkarte einfärben, Beispiel 104, 106 Listen 115, 119 Mathematik 117, 119 Mustererkennung (Pattern Matching) 344 Programmiermodell 337 340 Rekursion 113 114, 117, 119 Scheduling, Beispiel 111 Schöpfer 98 Schwächen 138 Stärken 137 138 Sudoku, Beispiel 125, 130 Tupel 115, 117 Unifikation 106, 108, 115, 117, 345 Wissensdatenbank 99 PrologUnifikation 117 Protokolle, Clojure 266 269 Prototypen, Io 67 Prototyp-Programmiersprache, Io als 60 R Reflexion, Io 81 Rekursion Clojure 259 260 Haskell 294, 299 300 Prolog 113 114, 117, 119 Scala 171 Ruby 14, 21, 57 Arrays 33 34 aus Datei ausführen 38 Codeblöcke 36 Entscheidungskonstrukte 26, 29 Entwickler von 22 23 Funktionen 32 Geschichte 22 Hashes 34, 36 installieren 24

Transactional Memory, Clojure 343 353 S interaktive Console 25 interpretiertes Modell 25 Klassen 38, 41 Metaprogrammierung 45 method_missing-verhalten 48 Mixins 41, 44 Module 41, 44, 49, 52 Nebenläufigkeit 56 offen 47 offene Klassen 46 47 Performance 56 Produkteinführungszeit (time to market) 55 Programmiermodell 26, 338 Raumschiff- (Spaceship) Operator 42 Schwächen 56 57 Skripting 54 Stärken 54 55 Typisierungsmodell 29 30 Typsicherheit 57 Verarbeitung von Strings 25 Web-Entwicklung 54 Scala 14, 141 190 Aktoren 180 184, 342 Any, Klasse 168 Ausdrücke 148 150 Bedingungen 148 150 Collections 164 174 Currying 174 domänenspezifische Sprachen mit 188 foldleft, Methode 174 Funktionen 169 174 Funktionen höherer Ordnung 169 Integration mitjava 143 Iteration 149 152, 170 172 Java und 142, 187 Klassen 154, 156 157, 160 Listen 164 165, 170 174 Maps 167 168 Mustererkennung (Pattern Matching) 178 180, 344 Nebenläufigkeit 145 146, 163 164, 180 184, 187 Nothing (Typ) 168 Programmiermodell 338, 340 Rekursion 171 Schöpfer 145 Schwächen 188 Sets 165 166 Stärken 186, 188 Traits 159 Tupel 154 Typen 146 147 Typisierungsmodell 150, 189 unveränderliche Variablen 163 164 Vererbung 158 Wertebereiche (Ranges) 152 154 XML und 176, 180, 188 semantisches Web, Prolog für 138 Sequenzen, clojure 260 266 Sets Clojure 247 248 Scala 165 166 Skripting, Ruby 54 Slots in Objekten, Io 61, 67 Spiele, Prolog für 138 stark typisierte Sprachen Clojure 242 Erlang 205 Haskell 288, 333 Ruby 29 Scala 147 statische Typisierung Haskell 288 Scala 150, 189 Strings Clojure 243 244 Rubys Verarbeitung von 25 syntaktischer Zucker 22 T Tarbox, Brian 111 Thread-Zustand, Clojure 280 Traits, Scala 159 Transactional Memory, Clojure 343

354 Tupel Tupel Erlang 198, 200 Haskell 295, 298 Prolog 115, 117 Typisierungsmodell 12 Clojure 242 Haskell 333 Io 64 Ruby 29, 31 Scala 146 147 Typsicherheit, Ruby 57 V veränderliche Zustände, Kontrolle 341 Vererbung Io 63, 65 Scala 158 W Web-Entwicklung, Ruby 54 Wissensdatenbank, Prolog 99 U Unifikation, Prolog 345 X XML Scala mit 178 XML, Scala und 180 XML, Scala und XPath 188