Added definitions / examples

documents/Programmierparadigmen/Abkuerzungen.tex

@@ -11,6 +11,7 @@
     \acro{DEA}{Deterministischer Endlicher Automat}
     \acro{etc.}{et cetera}
     \acro{ggf.}{gegebenenfalls}
+    \acro{mgu}{most general unifier}
     \acro{sog.}{sogenannte}
     \acro{Vor.}{Voraussetzung}
     \acro{vgl.}{vergleiche}

documents/Programmierparadigmen/Haskell.tex

@@ -213,6 +213,11 @@ sich das ganze sogar noch kürzer schreiben:
 \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=folds.hs]{haskell}{scripts/haskell/folds.hs}
 
 
+\subsection{Standard Prelude}
+Hier sind die Definitionen eininger wichtiger Funktionen:
+
+\inputminted[numbersep=5pt, tabsize=4]{haskell}{scripts/haskell/standard-definitions.hs}
+
 \section{Weitere Informationen}
 \begin{itemize}
     \item \href{http://hackage.haskell.org/package/base-4.6.0.1}{\path{hackage.haskell.org/package/base-4.6.0.1}}: Referenz

documents/Programmierparadigmen/Programmiersprachen.tex

@@ -32,12 +32,36 @@ Wie nah ist sie an einer mathematisch / algorithmischen Beschreibung?
     \end{bspenum}
 \end{beispiel}
 
-\begin{definition}\xindex{Assembler}%
-    \textbf{Assembler} TODO
+\begin{definition}[Assembler]\xindex{Assembler}%
+    Eine Assemblersprache ist eine Programmiersprache, deren Befehle dem
+    Befehlssatz eines Prozessor entspricht.
 \end{definition}
 
 \begin{beispiel}[Assembler]%
-    TODO
+    Folgendes Beispiel stammt von \url{https://de.wikibooks.org/wiki/Assembler-Programmierung_für_x86-Prozessoren/_Das_erste_Assemblerprogramm}:
+    \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=firstp.asm]{nasm}{scripts/assembler/firstp.asm}
+\end{beispiel}
+
+\begin{definition}[Höhere Programmiersprache]\xindex{Programmiersprache!höhere}%
+    Eine Programmiersprache heißt \textit{höher}, wenn sie nicht ausschließlich
+    für eine Prozessorarchitektur geschrieben wurde und turing-vollständig ist.
+\end{definition}
+
+\begin{beispiel}[Höhere Programmiersprachen]
+    Java, Python, Haskell, Ruby, TCL, \dots
+\end{beispiel}
+
+\begin{definition}[Domänenspezifische Sprache]\xindex{Sprache!domänenspezifische}%
+    Eine domänenspezifische Sprache (engl. domain-specific language; kurz DSL) 
+    ist eine formale Sprache, die für ein bestimmtes Problemfeld 
+    entworfen wurde.
+\end{definition}
+
+\begin{beispiel}[Domänenspezifische Sprache]
+    \begin{bspenum}
+        \item HTML
+        \item VHDL
+    \end{bspenum}
 \end{beispiel}
 
 \section{Paradigmen}

documents/Programmierparadigmen/Scala.tex

@@ -71,6 +71,10 @@ Klassen werden wie folgt erstellt:
 und so instanziiert:
 \inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/scala/simple-class-instanciation.scala}
 
+Listen können erstellt und durchgegangen werden:
+
+\inputminted[numbersep=5pt, tabsize=4]{scala}{scripts/scala/extended-for.scala}
+
 \section{Beispiele}
 
 \section{Weitere Informationen}

documents/Programmierparadigmen/scripts/assembler/firstp.asm

@@ -0,0 +1,8 @@
+ org 100h
+ start:
+   mov ax, 5522h
+   mov cx, 1234h
+   xchg cx,ax 
+   mov al, 0
+   mov ah,4Ch
+   int 21h

documents/Programmierparadigmen/scripts/haskell/standard-definitions.hs

@@ -0,0 +1,38 @@
+map :: (a -> b) -> [a] -> [b]
+map f []     = []
+map f (x:xs) = f x : map f xs
+----------
+
+zipWith          :: (a->b->c) -> [a]->[b]->[c]
+zipWith z (a:as) (b:bs)
+                 =  z a b : zipWith z as bs
+zipWith _ _ _    =  []
+----------
+
+zip              :: [a] -> [b] -> [(a,b)]
+zip              =  zipWith (,)
+----------
+
+unzip            :: [(a,b)] -> ([a],[b])
+unzip            =  foldr (\(a,b) ~(as,bs) -> (a:as,b:bs)) ([],[])
+----------
+
+foldl            :: (a -> b -> a) -> a -> [b] -> a
+foldl f z []     =  z
+foldl f z (x:xs) =  foldl f (f z x) xs
+----------
+
+foldr            :: (a -> b -> b) -> b -> [a] -> b
+foldr f z []     =  z
+foldr f z (x:xs) =  f x (foldr f z xs)
+----------
+
+take                   :: Int -> [a] -> [a]
+take n _      | n <= 0 =  []
+take _ []              =  []
+take n (x:xs)          =  x : take (n-1) xs
+----------
+
+splitAt                  :: Int -> [a] -> ([a],[a])
+splitAt n xs             =  (take n xs, drop n xs)
+----------

documents/Programmierparadigmen/scripts/scala/extended-for.scala

@@ -0,0 +1,3 @@
+val list = List("USA", "Russia", "Germany")
+for(country <- list)
+    println(country)