Merge branch 'master' of https://github.com/adambard/learnxinyminutes-docs

4 files changed, 172 insertions, 34 deletions

diff --git a/de-de/bash-de.html.markdown b/de-de/bash-de.html.markdown
index ad782e06..fb9cd9d4 100644
--- a/de-de/bash-de.html.markdown
+++ b/de-de/bash-de.html.markdown
@@ -17,7 +17,7 @@ Beinahe alle der folgenden Beispiele können als Teile eines Shell-Skripts oder
 
 ```bash
 #!/bin/bash
-# Die erste Zeile des Scripts nennt sich Shebang in gibt dem System an, wie
+# Die erste Zeile des Scripts nennt sich Shebang, dies gibt dem System an, 
 # wie das Script ausgeführt werden soll: http://de.wikipedia.org/wiki/Shebang
 # Du hast es bestimmt schon mitgekriegt, Kommentare fangen mit # an. Das Shebang ist auch ein Kommentar
 
diff --git a/de-de/go-de.html.markdown b/de-de/go-de.html.markdown
index ca27fdc7..83d59c8b 100644
--- a/de-de/go-de.html.markdown
+++ b/de-de/go-de.html.markdown
@@ -5,34 +5,34 @@ contributors:
     - ["Joseph Adams", "https://github.com/jcla1"]
 lang: de-de
 ---
-Go wurde entwickelt um probleme zu lösen. Sie ist zwar nicht der neuste Trend in
-der Informatik, aber sie ist eine der neusten und schnellsten Wege um Aufgabe in
+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 statisher Typisierung
+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.
 
-Außerdem beinhaltet Go eine gut ausgestattete standard bibliothek und hat eine
-aktive community.
+Außerdem beinhaltet Go eine gut ausgestattete Standardbibliothek und hat eine
+aktive Community.
 
 ```go
 // Einzeiliger Kommentar
 /* Mehr-
    zeiliger Kommentar */
 
-// Eine jede Quelldatei beginnt mit einer Packet-Klausel.
-// "main" ist ein besonderer Packetname, da er ein ausführbares Programm
+// Eine jede Quelldatei beginnt mit einer Paket-Klausel.
+// "main" ist ein besonderer Pkaetname, da er ein ausführbares Programm
 // einleitet, im Gegensatz zu jedem anderen Namen, der eine Bibliothek
 // deklariert.
 package main
 
-// Ein "import" wird verwendet um Packte zu deklarieren, die in dieser
+// Ein "import" wird verwendet, um Pakete zu deklarieren, die in dieser
 // Quelldatei Anwendung finden.
 import (
-    "fmt"      // Ein Packet in der Go standard Bibliothek
+    "fmt"      // Ein Paket in der Go Standardbibliothek
     "net/http" // Ja, ein Webserver.
     "strconv"  // Zeichenkettenmanipulation
 )
@@ -42,10 +42,10 @@ import (
 // Programms. Vergessen Sie nicht die geschweiften Klammern!
 func main() {
     // Println gibt eine Zeile zu stdout aus.
-    // Der Prefix "fmt" bestimmt das Packet aus welchem die Funktion stammt.
+    // Der Prefix "fmt" bestimmt das Paket aus welchem die Funktion stammt.
     fmt.Println("Hello world!")
 
-    // Aufruf einer weiteren Funktion definiert innerhalb dieses Packets.
+    // Aufruf einer weiteren Funktion definiert innerhalb dieses Pakets.
     beyondHello()
 }
 
@@ -54,7 +54,7 @@ func main() {
 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
+    // Kurze Deklaration: Benutzen Sie ":=", um die Typisierung automatisch zu
     // folgern, die Variable zu deklarieren und ihr einen Wert zu zuweisen.
     y := 4
 
@@ -70,7 +70,7 @@ func learnMultiple(x, y int) (sum, prod int) {
     return x + y, x * y // Wiedergabe zweier Werte
 }
 
-// Überblick ueber einige eingebaute Typen und Literale.
+// Überblick über einige eingebaute Typen und Literale.
 func learnTypes() {
     // Kurze Deklarationen sind die Norm.
     s := "Lernen Sie Go!" // Zeichenketten-Typ
@@ -111,7 +111,7 @@ Zeilenumbrüche beinhalten.` // Selber Zeichenketten-Typ
     m["eins"] = 1
 
     // Ungebrauchte Variablen sind Fehler in Go
-    // Der Unterstrich wird verwendet um einen Wert zu verwerfen.
+    // Der Unterstrich wird verwendet, um einen Wert zu verwerfen.
     _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs
     // Die Ausgabe zählt natürlich auch als Gebrauch
     fmt.Println(s, c, a4, s3, d2, m)
@@ -142,7 +142,7 @@ func learnFlowControl() {
     if true {
         fmt.Println("hab's dir ja gesagt!")
     }
-    // Die Formattierung ist durch den Befehl "go fmt" standardisiert
+    // Die Formatierung ist durch den Befehl "go fmt" standardisiert
     if false {
         // nicht hier
     } else {
@@ -170,7 +170,7 @@ func learnFlowControl() {
         continue // wird nie ausgeführt
     }
 
-    // Wie bei for, bedeutet := in einer Bedingten Anweisung zunächst die
+    // Wie bei for, bedeutet := in einer bedingten Anweisung zunächst die
     // Zuweisung und erst dann die Überprüfung der Bedingung.
     if y := expensiveComputation(); y > x {
         x = y
@@ -217,8 +217,8 @@ func learnInterfaces() {
     // Aufruf der String Methode von i, gleiche Ausgabe wie zuvor.
     fmt.Println(i.String())
 
-    // Funktionen des fmt-Packets rufen die String() Methode auf um eine
-    // druckbare variante des Empfängers zu erhalten.
+    // Funktionen des fmt-Pakets rufen die String() Methode auf um eine
+    // druckbare Variante des Empfängers zu erhalten.
     fmt.Println(p) // gleiche Ausgabe wie zuvor
     fmt.Println(i) // und wieder die gleiche Ausgabe wie zuvor
 
@@ -244,18 +244,18 @@ func learnErrorHandling() {
     learnConcurrency()
 }
 
-// c ist ein Kannal, ein sicheres Kommunikationsmedium.
+// c ist ein Kanal, ein sicheres Kommunikationsmedium.
 func inc(i int, c chan int) {
-    c <- i + 1 // <- ist der "send" Operator, wenn ein Kannal auf der Linken ist
+    c <- i + 1 // <- ist der "send" Operator, wenn ein Kanal auf der Linken ist
 }
 
 // Wir verwenden "inc" um Zahlen parallel zu erhöhen.
 func learnConcurrency() {
     // Die selbe "make"-Funktion wie vorhin. Sie initialisiert Speicher für
-    // maps, slices und Kannäle.
+    // 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 Kannal.
+    // 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)
@@ -269,16 +269,16 @@ func learnConcurrency() {
 
     // Start einer neuen Goroutine, nur um einen Wert zu senden
     go func() { c <- 84 }()
-    go func() { cs <- "wortreich" }() // schon wider, diesmal für
+    go func() { cs <- "wortreich" }() // schon wieder, diesmal für
     // "select" hat eine Syntax wie ein switch Statement, aber jeder Fall ist
-    // eine Kannaloperation. Es wählt eine Fall zufällig aus allen die
-    // kommunikationsbereit sind aus.
+    // eine Kanaloperation. Es wählt einen Fall zufällig aus allen, die
+    // kommunikationsbereit sind, aus.
     select {
     case i := <-c: // der empfangene Wert kann einer Variable zugewiesen werden
         fmt.Printf("es ist ein: %T", i)
     case <-cs: // oder der Wert kann verworfen werden
         fmt.Println("es ist eine Zeichenkette!")
-    case <-cc: // leerer Kannal, nicht bereit für den Empfang
+    case <-cc: // leerer Kanal, nicht bereit für den Empfang
         fmt.Println("wird nicht passieren.")
     }
     // Hier wird eine der beiden Goroutines fertig sein, die andere nicht.
@@ -287,16 +287,16 @@ func learnConcurrency() {
     learnWebProgramming() // Go kann es und Sie hoffentlich auch bald.
 }
 
-// Eine einzige Funktion aus dem http-Packet kann einen Webserver starten.
+// Eine einzige Funktion aus dem http-Paket kann einen Webserver starten.
 func learnWebProgramming() {
-    // Der erste Parameter von "ListenAndServe" ist eine TCP Addresse an die
+    // Der erste Parameter von "ListenAndServe" ist eine TCP Addresse, an die
     // sich angeschlossen werden soll.
     // Der zweite Parameter ist ein Interface, speziell: ein http.Handler
     err := http.ListenAndServe(":8080", pair{})
     fmt.Println(err) // Fehler sollte man nicht ignorieren!
 }
 
-// Wir lassen "pair" das http.Handler Interface erfüllen indem wir seine einzige
+// Wir lassen "pair" das http.Handler Interface erfüllen, indem wir seine einzige
 // Methode implementieren: ServeHTTP
 func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
     // Senden von Daten mit einer Methode des http.ResponseWriter
@@ -313,6 +313,6 @@ 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 documentiert, demonstriert sie leicht zu verstehendes und im idiomatischen Stil
-verfasstes Go. Erreichbar ist der Quelltext auch durch das Klicken der Funktions-
-Namen in der [offiziellen Dokumentation von Go](http://golang.org/pkg/).
+verfasstes Go. 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/python-de.html.markdown b/de-de/python-de.html.markdown
index 5ddb6f4b..ae29d6f9 100644
--- a/de-de/python-de.html.markdown
+++ b/de-de/python-de.html.markdown
@@ -149,7 +149,7 @@ li[0] #=> 1
 # Das letzte Element ansehen
 li[-1] #=> 3
 
-# Bei Zugriffen außerhal der Liste kommt es jedoch zu einem IndexError
+# Bei Zugriffen außerhalb der Liste kommt es jedoch zu einem IndexError
 li[4] # Raises an IndexError
 
 # Wir können uns Ranges mit Slice-Syntax ansehen
@@ -188,7 +188,7 @@ tup[:2] #=> (1, 2)
 
 # Wir können Tupel (oder Listen) in Variablen entpacken
 a, b, c = (1, 2, 3)     # a ist jetzt 1, b ist jetzt 2 und c ist jetzt 3
-# Tuple werden standardmäßig erstellt, wenn wir uns die Klammern sparen
+# Tupel werden standardmäßig erstellt, wenn wir uns die Klammern sparen
 d, e, f = 4, 5, 6
 # Es ist kinderleicht zwei Werte zu tauschen
 e, d = d, e     # d is now 5 and e is now 4
diff --git a/de-de/yaml-de.html.markdown b/de-de/yaml-de.html.markdown
new file mode 100644
index 00000000..88318014
--- /dev/null
+++ b/de-de/yaml-de.html.markdown
@@ -0,0 +1,138 @@
+---
+language: yaml
+filename: learnyaml.yaml
+contributors:
+  - ["Adam Brenecki", "https://github.com/adambrenecki"]
+translators:
+	- ["Ruben M.", https://github.com/switchhax]
+---
+
+YAML ist eine Sprache zur Datenserialisierung, die sofort von Menschenhand geschrieben und gelesen werden kann.
+
+YAML ist eine Erweiterung von JSON, mit der Erweiterung von syntaktisch wichtigen Zeilenumbrüche und Einrückung sowie in Python. Anders als in Python erlaubt YAML keine Tabulator-Zeichen.
+
+```yaml
+# Kommentare in YAML schauen so aus.
+
+#################
+# SKALARE TYPEN #
+#################
+
+# Unser Kernobjekt (für das ganze Dokument) wird das Assoziative Datenfeld (Map) sein,
+# welches equivalent zu einem Hash oder einem Objekt einer anderen Sprache ist.
+Schlüssel: Wert
+nochn_Schlüssel: Hier kommt noch ein Wert hin.
+eine_Zahl: 100
+wissenschaftliche_Notation: 1e+12
+boolean: true
+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."
+
+# Mehrzeilige Strings schreibst du am besten als 'literal block' (| gefolgt vom Text)
+# oder ein 'folded block' (> gefolgt vom text).
+literal_block: |
+    Dieser ganze Block an Text ist der Wert vom Schlüssel literal_block,
+    mit Erhaltung der Zeilenumbrüche.
+
+    Das Literal fährt solange fort bis dieses unverbeult ist und die vorherschende Einrückung wird 
+    gekürzt.
+
+        Zeilen, die weiter eingerückt sind, behalten den Rest ihrer Einrückung -
+        diese Zeilen sind mit 4 Leerzeichen eingerückt.
+folded_style: >
+    Dieser ganze Block an Text ist der Wert vom Schlüssel folded_style, aber diesmal
+    werden alle Zeilenumbrüche durch ein Leerzeichen ersetzt.
+
+    Freie Zeilen, wie obendrüber, werden in einen Zeilenumbruch verwandelt.
+
+        Weiter eingerückte Zeilen behalten ihre Zeilenumbrüche -
+        diese Textpassage wird auf zwei Zeilen sichtbar sein.
+
+####################
+# COLLECTION TYPEN #
+####################
+
+# Verschachtelung wird duch Einrückung erzielt.
+eine_verschachtelte_map:
+    schlüssel: wert
+    nochn_Schlüssel: Noch ein Wert.
+    noch_eine_verschachtelte_map:
+        hallo: hallo
+
+# Schlüssel müssen nicht immer String sein.
+0.25: ein Float-Wert als Schluessel
+
+# Schlüssel können auch mehrzeilig sein, ? symbolisiert den Anfang des Schlüssels
+? |
+    Dies ist ein Schlüssel,
+    der mehrzeilig ist.
+: und dies ist sein Wert
+
+# YAML erlaubt auch Collections als Schlüssel, doch viele Programmiersprachen
+# werden sich beklagen.
+
+# Folgen (equivalent zu Listen oder Arrays) schauen so aus:
+eine_Folge:
+    - Artikel 1
+    - Artikel 2
+    - 0.5 # Folgen können verschiedene Typen enthalten.
+    - Artikel 4
+    - schlüssel: wert
+      nochn_schlüssel: nochn_wert
+    -
+        - Dies ist eine Folge
+        - innerhalb einer Folge
+
+# Weil YAML eine Erweiterung von JSON ist, können JSON-ähnliche Maps und Folgen
+# geschrieben werden:
+json_map: {"schlüssel": "wert"}
+json_seq: [3, 2, 1, "Start"]
+
+############################
+# EXTRA YAML EIGENSCHAFTEN #
+############################
+
+# YAML stellt zusätzlich Verankerung zu Verfügung, welche es einfach machen 
+# Inhalte im Dokument zu vervielfältigen. Beide Schlüssel werden den selben Wert haben.
+verankerter_inhalt: &anker_name Dieser String wird als Wert beider Schlüssel erscheinen.
+anderer_anker: *anker_name
+
+# YAML hat auch Tags, mit denen man explizit Typangaben angibt.
+explicit_string: !!str 0.5
+# Manche Parser implementieren sprachspezifische Tags wie dieser hier für Pythons
+# komplexe Zahlen.
+python_komplexe_Zahlen: !!python/komplex 1+2j
+
+####################
+# EXTRA YAML TYPEN #
+####################
+
+# Strings and Zahlen sind nicht die einzigen Skalare, welche YAML versteht.
+# ISO-formatierte Datumsangaben and Zeiangaben können ebenso geparsed werden.
+DatumZeit: 2001-12-15T02:59:43.1Z
+DatumZeit_mit_Leerzeichen: 2001-12-14 21:59:43.10 -5
+Datum: 2002-12-14
+
+# Der !!binary Tag zeigt das ein String base64 verschlüsselt ist.
+# Representation des Binären Haufens
+gif_datei: !!binary |
+    R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
+    OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+    +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
+    AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
+
+# YAML bietet auch Mengen (Sets), welche so ausschauen
+menge:
+    ? artikel1
+    ? artikel2
+    ? artikel3
+
+# Wie in Python sind Mengen nicht anderes als Maps nur mit null als Wert; das Beispiel oben drüber ist equivalent zu:
+menge:
+    artikel1: null
+    artikel2: null
+    artikel3: null
+```