19 files changed, 1210 insertions, 55 deletions

diff --git a/csharp.html.markdown b/csharp.html.markdown
index 963f38f4..c98a7da9 100644
--- a/csharp.html.markdown
+++ b/csharp.html.markdown
@@ -132,6 +132,12 @@ namespace Learning.CSharp
             DateTime fooDate = DateTime.Now;
             Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
 
+            // Verbatim String
+            // You can use the @ symbol before a string literal to escape all characters in the string
+            string path = "C:\\Users\\User\\Desktop";
+            string verbatimPath = @"C:\Users\User\Desktop";
+            Console.WriteLine(path == verbatimPath);  // => true
+
             // You can split a string over two lines with the @ symbol. To escape " use ""
             string bazString = @"Here's some stuff
 on a new line! ""Wow!"", the masses cried";
@@ -949,6 +955,7 @@ on a new line! ""Wow!"", the masses cried";
 
     // String interpolation by prefixing the string with $
     // and wrapping the expression you want to interpolate with { braces }
+    // You can also combine both interpolated and verbatim strings with $@
     public class Rectangle
     {
         public int Length { get; set; }
@@ -961,6 +968,9 @@ on a new line! ""Wow!"", the masses cried";
         {
             Rectangle rect = new Rectangle { Length = 5, Width = 3 };
             Console.WriteLine($"The length is {rect.Length} and the width is {rect.Width}");
+
+            string username = "User";
+            Console.WriteLine($@"C:\Users\{username}\Desktop");
         }
     }
 
diff --git a/de-de/edn-de.html.markdown b/de-de/edn-de.html.markdown
new file mode 100644
index 00000000..4f452d7e
--- /dev/null
+++ b/de-de/edn-de.html.markdown
@@ -0,0 +1,112 @@
+---
+language: edn
+filename: learnedn-de.edn
+contributors:
+  - ["Jason Yeo", "https://github.com/jsyeo"]
+  - ["Jonathan D Johnston", "https://github.com/jdjohnston"]
+translators:
+    - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+
+Extensible Data Notation (EDN) ist ein Format für serialisierte Daten.
+
+EDN ist ein Subset der von Clojure verwendeten Syntax. Das Lesen von Daten, die durch EDN definiert werden, ist
+sicherer als das, was durch die vollständige Clojure-Syntax definiert wird, insbesondere von nicht
+vertrauenswürdigen Quellen. EDN ist beschränkt auf Daten, kein Code. Es ist ähnlich in seinen Zielen zu JSON.
+Obwohl es mehr in Clojure verwendet wird, gibt es verschiedene Implementationen von EDN in vielen
+verschiedenen anderen Sprachen.
+
+Der Hauptvorteil von EDN im Gegensatz zu JSON und YAML ist, dass es erweiterbar ist.
+Wir werden später sehen wie es erweitert werden kann.
+
+```clojure
+; Kommentare starten mit einem Semikolon.
+; Alles nach dem Semikolon wird ignoriert.
+
+;;;;;;;;;;;;;;;;;;;
+;;; Basistypen  ;;;
+;;;;;;;;;;;;;;;;;;;
+
+nil         ; auch bekannt in anderen Sprachen als null
+
+; Booleans
+true
+false
+
+; Strings werden in Gänsefüßchen eingeschlossen.
+"hungarian breakfast"
+"farmer's cheesy omelette"
+
+; Charaktere werden einem Backslash vorangestellt
+\g \r \a \c \e
+
+; Schlüsselwörter beginnen mit einenm Doppelpunkt. Sie verhalten sich wie Enums.
+; Ähnlich, wie Symbole in Ruby.
+:eggs
+:cheese
+:olives
+
+; Symbole werden verwendet um Identifier zu repräsentieren. Sie beginnen mit einem #.
+; Du kannst einen Namespace für Symbole nutzen, wenn du / verwendest. Egal was / vorangestellt wird
+; ist der Namespace dieses Namens.
+#spoon
+#kitchen/spoon ; nicht das selbe, wie #spoon
+#kitchen/fork
+#github/fork   ; damit kannst du nicht essen
+
+; Integers und Floats
+42
+3.14159
+
+; Listen sind Sequenzen von Werten  
+(:bun :beef-patty 9 "yum!")
+
+; Vektoren erlauben zufälligen Zugriff
+[:gelato 1 2 -2]
+
+; Maps sind assoziative Datenstrukturen, die einen Schlüssel mit einem Wert verbinden.
+{:eggs        2
+ :lemon-juice 3.5
+ :butter      1}                
+
+; Du bist nicht beschränkt ausschließlich Schlüsselwörter als Schlüssel zu verwenden.
+{[1 2 3 4] "tell the people what she wore",
+ [5 6 7 8] "the more you see the more you hate"}
+
+; Du kannst Kommas für eine bessere Lesbarkeit verwenden. Sie werden wie Leerraum behandelt.
+; Sets sind Sammlungen, die eindeutige Elemente enthalten.
+#{:a :b 88 "huat"}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; makierte Elemente ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; EDN kann erweitert werden, indem Elemente mit # Symbolen makiert werden.
+
+#MyYelpClone/MenuItem {:name "eggs-benedict" :rating 10}
+
+; Lass mich das mit einem Clojure Beispiel erklären.
+; Angenommen ich möchte dieses Stück EDM in einen MenuItem record umwandeln.
+(defrecord MenuItem [name rating])
+   
+; Um EDN in clojure Werte umzuwandeln, muss ich den eingebauten EDN Leser 
+;edn/read-string verwenden
+
+(edn/read-string "{:eggs 2 :butter 1 :flour 5}")
+; -> {:eggs 2 :butter 1 :flour 5}
+
+; Definiere die Leserfunktion, um markierte Elemente zu transformieren
+; und übergebe eine Map, die Tags den Lesefunktionen als edn / read-string zuweisen
+
+(edn/read-string {:readers {'MyYelpClone/MenuItem map->menu-item}}
+                 "#MyYelpClone/MenuItem {:name \"eggs-benedict\" :rating 10}")
+; -> #user.MenuItem{:name "eggs-benedict", :rating 10}
+
+```
+
+# Referenzen
+
+- [EDN spec](https://github.com/edn-format/edn)
+- [Implementationen](https://github.com/edn-format/edn/wiki/Implementations)
+- [makierte Elemente](http://www.compoundtheory.com/clojure-edn-walkthrough/)
diff --git a/de-de/nix-de.html.markdown b/de-de/nix-de.html.markdown
new file mode 100644
index 00000000..8c78ffbc
--- /dev/null
+++ b/de-de/nix-de.html.markdown
@@ -0,0 +1,358 @@
+---
+language: nix
+filename: learnnix-de.nix
+contributors:
+    - ["Chris Martin", "http://chris-martin.org/"]
+translators:
+    - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+
+Nix ist eine simple funktionale Programmiersprache, die für den 
+[Nix package manager](https://nixos.org/nix/) und
+[NixOS](https://nixos.org/) entwickelt wurde.
+
+Du kannst Nix Ausdrücke evaluieren mithilfe von 
+[nix-instantiate](https://nixos.org/nix/manual/#sec-nix-instantiate)
+oder [`nix-repl`](https://github.com/edolstra/nix-repl).
+
+```
+with builtins; [
+
+  #  Kommentare
+  #=========================================
+
+  # Inline Kommentare sehen so aus.
+
+  /* Multizeilen Kommentare 
+     sehen so aus. */
+
+
+  #  Booleans
+  #=========================================
+
+  (true && false)               # Und
+  #=> false
+
+  (true || false)               # Oder
+  #=> true
+
+  (if 3 < 4 then "a" else "b")  # Bedingungen
+  #=> "a"
+
+
+  #  Integers
+  #=========================================
+
+  # Integers sind die einzigen numerischen Typen.
+
+  1 0 42 (-3)       # Einige integers
+
+  (4 + 6 + 12 - 2)  # Addition
+  #=> 20
+
+  (7 / 2)           # Division
+  #=> 3
+
+
+  #  Strings
+  #=========================================
+
+  "String Literale sind in Gänsefüßchen."
+
+  "
+    String Literale können mehrere 
+    Zeilen umspannen.
+  "
+
+  ''
+    Dies wird als Literal mit eingerückten String bezeichnet.
+    Es entfernt intelligent führende Leerzeichen.
+  ''
+
+  ''
+    a
+      b
+  ''
+  #=> "a\n  b"
+
+  ("ab" + "cd")   # String Konkatenation
+  #=> "abcd"
+
+  # Mit Antiquotation kannst du Werte in Strings einbetten.
+  ("Dein Homeverzeichnis ist ${getEnv "HOME"}")
+  #=> "Dein Homeverzeichnis ist /home/alice"
+
+
+  #  Paths
+  #=========================================
+
+  # Nix besitzt einen primitven Datentyp für Pfade
+  /tmp/tutorials/learn.nix
+
+  # Ein relativer Pfad wird beim Parsing zu einem absoluten Pfad aufgelöst,
+  # relativ zu der Datei in der es auftritt.
+  tutorials/learn.nix
+  #=> /the-base-path/tutorials/learn.nix
+
+  # Ein Pfad muss mindestens einen Schrägstrich enthalten. Ein Pfad für eine 
+  # Datei im selben Verzeichnis benötigt ein ./ Präfix.
+  ./learn.nix
+  #=> /the-base-path/learn.nix
+
+  # Der / Operator muss von Leerraum umgeben sein wenn du dividieren möchtest.
+  7/2        # Das ist ein Pfadliteral
+  (7 / 2)    # Das ist ein Integerliteral
+
+
+  #  Importe
+  #=========================================
+
+  # Eine nix Datei besitzt einen einzelnen top-level Ausdruck mit keinen freien Variablen.
+  # Ein Import-Ausdruck wird zum Wert der Datei, die importiert wird, ausgewertet.
+  (import /tmp/foo.nix)
+
+  # Importe können ebenso mit Strings spezifiziert werden.
+  (import "/tmp/foo.nix")
+
+  # Import Pfade müssen absolut sein. Pfadliterale
+  # sind automatisch aufgelöst, das ist ein Ordnung.
+  (import ./foo.nix)
+
+  # Jedoch passiert dies nicht mit Strings.
+  (import "./foo.nix")
+  #=> error: string ‘foo.nix’ doesn't represent an absolute path
+
+
+  #  Let
+  #=========================================
+
+  # `let` Blöcke erlauben es uns Werte zu Variablen zu binden.
+  (let x = "a"; in
+    x + x + x)
+  #=> "aaa"
+
+  # Bindungen können auf sich gegenseitig verweisen. Die Reihenfolge spielt
+  # keine Rolle.
+  (let y = x + "b";
+       x = "a"; in
+    y + "c")
+  #=> "abc"
+
+  # Innere Bindungen überschatten Äußere.
+  (let a = 1; in
+    let a = 2; in
+      a)
+  #=> 2
+
+
+  #  Funktionen
+  #=========================================
+
+  (n: n + 1)      # Funktion, die 1 addiert
+
+  ((n: n + 1) 5)  # Dieselbe Funktion angewendet auf 5.
+  #=> 6
+
+  # Es gibt keine spezielle Syntax für benannte Funktionen, aber sie
+  # können mit `let` Blöcken, wie jeder andere Wert auch, gebunden werden.
+  (let succ = (n: n + 1); in succ 5)
+  #=> 6
+
+  # Eine Funktion hat genau ein Argument.
+  # Mehrere Argumente können erreicht werden mithilfe von Currying.
+  ((x: y: x + "-" + y) "a" "b")
+  #=> "a-b"
+
+  # Benannte Funktionsargumente gibt es auch. Diese werden wir einführen, nachdem wir uns Sets
+  # angeschaut haben.
+
+  #  Listen
+  #=========================================
+
+  # Listen werden durck eckige Klammern gekennzeichnet.
+
+  (length [1 2 3 "x"])
+  #=> 4
+
+  ([1 2 3] ++ [4 5])
+  #=> [1 2 3 4 5]
+
+  (concatLists [[1 2] [3 4] [5]])
+  #=> [1 2 3 4 5]
+
+  (head [1 2 3])
+  #=> 1
+  (tail [1 2 3])
+  #=> [2 3]
+
+  (elemAt ["a" "b" "c" "d"] 2)
+  #=> "c"
+
+  (elem 2 [1 2 3])
+  #=> true
+  (elem 5 [1 2 3])
+  #=> false
+
+  (filter (n: n < 3) [1 2 3 4])
+  #=> [ 1 2 ]
+
+
+  #  Sets
+  #=========================================
+
+  # Ein "Set" ist eine ungeordnete Zuordnung mit Stringschlüsseln.
+  { foo = [1 2]; bar = "x"; }
+
+  # Der . Operator nimmt einen Wert aus dem Set.
+  { a = 1; b = 2; }.a
+  #=> 1
+
+  # Der ? Operator testet, ob der Schlüssel in dem Set vorhanden ist.
+  ({ a = 1; b = 2; } ? a)
+  #=> true
+  ({ a = 1; b = 2; } ? c)
+  #=> false
+
+  # Der // Operator mergt zwei Sets.
+  ({ a = 1; } // { b = 2; })
+  #=> { a = 1; b = 2; }
+
+  # Werte auf der rechten Seite überschrieben die Werte auf der linken Seite.
+  ({ a = 1; b = 2; } // { a = 3; c = 4; })
+  #=> { a = 3; b = 2; c = 4; }
+
+  # Das Schlüsselwort rec bezeichenet ein "rekursives Set", in der sich Attribute
+  # aufeinander beziehen können.
+  (let a = 1; in     { a = 2; b = a; }.b)
+  #=> 1
+  (let a = 1; in rec { a = 2; b = a; }.b)
+  #=> 2
+
+  # Verschachetelte Sets können stückweise definiert werden.
+  {
+    a.b   = 1;
+    a.c.d = 2;
+    a.c.e = 3;
+  }.a.c
+  #=> { d = 2; e = 3; }
+
+  # Die Nachkommen eines Attributs können in diesem Feld nicht zugeordnet werden, wenn
+  # das Attribut selbst nicht zugeweisen wurde. 
+  {
+    a = { b = 1; };
+    a.c = 2;
+  }
+  #=> error: attribute ‘a’ already defined
+
+
+  #  With
+  #=========================================
+
+  # Der Körper eines Sets Blocks wird mit der Zurodnung eines Satzes an die Variablen gebunden.
+  (with { a = 1; b = 2; };
+    a + b)
+  # => 3
+
+  # Innere Bindungen überschatten äußere Bindungen.
+  (with { a = 1; b = 2; };
+    (with { a = 5; };
+      a + b))
+  #=> 7
+
+  # Die erste Linie diese Tutorials startet mit "with builtins;",
+  # weil builtins ein Set mit allen eingebauten 
+  # Funktionen (length, head, tail, filter, etc.) umfasst.
+  # Das erspart uns beispielseweise "builtins.length" zu schreiben, 
+  # anstatt nur "length".
+
+
+  #  Set patterns
+  #=========================================
+
+  # Sets sind nützlich, wenn du mehrere Werte einer Funktion
+  # übergeben musst.
+  (args: args.x + "-" + args.y) { x = "a"; y = "b"; }
+  #=> "a-b"
+
+  # Dies kann mit Hilfe von Set patterns deutlicher geschrieben werden.
+  ({x, y}: x + "-" + y) { x = "a"; y = "b"; }
+  #=> "a-b"
+
+  # Standardmäßig schlägt das Muster bei Sets mit zusätzlichen Schlüsseln fehl.
+  ({x, y}: x + "-" + y) { x = "a"; y = "b"; z = "c"; }
+  #=> error: anonymous function called with unexpected argument ‘z’
+
+  # Durch Hinzufügen von ", ..." können zusätzliche Schlüssel ignoriert werden.
+  ({x, y, ...}: x + "-" + y) { x = "a"; y = "b"; z = "c"; }
+  #=> "a-b"
+
+
+  #  Errors
+  #=========================================
+
+  # `throw` bewirkt, dass die Auswertung mit einer Fehlermeldung abgebrochen wird.
+  (2 + (throw "foo"))
+  #=> error: foo
+
+  # `tryEval` fängt geworfene Fehler.
+  (tryEval 42)
+  #=> { success = true; value = 42; }
+  (tryEval (2 + (throw "foo")))
+  #=> { success = false; value = false; }
+
+  # `abort` ist ähnlich wie throw, aber es ist fatal. Es kann nicht gefangen werden.
+  (tryEval (abort "foo"))
+  #=> error: evaluation aborted with the following error message: ‘foo’
+
+  # `assert` evaluiert zu dem gegebenen Wert, wenn die Bedingung wahr ist, sonst 
+  # löst es eine abfangbare Exception aus.
+  (assert 1 < 2; 42)
+  #=> 42
+  (assert 1 > 2; 42)
+  #=> error: assertion failed at (string):1:1
+  (tryEval (assert 1 > 2; 42))
+  #=> { success = false; value = false; }
+
+
+  #  Impurity
+  #=========================================
+
+  # Da die Wiederholbarkeit von Builds für den Nix Packetmangager entscheidend ist,
+  # werden in der Nix Sprache reine funktionale Elemente betont. Es gibt aber ein paar 
+  # unreine Elemente.
+  # Du kannst auf Umgebungsvarialben verweisen.
+  (getEnv "HOME")
+  #=> "/home/alice"
+
+  # Die trace Funktion wird zum Debugging verwendet. Sie gibt das erste Argument zu stderr aus
+  # und evaluiert das zweite Argument.
+  (trace 1 2)
+  #=> trace: 1
+  #=> 2
+
+  # Du kannst Dateien in den Nix store schreiben. Obwohl unrein, kannst du dir relativ sicher sein,
+  # dass es sicher ist, da der Dateiname aus dem Hash des Inhalts abgeleitet wird.
+  # Du kannst Dateien von überall lesen. In diesem Beispiel schreiben wir Dateien in den Store
+  # und lesen wieder davon.
+  (let filename = toFile "foo.txt" "hello!"; in
+    [filename (builtins.readFile filename)])
+  #=> [ "/nix/store/ayh05aay2anx135prqp0cy34h891247x-foo.txt" "hello!" ]
+
+  # Außerdem können wir Dateien in den Nix Store downloaden.
+  (fetchurl "https://example.com/package-1.2.3.tgz")
+  #=> "/nix/store/2drvlh8r57f19s9il42zg89rdr33m2rm-package-1.2.3.tgz"
+
+]
+```
+
+### Weitere Resourcen
+
+* [Nix Manual - Nix expression language]
+  (https://nixos.org/nix/manual/#ch-expression-language)
+
+* [James Fisher - Nix by example - Part 1: The Nix expression language]
+  (https://medium.com/@MrJamesFisher/nix-by-example-a0063a1a4c55)
+
+* [Susan Potter - Nix Cookbook - Nix By Example]
+  (http://funops.co/nix-cookbook/nix-by-example/)
diff --git a/de-de/pyqt-de.html.markdown b/de-de/pyqt-de.html.markdown
new file mode 100644
index 00000000..93ee20d4
--- /dev/null
+++ b/de-de/pyqt-de.html.markdown
@@ -0,0 +1,89 @@
+---
+category: tool
+tool: PyQT
+filename: learnpyqt-de.py
+contributors:
+    - ["Nathan Hughes", "https://github.com/sirsharpest"]
+translators:
+    - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de
+---
+
+**Qt** ist eine weit bekanntes Framework mit den man plattformunabhängige Programme schreiben kann,
+die auf verschiedenen Sotfware und Hardware Plattformen laufen mit kleinen oder keinen Änderungen im Code.
+Dabei besitzen sie trozdem die Power und Geschwindigkeit von nativen Anwendungen.
+**Qt** wurde ursprünglich in *C++** geschrieben.
+
+Das ist eine Adaption von dem C++ Intro für QT von [Aleksey Kholovchuk](https://github.com/vortexxx192),
+manche der Codebeispiele sollte in der selben Funktionalität resultieren.
+Diese Version wurde in pyqt erstellt.
+
+```python
+import sys
+from PyQt4 import QtGui
+	
+def window():
+	# Erschafft ein Anwendungsobjekt.
+    app = QtGui.QApplication(sys.argv)
+	# Erschafft ein Widget, auf dem unser Label platziert wird.
+    w = QtGui.QWidget()
+	# Fügt ein Label zu dem Widget hinzu.
+    b = QtGui.QLabel(w)
+	# Setzt einen Text für das Label.
+    b.setText("Hello World!")
+	# Setzt die Größe und die Platzierungsinfomationen.
+    w.setGeometry(100, 100, 200, 50)
+    b.move(50, 20)
+	# Setzt unserem Fenster einen schönen Titel.
+    w.setWindowTitle("PyQt")
+	# Lässt alles anzeigen.
+    w.show()
+	# Führe alles aus, nachdem wir alles aufgebaut haben.
+    sys.exit(app.exec_())
+
+if __name__ == '__main__':
+    window()
+
+```
+
+Damit wir weitere fortgeschrittene Funktionen in **pyqt** verwenden können,
+müssen wir anfangen zusätzliche Elemente zu bauen.
+Hier zeigen wir wie man eine Dialog Popup Box einführt. 
+Diese ist nützlich, um den Benutzer eine Entscheidung zu bestätigen oder um Informationen anzuzeigen.
+
+```Python 
+import sys
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+
+
+def window():
+    app = QApplication(sys.argv)
+    w = QWidget()
+    # Erschafft einen Knopf und fügt das Widget w hinzu
+    b = QPushButton(w)
+    b.setText("drücke mich")
+    b.move(50, 50)
+    # Wenn b gedrückt wird, wird diese Funktion aufgerufen.
+    # Bemerke das Fehlen von () bei dem Funktionsaufruf.
+    b.clicked.connect(showdialog)
+    w.setWindowTitle("PyQt Dialog")
+    w.show()
+    sys.exit(app.exec_())
+	
+# Diese Funktion soll ein Dialogfenster mit einem Knopf erschaffen.
+# Der Knopf wartet bis er geklickt wird und beendet das Programm
+def showdialog():
+    d = QDialog()
+    b1 = QPushButton("ok", d)
+    b1.move(50, 50)
+    d.setWindowTitle("Dialog")
+    # Diese Modalität sagt dem Popup, dass es den Parent blocken soll, solange es aktiv ist.
+    d.setWindowModality(Qt.ApplicationModal)
+    # Beim klicken möchte ich, dass der gesamte Prozess beendet wird.
+    b1.clicked.connect(sys.exit)
+    d.exec_()
+
+if __name__ == '__main__':
+    window()
+```
diff --git a/de-de/qt-de.html.markdown b/de-de/qt-de.html.markdown
new file mode 100644
index 00000000..480030fe
--- /dev/null
+++ b/de-de/qt-de.html.markdown
@@ -0,0 +1,175 @@
+---
+category: tool
+tool: Qt Framework
+language: c++
+filename: learnqt-de.cpp
+contributors:
+    - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
+translators:
+    - ["Dennis Keller", "https://github.com/denniskeller"]
+lang: de-de    
+---
+
+**Qt** ist ein weithin bekanntes Framework zum Entwickeln von cross-platform Software,
+die auf verschiedenen Hard- und Softwareplatformen mit wenig oder keinen Veränderungen im Code läuft.
+Dabei besitzt man die Power und Geschiwindigkeit von nativen Anwendungen.
+Obwohl **Qt** ursprünglich in *C++* geschrieben wurde,
+gibt es verschiedene Ports für andere Sprachen: *[PyQt](https://learnxinyminutes.com/docs/pyqt/)*, *QtRuby*, *PHP-Qt*, etc.
+
+**Qt** eignet sich hervorragend zum Erstellen von Anwendungen mit grafischer Benutzeroberfläche (GUI).
+Dieses Tutorial zeigt, wie man das in *C++* macht.
+
+```c++
+/*
+ * Lass uns klassisch starten
+ */
+
+// Alle Header vom Qt Framework starten mit dem Großbuchstaben 'Q'.
+#include <QApplication>
+#include <QLineEdit>
+
+int main(int argc, char *argv[]) {
+    // Erstellt ein Objekt um applikationsweit die Resourcen zu managen.
+    QApplication app(argc, argv);
+
+    // Erstellt ein Line edit Widget und zeigt es auf dem Bildschirm
+    QLineEdit lineEdit("Hello world!");
+    lineEdit.show();
+
+    // Startet die Event Loop der Anwendung.
+    return app.exec();
+}
+```
+
+Die GUI bezogene Teile von **Qt** bestehen aus *Widgets* und den *Verbindungen*
+dazwischen.
+
+[Lies mehr über Widgets](http://doc.qt.io/qt-5/qtwidgets-index.html)
+
+```c++
+/*
+ * Lass uns Label und einen Button machen.
+ * Ein Label soll auftauchen, wenn der Button gedrückt wird.
+ * 
+ * Der Qt Code spricht für sich selbst.
+ */
+ 
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QLabel>
+
+int main(int argc, char *argv[]) {
+    QApplication app(argc, argv);
+
+    QDialog dialogWindow;
+    dialogWindow.show();
+    
+    // Füge ein vertikales Layout hinzu
+    QVBoxLayout layout;
+    dialogWindow.setLayout(&layout);  
+
+    QLabel textLabel("Danke für das Knopf drücken");
+    layout.addWidget(&textLabel);
+    textLabel.hide();
+
+    QPushButton button("Drück mich");
+    layout.addWidget(&button);
+    
+    // Zeigt verstecktes Label, wenn der Button gedrückt wird.
+    QObject::connect(&button, &QPushButton::pressed,
+                     &textLabel, &QLabel::show);
+
+    return app.exec();
+}
+```
+
+Beachte den *QObject::connect* Teil. Diese Methode wird verwendet,
+um *Signale* eines Objekts mit den *Slots* eines Objektes zu verbinden.
+
+**Signale** werden ausgegeben, wenn bestimmte Dinge mit Objekten passieren.
+Beispielsweise wird das *pressed* Signal ausgegeben,
+wenn der Benutzer auf das QPushButton Objekt drückt.
+
+**Slots** sind Aktionen, die als Reaktion auf empfangene Signale ausgeführt werden können.
+
+[Lies mehr über Slots und Signale](http://doc.qt.io/qt-5/signalsandslots.html)
+
+
+Als Nächstes lernen wir, dass wir nicht nur Standard Widgets verwenden können,
+sondern auch ihr Verhalten mithilfe von Vererbung verändern können.
+Lass uns einen Button erschaffen, der zählt, wie häufig er gedrückt wird.
+Dafür definieren wir unsere eigene Klasse *CounterLabel*.
+Diese muss wegen der speziellen Qt Architektur in einer seperaten Datei deklariert werden.
+
+```c++
+// counterlabel.hpp
+
+#ifndef COUNTERLABEL
+#define COUNTERLABEL
+
+#include <QLabel>
+
+class CounterLabel : public QLabel {
+    Q_OBJECT  // Qt definiertes Makro, welches in jedem modifizierten Widget vorhanden sein muss.
+
+public:
+    CounterLabel() : counter(0) {
+        setText("Zähler wurde noch nicht erhöht.");  // Methode von QLabel
+    }
+
+public slots:
+    // Aktion, die ausgeführt wird, wenn der Button gedrückt wird.
+    void increaseCounter() {
+        setText(QString("Zähler Wert: %1").arg(QString::number(++counter)));
+    }
+
+private:
+    int counter;
+};
+
+#endif // Zähllabel
+```
+
+```c++
+// main.cpp
+// Fast das Gleiche, wie das vorherige Beispiel
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QString>
+#include "counterlabel.hpp"
+
+int main(int argc, char *argv[]) {
+    QApplication app(argc, argv);
+
+    QDialog dialogWindow;
+    dialogWindow.show();
+
+    QVBoxLayout layout;
+    dialogWindow.setLayout(&layout);
+
+    CounterLabel counterLabel;
+    layout.addWidget(&counterLabel);
+
+    QPushButton button("Drück mich nochmal.");
+    layout.addWidget(&button);
+    QObject::connect(&button, &QPushButton::pressed,
+                     &counterLabel, &CounterLabel::increaseCounter);
+
+    return app.exec();
+}
+```
+
+Das wars! Natürlich ist das Qt Framework erheblich größer, als der der Teil der in diesem Tutorial behandelt wurde.
+Das heißt, es gibt viel zu lesen und zu üben.
+
+## Further reading
+
+- [Qt 4.8 tutorials](http://doc.qt.io/qt-4.8/tutorials.html)
+- [Qt 5 tutorials](http://doc.qt.io/qt-5/qtexamplesandtutorials.html)
+
+Viel Erfolg und viel Spaß!
diff --git a/edn.html.markdown b/edn.html.markdown
index 04346eb8..f47853f0 100644
--- a/edn.html.markdown
+++ b/edn.html.markdown
@@ -44,13 +44,13 @@ false
 :cheese
 :olives
 
-; Symbols are used to represent identifiers. They start with #.
+; Symbols are used to represent identifiers. 
 ; You can namespace symbols by using /. Whatever precedes / is
-; the namespace of the name.
-#spoon
-#kitchen/spoon ; not the same as #spoon
-#kitchen/fork
-#github/fork   ; you can't eat with this
+; the namespace of the symbol.
+spoon
+kitchen/spoon ; not the same as spoon
+kitchen/fork
+github/fork   ; you can't eat with this
 
 ; Integers and floats
 42
@@ -84,22 +84,26 @@ false
 
 #MyYelpClone/MenuItem {:name "eggs-benedict" :rating 10}
 
-; Let me explain this with a clojure example. Suppose I want to transform that
+; Let me explain this with a Clojure example. Suppose I want to transform that
 ; piece of EDN into a MenuItem record.
 
 (defrecord MenuItem [name rating])
 
-; To transform EDN to clojure values, I will need to use the built in EDN
-; reader, edn/read-string
+; defrecord defined, among other things, map->MenuItem which will take a map
+; of field names (as keywords) to values and generate a user.MenuItem record
 
-(edn/read-string "{:eggs 2 :butter 1 :flour 5}")
+; To transform EDN to Clojure values, I will need to use the built-in EDN
+; reader, clojure.edn/read-string
+
+(clojure.edn/read-string "{:eggs 2 :butter 1 :flour 5}")
 ; -> {:eggs 2 :butter 1 :flour 5}
 
-; To transform tagged elements, define the reader function and pass a map
-; that maps tags to reader functions to edn/read-string like so
+; To transform tagged elements, pass to clojure.edn/read-string an option map
+; with a :readers map that maps tag symbols to data-reader functions, like so
 
-(edn/read-string {:readers {'MyYelpClone/MenuItem map->menu-item}}
-                 "#MyYelpClone/MenuItem {:name \"eggs-benedict\" :rating 10}")
+(clojure.edn/read-string
+    {:readers {'MyYelpClone/MenuItem map->MenuItem}}
+    "#MyYelpClone/MenuItem {:name \"eggs-benedict\" :rating 10}")
 ; -> #user.MenuItem{:name "eggs-benedict", :rating 10}
 
 ```
diff --git a/it-it/rst-it.html.markdown b/it-it/rst-it.html.markdown
new file mode 100644
index 00000000..8947c738
--- /dev/null
+++ b/it-it/rst-it.html.markdown
@@ -0,0 +1,110 @@
+---
+language: restructured text (RST)
+filename: restructuredtext-it.rst
+contributors:
+    - ["DamienVGN", "https://github.com/martin-damien"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
+translators:
+    - ["Ale46", "https://github.com/Ale46"]
+lang: it-it
+---
+
+RST è un formato di file formalmente creato dalla comunità Python per scrivere documentazione (e quindi fa parte di Docutils).
+
+I file RST sono semplici file di testo con una sintassi leggera (in confronto all'HTML).
+
+## Installazione
+
+Per usare Restructured Text, sarà necessario installare [Python](http://www.python.org) ed il pacchetto `docutils`.
+
+`docutils` può essere installato da riga di comando:
+
+```bash
+$ easy_install docutils
+```
+
+O se il tuo sistema ha `pip`, puoi usare anche lui:
+
+```bash
+$ pip install docutils
+```
+
+
+## Sintassi del file
+
+Un semplice esempio della sintassi del file:
+
+```
+.. Le righe che iniziano con due punti sono comandi speciali. Ma se non è possibile trovare alcun comando, la riga viene considerata come un commento
+
+===============================================================================
+I titoli principali sono scritti utilizzando caratteri di uguale, sopra e sotto
+===============================================================================
+
+Si noti che devono esistere tanti caratteri di uguale quanti sono i caratteri del titolo.
+
+Anche il titolo è sottolineato con caratteri di uguale
+======================================================
+
+Sottotitoli con i trattini
+--------------------------
+
+E sotto-sottotitoli con tildi
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Puoi inserire il testo in *corsivo* o in **grassetto**, puoi "contrassegnare" il testo come codice con un doppio apice ``: `` print () ``.
+
+Le liste sono semplici come in Markdown:
+
+- primo articolo
+- Secondo elemento
+     - Sottoelemento
+
+o
+
+* Primo elemento
+* Secondo elemento
+     * Sottoelemento
+
+Le tabelle sono davvero facili da scrivere:
+
+=========== ========
+Stato       Capitale
+=========== ========
+Francia     Parigi
+Giappone    Tokio
+=========== ========
+
+Le tabelle più complesse possono essere fatte facilmente (colonne e/o righe unite) ma ti suggerisco di leggere il documento completo per questo :)
+
+Esistono diversi modi per creare collegamenti:
+
+- Aggiungendo un underscore dopo una parola: Github_ e aggiungendo l'URL di destinazione dopo il testo (questo modo ha il vantaggio di non inserire URL non necessari all'interno del testo leggibile).
+- Digitando un URL completo: https://github.com/ (verrà automaticamente convertito in un collegamento)
+- Facendo un collegamento simile a Markdown: `Github <https://github.com/>`_ .
+
+.. _Github https://github.com/
+
+```
+
+
+## Come usarlo
+
+RST viene fornito con docutils che dispone di `rst2html`, per esempio:
+
+```bash
+$ rst2html miofile.rst output.html
+```
+
+*Nota : In alcuni sistemi il comando potrebbe essere rst2html.py*
+
+Ma ci sono applicazioni più complesse che utilizzano il formato RST:
+
+- [Pelican](http://blog.getpelican.com/), un generatore di siti statici
+- [Sphinx](http://sphinx-doc.org/), un generatore di documentazione
+- e molti altri
+
+
+## Letture
+
+- [Riferimento ufficiale rapido](http://docutils.sourceforge.net/docs/user/rst/quickref.html)
diff --git a/nim.html.markdown b/nim.html.markdown
index 07674532..30dfa94f 100644
--- a/nim.html.markdown
+++ b/nim.html.markdown
@@ -12,6 +12,25 @@ that gives the programmer power without compromises on runtime efficiency.
 Nim is efficient, expressive, and elegant.
 
 ```nim
+# Single-line comments start with a #
+
+#[
+  Multi-line comments begin with a #[
+  ... and end with ]#
+
+They don't care about indentation
+
+  #[
+  and they can be nested
+  ]#
+
+]#
+
+discard """
+This can also work as a multiline comment.
+Or for unparsable, broken code
+"""
+
 var                     # Declare (and assign) variables,
   letter: char = 'n'    # with or without type annotations
   lang = "N" & "im"
@@ -35,10 +54,6 @@ when compileBadCode:            # `when` is a compile time `if`
 discard 1 > 2 # Note: The compiler will complain if the result of an expression
               # is unused. `discard` bypasses this.
 
-discard """
-This can work as a multiline comment.
-Or for unparsable, broken code
-"""
 
 #
 # Data Structures
diff --git a/pt-br/amd-pt.html.markdown b/pt-br/amd-pt.html.markdown
index 38c1f70f..40c7cd09 100644
--- a/pt-br/amd-pt.html.markdown
+++ b/pt-br/amd-pt.html.markdown
@@ -141,7 +141,7 @@ require(['jquery', 'coolLibFromBower', 'modules/algunsHelpers'], function($, coo
   coolLib.facaAlgoDoidoCom(helpers.transform($('#foo')));
 });
 ```
-Apps baseados em `require.js` geralmente terão u´m único ponto de acesso (`main.js`) que é passado à tag script do `require.js` como um data-attribute. Ele vai ser automaticamente carregado e executado com o carregamento da página:
+Apps baseados em `require.js` geralmente terão um único ponto de acesso (`main.js`) que é passado à tag script do `require.js` como um data-attribute. Ele vai ser automaticamente carregado e executado com o carregamento da página:
 
 ```html
 <!DOCTYPE html>
diff --git a/pt-br/asciidoc-pt.html.markdown b/pt-br/asciidoc-pt.html.markdown
index 1dee31db..b12c0693 100644
--- a/pt-br/asciidoc-pt.html.markdown
+++ b/pt-br/asciidoc-pt.html.markdown
@@ -99,7 +99,7 @@ Para criar uma lista com marcadores use asteriscos.
 * baz
 ```
 
-Para criar uma lista númerada use pontos.
+Para criar uma lista numerada use pontos.
 
 ```
 . item 1
diff --git a/pt-br/asymptotic-notation-pt.html.markdown b/pt-br/asymptotic-notation-pt.html.markdown
index 2e299d09..aecc2194 100644
--- a/pt-br/asymptotic-notation-pt.html.markdown
+++ b/pt-br/asymptotic-notation-pt.html.markdown
@@ -38,7 +38,7 @@ Na primeira seção desse documento, descrevemos como Notação Assintótica ide
  *f*, *n* como o tamanho da entrada e *f(n)* sendo o tempo de execução. Então,
  para dado algoritmo *f*, com entrada de tamanho *n*, você terá tempo de execução
  *f(n)*. Isto resulta em um gráfico onde a coordernada Y é o tempo de execução
-, a coordernada X representa o tamanho da entrada e os pontos representao o tempo
+, a coordernada X representa o tamanho da entrada e os pontos representam o tempo
 de execução para dado tamanho de entrada.
 
 Você pode representar a função, ou o algoritmo, com Notação Assintótica de várias
diff --git a/pt-br/c++-pt.html.markdown b/pt-br/c++-pt.html.markdown
index c1cfbbb1..09bfc825 100644
--- a/pt-br/c++-pt.html.markdown
+++ b/pt-br/c++-pt.html.markdown
@@ -20,7 +20,7 @@ foi concebida para
 
 Embora sua sintaxe pode ser mais difícil ou complexa do que as linguagens mais
 recentes, C++ é amplamente utilizado porque compila para instruções nativas que
-podem ser executadas diretamente pelo processador e oferece um controlo rígido sobre hardware (como C), enquanto oferece recursos de alto nível, como os
+podem ser executadas diretamente pelo processador e oferece um controle rígido sobre hardware (como C), enquanto oferece recursos de alto nível, como os
 genéricos, exceções e classes. Esta combinação de velocidade e funcionalidade
 faz C++ uma das linguagens de programação mais utilizadas.
 
@@ -40,10 +40,10 @@ faz C++ uma das linguagens de programação mais utilizadas.
 
 int main(int argc, char** argv)
 {
-    // Argumentos de linha de comando são passados em pelo argc e argv da mesma
+    // Argumentos de linha de comando são passados para argc e argv da mesma
     // forma que eles estão em C.
     // argc indica o número de argumentos,
-    // e argv é um array de strings, feito C (char*) representado os argumentos
+    // e argv é um array de strings, feito C (char*) representando os argumentos
     // O primeiro argumento é o nome pelo qual o programa foi chamado.
     // argc e argv pode ser omitido se você não se importa com argumentos,
     // dando a assinatura da função de int main()
@@ -274,7 +274,7 @@ public:
 
     void setWeight(int dogsWeight);
 
-    // Funções que não modificam o estado do objecto devem ser marcadas como
+    // Funções que não modificam o estado do objeto devem ser marcadas como
     // const. Isso permite que você chamá-los se for dada uma referência const
     // para o objeto. Além disso, observe as funções devem ser explicitamente
     // declarados como _virtual_, a fim de ser substituídas em classes
diff --git a/pt-br/c-pt.html.markdown b/pt-br/c-pt.html.markdown
index 6e7aa8c2..c0cfb0ba 100644
--- a/pt-br/c-pt.html.markdown
+++ b/pt-br/c-pt.html.markdown
@@ -191,7 +191,7 @@ int main() {
     f1 / f2; // => 0.5, mais ou menos epsilon
     // Números e cálculos de ponto flutuante não são exatos
 
-    // Modulo também existe
+    // Módulo também existe
     11 % 3; // => 2
 
 	// Operadores de comparação provavelmente são familiares,
diff --git a/python3.html.markdown b/python3.html.markdown
index 5aa61b65..37987582 100644
--- a/python3.html.markdown
+++ b/python3.html.markdown
@@ -669,7 +669,7 @@ class Human:
 
     # An instance method. All methods take "self" as the first argument
     def say(self, msg):
-        print ("{name}: {message}".format(name=self.name, message=msg))
+        print("{name}: {message}".format(name=self.name, message=msg))
 
     # Another instance method
     def sing(self):
@@ -740,10 +740,105 @@ if __name__ == '__main__':
 
 
 ####################################################
-## 6.1 Multiple Inheritance
+## 6.1 Inheritance
+####################################################
+
+# Inheritance allows new child classes to be defined that inherit methods and
+# variables from their parent class. 
+
+# Using the Human class defined above as the base or parent class, we can
+# define a child class, Superhero, which inherits the class variables like
+# "species", "name", and "age", as well as methods, like "sing" and "grunt"
+# from the Human class, but can also have its own unique properties.
+
+# To take advantage of modularization by file you could place the classes above in their own files,
+# say, human.py
+
+# To import functions from other files use the following format
+# from "filename-without-extension" import "function-or-class"
+
+from human import Human
+
+
+# Specify the parent class(es) as parameters to the class definition
+class Superhero(Human):
+
+    # If the child class should inherit all of the parent's definitions without
+    # any modifications, you can just use the "pass" keyword (and nothing else)
+    # but in this case it is commented out to allow for a unique child class:
+    # pass
+
+    # Child classes can override their parents' attributes
+    species = 'Superhuman'
+
+    # Children automatically inherit their parent class's constructor including
+    # its arguments, but can also define additional arguments or definitions
+    # and override its methods such as the class constructor.
+    # This constructor inherits the "name" argument from the "Human" class and
+    # adds the "superpower" and "movie" arguments:
+    def __init__(self, name, movie=False,
+                 superpowers=["super strength", "bulletproofing"]):
+
+        # add additional class attributes:
+        self.fictional = True
+        self.movie = movie
+        self.superpowers = superpowers
+
+        # The "super" function lets you access the parent class's methods
+        # that are overridden by the child, in this case, the __init__ method.
+        # This calls the parent class constructor:
+        super().__init__(name)
+
+    # overload the sing method
+    def sing(self):
+        return 'Dun, dun, DUN!'
+
+    # add an additional class method
+    def boast(self):
+        for power in self.superpowers:
+            print("I wield the power of {pow}!".format(pow=power))
+
+
+if __name__ == '__main__':
+    sup = Superhero(name="Tick")
+
+    # Instance type checks
+    if isinstance(sup, Human):
+        print('I am human')
+    if type(sup) is Superhero:
+        print('I am a superhero')
+
+    # Get the Method Resolution search Order used by both getattr() and super()
+    # This attribute is dynamic and can be updated
+    print(Superhero.__mro__)    # => (<class '__main__.Superhero'>,
+                                # => <class 'human.Human'>, <class 'object'>)
+
+    # Calls parent method but uses its own class attribute
+    print(sup.get_species())    # => Superhuman
+
+    # Calls overloaded method
+    print(sup.sing())           # => Dun, dun, DUN!
+
+    # Calls method from Human
+    sup.say('Spoon')            # => Tick: Spoon
+
+    # Call method that exists only in Superhero
+    sup.boast()                 # => I wield the power of super strength!
+                                # => I wield the power of bulletproofing!
+
+    # Inherited class attribute
+    sup.age = 31
+    print(sup.age)              # => 31
+
+    # Attribute that only exists within Superhero
+    print('Am I Oscar eligible? ' + str(sup.movie))
+
+####################################################
+## 6.2 Multiple Inheritance
 ####################################################
 
 # Another class definition
+# bat.py
 class Bat:
 
     species = 'Baty'
@@ -765,21 +860,14 @@ if __name__ == '__main__':
     print(b.say('hello'))
     print(b.fly)
 
-# To take advantage of modularization by file you could place the classes above in their own files,
-# say, human.py and bat.py
-
-# To import functions from other files use the following format
-# from "filename-without-extension" import "function-or-class"
 
+# And yet another class definition that inherits from Superhero and Bat
 # superhero.py
-from human import Human
+from superhero import Superhero
 from bat import Bat
 
-# Batman inherits from both Human and Bat
-class Batman(Human, Bat):
-
-    # Batman has its own value for the species class attribute
-    species = 'Superhero'
+# Define Batman as a child that inherits from both Superhero and Bat
+class Batman(Superhero, Bat):
 
     def __init__(self, *args, **kwargs):
         # Typically to inherit attributes you have to call super:
@@ -789,7 +877,8 @@ class Batman(Human, Bat):
         # So instead we explicitly call __init__ for all ancestors.
         # The use of *args and **kwargs allows for a clean way to pass arguments,
         # with each parent "peeling a layer of the onion".
-        Human.__init__(self, 'anonymous', *args, **kwargs)
+        Superhero.__init__(self, 'anonymous', movie=True, 
+                           superpowers=['Wealthy'], *args, **kwargs)
         Bat.__init__(self, *args, can_fly=False, **kwargs)
         # override the value for the name attribute
         self.name = 'Sad Affleck'
@@ -801,20 +890,15 @@ class Batman(Human, Bat):
 if __name__ == '__main__':
     sup = Batman()
 
-    # Instance type checks
-    if isinstance(sup, Human):
-        print('I am human')
-    if isinstance(sup, Bat):
-        print('I am bat')
-    if type(sup) is Batman:
-        print('I am Batman')
-
     # Get the Method Resolution search Order used by both getattr() and super().
     # This attribute is dynamic and can be updated
-    print(Batman.__mro__)       # => (<class '__main__.Batman'>, <class 'human.Human'>, <class 'bat.Bat'>, <class 'object'>)
+    print(Batman.__mro__)       # => (<class '__main__.Batman'>, 
+                                # => <class 'superhero.Superhero'>, 
+                                # => <class 'human.Human'>, 
+                                # => <class 'bat.Bat'>, <class 'object'>)
 
     # Calls parent method but uses its own class attribute
-    print(sup.get_species())    # => Superhero
+    print(sup.get_species())    # => Superhuman
 
     # Calls overloaded method
     print(sup.sing())           # => nan nan nan nan nan batman!
@@ -827,10 +911,10 @@ if __name__ == '__main__':
 
     # Inherited class attribute
     sup.age = 100
-    print(sup.age)
+    print(sup.age)              # => 100
 
     # Inherited attribute from 2nd ancestor whose default value was overridden.
-    print('Can I fly? ' + str(sup.fly))
+    print('Can I fly? ' + str(sup.fly)) # => Can I fly? False
 
 
 
diff --git a/r.html.markdown b/r.html.markdown
index 7a94ba05..e7486e60 100644
--- a/r.html.markdown
+++ b/r.html.markdown
@@ -663,7 +663,8 @@ require(plyr)
 
 # "pets.csv" is a file on the internet
 # (but it could just as easily be a file on your own computer)
-pets <- read.csv("http://learnxinyminutes.com/docs/pets.csv")
+require(RCurl)
+pets <- read.csv(textConnection(getURL("http://learnxinyminutes.com/docs/pets.csv")))
 pets
 head(pets, 2) # first two rows
 tail(pets, 1) # last row
diff --git a/ru-ru/ruby-ru.html.markdown b/ru-ru/ruby-ru.html.markdown
index f54c89b4..e69c6d94 100644
--- a/ru-ru/ruby-ru.html.markdown
+++ b/ru-ru/ruby-ru.html.markdown
@@ -182,8 +182,9 @@ array.[] 12 #=> nil
 array[-1] #=> 5
 array.last #=> 5
 
-# С заданными левой и правой границами индексов
-array[2, 4] #=> [3, 4, 5]
+# Задавая индекс и количество элементов
+array[0,2] #=> [1, 2]
+array[0,999] #=> [1, 2, 3, 4, 5]
 
 # Или с использованием диапазона значений
 array[1..3] #=> [2, 3, 4]
diff --git a/vi-vn/typescript-vi.html.markdown b/vi-vn/typescript-vi.html.markdown
new file mode 100644
index 00000000..ba459c11
--- /dev/null
+++ b/vi-vn/typescript-vi.html.markdown
@@ -0,0 +1,193 @@
+---
+language: TypeScript
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+translators:
+    - ["Thanh Duy Phan", "https://github.com/thanhpd"]
+filename: learntypescript-vi.ts
+lang: vi-vn
+---
+
+TypeScript là ngôn ngữ được viết nhằm tinh giản quá trình phát triển ứng dụng quy mô lớn được viết bằng JavaScript.
+TypeScript bổ sung thêm các khái niệm phổ biến như Class, Module, Interface, Generic và Static typing (tùy chọn) vào JavaScript.
+Ngôn ngữ này là tập lớn hơn của JavaScript: tất cả code JavaScript đều là code TypeScript đúng nên nó có thể được thêm vào các dự án một cách nhanh chóng. Trình biên dịch TypeScript sẽ sinh ra JavaScript.
+
+Bài viết này sẽ chỉ tập trung tới các cú pháp bổ sung mà TypeScript thêm vào thay vì nói đến cả các cú pháp [JavaScript](javascript-vi.html.markdown).
+
+Để thử dùng TypeScript với trình biên dịch, đi đến [Sân chơi TypeScript](http://www.typescriptlang.org/play) nơi mà bạn có thể nhập code, sử dụng chức năng hỗ trợ tự hoàn thành code - autocompletion và trực tiếp quan sát mã JavaScript được sinh ra.
+
+```ts
+// Đây là 3 khai báo kiểu biến cơ bản trong TypeScript
+// (JavaScript chỉ có kiểu của giá trị, không có kiểu của biến)
+let isDone: boolean = false;
+let lines: number = 42;
+let name: string = "Anders";
+
+// Bạn có thể bỏ khai báo kiểu của biến nếu như nó đã được suy ra từ kiểu giá trị cơ bản
+let isDone = false;
+let lines = 42;
+let name = "Anders";
+
+// Có kiểu biến "any" tương thích với mọi kiểu của biến,
+// được dùng khi ta không chắc chắn về kiểu của biến khi được khai báo
+let notSure: any = 4;
+notSure = "có thể là một biến kiểu string";
+notSure = false; // cũng có thể là biến kiểu boolean
+
+// Dùng từ khóa const cho khái báo biến không thay đổi (constant variable)
+const numLivesForCat = 9;
+numLivesForCat = 1; // Có lỗi!
+
+// Khi khai báo tập hợp ta có thể dùng mảng có kiểu được khai báo trước - typed array
+let list: number[] = [1, 2, 3];
+// Ta cũng có thể sử dụng mảng kiểu chung - generic array
+let list: Array<number> = [1, 2, 3];
+
+// Để dùng enumeration - danh sách của một tập hợp:
+enum Color { Red, Green, Blue };
+let c: Color = Color.Green;
+
+// Nếu function không trả về kết quả, sử dụng "void" cho kết quả trả về
+function bigHorribleAlert(): void {
+  alert("I'm a little annoying box!");
+}
+
+// Function trong TypeScript là first-class citizen (tạm dịch: phần tử hạng nhất), hỗ trợ thao tác tới các thực thể khác
+// (vd: truyền vào như tham số, được trả về từ function, chỉnh sửa, gán vào một biến)
+// TypeScript hỗ trợ sử dụng function với cú pháp lambda (mũi tên) và suy luận kiểu trả về
+
+// Các cú pháp dưới đây tương đương với nhau,
+// trình biên dịch sẽ tự nhận biết và sinh ra mã JavaScript giống nhau
+let f1 = function (i: number): number { return i * i; }
+// Kiểu trả về nếu không khai báo được tự suy diễn
+let f2 = function (i: number) { return i * i; }
+// Cú pháp mũi tên (arrow syntax)
+let f3 = (i: number): number => { return i * i; }
+// Cú pháp mũi tên với kiểu trả về được suy diễn
+let f4 = (i: number) => { return i * i; }
+// Cú pháp mũi tên với kiểu trả về được suy diễn
+// khi không sử dụng dấu ngoặc nhọn {} thì không cần sử dụng return
+let f5 = (i: number) => i * i;
+
+// Interface mang tính cấu trúc, mọi thứ có các đặc điểm (property) đều tương thích
+interface IPerson {
+  name: string;
+  // Đặc điểm có thể tùy chọn bằng sử dụng dấu "?"
+  age?: number;
+  // Có thể sử dụng function
+  move(): void;
+}
+
+// Object sử dụng interface IPerson nói trên
+// có thể được coi là 1 thực thể Person vì nó có đặc điểm name và chức năng move
+let p: Person = { name: "Bobby", move: () => { } };
+// Object sử dụng property tùy chọn
+let validPerson: Person = { name: "Bobby", age: 42, move: () => { } };
+// Khai báo dưới đây gây lỗi vì giá trị đặc điểm age không mang kiểu number
+let invalidPerson: Person = { name: "Bobby", age: true };
+
+// Interface cũng có thể mô tả đặc tả của function
+interface SearchFunc {
+  (source: string, subString: string): boolean;
+}
+// Chỉ có kiểu của tham số là quan trọng còn tên không quan trọng
+let mySearch: SearchFunc;
+mySearch = function (src: string, sub: string) {
+  return src.search(sub) != -1;
+}
+
+// Class - các khai báo mặc định là public
+class Point {
+  // Property
+  x: number;
+
+  // Constructor - sử dụng tham số với từ khóa public/private
+  // sẽ tạo ra property tương ứng (ví dụ với property y)
+  // Có thể khai báo giá trị mặc định
+
+  constructor(x: number, public y: number = 0) {
+    this.x = x;
+  }
+
+  // Function
+  dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+  // Biến Static
+  static origin = new Point(0, 0);
+}
+
+let p1 = new Point(10, 20);
+let p2 = new Point(25); // y sử dụng giá trị mặc định là 0
+
+// Thừa kế - Inheritance
+class Point3D extends Point {
+  constructor(x: number, y: number, public z: number = 0) {
+    super(x, y); // Bắt buộc phải gọi constructor của class cha
+  }
+
+  // Overwrite/Polymorphism - Ghi đè/Đa hình
+  dist() {
+    let d = super.dist();
+    return Math.sqrt(d * d + this.z * this.z);
+  }
+}
+
+// module, "." có thể được dùng như những module con
+module Geometry {
+  export class Square {
+    constructor(public sideLength: number = 0) {
+    }
+    area() {
+      return Math.pow(this.sideLength, 2);
+    }
+  }
+}
+
+let s1 = new Geometry.Square(5);
+
+// Bí danh (alias) có thể được sử dụng để tham vấn module khác
+import G = Geometry;
+
+let s2 = new G.Square(10);
+
+// Generic
+// Class
+class Tuple<T1, T2> {
+  constructor(public item1: T1, public item2: T2) {
+  }
+}
+
+// Interface
+interface Pair<T> {
+  item1: T;
+  item2: T;
+}
+
+// Function
+let pairToTuple = function <T>(p: Pair<T>) {
+  return new Tuple(p.item1, p.item2);
+};
+
+let tuple = pairToTuple({ item1: "hello", item2: "world" });
+
+// Các thư viện viết bằng JavaScript thường đi kèm file định nghĩa kiểu để có thể sử dụng cho TypeScript
+// Thêm vào tham vấn tới file định nghĩa:
+/// <reference path="jquery.d.ts" />
+
+// Template Strings - Chuỗi dạng mẫu (string sử dụng dấu `)
+// String Interpolation - Nội suy chuỗi with với template string
+let name = 'Tyrone';
+let greeting = `Chào ${name}, bạn khỏe không?`
+// Chuỗi nhiều dòng với template string
+let multiline = `Đây là ví dụ
+cho chuỗi nhiều dòng`;
+
+```
+
+## Tìm hiểu thêm
+
+* [Website TypeScript chính thức](http://www.typescriptlang.org/)
+* [Đặc tả ngôn ngữ TypeScript] (https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md)
+* [Anders Hejlsberg - Introducing TypeScript on Channel 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+* [Mã nguồn trên GitHub] (https://github.com/Microsoft/TypeScript)
+* [Definitely Typed - repository for type definitions] (http://definitelytyped.org/)
diff --git a/whip.html.markdown b/whip.html.markdown
index e7e5e427..c692714a 100644
--- a/whip.html.markdown
+++ b/whip.html.markdown
@@ -3,6 +3,7 @@ language: whip
 contributors:
   - ["Tenor Biel", "http://github.com/L8D"]
   - ["Saurabh Sandav", "http://github.com/SaurabhSandav"]
+  - ["Paulo Henrique Rodrigues Pinheiro", "https://github.com/paulohrpinheiro"]
 author: Tenor Biel
 author_url: http://github.com/L8D
 filename: whip.lisp
@@ -232,6 +233,7 @@ undefined ; user to indicate a value that hasn't been set
 (words "foobar nachos cheese") ; => ("foobar" "nachos" "cheese")
 ; Join list of strings together.
 (unwords ("foo" "bar")) ; => "foobar"
+; Successor and Predecessor
 (pred 21) ; => 20
 (succ 20) ; => 21
 ```
diff --git a/zh-cn/go-cn.html.markdown b/zh-cn/go-cn.html.markdown
index 75498367..37b4b137 100644
--- a/zh-cn/go-cn.html.markdown
+++ b/zh-cn/go-cn.html.markdown
@@ -142,6 +142,7 @@ func learnTypes() {
 func learnNamedReturns(x, y int) (z int) {
     z = x * y
     return // z is implicit here, because we named it earlier.
+}
 
 // Go全面支持垃圾回收。Go有指针，但是不支持指针运算。
 // 你会因为空指针而犯错，但是不会因为增加指针而犯错。