O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Sieben Wochen, sieben Sprachen (Prags)

Book Description

Ruby – Io – Prolog – Scala – Erlang – Clojure – Haskell: Mit diesen sieben Programmiersprachen versteht der Leser die wichtigsten Programmiermodelle unserer Zeit.

Der Leser überträgt das Konzept einer Sprache, um kreative Lösungen für eine andere Programmiersprache zu finden. Mit Sieben Wochen, sieben Sprachen lernt der Leser nicht nur neue Sprachen, sondern versteht auch, welcher Programmieransatz für welches reale Problem am besten geeignet ist. Von der Skriptsprache über die objektorientierte Programmierung bis hin zur funktionalen Programmiersprache – alles in einem Buch.

Table of Contents

  1. Sieben Wochen, sieben Sprachen: Verstehen Sie die modernen Sprachkonzepte
  2. Widmung
  3. Danksagung
  4. Vorwort
  5. 1. Einführung
    1. 1.1 Wahnsinn mit Methode
    2. 1.2 Die Sprachen
    3. 1.3 Kaufen Sie dieses Buch
      1. Lernen Sie zu lernen
      2. Hilfe in schwierigen Zeiten
    4. 1.4 Kaufen Sie dieses Buch nicht
      1. Ich gehe über die Syntax hinaus
      2. Ich helfe nicht bei der Installation
      3. Ich bin keine Programmierreferenz
      4. Ich werde Sie hart rannehmen
    5. 1.5 Ein letzter Punkt
  6. 2. Ruby
    1. 2.1 Ein wenig Geschichte
      1. Interview mit Yukihiro (Matz) Matsumoto
    2. 2.2 Tag 1: Ein Kindermädchen finden
      1. Schnelleinstieg
      2. Ruby über die Konsole nutzen
      3. Das Programmiermodell
      4. Entscheidungen
      5. Duck-Typing
      6. Was wir am ersten Tag gelernt haben
      7. Tag 1: Selbststudium
    3. 2.3 Tag 2: Vom Himmel herab
      1. Funktionen definieren
      2. Arrays
      3. Hashes
      4. Codeblöcke und yield
      5. Ruby aus einer Datei ausführen
      6. Klassen definieren
      7. Ein Mixin schreiben
      8. Module, Enumerable und Sets
      9. Was wir am zweiten Tag gelernt haben
      10. Tag 2: Selbststudium
    4. 2.4 Tag 3: Tiefgreifende Veränderung
      1. Offene Klassen
      2. Verwendung von method_missing
      3. Module
      4. Was wir am dritten Tag gelernt haben
      5. Tag 3: Selbststudium
    5. 2.5 Ruby zusammengefasst
      1. Stärken
      2. Scripting
      3. Webentwicklung
      4. Produkteinführungszeit (Time to Market)
      5. Schwächen
      6. Performance
      7. Nebenläufigkeit und OOP
      8. Typsicherheit
      9. Abschließende Gedanken
  7. 3. Io
    1. 3.1 Einführung in Io
    2. 3.2 Tag 1: Blaumachen und rumhängen
      1. Aufwärmen
      2. Objekte, Prototypen und Vererbung
      3. Methoden
      4. Listen und Maps
      5. true, false, nil und Singletons
      6. Ein Interview mit Steve Dekorte
      7. Was wir am ersten Tag gelernt haben
      8. Tag 1: Selbststudium
    3. 3.3 Tag 2: Der Würstchenkönig
      1. Bedingungen und Schleifen
      2. Operatoren
      3. Nachrichten
      4. Reflexion
      5. Was wir am zweiten Tag gelernt haben
      6. Tag 2: Selbststudium
    4. 3.4 Tag 3: Die Parade und andere sonderbare Orte
      1. Domänenspezifische Sprachen
      2. Ios method_missing
      3. Nebenläufigkeit
        1. Koroutinen
        2. Aktoren
        3. Futures
      4. Was Sie am dritten Tag gelernt haben
      5. Tag 3: Selbststudium
    5. 3.5 Io zusammengefasst
      1. Stärken
      2. Footprint
      3. Einfachheit
      4. Flexibilität
      5. Nebenläufigkeit
      6. Schwächen
      7. Syntax
        1. Community
        2. Performance
      8. Abschließende Gedanken
  8. 4. Prolog
    1. 4.1 Über Prolog
    2. 4.2 Tag 1: Ein ausgezeichneter Fahrer
      1. Grundlegende Fakten
      2. Grundlegende Folgerungen und Variablen
      3. Die Lücken füllen
      4. Karten einfärben
      5. Wo ist das Programm?
      6. Unifizierung, Teil 1
      7. Prolog in der Praxis
      8. Ein Interview mit Brian Tarbox, Delfinforscher
      9. Was wir am ersten Tag gelernt haben
      10. Tag 1: Selbststudium
    3. 4.3 Tag 2: Fünfzehn Minuten für Wapner
      1. Rekursion
        1. Listen und Tupel
      2. Unifizierung, Teil 2
      3. Listen und Mathematik
      4. Regeln in beiden Richtungen verwenden
      5. Was wir am zweiten Tag gelernt haben
      6. Tag 2: Selbststudium
    4. 4.4 Tag 3: Die Bank sprengen
      1. Sudokus lösen
      2. Acht Damen
      3. Was wir an Tag 3 gelernt haben
      4. Tag 3: Selbststudium
    5. 4.5 Prolog zusammengefasst
      1. Stärken
      2. Natürliche Sprachverarbeitung
        1. Spiele
        2. Semantisches Web
        3. Künstliche Intelligenz
        4. Planung
        5. Schwächen
        6. Nützlichkeit
        7. Sehr große Datenmengen
        8. Mischen imperativer und deklarativer Modelle
        9. Abschließende Gedanken
  9. 5. Scala
    1. 5.1 Über Scala
      1. Affinität zu Java ...
      2. Ohne sklavische Hingabe
        1. Ein Interview mit Scalas Schöpfer Martin Odersky
        2. Funktionale Programmierung und Nebenläufigkeit
    2. 5.2 Tag 1: Die Burg auf der Anhöhe
      1. Scala-Typen
      2. Ausdrücke und Bedingungen
      3. Schleifen
      4. whileLoop
      5. forLoop
      6. rubyStyleForLoop
      7. Bereiche (Ranges) und Tupel
      8. Klassen in Scala
      9. Hilfskonstruktoren
      10. Klassen erweitern
        1. Companion-Objekte und Klassenmethoden
        2. Vererbung
        3. Traits
        4. Was wir am ersten Tag gelernt haben
        5. Tag 1: Selbststudium
    3. 5.3 Tag 2: Gesträuch beschneiden und andere neue Tricks
      1. var versus val
      2. Collections
      3. Listen
      4. Sets
      5. Maps
      6. Alles und Nichts
      7. Collections und Funktionen
        1. foreach
        2. Weitere Listenmethoden
        3. count, map, filter und mehr
        4. foldLeft
      8. Was wir am zweiten Tag gelernt haben
      9. Tag 2: Selbststudium
    4. 5.4 Tag 3: Sich durch die Fusseln schneiden
      1. XML
        1. Mustererkennung
        2. Guards
        3. Reguläre Ausrücke
        4. XML mit Matching
        5. Nebenläufigkeit
        6. Nebenläufigkeit in Aktion
      2. Was wir an Tag 3 gelernt haben
      3. Tag 3: Selbststudium
    5. 5.5 Scala zusammengefasst
      1. Kernstärken
      2. Nebenläufigkeit
        1. Evolution des Java-Erbes
      3. Domänenspezifische Sprachen
        1. XML
        2. Brückenbildung
        3. Schwächen
        4. Statische Typisierung
        5. Syntax
        6. Veränderlichkeit
        7. Abschließende Gedanken
  10. 6. Erlang
    1. 6.1 Einführung in Erlang
      1. Entwickelt für Nebenläufigkeit
      2. Kein Threading
      3. Leichtgewichtige Prozesse
      4. Zuverlässigkeit
      5. Interview mit Dr. Joe Armstrong
    2. 6.2 Tag 1: Menschlich erscheinen
      1. Erste Schritte
      2. Kommentare, Variablen und Ausdrücke
      3. Atome, Listen und Tupel
      4. Mustererkennung
      5. Bit-Matching
      6. Funktionen
      7. Was wir an Tag 1 gelernt haben
      8. Tag 1: Selbststudium
    3. 6.3 Tag 2: Die Form ändern
      1. Kontrollstrukturen
      2. Case
      3. If
      4. Anonyme Funktionen
      5. Listen und Funktionen höherer Ordnung
      6. Funktionen auf Listen anwenden
      7. foldl
      8. Fortgeschrittene Listenkonzepte
      9. Konstruktion von Listen
      10. Listenkomprehension
      11. Was wir an Tag 2 gelernt haben
      12. Tag 2: Selbststudium
    4. 6.4 Tag 3: Die rote Pille
      1. Grundlegende Primitive zur Nebenläufigkeit
      2. Eine einfache Empfangsschleife
      3. Einen Prozess starten
      4. Nachrichten senden
      5. Synchrone Nachrichten
      6. Synchron empfangen
      7. Synchrones Senden
      8. Prozesse der Zuverlässigkeit halber verknüpfen
      9. Einen verknüpften Prozess starten
      10. Vom Leichenbeschauer zum Doktor
      11. Was wir an Tag 3 gelernt haben
      12. Tag 3: Selbststudium
    5. 6.5 Erlang zusammengefasst
      1. Kernstärken
      2. Dynamisch und zuverlässig
      3. Leichtgewichtige, nichts teilende Prozesse
      4. OTP, die Enterprise-Bibliotheken
      5. Lass es abstürzen
      6. Kernschwächen
      7. Syntax
      8. Integration
      9. Abschließende Gedanken
  11. 7. Clojure
    1. 7.1 Einführung in Clojure
      1. Alles Lisp
      2. Auf der JVM
      3. Modernisiert für eine parallele Welt
    2. 7.2 Tag 1: Luke trainieren
      1. Grundlegende Funktionsaufrufe
      2. Strings und Chars
      3. Boolesche Werte und Ausdrücke
      4. Listen, Maps, Sets und Vektoren
        1. Listen
        2. Vektoren
        3. Sets
        4. Maps
      5. Funktionen definieren
      6. Bindungen
      7. Anonyme Funktionen
        1. apply
        2. filter
      8. Interview mit Rich Hickey, Schöpfer von Clojure
      9. Was wir am ersten Tag gelernt haben
      10. Tag 1: Selbststudium
    3. 7.3 Tag 2: Yoda und die Macht
      1. Rekursion mit loop und recur
      2. Sequenzen
      3. Tests
      4. Eine Sequenz verändern
      5. Lazy Evaluation
        1. Endliche Sequenzen mit range
        2. Unendliche Sequenzen und take
      6. defrecord und protocol
      7. Makros
      8. Was wir an Tag 2 gelernt haben
      9. Tag 2: Selbststudium
    4. 7.4 Tag 3: Ein Auge für Böses
      1. Referenzen und Transactional Memory
        1. Referenzen
      2. Mit Atomen arbeiten
        1. Einen Atom-Cache entwickeln
      3. Mit Agenten arbeiten
      4. Futures
      5. Was wir weggelassen haben
        1. Metadaten
        2. Java-Integration
        3. Multimethoden
        4. Threadzustand
      6. Was wir an Tag 3 gelernt haben
      7. Tag 3: Selbststudium
    5. 7.5 Clojure zusammengefasst
      1. Das Lisp-Paradox
      2. Kernstärken
        1. Ein gutes Lisp
        2. Nebenläufigkeit
        3. Java-Integration
        4. Lazy Evaluation
        5. Daten als Code
      3. Kernschwächen
        1. Präfixnotation
        2. Lesbarkeit
        3. Lernkurve
        4. Beschränktes Lisp
        5. Zugänglichkeit
      4. Abschließende Gedanken
  12. 8. Haskell
    1. 8.1 Einführung in Haskell
    2. 8.2 Tag 1: Logisch
      1. Ausdrücke und primitive Typen
        1. Zahlen
        2. Character-Daten
        3. Boolesche Werte
      2. Funktionen
        1. Einfache Funktionen definieren
        2. Rekursion
      3. Tupel und Listen
        1. Programmieren mit Tupeln
        2. Tupel und Komposition
        3. Listen durchgehen
      4. Listen generieren
        1. Rekursion
        2. Ranges und Composition
        3. Listenkomprehension
      5. Ein Interview mit Philip Wadler
      6. Was wir an Tag 1 gelernt haben
      7. Tag 1: Selbststudium
    3. 8.3 Tag 2: Spocks große Stärke
      1. Funktionen höherer Ordnung
        1. Anonyme Funktionen
        2. map und where
        3. filter, foldl, foldr
      2. Partiell angewandte Funktionen und Currying
        1. Lazy Evaluation
      3. Ein Interview mit Simon Peyton-Jones
      4. Was wir an Tag 2 gelernt haben
      5. Tag 2: Selbststudium
    4. 8.4 Tag 3: Gedankenverschmelzung
      1. Klassen und Typen
        1. Grundlegende Typen
        2. Benutzerdefinierte Typen
        3. Funktionen und Polymorphismus
        4. Rekursive Typen
        5. Klassen
      2. Monaden
        1. Das Problem: Der betrunkene Pirat
        2. Komponenten einer Monade
        3. Eine Monade von Grund auf entwickeln
        4. Monaden und do-Notation
        5. Verschiedene rechnerische Strategien
        6. Maybe-Monade
      3. Was wir an Tag 3 gelernt haben
      4. Tag 3: Selbststudium
    5. 8.5 Haskell zusammengefasst
      1. Kernstärken
      2. Typsystem
      3. Ausdrucksfähigkeit
      4. Reinheit des Programmiermodells
      5. „Lazy“ Semantik
      6. Akademische Unterstützung
      7. Kernschwächen
        1. Unflexibles Programmiermodell
        2. Community
        3. Lernkurve
      8. Abschließende Gedanken
  13. 9. Zusammenfassung
    1. 9.1 Programmiermodelle
      1. Objektorientiert (Ruby, Scala)
      2. Prototyp-Programmierung (Io)
      3. Logikprogrammierung (Prolog)
      4. Funktionale Programmierung (Scala, Erlang, Clojure, Haskell)
      5. Paradigmen wechseln
    2. 9.2 Nebenläufigkeit
      1. Kontrolle veränderlicher Zustände
      2. Aktoren bei Io, Erlang und Scala
      3. Futures
      4. Transactional Memory
    3. 9.3 Programmierkonstrukte
      1. Listenkomprehensionen
      2. Monaden
      3. Matching
      4. Unifizierung
    4. 9.4 Ihre Sprache finden
  14. A. Bibliografie
  15. Stichwortverzeichnis