Resolve conflicts from merge

5 files changed, 418 insertions, 366 deletions

diff --git a/de-de/go-de.html.markdown b/de-de/go-de.html.markdown
index 7e61bf81..94f48e65 100644
--- a/de-de/go-de.html.markdown
+++ b/de-de/go-de.html.markdown
@@ -4,17 +4,16 @@ filename: learngo-de.go
 contributors:
     - ["Joseph Adams", "https://github.com/jcla1"]
     - ["Dennis Keller", "https://github.com/denniskeller"]
+    - ["Jerome Meinke", "https://github.com/jmeinke"]
 lang: de-de
 ---
-Go wurde entwickelt, um Probleme zu lösen. Sie ist zwar nicht der neueste Trend in
-der Informatik, aber sie ist einer der neuesten und schnellsten Wege, um Aufgabe in
-der realen Welt zu lösen.
-
-Sie hat vertraute Elemente von imperativen Sprachen mit statischer Typisierung
-und kann schnell kompiliert und ausgeführt werden. Verbunden mit leicht zu
-verstehenden Parallelitäts-Konstrukten, um die heute üblichen mehrkern
-Prozessoren optimal nutzen zu können, eignet sich Go äußerst gut für große
-Programmierprojekte.
+Die Sprache Go (auch golang) wurde von Google entwickelt und wird seit 2007
+benutzt. Go ähnelt in der Syntax der Sprache C, bietet darüber hinaus aber viele
+Vorteile. Einerseits verzichtet Gp auf Speicherarithmetik und
+benutzt einen Garbabe Collector. Andererseits enthält Go native Sprachelemente
+für die Unterstützung von Nebenläufigkeit. Durch den Fokus auf einen schnellen
+Kompilierprozess wird außerdem die Softwareentwicklung in Großprojekten
+erleichtert.
 
 Außerdem beinhaltet Go eine gut ausgestattete Standardbibliothek und hat eine
 aktive Community.
@@ -24,8 +23,8 @@ aktive Community.
 /* Mehr-
    zeiliger Kommentar */
 
-// Eine jede Quelldatei beginnt mit einer Paket-Klausel.
-// "main" ist ein besonderer Pkaetname, da er ein ausführbares Programm
+// Wie bei Java gehört jede Quelldatei einem Paket an (Modularisierung).
+// "main" ist ein besonderer Paketname, da er ein ausführbares Programm
 // einleitet, im Gegensatz zu jedem anderen Namen, der eine Bibliothek
 // deklariert.
 package main
@@ -38,9 +37,9 @@ import (
     "strconv"  // Zeichenkettenmanipulation
 )
 
-// Es folgt die Definition einer Funktions, in diesem Fall von "main". Auch hier
+// Es folgt die Definition einer Funktion, in diesem Fall von "main". Auch hier
 // ist der Name wieder besonders. "main" markiert den Eintrittspunkt des
-// Programms. Vergessen Sie nicht die geschweiften Klammern!
+// Programms.
 func main() {
     // Println gibt eine Zeile zu stdout aus.
     // Der Prefix "fmt" bestimmt das Paket aus welchem die Funktion stammt.
@@ -50,13 +49,13 @@ func main() {
     beyondHello()
 }
 
-// Funktionen können Parameter akzeptieren, diese werden in Klammern deklariert,
-// die aber auch bei keinen Parametern erforderlich sind.
+// Funktionen können Parameter akzeptieren. Diese werden in Klammern deklariert,
+// die aber auch ohne Parameter erforderlich sind.
 func beyondHello() {
     var x int // Deklaration einer Variable, muss vor Gebrauch geschehen.
     x = 3     // Zuweisung eines Werts.
     // Kurze Deklaration: Benutzen Sie ":=", um die Typisierung automatisch zu
-    // folgern, die Variable zu deklarieren und ihr einen Wert zu zuweisen.
+    // folgern, die Variable zu deklarieren und ihr einen Wert zuzuweisen.
     y := 4
 
     // Eine Funktion mit mehreren Rückgabewerten.
@@ -99,7 +98,7 @@ Zeilenumbrüche beinhalten.` // Selber Zeichenketten-Typ
     // "slices" haben eine dynamische Größe. Arrays und Slices haben beide ihre
     // Vorzüge, aber slices werden viel häufiger verwendet
     s3 := []int{4, 5, 9}       // Vergleichen Sie mit a3, hier: keine Ellipse
-    s4 := make([]int, 4)       // Weist Speicher für 4 ints zu, alle mit Initialwert 0
+    s4 := make([]int, 4)       // Weist Speicher für 4 ints zu, alle mit Wert 0
     var d2 [][]float64         // Nur eine Deklaration, keine Speicherzuweisung
     bs := []byte("eine slice") // Umwandlungs-Syntax
 
@@ -147,7 +146,7 @@ func learnFlowControl() {
     if false {
         // nicht hier
     } else {
-        // sonder hier! spielt die Musik
+        // sondern hier! spielt die Musik
     }
 
     // Benutzen Sie ein "switch" Statement anstatt eine Anreihung von if-s
@@ -166,7 +165,7 @@ func learnFlowControl() {
     // Ab hier gilt wieder: x == 1
 
     // For ist die einzige Schleifenform in Go, sie hat aber mehrere Formen:
-    for { // Endloschleife
+    for { // Endlosschleife
         break    // nur ein Spaß
         continue // wird nie ausgeführt
     }
@@ -201,7 +200,8 @@ type pair struct {
     x, y int
 }
 
-// Definiere eine Methode von "pair". Dieser Typ erfüllt jetzt das Stringer interface.
+// Definiere eine Methode von "pair".
+// Dieser Typ erfüllt jetzt das Stringer interface.
 func (p pair) String() string { // p ist der Empfänger
     // Sprintf ist eine weitere öffentliche Funktion von fmt.
     // Der Syntax mit Punkt greift auf die Felder zu.
@@ -255,18 +255,19 @@ func learnConcurrency() {
     // Die selbe "make"-Funktion wie vorhin. Sie initialisiert Speicher für
     // maps, slices und Kanäle.
     c := make(chan int)
-    // Starte drei parallele "Goroutines". Die Zahlen werden parallel (concurrently)
-    // erhöht. Alle drei senden ihr Ergebnis in den gleichen Kanal.
+    // Starte drei parallele "Goroutines".
+    // Die Zahlen werden parallel (concurrently) erhöht.
+    // Alle drei senden ihr Ergebnis in den gleichen Kanal.
     go inc(0, c) // "go" ist das Statement zum Start einer neuen Goroutine
     go inc(10, c)
     go inc(-805, c)
     // Auslesen und dann Ausgeben der drei berechneten Werte.
     // Man kann nicht im voraus feststellen in welcher Reihenfolge die Werte
     // ankommen.
-    fmt.Println(<-c, <-c, <-c) // mit dem Kannal rechts ist <- der Empfangs-Operator
+    fmt.Println(<-c, <-c, <-c) // mit dem Kanal rechts ist <- der Empfangs-Operator
 
-    cs := make(chan string)       // ein weiterer Kannal, diesmal für strings
-    cc := make(chan chan string)  // ein Kannal für string Kannäle
+    cs := make(chan string)       // ein weiterer Kanal, diesmal für strings
+    cc := make(chan chan string)  // ein Kanal für string Kanäle
 
     // Start einer neuen Goroutine, nur um einen Wert zu senden
     go func() { c <- 84 }()
@@ -283,7 +284,7 @@ func learnConcurrency() {
         fmt.Println("wird nicht passieren.")
     }
     // Hier wird eine der beiden Goroutines fertig sein, die andere nicht.
-    // Sie wird warten bis der Wert den sie sendet von dem Kannal gelesen wird.
+    // Sie wird warten bis der Wert den sie sendet von dem Kanal gelesen wird.
 
     learnWebProgramming() // Go kann es und Sie hoffentlich auch bald.
 }
@@ -301,19 +302,18 @@ func learnWebProgramming() {
 // Methode implementieren: ServeHTTP
 func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
     // Senden von Daten mit einer Methode des http.ResponseWriter
-    w.Write([]byte("Sie habe Go in Y Minuten gelernt!"))
+    w.Write([]byte("Sie haben Go in Y Minuten gelernt!"))
 }
 ```
 
 ## Weitere Resourcen
-Alles zu Go finden Sie auf der [offiziellen Go Webseite](http://golang.org/).
-Dort können sie dem Tutorial folgen, interaktiv Quelltext ausprobieren und viel
-Dokumentation lesen.
+Informationen zu Go findet man auf der [offiziellen Go Webseite](http://golang.org/).
+Dort gibt es unter anderem ein Tutorial und interaktive Quelltext-Beispiele, vor
+allem aber Dokumentation zur Sprache und den Paketen.
 
 Auch zu empfehlen ist die Spezifikation von Go, die nach heutigen Standards sehr
-kurz und auch gut verständlich formuliert ist. Auf der Leseliste von Go-Neulingen
-ist außerdem der Quelltext der [Go standard Bibliothek](http://golang.org/src/pkg/).
-Gut dokumentiert, demonstriert sie leicht zu verstehendes und im idiomatischen Stil
-verfasstes Go. Erreichbar ist der Quelltext auch durch das Klicken der Funktionsnamen
+kurz und gut verständlich formuliert ist. Auf der Leseliste von Go-Neulingen
+ist außerdem der Quelltext der [Go standard Bibliothek](http://golang.org/src/pkg/)
+einzusehen. Dieser kann als Referenz für leicht zu verstehendes und im idiomatischen Stil
+verfasstes Go dienen. Erreichbar ist der Quelltext auch durch das Klicken der Funktionsnamen
 in der [offiziellen Dokumentation von Go](http://golang.org/pkg/).
-
diff --git a/de-de/haskell-de.html.markdown b/de-de/haskell-de.html.markdown
index 2c548961..d1a0008e 100644
--- a/de-de/haskell-de.html.markdown
+++ b/de-de/haskell-de.html.markdown
@@ -5,6 +5,7 @@ contributors:
     - ["Adit Bhargava", "http://adit.io"]
 translators:
     - ["Henrik Jürges", "https://github.com/santifa"]
+    - ["Nikolai Weh", "http://weh.hamburg"]
 filename: haskell-de.hs
 
 ---
@@ -58,12 +59,13 @@ not False -- True
 -- Strings und Zeichen
 "Das ist ein String."
 'a' -- Zeichen
-'Einfache Anfuehrungszeichen gehen nicht.' -- error!
+'Einfache Anführungszeichen gehen nicht.' -- error!
 
 -- Strings können konkateniert werden.
 "Hello " ++ "world!" -- "Hello world!"
 
 -- Ein String ist eine Liste von Zeichen.
+['H', 'a', 'l', 'l', 'o', '!'] -- "Hallo!"
 "Das ist eine String" !! 0 -- 'D'
 
 
@@ -76,11 +78,23 @@ not False -- True
 [1, 2, 3, 4, 5]
 [1..5]
 
--- Haskell unterstuetzt unendliche Listen!
-[1..] -- Die Liste aller natuerlichen Zahlen
+-- Die zweite Variante nennt sich die "range"-Syntax.
+-- Ranges sind recht flexibel:
+['A'..'F'] -- "ABCDEF"
+
+-- Es ist möglich eine Schrittweite anzugeben:
+[0,2..10] -- [0,2,4,6,8,10]
+[5..1] -- [], da Haskell standardmässig inkrementiert.
+[5,4..1] -- [5,4,3,2,1]
+
+-- Der "!!"-Operator extrahiert das Element an einem bestimmten Index:
+[1..10] !! 3 -- 4
+
+-- Haskell unterstützt unendliche Listen!
+[1..] -- Die Liste aller natürlichen Zahlen
 
 -- Unendliche Listen funktionieren in Haskell, da es "lazy evaluation"
--- unterstuetzt. Haskell evaluiert erst etwas, wenn es benötigt wird.
+-- unterstützt. Haskell evaluiert erst etwas, wenn es benötigt wird.
 -- Somit kannst du nach dem 1000. Element fragen und Haskell gibt es dir:
 
 [1..] !! 999 -- 1000
@@ -92,12 +106,9 @@ not False -- True
 -- Zwei Listen konkatenieren
 [1..5] ++ [6..10]
 
--- Ein Element als Head hinzufuegen
+-- Ein Element als Head hinzufügen
 0:[1..5] -- [0, 1, 2, 3, 4, 5]
 
--- Gibt den 5. Index zurueck
-[0..] !! 5 -- 5
-
 -- Weitere Listenoperationen
 head [1..5] -- 1
 tail [1..5] -- [2, 3, 4, 5]
@@ -114,7 +125,8 @@ last [1..5] -- 5
 -- Ein Tupel:
 ("haskell", 1)
 
--- Auf Elemente eines Tupels zugreifen:
+-- Ein Paar (Pair) ist ein Tupel mit 2 Elementen, auf die man wie folgt
+-- zugreifen kann:
 fst ("haskell", 1) -- "haskell"
 snd ("haskell", 1) -- 1
 
@@ -140,9 +152,9 @@ add 1 2 -- 3
 (//) a b = a `div` b
 35 // 4 -- 8
 
--- Guards sind eine einfache Möglichkeit fuer Fallunterscheidungen.
+-- Guards sind eine einfache Möglichkeit für Fallunterscheidungen.
 fib x
-  | x < 2 = x
+  | x < 2 = 1
   | otherwise = fib (x - 1) + fib (x - 2)
 
 -- Pattern Matching funktioniert ähnlich.
@@ -174,7 +186,7 @@ foldl1 (\acc x -> acc + x) [1..5] -- 15
 -- 4. Mehr Funktionen
 ----------------------------------------------------
 
--- currying: Wenn man nicht alle Argumente an eine Funktion uebergibt,
+-- currying: Wenn man nicht alle Argumente an eine Funktion übergibt,
 -- so wird sie eine neue Funktion gebildet ("curried").
 -- Es findet eine partielle Applikation statt und die neue Funktion
 -- nimmt die fehlenden Argumente auf.
@@ -190,23 +202,28 @@ foo 5 -- 15
 -- Funktionskomposition
 -- Die (.) Funktion verkettet Funktionen.
 -- Zum Beispiel, die Funktion Foo nimmt ein Argument addiert 10 dazu und
--- multipliziert dieses Ergebnis mit 5.
-foo = (*5) . (+10)
+-- multipliziert dieses Ergebnis mit 4.
+foo = (*4) . (+10)
+
+-- (5 + 10) * 4 = 60
+foo 5 -- 60
 
--- (5 + 10) * 5 = 75
-foo 5 -- 75
 
+-- Haskell hat einen Operator `$`, welcher Funktionsapplikation durchführt.
+-- Im Gegenzug zu der Standard-Funktionsapplikation, welche linksassoziativ ist
+-- und die höchstmögliche Priorität von "10" hat, ist der `$`-Operator
+-- rechtsassoziativ und hat die Priorität 0. Dieses hat (idr.) den Effekt,
+-- dass der `komplette` Ausdruck auf der rechten Seite als Parameter für die
+-- Funktion auf der linken Seite verwendet wird.
+-- Mit `.` und `$` kann man sich so viele Klammern ersparen.
 
--- Haskell hat eine Funktion `$`. Diese ändert den Vorrang,
--- so dass alles links von ihr zuerst berechnet wird und
--- und dann an die rechte Seite weitergegeben wird.
--- Mit `.` und `$` kann man sich viele Klammern ersparen.
+(even (fib 7)) -- false
 
--- Vorher
-(even (fib 7)) -- true
+-- Äquivalent:
+even $ fib 7 -- false
 
--- Danach
-even . fib $ 7 -- true
+-- Funktionskomposition:
+even . fib $ 7 -- false
 
 ----------------------------------------------------
 -- 5. Typensystem
@@ -221,31 +238,31 @@ even . fib $ 7 -- true
 True :: Bool
 
 -- Funktionen haben genauso Typen.
--- `not` ist Funktion die ein Bool annimmt und ein Bool zurueckgibt:
+-- `not` ist Funktion die ein Bool annimmt und ein Bool zurückgibt:
 -- not :: Bool -> Bool
 
 -- Eine Funktion die zwei Integer Argumente annimmt:
 -- add :: Integer -> Integer -> Integer
 
 -- Es ist guter Stil zu jeder Funktionsdefinition eine
--- Typdefinition darueber zu schreiben:
+-- Typdefinition darüber zu schreiben:
 double :: Integer -> Integer
 double x = x * 2
 
 ----------------------------------------------------
--- 6. If-Anweisung und Kontrollstrukturen
+-- 6. If-Ausdrücke und Kontrollstrukturen
 ----------------------------------------------------
 
--- If-Anweisung:
+-- If-Ausdruck:
 haskell = if 1 == 1 then "awesome" else "awful" -- haskell = "awesome"
 
--- If-Anweisungen können auch ueber mehrere Zeilen verteilt sein.
--- Das Einruecken ist dabei äußerst wichtig.
+-- If-Ausdrücke können auch über mehrere Zeilen verteilt sein.
+-- Die Einrückung ist dabei wichtig.
 haskell = if 1 == 1
             then "awesome"
             else "awful"
 
--- Case-Anweisung: Zum Beispiel "commandline" Argumente parsen.
+-- Case-Ausdruck: Am Beispiel vom Parsen von "commandline"-Argumenten.
 case args of
   "help" -> printHelp
   "start" -> startProgram
@@ -276,7 +293,7 @@ foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
 foldr (\x y -> 2*x + y) 4 [1,2,3] -- 16
 
 -- die Abarbeitung sieht so aus:
-(2 * 3 + (2 * 2 + (2 * 1 + 4)))
+(2 * 1 + (2 * 2 + (2 * 3 + 4)))
 
 ----------------------------------------------------
 -- 7. Datentypen
@@ -300,7 +317,7 @@ data Maybe a = Nothing | Just a
 -- Diese sind alle vom Typ Maybe:
 Just "hello"    -- vom Typ `Maybe String`
 Just 1          -- vom Typ `Maybe Int`
-Nothing         -- vom Typ `Maybe a` fuer jedes `a`
+Nothing         -- vom Typ `Maybe a` für jedes `a`
 
 ----------------------------------------------------
 -- 8. Haskell IO
@@ -309,8 +326,8 @@ Nothing         -- vom Typ `Maybe a` fuer jedes `a`
 -- IO kann nicht völlig erklärt werden ohne Monaden zu erklären,
 -- aber man kann die grundlegenden Dinge erklären.
 
--- Wenn eine Haskell Programm ausgefuehrt wird, so wird `main` aufgerufen.
--- Diese muss etwas vom Typ `IO ()` zurueckgeben. Zum Beispiel:
+-- Wenn eine Haskell Programm ausgeführt wird, so wird `main` aufgerufen.
+-- Diese muss etwas vom Typ `IO ()` zurückgeben. Zum Beispiel:
 
 main :: IO ()
 main = putStrLn $ "Hello, sky! " ++ (say Blue)
@@ -338,10 +355,10 @@ sayHello = do
                    -- an die Variable "name" gebunden
    putStrLn $ "Hello, " ++ name
 
--- Uebung: Schreibe deine eigene Version von `interact`,
+-- Übung: Schreibe deine eigene Version von `interact`,
 -- die nur eine Zeile einliest.
 
--- `sayHello` wird niemals ausgefuehrt, nur `main` wird ausgefuehrt.
+-- `sayHello` wird niemals ausgeführt, nur `main` wird ausgeführt.
 -- Um `sayHello` laufen zulassen kommentiere die Definition von `main`
 -- aus und ersetze sie mit:
 --     main = sayHello
@@ -359,7 +376,7 @@ action = do
    input1 <- getLine
    input2 <- getLine
    -- Der Typ von `do` ergibt sich aus der letzten Zeile.
-   -- `return` ist eine Funktion und keine Schluesselwort
+   -- `return` ist eine Funktion und keine Schlüsselwort
    return (input1 ++ "\n" ++ input2) -- return :: String -> IO String
 
 -- Nun können wir `action` wie `getLine` benutzen:
@@ -370,7 +387,7 @@ main'' = do
     putStrLn result
     putStrLn "This was all, folks!"
 
--- Der Typ `IO` ist ein Beispiel fuer eine Monade.
+-- Der Typ `IO` ist ein Beispiel für eine Monade.
 -- Haskell benutzt Monaden Seiteneffekte zu kapseln und somit
 -- eine rein funktional Sprache zu sein.
 -- Jede Funktion die mit der Außenwelt interagiert (z.B. IO)
@@ -387,7 +404,7 @@ main'' = do
 
 -- Starte die REPL mit dem Befehl `ghci`
 -- Nun kann man Haskell Code eingeben.
--- Alle neuen Werte muessen mit `let` gebunden werden:
+-- Alle neuen Werte müssen mit `let` gebunden werden:
 
 let foo = 5
 
@@ -396,7 +413,7 @@ let foo = 5
 >:t foo
 foo :: Integer
 
--- Auch jede `IO ()` Funktion kann ausgefuehrt werden.
+-- Auch jede `IO ()` Funktion kann ausgeführt werden.
 
 > sayHello
 What is your name?
@@ -420,6 +437,6 @@ qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
 Haskell ist sehr einfach zu installieren.
 Hohl es dir von [hier](http://www.haskell.org/platform/).
 
-Eine sehr viele langsamere Einfuehrung findest du unter:
+Eine sehr viele langsamere Einführung findest du unter:
 [Learn you a Haskell](http://learnyouahaskell.com/) oder
 [Real World Haskell](http://book.realworldhaskell.org/).
diff --git a/de-de/latex-de.html.markdown b/de-de/latex-de.html.markdown
index 2c18b8fd..ee9c6e3e 100644
--- a/de-de/latex-de.html.markdown
+++ b/de-de/latex-de.html.markdown
@@ -6,19 +6,19 @@ contributors:
     - ["Sricharan Chiruvolu", "http://sricharan.xyz"]
 translators:
   - ["Moritz Kammerer", "https://github.com/phxql"]
+  - ["Jerome Meinke", "https://github.com/jmeinke"]
 lang: de-de
 filename: latex-de.tex
 ---
 ```
-% Alle Kommentare starten fangen mit % an
-% Es gibt keine Kommentare über mehrere Zeilen
+% Alle Kommentare starten mit einem Prozentzeichen %
 
-% LateX ist keine "What You See Is What You Get" Textverarbeitungssoftware wie z.B.
+% LaTeX ist keine "What You See Is What You Get" Textverarbeitungssoftware wie z.B.
 % MS Word oder OpenOffice Writer
 
-% Jedes LateX-Kommando startet mit einem Backslash (\)
+% Jedes LaTeX-Kommando startet mit einem Backslash (\)
 
-% LateX-Dokumente starten immer mit der Definition des Dokuments, die sie darstellen
+% LaTeX-Dokumente starten immer mit der Definition des Dokuments, die sie darstellen
 % Weitere Dokumententypen sind z.B. book, report, presentations, etc.
 % Optionen des Dokuments stehen zwischen den eckigen Klammern []. In diesem Fall
 % wollen wir einen 12 Punkte-Font verwenden.
@@ -26,7 +26,7 @@ filename: latex-de.tex
 
 % Als nächstes definieren wir die Pakete, die wir verwenden wollen.
 % Wenn du z.B. Grafiken, farbigen Text oder Quelltext in dein Dokument einbetten möchtest,
-% musst du die Fähigkeiten von Latex durch Hinzufügen von Paketen erweitern.
+% musst du die Fähigkeiten von LaTeX durch Hinzufügen von Paketen erweitern.
 % Wir verwenden die Pakete float und caption für Bilder.
 \usepackage{caption}
 \usepackage{float}
@@ -34,30 +34,41 @@ filename: latex-de.tex
 % Mit diesem Paket können leichter Umlaute getippt werden
 \usepackage[utf8]{inputenc}
 
+% Es gibt eigentlich keine Kommentare über mehrere Zeilen, solche kann man
+% aber selbst durch die Angabe eigener Kommandos definieren.
+% Dieses Kommando kann man später benutzen.
+\newcommand{\comment}[1]{}
+
 % Es können durchaus noch weitere Optione für das Dokument gesetzt werden!
 \author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu}
 \date{\today}
-\title{Learn LaTeX in Y Minutes!}
+\title{Learn \LaTeX\ in Y Minutes!}
 
 % Nun kann's losgehen mit unserem Dokument.
 % Alles vor dieser Zeile wird die Preamble genannt.
-\begin{document} 
+\begin{document}
+
+\comment{
+  Dies ist unser selbst-definierter Befehl
+  für mehrzeilige Kommentare.
+}
+
 % Wenn wir den Autor, das Datum und den Titel gesetzt haben, kann
-% LateX für uns eine Titelseite generieren
+% LaTeX für uns eine Titelseite generieren
 \maketitle
 
-% Die meisten Paper haben ein Abstract. LateX bietet dafür einen vorgefertigen Befehl an.
+% Die meisten Paper haben ein Abstract. LaTeX bietet dafür einen vorgefertigen Befehl an.
 % Das Abstract sollte in der logischen Reihenfolge, also nach dem Titel, aber vor dem
 % Inhalt erscheinen.
 % Dieser Befehl ist in den Dokumentenklassen article und report verfügbar.
 \begin{abstract}
- LateX documentation geschrieben in LateX! Wie ungewöhnlich und garantiert nicht meine Idee!
+ \LaTeX -Documentation geschrieben in \LaTeX ! Wie ungewöhnlich und garantiert nicht meine Idee!
 \end{abstract}
 
 % Section Befehle sind intuitiv.
 % Alle Titel der sections werden automatisch in das Inhaltsverzeichnis übernommen.
 \section{Einleitung}
-Hi, mein Name ist Moritz und zusammen werden wir LateX erforschen!
+Hi, mein Name ist Moritz und zusammen werden wir \LaTeX\ erforschen!
 
 \section{Noch eine section}
 Das hier ist der Text für noch eine section. Ich glaube, wir brauchen eine subsection.
@@ -71,16 +82,16 @@ So ist's schon viel besser.
 
 % Wenn wir den Stern nach section schreiben, dann unterdrückt LateX die Nummerierung.
 % Das funktioniert auch bei anderen Befehlen.
-\section*{Das ist eine unnummerierte section} 
-Es müssen nicht alle sections nummeriert sein!
+\section*{Das ist eine unnummerierte section}
+Es müssen nicht alle Sections nummeriert sein!
 
 \section{Ein paar Notizen}
-LateX ist ziemlich gut darin, Text so zu platzieren, dass es gut aussieht.
+\LaTeX\ ist ziemlich gut darin, Text so zu platzieren, dass es gut aussieht.
 Falls eine Zeile \\ mal \\ woanders \\ umgebrochen \\ werden \\ soll, füge
 \textbackslash\textbackslash in den Code ein.\\
 
 \section{Listen}
-Listen sind eine der einfachsten Dinge in LateX. Ich muss morgen einkaufen gehen,
+Listen sind eine der einfachsten Dinge in \LaTeX. Ich muss morgen einkaufen gehen,
 also lass uns eine Einkaufsliste schreiben:
 \begin{enumerate} % Dieser Befehl erstellt eine "enumerate" Umgebung.
   % \item bringt enumerate dazu, eins weiterzuzählen.
@@ -96,7 +107,7 @@ also lass uns eine Einkaufsliste schreiben:
 
 \section{Mathe}
 
-Einer der Haupteinsatzzwecke von LateX ist das Schreiben von akademischen
+Einer der Haupteinsatzzwecke von \LaTeX\ ist das Schreiben von akademischen
 Artikeln oder Papern. Meistens stammen diese aus dem Bereich der Mathe oder
 anderen Wissenschaften. Und deswegen müssen wir in der Lage sein, spezielle
 Symbole zu unserem Paper hinzuzufügen! \\
@@ -106,18 +117,18 @@ Symbole für Mengen und relationen, Pfeile, Operatoren und Griechische Buchstabe
 um nur ein paar zu nennen.\\
 
 Mengen und Relationen spielen eine sehr wichtige Rolle in vielen mathematischen
-Papern. So schreibt man in LateX, dass alle y zu X gehören: $\forall$ y $\in$ X. \\
+Papern. So schreibt man in \LaTeX, dass alle y zu X gehören: $\forall$ y $\in$ X. \\
 
-% Achte auf die $ Zeichen vor und nach den Symbolen. Wenn wir in LateX schreiben,
+% Achte auf die $ Zeichen vor und nach den Symbolen. Wenn wir in LaTeX schreiben,
 % geschieht dies standardmäßig im Textmodus. Die Mathe-Symbole existieren allerdings
 % nur im Mathe-Modus. Wir können den Mathe-Modus durch das $ Zeichen aktivieren und
 % ihn mit $ wieder verlassen. Variablen können auch im Mathe-Modus angezeigt werden.
 
 Mein Lieblingsbuchstabe im Griechischen ist $\xi$. Ich mag auch $\beta$, $\gamma$ und $\sigma$.
-Bis jetzt habe ich noch keinen griechischen Buchstaben gefunden, den LateX nicht kennt!
+Bis jetzt habe ich noch keinen griechischen Buchstaben gefunden, den \LaTeX nicht kennt!
 
 Operatoren sind ebenfalls wichtige Bestandteile von mathematischen Dokumenten:
-Trigonometrische Funktionen ($\sin$, $\cos$, $\tan$), 
+Trigonometrische Funktionen ($\sin$, $\cos$, $\tan$),
 Logarithmus und Exponenten ($\log$, $\exp$),
 Grenzwerte ($\lim$), etc. haben vordefinierte Befehle.
 Lass uns eine Gleichung schreiben: \\
@@ -127,7 +138,7 @@ $\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$\\
 Brüche (Zähler / Nenner) können so geschrieben werden:
 
 % 10 / 7
-$^{10}/_{7}$ 
+$^{10}/_{7}$
 
 % Komplexere Brüche können so geschrieben werden:
 % \frac{Zähler}{Nenner}
@@ -142,19 +153,19 @@ Wir können Gleichungen auch in einer equation Umgebung verwenden.
 \end{equation} % Alle \begin Befehle müssen einen \end Befehl besitzen
 
 Wir können nun unsere Gleichung referenzieren!
-Gleichung ~\ref{eq:pythagoras} ist auch als das Theorem des Pythagoras bekannt. Dieses wird in 
+Gleichung ~\ref{eq:pythagoras} ist auch als das Theorem des Pythagoras bekannt. Dieses wird in
 Abschnitt ~\ref{subsec:pythagoras} behandelt. Es können sehr viele Sachen mit Labels versehen werden:
 Grafiken, Gleichungen, Sections, etc.
 
 Summen und Integrale können mit den sum und int Befehlen dargestellt werden:
 
-% Manche LateX-Compiler beschweren sich, wenn Leerzeilen in Gleichungen auftauchen
-\begin{equation} 
+% Manche LaTeX-Compiler beschweren sich, wenn Leerzeilen in Gleichungen auftauchen
+\begin{equation}
   \sum_{i=0}^{5} f_{i}
-\end{equation} 
-\begin{equation} 
+\end{equation}
+\begin{equation}
   \int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x
-\end{equation} 
+\end{equation}
 
 \section{Grafiken}
 
@@ -164,7 +175,7 @@ Aber keine Sorge, ich muss auch jedes mal nachschauen, welche Option wie wirkt.
 \begin{figure}[H] % H ist die Platzierungsoption
     \centering % Zentriert die Grafik auf der Seite
     % Fügt eine Grafik ein, die auf 80% der Seitenbreite einnimmt.
-    %\includegraphics[width=0.8\linewidth]{right-triangle.png} 
+    %\includegraphics[width=0.8\linewidth]{right-triangle.png}
     % Auskommentiert, damit es nicht im Dokument auftaucht.
     \caption{Dreieck mit den Seiten $a$, $b$, $c$}
     \label{fig:right-triangle}
@@ -177,7 +188,7 @@ Wir können Tabellen genauso wie Grafiken einfügen.
   \caption{Überschrift der Tabelle.}
   % Die {} Argumente geben an, wie eine Zeile der Tabelle dargestellt werden soll.
   % Auch hier muss ich jedes Mal nachschauen. Jedes. einzelne. Mal.  
-  \begin{tabular}{c|cc} 
+  \begin{tabular}{c|cc}
     Nummer &  Nachname & Vorname \\ % Spalten werden durch & getrennt
     \hline % Eine horizontale Linie
     1 & Biggus & Dickus \\
@@ -187,36 +198,36 @@ Wir können Tabellen genauso wie Grafiken einfügen.
 
 % \section{Links} % Kommen bald!
 
-\section{Verhindern, dass LateX etwas kompiliert (z.B. Quelltext)}
-Angenommen, wir wollen Quelltext in unserem LateX-Dokument. LateX soll 
-in diesem Fall nicht den Quelltext als LateX-Kommandos interpretieren, 
+\section{Verhindern, dass \LaTeX\ etwas kompiliert (z.B. Quelltext)}
+Angenommen, wir wollen Quelltext in unserem \LaTeX-Dokument. \LaTeX\ soll
+in diesem Fall nicht den Quelltext als \LaTeX-Kommandos interpretieren,
 sondern es einfach ins Dokument schreiben. Um das hinzubekommen, verwenden
 wir eine verbatim Umgebung.
 
 % Es gibt noch weitere Pakete für Quelltexte (z.B. minty, lstlisting, etc.)
 % aber verbatim ist das simpelste.
-\begin{verbatim} 
+\begin{verbatim}
   print("Hello World!")
   a%b; % Schau dir das an! Wir können % im verbatim verwenden!
   random = 4; #decided by fair random dice roll
 \end{verbatim}
 
-\section{Kompilieren} 
+\section{Kompilieren}
 
 Ich vermute, du wunderst dich, wie du dieses tolle Dokument in ein PDF
 verwandeln kannst. (Ja, dieses Dokument kompiliert wirklich!) \\
 
 Dafür musst du folgende Schritte durchführen:
   \begin{enumerate}
-    \item Schreibe das Dokument. (den LateX-Quelltext).
-    \item Kompiliere den Quelltext in ein PDF. 
+    \item Schreibe das Dokument. (den \LaTeX -Quelltext).
+    \item Kompiliere den Quelltext in ein PDF.
      Das Kompilieren sieht so ähnlich wie das hier aus (Linux): \\
-     \begin{verbatim} 
-        $pdflatex learn-latex.tex learn-latex.pdf 
+     \begin{verbatim}
+        $pdflatex learn-latex.tex learn-latex.pdf
      \end{verbatim}
   \end{enumerate}
 
-Manche LateX-Editoren kombinieren Schritt 1 und 2. Du siehst also nur Schritt 1 und Schritt
+Manche \LaTeX-Editoren kombinieren Schritt 1 und 2. Du siehst also nur Schritt 1 und Schritt
 2 wird unsichtbar im Hintergrund ausgeführt.
 
 Alle Formatierungsoptionen werden in Schritt 1 in den Quelltext geschrieben. Schritt 2 verwendet
diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown
index 7fd299b4..456403a2 100644
--- a/de-de/scala-de.html.markdown
+++ b/de-de/scala-de.html.markdown
@@ -5,6 +5,7 @@ contributors:
     - ["Dominic Bou-Samra", "http://dbousamra.github.com"]
     - ["Geoff Liu", "http://geoffliu.me"]
     - ["Ha-Duong Nguyen", "http://reference-error.org"]
+    - ["Dennis Keller", "github.com/denniskeller"]
 translators:
   - ["Christian Albrecht", "https://github.com/coastalchief"]
 filename: learnscala-de.scala
@@ -16,167 +17,172 @@ für die Java Virtual Machine (JVM), um allgemeine Programmieraufgaben
 zu erledigen. Scala hat einen akademischen Hintergrund und wurde an  
 der EPFL (Lausanne / Schweiz) unter der Leitung von Martin Odersky entwickelt.
 
-
-# 0. Umgebung einrichten
+```scala 
+/*
 Scala Umgebung einrichten:
 
 1. Scala binaries herunterladen- http://www.scala-lang.org/downloads
 2. Unzip/untar in ein Verzeichnis
 3. das bin Unterverzeichnis der `PATH` Umgebungsvariable hinzufügen
 4. Mit dem Kommando `scala` wird die REPL gestartet und zeigt als Prompt:
-```
+
 scala>
-```
 
 Die REPL (Read-Eval-Print Loop) ist der interaktive Scala Interpreter.  
 Hier kann man jeden Scala Ausdruck verwenden und das Ergebnis wird direkt  
 ausgegeben.  
 Als nächstes beschäftigen wir uns mit ein paar Scala Basics.
+*/
 
-# 1. Basics
 
-Einzeilige Kommentare beginnen mit zwei vorwärts Slash
+/////////////////////////////////////////////////
+// 1. Basics
+/////////////////////////////////////////////////
+
+// Einzeilige Kommentare beginnen mit zwei Slashes
 
 /*
-  Mehrzeilige Kommentare, werden starten 
-  mit Slash-Stern und enden mit Stern-Slash
+  Mehrzeilige Kommentare, starten 
+  mit einem Slash-Stern und enden mit einem Stern-Slash
 */
 
 // Einen Wert, und eine zusätzliche neue Zeile ausgeben  
-```
+
 println("Hello world!")
 println(10)
-```
+
 
 // Einen Wert, ohne eine zusätzliche neue Zeile ausgeben  
-```
+
 print("Hello world")
-```
 
-// Variablen werden entweder mit var oder val deklariert.  
-// Deklarationen mit val sind immutable, also unveränderlich  
-// Deklarationen mit var sind mutable, also veränderlich  
-// Immutability ist gut.  
-```
+/*
+  Variablen werden entweder mit var oder val deklariert.  
+  Deklarationen mit val sind immutable, also unveränderlich  
+  Deklarationen mit var sind mutable, also veränderlich  
+  Immutability ist gut.  
+*/
 val x = 10 // x ist 10
 x = 20     // error: reassignment to val
 var y = 10
 y = 20     // y ist jetzt 20
-```
 
-Scala ist eine statisch getypte Sprache, auch wenn in dem o.g. Beispiel  
+/*
+Scala ist eine statisch getypte Sprache, auch wenn wir in dem o.g. Beispiel  
 keine Typen an x und y geschrieben haben.  
-In Scala ist etwas eingebaut, was sich Type Inference nennt. D.h. das der  
-Scala Compiler in den meisten Fällen erraten kann, von welchen Typ eine ist,  
-so dass der Typ nicht jedes mal angegeben werden soll.  
+In Scala ist etwas eingebaut, was sich Type Inference nennt. Das heißt das der  
+Scala Compiler in den meisten Fällen erraten kann, von welchen Typ eine Variable ist,  
+so dass der Typ nicht jedes mal angegeben werden muss.  
 Einen Typ gibt man bei einer Variablendeklaration wie folgt an:  
-```
+*/
 val z: Int = 10
 val a: Double = 1.0
-```
+
 
 // Bei automatischer Umwandlung von Int auf Double wird aus 10 eine 10.0  
-```
+
 val b: Double = 10
-```
+
 
 // Boolean Werte  
-```
+
 true
 false
-```
+
 
 // Boolean Operationen  
-```
+
 !true         // false
 !false        // true
 true == false // false
 10 > 5        // true
-```
+
 
 // Mathematische Operationen sind wie gewohnt  
-```
+
 1 + 1   // 2
 2 - 1   // 1
 5 * 3   // 15
 6 / 2   // 3
 6 / 4   // 1
 6.0 / 4 // 1.5
-```
+
 
 // Die Auswertung eines Ausdrucks in der REPL gibt den Typ  
 // und das Ergebnis zurück.  
-```
+
   scala> 1 + 7
   res29: Int = 8
-```
 
+/*
 Das bedeutet, dass das Resultat der Auswertung von 1 + 7 ein Objekt  
 von Typ Int ist und einen Wert 0 hat.  
 "res29" ist ein sequentiell generierter name, um das Ergebnis des  
 Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein...  
-
+*/
 
 "Scala strings werden in doppelten Anführungszeichen eingeschlossen"  
 'a' // A Scala Char  
 // 'Einzeln ge-quotete strings gibt es nicht!' <= This causes an error  
   
 // Für Strings gibt es die üblichen Java Methoden  
-```
+
 "hello world".length
 "hello world".substring(2, 6)
 "hello world".replace("C", "3")
-```
+
 
 // Zusätzlich gibt es noch extra Scala Methoden  
 // siehe: scala.collection.immutable.StringOps  
-```
+
 "hello world".take(5)
 "hello world".drop(5)
-```
+
 
 // String interpolation: prefix "s"  
-```
+
 val n = 45
 s"We have $n apples" // => "We have 45 apples"
-```
 
-// Ausdrücke im innern von interpolierten Strings gibt es auch  
-```
+
+// Ausdrücke im Innern von interpolierten Strings gibt es auch  
+
 val a = Array(11, 9, 6)
 val n = 100
 s"My second daughter is ${a(0) - a(2)} years old."    // => "My second daughter is 5 years old."
 s"We have double the amount of ${n / 2.0} in apples." // => "We have double the amount of 22.5 in apples."
 s"Power of 2: ${math.pow(2, 2)}"                      // => "Power of 2: 4"
-```
+
 
 // Formatierung der interpolierten Strings mit dem prefix "f"  
-```
+
 f"Power of 5: ${math.pow(5, 2)}%1.0f"         // "Power of 5: 25"
 f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454"
-```
+
 
 // Raw Strings, ignorieren Sonderzeichen.  
-```
+
 raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r."
-```
+
 
 // Manche Zeichen müssen "escaped" werden, z.B.   
 // ein doppeltes Anführungszeichen in innern eines Strings.  
-```
+
 "They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown""
-```
+
 
 // Dreifache Anführungszeichen erlauben es, dass ein String über mehrere Zeilen geht  
 // und Anführungszeichen enthalten kann.  
-```
+
 val html = """<form id="daform">
                 <p>Press belo', Joe</p>
                 <input type="submit">
               </form>"""
-```
 
-# 2. Funktionen
+  
+/////////////////////////////////////////////////
+// 2. Funktionen
+/////////////////////////////////////////////////
 
 // Funktionen werden so definiert  
 //  
@@ -184,74 +190,74 @@ val html = """<form id="daform">
 //  
 // Beachte: Es gibt kein return Schlüsselwort. In Scala ist der letzte Ausdruck  
 // in einer Funktion der Rückgabewert.  
-```
+
 def sumOfSquares(x: Int, y: Int): Int = {
   val x2 = x * x
   val y2 = y * y
   x2 + y2
 }
-```
+
 
 // Die geschweiften Klammern können weggelassen werden, wenn  
 // die Funktion nur aus einem einzigen Ausdruck besteht:  
-```
+
 def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y
-```
+
 
 // Syntax für Funktionsaufrufe:  
-```
+
 sumOfSquares(3, 4)  // => 25
-```
+
 
 // In den meisten Fällen (mit Ausnahme von rekursiven Funktionen), können  
 // Rückgabetypen auch weggelassen werden, da dieselbe Typ Inference, wie bei  
 // Variablen, auch bei Funktionen greift:  
-```
+
 def sq(x: Int) = x * x  // Compiler errät, dass der return type Int ist
-```
+
 
 // Funktionen können default parameter haben:  
-```
+
 def addWithDefault(x: Int, y: Int = 5) = x + y
 addWithDefault(1, 2) // => 3
 addWithDefault(1)    // => 6
-```
+
 
 // Anonyme Funktionen sehen so aus:  
-```
+
 (x: Int) => x * x
-```
+
 
 // Im Gegensatz zu def bei normalen Funktionen, kann bei anonymen Funktionen   
 // sogar der Eingabetyp weggelassen werden, wenn der Kontext klar ist.  
 // Beachte den Typ "Int => Int", dies beschreibt eine Funktion,  
 // welche Int als Parameter erwartet und Int zurückgibt.  
-```
+
 val sq: Int => Int = x => x * x
-```
+
 
 // Anonyme Funktionen benutzt man ganz normal:  
-```
+
 sq(10)   // => 100
-```
+
 
 // Wenn ein Parameter einer anonymen Funktion nur einmal verwendet wird,  
 // bietet Scala einen sehr kurzen Weg diesen Parameter zu benutzen,  
 // indem die Parameter als Unterstrich "_" in der Parameterreihenfolge  
 // verwendet werden. Diese anonymen Funktionen werden sehr häufig   
 // verwendet.  
-```
+
 val addOne: Int => Int = _ + 1  
 val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3)  
 addOne(5)      // => 6  
 weirdSum(2, 4) // => 16  
-```
+
 
 // Es gibt einen keyword return in Scala. Allerdings ist seine Verwendung  
 // nicht immer ratsam und kann fehlerbehaftet sein. "return" gibt nur aus  
 // dem innersten def, welches den return Ausdruck umgibt, zurück.  
 // "return" hat keinen Effekt in anonymen Funktionen:  
-```
+
 def foo(x: Int): Int = {  
   val anonFunc: Int => Int = { z =>  
     if (z > 5)  
@@ -261,28 +267,30 @@ def foo(x: Int): Int = {
   }  
   anonFunc(x)  // Zeile ist der return Wert von foo  
 }  
-```
 
-# 3. Flow Control
 
-## Wertebereiche und Schleifen
-```
+/////////////////////////////////////////////////
+// 3. Flow Control
+/////////////////////////////////////////////////
+
+// Wertebereiche und Schleifen
+
 1 to 5
 val r = 1 to 5
 r.foreach(println)
 r foreach println
 (5 to 1 by -1) foreach (println)
-```  
-// Scala ist syntaktisch sehr grosszügig, Semikolons am Zeilenende  
+  
+// Scala ist syntaktisch sehr großzügig, Semikolons am Zeilenende  
 // sind optional, beim Aufruf von Methoden können die Punkte  
 // und Klammern entfallen und Operatoren sind im Grunde austauschbare Methoden  
 
 // while Schleife  
-```
+
 var i = 0
 while (i < 10) { println("i " + i); i += 1 }
 i    // i ausgeben, res3: Int = 10
-```
+
 
 // Beachte: while ist eine Schleife im klassischen Sinne -  
 // Sie läuft sequentiell ab und verändert die loop-Variable.  
@@ -291,28 +299,28 @@ i    // i ausgeben, res3: Int = 10
 // und zu parellelisieren.
 
 // Ein do while Schleife  
-```
+
 do {
   println("x ist immer noch weniger wie 10")
   x += 1
 } while (x < 10)
-```
+
 
 // Endrekursionen sind ideomatisch um sich wiederholende  
 // Dinge in Scala zu lösen. Rekursive Funtionen benötigen explizit einen  
 // return Typ, der Compiler kann ihn nicht erraten.  
 // Unit, in diesem Beispiel.  
-```
+
 def showNumbersInRange(a: Int, b: Int): Unit = {
   print(a)
   if (a < b)
     showNumbersInRange(a + 1, b)
 }
 showNumbersInRange(1, 14)
-```
 
-## Conditionals
-```
+
+// Conditionals
+
 val x = 10
 if (x == 1) println("yeah")
 if (x == 10) println("yeah")
@@ -320,186 +328,193 @@ if (x == 11) println("yeah")
 if (x == 11) println ("yeah") else println("nay")
 println(if (x == 10) "yeah" else "nope")
 val text = if (x == 10) "yeah" else "nope"
-```
 
-# 4. Daten Strukturen (Array, Map, Set, Tuples)
 
-## Array
-```
+/////////////////////////////////////////////////
+// 4. Daten Strukturen (Array, Map, Set, Tuples)
+/////////////////////////////////////////////////
+
+// Array
+
 val a = Array(1, 2, 3, 5, 8, 13)
 a(0)
 a(3)
 a(21)    // Exception
-```
 
-## Map - Speichert Key-Value-Paare
-```
+
+// Map - Speichert Key-Value-Paare
+
 val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo")
 m("fork")
 m("spoon")
 m("bottle")       // Exception
 val safeM = m.withDefaultValue("no lo se")
 safeM("bottle")
-```
-## Set - Speichert Unikate, unsortiert (sortiert -> SortedSet)
-```
+
+// Set - Speichert Unikate, unsortiert (sortiert -> SortedSet)
+
 val s = Set(1, 3, 7)
 s(0) //false
 s(1) //true
 val s = Set(1,1,3,3,7)
 s: scala.collection.immutable.Set[Int] = Set(1, 3, 7)
-```
-## Tuple - Speichert beliebige Daten und "verbindet" sie miteinander
+
+// Tuple - Speichert beliebige Daten und "verbindet" sie miteinander
 // Ein Tuple ist keine Collection.  
-```
+
 (1, 2)
 (4, 3, 2)
 (1, 2, "three")
 (a, 2, "three")
-```
+
 
 // Hier ist der Rückgabewert der Funktion ein Tuple  
 // Die Funktion gibt das Ergebnis, so wie den Rest zurück.  
-```
+
 val divideInts = (x: Int, y: Int) => (x / y, x % y)
 divideInts(10, 3)
-```
+
 
 // Um die Elemente eines Tuples anzusprechen, benutzt man diese  
 // Notation: _._n wobei n der index des Elements ist (Index startet bei 1)  
-```
+
 val d = divideInts(10, 3)
 d._1
 d._2
-```
-# 5. Objekt Orientierte Programmierung
 
-Bislang waren alle gezeigten Sprachelemente einfache Ausdrücke, welche zwar  
-zum Ausprobieren und Lernen in der REPL gut geeignet sind, jedoch in  
-einem Scala file selten alleine zu finden sind.  
-Die einzigen Top-Level Konstrukte in Scala sind nämlich:  
 
-- Klassen (classes)
-- Objekte (objects)
-- case classes
-- traits
+/////////////////////////////////////////////////
+// 5. Objektorientierte Programmierung
+/////////////////////////////////////////////////
+
+/*
+  Bislang waren alle gezeigten Sprachelemente einfache Ausdrücke, welche zwar  
+  zum Ausprobieren und Lernen in der REPL gut geeignet sind, jedoch in  
+  einem Scala file selten alleine zu finden sind.  
+  Die einzigen Top-Level Konstrukte in Scala sind nämlich:  
+
+  - Klassen (classes)
+  - Objekte (objects)
+  - case classes
+  - traits
 
-Diesen Sprachelemente wenden wir uns jetzt zu.  
+  Diesen Sprachelemente wenden wir uns jetzt zu.  
+*/
 
-## Klassen
+// Klassen
 
 // Zum Erstellen von Objekten benötigt man eine Klasse, wie in vielen  
 // anderen Sprachen auch. 
 
 // erzeugt Klasse mit default Konstruktor  
-```
+
 class Hund
 scala> val t = new Hund
 t: Hund = Hund@7103745
-```
+
 
 // Der Konstruktor wird direkt hinter dem Klassennamen deklariert.  
-```
+
 class Hund(sorte: String)
 scala> val t = new Hund("Dackel")
 t: Hund = Hund@14be750c
 scala> t.sorte //error: value sorte is not a member of Hund
-```
+
 
 // Per val wird aus dem Attribut ein unveränderliches Feld der Klasse  
 // Per var wird aus dem Attribut ein veränderliches Feld der Klasse  
-```
+
 class Hund(val sorte: String)
 scala> val t = new Hund("Dackel")
 t: Hund = Hund@74a85515
 scala> t.sorte
 res18: String = Dackel
-```
+
 
 // Methoden werden mit def geschrieben  
-```
+
 def bark = "Woof, woof!"
-```
+
 
 // Felder und Methoden können public, protected und private sein  
 // default ist public  
 // private ist nur innerhalb des deklarierten Bereichs sichtbar  
-```
+
 class Hund {
   private def x = ...
   def y = ...
 }
-```
+
 
 // protected ist nur innerhalb des deklarierten und aller  
 // erbenden Bereiche sichtbar  
-```
+
 class Hund {
   protected def x = ...
 }
 class Dackel extends Hund {
   // x ist sichtbar
 }
-```
-##  Object
-Wird ein Objekt ohne das Schlüsselwort "new" instanziert, wird das sog.  
-"companion object" aufgerufen. Mit dem "object" Schlüsselwort wird so  
-ein Objekt (Typ UND Singleton) erstellt. Damit kann man dann eine Klasse  
-benutzen ohne ein Objekt instanziieren zu müssen.  
-Ein gültiges companion Objekt einer Klasse ist es aber erst dann, wenn  
-es genauso heisst und in derselben Datei wie die Klasse definiert wurde.  
-```
+
+// Object
+// Wird ein Objekt ohne das Schlüsselwort "new" instanziert, wird das sog.  
+// "companion object" aufgerufen. Mit dem "object" Schlüsselwort wird so  
+// ein Objekt (Typ UND Singleton) erstellt. Damit kann man dann eine Klasse  
+// benutzen ohne ein Objekt instanziieren zu müssen.  
+// Ein gültiges companion Objekt einer Klasse ist es aber erst dann, wenn  
+// es genauso heisst und in derselben Datei wie die Klasse definiert wurde.  
+
 object Hund {
   def alleSorten = List("Pitbull", "Dackel", "Retriever")
   def createHund(sorte: String) = new Hund(sorte)
 }
-```
-## Case classes
-Fallklassen bzw. Case classes sind Klassen die normale Klassen um extra  
-Funktionalität erweitern. Mit Case Klassen bekommt man ein paar  
-Dinge einfach dazu, ohne sich darum kümmern zu müssen. Z.B.  
-ein companion object mit den entsprechenden Methoden,  
-Hilfsmethoden wie toString(), equals() und hashCode() und auch noch  
-Getter für unsere Attribute (das Angeben von val entfällt dadurch)  
-```
+
+// Case classes
+// Fallklassen bzw. Case classes sind Klassen die normale Klassen um extra  
+// Funktionalität erweitern. Mit Case Klassen bekommt man ein paar  
+// Dinge einfach dazu, ohne sich darum kümmern zu müssen. Z.B.  
+// ein companion object mit den entsprechenden Methoden,  
+// Hilfsmethoden wie toString(), equals() und hashCode() und auch noch  
+// Getter für unsere Attribute (das Angeben von val entfällt dadurch)  
+
 class Person(val name: String)
 class Hund(val sorte: String, val farbe: String, val halter: Person)
-```
+
 
 // Es genügt das Schlüsselwort case vor die Klasse zu schreiben.  
-```
+
 case class Person(name: String)
 case class Hund(sorte: String, farbe: String, halter: Person)
-```
+
 
 // Für neue Instanzen brauch man kein "new"  
-```
+
 val dackel = Hund("dackel", "grau", Person("peter"))
 val dogge = Hund("dogge", "grau", Person("peter"))
   
-```
+
 // getter  
-```
+
 dackel.halter  // => Person = Person(peter)
-```
+
   
 // equals  
-```
+
 dogge == dackel  // => false
-```
+
   
 // copy  
 // otherGeorge == Person("george", "9876")  
-```
+
 val otherGeorge = george.copy(phoneNumber = "9876")
-```
-## Traits
-Ähnlich wie Java interfaces, definiert man mit traits einen Objekttyp  
-und Methodensignaturen. Scala erlaubt allerdings das teilweise  
-implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt.  
-Traits können von anderen Traits oder Klassen erben, aber nur von  
-parameterlosen.  
-```
+
+// Traits
+// Ähnlich wie Java interfaces, definiert man mit traits einen Objekttyp  
+// und Methodensignaturen. Scala erlaubt allerdings das teilweise  
+// implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt.  
+// Traits können von anderen Traits oder Klassen erben, aber nur von  
+// parameterlosen.  
+
 trait Hund {
 	def sorte: String
 	def farbe: String
@@ -511,9 +526,9 @@ class Bernhardiner extends Hund{
 	val farbe = "braun"
 	def beissen = false
 }
-```
+
   
-```
+
 scala> b  
 res0: Bernhardiner = Bernhardiner@3e57cd70  
 scala> b.sorte  
@@ -522,10 +537,10 @@ scala> b.bellen
 res2: Boolean = true  
 scala> b.beissen  
 res3: Boolean = false  
-```
+
 
 // Traits können auch via Mixins (Schlüsselwort "with") eingebunden werden  
-```
+
 trait Bellen {
 	def bellen: String = "Woof"
 }
@@ -541,25 +556,27 @@ scala> val b = new Bernhardiner
 b: Bernhardiner = Bernhardiner@7b69c6ba
 scala> b.bellen
 res0: String = Woof
-```
 
-# 6. Pattern Matching
-Pattern matching in Scala ist ein sehr nützliches und wesentlich  
-mächtigeres Feature als Vergleichsfunktionen in Java. In Scala  
-benötigt ein case Statement kein "break", ein fall-through gibt es nicht.  
-Mehrere Überprüfungen können mit einem Statement gemacht werden.  
-Pattern matching wird mit dem Schlüsselwort "match" gemacht.  
-```
+/////////////////////////////////////////////////
+// 6. Pattern Matching
+/////////////////////////////////////////////////
+
+// Pattern matching in Scala ist ein sehr nützliches und wesentlich  
+// mächtigeres Feature als Vergleichsfunktionen in Java. In Scala  
+// benötigt ein case Statement kein "break", ein fall-through gibt es nicht.  
+// Mehrere Überprüfungen können mit einem Statement gemacht werden.  
+// Pattern matching wird mit dem Schlüsselwort "match" gemacht.  
+
 val x = ...
 x match {
   case 2 =>
   case 3 =>
   case _ =>
 }
-```
+
 
 // Pattern Matching kann auf beliebige Typen prüfen  
-```
+
 val any: Any = ...
 val gleicht = any match {
   case 2 | 3 | 5 => "Zahl"
@@ -568,19 +585,19 @@ val gleicht = any match {
   case 45.35 => "Double"
   case _ => "Unbekannt"
 }
-```
+
 
 // und auf Objektgleichheit  
-```
+
 def matchPerson(person: Person): String = person match {
   case Person("George", nummer) => "George! Die Nummer ist " + number
   case Person("Kate", nummer)   => "Kate! Die Nummer ist " + nummer
   case Person(name, nummer)     => "Irgendjemand: " + name + ", Telefon: " + nummer
 }
-```
+
 
 // Und viele mehr...  
-```
+
 val email = "(.*)@(.*)".r  // regex
 def matchEverything(obj: Any): String = obj match {
   // Werte:
@@ -600,18 +617,21 @@ def matchEverything(obj: Any): String = obj match {
   // Patterns kann man ineinander schachteln:
   case List(List((1, 2, "YAY"))) => "Got a list of list of tuple"
 }
-```
+
 
 // Jedes Objekt mit einer "unapply" Methode kann per Pattern geprüft werden  
 // Ganze Funktionen können Patterns sein  
-```
+
 val patternFunc: Person => String = {
   case Person("George", number) => s"George's number: $number"
   case Person(name, number) => s"Random person's number: $number"
 }
-```
 
-# 7. Higher-order functions
+
+/////////////////////////////////////////////////
+// 37. Higher-order functions
+/////////////////////////////////////////////////
+
 Scala erlaubt, das Methoden und Funktion wiederum Funtionen und Methoden  
 als Aufrufparameter oder Return Wert verwenden. Diese Methoden heissen  
 higher-order functions  
@@ -621,116 +641,117 @@ Nennenswerte sind:
 "filter", "map", "reduce", "foldLeft"/"foldRight", "exists", "forall"  
 
 ## List
-```
+
 def isGleichVier(a:Int) = a == 4
 val list = List(1, 2, 3, 4)
 val resultExists4 = list.exists(isEqualToFour)
-```
+
 
 ## map
 // map nimmt eine Funktion und führt sie auf jedem Element aus und erzeugt  
 // eine neue Liste  
   
 // Funktion erwartet ein Int und returned ein Int  
-```
+
 val add10: Int => Int = _ + 10 
-```
+
 
 // add10 wird auf jedes Element angewendet  
-```
+
 List(1, 2, 3) map add10 // => List(11, 12, 13)
-```
+
 
 // Anonyme Funktionen können anstatt definierter Funktionen verwendet werden  
-```
+
 List(1, 2, 3) map (x => x + 10)
-```
+
 
 // Der Unterstrich wird anstelle eines Parameters einer anonymen Funktion  
 // verwendet. Er wird an die Variable gebunden.  
-```
+
 List(1, 2, 3) map (_ + 10)
-```
+
 
 // Wenn der anonyme Block und die Funtion beide EIN Argument erwarten,  
 // kann sogar der Unterstrich weggelassen werden.  
-```
+
 List("Dom", "Bob", "Natalia") foreach println
-```
 
-## filter
+
+// filter
 // filter nimmt ein Prädikat (eine Funktion von A -> Boolean) und findet  
 // alle Elemente die auf das Prädikat passen  
-```
+
 List(1, 2, 3) filter (_ > 2) // => List(3)
 case class Person(name: String, age: Int)
 List(
   Person(name = "Dom", age = 23),
   Person(name = "Bob", age = 30)
 ).filter(_.age > 25) // List(Person("Bob", 30))
-```
 
-## reduce
+
+// reduce
 // reduce nimmt zwei Elemente und kombiniert sie zu einem Element,  
 // und zwar solange bis nur noch ein Element da ist.  
 
-## foreach
+// foreach
 // foreach gibt es für einige Collections  
-```
+
 val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100)
 aListOfNumbers foreach (x => println(x))
 aListOfNumbers foreach println
-```
-## For comprehensions
+
+// For comprehensions
 // Eine for-comprehension definiert eine Beziehung zwischen zwei Datensets.  
 // Dies ist keine for-Schleife.  
-```
+
 for { n <- s } yield sq(n)
 val nSquared2 = for { n <- s } yield sq(n)
 for { n <- nSquared2 if n < 10 } yield n
 for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
-```
+
 
 /////////////////////////////////////////////////
-# 8. Implicits
+// 8. Implicits
 /////////////////////////////////////////////////
 
-**ACHTUNG:**  
-Implicits sind ein sehr mächtiges Sprachfeature von Scala. Es sehr einfach  
-sie falsch zu benutzen und Anfänger sollten sie mit Vorsicht oder am  
-besten erst dann benutzen, wenn man versteht wie sie funktionieren.  
-Dieses Tutorial enthält Implicits, da sie in Scala an jeder Stelle  
-vorkommen und man auch mit einer Lib die Implicits benutzt nichts sinnvolles  
-machen kann.  
-Hier soll ein Grundverständnis geschaffen werden, wie sie funktionieren.  
+// **ACHTUNG:**  
+// Implicits sind ein sehr mächtiges Sprachfeature von Scala.
+// Es sehr einfach  
+// sie falsch zu benutzen und Anfänger sollten sie mit Vorsicht oder am  
+// besten erst dann benutzen, wenn man versteht wie sie funktionieren.  
+// Dieses Tutorial enthält Implicits, da sie in Scala an jeder Stelle  
+// vorkommen und man auch mit einer Lib die Implicits benutzt nichts sinnvolles  
+// machen kann.  
+// Hier soll ein Grundverständnis geschaffen werden, wie sie funktionieren.  
 
 // Mit dem Schlüsselwort implicit können Methoden, Werte, Funktion, Objekte  
 // zu "implicit Methods" werden.  
-```
+
 implicit val myImplicitInt = 100
 implicit def myImplicitFunction(sorte: String) = new Hund("Golden " + sorte)
-```
+
 
 // implicit ändert nicht das Verhalten eines Wertes oder einer Funktion  
-```
+
 myImplicitInt + 2                   // => 102
 myImplicitFunction("Pitbull").sorte // => "Golden Pitbull"
-```
+
 
 // Der Unterschied ist, dass diese Werte ausgewählt werden können, wenn ein  
 // anderer Codeteil einen implicit Wert benötigt, zum Beispiel innerhalb von  
 // implicit Funktionsparametern  
   
 // Diese Funktion hat zwei Parameter: einen normalen und einen implicit  
-```
+
 def sendGreetings(toWhom: String)(implicit howMany: Int) =
   s"Hello $toWhom, $howMany blessings to you and yours!"
-```
+
 
 // Werden beide Parameter gefüllt, verhält sich die Funktion wie erwartet  
-```
+
 sendGreetings("John")(1000)  // => "Hello John, 1000 blessings to you and yours!"
-```
+
 
 // Wird der implicit Parameter jedoch weggelassen, wird ein anderer  
 // implicit Wert vom gleichen Typ genommen. Der Compiler sucht im  
@@ -739,66 +760,69 @@ sendGreetings("John")(1000)  // => "Hello John, 1000 blessings to you and yours!
 // geforderten Typ konvertieren kann.  
   
 // Hier also: "myImplicitInt", da ein Int gesucht wird  
-```
+
 sendGreetings("Jane")  // => "Hello Jane, 100 blessings to you and yours!"
-```
+
 
 // bzw. "myImplicitFunction"  
 // Der String wird erst mit Hilfe der Funktion in Hund konvertiert, und  
 // dann wird die Methode aufgerufen  
-```
+
 "Retriever".sorte // => "Golden Retriever"
-```
 
-# 9. Misc
-## Importe
-```
+
+/////////////////////////////////////////////////
+// 19. Misc
+/////////////////////////////////////////////////
+// Importe
+
 import scala.collection.immutable.List
-```
+
 
 // Importiere alle Unterpackages  
-```
+
 import scala.collection.immutable._
-```
+
 
 // Importiere verschiedene Klassen mit einem Statement  
-```
+
 import scala.collection.immutable.{List, Map}
-```
+
 
 // Einen Import kann man mit '=>' umbenennen  
-```
+
 import scala.collection.immutable.{List => ImmutableList}
-```
+
 
 // Importiere alle Klasses, mit Ausnahem von....  
 // Hier ohne: Map and Set:  
-```
+
 import scala.collection.immutable.{Map => _, Set => _, _}
-```
-## Main 
-```
+
+// Main 
+
 object Application {
   def main(args: Array[String]): Unit = {
-    // stuff goes here.
+    // Sachen kommen hierhin
   }
 }
-```
 
-## I/O
+
+// I/O
 // Eine Datei Zeile für Zeile lesen  
-```
+
 import scala.io.Source
 for(line <- Source.fromFile("myfile.txt").getLines())
   println(line)
-```
+
 
 // Eine Datei schreiben  
-```
+
 val writer = new PrintWriter("myfile.txt")
 writer.write("Schreibe Zeile" + util.Properties.lineSeparator)
 writer.write("Und noch eine Zeile" + util.Properties.lineSeparator)
 writer.close()
+
 ```
 
 ## Weiterführende Hinweise 
diff --git a/de-de/yaml-de.html.markdown b/de-de/yaml-de.html.markdown
index 19ea9e87..a46c30f6 100644
--- a/de-de/yaml-de.html.markdown
+++ b/de-de/yaml-de.html.markdown
@@ -30,7 +30,7 @@ null_Wert: null
 Schlüssel mit Leerzeichen: value
 # Strings müssen nicht immer mit Anführungszeichen umgeben sein, können aber:
 jedoch: "Ein String in Anführungzeichen"
-"Ein Schlüssel in Anführungszeichen": "Nützlich, wenn du einen Doppelpunkt im Schluessel haben willst."
+"Ein Schlüssel in Anführungszeichen": "Nützlich, wenn du einen Doppelpunkt im Schlüssel haben willst."
 
 # Mehrzeilige Strings schreibst du am besten als 'literal block' (| gefolgt vom Text)
 # oder ein 'folded block' (> gefolgt vom text).
@@ -64,7 +64,7 @@ eine_verschachtelte_map:
         hallo: hallo
 
 # Schlüssel müssen nicht immer String sein.
-0.25: ein Float-Wert als Schluessel
+0.25: ein Float-Wert als Schlüssel
 
 # Schlüssel können auch mehrzeilig sein, ? symbolisiert den Anfang des Schlüssels
 ? |