Tippfehler korrigiert; Beispiele hinzugefügt

documents/Programmierparadigmen/Programmiersprachen.tex

@@ -1,8 +1,5 @@
 %!TEX root = Programmierparadigmen.tex
 \chapter{Programmiersprachen}
-Im folgenden werden einige Begriffe definiert anhand derer
-Programmiersprachen unterschieden werden können.
-
 \begin{definition}\xindex{Programmiersprache}\xindex{Programm}%
     Eine \textbf{Programmiersprache} ist eine formale Sprache, die durch eine
     Spezifikation definiert wird und mit der Algorithmen beschrieben werden
@@ -27,8 +24,8 @@ Wie nah ist sie an einer mathematisch / algorithmischen Beschreibung?
 
 \begin{beispiel}[Maschinensprachen]
     \begin{bspenum}
-        \item \xindex{x86}x86: 
-        \item \xindex{SPARC}SPARC:
+        \item \xindex{x86}x86
+        \item \xindex{SPARC}SPARC
     \end{bspenum}
 \end{beispiel}
 
@@ -65,28 +62,39 @@ Wie nah ist sie an einer mathematisch / algorithmischen Beschreibung?
 \end{beispiel}
 
 \section{Paradigmen}
-Die grundlegendste Art, wie man Programmiersprachen unterscheiden
+Eine weitere Art, wie man Programmiersprachen unterscheiden
 kann ist das sog. \enquote{Programmierparadigma}, also die Art wie
 man Probleme löst.
 
-\begin{definition}[Imperatives Paradigma]\xindex{Programmierung!imperative}
-    In der imperativen Programmierung betrachtet man Programme als
-    eine folge von Anweisungen, die vorgibt auf welche Art etwas 
+\begin{definition}[Imperatives Paradigma]\xindex{Programmierung!imperative}%
+    In der \textit{imperativen Programmierung} betrachtet man Programme als
+    eine Folge von Anweisungen, die vorgibt auf welche Art etwas 
     Schritt für Schritt gemacht werden soll.
 \end{definition}
 
-\begin{definition}[Prozedurales Paradigma]\xindex{Programmierung!prozedurale}
+\begin{beispiel}[Imperative Programmierung]
+    In folgenden Programm erkennt man den imperativen Programmierstil vor allem
+    an den Variablenzuweisungen:
+    \inputminted[numbersep=5pt, tabsize=4]{c}{scripts/c/fibonacci-imperativ.c}
+\end{beispiel}
+
+\begin{definition}[Prozedurales Paradigma]\xindex{Programmierung!prozedurale}%
     Die prozeduralen Programmierung ist eine Erweiterung des imperativen
     Programmierparadigmas, bei dem man versucht die Probleme in 
     kleinere Teilprobleme zu zerlegen.
 \end{definition}
 
-\begin{definition}[Funktionales Paradigma]\xindex{Programmierung!funktionale}
+\begin{definition}[Funktionales Paradigma]\xindex{Programmierung!funktionale}%
     In der funktionalen Programmierung baut man auf Funktionen und
     ggf. Funktionen höherer Ordnung, die eine Aufgabe ohne Nebeneffekte
     lösen.
 \end{definition}
 
+\begin{beispiel}[Funktionale Programmierung]
+    Der Funktionale Stil kann daran erkannt werden, dass keine Werte zugewiesen werden:
+    \inputminted[numbersep=5pt, tabsize=4]{haskell}{scripts/haskell/fibonacci-akk.hs}
+\end{beispiel}
+
 Haskell ist eine funktionale Programmiersprache, C ist eine
 nicht-funktionale Programmiersprache.
 
@@ -97,21 +105,31 @@ Wichtige Vorteile von funktionalen Programmiersprachen sind:
           sich sehr elegant formulieren.
 \end{itemize}
 
-\begin{definition}[Logisches Paradigma]\xindex{Programmierung!logische}
-    In der logischen Programmierung baut auf der Unifikation auf.\todo{genauer!}
+\begin{definition}[Logisches Paradigma]\xindex{Programmierung!logische}%
+    Das \textbf{logische Programmierparadigma} baut auf der formalen Logik auf. 
+    Man verwendet \textbf{Fakten} und \textbf{Regeln}
+    und einen Inferenzalgorithmus um Probleme zu lösen.
 \end{definition}
 
+Der Inferenzalgorithmus kann z.~B. die Unifikation nutzen.
+
+\begin{beispiel}[Logische Programmierung]
+    Obwohl die logische Programmierung für Zahlenfolgen weniger geeignet erscheint,
+    sei hier zur Vollständigkeit das letzte Fibonacci-Beispiel in Prolog:
+    \inputminted[numbersep=5pt, tabsize=4]{prolog}{scripts/prolog/fibonacci.pl}
+\end{beispiel}
+
 \section{Typisierung}
-Eine weitere Art, Programmiersprachen zu unterscheiden ist die stärke
+Eine weitere Art, Programmiersprachen zu unterscheiden ist die Stärke
 ihrer Typisierung.
 
-\begin{definition}[Dynamische Typisierung]\xindex{Typisierung!dynamische}
+\begin{definition}[Dynamische Typisierung]\xindex{Typisierung!dynamische}%
     Bei dynamisch typisierten Sprachen kann eine Variable ihren Typ ändern.
 \end{definition}
 
 Beispiele sind Python und PHP.
 
-\begin{definition}[Statische Typisierung]\xindex{Typisierung!statische}
+\begin{definition}[Statische Typisierung]\xindex{Typisierung!statische}%
     Bei statisch typisierten Sprachen kann eine niemals ihren Typ ändern.
 \end{definition}
 
@@ -125,10 +143,11 @@ C und Java werden kompiliert, Python und TCL interpretiert.
 
 \section{Dies und das}
 \begin{definition}[Seiteneffekt]\xindex{Seiteneffekt}\index{Nebeneffekt|see{Seiteneffekt}}\index{Wirkung|see{Seiteneffekt}}%
-    Seiteneffekte sind Veränderungen des Zustandes.\todo{Das geht besser}
+    Seiteneffekte sind Veränderungen des Zustandes eines Programms.
 \end{definition}
 
 Manchmal werden Seiteneffekte auch als Nebeneffekt oder Wirkung bezeichnet.
+Meistens meint man insbesondere unerwünschte oder überaschende Zustandsänderungen.
 
 \begin{definition}[Unifikation]\xindex{Unifikation}%
     Die Unifikation ist eine Operation in der Logik und dient zur Vereinfachung

documents/Programmierparadigmen/Scala.tex

@@ -82,8 +82,13 @@ Ein Companion Object ist ein Objekt mit dem Namen einer Klasse oder eines Traits
 Im Gegensatz zu anderen Objekten / Traits hat das Companion Object zugriff auf
 die Klasse.
 
-\section{actor}\xindex{actor}
-actor dient der Concurrency.
+\section{actor}
+\begin{definition}[Aktor]\xindex{Aktor}\index{actor|see{Aktor}}
+    Ein \textit{Aktor} ist ein Prozess, der Nebenläufig zu anderen Aktoren
+    läuft. Er kommuniziert mit anderen Aktoren, indem er Nachrichten austauscht.
+\end{definition}
+
+Das folgende Wetter-Beispiel zeigt, wie man Aktoren benutzen kann.
 
 \section{Beispiele}
 \subsection{Wetter}

documents/Programmierparadigmen/Vorwort.tex

@@ -21,7 +21,7 @@ fraglich, ob ich bis zur Klausur alles in guter Qualität bereitstellen
 kann. Daher freue ich mich über jeden Verbesserungsvorschlag.
 
 Anregungen, Verbesserungsvorschläge und Ergänzungen können per
-Pull-Request gemacht werden oder mir per Email an info@martin-thoma.de
+Pull-Request gemacht werden oder mir per E-Mail an info@martin-thoma.de
 geschickt werden.
 
 \section*{Erforderliche Vorkenntnisse}
@@ -32,3 +32,6 @@ das $\mathcal{O}$-Kalkül aus \enquote{Grundbegriffe der Informatik} hilfreich s
 
 Die Unifikation wird wohl auch in \enquote{Formale Systeme}
 erklärt; das könnte also hier von Vorteil sein.
+
+Die Grundlagen des Kapitels \enquote{Parallelität} wurden in Softwaretechnik I
+(kurz: SWT I) gelegt.

documents/Programmierparadigmen/scripts/c/fibonacci-imperativ.c

@@ -0,0 +1,14 @@
+int fib(int n) {
+    if (n < 0) {
+        return -1;
+    }
+
+    int fib[2] = {0, 1}, tmp;
+
+    for (; n > 0; n--) {
+        tmp    = fib[1];
+        fib[1] = fib[0] + fib[1];
+        fib[0] = tmp;
+    }
+    return fib[0];
+}

documents/Programmierparadigmen/scripts/haskell/fibonacci-akk.hs

@@ -1,5 +1,5 @@
 fibAkk n n1 n2
-    | (n == 0) = n1
-    | (n == 1) = n2
+    | (n == 0)  = n1
+    | (n == 1)  = n2
     | otherwise = fibAkk (n - 1) n2 (n1 + n2)
 fib n = fibAkk n 0 1

documents/Programmierparadigmen/scripts/prolog/fibonacci.pl

@@ -0,0 +1,5 @@
+fib(0, A, _, A).
+fib(N, A, B, F) :- N1 is N - 1, 
+                   Sum is A + B, 
+                   fib(N1, B, Sum, F).
+fib(N, F) :- fib(N, 0, 1, F).