1. Einführung
1.1. Konzepte
1.1.1. Lernziel ist, Konzepte definieren, identifizieren, anwenden und Beispiele geben zu können.
2. Softwaresysteme
2.1. Was sind die Haupteigenschaften von Softwaresystemen?
2.2. Wie messen wir Softwaresysteme?
2.3. Definiere und identifiziere: Softwaresystem, Schnittstelle, Systemumgebung, Plattform
2.4. Was sind die Hauptschritte des Softwareentwicklungsprozesses?
2.5. Was sind die prinzipiellen Ausführungsvarianten für Software?
3. Formale Sprachen
3.1. Konzepte
3.1.1. Zeichen, Symbol, Zeichenreihe, formale Sprache
3.2. Gib die mathematische Definition einer SDmSD
3.3. Gib die Grundtypen der Syntaxdiagramme an.
3.4. Erkenne, ob eine Zeichenreihe zu einer gegebenen SDmSD konform ist.
3.5. Leite Beispielzeichenreihen aus einer SDmSD ab.
3.6. Gib die mathematische Definition einer kontextfreien Grammatik.
3.7. Konzepte
3.7.1. Ableitung, direkte Ableitung, Linksableitung, Rechtsableitung, Sprache, Satz, Satzform, mehrdeutiger Satz, eindeutiger Satz, Ableitungsbaum, Strukturbaum
3.8. Identifiziere, ob eine Grammatik kontextfrei ist.
3.9. Erkenne, ob eine Zeichenreihe einer kfG entspricht.
3.10. Erkläre den Unterschied zwischen Syntax und Semantik
3.11. Erkläre, wie Semantik aus Syntax abgeleitet werden kann (wie im Beispiel in der Vorlesung).
4. Paradigmen der Softwarentwicklung
4.1. Konzepte
4.1.1. deklarative Programmierung, logisches Programmieren, prozedurales Programmieren, objektorientiertes Programmieren
5. Funktionales Programmieren
5.1. Vertrautheit mit den algorithmischen Beispielen
5.1.1. wandle numerische Formeln in Haskellfunktionen um
5.1.2. berechne Fibonaccizahlen
5.1.3. berechne die Fakultätsfunktion
5.1.4. Hypothekentilgung
5.1.5. Berechnung von Quadratwurzel
5.2. Funktionen im Allgemeinen
5.2.1. Konzepte
5.2.1.1. partielle, totale Funktionen
5.2.1.2. Funktionsanwendung
5.2.1.3. Auswertung / Evaluierung
5.2.1.4. Terminierung
5.2.1.4.1. normal
5.2.1.4.2. abrupt
5.2.1.4.3. nicht-terminierend
5.2.2. Entscheidbarkeit der Terminierung
5.2.3. McCarthyfunktion
5.3. Werte, Typen, Datenstrukturen
5.3.1. Konzepte
5.3.1.1. Werte
5.3.1.2. Typen
5.3.1.3. Datenstrukturen
5.3.1.4. Signaturen
5.3.1.5. Stelligkeit
5.3.1.6. Überladen
5.3.1.7. Infixsyntax
5.3.1.8. Operatorenpräzedenz
5.3.1.9. Operatorensyntax in Haskell: (+), `plus`
5.3.1.10. Kategorien von Typen
5.3.1.10.1. elementare Daten
5.3.1.10.2. zusammengesetzte Werte
5.3.1.10.3. partielle Funktionen
5.3.1.11. Zahlen mit beschränkten Wertebereichen
5.3.2. Datenstrukturen
5.3.2.1. Haskell Datenstrukturen
5.3.2.1.1. Bool
5.3.2.1.2. Integer
5.3.2.1.3. Int
5.3.2.1.4. Float
5.3.2.1.5. Double
5.3.2.2. übliche Funktionen/Operatoren und ihre Typen
5.3.3. Notation
5.3.3.1. Ganzzahlen (123, 0x3f3, 0o177)
5.3.3.2. Gleitkommazahlen
5.3.3.3. Zeichen
5.3.3.4. Zeichenreihen
5.4. Aufbau funktionaler Programme
5.4.1. Beschreibung von Werten
5.4.1.1. Ausdrücke / Expressions
5.4.1.2. Präzedenzregeln
5.4.2. Deklaration und Bezeichnerbindung
5.4.3. Wertevereinbarung
5.4.4. Funktionsvereinbarung
5.4.5. Typvereinbarung
5.4.6. Lambdanotation
5.4.7. Funktionsdeklaration
5.4.7.1. direkte Wertevereinbarung mit Lambda
5.4.7.2. Funktionsdeklaration
5.4.7.3. Funktionsdeklaration mit Fallunterscheidung
5.4.7.4. Fallunterscheidung mit Mustern
5.4.7.5. rekursive Funktionsdeklaration
5.4.8. Rekursion
5.4.8.1. lineare Rekursion
5.4.8.2. repititive Rekursion
5.4.8.3. geschachtelte Rekursion
5.4.8.4. kaskadenartige Rekursion
5.5. zusammengesetze Datenstrukturen
5.5.1. Listen
5.5.2. Paare
5.5.3. n-Tupel
5.5.4. Schachteln
5.5.5. Muster in Deklarationen
5.6. noch Syntax
5.6.1. let
5.6.2. New node
5.7. benutzerdefinierte Datentypen
5.7.1. type
5.7.2. data
5.7.3. Summentypen
5.7.4. Konzepte
5.7.4.1. Konstruktorfunktion
5.7.4.2. Diskriminatorfunktion
5.7.4.3. Selektorfunktion
5.7.4.4. deriving (Eq,Show)
5.7.5. Aufzählungstypen
5.7.6. Stelligkeit von Konstruktoren
5.8. rekursive Datentypen
5.8.1. Definition von Listen
5.8.2. Definition von Binärbäumen
5.8.3. Konzepte
5.8.3.1. Baum
5.8.3.2. Knoten
5.8.3.3. Blatt
5.8.3.4. innerer Knoten
5.8.3.5. Zweig
5.8.3.6. Wurzel
5.8.3.7. Markierung
5.8.3.8. Binärbaum
5.8.3.9. Unterbaum
5.8.3.10. sortierte Bäume
5.8.3.11. Tiefe
5.8.3.12. Niveau
5.8.3.13. Höhe
5.8.3.14. Größe
6. Prozedurales Programmieren
6.1. Analogie Java / Haskell
6.1.1. gemeinsam
6.1.1.1. Funktionen
6.1.1.2. Rekursion
6.1.1.3. Verbundtypen
6.1.1.3.1. Listen
6.1.2. neu
6.1.2.1. Anweisungen
6.1.2.2. Wertezuweisung
6.1.2.3. Schleifen
6.1.2.4. Felder
6.1.2.5. L-values
6.2. Java Konstrukte
6.2.1. Bloecke
6.2.2. Variablendeklaration
6.2.3. Wertezuweisung
6.2.4. Funktionen
6.2.4.1. Prozeduren als spezielle Funktionen
6.2.4.2. void
6.2.5. Bedingungen
6.2.5.1. if else
6.2.5.2. switch case
6.2.6. Schleifen
6.2.6.1. while
6.2.6.2. do...while
6.2.6.3. for
6.2.6.4. break
6.2.6.5. continue
6.2.7. Datentypen
6.2.7.1. einfache Datentypen
6.2.7.1.1. int, float, double, char
6.2.7.2. einfache Datentypen (Referenzen)
6.2.7.2.1. String
6.2.7.3. Felder
6.2.7.3.1. Konstruktor
6.2.7.3.2. Selektorfunktion
6.2.7.3.3. L-values / R-values
6.2.7.3.4. Rekursion:Listen :: Iteration:Felder
6.2.7.4. Verbundtypen
6.2.7.4.1. Konstruktor
6.2.7.4.2. Selektorfunktionen
6.2.7.4.3. L-values / R-values
6.3. Prozedurale Programmierung
6.3.1. Ausdruecke
6.3.1.1. beachte Bitarithmetik
6.3.2. Variablen
6.3.2.1. Sichtbarkeit
6.3.2.1.1. Scope
6.3.2.2. Verschattung
6.3.2.2.1. shadowing / hiding
6.3.3. Seiteneffekte
6.3.3.1. reine Funktionen
6.3.3.1.1. pure functions
6.3.3.2. globale und lokale Variablen
6.3.3.3. Programmzustand und globale Variablen
6.3.4. Sichtbarkeit von Bezeichnern
6.3.4.1. Vergleich mit Dynamic Scoping
6.3.4.2. Lexical Scoping
6.3.5. Werte- und Referenztypen
6.3.5.1. null
6.3.5.2. Speicherraepresentation
6.3.5.3. Kastendiagramme (s.u.)
6.3.6. Schleifen und Rekursion - Äquivalenz
6.4. Programmablaeufe
6.4.1. Argumentuebergabe
6.4.1.1. call-by-value
6.4.1.2. call-by-need
6.4.1.3. Beispielprogramm Ite
6.4.1.4. Zustaende
6.4.1.4.1. Ausfuehrungszustand
6.4.1.4.2. Nachfolgezustand
6.4.1.4.3. Ausfuehrungsschritt
6.4.1.4.4. Aktion
6.4.1.4.5. Ablauf
6.4.2. Debugger
6.4.2.1. Beispielprogramm Abzahlung
6.4.2.2. Effizienz
6.4.2.2.1. Zeitkomplexitaet = Anzahl der Schritte in Abhaengigkeit der Groesse der Eingabe
6.4.2.2.2. Raumkomplexitaet = Speicherplatz in Abhaengigkeit der Eingabewerte
6.4.2.3. koennen wir die Abzahlung effizienter berechnen
6.4.2.4. illustriere PC
6.4.2.5. illustriere Variablenzustand
6.4.2.6. illustriere Interaktion mit print
6.4.2.7. print debugging
6.4.2.8. assertions vs print
6.4.2.8.1. assert expression;
6.4.2.8.2. assert expression : message;
6.4.3. Tracing
6.4.3.1. automatisch
6.4.3.2. manuell
6.4.3.2.1. "Instrumentierung"
6.4.3.2.2. print
6.4.3.2.3. print debugging
6.4.3.3. Beispielprogramm Fib und FibLoop
6.4.4. Profiling
6.4.4.1. Zeit / #Aufrufe
6.4.4.1.1. automatisch
6.4.4.1.2. manuell
6.4.4.2. Speicher
6.4.4.2.1. automatisch
6.4.4.2.2. manuell
6.4.4.3. Beispielprogramm Fib und FibLoop
6.5. Prozedurale Programmierung
6.5.1. Determinismus
6.5.1.1. deterministische Zustandsfolge
6.5.1.1.1. "deterministischer Algorithmus"
6.5.1.2. deterministische Ergebnisse
6.5.1.2.1. "determinierter Algorithmus"
6.5.1.3. nicht-deterministische Algorithmen
6.5.1.3.1. Las Vegas Algorithm
6.5.1.3.2. Monte Carlo
6.5.1.4. Beispiel: division mit choose
6.5.2. Inkarnation
6.5.2.1. procedure activation record
6.5.2.1.1. Speicherplatz fuer lokale Variblen
6.5.2.1.2. gegenwaertige Anweisung (wo wir zurueckkehren muessen)
6.5.2.2. Lebensdauer
6.5.2.3. Prozeduraufrufbaum
6.5.3. Speicher
6.5.3.1. lokale Variablen (in Prozeduraufrufen)
6.5.3.2. globale Variablen
6.5.3.3. Objekte
6.5.3.3.1. Felder
6.5.3.3.2. Verbundtypen
6.5.3.4. first-fit memory allocator
6.5.3.4.1. Beispiel; benutzerdefinierter Keller
6.5.4. Kastendiagramme
6.5.4.1. Felder
6.5.4.2. Verbundtypen
6.5.4.3. Objektreferenzen und Pfeile
6.5.4.4. pseudo-2D Felder
6.5.5. Listen in prozeduralen Sprachen
6.5.6. Baeume in prozeduralen Sprachen
6.5.6.1. Geflechte
6.5.7. Kastendiagramme fuer Prozeduraufruf
6.5.8. Umwandlung von rekursiven in Stackalgorithmen
6.5.9. automatische Programmtransformation