From 5bed6d5a79834d92984a60699ef9f5792b37377c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dominik=20S=C3=BC=C3=9F?= <dominik.suess@outlook.at>
Date: Thu, 1 Oct 2015 22:32:49 +0200
Subject: Added D Translation to German

---
 de-de/d-de.html.markdown | 248 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 248 insertions(+)
 create mode 100644 de-de/d-de.html.markdown

(limited to 'de-de')

diff --git a/de-de/d-de.html.markdown b/de-de/d-de.html.markdown
new file mode 100644
index 00000000..305c9167
--- /dev/null
+++ b/de-de/d-de.html.markdown
@@ -0,0 +1,248 @@
+---
+language: D 
+filename: learnd.d 
+contributors:
+    - ["Nick Papanastasiou", "Dominik Süß"]
+lang: de
+---
+
+```c
+// Es war klar dass das kommt...
+module hello;
+
+import std.stdio;
+
+// argumente sind optional
+void main(string[] args) {
+    writeln("Hello, World!");
+}
+```
+
+Wenn du so wie ich bist und viel zeit im Internet verbringst stehen die Chancen gut
+das du schonmal über [D](http://dlang.org/) gehört hast.
+Die D-Sprache ist eine moderne, überall einsetzbare programmiersprache die von Low bis
+High Level verwendet werden kann und dabei viele stile anbietet.
+
+D wird aktiv von Walter Bright und Andrei Alexandrescu entwickelt, zwei super schlaue,
+richtig coole leute. Da das jetzt alles aus dem weg ist - auf zu den Beispielen!
+
+```c
+import std.stdio;
+
+void main() {
+
+    // Logische Ausdrücke und Schleifen funktionieren wie erwartet
+    for(int i = 0; i < 10000; i++) {
+        writeln(i);
+    }
+
+    auto n = 1; // auto um den typ vom Compiler bestimmen zu lassen
+    
+    // Zahlenliterale können _ verwenden für lesbarkeit
+    while(n < 10_000) {
+        n += n;
+    }
+
+    do {
+        n -= (n / 2);
+    } while(n > 0);
+
+    // For und while sind ja schön und gut aber D bevorzugt foreach
+    // .. erstellt eine spanne von zahlen, exklusive dem Ende
+    foreach(i; 1..1_000_000) {
+        if(n % 2 == 0)
+            writeln(i);
+    }
+
+    foreach_reverse(i; 1..int.max) {
+        if(n % 2 == 1) {
+            writeln(i);
+        } else {
+            writeln("No!");
+        }
+    }
+}
+```
+
+Neue Typen können mit `struct`, `class`, `union`, und `enum` definiert werden. Structs und unions
+werden as-value (koppiert) an methoden übergeben wogegen Klassen als Referenz übergeben werden.
+Templates können verwendet werden um alle typen zu parameterisieren.
+
+```c
+// Hier, T ist ein Type-Parameter, Er funktioniert wie Generics in C#/Java/C++
+struct LinkedList(T) {
+    T data = null;
+    LinkedList!(T)* next; // Das ! wird verwendet um T zu übergeben. (<T> in C#/Java/C++)
+}
+
+class BinTree(T) {
+    T data = null;
+    
+    // Wenn es nur einen T parameter gibt können die Klammern um ihn weggelassen werden
+    BinTree!T left;
+    BinTree!T right;
+}
+
+enum Day {
+    Sunday,
+    Monday,
+    Tuesday,
+    Wednesday,
+    Thursday,
+    Friday,
+    Saturday,
+}
+
+// Aliase können verwendet werden um die Entwicklung zu erleichtern
+
+alias IntList = LinkedList!int;
+alias NumTree = BinTree!double;
+
+// Funktionen können genau so Templates beinhalten
+
+T max(T)(T a, T b) {
+    if(a < b)
+        return b;
+
+    return a;
+}
+
+// Steht ref vor einem Parameter wird sichergestellt das er als Referenz übergeben wird.
+// Selbst bei werten wird es immer eine Referenz sein.
+void swap(T)(ref T a, ref T b) {
+    auto temp = a;
+
+    a = b;
+    b = temp;
+}
+
+// Templates können ebenso werte parameterisieren.
+class Matrix(uint m, uint n, T = int) {
+    T[m] rows;
+    T[n] columns;
+}
+
+auto mat = new Matrix!(3, 3); // Standardmäßig ist T vom typ Integer
+
+```
+
+Wo wir schon bei Klassen sind - Wie wäre es mit Properties! Eine Property
+ist eine Funktion die wie ein Wert agiert. Das gibt uns viel klarere syntax
+im stil von `structure.x = 7` was gleichgültig wäre zu `structure.setX(7)`
+
+```c
+// Diese Klasse ist parameterisiert mit T, U
+
+class MyClass(T, U) {
+    T _data;
+    U _other;
+
+}
+
+// Ihre Getter und Setter Methoden sehen so aus
+class MyClass(T, U) {
+    T _data;
+    U _other;
+    
+    // Konstruktoren heißen immer `this`
+    this(T t, U u) {
+        data = t;
+        other = u;
+    }
+    
+    // getters
+    @property T data() {
+        return _data;
+    }
+
+    @property U other() {
+        return _other;
+    }
+
+    // setters    
+	// @property kann genauso gut am ende der Methodensignatur stehen
+    void data(T t) @property {
+        _data = t;
+    }
+
+    void other(U u) @property {
+        _other = u;
+    }
+}
+// Und so kann man sie dann verwenden
+
+void main() {
+    auto mc = MyClass!(int, string);
+
+    mc.data = 7;
+    mc.other = "seven";
+    
+    writeln(mc.data);
+    writeln(mc.other);
+}
+```
+
+Mit properties können wir sehr viel logik hinter unseren gettern
+und settern hinter einer schönen syntax verstecken
+
+Other object-oriented goodies at our disposal
+Andere Objektorientierte features sind beispielsweise
+`interface`s, `abstract class` und `override`.
+Vererbung funktioniert in D wie in Java:
+Erben von einer Klasse, so viele interfaces wie man will.
+
+Jetzt haben wir Objektorientierung in D gesehen aber schauen
+wir uns noch was anderes an.
+D bietet funktionale programmierung mit _first-class functions_
+puren funktionen und unveränderbare daten.
+Zusätzlich können viele funktionale Algorithmen wie z.B
+map, filter, reduce und friends im `std.algorithm` Modul gefunden werden!
+
+```c
+import std.algorithm : map, filter, reduce;
+import std.range : iota; // builds an end-exclusive range
+
+void main() {
+    // Wir wollen die summe aller quadratzahlen zwischen
+    // 1 und 100 ausgeben. Nichts leichter als das!
+ 
+    // Einfach eine lambda funktion als template parameter übergeben
+    // Es ist genau so gut möglich eine normale funktion hier zu übergeben
+	// Lambdas bieten sich hier aber an.
+    auto num = iota(1, 101).filter!(x => x % 2 == 0)
+                           .map!(y => y ^^ 2)
+                           .reduce!((a, b) => a + b);
+
+    writeln(num);
+}
+```
+
+Ist dir aufgefallen wie wir eine Haskell-Style pipeline gebaut haben
+um num zu berechnen?
+Das war möglich durch die Uniform Function Call Syntax.
+Mit UFCS können wir auswählen ob wir eine Funktion als Methode oder
+als freie Funktion aufrufen. Walters artikel dazu findet ihr
+[hier.](http://www.drdobbs.com/cpp/uniform-function-call-syntax/232700394) 
+Kurzgesagt kann man Funktionen deren erster parameter vom typ A ist, als
+Methode auf A anwenden.
+
+Parrallel Computing ist eine Tolle sache, findest du nicht auch?
+
+```c
+import std.stdio;
+import std.parallelism : parallel;
+import std.math : sqrt;
+
+void main() {
+    // Wir wollen die Wurzel von jeder Zahl in unserem Array berechnen
+    // und dabei alle Kerne verwenden die wir zur verfügung haben
+    auto arr = new double[1_000_000];
+
+    // Wir verwenden den index und das element als referenz
+    // und rufen einfach parallel auf!
+    foreach(i, ref elem; parallel(arr)) {
+        ref = sqrt(i + 1.0);
+    }
+}
+
+```
-- 
cgit v1.2.3


From bc0431b667a5790679792c01e5a12af753fcdf88 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dominik=20S=C3=BC=C3=9F?= <dominik.suess@outlook.at>
Date: Thu, 1 Oct 2015 22:35:13 +0200
Subject: Fixed File Header

---
 de-de/d-de.html.markdown | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'de-de')

diff --git a/de-de/d-de.html.markdown b/de-de/d-de.html.markdown
index 305c9167..a7291518 100644
--- a/de-de/d-de.html.markdown
+++ b/de-de/d-de.html.markdown
@@ -1,8 +1,9 @@
 ---
 language: D 
-filename: learnd.d 
+filename: learnd-de.d 
 contributors:
-    - ["Nick Papanastasiou", "Dominik Süß"]
+    - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
+    - ["Dominik Süß", "www.thesuess.me"]
 lang: de
 ---
 
-- 
cgit v1.2.3


From e19e1a8f27da89487a97146b0c00eb9ffffd0520 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dominik=20S=C3=BC=C3=9F?= <dominik.suess@outlook.at>
Date: Thu, 1 Oct 2015 22:35:48 +0200
Subject: Fixed lang

---
 de-de/d-de.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'de-de')

diff --git a/de-de/d-de.html.markdown b/de-de/d-de.html.markdown
index a7291518..94519b28 100644
--- a/de-de/d-de.html.markdown
+++ b/de-de/d-de.html.markdown
@@ -4,7 +4,7 @@ filename: learnd-de.d
 contributors:
     - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
     - ["Dominik Süß", "www.thesuess.me"]
-lang: de
+lang: de-de
 ---
 
 ```c
-- 
cgit v1.2.3


From 2813f49b8a00afc50a8cbcb1ac2960d594e5db9e Mon Sep 17 00:00:00 2001
From: Martin Schimandl <martin.schimandl@gmail.com>
Date: Fri, 9 Oct 2015 10:50:34 +0200
Subject: First version of a german translation of the Tcl page

---
 de-de/tcl-de.html.markdown | 474 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 474 insertions(+)
 create mode 100644 de-de/tcl-de.html.markdown

(limited to 'de-de')

diff --git a/de-de/tcl-de.html.markdown b/de-de/tcl-de.html.markdown
new file mode 100644
index 00000000..1e24e379
--- /dev/null
+++ b/de-de/tcl-de.html.markdown
@@ -0,0 +1,474 @@
+---
+language: Tcl
+contributors:
+    - ["Poor Yorick", "http://pooryorick.com/"]
+translators:
+    - ["Martin Schimandl", "https://github.com/Git-Jiro"]
+filename: learntcl-de.tcl
+---
+
+Tcl wurde kreiert von [John Ousterhout](http://wiki.tcl.tk/John Ousterout) als
+eine wiederverwendbare Script-Sprache für Chip-Design Werkzeuge die er kreiert
+hat. Im Jahre 1997 wurde er mit dem [ACM Software System
+Award](http://en.wikipedia.org/wiki/ACM_Software_System_Award) für Tcl
+ausgezeichnet. Tcl kann sowohl als eingebettete Scipt-Sprache als auch als
+allgemeine Programmier-Sprache verwendet werden. Tcl kann auch als portable
+C-Bibliothek verwendet werden. Sogar in Fällen in denen die Script-Fähigkeiten
+nicht nötig sind. Denn Tcl stellt Daten-Strukturen wie dynamische Zeichenketten,
+Listen und Hash-Tabellen bereit. Die C-Bilbiothek stellt auch portable
+Funktionen zur Verfügung: Laden von dynamischen Bibliotheken, Zeichenketten
+formatierung und Code Konversion, Dateisystem Operationen, Netzwerk Operationen
+und mehr.
+
+
+Verschiedenste herausragende Fähigkeiten von Tcl:
+
+* Praktische Cross-Platform Netzwerk-API
+
+* Vollständig virtualisiertes Dateisystem
+
+* Stapelbare I/O Kanäle
+
+* Asynchron bis zum Kern
+
+* Vollständige Ko-Routinen
+
+* Robustes und einfach zu verwendendes Thread-Modell
+
+
+Wenn Lisp ein Listen-Prozessor ist, dann ist TCl ein Zeichenketten-Prozessor.
+Alle Werte sind Zeichenketten. Eine Liste ist ein Zeichenketten-Format. Eine
+Prozedur-Definition ist ein Zeichenketten-Format. Um leistungsfähig zu sein,
+werden Tcl-intern diese Zeichenketten in Strukutierter-Form gepuffert. Ein
+Beispiel: Der "list" Befehl arbeitet mit diesen internen gepufferten 
+Repräsentationen. Tcl kümmert sich selbständig darum die String-Repräsentationen
+zu aktualisieren, falls dies im Skript benötigt werden sollten. Das Kopieren-
+beim-Schreiben-Design von Tcl erlaubt es Skript-Authoren mit großen Daten-
+Strukturen zu arbeiten ohne zuätzlichen Speicher-Overhead. Prozeduren werden
+automatisch byte-kompiliert außer sie verwenden dynamsiche Befehle wie zum
+Beispiel "uplevel", "upvar und "trace".
+
+Es ist eine freude in Tcl zu programmieren. Hacker-Typen werden gefallen daran
+finden, wenn sie Lisp, Forth oder Smalltalk interessant finden. Tcl wird auch
+Ingenieuren und Wissenshaftlern gefallen die nur den Job erledigen wollen,
+und zwar mit Werkzeugen die sich ihrem Willen anpassen. Bei Tcl ist jegliche
+funktionalität in Befehlen ausgeführt, selbst Dinge wie Schleifen und
+Mathematische-Funktionen die bei anderen Sprachen normalerweise Teil der Syntax
+sind. Das erlaubt Tcl in den Hintergrund von Domänen spezischen Sprachen zu
+treten die das jeweilige Projekt gerade benötigt. Die Tcl-Syntax ist sehr
+leichtgewichtig. Sie ist selbst leichtgewichtiger als die Syntax von Lisp.
+Tcl steht dir einfach nicht im Weg.
+
+
+```tcl
+#! /bin/env tclsh
+
+################################################################################
+## 1. Richtlinien 
+################################################################################
+
+# Tcl ist nicht Bash oder C! Das muss gesagt werden, denn standard Shell-Quoting
+# funktioniert fast mit Tcl. Daher glauben viele sie können diese Syntax für
+# Tcl übernehmen. Am Beginn funktioniert das meist, führt aber schnell zu 
+# Frustrationen wenn die Skripte komplexer werden.
+
+# Eckige-Klammern sind nur Quoting-Mechanismen, keine Code-Block-Konstruktoren
+# und auch keine Listen-Konstruktoren. In Tcl gibt es diese beiden Dinge nicht.
+# Eckige-Klammern werden verwendet um Spezial-Zeichen in Prozeduren zu escapen
+# und in Zeichenketten die als Listen formattiert sind.
+
+################################################################################
+## 2. Syntax 
+################################################################################
+
+# Jede Zeile ist ein Befehl. Das erste Wort ist der Name des Befehls, jedes
+# weitere Wort ist ein Argument des Befehls. Wörter sind begrenzt durch
+# Leerzeichen. Da jedes Wort auch ein String ist, sind keine speziellen
+# auszeichnungen wie Anführungs-Zeichen, Klammern oder Backslashes nötig.
+# Selbst wenn Anführungs-Zeichen verwendet werden, denn sie sind ja keine
+# String-Konstruktoren, sondern nur Escape-Zeichen.
+
+set greeting1 Sal 
+set greeting2 ut
+set greeting3 ations
+
+
+# Strichpunkte begrenzen auch Befehle
+set greeting1 Sal; set greeting2 ut; set greeting3 ations 
+
+
+# Das Dollar-Zeichen zeigt eine Variablen-Substitution an.
+set greeting $greeting1$greeting2$greeting3
+
+
+# Eckige-Klammern zeigen Befehls-Substitionen an. Das Ergebnis des Befehls wird an
+# Stelle des Klammern-Ausdrucks eingefügt. Wenn man dem "set" Befehl nur den
+# Namen einer Variablen übergibt, gibt er den Wert der Variablen zurück.
+set greeting $greeting1$greeting2[set greeting3]
+
+
+# Befehls-Substitution sollte eigentlich Script-Substitution heißen, denn ein
+# komplettes Script, und nicht nur ein Befehl, kann zwischen die Eckigen-Klammern
+# geschrieben werden. Der "incr" Befehl erhöht den Wert einer Variable um 1
+# und gibt den neuen Wert der Variable zurück.
+set greeting $greeting[
+	incr i
+	incr i
+	incr i
+]
+
+
+# Der Backslash unterdrück die Bedeutung von Sonderzeichen
+set amount \$16.42
+
+
+# Der Backslash macht bestimmte Zeichen zu Sonderzeichen
+puts lots\nof\n\n\n\n\n\nnewlines
+
+# Ein Wort das in geschweiften Klammern eingeschlossen wurde ist von jeglichen
+# speziellen Interpretationen ausgeschlossen. Eine Ausnahme bilden Backslashes
+# vor geschweiften Klammern, hiermit wird die geschweifte Klammer von der Suche
+# nach der schließenden geschweiften Klammer ausgeschlossen.
+set somevar {
+    Das ist ein literales $ Zeichen, diese geschweifte Klammer \} wird nicht
+    als Ende interpretiert.
+} 
+
+
+# Bei einem Wort das in doppelten Anführungszeichen steht verlieren Leerzeichen
+# ihre spezielle Bedeutung.
+set name Neo
+set greeting "Hallo, $name"
+
+
+#Variablen-Namen können irgend eine Zeichenkette sein.
+set {first name} New
+
+
+# Die Geschweifte-Klammern-Form der Variablen-Substitution kann sehr komplexe
+# Variblen-Namen handhaben.
+set greeting "Hello, ${first name}"
+
+
+# Der "set" Befehl kann immer anstatt einer Variablen-Substition verwendet
+# werden.
+set greeting "Hello, [set {first name}]"
+
+
+# Mit dem Expansions-Operator "{*}" werden Wörter innerhalb eines Wortes wieder
+# individuell als Teile des aktuellen Befehls behandelt.
+set {*}{name Neo}
+
+# Ist Äquivalent zu
+set name Neo
+
+
+# Ein Array ist eine spezielle Varible die also Kontainer für andere Variablen
+# dient.
+set person(name) Neo
+set person(gender) male
+set greeting "Hello, $person(name)"
+
+
+# Ein Namensraum enthält Befehle und Variablen
+namespace eval people {
+    namespace eval person1 {
+        variable name Neo
+    }
+}
+
+
+#Der volle Name einer Variablen beihaltet den/die umschließenden
+# Namensraum/Namensräume begrenzt durch zwei Doppelpunkte.
+set greeting "Hello $people::person1::name"
+```
+
+```tcl
+################################################################################
+## 3. Einige Notizen 
+################################################################################
+
+# Jede weitere Funktion ist über Befehle implementiert. Von nun an kommt keine
+# neue Syntax hinzu. Alles weitere das es über Tcl zu lernen gibt ist das
+# Verhalten individueller Befehle und die bedeutung ihrer Argumente.
+
+
+# Um einen Interpreter zu bekommen mit dem man nichts mehr machen kann, lösche
+# einfach den globalen Namensraum. Das ist nicht sehr sinnvoll, zeigt aber die
+# Natur von Tcl.
+namespace delete ::
+
+
+# Wegen des Verhaltens der Namens-Auflösung ist es sicherer den "variable"
+# Befehl zu verwenden um in einem Namensraum einen Wert zu deklarieren oder
+# zuzuweisen. Wenn eine Variable mit dem namen "name" bereits im globalen
+# Namensraum existiert, bewirkt der "set" Befehl das der globalen Variable ein
+# Wert zugewiesen wird, anstatt eine Variable im lokalen Namensraum zu erzeugen
+namespace eval people {
+    namespace eval person1 {
+        variable name Neo
+    }
+}
+
+
+# Es kann immer der vollständige Name einer Variable verwendet werden, falls
+# gewünscht.
+set people::person1::name Neo
+
+
+
+################################################################################
+## 4. Befehle 
+################################################################################
+
+# Berechnungen werde mit dem "expr" Befehl durchgeführt.
+set a 3
+set b 4
+set c [expr {$a + $b}]
+
+# Since "expr" performs variable substitution on its own, brace the expression
+# to prevent Tcl from performing variable substitution first.  See
+
+# Da der "expr" Befehl eigene Variablen-Substitutionen durchführt, setze den
+# zu berechnenden Ausdruck in Eckige-Klammern. Das hindert Tcl daran Variablen-
+# Substitutionen durchzuführen. Für Details siehe:
+# "http://wiki.tcl.tk/Brace%20your%20#%20expr-essions"
+
+
+# Der "expr" Befehl versteht Variablen- und Befehls-Substitutionen
+set c [expr {$a + [set b]}]
+
+
+# Der "expr" Befehl stellt Mathematische-Funktionen zur Verfügung.
+set c [expr {pow($a,$b)}]
+
+
+# Mathematische Operatoren sind als Befehle auch im Namensraum 
+# ::tcl::mathop verfügbar.
+::tcl::mathop::+ 5 3
+
+# Befehle können aus anderen Namensräumen importiert werden.
+namespace import ::tcl::mathop::+
+set result [+ 5 3]
+
+
+# Neu Befehle werden mit dem "proc" Befehl gebildet.
+proc greet name {
+    return "Hello, $name!"
+}
+
+#Es können mehrere Parameter spezifiziert werden.
+proc greet {greeting name} {
+    return "$greeting, $name!"
+}
+
+
+# Wie bereits erwähnt, geschwungene Klammern erzeugen keinen Code-Block.
+# Jeder Wert, sogar das dritte Argument für den "proc" Befehl ist eine
+# Zeichenkette. Der vorherige Befehl kann daher auch ohne
+# geschwungene Klammern geschrieben werden:
+proc greet greeting\ name return\ \"Hello,\ \$name!
+
+
+
+# Wenn der letzte Parameter der literale Wert "args" ist, sammelt dieser Wert
+# alle übrigen Argumente des Befehls ein wenn dieser aufgerufen wird.
+proc fold {cmd args} {
+    set res 0
+    foreach arg $args {
+        set res [$cmd $res $arg]
+    }
+}
+fold ::tcl::mathop::* 5 3 3 ;# ->  45
+
+
+# Bedingte Ausführung ist auch als Befehl implementiert
+if {3 > 4} {
+    puts {This will never happen}
+} elseif {4 > 4} {
+    puts {This will also never happen}
+} else {
+    puts {This will always happen}
+}
+
+
+# Auch Schleifen sind Befehle. Das erste, zweite und dritte Argument des "for"
+# Befehls wird als mathematischer Ausdruck behandelt.
+for {set i 0} {$i < 10} {incr i} {
+    set res [expr {$res + $i}]
+}
+
+
+# Das erste Argument des "while" Befehls wird auch als mathematischer Ausdruck
+# behandelt.
+set i 0
+while {$i < 10} {
+    incr i 2
+}
+
+
+# Eine Liste ist eine speziell formatierte Zeichenkette. Im einfachsten Fall
+# genügen Leerzeichen als Trennzeichen zwischen den einzelnen Werten.
+set amounts 10\ 33\ 18 
+set amount [lindex $amounts 1]
+
+
+# Geschwungene Klammern und Backslashes können verwendet werden um komplexe
+# Werte in einer Liste zu formatieren. Eine Liste sieht aus wie ein Skript,
+# allerdings verlieren verlieren Zeilenumbrüche und Doppelüunkte ihre 
+# besondere Bedeutung. Diese Funktionalität macht Tcl homoikonisch. Die
+# folgende Liste enhtält drei Elemente.
+set values {
+
+    one\ two
+
+    {three four}
+
+    five\{six
+
+}
+
+
+# Da Listen auch Zeichenketten sind, kann man Zeichenketten-Operationen auf
+# ihnen anwenden. Allerdings mit dem Risiko die Formatierung der Liste zu
+# beschädigen.
+set values {one two three four}
+set values [string map {two \{} $values] ;# $values is no-longer a \
+    properly-formatted listwell-formed list
+
+
+# Der sicherste Weg korrekt formatierte Liste zu erzeugen, ist den "list"
+# Befehl zu verwenden.
+set values [list one \{ three four]
+lappend values { } ;# Ein Leerzeichen als Element der Liste hinzufügen
+
+
+# Mit "eval" können Werte als Skripts evaluiert weden.
+eval {
+    set name Neo
+    set greeting "Hello, $name"
+}
+
+
+# Eine Liste kann immer an "eval" übergeben werden, solange die Liste einen
+# einzigen Befehl entält.
+eval {set name Neo}
+eval [list set greeting "Hello, $name"]
+
+
+# Daher: Wenn "eval" verwendet wird, verwende [list] um den gewünschten Befehl
+# aufzubauen.
+set command {set name}
+lappend command {Archibald Sorbisol}
+eval $command
+
+
+# Es ist ein häufiger Fehler die Listen funktionen beim Aufbauen von Listen
+# nicht zu verwenden.
+set command {set name}
+append command { Archibald Sorbisol}
+eval $command ;# Hier passiert eine Fehler, denn der "set" Befehl hat nun zu \
+    viele Argumente {set name Archibald Sorbisol}
+
+
+# Dieser Fehler kann auch leicht beim "subst" Befehl passieren.
+set replacement {Archibald Sorbisol}
+set command {set name $replacement}
+set command [subst $command] 
+eval $command ;# The same error as before: too many arguments to "set" in \
+    {set name Archibald Sorbisol}
+
+
+# Die korrekte Vorgangsweise ist es den substituierten Wert mit dem "list"
+# Befehl zu formatieren.
+set replacement [list {Archibald Sorbisol}]
+set command {set name $replacement}
+set command [subst $command] 
+eval $command
+
+
+# Der "list" Befehl wird sehr häufig verwendet um Werte zu formatieren die
+# in Tcl Skript Vorlagen substituiert werden. Es gibt dazu viele Beispiele,
+# siehe unterhalb.
+
+
+# Der "apply" Befehl evaluiert eine Zeichenkette als Befehl.
+set cmd {{greeting name} {
+    return "$greeting, $name!"
+}}
+apply $cmd Whaddup Neo
+
+
+# Der "uplevel" Befehl evaluiert ein Skript in einem höher liegenden
+Gültigkeitsbereich.
+proc greet {} {
+	uplevel {puts "$greeting, $name"}
+}
+
+proc set_double {varname value} {
+	if {[string is double $value]} {
+		uplevel [list variable $varname $value]
+	} else {
+		error [list {not a double} $value]
+	}
+}
+
+
+# Der "upvar" Befehl verknüpft eine Variable im aktuellen Gültigkeitsbereich
+# mit einer Variable in einem höher liegenden Gültigkeitsbereich.
+proc set_double {varname value} {
+	if {[string is double $value]} {
+		upvar 1 $varname var
+		set var $value
+	} else {
+		error [list {not a double} $value]
+	}
+}
+
+
+# Werde den eingebauten "while" Befehl los.
+rename ::while {}
+
+
+# Definieren einen neuen "while" Befehl mit hilfe des "proc" Befehls.
+# Ausführlichere Fehler-Behandlung wird dem Leser als Übung überlassen.
+proc while {condition script} {
+    if {[uplevel 1 [list expr $condition]]} {
+        uplevel 1 $script
+        tailcall [namespace which while] $condition $script
+    }
+}
+
+
+# Der "coroutine" Befehl erzeugt einen separaten Call-Stack, zusammen mit einem
+# Befehl um diesem Call-Stack zu verwenden. Der "yield" Befehl unterbricht
+# die Ausführung des aktuellen Call-Stacks.
+proc countdown {} {
+	#send something back to the initial "coroutine" command
+	yield
+
+	set count 3 
+	while {$count > 1} {
+		yield [incr count -1]
+	}
+	return 0
+}
+coroutine countdown1 countdown
+coroutine countdown2 countdown
+puts [countdown 1] ;# -> 2 
+puts [countdown 2] ;# -> 2 
+puts [countdown 1] ;# -> 1 
+puts [countdown 1] ;# -> 0 
+puts [coundown 1] ;# -> invalid command name "countdown1"
+puts [countdown 2] ;# -> 1 
+
+
+```
+
+## Referenzen
+
+[Official Tcl Documentation](http://www.tcl.tk/man/tcl/)
+
+[Tcl Wiki](http://wiki.tcl.tk)
+
+[Tcl Subreddit](http://www.reddit.com/r/Tcl)
-- 
cgit v1.2.3


From 2f1d29ce8064fe3f920f9d1429b9e5c9c228f5d4 Mon Sep 17 00:00:00 2001
From: Martin Schimandl <martin.schimandl@gmail.com>
Date: Sat, 10 Oct 2015 17:50:55 +0200
Subject: First version of german translation of Lua

---
 de-de/lua-de.html.markdown | 426 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 426 insertions(+)
 create mode 100644 de-de/lua-de.html.markdown

(limited to 'de-de')

diff --git a/de-de/lua-de.html.markdown b/de-de/lua-de.html.markdown
new file mode 100644
index 00000000..875629ad
--- /dev/null
+++ b/de-de/lua-de.html.markdown
@@ -0,0 +1,426 @@
+---
+language: Lua
+contributors:
+    - ["Tyler Neylon", "http://tylerneylon.com/"]
+translators:
+    - ["Martin Schimandl", "https://github.com/Git-Jiro"]
+filename: learnlua-de.lua
+---
+
+```lua
+-- Zwei Gedankenstriche starten ein einzeiliges Kommentar.
+
+--[[
+     Fügt man zwei '[' und ']' hinzu,
+     erzeugt man ein mehrzeiliges Kommentar.
+--]]
+--------------------------------------------------------------------------------
+-- 1. Variablen und Fluß-Kontrolle.
+--------------------------------------------------------------------------------
+
+num = 42  -- All Nummern sind vom Typ: Double.
+-- Werd nicht nervös, 64-Bit Double haben 52 Bits zum Speichern von exakten
+-- Ganzzahlen; Maschinen-Genauigkeit ist kein Problem für Ganzzahlen kleiner als 
+-- 52 Bit.
+
+s = 'walternate'  -- Unveränderliche Zeichenkette wie by Python.
+t = "Doppelte Anführungszeichen sind auch OK"
+u = [[ Doppelte eckige Klammern
+       beginnen und beenden
+       mehrzeilige Zeichenketten.]]
+t = nil  -- Undefineren von t; Lua hat Garbage Collection.
+
+-- Blöcke werden durch Schlüsselwörter markiert wie do/end:
+while num < 50 do
+  num = num + 1  -- Keine Operatoren wie ++ oder +=
+end
+
+-- If Bedingungen:
+if num > 40 then
+  print('over 40')
+elseif s ~= 'walternate' then  -- ~= ist ungleich
+  -- Gleichheits-Check == wie bei Python; OK für Zeichenketten.
+  io.write('not over 40\n')  -- Standard ist stdout.
+else
+  -- Variablen sind standardmäßig global.
+  thisIsGlobal = 5  -- Camel case ist üblich.
+
+  -- So macht man eine Variable lokal:
+  local line = io.read()  -- Lies die nächste Zeile von stdin.
+
+  -- Zeichenketten zusammenführen mit dem .. Operator:
+  print('Winter is coming, ' .. line)
+end
+
+-- Undefinierte Variablen geben nil zurück.
+-- Das ist kein Fehler:
+foo = anUnknownVariable  -- Nun ist foo = nil.
+
+aBoolValue = false
+
+-- Nur nil und false sind unwahr; 0 and '' sind wahr!
+if not aBoolValue then print('was false') end
+
+-- 'or' und 'and' sind "kurz-geschlossen". Das ist so ähnlich wie der a?b:c
+-- operator in C/js:
+-- in C/js:
+ans = aBoolValue and 'yes' or 'no'  --> 'no'
+
+karlSum = 0
+for i = 1, 100 do  -- Ein Bereich inkludiert beide Enden.
+  karlSum = karlSum + i
+end
+
+-- Verwende "100, 1, -1" als Breich für Countdowns:
+fredSum = 0
+for j = 100, 1, -1 do fredSum = fredSum + j end
+
+-- Im Allgemeinen besteht ein Bereich aus: Anfang, Ende, [, Schrittweite].
+
+-- Ein anderes Schleifen-Konstrukt:
+repeat
+  print('Der Weg der Zukunft')
+  num = num - 1
+until num == 0
+
+--------------------------------------------------------------------------------
+-- 2. Funktionen.
+--------------------------------------------------------------------------------
+
+function fib(n)
+  if n < 2 then return n end
+  return fib(n - 2) + fib(n - 1)
+end
+
+-- Closures und anonyme Funktionen sind ok:
+function adder(x)
+  -- Die zurückgegbe Funktion wird erzeugt wenn addr aufgerufen wird und merkt
+  -- sich den Wert von x:
+  return function (y) return x + y end
+end
+a1 = adder(9)
+a2 = adder(36)
+print(a1(16))  --> 25
+print(a2(64))  --> 100
+
+-- Rückgabewerte. Funktions-Aufrufe und Zuweisungen funktionieren all mit
+-- Listen die nicht immer gleich lang sein müssen. Überzählige Empfanger
+-- bekommen nil; überzählige Sende werden entfernt.
+
+x, y, z = 1, 2, 3, 4
+-- Nun ist x = 1, y = 2, z = 3, und 4 wird entfernt.
+
+function bar(a, b, c)
+  print(a, b, c)
+  return 4, 8, 15, 16, 23, 42
+end
+
+x, y = bar('zaphod')  --> prints "zaphod  nil nil"
+-- Nun ist x = 4, y = 8, die Werte 15..42 werden entfernt.
+
+-- Funktionen sind erste Klasse, und können lokal oder global sein.
+-- Das ist alles das Gleiche:
+function f(x) return x * x end
+f = function (x) return x * x end
+
+-- Und diese auch:
+local function g(x) return math.sin(x) end
+local g = function(x) return math.sin(x) end
+-- Äquivalent zu local function g(x)..., außer das Referenzen auf g im
+-- Funktions-Körper nicht wie erwartet funktionieren.
+local g; g  = function (x) return math.sin(x) end
+-- Die 'local g' Deklaration macht G-Selbst-Referenzen OK.
+
+-- Nebenbei gesagt, Trigonometrie-Funktionen verwenden Radianten.
+
+-- Funktionsaufrufe mit nur einem Zeichenketten-Parameter brauch keine runden
+-- Klammern.
+print 'hello'  -- Works fine.
+
+-- Funktionsaufruge mit einem Tabellen-Parameter brauchen auch keine runden
+-- Klammern. Mehr zu Tabellen später.
+print {} -- Works fine too.
+
+--------------------------------------------------------------------------------
+-- 3. Tabellen.
+--------------------------------------------------------------------------------
+
+-- Tabellen sind die einzige zusammengesetzte Struktur in Lua. Sie sind
+-- assoziative Arrays. Sie sind so ähnlich wie PHP arrays oder JavaScript
+-- Objekte. Sie sind Hash-Lookup-Dictionaries die auch als Listen verwendet
+-- werden können.
+
+-- Verwenden von Tabellen als Dictionaries oder Maps:
+-- Using tables as dictionaries / maps:
+
+-- Dict lieterale haben standardmäßig Zeichenketten-Schlüssel:
+t = {key1 = 'value1', key2 = false}
+
+-- Zeichenketten-Schlüssel verwenden ein JavaScript ähnliche Punkt-Notation.
+print(t.key1)  -- Ausgabe 'value1'.
+t.newKey = {}  -- Neues Schlüssel/Wert Paar hinzufügen.
+t.key2 = nil   -- key2 aus der Tabelle entfernen.
+
+-- Literale notation für jeden (nicht-nil) Wert als Schlüssel:
+u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}
+print(u[6.28])  -- ausgabe "tau"
+
+-- Schlüssel-Vergleiche funktionieren per Wert für Nummern und Zeichenketten,
+-- aber über die Identität bei Tabellen.
+a = u['@!#']  -- Nun ist a = 'qbert'.
+b = u[{}]     -- Wir würden 1729 erwarten, aber es ist nil:
+-- b = nil weil der Lookup fehlschlägt. Er schlägt Fehl, weil der Schlüssel
+-- den wir verwendet haben nicht das gleiche Objekt ist das wir verwendet
+-- haben um den original Wert zu speichern. Zahlen und Zeichnkette sind daher
+-- die praktischeren Schlüssel.
+
+-- Eine Funktion mit nur einem Tabellen-Parameter benötigt keine Klammern.
+function h(x) print(x.key1) end
+h{key1 = 'Sonmi~451'}  -- Prints 'Sonmi~451'.
+
+for key, val in pairs(u) do  -- Tabellen-Interation.
+  print(key, val)
+end
+
+-- _G ist eine spezielle Tabelle die alles Globale enthält.
+print(_G['_G'] == _G)  -- Ausgabe 'true'.
+
+-- Verwenden von Tabellen als Listen/Arrays:
+
+-- Listen-Literale verwenden implizit Ganzzahlen als Schlüssel:
+v = {'value1', 'value2', 1.21, 'gigawatts'}
+for i = 1, #v do  -- #v ist die Größe von v für Listen.
+  print(v[i])  -- Indices beginnen mit 1 !! SO VERRÜCKT!
+end
+-- Eine 'Liste' ist kein echter Typ. v ist nur eine Tabelle mit fortlaufenden
+-- Ganzzahlen als Schlüssel, behandelt wie eine Liste.
+
+--------------------------------------------------------------------------------
+-- 3.1 Metatabellen und Metamethoden
+--------------------------------------------------------------------------------
+
+-- Eine Tabelle kann eine Metatabelle haben die ihr so etwas wie
+-- Tabellen-Operator-Überladungs-Verhalten verleiht. Später sehen wir wie
+-- Metatabellen js-prototypen artiges Verhalten unterstützen.
+
+f1 = {a = 1, b = 2}  -- Repräsentiert den Bruch a/b.
+f2 = {a = 2, b = 3}
+
+-- Dies würde Fehlschlagen:
+-- s = f1 + f2
+
+metafraction = {}
+function metafraction.__add(f1, f2)
+  local sum = {}
+  sum.b = f1.b * f2.b
+  sum.a = f1.a * f2.b + f2.a * f1.b
+  return sum
+end
+
+setmetatable(f1, metafraction)
+setmetatable(f2, metafraction)
+
+s = f1 + f2  -- Rufe __add(f1, f2) vom der Metatabelle von f1 auf
+
+-- f1 und f2 haben keine Schlüssel für ihrer Metatabellen, anders als bei js
+-- Prototypen. Daher muss mithilfe von getmetatable(f1) darauf zugegriffen
+-- werden. Eine Metatabelle ist wie eine normale Tabelle mit Schlüsseln die
+-- Lua bekannt sind, so wie __add.
+
+
+-- Die nächste Zeile schlägt fehl weil s keine Metatabelle hat:
+-- t = s + s
+-- Mihilfe von Klassen ähnlichen Mustern kann das gelöst werden.
+-- Siehe weiter unten.
+
+-- Ein __index einer Metatabelle überlädt Punkt-Lookups:
+defaultFavs = {animal = 'gru', food = 'donuts'}
+myFavs = {food = 'pizza'}
+setmetatable(myFavs, {__index = defaultFavs})
+eatenBy = myFavs.animal  -- Funktioniert dank Metatabelle!
+
+--------------------------------------------------------------------------------
+-- Direkte Tabellen-Lookups die fehlschlagen werden mithilfe von __index der
+-- Metatabelle wiederholt. Das geschieht rekursiv.
+
+-- __index kann auch eine Funktion mit der Form function(tbl, key) sein.
+-- Damit kann man Lookups weiter anpassen.
+
+-- Werte wie __index,add, .. werden Metamethoden genannt.
+-- Vollständige Liste aller Metamethoden.
+
+-- __add(a, b)                     für a + b
+-- __sub(a, b)                     für a - b
+-- __mul(a, b)                     für a * b
+-- __div(a, b)                     für a / b
+-- __mod(a, b)                     für a % b
+-- __pow(a, b)                     für a ^ b
+-- __unm(a)                        für -a
+-- __concat(a, b)                  für a .. b
+-- __len(a)                        für #a
+-- __eq(a, b)                      für a == b
+-- __lt(a, b)                      für a < b
+-- __le(a, b)                      für a <= b
+-- __index(a, b)  <fn or a table>  für a.b
+-- __newindex(a, b, c)             für a.b = c
+-- __call(a, ...)                  für a(...)
+
+--------------------------------------------------------------------------------
+-- 3.2 Klassen-Artihe Tabellen und vererbung.
+--------------------------------------------------------------------------------
+
+-- Klassen sind in Lua nicht eingebaut; es gibt verschieden Wege sie mithilfe
+-- von Tabellen und Metatabellen zu erzeugen.
+
+-- Die Erklärund des Beispiels erfolgt unterhalb.
+
+Dog = {}                                   -- 1.
+
+function Dog:new()                         -- 2.
+  local newObj = {sound = 'woof'}          -- 3.
+  self.__index = self                      -- 4.
+  return setmetatable(newObj, self)        -- 5.
+end
+
+function Dog:makeSound()                   -- 6.
+  print('I say ' .. self.sound)
+end
+
+mrDog = Dog:new()                          -- 7.
+mrDog:makeSound()  -- 'I say woof'         -- 8.
+
+-- 1. Dog verhält sich wie eine Klasse; Ist aber eine Tabelle.
+-- 2. "function tablename:fn(...)" ist das gleiche wie
+--    "function tablename.fn(self, ...)", Der : fügt nur ein Argument namens
+--    self hinzu. Siehe 7 & 8 um zu sehen wie self seinen Wert bekommt.
+-- 3. newObj wird eine Instanz von Dog.
+-- 4. "self" ist die zu Instanzierende Klasse. Meisterns ist self = Doh, aber
+--    dies kann durch Vererbung geändert werden. newObj bekommt die Funktionen
+--    von self wenn wir die Metatabelle von newObj und __index von self auf
+--    self setzen.
+-- 5. Zur Erinnerung: setmetatable gibt sein erstes Argument zurück.
+-- 6. Der Doppelpunkt funktioniert wie bei 2, aber dieses Mal erwarten wir das
+--    self eine Instanz ist und keine Klasse.
+-- 7. Das Selbe wie Dog.new(Dog), also self = Dog in new().
+-- 8. Das Selbe wie mrDog.makeSound(mrDog); self = mrDog.
+
+--------------------------------------------------------------------------------
+
+-- Vererbungs-Beispiel:
+
+LoudDog = Dog:new()                           -- 1.
+
+function LoudDog:makeSound()
+  local s = self.sound .. ' '                 -- 2.
+  print(s .. s .. s)
+end
+
+seymour = LoudDog:new()                       -- 3.
+seymour:makeSound()  -- 'woof woof woof'      -- 4.
+
+--------------------------------------------------------------------------------
+-- 1. LoudDog bekommt die Methoden und Variablen von Dog.
+-- 2. self hat einen 'sound' Schlüssel von new(), siehe 3.
+-- 3. Das Gleiche wie "LoudDog.new(LoudDog)", und umgewandelt zu "Dog.new(LoudDog)"
+--    denn LoudDog hat keinen 'new' Schlüssel, aber "__index = Dog" steht in der
+--    Metatabelle.
+--    Ergebnis: Die Metatabelle von seymour ist LoudDog und "LoudDog.__index = Dog".
+--    Daher ist seymour.key gleich seymour.key, LoudDog.key, Dog.key, je nacdem
+--    welche Tabelle als erstes einen passenden Schlüssel hat.
+-- 4. Der 'makeSound' Schlüssel wird in LoudDog gefunden: Das ist das Gleiche
+--    wie "LoudDog.makeSound(seymour)".
+
+-- Wenn nötig, sieht new() eine Sub-Klasse genau so aus wie new() der
+-- Basis-Klasse:
+function LoudDog:new()
+  local newObj = {}
+  -- set up newObj
+  self.__index = self
+  return setmetatable(newObj, self)
+end
+
+--------------------------------------------------------------------------------
+-- 4. Module.
+--------------------------------------------------------------------------------
+
+
+--[[ Dieser Abschnitt ist auskommentiert damit der Rest des Skripts lauffähig
+--   bleibt.
+```
+
+```lua
+-- Angenommen mod.lua sieht so aus:
+local M = {}
+
+local function sayMyName()
+  print('Hrunkner')
+end
+
+function M.sayHello()
+  print('Why hello there')
+  sayMyName()
+end
+
+return M
+
+-- Eine andere Datei könnte die Funktionen in mod.lua so verwenden:
+local mod = require('mod')  -- Führe mod.lua aus.
+
+-- require ist der Standard-Weg um Module zu inkludieren.
+-- require verhält sich wie: (Wenn nicht gecached wird; siehe später)
+local mod = (function ()
+  <Inhalt von mod.lua>
+end)()
+-- Es ist als ob mod.lua eine Funktion wäre, sodass lokale Variablen in
+-- mod.lua ausserhalb unsichtbar sind.
+
+-- Das funktioniert weil mod hier ist M in mod.lua:
+mod.sayHello()  -- Says hello to Hrunkner.
+
+-- Das ist Falsch: syMyName existiert nur in mod.lua:
+mod.sayMyName()  -- error
+
+-- Der Rückgabe-Wert von require wird zwischengespeichert. Sodass module nur
+-- einmal abgearbeitet werden, auch wenn sie mit require öfters eingebunden
+-- werden.
+
+-- Nehmen wir an mod2.lua enthält "print('Hi!')".
+local a = require('mod2')  -- Ausgabe Hi!
+local b = require('mod2')  -- Keine Ausgabe; a=b.
+
+-- dofile ist wie require aber ohne Zwischenspeichern.
+dofile('mod2')  --> Hi!
+dofile('mod2')  --> Hi! (läuft nochmal, nicht wie require)
+
+-- loadfile ladet eine lua Datei aber die Datei wird noch nicht abgearbeitet.
+f = loadfile('mod2')  -- Sobald f() aufgerufen wird läuft mod2.lua.
+
+-- loadstring ist loadfile für Zeichenketten
+g = loadstring('print(343)')  -- Gibt eine Funktion zurück..
+g()  -- Ausgabe 343; Es kam keine Ausgabe bevor hier.
+
+--]]
+
+```
+## Referenzen
+
+Ich war so begeistert Lua zu lernen, um damit Spiele mit <a href="http://love2d.org/">Love 2D game engine</a> zu programmieren.
+
+Ich habe angefangen mit <a href="http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/">BlackBulletIV's Lua for programmers</a>.
+Danach habe ich das offizielle Lua Buch gelesen: <a href="http://www.lua.org/pil/contents.html">Programming in Lua</a>
+
+Es kann auch hilfreich sein hier vorbeizuschauen: <a href="http://lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Lua short
+reference</a>
+
+Wichtige Themen die hier nicht angesprochen wurden, die Standard-Bibliotheken:
+
+* <a href="http://lua-users.org/wiki/StringLibraryTutorial">string library</a>
+* <a href="http://lua-users.org/wiki/TableLibraryTutorial">table library</a>
+* <a href="http://lua-users.org/wiki/MathLibraryTutorial">math library</a>
+* <a href="http://lua-users.org/wiki/IoLibraryTutorial">io library</a>
+* <a href="http://lua-users.org/wiki/OsLibraryTutorial">os library</a>
+
+Übrigends, die gesamte Datei ist gültiges Lua. Speichere es als learn.lua und
+starte es als "lua learn.lua" !
+
+Die Erstfassung ist von tylerneylon.com, und ist auch hier verfügbar: <a href="https://gist.github.com/tylerneylon/5853042">github gist</a>. Viel Spaß mit Lua!
-- 
cgit v1.2.3


From c5b6113677e6d1a596d7e5ca53c642482412cacd Mon Sep 17 00:00:00 2001
From: Martin Schimandl <martin.schimandl@gmail.com>
Date: Sun, 11 Oct 2015 08:38:45 +0200
Subject: Improve grammar and correct spelling errors.

---
 de-de/lua-de.html.markdown | 91 +++++++++++++++++++++++-----------------------
 1 file changed, 45 insertions(+), 46 deletions(-)

(limited to 'de-de')

diff --git a/de-de/lua-de.html.markdown b/de-de/lua-de.html.markdown
index 875629ad..eccfcf1e 100644
--- a/de-de/lua-de.html.markdown
+++ b/de-de/lua-de.html.markdown
@@ -12,33 +12,33 @@ filename: learnlua-de.lua
 
 --[[
      Fügt man zwei '[' und ']' hinzu,
-     erzeugt man ein mehrzeiliges Kommentar.
+     erzeugt man einen mehrzeiligen Kommentar.
 --]]
 --------------------------------------------------------------------------------
 -- 1. Variablen und Fluß-Kontrolle.
 --------------------------------------------------------------------------------
 
-num = 42  -- All Nummern sind vom Typ: Double.
+num = 42  -- Alle Nummern sind vom Typ: Double.
 -- Werd nicht nervös, 64-Bit Double haben 52 Bits zum Speichern von exakten
 -- Ganzzahlen; Maschinen-Genauigkeit ist kein Problem für Ganzzahlen kleiner als 
 -- 52 Bit.
 
-s = 'walternate'  -- Unveränderliche Zeichenkette wie by Python.
+s = 'walternate'  -- Zeichenketten sind unveränderlich, wie bei Python.
 t = "Doppelte Anführungszeichen sind auch OK"
 u = [[ Doppelte eckige Klammern
        beginnen und beenden
        mehrzeilige Zeichenketten.]]
-t = nil  -- Undefineren von t; Lua hat Garbage Collection.
+t = nil  -- Undefineren von t; Lua hat einen Garbage Collection.
 
--- Blöcke werden durch Schlüsselwörter markiert wie do/end:
+-- Blöcke werden durch Schlüsselwörter wie do/end markiert:
 while num < 50 do
-  num = num + 1  -- Keine Operatoren wie ++ oder +=
+  num = num + 1  -- Es gibt Keine Operatoren wie ++ oder +=
 end
 
 -- If Bedingungen:
 if num > 40 then
   print('over 40')
-elseif s ~= 'walternate' then  -- ~= ist ungleich
+elseif s ~= 'walternate' then  -- ~= bedeutet ungleich
   -- Gleichheits-Check == wie bei Python; OK für Zeichenketten.
   io.write('not over 40\n')  -- Standard ist stdout.
 else
@@ -94,7 +94,7 @@ end
 
 -- Closures und anonyme Funktionen sind ok:
 function adder(x)
-  -- Die zurückgegbe Funktion wird erzeugt wenn addr aufgerufen wird und merkt
+  -- Die zurückgegebene Funktion wird erzeugt wenn addr aufgerufen wird und merkt
   -- sich den Wert von x:
   return function (y) return x + y end
 end
@@ -103,12 +103,12 @@ a2 = adder(36)
 print(a1(16))  --> 25
 print(a2(64))  --> 100
 
--- Rückgabewerte. Funktions-Aufrufe und Zuweisungen funktionieren all mit
--- Listen die nicht immer gleich lang sein müssen. Überzählige Empfanger
--- bekommen nil; überzählige Sende werden entfernt.
+-- Rückgabewerte, Funktions-Aufrufe und Zuweisungen funktionieren alle mit
+-- Listen die nicht immer gleich lang sein müssen. Überzählige Empfänger
+-- bekommen nil; überzählige Sender werden ignoriert.
 
 x, y, z = 1, 2, 3, 4
--- Nun ist x = 1, y = 2, z = 3, und 4 wird entfernt.
+-- Nun ist x = 1, y = 2, z = 3, und 4 wird ignoriert.
 
 function bar(a, b, c)
   print(a, b, c)
@@ -116,30 +116,30 @@ function bar(a, b, c)
 end
 
 x, y = bar('zaphod')  --> prints "zaphod  nil nil"
--- Nun ist x = 4, y = 8, die Werte 15..42 werden entfernt.
+-- Nun ist x = 4, y = 8, die Werte 15..42 werden ignoriert.
 
 -- Funktionen sind erste Klasse, und können lokal oder global sein.
 -- Das ist alles das Gleiche:
 function f(x) return x * x end
 f = function (x) return x * x end
 
--- Und diese auch:
+-- Das auch:
 local function g(x) return math.sin(x) end
 local g = function(x) return math.sin(x) end
 -- Äquivalent zu local function g(x)..., außer das Referenzen auf g im
 -- Funktions-Körper nicht wie erwartet funktionieren.
 local g; g  = function (x) return math.sin(x) end
--- Die 'local g' Deklaration macht G-Selbst-Referenzen OK.
+-- Die Deklaration 'local g' macht Selbst-Referenzen auf g OK.
 
 -- Nebenbei gesagt, Trigonometrie-Funktionen verwenden Radianten.
 
 -- Funktionsaufrufe mit nur einem Zeichenketten-Parameter brauch keine runden
 -- Klammern.
-print 'hello'  -- Works fine.
+print 'hello'  -- Funktioniert wunderbar.
 
--- Funktionsaufruge mit einem Tabellen-Parameter brauchen auch keine runden
--- Klammern. Mehr zu Tabellen später.
-print {} -- Works fine too.
+-- Funktionsaufrufe mit einem Tabellen-Parameter brauchen auch keine runden
+-- Klammern. Mehr zu Tabellen kommt später.
+print {} -- Funktioniert auch wunderbar.
 
 --------------------------------------------------------------------------------
 -- 3. Tabellen.
@@ -151,19 +151,18 @@ print {} -- Works fine too.
 -- werden können.
 
 -- Verwenden von Tabellen als Dictionaries oder Maps:
--- Using tables as dictionaries / maps:
 
--- Dict lieterale haben standardmäßig Zeichenketten-Schlüssel:
+-- Dict-Literale haben standardmäßig Zeichenketten als Schlüssel:
 t = {key1 = 'value1', key2 = false}
 
--- Zeichenketten-Schlüssel verwenden ein JavaScript ähnliche Punkt-Notation.
+-- Zeichenketten-Schlüssel verwenden eine JavaScript ähnliche Punkt-Notation.
 print(t.key1)  -- Ausgabe 'value1'.
-t.newKey = {}  -- Neues Schlüssel/Wert Paar hinzufügen.
+t.newKey = {}  -- Neues Schlüssel/Wert-Paar hinzufügen.
 t.key2 = nil   -- key2 aus der Tabelle entfernen.
 
 -- Literale notation für jeden (nicht-nil) Wert als Schlüssel:
 u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'}
-print(u[6.28])  -- ausgabe "tau"
+print(u[6.28])  -- Ausgabe "tau"
 
 -- Schlüssel-Vergleiche funktionieren per Wert für Nummern und Zeichenketten,
 -- aber über die Identität bei Tabellen.
@@ -176,9 +175,9 @@ b = u[{}]     -- Wir würden 1729 erwarten, aber es ist nil:
 
 -- Eine Funktion mit nur einem Tabellen-Parameter benötigt keine Klammern.
 function h(x) print(x.key1) end
-h{key1 = 'Sonmi~451'}  -- Prints 'Sonmi~451'.
+h{key1 = 'Sonmi~451'}  -- Ausgabe 'Sonmi~451'.
 
-for key, val in pairs(u) do  -- Tabellen-Interation.
+for key, val in pairs(u) do  -- Tabellen-Iteration.
   print(key, val)
 end
 
@@ -193,14 +192,14 @@ for i = 1, #v do  -- #v ist die Größe von v für Listen.
   print(v[i])  -- Indices beginnen mit 1 !! SO VERRÜCKT!
 end
 -- Eine 'Liste' ist kein echter Typ. v ist nur eine Tabelle mit fortlaufenden
--- Ganzzahlen als Schlüssel, behandelt wie eine Liste.
+-- Ganzzahlen als Schlüssel, die behandelt wird wie eine Liste.
 
 --------------------------------------------------------------------------------
 -- 3.1 Metatabellen und Metamethoden
 --------------------------------------------------------------------------------
 
--- Eine Tabelle kann eine Metatabelle haben die ihr so etwas wie
--- Tabellen-Operator-Überladungs-Verhalten verleiht. Später sehen wir wie
+-- Eine Tabelle kann eine Metatabelle haben. Diese verleiht ihr so etwas wie
+-- Tabellen-Operator-Überladungs-Verhalten. Später sehen wir wie
 -- Metatabellen js-prototypen artiges Verhalten unterstützen.
 
 f1 = {a = 1, b = 2}  -- Repräsentiert den Bruch a/b.
@@ -220,9 +219,9 @@ end
 setmetatable(f1, metafraction)
 setmetatable(f2, metafraction)
 
-s = f1 + f2  -- Rufe __add(f1, f2) vom der Metatabelle von f1 auf
+s = f1 + f2  -- Rufe __add(f1, f2) vom der Metatabelle von f1 auf.
 
--- f1 und f2 haben keine Schlüssel für ihrer Metatabellen, anders als bei js
+-- f1 und f2 haben keine Schlüssel für ihre Metatabellen, anders als bei js
 -- Prototypen. Daher muss mithilfe von getmetatable(f1) darauf zugegriffen
 -- werden. Eine Metatabelle ist wie eine normale Tabelle mit Schlüsseln die
 -- Lua bekannt sind, so wie __add.
@@ -247,7 +246,7 @@ eatenBy = myFavs.animal  -- Funktioniert dank Metatabelle!
 -- Damit kann man Lookups weiter anpassen.
 
 -- Werte wie __index,add, .. werden Metamethoden genannt.
--- Vollständige Liste aller Metamethoden.
+-- HIer eine vollständige Liste aller Metamethoden.
 
 -- __add(a, b)                     für a + b
 -- __sub(a, b)                     für a - b
@@ -266,10 +265,10 @@ eatenBy = myFavs.animal  -- Funktioniert dank Metatabelle!
 -- __call(a, ...)                  für a(...)
 
 --------------------------------------------------------------------------------
--- 3.2 Klassen-Artihe Tabellen und vererbung.
+-- 3.2 Klassen-Artige Tabellen und Vererbung.
 --------------------------------------------------------------------------------
 
--- Klassen sind in Lua nicht eingebaut; es gibt verschieden Wege sie mithilfe
+-- Klassen sind in Lua nicht eingebaut. Es gibt verschieden Wege sie mithilfe
 -- von Tabellen und Metatabellen zu erzeugen.
 
 -- Die Erklärund des Beispiels erfolgt unterhalb.
@@ -294,7 +293,7 @@ mrDog:makeSound()  -- 'I say woof'         -- 8.
 --    "function tablename.fn(self, ...)", Der : fügt nur ein Argument namens
 --    self hinzu. Siehe 7 & 8 um zu sehen wie self seinen Wert bekommt.
 -- 3. newObj wird eine Instanz von Dog.
--- 4. "self" ist die zu Instanzierende Klasse. Meisterns ist self = Doh, aber
+-- 4. "self" ist die zu Instanzierende Klasse. Meistern ist self = Dog, aber
 --    dies kann durch Vererbung geändert werden. newObj bekommt die Funktionen
 --    von self wenn wir die Metatabelle von newObj und __index von self auf
 --    self setzen.
@@ -325,12 +324,12 @@ seymour:makeSound()  -- 'woof woof woof'      -- 4.
 --    denn LoudDog hat keinen 'new' Schlüssel, aber "__index = Dog" steht in der
 --    Metatabelle.
 --    Ergebnis: Die Metatabelle von seymour ist LoudDog und "LoudDog.__index = Dog".
---    Daher ist seymour.key gleich seymour.key, LoudDog.key, Dog.key, je nacdem
+--    Daher ist seymour.key gleich seymour.key, LoudDog.key, Dog.key, je nachdem
 --    welche Tabelle als erstes einen passenden Schlüssel hat.
 -- 4. Der 'makeSound' Schlüssel wird in LoudDog gefunden: Das ist das Gleiche
 --    wie "LoudDog.makeSound(seymour)".
 
--- Wenn nötig, sieht new() eine Sub-Klasse genau so aus wie new() der
+-- Wenn nötig, sieht new() einer Sub-Klasse genau so aus wie new() der
 -- Basis-Klasse:
 function LoudDog:new()
   local newObj = {}
@@ -374,13 +373,13 @@ end)()
 -- Es ist als ob mod.lua eine Funktion wäre, sodass lokale Variablen in
 -- mod.lua ausserhalb unsichtbar sind.
 
--- Das funktioniert weil mod hier ist M in mod.lua:
+-- Das funktioniert weil mod hier das Gleiche wie M in mod.lua ist:
 mod.sayHello()  -- Says hello to Hrunkner.
 
--- Das ist Falsch: syMyName existiert nur in mod.lua:
-mod.sayMyName()  -- error
+-- Das ist Falsch: sayMyName existiert nur in mod.lua:
+mod.sayMyName()  -- Fehler
 
--- Der Rückgabe-Wert von require wird zwischengespeichert. Sodass module nur
+-- Der Rückgabe-Wert von require wird zwischengespeichert. Sodass Module nur
 -- einmal abgearbeitet werden, auch wenn sie mit require öfters eingebunden
 -- werden.
 
@@ -397,14 +396,14 @@ f = loadfile('mod2')  -- Sobald f() aufgerufen wird läuft mod2.lua.
 
 -- loadstring ist loadfile für Zeichenketten
 g = loadstring('print(343)')  -- Gibt eine Funktion zurück..
-g()  -- Ausgabe 343; Es kam keine Ausgabe bevor hier.
+g()  -- Ausgabe 343; Vorher kam keine Ausgabe.
 
 --]]
 
 ```
 ## Referenzen
 
-Ich war so begeistert Lua zu lernen, um damit Spiele mit <a href="http://love2d.org/">Love 2D game engine</a> zu programmieren.
+Ich war so begeistert Lua zu lernen, damit ich Spiele mit <a href="http://love2d.org/">Love 2D game engine</a> programmieren konnte.
 
 Ich habe angefangen mit <a href="http://nova-fusion.com/2012/08/27/lua-for-programmers-part-1/">BlackBulletIV's Lua for programmers</a>.
 Danach habe ich das offizielle Lua Buch gelesen: <a href="http://www.lua.org/pil/contents.html">Programming in Lua</a>
@@ -412,7 +411,7 @@ Danach habe ich das offizielle Lua Buch gelesen: <a href="http://www.lua.org/pil
 Es kann auch hilfreich sein hier vorbeizuschauen: <a href="http://lua-users.org/files/wiki_insecure/users/thomasl/luarefv51.pdf">Lua short
 reference</a>
 
-Wichtige Themen die hier nicht angesprochen wurden, die Standard-Bibliotheken:
+Wichtige Themen die hier nicht angesprochen wurden; die Standard-Bibliotheken:
 
 * <a href="http://lua-users.org/wiki/StringLibraryTutorial">string library</a>
 * <a href="http://lua-users.org/wiki/TableLibraryTutorial">table library</a>
@@ -420,7 +419,7 @@ Wichtige Themen die hier nicht angesprochen wurden, die Standard-Bibliotheken:
 * <a href="http://lua-users.org/wiki/IoLibraryTutorial">io library</a>
 * <a href="http://lua-users.org/wiki/OsLibraryTutorial">os library</a>
 
-Übrigends, die gesamte Datei ist gültiges Lua. Speichere es als learn.lua und
-starte es als "lua learn.lua" !
+Übrigends, die gesamte Datei ist gültiges Lua. Speichere sie als learn.lua und
+starte sie als "lua learn.lua" !
 
 Die Erstfassung ist von tylerneylon.com, und ist auch hier verfügbar: <a href="https://gist.github.com/tylerneylon/5853042">github gist</a>. Viel Spaß mit Lua!
-- 
cgit v1.2.3


From ac474904b1d49a3d2372a9283a6b7e7bf5bc7ac0 Mon Sep 17 00:00:00 2001
From: meinkej <jerome.meinke@googlemail.com>
Date: Fri, 16 Oct 2015 11:10:26 +0100
Subject: [hack/de] Translation to German of the article about Hack

---
 de-de/hack-de.html.markdown | 320 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 320 insertions(+)
 create mode 100644 de-de/hack-de.html.markdown

(limited to 'de-de')

diff --git a/de-de/hack-de.html.markdown b/de-de/hack-de.html.markdown
new file mode 100644
index 00000000..330d0b9b
--- /dev/null
+++ b/de-de/hack-de.html.markdown
@@ -0,0 +1,320 @@
+---
+language: Hack
+contributors:
+    - ["Stephen Holdaway", "https://github.com/stecman"]
+    - ["David Lima", "https://github.com/davelima"]
+    - ["Jerome Meinke", "https://github.com/jmeinke"]
+filename: learnhack.hh
+---
+
+Hack ist eine von Facebook neu entwickelte Programmiersprache auf Basis von PHP.
+Sie wird von der HipHop Virtual Machine (HHVM) ausgeführt. Die HHVM kann
+aufgrund der Ähnlichkeit der Programmiersprachen nicht nur Hack, sondern auch
+PHP-Code ausführen. Der wesentliche Unterschied zu PHP besteht in der statischen
+Typisierung der Sprache, die eine wesentlich höhere Performance erlaubt.
+
+
+Hier werden nur Hack-spezifische Eigenschaften beschrieben. Details über PHP's
+Syntax findet man im [PHP Artikel](http://learnxinyminutes.com/docs/php/) dieser
+Seite.
+
+```php
+<?hh
+
+// Hack-Syntax ist nur für Dateien aktiv, die mit dem <?hh Prefix starten.
+// Der <?hh Prefix kann nicht wie <?php mit HTML gemischt werden.
+// Benutzung von "<?hh //strict" aktiviert den Strikt-Modus des Type-Checkers.
+
+
+// Typisierung für Funktions-Argumente
+function repeat(string $word, int $count)
+{
+    $word = trim($word);
+    return str_repeat($word . ' ', $count);
+}
+
+// Typisierung für Rückgabewerte
+function add(...$numbers) : int
+{
+    return array_sum($numbers);
+}
+
+// Funktionen ohne Rückgabewert, werden mit "void" typisiert
+function truncate(resource $handle) : void
+{
+    // ...
+}
+
+// Typisierung unterstützt die explizit optionale Ein- / Ausgabe von "null"
+function identity(?string $stringOrNull) : ?string
+{
+    return $stringOrNull;
+}
+
+// Typisierung von Klassen-Eigenschaften
+class TypeHintedProperties
+{
+    public ?string $name;
+
+    protected int $id;
+
+    private float $score = 100.0;
+
+    // Hack erfordert es, dass typisierte Eigenschaften (also "non-null")
+    // einen Default-Wert haben oder im Konstruktor initialisiert werden.
+    public function __construct(int $id)
+    {
+        $this->id = $id;
+    }
+}
+
+
+// Kurzgefasste anonyme Funktionen (lambdas)
+$multiplier = 5;
+array_map($y ==> $y * $multiplier, [1, 2, 3]);
+
+
+// Weitere, spezielle Felder (Generics)
+// Diese kann man sich als ein zugreifbares Interface vorstellen
+class Box<T>
+{
+    protected T $data;
+
+    public function __construct(T $data) {
+        $this->data = $data;
+    }
+
+    public function getData(): T {
+        return $this->data;
+    }
+}
+
+function openBox(Box<int> $box) : int
+{
+    return $box->getData();
+}
+
+
+// Formen
+//
+// Hack fügt das Konzept von Formen hinzu, wie struct-ähnliche arrays
+// mit einer typ-geprüften Menge von Schlüsseln
+type Point2D = shape('x' => int, 'y' => int);
+
+function distance(Point2D $a, Point2D $b) : float
+{
+    return sqrt(pow($b['x'] - $a['x'], 2) + pow($b['y'] - $a['y'], 2));
+}
+
+distance(
+    shape('x' => -1, 'y' => 5),
+    shape('x' => 2, 'y' => 50)
+);
+
+
+// Typen-Definition bzw. Aliasing
+//
+// Hack erlaubt es Typen zu definieren und sorgt somit für bessere Lesbarkeit
+newtype VectorArray = array<int, Vector<int>>;
+
+// Ein Tupel mit zwei Integern
+newtype Point = (int, int);
+
+function addPoints(Point $p1, Point $p2) : Point
+{
+    return tuple($p1[0] + $p2[0], $p1[1] + $p2[1]);
+}
+
+addPoints(
+    tuple(1, 2),
+    tuple(5, 6)
+);
+
+
+// Erstklassige Aufzählungen (enums)
+enum RoadType : int
+{
+    Road = 0;
+    Street = 1;
+    Avenue = 2;
+    Boulevard = 3;
+}
+
+function getRoadType() : RoadType
+{
+    return RoadType::Avenue;
+}
+
+
+// Automatische Erstellung von Klassen-Eigenschaften durch Konstruktor-Argumente
+//
+// Wiederkehrende Definitionen von Klassen-Eigenschaften können durch die Hack-
+// Syntax vermieden werden. Hack erlaubt es die Klassen-Eigenschaften über
+// Argumente des Konstruktors zu definieren.
+class ArgumentPromotion
+{
+    public function __construct(public string $name,
+                                protected int $age,
+                                private bool $isAwesome) {}
+}
+
+class WithoutArgumentPromotion
+{
+    public string $name;
+
+    protected int $age;
+
+    private bool $isAwesome;
+
+    public function __construct(string $name, int $age, bool $isAwesome)
+    {
+        $this->name = $name;
+        $this->age = $age;
+        $this->isAwesome = $isAwesome;
+    }
+}
+
+
+// Kooperatives Multitasking
+//
+// Die Schlüsselworte "async" and "await" führen Multitasking ein.
+// Achtung, hier werden keine Threads benutzt, sondern nur Aktivität getauscht.
+async function cooperativePrint(int $start, int $end) : Awaitable<void>
+{
+    for ($i = $start; $i <= $end; $i++) {
+        echo "$i ";
+
+        // Geben anderen Tasks die Möglichkeit aktiv zu werden
+        await RescheduleWaitHandle::create(RescheduleWaitHandle::QUEUE_DEFAULT, 0);
+    }
+}
+
+// Die Ausgabe von folgendem Code ist "1 4 7 2 5 8 3 6 9"
+AwaitAllWaitHandle::fromArray([
+    cooperativePrint(1, 3),
+    cooperativePrint(4, 6),
+    cooperativePrint(7, 9)
+])->getWaitHandle()->join();
+
+
+// Attribute
+//
+// Attribute repräsentieren eine Form von Metadaten für Funktionen.
+// Hack bietet Spezial-Attribute, die nützliche Eigenschaften mit sich bringen.
+
+// Das __Memoize Attribut erlaubt es die Ausgabe einer Funktion zu cachen.
+<<__Memoize>>
+function doExpensiveTask() : ?string
+{
+    return file_get_contents('http://example.com');
+}
+
+// Der Funktionsrumpf wird im Folgenden nur ein einziges mal ausgeführt:
+doExpensiveTask();
+doExpensiveTask();
+
+
+// Das __ConsistentConstruct Attribut signalisiert dem type-checker, dass
+// die Funktionsdeklaration von __construct für alle Unterklassen dieselbe ist.
+<<__ConsistentConstruct>>
+class ConsistentFoo
+{
+    public function __construct(int $x, float $y)
+    {
+        // ...
+    }
+
+    public function someMethod()
+    {
+        // ...
+    }
+}
+
+class ConsistentBar extends ConsistentFoo
+{
+    public function __construct(int $x, float $y)
+    {
+        // Der Type-checker erzwingt den Aufruf des Eltern-Klassen-Konstruktors
+        parent::__construct($x, $y);
+
+        // ...
+    }
+
+    // Das __Override Attribut ist ein optionales Signal an den Type-Checker,
+    // das erzwingt, dass die annotierte Methode die Methode der Eltern-Klasse
+    // oder des Traits verändert.
+    <<__Override>>
+    public function someMethod()
+    {
+        // ...
+    }
+}
+
+class InvalidFooSubclass extends ConsistentFoo
+{
+    // Wenn der Konstruktor der Eltern-Klasse nicht übernommen wird,
+    // wird der Type-Checker einen Fehler ausgeben:
+    //
+    //  "This object is of type ConsistentBaz. It is incompatible with this object
+    //   of type ConsistentFoo because some of their methods are incompatible"
+    //
+    public function __construct(float $x)
+    {
+        // ...
+    }
+
+    // Auch bei der Benutzung des __Override Attributs für eine nicht veränderte
+    // Methode wird vom Type-Checker eine Fehler ausgegeben:
+    //
+    //  "InvalidFooSubclass::otherMethod() is marked as override; no non-private
+    //   parent definition found or overridden parent is defined in non-<?hh code"
+    //
+    <<__Override>>
+    public function otherMethod()
+    {
+        // ...
+    }
+}
+
+// Ein Trait ist ein Begriff aus der objektorientierten Programmierung und
+// beschreibt eine wiederverwendbare Sammlung von Methoden und Attributen,
+// ähnlich einer Klasse.
+
+// Anders als in PHP können Traits auch als Schnittstellen (Interfaces)
+// implementiert werden und selbst Schnittstellen implementieren.
+interface KittenInterface
+{
+    public function play() : void;
+}
+
+trait CatTrait implements KittenInterface
+{
+    public function play() : void
+    {
+        // ...
+    }
+}
+
+class Samuel
+{
+    use CatTrait;
+}
+
+
+$cat = new Samuel();
+$cat instanceof KittenInterface === true; // True
+
+```
+
+## Weitere Informationen
+
+Die Hack [Programmiersprachen-Referenz](http://docs.hhvm.com/manual/de/hacklangref.php)
+erklärt die neuen Eigenschaften der Sprache detailliert auf Englisch. Für
+allgemeine Informationen kann man auch die offizielle Webseite [hacklang.org](http://hacklang.org/)
+besuchen.
+
+Die offizielle Webseite [hhvm.com](http://hhvm.com/) bietet Infos zum Download
+und zur Installation der HHVM.
+
+Hack's [nicht-untersützte PHP Syntax-Elemente](http://docs.hhvm.com/manual/en/hack.unsupported.php)
+werden im offiziellen Handbuch beschrieben.
-- 
cgit v1.2.3


From 6b58f22ec9bd3809f39a6ba62bcac02161fc6214 Mon Sep 17 00:00:00 2001
From: Martin Schimandl <martin.schimandl@gmail.com>
Date: Sun, 18 Oct 2015 18:07:43 +0200
Subject: First version of Make to german translation

---
 de-de/make-de.html.markdown | 260 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 260 insertions(+)
 create mode 100644 de-de/make-de.html.markdown

(limited to 'de-de')

diff --git a/de-de/make-de.html.markdown b/de-de/make-de.html.markdown
new file mode 100644
index 00000000..bed7abf3
--- /dev/null
+++ b/de-de/make-de.html.markdown
@@ -0,0 +1,260 @@
+---
+language: make
+contributors:
+    - ["Robert Steed", "https://github.com/robochat"]
+translators:
+  - ["Martin Schimandl", "https://github.com/Git-Jiro"]
+filename: Makefile
+lang: de-de
+---
+
+Eine Makefile definiert einen Graphen von Regeln um ein Ziel (oder Ziele)
+zu erzeugen. Es dient dazu die geringste Menge an Arbeit zu verrichten um
+ein Ziel in einklang mit dem Quellcode zu bringen. Make wurde berühmterweise
+von Stuart Feldman 1976 übers Wochenende geschrieben. Make ist noch immer
+sehr verbreitet (vorallem im Unix umfeld) obwohl es bereits sehr viel
+Konkurrenz und Kritik zu Make gibt.
+
+Es gibt eine vielzahl an Varianten von Make, dieser Artikel beschäftig sich
+mit der Version GNU Make. Diese Version ist standard auf Linux.
+
+```make
+
+# Kommentare können so geschrieben werden.
+
+# Dateien sollten Makefile heißen, denn dann können sie als `make <ziel>`
+# aufgerufen werden. Ansonsten muss `make -f "dateiname" <ziel>` verwendet
+# werden.
+
+# Warnung - Es sollten nur TABULATOREN zur Einrückung im Makefile verwendet
+# werden. Niemals Leerzeichen!
+
+#-----------------------------------------------------------------------
+# Grundlagen
+#-----------------------------------------------------------------------
+
+# Eine Regel - Diese Regel wird nur abgearbeitet wenn die Datei file0.txt
+# nicht existiert.
+file0.txt:
+	echo "foo" > file0.txt
+	# Selbst Kommentare in der 'Rezept' Sektion werden an die Shell
+	# weitergegeben. Versuche `make file0.txt` oder einfach `make`
+	# die erste Regel ist die Standard-Regel.
+
+
+# Diese Regel wird nur abgearbeitet wenn file0.txt aktueller als file1.txt ist.
+file1.txt: file0.txt
+	cat file0.txt > file1.txt
+	# Verwende die selben Quoting-Regeln wie die Shell
+	@cat file0.txt >> file1.txt
+	# @ unterdrückt die Ausgabe des Befehls an stdout.
+	-@echo 'hello'
+	# - bedeutet das Make die Abarbeitung fortsetzt auch wenn Fehler passieren.
+	# Versuche `make file1.txt` auf der Kommandozeile.
+
+# Eine Regel kann mehrere Ziele und mehrere Voraussetzungen haben.
+file2.txt file3.txt: file0.txt file1.txt
+	touch file2.txt
+	touch file3.txt
+
+# Make wird sich beschweren wenn es mehrere Rezepte für die gleiche Regel gibt.
+# Leere Rezepte zählen nicht und können dazu verwendet werden weitere 
+# Voraussetzungen hinzuzufügen.
+
+#-----------------------------------------------------------------------
+# Phony-Ziele
+#-----------------------------------------------------------------------
+
+# Ein Phony-Ziel ist ein Ziel das keine Datei ist.
+# Es wird nie aktuell sein, daher wird Make immer versuchen es abzuarbeiten
+all: maker process
+
+# Es ist erlaubt Dinge ausserhalb der Reihenfolge zu deklarieren.
+maker:
+	touch ex0.txt ex1.txt
+
+# Um das Fehlschlagen von Phony-Regeln zu vermeiden wenn eine echte Datei den
+# selben namen wie ein Phony-Ziel hat:
+.PHONY: all maker process
+# Das ist ein spezielles Ziel. Es gibt noch ein paar mehr davon.
+
+# Eine Regel mit einem Phony-Ziel als Voraussetzung wird immer abgearbeitet
+ex0.txt ex1.txt: maker
+
+# Häufige Phony-Ziele sind: all make clean install ...
+
+#-----------------------------------------------------------------------
+# Automatische Variablen & Wildcards
+#-----------------------------------------------------------------------
+
+process: file*.txt	# Eine Wildcard um Dateinamen zu Vergleichen
+	@echo $^	# $^ ist eine Variable die eine Liste aller
+			# Voraussetzungen enthält.
+	@echo $@	# Namen des Ziels ausgeben.
+	#(Bei mehreren Ziel-Regeln enthält $@ den Verursacher der Abarbeitung
+	#der Regel.)
+	@echo $<	# Die erste Voraussetzung aus der Liste
+	@echo $?	# Nur die Voraussetzungen die nicht aktuell sind.
+	@echo $+	# Alle Voraussetzungen inklusive Duplikate (nicht wie Üblich)
+	#@echo $|	# Alle 'order only' Voraussetzungen
+
+# Selbst wenn wir die Voraussetzungen der Regel aufteilen, $^ wird sie finden.
+process: ex1.txt file0.txt
+# ex1.txt wird gefunden werden, aber file0.txt wird dedupliziert.
+
+#-----------------------------------------------------------------------
+# Muster
+#-----------------------------------------------------------------------
+
+# Mit Mustern kann man make beibringen wie Dateien in andere Dateien
+# umgewandelt werden.
+
+%.png: %.svg
+	inkscape --export-png $^
+
+# Muster-Vergleichs-Regeln werden nur abgearbeitet wenn make entscheidet das Ziel zu
+# erzeugen
+
+# Verzeichnis-Pfade werden normalerweise bei Muster-Vergleichs-Regeln ignoriert.
+# Aber make wird versuchen die am besten passende Regel zu verwenden.
+small/%.png: %.svg
+	inkscape --export-png --export-dpi 30 $^
+
+# Make wird die letzte Version einer Muster-Vergleichs-Regel verwenden die es
+# findet.
+%.png: %.svg
+	@echo this rule is chosen
+
+# Allerdings wird make die erste Muster-Vergleicher-Regel verwenden die das
+# Ziel erzeugen kann.
+%.png: %.ps
+	@echo this rule is not chosen if *.svg and *.ps are both present
+
+# Make hat bereits ein paar eingebaute Muster-Vergleichs-Regelen. Zum Beispiel
+# weiß Make wie man aus *.c Dateien *.o Dateien erzeugt.
+
+# Ältere Versionen von Make verwenden möglicherweise Suffix-Regeln anstatt
+# Muster-Vergleichs-Regeln.
+.png.ps:
+	@echo this rule is similar to a pattern rule.
+
+# Aktivieren der Suffix-Regel
+.SUFFIXES: .png
+
+#-----------------------------------------------------------------------
+# Variablen
+#-----------------------------------------------------------------------
+# auch Makros genannt.
+
+# Variablen sind im Grunde genommen Zeichenketten-Typen.
+
+name = Ted
+name2="Sarah"
+
+echo:
+	@echo $(name)
+	@echo ${name2}
+	@echo $name    # Das funktioniert nicht, wird als $(n)ame behandelt.
+	@echo $(name3) # Unbekannte Variablen werden als leere Zeichenketten behandelt.
+
+# Es git 4 Stellen um Variablen zu setzen.
+# In Reihenfolge der Priorität von höchster zu niedrigster:
+# 1: Befehls-Zeilen Argumente
+# 2: Makefile
+# 3: Shell Umbebungs-Variablen - Make importiert diese automatisch.
+# 3: MAke hat einige vordefinierte Variablen.
+
+name4 ?= Jean
+# Setze die Variable nur wenn es eine gleichnamige Umgebungs-Variable noch
+# nicht gibt.
+
+override name5 = David
+# Verhindert das Kommando-Zeilen Argumente diese Variable ändern können.
+
+name4 +=grey
+# Werte an eine Variable anhängen (inkludiert Leerzeichen).
+
+# Muster-Spezifische Variablen Werte (GNU Erweiterung).
+echo: name2 = Sara # Wahr innerhalb der passenden Regel und auch innerhalb
+	# rekursiver Voraussetzungen (ausser wenn es den Graphen zerstören
+	# kann wenn es zu kompilizert wird!)
+
+# Ein paar Variablen die von Make automatisch definiert werden.
+echo_inbuilt:
+	echo $(CC)
+	echo ${CXX)}
+	echo $(FC)
+	echo ${CFLAGS)}
+	echo $(CPPFLAGS)
+	echo ${CXXFLAGS}
+	echo $(LDFLAGS)
+	echo ${LDLIBS}
+
+#-----------------------------------------------------------------------
+# Variablen 2
+#-----------------------------------------------------------------------
+
+# Der erste Typ von Variablen wird bei jeder verwendung ausgewertet.
+# Das kann aufwendig sein, daher exisitert ein zweiter Typ von Variablen.
+# Diese werden nur einmal ausgewertet. (Das ist eine GNU make Erweiterung)
+
+var := hello
+var2 ::=  $(var) hello
+#:= und ::= sind äquivalent.
+
+# Diese Variablen werden prozedural ausgwertet (in der Reihenfolge in der sie
+# auftauchen), die stehen daher im wiederspruch zum Rest der Sprache!
+
+# Das funktioniert nicht
+var3 ::= $(var4) and good luck
+var4 ::= good night
+
+#-----------------------------------------------------------------------
+# Funktionen
+#-----------------------------------------------------------------------
+
+# Make verfügt über eine vielzahl von Funktionen.
+
+sourcefiles = $(wildcard *.c */*.c)
+objectfiles = $(patsubst %.c,%.o,$(sourcefiles))
+
+# Das Format ist $(func arg0,arg1,arg2...)
+
+# Ein paar Beispiele
+ls:	* src/*
+	@echo $(filter %.txt, $^)
+	@echo $(notdir $^)
+	@echo $(join $(dir $^),$(notdir $^))
+
+#-----------------------------------------------------------------------
+# Direktiven
+#-----------------------------------------------------------------------
+
+# Inkludiere andere Makefile, sehr praktisch für platformspezifischen Code
+include foo.mk
+
+sport = tennis
+# Konditionale kompiliereung
+report:
+ifeq ($(sport),tennis)
+	@echo 'game, set, match'
+else
+	@echo "They think it's all over; it is now"
+endif
+
+# Es gibt auch ifneq, ifdef, ifndef
+
+foo = true
+
+ifdef $(foo)
+bar = 'hello'
+endif
+```
+
+
+### Mehr Resourcen
+
++ [gnu make documentation](https://www.gnu.org/software/make/manual/)
++ [software carpentry tutorial](http://swcarpentry.github.io/make-novice/)
++ learn C the hard way [ex2](http://c.learncodethehardway.org/book/ex2.html) [ex28](http://c.learncodethehardway.org/book/ex28.html)
+
-- 
cgit v1.2.3


From cb251870aa716a04350687f8c9191f24bb1e00b9 Mon Sep 17 00:00:00 2001
From: Marian Sievers <marian.sievers@gmail.com>
Date: Thu, 22 Oct 2015 08:50:17 +0200
Subject: Add link to gitflow

Add link to gitflow as a example of a branching model.
---
 de-de/git-de.html.markdown | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'de-de')

diff --git a/de-de/git-de.html.markdown b/de-de/git-de.html.markdown
index dea329d5..55d7e8cc 100644
--- a/de-de/git-de.html.markdown
+++ b/de-de/git-de.html.markdown
@@ -374,3 +374,5 @@ $ git rm /pather/to/the/file/HelloWorld.c
 * [SalesForce Cheat Sheet](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
 
 * [GitGuys](http://www.gitguys.com/)
+
+* [gitflow - Ein Modell um mit Branches zu arbeiten](http://nvie.com/posts/a-successful-git-branching-model/)
-- 
cgit v1.2.3


From f43d7d4fa050e1036956c522c8c5efd4ec99aa45 Mon Sep 17 00:00:00 2001
From: Marian Sievers <marian.sievers@gmail.com>
Date: Thu, 22 Oct 2015 09:02:44 +0200
Subject: Improve translations and add command examples

Improve some translations.
Add some more examples for commands.
---
 de-de/git-de.html.markdown | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

(limited to 'de-de')

diff --git a/de-de/git-de.html.markdown b/de-de/git-de.html.markdown
index 55d7e8cc..4c259cfd 100644
--- a/de-de/git-de.html.markdown
+++ b/de-de/git-de.html.markdown
@@ -33,6 +33,7 @@ Eine Versionsverwaltung erfasst die Änderungen einer Datei oder eines Verzeichn
 * Ist offline einsetzbar.
 * Einfache Kollaboration!
 * Branching ist einfach!
+* Branching ist schnell!
 * Merging ist einfach!
 * Git ist schnell.
 * Git ist flexibel.
@@ -53,11 +54,11 @@ Das .git-Verzeichnis enthält alle Einstellung, Logs, Branches, den HEAD und meh
 
 ### Arbeitsverzeichnis (Teil des Repositorys)
 
-Dies sind die Verzeichnisse und Dateien in deinem Repository.
+Dies sind die Verzeichnisse und Dateien in deinem Repository, also z.B. dein Programmcode.
 
 ### Index (Teil des .git-Verzeichnisses)
 
-Der Index ist die die Staging-Area von Git. Es ist im Grunde eine Ebene, die Arbeitsverzeichnis vom Repository trennt. Sie gibt Entwicklern mehr Einfluss darüber, was ins Git-Repository eingeht.
+Der Index ist die Staging-Area von Git. Es ist im Grunde eine Ebene, die Arbeitsverzeichnis vom Repository trennt. Sie gibt Entwicklern mehr Einfluss darüber, was ins Git-Repository eingeht.
 
 ### Commit
 
@@ -84,7 +85,7 @@ Ein *head* ist ein Pointer, der auf einen beliebigen Commit zeigt.  Ein Reposito
 
 ### init
 
-Erstelle ein leeres Git-Repository. Die Einstellungen, gespeicherte Informationen und mehr zu diesem Git-Repository werden in einem Verzeichnis namens *.git* angelegt.
+Erstelle ein leeres Git-Repository im aktuellen Verzeichnis. Die Einstellungen, gespeicherte Informationen und mehr zu diesem Git-Repository werden in einem Verzeichnis namens *.git* angelegt.
 
 ```bash
 $ git init
@@ -180,6 +181,8 @@ Bringt alle Dateien im Arbeitsverzeichnis auf den Stand des Index oder des angeg
 ```bash
 # Ein Repo auschecken - wenn nicht anders angegeben ist das der master
 $ git checkout
+# Eine Datei auschecken - sie befindet sich dann auf dem aktuellen Stand im Repository
+$ gut checkout /path/to/file
 # Einen bestimmten Branch auschecken
 $ git checkout branchName
 # Erstelle einen neuen Branch und wechsle zu ihm. Wie: "git branch <name>; git checkout <name>"
@@ -217,6 +220,9 @@ $ git diff --cached
 
 # Unterschiede zwischen deinem Arbeitsverzeichnis und dem aktuellsten Commit anzeigen
 $ git diff HEAD
+
+# Unterschiede zwischen dem Index und dem aktuellsten Commit (betrifft nur Dateien im Index)
+$ git diff --staged
 ```
 
 ### grep
-- 
cgit v1.2.3


From 0c04685b3a074282724d649c9c769ba8e609d0fb Mon Sep 17 00:00:00 2001
From: Marian Sievers <marian.sievers@gmail.com>
Date: Thu, 22 Oct 2015 16:24:57 +0200
Subject: Fixed typo.

---
 de-de/git-de.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'de-de')

diff --git a/de-de/git-de.html.markdown b/de-de/git-de.html.markdown
index 4c259cfd..61f7bb67 100644
--- a/de-de/git-de.html.markdown
+++ b/de-de/git-de.html.markdown
@@ -182,7 +182,7 @@ Bringt alle Dateien im Arbeitsverzeichnis auf den Stand des Index oder des angeg
 # Ein Repo auschecken - wenn nicht anders angegeben ist das der master
 $ git checkout
 # Eine Datei auschecken - sie befindet sich dann auf dem aktuellen Stand im Repository
-$ gut checkout /path/to/file
+$ git checkout /path/to/file
 # Einen bestimmten Branch auschecken
 $ git checkout branchName
 # Erstelle einen neuen Branch und wechsle zu ihm. Wie: "git branch <name>; git checkout <name>"
-- 
cgit v1.2.3


From d04ffe7f9a67b25d0add4d5852e803b03924d666 Mon Sep 17 00:00:00 2001
From: SmuSmu <SmuSmu@users.noreply.github.com>
Date: Thu, 22 Oct 2015 21:22:49 +0200
Subject: follow english original

follow english original
---
 de-de/bash-de.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'de-de')

diff --git a/de-de/bash-de.html.markdown b/de-de/bash-de.html.markdown
index 541d28bb..654fcdd4 100644
--- a/de-de/bash-de.html.markdown
+++ b/de-de/bash-de.html.markdown
@@ -92,12 +92,12 @@ echo "immer ausgeführt" || echo "Nur ausgeführt wenn der erste Befehl fehlschl
 echo "immer ausgeführt" && echo "Nur ausgeführt wenn der erste Befehl Erfolg hat"
 
 # Um && und || mit if statements zu verwenden, braucht man mehrfache Paare eckiger Klammern:
-if [ $NAME == "Steve" ] && [ $Alter -eq 15 ]
+if [ "$NAME" == "Steve" ] && [ "$Alter" -eq 15 ]
 then
     echo "Wird ausgeführt wenn $NAME gleich 'Steve' UND $Alter gleich 15."
 fi
 
-if [ $Name == "Daniya" ] || [ $Name == "Zach" ]
+if [ "$Name" == "Daniya" ] || [ "$Name" == "Zach" ]
 then
     echo "Wird ausgeführt wenn $NAME gleich 'Daniya' ODER $NAME gleich 'Zach'."
 fi
-- 
cgit v1.2.3


From b27ddf1bd65c0d62293934eee085fafe340937d4 Mon Sep 17 00:00:00 2001
From: meinkej <jerome.meinke@googlemail.com>
Date: Thu, 29 Oct 2015 19:44:21 +0100
Subject: [go/de] More infos, reformulation and typo fixes for Go.

---
 de-de/go-de.html.markdown | 40 +++++++++++++++++++---------------------
 1 file changed, 19 insertions(+), 21 deletions(-)

(limited to 'de-de')

diff --git a/de-de/go-de.html.markdown b/de-de/go-de.html.markdown
index d3a192fe..099927b6 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,7 +23,7 @@ aktive Community.
 /* Mehr-
    zeiliger Kommentar */
 
-// Eine jede Quelldatei beginnt mit einer Paket-Klausel.
+// 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.
@@ -40,7 +39,7 @@ import (
 
 // 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,8 +49,8 @@ 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. Siese 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.
@@ -306,14 +305,13 @@ func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 ```
 
 ## 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/).
-
-- 
cgit v1.2.3


From e5a02057227506b95630658971caabb30b64f705 Mon Sep 17 00:00:00 2001
From: meinkej <jerome.meinke@googlemail.com>
Date: Thu, 29 Oct 2015 19:50:17 +0100
Subject: Fix a typo introduced in the previous commit. Reformatted some lines.

---
 de-de/go-de.html.markdown | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'de-de')

diff --git a/de-de/go-de.html.markdown b/de-de/go-de.html.markdown
index 099927b6..94f48e65 100644
--- a/de-de/go-de.html.markdown
+++ b/de-de/go-de.html.markdown
@@ -49,7 +49,7 @@ func main() {
     beyondHello()
 }
 
-// Funktionen können Parameter akzeptieren. Siese werden in Klammern deklariert,
+// 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.
@@ -98,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
 
@@ -200,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.
@@ -254,8 +255,9 @@ 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)
-- 
cgit v1.2.3


From 9631e99f4acca4c4415f5166c2a8f7292058cd51 Mon Sep 17 00:00:00 2001
From: meinkej <jerome.meinke@googlemail.com>
Date: Sat, 31 Oct 2015 15:39:50 +0100
Subject: Improvements to the german LaTeX document. Fix a sentence, added a
 command to be able to define multiline comment blocks. Additionally, make use
 of the \LaTeX command to correctly show the LaTeX logo.

---
 de-de/latex-de.html.markdown | 91 +++++++++++++++++++++++++-------------------
 1 file changed, 51 insertions(+), 40 deletions(-)

(limited to 'de-de')

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
-- 
cgit v1.2.3


From 484300f1db4509b08ed48526c61fcfcb48a6152b Mon Sep 17 00:00:00 2001
From: Zach Latta <zach@zachlatta.com>
Date: Tue, 23 Feb 2016 16:12:44 -0800
Subject: Fix capitalization of GitHub

---
 de-de/markdown-de.html.markdown | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'de-de')

diff --git a/de-de/markdown-de.html.markdown b/de-de/markdown-de.html.markdown
index 6a90980b..2c838660 100644
--- a/de-de/markdown-de.html.markdown
+++ b/de-de/markdown-de.html.markdown
@@ -56,7 +56,7 @@ __Genau wie dieser.__
 **_Dieser auch!_**
 *__Und dieser genau so!__*
 
-<!-- In "Github Flavored Markdown", dem von Github verwendeten Dialekt / Parser,
+<!-- In "GitHub Flavored Markdown", dem von GitHub verwendeten Dialekt / Parser,
 gibt es auch noch durchgestrichenen Text: -->
 
 ~~Dieser Text wird durchgestrichen dargestellt.~~
@@ -148,7 +148,7 @@ indem du eine Zeile mit vier Leerzeichen oder einem Tabulator einrückst -->
 
 Hermann hatte nicht die leiseste Ahnung, was dieses `go_to()` bedeuten könnte!
 
-<!-- In "Github Flavored Markdown" gibt es für Code nocheinmal eine
+<!-- In "GitHub Flavored Markdown" gibt es für Code nocheinmal eine
 besondere Syntax -->
 
 \`\`\`ruby <!-- in "echt" musst du die Backslashes entfernen: ```ruby ! -->
@@ -157,7 +157,7 @@ def foobar
 end
 \`\`\` <!-- hier auch keine Backslashes, nur ``` -->
 
-<-- der obige Block muss nicht extra eingerückt werden, außerdem fügt Github
+<-- der obige Block muss nicht extra eingerückt werden, außerdem fügt GitHub
 Syntax-Highlighting für die nach dem ``` angegebene Sprache hinzu -->
 
 <!-- Horizontale Linie (<hr />) -->
@@ -233,7 +233,7 @@ Ich würde *diesen Teil gerne mit Sternen umschließen*, doch ohne dass er kursi
 wird. Also mache ich folgendes: \*Ich umschließe diesen Text mit Sternen\*!
 
 <!-- Tabellen -->
-<!-- Tabellen gibt es bis jetzt nur in "Github Flavored Markdown".
+<!-- Tabellen gibt es bis jetzt nur in "GitHub Flavored Markdown".
 Zudem sind sie ziemlich mühselig, aber wenn du es wirklich wissen willst: -->
 
 | Spalte1      | Spalte2  | Spalte3       |
@@ -253,4 +253,4 @@ Ganz schön hässlich | vielleicht doch lieber | wieder aufhören
 
 Mehr Informationen gibt es in [John Gruber's offiziellem Blog-Post](http://daringfireball.net/projects/markdown/syntax)
 und bei Adam Pritchards [grandiosem Cheatsheet](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
-Infos zu Github Flavored Markdown [gibt es hier](https://help.github.com/articles/github-flavored-markdown).
\ No newline at end of file
+Infos zu GitHub Flavored Markdown [gibt es hier](https://help.github.com/articles/github-flavored-markdown).
\ No newline at end of file
-- 
cgit v1.2.3


From 7740af83e71ceaed96d39d3d97f0a5fc02d1c9ab Mon Sep 17 00:00:00 2001
From: S0lll0s <s0lll0s@blinkenshell.org>
Date: Thu, 8 Oct 2015 12:33:01 +0200
Subject: [haml/de] Add Haml/de article

---
 de-de/haml-de.html.markdown | 156 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 156 insertions(+)
 create mode 100644 de-de/haml-de.html.markdown

(limited to 'de-de')

diff --git a/de-de/haml-de.html.markdown b/de-de/haml-de.html.markdown
new file mode 100644
index 00000000..7272b365
--- /dev/null
+++ b/de-de/haml-de.html.markdown
@@ -0,0 +1,156 @@
+---
+language: haml
+filename: learnhaml-de.haml
+contributors:
+  - ["Simon Neveu", "https://github.com/sneveu"]
+  - ["Sol Bekic", "https://github.com/S0lll0s"]
+lang: de-de
+---
+
+Haml ist eine Markup- und Templatingsprache, aufgesetzt auf Ruby, mit der HTML Dokumente einfach beschrieben werden können.
+
+Haml vermindert Wiederholung und Fehleranfälligkeit, indem es Tags basierend auf der Markup-Struktur schließt und schachtelt.
+Dadurch ergibt sich kurzes, präzises und logisches Markup.
+
+Haml kann außerhalb eines Ruby-projekts verwendet werden. Mit dem installierten Haml gem kann man das Terminal benutzen um Haml zu HTML umzuwandeln:
+
+$ haml input_file.haml output_file.html
+
+
+```haml
+/ -------------------------------------------
+/ Einrückung
+/ -------------------------------------------
+
+/
+  Einrückung ist ein wichtiges Element des Haml Syntax, deswegen ist es
+  wichtig ein konsequentes Schema zu verwenden. Meistens werden zwei spaces
+  verwendet, solange die Einrückungen das gleiche Schema verfolgen können
+  aber auch andere Breiten und Tabs verwendet werden
+
+
+/ -------------------------------------------
+/ Kommentare
+/ -------------------------------------------
+
+/ Kommentare beginnen mit einem Slash
+
+/
+  Mehrzeilige Kommentare werden eingerückt und mit einem Slash
+  eingeführt
+
+-# Diese Zeile ist ein "stummes" Kommentar, es wird nicht mitgerendert
+
+
+/ -------------------------------------------
+/ HTML Elemente
+/ -------------------------------------------
+
+/ Tags werden durch ein Prozentzeichen und den Tagnamen erzeugt
+%body
+  %header
+    %nav
+
+/ Die Zeilen oben würden folgendes ergeben:
+  <body>
+    <header>
+      <nav></nav>
+    </header>
+  </body>
+
+/ Text kann direkt nach dem Tagnamen eingefügt werden:
+%h1 Headline copy
+
+/ Mehrzeilige Inhalte müssen stattdessen eingerückt werden:
+%p 
+  This is a lot of content that we could probably split onto two
+  separate lines.
+
+/ 
+  HTML kann mit &= escaped werden. So werden HTML-sensitive Zeichen
+  enkodiert. Zum Beispiel:
+
+%p
+  &= "Ja & Nein"
+
+/ würde 'Ja &amp; Nein' ergeben
+
+/ HTML kann mit != dekodiert werden:
+%p
+  != "so schreibt man ein Paragraph-Tag: <p></p>"
+
+/ ...was 'This is how you write a paragraph tag <p></p>' ergeben würde
+
+/ CSS Klassen können mit '.classname' an Tags angehängt werden:
+%div.foo.bar
+
+/ oder über einen Ruby Hash:
+%div{:class => 'foo bar'}
+
+/ Das div Tag wird standardmäßig verwendet, divs können also verkürzt werden:
+.foo
+
+/ andere Attribute können über den Hash angegeben werden:
+%a{:href => '#', :class => 'bar', :title => 'Bar'}
+
+/ Booleesche Attribute können mit 'true' gesetzt werden:
+%input{:selected => true}
+
+/ data-Attribute können in einem eigenen Hash im :data key angegeben werden:
+%div{:data => {:attribute => 'foo'}}
+
+
+/ -------------------------------------------
+/ Verwendung von Ruby
+/ -------------------------------------------
+
+/ Mit dem = Zeichen können Ruby-werte evaluiert und als Tag-text verwendet werden:
+
+%h1= book.name
+
+%p
+  = book.author
+  = book.publisher
+
+
+/ Code nach einem Bindestrich wird ausgeführt aber nicht gerendert:
+- books = ['book 1', 'book 2', 'book 3']
+
+/ So können zum Beispiel auch Blöcke verwendet werden:
+- books.shuffle.each_with_index do |book, index|
+  %h1= book
+
+  if book do
+    %p This is a book
+
+/
+  Auch hier werden wieder keine End-Tags benötigt!
+  Diese ergeben sich aus der Einrückung.
+
+
+/ -------------------------------------------
+/ Inline Ruby / Ruby Interpolation
+/ -------------------------------------------
+
+/ Ruby variablen können mit #{} in Text interpoliert werden:
+%p dein bestes Spiel ist #{best_game}
+
+
+/ -------------------------------------------
+/ Filter
+/ -------------------------------------------
+
+/
+  Mit dem Doppelpinkt können Haml Filter benutzt werden.
+  Zum Beispiel gibt es den :javascript Filter, mit dem inline JS
+  geschrieben werden kann:
+
+:javascript
+  console.log('Dies ist ein <script>');
+
+```
+
+## Weitere Resourcen
+
+- [What is HAML?](http://haml.info/) - Eine gute Einleitung auf der Haml homepage (englisch)
+- [Official Docs](http://haml.info/docs/yardoc/file.REFERENCE.html) - Die offizielle Haml Referenz (englisch)
-- 
cgit v1.2.3


From 433fb259093c3570d20271cad675cb22f9608d19 Mon Sep 17 00:00:00 2001
From: Martin Schimandl <martin.schimandl@gmail.com>
Date: Fri, 11 Mar 2016 06:14:36 +0100
Subject: Add lang property to page

---
 de-de/lua-de.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'de-de')

diff --git a/de-de/lua-de.html.markdown b/de-de/lua-de.html.markdown
index eccfcf1e..83f8506c 100644
--- a/de-de/lua-de.html.markdown
+++ b/de-de/lua-de.html.markdown
@@ -5,6 +5,7 @@ contributors:
 translators:
     - ["Martin Schimandl", "https://github.com/Git-Jiro"]
 filename: learnlua-de.lua
+lang: de-de
 ---
 
 ```lua
-- 
cgit v1.2.3


From bca546e31a2918f0de8a0fe19cc64b08e8cdf73f Mon Sep 17 00:00:00 2001
From: Martin Schimandl <martin.schimandl@gmail.com>
Date: Fri, 11 Mar 2016 06:14:59 +0100
Subject: Add lang property to page

---
 de-de/tcl-de.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'de-de')

diff --git a/de-de/tcl-de.html.markdown b/de-de/tcl-de.html.markdown
index 1e24e379..4f3b8820 100644
--- a/de-de/tcl-de.html.markdown
+++ b/de-de/tcl-de.html.markdown
@@ -5,6 +5,7 @@ contributors:
 translators:
     - ["Martin Schimandl", "https://github.com/Git-Jiro"]
 filename: learntcl-de.tcl
+lang: de-de
 ---
 
 Tcl wurde kreiert von [John Ousterhout](http://wiki.tcl.tk/John Ousterout) als
-- 
cgit v1.2.3


From c378f8da3d76038e6a135cc3c129db76666bcda5 Mon Sep 17 00:00:00 2001
From: Martin Schimandl <martin.schimandl@gmail.com>
Date: Fri, 11 Mar 2016 20:05:03 +0100
Subject: Add -de filename suffix, as requested.

---
 de-de/make-de.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'de-de')

diff --git a/de-de/make-de.html.markdown b/de-de/make-de.html.markdown
index bed7abf3..22c14a69 100644
--- a/de-de/make-de.html.markdown
+++ b/de-de/make-de.html.markdown
@@ -4,7 +4,7 @@ contributors:
     - ["Robert Steed", "https://github.com/robochat"]
 translators:
   - ["Martin Schimandl", "https://github.com/Git-Jiro"]
-filename: Makefile
+filename: Makefile-de
 lang: de-de
 ---
 
-- 
cgit v1.2.3


From 12e513c70d5c8bd0d59784a4e6e6c3ae3708b04a Mon Sep 17 00:00:00 2001
From: meinkej <jerome.meinke@googlemail.com>
Date: Sat, 12 Mar 2016 14:55:23 +0100
Subject: added a -de suffix to the filename, and a lang: de-de field

---
 de-de/hack-de.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'de-de')

diff --git a/de-de/hack-de.html.markdown b/de-de/hack-de.html.markdown
index 330d0b9b..d85c8d86 100644
--- a/de-de/hack-de.html.markdown
+++ b/de-de/hack-de.html.markdown
@@ -1,10 +1,11 @@
 ---
 language: Hack
+lang: de-de
 contributors:
     - ["Stephen Holdaway", "https://github.com/stecman"]
     - ["David Lima", "https://github.com/davelima"]
     - ["Jerome Meinke", "https://github.com/jmeinke"]
-filename: learnhack.hh
+filename: learnhack-de.hh
 ---
 
 Hack ist eine von Facebook neu entwickelte Programmiersprache auf Basis von PHP.
-- 
cgit v1.2.3


From 8cbdad885357b43960c07b72b35a4c7b9b8aad4f Mon Sep 17 00:00:00 2001
From: Numeri <Numeri@users.noreply.github.com>
Date: Sat, 12 Mar 2016 22:46:21 -0500
Subject: [haskell/de] Fixed a few typos and spelling errors

---
 de-de/haskell-de.html.markdown | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'de-de')

diff --git a/de-de/haskell-de.html.markdown b/de-de/haskell-de.html.markdown
index d1a0008e..5d17ccc7 100644
--- a/de-de/haskell-de.html.markdown
+++ b/de-de/haskell-de.html.markdown
@@ -100,7 +100,7 @@ not False -- True
 [1..] !! 999 -- 1000
 
 -- Haskell evaluiert nun die ersten 1 - 1000 Elemente, aber der Rest der Liste
--- bleibt unangetastet. Haskell wird sie solange nicht weiterevalieren
+-- bleibt unangetastet. Haskell wird sie solange nicht weiterevaluieren
 -- bis es muss.
 
 -- Zwei Listen konkatenieren
@@ -115,7 +115,7 @@ tail [1..5] -- [2, 3, 4, 5]
 init [1..5] -- [1, 2, 3, 4]
 last [1..5] -- 5
 
--- list comprehensions | Listen erschaffen
+-- Listen erschaffen ("list comprehensions")
 [x*2 | x <- [1..5]] -- [2, 4, 6, 8, 10]
 
 -- Mit Bedingungen
@@ -179,7 +179,7 @@ myMap (\x -> x + 2) [1..5] -- [3, 4, 5, 6, 7]
 
 -- Fold (`inject` in einigen Sprachen)
 -- Foldl1 bedeutet: fold von links nach rechts und nehme den ersten
--- Wert der Liste als Basiswert f[r den Akkumulator.
+-- Wert der Liste als Basiswert für den Akkumulator.
 foldl1 (\acc x -> acc + x) [1..5] -- 15
 
 ----------------------------------------------------
@@ -201,7 +201,7 @@ foo 5 -- 15
 
 -- Funktionskomposition
 -- Die (.) Funktion verkettet Funktionen.
--- Zum Beispiel, die Funktion Foo nimmt ein Argument addiert 10 dazu und
+-- Zum Beispiel, die Funktion Foo nimmt ein Argument, addiert 10 dazu und
 -- multipliziert dieses Ergebnis mit 4.
 foo = (*4) . (+10)
 
@@ -212,7 +212,7 @@ foo 5 -- 60
 -- 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,
+-- rechtsassoziativ und hat die Priorität 0. Dieses hat (i.d.R.) 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.
@@ -283,7 +283,7 @@ for [0..5] $ \i -> show i
 for [0..5] show
 
 -- foldl oder foldr reduziren Listen auf einen Wert.
--- foldl <fn> <initial value> <list>
+-- foldl <Funktion> <initialer Wert> <Liste>
 foldl (\x y -> 2*x + y) 4 [1,2,3] -- 43
 
 -- die Abarbeitung sieht so aus:
@@ -435,7 +435,7 @@ qsort (p:xs) = qsort lesser ++ [p] ++ qsort greater
 ```
 
 Haskell ist sehr einfach zu installieren.
-Hohl es dir von [hier](http://www.haskell.org/platform/).
+Hol es dir von [hier](http://www.haskell.org/platform/).
 
 Eine sehr viele langsamere Einführung findest du unter:
 [Learn you a Haskell](http://learnyouahaskell.com/) oder
-- 
cgit v1.2.3


From 7333f7bc3533716fecb77046c263411798b7417d Mon Sep 17 00:00:00 2001
From: ven <vendethiel@hotmail.fr>
Date: Sun, 13 Mar 2016 10:40:08 +0100
Subject: jmeinke is a translator

---
 de-de/go-de.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'de-de')

diff --git a/de-de/go-de.html.markdown b/de-de/go-de.html.markdown
index 94f48e65..dca88f01 100644
--- a/de-de/go-de.html.markdown
+++ b/de-de/go-de.html.markdown
@@ -4,6 +4,7 @@ filename: learngo-de.go
 contributors:
     - ["Joseph Adams", "https://github.com/jcla1"]
     - ["Dennis Keller", "https://github.com/denniskeller"]
+translators:
     - ["Jerome Meinke", "https://github.com/jmeinke"]
 lang: de-de
 ---
-- 
cgit v1.2.3


From e78b5924a7eb27589e8a8269ad45b4c83bd59d93 Mon Sep 17 00:00:00 2001
From: ven <vendethiel@hotmail.fr>
Date: Sun, 13 Mar 2016 10:40:11 +0100
Subject: jmeinke is a translator

---
 de-de/hack-de.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'de-de')

diff --git a/de-de/hack-de.html.markdown b/de-de/hack-de.html.markdown
index d85c8d86..42428130 100644
--- a/de-de/hack-de.html.markdown
+++ b/de-de/hack-de.html.markdown
@@ -4,6 +4,7 @@ lang: de-de
 contributors:
     - ["Stephen Holdaway", "https://github.com/stecman"]
     - ["David Lima", "https://github.com/davelima"]
+translators:
     - ["Jerome Meinke", "https://github.com/jmeinke"]
 filename: learnhack-de.hh
 ---
-- 
cgit v1.2.3


From 1da996d5a587d963be7b7b968b7f99d4d015bfd0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Dominik=20S=C3=BC=C3=9F?= <dominik.suess@outlook.at>
Date: Wed, 16 Mar 2016 12:38:14 +0100
Subject: Update d-de.html.markdown

---
 de-de/d-de.html.markdown | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'de-de')

diff --git a/de-de/d-de.html.markdown b/de-de/d-de.html.markdown
index 94519b28..ae036d70 100644
--- a/de-de/d-de.html.markdown
+++ b/de-de/d-de.html.markdown
@@ -3,6 +3,7 @@ language: D
 filename: learnd-de.d 
 contributors:
     - ["Nick Papanastasiou", "www.nickpapanastasiou.github.io"]
+translators:
     - ["Dominik Süß", "www.thesuess.me"]
 lang: de-de
 ---
@@ -22,7 +23,7 @@ void main(string[] args) {
 Wenn du so wie ich bist und viel zeit im Internet verbringst stehen die Chancen gut
 das du schonmal über [D](http://dlang.org/) gehört hast.
 Die D-Sprache ist eine moderne, überall einsetzbare programmiersprache die von Low bis
-High Level verwendet werden kann und dabei viele stile anbietet.
+High Level verwendet werden kann und dabei viele Stile anbietet.
 
 D wird aktiv von Walter Bright und Andrei Alexandrescu entwickelt, zwei super schlaue,
 richtig coole leute. Da das jetzt alles aus dem weg ist - auf zu den Beispielen!
@@ -128,8 +129,8 @@ auto mat = new Matrix!(3, 3); // Standardmäßig ist T vom typ Integer
 ```
 
 Wo wir schon bei Klassen sind - Wie wäre es mit Properties! Eine Property
-ist eine Funktion die wie ein Wert agiert. Das gibt uns viel klarere syntax
-im stil von `structure.x = 7` was gleichgültig wäre zu `structure.setX(7)`
+ist eine Funktion die wie ein Wert agiert. Das gibt uns viel klarere Syntax
+im Stil von `structure.x = 7` was gleichgültig wäre zu `structure.setX(7)`
 
 ```c
 // Diese Klasse ist parameterisiert mit T, U
-- 
cgit v1.2.3