23 files changed, 3142 insertions, 2289 deletions

diff --git a/de-de/asciidoc-de.html.markdown b/de-de/asciidoc-de.html.markdown
index e3f64a00..d0a62c66 100644
--- a/de-de/asciidoc-de.html.markdown
+++ b/de-de/asciidoc-de.html.markdown
@@ -4,15 +4,19 @@ contributors:
     - ["Ryan Mavilia", "http://unoriginality.rocks/"]
 translators:
   - ["Dennis Keller", "https://github.com/denniskeller"]
-filename: asciidoc-de.md
+filename: asciidoc-de.adoc
 lang: de-de
 ---
 
-AsciiDoc ist eine Auszeichnungssprache ähnlich zu Markdown. Sie kann für alles verwendet werden von Büchern zu Blogs. Erfunden wurde sie 2002 von Stuart Rackham. Die Sprache ist simpel aber sie ermöglicht eine große Anzahl an Anpassungen.
+AsciiDoc ist eine Auszeichnungssprache ähnlich zu Markdown. Sie kann für alles
+verwendet werden von Büchern zu Blogs. Erfunden wurde sie 2002 von Stuart
+Rackham. Die Sprache ist simpel aber sie ermöglicht eine große Anzahl an
+Anpassungen.
 
 Kopfzeile des Dokuments
 
-Kopfzeilen sind optional und dürfen keine Leerzeilen besitzen. Sie müssen mindestens eine Leerzeile vom Inhalt versetzt sein.
+Kopfzeilen sind optional und dürfen keine Leerzeilen besitzen. Sie müssen
+mindestens eine Leerzeile vom Inhalt versetzt sein.
 
 Nur Titel
 
@@ -104,7 +108,8 @@ Um eine nummerierte Liste zu erstellen, verwendest du Punkte.
 . item 3
 ```
 
-Um Listen zu verschachteln, musst du zusätzliche Sternchen beziehungsweise Punkte hinzufügen. Dies ist bis zu fünf Mal möglich.
+Um Listen zu verschachteln, musst du zusätzliche Sternchen beziehungsweise
+Punkte hinzufügen. Dies ist bis zu fünf Mal möglich.
 
 ```
 * foo 1
diff --git a/de-de/brainfuck-de.html.markdown b/de-de/brainfuck-de.html.markdown
index dd62dd67..09f01cd2 100644
--- a/de-de/brainfuck-de.html.markdown
+++ b/de-de/brainfuck-de.html.markdown
@@ -1,11 +1,11 @@
 ---
-language: brainfuck
+language: bf
 contributors:
     - ["Prajit Ramachandran", "http://prajitr.github.io/"]
     - ["Mathias Bynens", "http://mathiasbynens.be/"]
 translators:
     - ["urfuchs", "https://github.com/urfuchs"]
-filename: brainfuck-de
+filename: brainfuck-de.bf
 lang: de-de
 
 ---
diff --git a/de-de/c++-de.html.markdown b/de-de/c++-de.html.markdown
index 87e75ad6..cca54c30 100644
--- a/de-de/c++-de.html.markdown
+++ b/de-de/c++-de.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c++
+language: C++
 filename: learncpp-de.cpp
 contributors:
     - ["Steven Basart", "http://github.com/xksteven"]
diff --git a/de-de/c-de.html.markdown b/de-de/c-de.html.markdown
index f9090518..3a726b83 100644
--- a/de-de/c-de.html.markdown
+++ b/de-de/c-de.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c
+language: C
 filename: learnc-de.c
 contributors:
     - ["caminsha", "https://github.com/caminsha"]
diff --git a/de-de/crystal-de.html.markdown b/de-de/crystal-de.html.markdown
new file mode 100644
index 00000000..535267ee
--- /dev/null
+++ b/de-de/crystal-de.html.markdown
@@ -0,0 +1,561 @@
+---
+language: crystal
+contributors:
+    - ["Vitalii Elenhaupt", "http://veelenga.com"]
+    - ["Arnaud Fernandés", "https://github.com/TechMagister/"] 
+translators:
+    - ["caminsha", "https://github.com/caminsha"]
+filename: learncrystal-de.cr
+lang: de-de
+---
+
+```crystal
+
+# Das ist ein Kommentar
+
+# Alles ist ein Objekt
+nil.class # => Nil
+100.class # => Int32
+true.class # => Bool
+
+# Falschwerte sind: nil, false und Nullpointer
+!nil    # => true    : Bool
+!false  # => true    : Bool
+!0      # => false   : Bool
+
+# Integer
+
+1.class # => Int32
+
+# Fünf vorzeichenbehaftete Ganzzahlen
+1_i8.class   # =>    Int8
+1_i16.class  # =>    Int16
+1_i32.class  # =>    Int32
+1_i64.class  # =>    Int64
+1_i128.class # =>    Int128
+
+# Fünf vorzeichenlose Ganzzahlen
+1_u8.class   # =>    UInt8
+1_u16.class  # =>    UInt16
+1_u32.class  # =>    UInt32
+1_u64.class  # =>    UInt64
+1_u128.class # =>    UInt128
+
+
+2147483648.class            # => Int64
+9223372036854775808.class   # => UInt64
+
+# Binäre Zahlen
+0b1101 # => 13  : Int32
+
+# Oktalzahlen
+0o123 # => 83   : Int32
+
+# Hexadezimalzahlen
+0xFE012D # => 16646445 : Int32
+0xfe012d # => 16646445 : Int32
+
+# Gleitkommazahlen (floats)
+
+1.0.class   # => Float64
+
+# Es gibt zwei Typen von Gleitkommazahlen
+
+1.0_f32.class   # => Float32
+1_f32.class     # => Float32
+
+1e10.class      # => Float64
+1.5e10.class    # => Float64
+1.5e-7.class    # => Float64
+
+
+# Chars (einzelne Zeichen)
+
+'a'.class   # => Char
+
+# Oktale Schreibweise
+'\101'      # => 'A' : Char
+
+# Unicode Schreibweise
+'\u0041'    # => 'A' : Char
+
+# Strings (Zeichenketten)
+"s".class   # => String
+
+# Strings sind unveränderlich
+s = 'hello, "   # => "hello, "          : String
+s.object_id     # => 1234667712         : UInt64
+s += "Crystal"  # => "hello, Crystal"   : String
+s.object_id     # => 142528472          : UInt64
+
+# Interpolation wird unterstützt
+"sum = #{1 + 2}"    # => "sum = 3"  : String
+
+# Mehrzeilige Strings
+" Dies ist ein
+    mehrzeiliger String."
+
+# String mit doppeltem Anführungszeichen
+%(hello "world")    # => "hello \"world\""
+
+# Symbole
+# Unveränderbare, wiederverwendbare Konstanten, welche intern als Int32 Integer
+# Werte repräsentiert werden.
+# Symbole werden oft anstelle von Strings verwendet, um bestimmte Werte zu bestimmen.
+
+:symbol.class   # => Symbol
+
+sentence = :question?   # :"question?" : Symbol
+
+sentence = :question?       # => true   : Bool
+sentence = :exclamation!    # => false  : Bool
+sentence = "question?"      # => false  : Bool
+
+# Arrays
+[1, 2, 3].class         # => Array(Int32)
+[1, "hello", 'x'].class # => Array(Int32 | String | Char)
+
+# Leere Arrays sollten einen Typen definieren
+[]                  # => Syntaxfehler: für leere Arrays,
+                    # verwende `[] of ElementType`
+[] of Int32         # => [] : Array(Int32)
+Array(Int32).new    # => [] : Array(Int32)
+
+# Arrays können indiziert werden
+array = [1, 2, 3, 4, 5] # => [1, 2, 3, 4, 5] : Array(Int32)
+array[0]                # => 1               : Int32
+array[10]               # führt zu einem IndexError
+array[-6]               # führt zu einem IndexError
+array[10]?              # => nil             : (Int32 | Nil)
+array[-6]?              # => nil             : (Int32 | Nil)
+
+# Starte am Ende des Arrays
+array[-1]               # => 5
+
+# Mit einem Startindex und einer Länge
+array[2, 4]             # => [3, 4, 5]
+
+# oder mit einem Bereich
+array[1..3]             # => [2, 3, 4]
+
+# Füge etwas zu einem Array hinzu
+array << 6              # => [1, 2, 3, 4, 5, 6]
+
+# Entferne Einträge am Ende des Arrays
+array.pop               # => 6
+array                   # => [1, 2, 3, 4, 5]
+
+# Entferne ersten Eintrag im Array
+array.shift             # => 1
+array                   # => [2, 3, 4, 5]
+
+# Überprüfe, ob ein Element in einem Array existiert
+array.includes? 3       # => true
+
+# Spezielle Syntax für String-Arrays und Symbol-Arrays
+%w(one two three)   # => ["one", "two", "three"]    : Array(String)
+%i(one two three)   # 0> [:one, :two, :three]       : Array(Symbol)
+
+# Es gibt auch für andere Arrays eine spezielle Syntax, wenn die Methoden
+# `.new` und `#<<` definiert werden.
+set = Set{1, 2, 3}  # => [1, 2, 3]
+set.class           # => Set(Int32)
+
+# Das obere ist äquivalent zu:
+set = Set(typeof(1, 2, 3)).new
+set << 1
+set << 2
+set << 3
+
+# Hashes
+{1 => 2, 3 => 4}.class      # => Hash(Int32, Int32)
+{1 => 2, 'a' => 3}.class    # => Hash (Int32 | Char, Int32)
+
+# Leere Hashes sollten einen Typen spezifieren
+{}                      # Syntaxfehler
+{} of Int32 => Int32    # {}
+Hash(Int32, Int32).new  # {}
+
+# Hashes können schnell mit dem Key nachgeschaut werden
+hash = {"color" => "green", "number" => 5}
+hash["color"]           # => "green"
+hash["no_such_key"]     # => Fehlender hash key: "no_such_key" (KeyError)
+hash["no_such_key"]?    # => nil
+
+# Überprüfe die Existenz eines Hashkeys
+hash.has_key? "color"   # => true
+
+# Spezielle Schreibweise für Symbol- und Stringkeys
+{key1: 'a', key2: 'b'}      # {:key1 => 'a', :key2 => 'b'} 
+{"key1": 'a', "key2": 'b'}  # {"key1" => 'a', "key2" => 'b'}
+
+# Die spezielle Syntax für Hash-Literale gibt es auch für andere Typen, sofern
+# diese die Methoden `.new` und `#[]=` Methoden definieren.
+class MyType
+    def []=(key, value)
+        puts "do stuff"
+    end
+end
+
+MyType{"foo" => "bar"}
+
+# Das obere ist äquivalent zu:
+tmp = MyType.new
+tmp["foo"] = "bar"
+tmp
+
+# Ranges (Bereiche)
+1..10                   # => Range(Int32, Int32)
+Range.new(1,10).class   # => Range(Int32, Int32)
+
+# Ranges können inklusiv oder exklusiv sein.
+(3..5).to_a     # => [3, 4, 5]
+(3...5).to_a    # => [3, 4]
+
+# Überprüfe, ob ein Range einen Wert enthält oder nicht.
+(1..8).includes? 2  # => true
+
+# Tupel sind unveränderliche, Stack-zugewiese Folgen von Werten mit fester 
+# Größe und möglicherweise unterschiedlichen Typen
+{1, "hello", 'x'}.class # => Tuple(Int32, String, Char)
+
+# Erhalte den Wert eines Tupels über den Index
+tuple = {:key1, :key2}
+tuple[1] # => :key2
+tuple[2] # syntax error: Index out of bound
+
+# Können auf mehrere Variablen erweitert werden
+a, b, c = {:a, 'b', "c"}
+a   # => :a
+b   # => 'b'
+c   # => "c"
+
+# Procs repräsentieren ein Funktionspointer mit einem optionalen Kontext.
+# Normalerweise wird ein Proc mit einem proc-Literal erstellt.
+proc = ->(x : Int32) { x.to_s }
+proc.class  # => Print(Int32, String)
+# Außerdem kann man auch mit der Methode `new` ein Proc erstellen.
+Proc(Int32, String).new { |x| x.to_s }
+
+# Rufe ein Proc auf mit der Methode `call`
+proc.call 10    # => "10"
+
+# Kontrollstatements
+
+if true
+    "if statement"
+elsif false
+    "else-f, optional"
+else
+    "else, auch optional"
+end
+
+puts "if as a suffix" if true # => if as a suffix
+
+# If als Ausdruck
+a = if 2 > 1
+        3
+    else
+        4
+    end
+
+a # => 3
+
+# Bedingter ternärer Ausdruck
+a = 1 > 2 ? 3 : 4   # => 4
+
+# Case-Statement
+cmd = "move"
+
+action = case cmd
+    when "create"
+        "Creating..."
+    when "copy"
+        "Copying..."
+    when "move"
+        "Moving..."
+    when "delete"
+        "Deleting..."
+end
+
+action # => "Moving..."
+
+# Schleifen
+index = 0
+while index <= 3
+    puts "Index: #{index}"
+    index += 1
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+index = 0
+until index > 3
+    puts "Index: #{index}"
+    index += 1
+end
+# Index: 0
+# Index: 1
+# Index: 2
+# Index: 3
+
+# Der bevorzugte Weg, ist `each` zu verwenden.
+(1..3).each do |index|
+    puts "Index: #{index}"
+end
+# Index: 1
+# Index: 2
+# Index: 3
+
+# Der Typ der Variablen hängt vom Typen innerhalb der Kontrollanweisung ab
+if a < 3
+    a = "hello"
+else
+    a = true
+end
+typeof a    # => (Bool | String)
+
+if a && b
+    # Hier wird garantiert, dass weder a noch b vom Typ Nil sind
+end
+
+if a.is_a? String
+    a.class # => String
+end
+
+# Funktionen
+def double(x)
+    x * 2
+end
+
+# Funktionen geben implizit den Wert der letzten Anweisung zurück
+# Dies ist auch bei anderen Blöcken der Fall.
+double(2)       # => 4
+
+# Klammern müssen nicht gesetzt werden, wenn der Aufruf eindeutig ist
+double 3        # => 6
+double double 3 # => 12
+
+def sum(x, y)
+    x + y
+end
+
+# Funktionsargumente werden mit einem Komma separiert.
+sum 3, 4            # => 7
+
+sum sum(3, 4), 5    # => 12
+
+# yield
+# Alle Methoden haben einen impliziten, optionalen Blockparameter.
+# Dieser kann mit dem Schlüsselwort `yield` aufgerufen werden.
+
+def surround
+    puts '{'
+    yield
+    puts '}'
+end
+
+surround { puts "Hallo Welt" }
+
+# {
+# Hallo Welt 
+# }
+
+# Du kannst ein Block einer Funktion übergeben.
+# "&" kennzeichnet eine Referenz zu einem übergebenen Block
+def guests(&block)
+    block.call "some_argument"
+end
+
+# Du kannst eine Liste von Argumenten mitgeben, welche zu einem Array
+# umgewandelt werden.
+# Hierfür ist der Splat-Operator ("*")
+def guests(*array)
+    array.each { |guest| puts guest }
+end
+
+# Wenn eine Methode ein Array zurückgibt, kann destrukturiende Zuordnung
+# verwendet werden.
+def foods
+    ["pancake", "sandwich", "quesadilla"]
+end
+breakfast, lunch, dinner = foods
+breakfast   # => "pancake"
+dinner      # => "quesadilla"
+
+# Gemäß der Konvention enden alle Methoden, welchen einen Boolean zurückgeben
+# mit einem Fragezeichen.
+5.even? # false
+5.odd?  # true
+
+# Und wenn eine Methode mit einem Ausrufezeichen endet, macht sie etwas
+# destruktives. Zum Beispiel wird der Aufrufer verändert. Einige Methoden haben
+# eine !-Version, um eine Änderung zu machen und eine Nicht-!-Version, welche
+# lediglich eine neue veränderte Version zurückgibt.
+
+company_name = "Dunder Mifflin"
+company_name.gsub "Dunder", "Donald"    # => "Donald Mifflin"
+company_name    # => "Dunder Mifflin"
+company_name.gsub! "Dunder", "Donald"
+company_name    # => "Donald Mifflin"
+
+# definiere eine Klasse mit dem Schlüsselwort `class`.
+class Human
+
+# eine Klassenvariable. Diese wird mit allen Instanzen dieser Klasse geteilt.
+    @@species = "H. sapiens"
+
+    # type of name is String
+    @name: String
+
+    # Grundlegender Intialisierer
+    # Weise das Argument der Instanz-Variable "name" zu
+    # Wenn kein Alter angegeben wird, wird der Default (hier 0) genommen.
+    def initialize(@name, @age = 0)
+    end
+
+    # Einfache Setter-Methode
+    def name=(name)
+        @name = name
+    end
+
+    # einfache Getter-Methode
+    def name
+        @name
+    end
+
+    # Die obere Funktionalität kann mit der property-Methode gekapselt werden:
+    property :name
+
+    # Getter/Setter-Methoden können auch individuell erstellt werden:
+    getter :name
+    setter :name
+    
+    # eine Klassenmethode verwendet `self` um sich von Instanzmethoden zu 
+    # unterscheiden. Diese kann lediglich von einer Klasse aufgerufen werden,
+    # nicht von einer Instanz.
+    def self.say(msg)
+        puts msg
+    end
+
+    def species
+        @@species
+    end
+end
+
+
+# Eine Klasse instanzieren
+jim = Human.new("Jim Halpert")
+
+dwight = Human.new("Dwight K. Schrute")
+
+# Lass uns ein paar Methoden aufrufen
+jim.species                     # => "H. sapiens"
+jim.name                        # => "Jim Halpert"
+jim.name = "Jim Halpert II"     # => "Jim Halpert II"
+jim.name                        # => "Jim Halpert II"
+dwight.species                  # => "H. sapiens"
+dwight.name                     # => "Dwight K. Schrute"
+
+# Rufe die Klassenmethode auf
+Human.say("Hi")     # => gibt Hi aus und gibt `nil` zurück
+
+# Variablen, welche mit @ starten, sind im Scope der Instanz
+class TestClass
+    @var = "Ich bin eine Instanzvariable"
+end
+
+# Variablen, welche mit @@ starten, sind im Scope der Klasse
+class TestClass
+    @@var = "Ich bin eine Klassenvariable"
+end
+
+# Variablen, welche mit einem Großbuchstaben starten, sind Konstanten.
+Var = "Ich bin eine Konstante"
+Var = "Ich kann nicht aktualisiert werden." # Die Konstante Var wurde bereits
+                                            # initialisiert.
+
+# In Crystal ist Class auch ein Objekt. Dadurch können Klassen Instanzvariablen
+# haben. Klassenvariablen werden mit der Klasse und allen Subklassen geteilt.
+
+# Basisklasse
+class Human
+    @@foo = 0
+
+    def self.foo
+        @@foo
+    end
+
+    def self.foo=(value)
+        @@foo = value
+    end
+end
+
+# abgeleitete Klasse
+class Worker < Human
+end
+
+Human.foo       # => 0
+Worker.foo      # => 0
+
+Human.foo = 2   # => 2
+Worker.foo      # => 0
+
+Worker.foo = 3  # => 3
+Human.foo       # => 2
+Worker.foo      # => 3
+
+module ModuleExample
+    def foo
+        "foo"
+    end
+end
+
+# Wenn ein Modul mit include eingeschlossen wird, so werden die Methoden an die
+# Instanzen gebunden.
+# Wenn eine Klasse mit einem Modul erweitert wird, so werden die Methoden an die
+# Klasse selbst gebunden.
+
+class Person 
+    include ModuleExample
+end
+
+class Book
+    extend ModuleExample
+end
+
+Person.foo      # => undefinierte Methode 'foo' für Person:Class
+Person.new.foo  # => 'foo'
+Book.foo        # => 'foo'
+Book.new.foo    # => undefinierte Methode für Book
+
+# Ausnahmebehandlung
+
+# Definiere eine neue Ausnahme
+class MyException < Exception
+end
+
+# Definiere eine weitere Ausnahme
+class MyAnotherException < Exception; end
+
+ex = begin
+    raise MyException.new
+rescue ex1 : IndexError
+    "ex1"
+rescue ex2 : MyException | MyAnotherException
+    "ex2"
+rescue ex3 : Exception
+    "ex3"
+rescue ex4 # fange alle Ausnahmen ab
+    "ex4"
+end
+
+ex # => "ex2"
+```
+
+
+## Weitere Unterlagen
+
+- [offizielle Dokumentation, englisch](https://crystal-lang.org/)
diff --git a/de-de/csharp-de.html.markdown b/de-de/csharp-de.html.markdown
index 78bb0a6b..662c2e76 100644
--- a/de-de/csharp-de.html.markdown
+++ b/de-de/csharp-de.html.markdown
@@ -1,890 +1,890 @@
----

-language: c#

-contributors:

-    - ["Irfan Charania", "https://github.com/irfancharania"]

-    - ["Max Yankov", "https://github.com/golergka"]

-    - ["Melvyn Laïly", "http://x2a.yt"]

-    - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]

-translators:

-    - ["Frederik Ring", "https://github.com/m90"]

-filename: LearnCSharp-de.cs

-lang: de-de

----

-C# ist eine elegante, typsichere und objektorientierte Sprache, mit der Entwickler eine Vielzahl sicherer und robuster Anwendungen erstellen können, die im .NET Framework ausgeführt werden.

-

-[Mehr über C# erfährst du hier.](http://msdn.microsoft.com/de-de/library/vstudio/z1zx9t92.aspx)

-

-```c#

-// Einzeilige Kommentare starten mit zwei Schrägstrichen: //

-/*

-Mehrzeile Kommentare wie in C Schrägstrich / Stern

-*/

-/// <summary>

-/// XML-Kommentare können zur automatisierten Dokumentation verwendet werden

-/// </summary>

-

-// Zu Beginn werden die in der Datei verwendeten Namespaces aufgeführt

-using System;

-using System.Collections.Generic;

-using System.Data.Entity;

-using System.Dynamic;

-using System.Linq;

-using System.Linq.Expressions;

-using System.Net;

-using System.Threading.Tasks;

-using System.IO;

-

-// definiert einen Namespace um Code in "packages" zu organisieren

-namespace Learning

-{

-    // Jede .cs-Datei sollte zumindest eine Klasse mit dem Namen der Datei

-    // enthalten. Das ist zwar nicht zwingend erforderlich, es anders zu

-    // handhaben führt aber unweigerlich ins Chaos (wirklich)!

-    public class LearnCSharp

-    {

-        // Zuerst erklärt dieses Tutorial die Syntax-Grundlagen,

-        // wenn du bereits Java oder C++ programmieren kannst:

-        // lies bei "Interessante Features" weiter!

-        public static void Syntax()

-        {

-            // Mit Console.WriteLine kannst du einfachen Text ausgeben:

-            Console.WriteLine("Hallo Welt");

-            Console.WriteLine(

-                "Integer: " + 10 +

-                " Double: " + 3.14 +

-                " Boolean: " + true);

-

-            // Console.Write erzeugt keinen Zeilenumbruch

-            Console.Write("Hallo ");

-            Console.Write("Welt");

-

-            ///////////////////////////////////////////////////

-            // Typen & Variablen

-            ///////////////////////////////////////////////////

-

-            // Deklariere eine Variable mit <Typ> <Name>

-

-            // Sbyte - Vorzeichenbehaftete 8-Bit Ganzzahl

-            // (-128 <= sbyte <= 127)

-            sbyte fooSbyte = 100;

-

-            // Byte - Vorzeichenlose 8-Bit Ganzzahl

-            // (0 <= byte <= 255)

-            byte fooByte = 100;

-

-            // Short - 16-Bit Ganzzahl

-            // Vorzeichenbehaftet - (-32,768 <= short <= 32,767)

-            // Vorzeichenlos - (0 <= ushort <= 65,535)

-            short fooShort = 10000;

-            ushort fooUshort = 10000;

-

-            // Integer - 32-bit Ganzzahl

-            int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)

-            uint fooUint = 1; // (0 <= uint <= 4,294,967,295)

-

-            // Long - 64-bit Ganzzahl

-            long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)

-            ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)

-            // Ganze Zahlen werden standardmäßig - je nach Größe - als int oder

-            // uint behandelt. Ein nachgestelltes L markiert den Wert als long

-            // oder ulong.

-

-            // Double - Double-precision 64-bit IEEE 754 Fließkommazahl

-            double fooDouble = 123.4; // Genauigkeit: 15-16 Stellen

-

-            // Float - Single-precision 32-bit IEEE 754 Fließkommazahl

-            float fooFloat = 234.5f; // Genauigkeit: 7 Stellen

-            // Das nachgestellte f zeigt an dass es sich um einen Wert vom Typ

-            // float handelt

-

-            // Decimal - ein 128-Bit-Datentyp mit größerer Genauigkeit als

-            // andere Fließkommatypen, und somit bestens geeignet für

-            // die Berechnung von Geld- und Finanzwerten

-            decimal fooDecimal = 150.3m;

-

-            // Boolean - true & false

-            bool fooBoolean = true; // oder false

-

-            // Char - Ein einzelnes 16-Bit Unicode Zeichen

-            char fooChar = 'A';

-

-            // Strings - im Gegensatz zu allen vorhergehenden Basistypen, die

-            // alle Werttypen sind, ist String ein Referenztyp. Strings sind

-            // somit nullable, Werttypen sind dies nicht.

-            string fooString = "\"maskiere\" Anführungszeichen, und füge \n (Umbrüche) und \t (Tabs) hinzu";

-            Console.WriteLine(fooString);

-

-            // Jeder Buchstabe eines Strings kann über seinen Index

-            // referenziert werden:

-            char charFromString = fooString[1]; // => 'e'

-            // Strings sind unveränderlich:

-            // `fooString[1] = 'X';` funktioniert nicht

-

-            // Ein Vergleich zweier Strings, unter Berücksichtigung der

-            // aktuellen, sprachspezifischen Gegebenheiten (also z.B. a,ä,b,c

-            // in deutschsprachigen Umgebungen), und ohne Beachtung von

-            // Groß- und Kleinschreibung:

-            string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);

-

-            // Formatierung, genau wie "sprintf"

-            string fooFs = string.Format("Mikrofon Check, {0} {1}, {0} {1:0.0}", 1, 2);

-

-            // Datumsangaben und Formatierung

-            DateTime fooDate = DateTime.Now;

-            Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));

-

-            // Durch ein vorangestelltes @ lässt sich ein mehrzeiliger String

-            // schreiben. Um " zu maskieren benutzt man ""

-            string bazString = @"Hier geht es

-zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen";

-

-            // Die Keywords const oder readonly kennzeichnen eine

-            // unveränderliche Variable/Konstante. Die Werte von Konstanten

-            // werden übrigens bereits zur Compile-Zeit berechnet.

-            const int HOURS_I_WORK_PER_WEEK = 9001;

-

-            ///////////////////////////////////////////////////

-            // Datenstrukturen

-            ///////////////////////////////////////////////////

-

-            // Arrays - Index beginnt bei Null

-            // Die Größe des Arrays wird bei der Deklaration festgelegt.

-            // Die syntaktische Struktur um ein neues Array zu erzeugen sieht

-            // folgendermaßen aus:

-            // <datatype>[] <varname> = new <datatype>[<array size>];

-            int[] intArray = new int[10];

-

-            // Arrays können auch über ein Array-Literal deklariert werden:

-            int[] y = { 9000, 1000, 1337 };

-

-            // Indizierung eines Arrays - Zugriff auf ein bestimmtes Element

-            Console.WriteLine("intArray @ 0: " + intArray[0]);

-            // Arrays sind veränderbar

-            intArray[1] = 1;

-

-            // Listen

-            // Durch ihre größere Flexibilität kommen Listen in C# weit

-            // häufiger zum Einsatz als Arrays. Eine Liste wird so deklariert:

-            // List<datatype> <varname> = new List<datatype>();

-            List<int> intList = new List<int>();

-            List<string> stringList = new List<string>();

-            List<int> z = new List<int> { 9000, 1000, 1337 };

-            // Die <> kennzeichnen "Generics", mehr dazu unter "Coole Sachen"

-

-            // Listen haben keinen Default-Wert.

-            // Bevor auf einen Index zugegriffen werden kann, muss dieser

-            // auch gesetzt worden sein:

-            intList.Add(1);

-            Console.WriteLine("intList @ 0: " + intList[0]);

-

-            // Andere interessante Datenstrukturen sind:

-            // Stack/Queue

-            // Dictionary (entspricht einer Hash Map)

-            // HashSet

-            // Read-only Collections

-            // Tuple (.Net 4+)

-

-            ///////////////////////////////////////

-            // Operatoren

-            ///////////////////////////////////////

-            Console.WriteLine("\n->Operatoren");

-

-            // kurze Schreibweise um mehrere Deklarationen zusammenzufassen:

-            // (Benutzung vom C# Styleguide aber ausdrücklich abgeraten!)

-            int i1 = 1, i2 = 2;

-

-            // Arithmetik funktioniert wie erwartet:

-            Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3

-

-            // Modulo

-            Console.WriteLine("11%3 = " + (11 % 3)); // => 2

-

-            // Vergleiche

-            Console.WriteLine("3 == 2? " + (3 == 2)); // => false

-            Console.WriteLine("3 != 2? " + (3 != 2)); // => true

-            Console.WriteLine("3 > 2? " + (3 > 2)); // => true

-            Console.WriteLine("3 < 2? " + (3 < 2)); // => false

-            Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true

-            Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true

-

-            // Bitweise Operatoren

-            /*

-            ~       Unäres bitweises NICHT

-            <<      Verschieben nach links

-            >>      Verschieben nach rechts

-            &       Bitweises UND

-            ^       Bitweises exklusives ODER

-            |       Bitweises inklusives ODER

-            */

-

-            // Inkremente

-            int i = 0;

-            Console.WriteLine("\n->Inkrement / Dekrement");

-            Console.WriteLine(i++); //i = 1. Post-Inkrement

-            Console.WriteLine(++i); //i = 2. Pre-Inkrement

-            Console.WriteLine(i--); //i = 1. Post-Dekrement

-            Console.WriteLine(--i); //i = 0. Pre-Dekrement

-

-            ///////////////////////////////////////

-            // Kontrollstrukturen

-            ///////////////////////////////////////

-            Console.WriteLine("\n->Kontrollstrukturen");

-

-            // If-Statements funktionieren wie in C

-            int j = 10;

-            if (j == 10)

-            {

-                Console.WriteLine("Ich werde ausgegeben");

-            }

-            else if (j > 10)

-            {

-                Console.WriteLine("Ich nicht");

-            }

-            else

-            {

-                Console.WriteLine("Ich leider auch nicht");

-            }

-

-            // Ternärer Operator

-            // Anstatt eines einfachen if/else lässt sich auch folgendes schreiben:

-            // <condition> ? <true> : <false>

-            int zumVergleich = 17;

-            string isTrue = zumVergleich == 17 ? "Ja" : "Nein";

-

-            // while-Schleife

-            int fooWhile = 0;

-            while (fooWhile < 100)

-            {

-                // Wird 100mal wiederholt, fooWhile 0->99

-                fooWhile++;

-            }

-

-            // do-while-Schleife

-            int fooDoWhile = 0;

-            do

-            {

-                // Wird 100mal wiederholt, fooDoWhile 0->99

-                fooDoWhile++;

-            } while (fooDoWhile < 100);

-

-            //for-Schleifen => for(<start_statement>; <conditional>; <step>)

-            for (int fooFor = 0; fooFor < 10; fooFor++)

-            {

-                // Wird 10mal wiederholt, fooFor 0->9

-            }

-

-            // foreach-Schleife

-            // Die normale Syntax für eine foreach-Schleife lautet:

-            // foreach(<iteratorType> <iteratorName> in <enumerable>)

-            // foreach kann mit jedem Objekt verwendet werden das IEnumerable

-            // oder IEnumerable<T> implementiert. Alle Auflistungs-Typen

-            // (Array, List, Dictionary...) im .NET Framework implementieren

-            // eines dieser beiden Interfaces.

-

-            foreach (char character in "Hallo Welt".ToCharArray())

-            {

-                // Ein Durchgang für jedes Zeichen im String

-            }

-            // (ToCharArray() könnte man hier übrigens auch weglassen,

-            // da String IEnumerable bereits implementiert)

-

-            // Switch Struktur

-            // Ein Switch funktioniert mit byte, short, char und int Datentypen.

-            // Auch Aufzählungstypen können verwendet werden, genau wie

-            // die Klasse String, und ein paar Sonderklassen, die Wrapper für

-            // Primitives sind: Character, Byte, Short und Integer

-            int month = 3;

-            string monthString;

-            switch (month)

-            {

-                case 1:

-                    monthString = "Januar";

-                    break;

-                case 2:

-                    monthString = "Februar";

-                    break;

-                case 3:

-                    monthString = "März";

-                    break;

-                // Man kann für mehrere Fälle auch das selbe Verhalten

-                // definieren. Jeder Block muss aber mit einem break-Statement

-                // abgeschlossen werden. Einzelne Fälle können über

-                // `goto case x` erreicht werden

-                case 6:

-                case 7:

-                case 8:

-                    monthString = "Sommer!!";

-                    break;

-                default:

-                    monthString = "Irgendein anderer Monat";

-                    break;

-            }

-

-            ///////////////////////////////////////

-            // Umwandlung von Datentypen und Typecasting

-            ///////////////////////////////////////

-

-            // Umwandlung

-

-            // von String nach Integer

-            // bei einem Fehler wirft diese Code eine Exception

-            int.Parse("123"); //gibt die Ganzzahl 123 zurück

-

-            // TryParse gibt bei einem Fehler den Default-Wert zurück

-            // (im Fall von int: 0)

-            int tryInt;

-            if (int.TryParse("123", out tryInt)) // gibt true oder false zurück

-            {

-                Console.WriteLine(tryInt);       // 123

-            }

-

-            // von Integer nach String

-            // Die Klasse Convert stellt Methoden zur Konvertierung von

-            // unterschiedlichsten Daten zur Verfügung:

-            Convert.ToString(123); // "123"

-            // oder

-            tryInt.ToString(); // "123"

-        }

-

-        ///////////////////////////////////////

-        // Klassen

-        ///////////////////////////////////////

-        public static void Classes()

-        {

-

-            // Benutze das new-Keyword um eine Instanz einer Klasse zu erzeugen

-            Bicycle trek = new Bicycle();

-

-            // So werden Methoden der Instanz aufgerufen

-            trek.SpeedUp(3); // Es empfiehlt sich immer Getter und Setter zu benutzen

-            trek.Cadence = 100;

-

-            // ToString ist eine Konvention über die man üblicherweiser

-            // Informationen über eine Instanz erhält

-            Console.WriteLine("Infos zu trek: " + trek.ToString());

-

-            // Wir instantiieren ein neues Hochrad

-            PennyFarthing funbike = new PennyFarthing(1, 10);

-            Console.WriteLine("Infos zu funbike: " + funbike.ToString());

-

-            Console.Read();

-        } // Ende der Methode main

-

-        // Main als Konsolenstartpunkt

-        // Eine Konsolenanwendung muss eine Methode Main als Startpunkt besitzen

-        public static void Main(string[] args)

-        {

-            OtherInterestingFeatures();

-        }

-

-        ///////////////////////////////////////

-        // Interessante Features

-        ///////////////////////////////////////

-

-        // Methodensignaturen

-

-        public // Sichtbarkeit

-        static // Erlaubt einen Zugriff auf der Klasse (nicht auf einer Instanz)

-        int // Typ des Rückgabewerts,

-        MethodSignatures(

-            // Erstes Argument, erwartet int

-            int maxCount,

-            // setzt sich selbst auf 0 wenn kein anderer Wert übergeben wird

-            int count = 0,

-            int another = 3,

-            // enthält alle weiteren der Methode übergebenen Parameter (quasi Splats)

-            params string[] otherParams

-        )

-        {

-            return -1;

-        }

-

-        // Methoden können überladen werden, solange sie eindeutige

-        // Signaturen haben

-        public static void MethodSignatures(string maxCount)

-        {

-        }

-

-        // Generische Typen

-        // Die Typen für TKey und TValue werden erst beim Aufruf der Methode

-        // festgelegt. Diese Methode emuliert z.B. SetDefault aus Python:

-        public static TValue SetDefault<TKey, TValue>(

-            IDictionary<TKey, TValue> dictionary,

-            TKey key,

-            TValue defaultItem)

-        {

-            TValue result;

-            if (!dictionary.TryGetValue(key, out result))

-            {

-                return dictionary[key] = defaultItem;

-            }

-            return result;

-        }

-

-        // Möglichen Typen lassen sich auch über ihr Interface beschränken:

-        public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>

-        {

-            // Da T ein IEnumerable ist können wir foreach benutzen

-            foreach (var item in toPrint)

-            {

-                // Item ist ein int

-                Console.WriteLine(item.ToString());

-            }

-        }

-

-        public static void OtherInterestingFeatures()

-        {

-            // Optionale Parameter

-            MethodSignatures(3, 1, 3, "Ein paar", "extra", "Strings");

-            // setzt explizit einen bestimmten Parameter, andere werden übersprungen

-            MethodSignatures(3, another: 3);

-

-            // Erweiterungsmethoden

-            int i = 3;

-            i.Print(); // Weiter unten definiert

-

-            // Nullables - perfekt für die Interaktion mit

-            // Datenbanken / Rückgabewerten

-            // Jeder Wert (d.h. keine Klassen) kann durch das Nachstellen eines ?

-            // nullable gemacht werden: <type>? <varname> = <value>

-            int? nullable = null; // Die explizite Langform wäre Nullable<int>

-            Console.WriteLine("Mein Nullable: " + nullable);

-            bool hasValue = nullable.HasValue; // true wenn nicht null

-

-            // ?? ist "syntaktischer Zucker" um einen Defaultwert für den Fall

-            // dass die Variable null ist festzulegen.

-            int notNullable = nullable ?? 0; // 0

-

-            // Implizit typisierte Variablen

-            // Man kann auch den Typ einer Variable auch vom Compiler

-            // bestimmen lassen:

-            var magic = "magic ist zur Compile-Zeit ein String, folglich geht keine Typsicherheit verloren";

-            magic = 9; // funktioniert nicht da magic vom Typ String ist

-

-            // Generics

-            var phonebook = new Dictionary<string, string>() {

-                {"Resi", "08822 / 43 67"} // Fügt einen Eintrag zum Telefonbuch hinzu

-            };

-

-            // Hier könnte man auch unser generisches SetDefault von

-            // weiter oben benutzen:

-            Console.WriteLine(SetDefault<string,string>(phonebook, "Xaver", "kein Telefon")); // kein Telefon

-            // TKey und TValue müssen nicht zwingend angegeben werden, da sie

-            // auch implizit vom Compiler ermittelt werden können

-            Console.WriteLine(SetDefault(phonebook, "Resi", "kein Telefon")); // 08822 / 43 67

-

-            // Lambdas - konzise Syntax für Inline-Funktionen

-            Func<int, int> square = (x) => x * x; // Das letzte Element vom Typ T ist der Rückgabewert

-            Console.WriteLine(square(3)); // 9

-

-            // Disposables - einfaches Management von nicht verwalteten Ressourcen

-            // So gut wie alle Objekte die auf nicht verwaltete Ressourcen

-            // (Dateien, Geräte, ...) zugreifen, implementieren das Interface

-            // IDisposable. Das using Statement stellt sicher dass die vom

-            // IDisposable benutzten Ressourcen nach der Benutzung wieder

-            // freigegeben werden:

-            using (StreamWriter writer = new StreamWriter("log.txt"))

-            {

-                writer.WriteLine("Alles bestens!");

-                // Am Ende des Codeblocks werden die Ressourcen wieder

-                // freigegeben - auch im Falle einer Exception

-            }

-

-            // Parallel Klasse

-            // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx

-            var websites = new string[] {

-                "http://www.google.com", "http://www.reddit.com",

-                "http://www.shaunmccarthy.com"

-            };

-            var responses = new Dictionary<string, string>();

-

-            // Für jeden Request wird ein neuer Thread erzeugt, der nächste

-            // Schritt wird erst nach Beendigung aller Tasks ausgeführt

-            Parallel.ForEach(websites,

-                // maximal 3 Threads gleichzeitig

-                new ParallelOptions() {MaxDegreeOfParallelism = 3},

-                website =>

-            {

-                // Hier folgt eine langwierige, asynchrone Operation

-                using (var r = WebRequest.Create(new Uri(website)).GetResponse())

-                {

-                    responses[website] = r.ContentType;

-                }

-            });

-

-            // Dieser Code wird erst nach Beendigung aller Requests ausgeführt

-            foreach (var key in responses.Keys)

-            {

-                Console.WriteLine("{0}:{1}", key, responses[key]);

-            }

-

-            // Dynamische Objekte (gut um mit anderen Sprachen zu arbeiten)

-            dynamic student = new ExpandoObject();

-            // hier muss keine Typ angegeben werden

-            student.FirstName = "Christian";

-

-            // Einem solchen Objekt kann man sogar Methoden zuordnen.

-            // Das Beispiel gibt einen String zurück und erwartet einen String

-            student.Introduce = new Func<string, string>(

-                (introduceTo) => string.Format("Hallo {0}, das ist {1}", student.FirstName, introduceTo));

-            Console.WriteLine(student.Introduce("Bettina"));

-

-            // IQueryable<T> - So gut wie alle Aufzählungstypen implementieren

-            // dieses Interface, welches eine Vielzahl von funktionalen Methoden

-            // wie Map / Filter / Reduce zur Verfügung stellt:

-            var bikes = new List<Bicycle>();

-            // sortiert die Liste

-            bikes.Sort();

-            // sortiert nach Anzahl Räder

-            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels));

-            var result = bikes

-                // diese Filter können auch aneinandergehängt werden

-                .Where(b => b.Wheels > 3) // (gibt ein IQueryable des vorherigen Typs zurück)

-                .Where(b => b.IsBroken && b.HasTassles)

-                // diese Zuordnung gibt ein IQueryable<String> zurück

-                .Select(b => b.ToString());

-

-            // "Reduce" - addiert alle Räder der Aufzählung zu einem Wert

-            var sum = bikes.Sum(b => b.Wheels);

-

-            // So erzeugt man ein implizit typisiertes Objekt, basierend auf

-            // den Parametern der Elemente:

-            var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });

-            // Auch wenn wir es hier nicht demonstrieren können:

-            // In einer IDE wie VisualStudio kriegen wir hier sogar TypeAhead,

-            // da der Compiler in der Lage ist, die passenden Typen zu erkennen.

-            foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))

-            {

-                Console.WriteLine(bikeSummary.Name);

-            }

-

-            // AsParallel-Methode

-            // Jetzt kommen die Schmankerl! Die AsParallel-Methode kombiniert

-            // LINQ und parallele Operationen:

-            var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);

-            // Diese Berechnung passiert parallel! Benötigte Threads werden

-            // automatisch erzeugt, und die Rechenlast unter ihnen aufgeteilt.

-            // Ein Traum für die Verarbeitung von großen Datenmengen

-            // auf mehreren Cores!

-

-            // LINQ - bildet einen Datenspeicher auf IQueryable<T> Objekte ab

-            // LinqToSql beispielsweise speichert und liest aus einer

-            // SQL-Datenbank, LinqToXml aus einem XML-Dokument.

-            // LINQ-Operationen werden "lazy" ausgeführt.

-            var db = new BikeRepository();

-

-            // Die verzögerte Ausführung ist optimal für Datenbankabfragen

-            var filter = db.Bikes.Where(b => b.HasTassles); // noch keine Abfrage

-            // Es können noch mehr Filter hinzugefügt werden (auch mit

-            // Bedingungen) - ideal für z.B. "erweiterte Suchen"

-            if (42 > 6)

-            {

-                filter = filter.Where(b => b.IsBroken); // immer noch keine Abfrage

-            }

-

-            var query = filter

-                .OrderBy(b => b.Wheels)

-                .ThenBy(b => b.Name)

-                .Select(b => b.Name); // auch hier: immer noch keine Abfrage

-

-            // Erst hier wird die Datenbankabfrage wirklich ausgeführt,

-            // limitiert auf die Elemente die der foreach-Loop verwendet

-            foreach (string bike in query)

-            {

-                Console.WriteLine(result);

-            }

-

-        }

-

-    } // Ende der Klasse LearnCSharp

-

-    // Eine .cs-Datei kann auch mehrere Klassen enthalten

-

-    public static class Extensions

-    {

-        // Erweiterungsmethoden

-        public static void Print(this object obj)

-        {

-            Console.WriteLine(obj.ToString());

-        }

-    }

-

-    // Syntax zur Deklaration einer Klasse:

-    // <public/private/protected/internal> class <class name>{

-    //    // Datenfelder, Konstruktoren und Methoden leben alle

-    //    // innerhalb dieser Deklaration

-    // }

-

-    public class Bicycle

-    {

-        // Felder/Variablen der Klasse "Bicycle"

-        // Das Keyword public macht das Member von überall zugänglich

-        public int Cadence

-        {

-            get // get definiert eine Methode um die Eigenschaft abzurufen

-            {

-                return _cadence;

-            }

-            set // set definiert eine Methode um die Eigenschaft zu setzen

-            {

-                _cadence = value; // value ist der dem Setter übergebene Wert

-            }

-        }

-        private int _cadence;

-

-        // Das Keyword protected macht das Member nur für die Klasse selbst

-        // und ihre Subklassen zugänglich

-        protected virtual int Gear

-        {

-            get; // erzeugt eine Eigenschaft für die kein "Zwischenwert" benötigt wird

-            set;

-        }

-

-        // Das Keyword internal macht das Member innerhalb der Assembly zugänglich

-        internal int Wheels

-        {

-            get;

-            private set; // get/set kann auch über Keywords modifiziert werden

-        }

-

-        int _speed; // Member ohne vorangestellte Keywords sind standardmäßig

-                    // private, sie sind nur innerhalb der Klasse zugänglich.

-                    // Man kann aber natürlich auch das Keyword private benutzen.

-        private string Name { get; set; }

-

-        // Ein Enum ist ein klar definierter Satz an benannten Konstanten.

-        // Eigentlich ordnet es diese Konstanten nur bestimmten Werten zu

-        // (einer int-Zahl, solange nicht anders angegeben). Mögliche Typen für

-        // die Werte eines Enums sind byte, sbyte, short, ushort, int, uint,

-        // long, oder ulong. Alle Werte in einem Enum sind eindeutig.

-        public enum BikeBrand

-        {

-            Colnago,

-            EddyMerckx,

-            Bianchi = 42, // so kann man den Wert explizit setzen

-            Kynast // 43

-        }

-        // Nachdem dieser Typ in der Klasse "Bicycle" definiert ist,

-        // sollte Code ausserhalb der Klasse den Typen als Bicycle.Brand referenzieren

-

-        // Nachdem das Enum deklariert ist, können wir den Typen verwenden:

-        public BikeBrand Brand;

-

-        // Als static gekennzeichnete Member gehören dem Typ selbst,

-        // nicht seinen Instanzen. Man kann sie also ohne Referenz zu einem

-        // Objekt benutzen

-        // Console.WriteLine("Schon " + Bicycle.BicyclesCreated + " Fahrräder, nur für dieses Tutorial!");

-        static public int BicyclesCreated = 0;

-

-        // readonly-Werte werden zur Laufzeit gesetzt

-        // Ihr Wert kann nur bei ihrer Deklaration, oder in einem Konstruktor

-        // festgelegt werden

-        readonly bool _hasCardsInSpokes = false; // readonly und private

-

-        // Konstruktoren bestimmen was bei einer Instantiierung passiert.

-        // Das ist ein Default-Konstruktor:

-        public Bicycle()

-        {

-            // Member der Klasse können über das Keyword this erreicht werden

-            this.Gear = 1;

-            // oft ist das aber gar nicht nötig

-            Cadence = 50;

-            _speed = 5;

-            Name = "Bonanzarad";

-            Brand = BikeBrand.Kynast;

-            BicyclesCreated++;

-        }

-

-        // Das ist ein spezifischer Konstruktor (d.h. er erwartet Argumente):

-        public Bicycle(int startCadence, int startSpeed, int startGear,

-                       string name, bool hasCardsInSpokes, BikeBrand brand)

-            : base() // ruft zuerst den "base"-Konstruktor auf

-        {

-            Gear = startGear;

-            Cadence = startCadence;

-            _speed = startSpeed;

-            Name = name;

-            _hasCardsInSpokes = hasCardsInSpokes;

-            Brand = brand;

-        }

-

-        // Konstruktoren können aneinandergehängt werden:

-        public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :

-            this(startCadence, startSpeed, 0, "richtig große Räder", true, brand)

-        {

-        }

-

-        // Syntax für Methoden:

-        // <public/private/protected> <return type> <function name>(<args>)

-

-        // Klassen können Getter und Setter für Werte definieren,

-        // oder diese Werte direkt als Eigenschaft implementieren

-        // (in C# der bevorzugte Weg)

-

-        // Parameter von Methoden können Default-Werte haben.

-        // "SpeedUp" kann man also auch ohne Parameter aufrufen:

-        public void SpeedUp(int increment = 1)

-        {

-            _speed += increment;

-        }

-

-        public void SlowDown(int decrement = 1)

-        {

-            _speed -= decrement;

-        }

-

-        // Eigenschaften mit get/set

-        // wenn es nur um den Zugriff auf Daten geht, ist eine Eigenschaft zu

-        // empfehlen. Diese können Getter und Setter haben, oder auch nur

-        // einen Getter bzw. einen Setter

-        private bool _hasTassles; // private Variable

-        public bool HasTassles // öffentliches Interface

-        {

-            get { return _hasTassles; }

-            set { _hasTassles = value; }

-        }

-

-        // Das kann man auch kürzer schreiben:

-        // Dieser Syntax erzeugt automatisch einen hinterlegten Wert,

-        // (entsprechend `private bool _isBroken`) der gesetzt

-        // bzw. zurückgegeben wird:

-        public bool IsBroken { get; private set; }

-        public int FrameSize

-        {

-            get;

-            // für Getter und Setter kann der Zugriff auch einzeln

-            // beschränkt werden, FrameSize kann also nur von innerhalb

-            // der Klasse "Bicycle" gesetzt werden

-            private set;

-        }

-

-        // Diese Methode gibt eine Reihe an Informationen über das Objekt aus:

-        public virtual string ToString()

-        {

-            return "Gang: " + Gear +

-                    " Kadenz: " + Cadence +

-                    " Geschwindigkeit: " + _speed +

-                    " Name: " + Name +

-                    " Hipster-Karten zwischen den Speichen: " + (_hasCardsInSpokes ? "Na klar!" : "Bloß nicht!") +

-                    "\n------------------------------\n"

-                    ;

-        }

-

-        // Auch Methoden können als static gekennzeichnet werden, nützlich

-        // beispielsweise für Helper-Methoden

-        public static bool DidWeCreateEnoughBicyclesYet()

-        {

-            // In einer statischen Methode können wir natürlich auch nur

-            // statische Member der Klasse referenzieren

-            return BicyclesCreated > 9000;

-        }

-        // Wenn eine Klasse nur statische Member enthält, kann es eine gute Idee

-        // sein die Klasse selbst als static zu kennzeichnen

-

-    } // Ende der Klasse "Bicycle"

-

-    // "PennyFarthing" ist eine Unterklasse von "Bicycle"

-    class PennyFarthing : Bicycle

-    {

-        // (Hochräder - englisch Penny Farthing - sind diese antiken Fahrräder

-        // mit riesigem Vorderrad. Sie haben keine Gangschaltung.)

-

-        // hier wird einfach der Elternkonstruktor aufgerufen

-        public PennyFarthing(int startCadence, int startSpeed) :

-            base(startCadence, startSpeed, 0, "Hochrad", true, BikeBrand.EddyMerckx)

-        {

-        }

-

-        protected override int Gear

-        {

-            get

-            {

-                return 0;

-            }

-            set

-            {

-                throw new ArgumentException("Ein Hochrad hat keine Gangschaltung, doh!");

-            }

-        }

-

-        public override string ToString()

-        {

-            string result = "Hochrad ";

-            result += base.ToString(); // ruft die "base"-Version der Methode auf

-            return result;

-        }

-    }

-

-    // Interfaces (auch Schnittstellen genant) definieren nur die Signaturen

-    // ihrer Member, enthalten aber auf keinen Fall ihre Implementierung:

-    interface IJumpable

-    {

-        // Alle Member eines Interfaces sind implizit public

-        void Jump(int meters);

-    }

-

-    interface IBreakable

-    {

-        // Interfaces können Eigenschaften, Methoden und Events definieren

-        bool Broken { get; }

-    }

-

-    // Eine Klasse kann nur von einer Klasse erben, kann aber eine beliebige

-    // Anzahl von Interfaces implementieren

-    class MountainBike : Bicycle, IJumpable, IBreakable

-    {

-        int damage = 0;

-

-        public void Jump(int meters)

-        {

-            damage += meters;

-        }

-

-        public bool Broken

-        {

-            get

-            {

-                return damage > 100;

-            }

-        }

-    }

-

-    // Das hier stellt eine Datenbankverbindung für das LinqToSql-Beispiel her.

-    // EntityFramework Code First ist großartig

-    // (ähnlich zu Ruby's ActiveRecord, aber bidirektional)

-    // http://msdn.microsoft.com/de-de/data/jj193542.aspx

-    public class BikeRepository : DbSet

-    {

-        public BikeRepository()

-            : base()

-        {

-        }

-

-        public DbSet<Bicycle> Bikes { get; set; }

-    }

-} // Ende des Namespaces

-```

-

-## In dieser Übersicht nicht enthalten sind die Themen:

-

- * Flags

- * Attributes

- * Statische Eigenschaften

- * Exceptions, Abstraction

- * ASP.NET (Web Forms/MVC/WebMatrix)

- * Winforms

- * Windows Presentation Foundation (WPF)

-

-## Zum Weiterlesen gibt es viele gute Anlaufpunkte:

-

- * [DotNetPerls](http://www.dotnetperls.com)

- * [C# in Depth](http://manning.com/skeet2)

- * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)

- * [LINQ](http://shop.oreilly.com/product/9780596519254.do)

- * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx)

- * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)

- * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/overview/exploring-webmatrix)

- * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)

- * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)

-

-[C# Coding Conventions](http://msdn.microsoft.com/de-de/library/vstudio/ff926074.aspx)

+---
+language: C#
+contributors:
+    - ["Irfan Charania", "https://github.com/irfancharania"]
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Melvyn Laïly", "http://x2a.yt"]
+    - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
+translators:
+    - ["Frederik Ring", "https://github.com/m90"]
+filename: LearnCSharp-de.cs
+lang: de-de
+---
+C# ist eine elegante, typsichere und objektorientierte Sprache, mit der Entwickler eine Vielzahl sicherer und robuster Anwendungen erstellen können, die im .NET Framework ausgeführt werden.
+
+[Mehr über C# erfährst du hier.](http://msdn.microsoft.com/de-de/library/vstudio/z1zx9t92.aspx)
+
+```c#
+// Einzeilige Kommentare starten mit zwei Schrägstrichen: //
+/*
+Mehrzeile Kommentare wie in C Schrägstrich / Stern
+*/
+/// <summary>
+/// XML-Kommentare können zur automatisierten Dokumentation verwendet werden
+/// </summary>
+
+// Zu Beginn werden die in der Datei verwendeten Namespaces aufgeführt
+using System;
+using System.Collections.Generic;
+using System.Data.Entity;
+using System.Dynamic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Net;
+using System.Threading.Tasks;
+using System.IO;
+
+// definiert einen Namespace um Code in "packages" zu organisieren
+namespace Learning
+{
+    // Jede .cs-Datei sollte zumindest eine Klasse mit dem Namen der Datei
+    // enthalten. Das ist zwar nicht zwingend erforderlich, es anders zu
+    // handhaben führt aber unweigerlich ins Chaos (wirklich)!
+    public class LearnCSharp
+    {
+        // Zuerst erklärt dieses Tutorial die Syntax-Grundlagen,
+        // wenn du bereits Java oder C++ programmieren kannst:
+        // lies bei "Interessante Features" weiter!
+        public static void Syntax()
+        {
+            // Mit Console.WriteLine kannst du einfachen Text ausgeben:
+            Console.WriteLine("Hallo Welt");
+            Console.WriteLine(
+                "Integer: " + 10 +
+                " Double: " + 3.14 +
+                " Boolean: " + true);
+
+            // Console.Write erzeugt keinen Zeilenumbruch
+            Console.Write("Hallo ");
+            Console.Write("Welt");
+
+            ///////////////////////////////////////////////////
+            // Typen & Variablen
+            ///////////////////////////////////////////////////
+
+            // Deklariere eine Variable mit <Typ> <Name>
+
+            // Sbyte - Vorzeichenbehaftete 8-Bit Ganzzahl
+            // (-128 <= sbyte <= 127)
+            sbyte fooSbyte = 100;
+
+            // Byte - Vorzeichenlose 8-Bit Ganzzahl
+            // (0 <= byte <= 255)
+            byte fooByte = 100;
+
+            // Short - 16-Bit Ganzzahl
+            // Vorzeichenbehaftet - (-32,768 <= short <= 32,767)
+            // Vorzeichenlos - (0 <= ushort <= 65,535)
+            short fooShort = 10000;
+            ushort fooUshort = 10000;
+
+            // Integer - 32-bit Ganzzahl
+            int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
+            uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
+
+            // Long - 64-bit Ganzzahl
+            long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+            ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
+            // Ganze Zahlen werden standardmäßig - je nach Größe - als int oder
+            // uint behandelt. Ein nachgestelltes L markiert den Wert als long
+            // oder ulong.
+
+            // Double - Double-precision 64-bit IEEE 754 Fließkommazahl
+            double fooDouble = 123.4; // Genauigkeit: 15-16 Stellen
+
+            // Float - Single-precision 32-bit IEEE 754 Fließkommazahl
+            float fooFloat = 234.5f; // Genauigkeit: 7 Stellen
+            // Das nachgestellte f zeigt an dass es sich um einen Wert vom Typ
+            // float handelt
+
+            // Decimal - ein 128-Bit-Datentyp mit größerer Genauigkeit als
+            // andere Fließkommatypen, und somit bestens geeignet für
+            // die Berechnung von Geld- und Finanzwerten
+            decimal fooDecimal = 150.3m;
+
+            // Boolean - true & false
+            bool fooBoolean = true; // oder false
+
+            // Char - Ein einzelnes 16-Bit Unicode Zeichen
+            char fooChar = 'A';
+
+            // Strings - im Gegensatz zu allen vorhergehenden Basistypen, die
+            // alle Werttypen sind, ist String ein Referenztyp. Strings sind
+            // somit nullable, Werttypen sind dies nicht.
+            string fooString = "\"maskiere\" Anführungszeichen, und füge \n (Umbrüche) und \t (Tabs) hinzu";
+            Console.WriteLine(fooString);
+
+            // Jeder Buchstabe eines Strings kann über seinen Index
+            // referenziert werden:
+            char charFromString = fooString[1]; // => 'e'
+            // Strings sind unveränderlich:
+            // `fooString[1] = 'X';` funktioniert nicht
+
+            // Ein Vergleich zweier Strings, unter Berücksichtigung der
+            // aktuellen, sprachspezifischen Gegebenheiten (also z.B. a,ä,b,c
+            // in deutschsprachigen Umgebungen), und ohne Beachtung von
+            // Groß- und Kleinschreibung:
+            string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
+
+            // Formatierung, genau wie "sprintf"
+            string fooFs = string.Format("Mikrofon Check, {0} {1}, {0} {1:0.0}", 1, 2);
+
+            // Datumsangaben und Formatierung
+            DateTime fooDate = DateTime.Now;
+            Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
+
+            // Durch ein vorangestelltes @ lässt sich ein mehrzeiliger String
+            // schreiben. Um " zu maskieren benutzt man ""
+            string bazString = @"Hier geht es
+zur nächsten Zeile, ""Wahnsinn!"", die Massen waren kaum zu bändigen";
+
+            // Die Keywords const oder readonly kennzeichnen eine
+            // unveränderliche Variable/Konstante. Die Werte von Konstanten
+            // werden übrigens bereits zur Compile-Zeit berechnet.
+            const int HOURS_I_WORK_PER_WEEK = 9001;
+
+            ///////////////////////////////////////////////////
+            // Datenstrukturen
+            ///////////////////////////////////////////////////
+
+            // Arrays - Index beginnt bei Null
+            // Die Größe des Arrays wird bei der Deklaration festgelegt.
+            // Die syntaktische Struktur um ein neues Array zu erzeugen sieht
+            // folgendermaßen aus:
+            // <datatype>[] <varname> = new <datatype>[<array size>];
+            int[] intArray = new int[10];
+
+            // Arrays können auch über ein Array-Literal deklariert werden:
+            int[] y = { 9000, 1000, 1337 };
+
+            // Indizierung eines Arrays - Zugriff auf ein bestimmtes Element
+            Console.WriteLine("intArray @ 0: " + intArray[0]);
+            // Arrays sind veränderbar
+            intArray[1] = 1;
+
+            // Listen
+            // Durch ihre größere Flexibilität kommen Listen in C# weit
+            // häufiger zum Einsatz als Arrays. Eine Liste wird so deklariert:
+            // List<datatype> <varname> = new List<datatype>();
+            List<int> intList = new List<int>();
+            List<string> stringList = new List<string>();
+            List<int> z = new List<int> { 9000, 1000, 1337 };
+            // Die <> kennzeichnen "Generics", mehr dazu unter "Coole Sachen"
+
+            // Listen haben keinen Default-Wert.
+            // Bevor auf einen Index zugegriffen werden kann, muss dieser
+            // auch gesetzt worden sein:
+            intList.Add(1);
+            Console.WriteLine("intList @ 0: " + intList[0]);
+
+            // Andere interessante Datenstrukturen sind:
+            // Stack/Queue
+            // Dictionary (entspricht einer Hash Map)
+            // HashSet
+            // Read-only Collections
+            // Tuple (.Net 4+)
+
+            ///////////////////////////////////////
+            // Operatoren
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Operatoren");
+
+            // kurze Schreibweise um mehrere Deklarationen zusammenzufassen:
+            // (Benutzung vom C# Styleguide aber ausdrücklich abgeraten!)
+            int i1 = 1, i2 = 2;
+
+            // Arithmetik funktioniert wie erwartet:
+            Console.WriteLine(i1 + i2 - i1 * 3 / 7); // => 3
+
+            // Modulo
+            Console.WriteLine("11%3 = " + (11 % 3)); // => 2
+
+            // Vergleiche
+            Console.WriteLine("3 == 2? " + (3 == 2)); // => false
+            Console.WriteLine("3 != 2? " + (3 != 2)); // => true
+            Console.WriteLine("3 > 2? " + (3 > 2)); // => true
+            Console.WriteLine("3 < 2? " + (3 < 2)); // => false
+            Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true
+            Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true
+
+            // Bitweise Operatoren
+            /*
+            ~       Unäres bitweises NICHT
+            <<      Verschieben nach links
+            >>      Verschieben nach rechts
+            &       Bitweises UND
+            ^       Bitweises exklusives ODER
+            |       Bitweises inklusives ODER
+            */
+
+            // Inkremente
+            int i = 0;
+            Console.WriteLine("\n->Inkrement / Dekrement");
+            Console.WriteLine(i++); //i = 1. Post-Inkrement
+            Console.WriteLine(++i); //i = 2. Pre-Inkrement
+            Console.WriteLine(i--); //i = 1. Post-Dekrement
+            Console.WriteLine(--i); //i = 0. Pre-Dekrement
+
+            ///////////////////////////////////////
+            // Kontrollstrukturen
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Kontrollstrukturen");
+
+            // If-Statements funktionieren wie in C
+            int j = 10;
+            if (j == 10)
+            {
+                Console.WriteLine("Ich werde ausgegeben");
+            }
+            else if (j > 10)
+            {
+                Console.WriteLine("Ich nicht");
+            }
+            else
+            {
+                Console.WriteLine("Ich leider auch nicht");
+            }
+
+            // Ternärer Operator
+            // Anstatt eines einfachen if/else lässt sich auch folgendes schreiben:
+            // <condition> ? <true> : <false>
+            int zumVergleich = 17;
+            string isTrue = zumVergleich == 17 ? "Ja" : "Nein";
+
+            // while-Schleife
+            int fooWhile = 0;
+            while (fooWhile < 100)
+            {
+                // Wird 100mal wiederholt, fooWhile 0->99
+                fooWhile++;
+            }
+
+            // do-while-Schleife
+            int fooDoWhile = 0;
+            do
+            {
+                // Wird 100mal wiederholt, fooDoWhile 0->99
+                fooDoWhile++;
+            } while (fooDoWhile < 100);
+
+            //for-Schleifen => for(<start_statement>; <conditional>; <step>)
+            for (int fooFor = 0; fooFor < 10; fooFor++)
+            {
+                // Wird 10mal wiederholt, fooFor 0->9
+            }
+
+            // foreach-Schleife
+            // Die normale Syntax für eine foreach-Schleife lautet:
+            // foreach(<iteratorType> <iteratorName> in <enumerable>)
+            // foreach kann mit jedem Objekt verwendet werden das IEnumerable
+            // oder IEnumerable<T> implementiert. Alle Auflistungs-Typen
+            // (Array, List, Dictionary...) im .NET Framework implementieren
+            // eines dieser beiden Interfaces.
+
+            foreach (char character in "Hallo Welt".ToCharArray())
+            {
+                // Ein Durchgang für jedes Zeichen im String
+            }
+            // (ToCharArray() könnte man hier übrigens auch weglassen,
+            // da String IEnumerable bereits implementiert)
+
+            // Switch Struktur
+            // Ein Switch funktioniert mit byte, short, char und int Datentypen.
+            // Auch Aufzählungstypen können verwendet werden, genau wie
+            // die Klasse String, und ein paar Sonderklassen, die Wrapper für
+            // Primitives sind: Character, Byte, Short und Integer
+            int month = 3;
+            string monthString;
+            switch (month)
+            {
+                case 1:
+                    monthString = "Januar";
+                    break;
+                case 2:
+                    monthString = "Februar";
+                    break;
+                case 3:
+                    monthString = "März";
+                    break;
+                // Man kann für mehrere Fälle auch das selbe Verhalten
+                // definieren. Jeder Block muss aber mit einem break-Statement
+                // abgeschlossen werden. Einzelne Fälle können über
+                // `goto case x` erreicht werden
+                case 6:
+                case 7:
+                case 8:
+                    monthString = "Sommer!!";
+                    break;
+                default:
+                    monthString = "Irgendein anderer Monat";
+                    break;
+            }
+
+            ///////////////////////////////////////
+            // Umwandlung von Datentypen und Typecasting
+            ///////////////////////////////////////
+
+            // Umwandlung
+
+            // von String nach Integer
+            // bei einem Fehler wirft diese Code eine Exception
+            int.Parse("123"); //gibt die Ganzzahl 123 zurück
+
+            // TryParse gibt bei einem Fehler den Default-Wert zurück
+            // (im Fall von int: 0)
+            int tryInt;
+            if (int.TryParse("123", out tryInt)) // gibt true oder false zurück
+            {
+                Console.WriteLine(tryInt);       // 123
+            }
+
+            // von Integer nach String
+            // Die Klasse Convert stellt Methoden zur Konvertierung von
+            // unterschiedlichsten Daten zur Verfügung:
+            Convert.ToString(123); // "123"
+            // oder
+            tryInt.ToString(); // "123"
+        }
+
+        ///////////////////////////////////////
+        // Klassen
+        ///////////////////////////////////////
+        public static void Classes()
+        {
+
+            // Benutze das new-Keyword um eine Instanz einer Klasse zu erzeugen
+            Bicycle trek = new Bicycle();
+
+            // So werden Methoden der Instanz aufgerufen
+            trek.SpeedUp(3); // Es empfiehlt sich immer Getter und Setter zu benutzen
+            trek.Cadence = 100;
+
+            // ToString ist eine Konvention über die man üblicherweiser
+            // Informationen über eine Instanz erhält
+            Console.WriteLine("Infos zu trek: " + trek.ToString());
+
+            // Wir instantiieren ein neues Hochrad
+            PennyFarthing funbike = new PennyFarthing(1, 10);
+            Console.WriteLine("Infos zu funbike: " + funbike.ToString());
+
+            Console.Read();
+        } // Ende der Methode main
+
+        // Main als Konsolenstartpunkt
+        // Eine Konsolenanwendung muss eine Methode Main als Startpunkt besitzen
+        public static void Main(string[] args)
+        {
+            OtherInterestingFeatures();
+        }
+
+        ///////////////////////////////////////
+        // Interessante Features
+        ///////////////////////////////////////
+
+        // Methodensignaturen
+
+        public // Sichtbarkeit
+        static // Erlaubt einen Zugriff auf der Klasse (nicht auf einer Instanz)
+        int // Typ des Rückgabewerts,
+        MethodSignatures(
+            // Erstes Argument, erwartet int
+            int maxCount,
+            // setzt sich selbst auf 0 wenn kein anderer Wert übergeben wird
+            int count = 0,
+            int another = 3,
+            // enthält alle weiteren der Methode übergebenen Parameter (quasi Splats)
+            params string[] otherParams
+        )
+        {
+            return -1;
+        }
+
+        // Methoden können überladen werden, solange sie eindeutige
+        // Signaturen haben
+        public static void MethodSignatures(string maxCount)
+        {
+        }
+
+        // Generische Typen
+        // Die Typen für TKey und TValue werden erst beim Aufruf der Methode
+        // festgelegt. Diese Methode emuliert z.B. SetDefault aus Python:
+        public static TValue SetDefault<TKey, TValue>(
+            IDictionary<TKey, TValue> dictionary,
+            TKey key,
+            TValue defaultItem)
+        {
+            TValue result;
+            if (!dictionary.TryGetValue(key, out result))
+            {
+                return dictionary[key] = defaultItem;
+            }
+            return result;
+        }
+
+        // Möglichen Typen lassen sich auch über ihr Interface beschränken:
+        public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
+        {
+            // Da T ein IEnumerable ist können wir foreach benutzen
+            foreach (var item in toPrint)
+            {
+                // Item ist ein int
+                Console.WriteLine(item.ToString());
+            }
+        }
+
+        public static void OtherInterestingFeatures()
+        {
+            // Optionale Parameter
+            MethodSignatures(3, 1, 3, "Ein paar", "extra", "Strings");
+            // setzt explizit einen bestimmten Parameter, andere werden übersprungen
+            MethodSignatures(3, another: 3);
+
+            // Erweiterungsmethoden
+            int i = 3;
+            i.Print(); // Weiter unten definiert
+
+            // Nullables - perfekt für die Interaktion mit
+            // Datenbanken / Rückgabewerten
+            // Jeder Wert (d.h. keine Klassen) kann durch das Nachstellen eines ?
+            // nullable gemacht werden: <type>? <varname> = <value>
+            int? nullable = null; // Die explizite Langform wäre Nullable<int>
+            Console.WriteLine("Mein Nullable: " + nullable);
+            bool hasValue = nullable.HasValue; // true wenn nicht null
+
+            // ?? ist "syntaktischer Zucker" um einen Defaultwert für den Fall
+            // dass die Variable null ist festzulegen.
+            int notNullable = nullable ?? 0; // 0
+
+            // Implizit typisierte Variablen
+            // Man kann auch den Typ einer Variable auch vom Compiler
+            // bestimmen lassen:
+            var magic = "magic ist zur Compile-Zeit ein String, folglich geht keine Typsicherheit verloren";
+            magic = 9; // funktioniert nicht da magic vom Typ String ist
+
+            // Generics
+            var phonebook = new Dictionary<string, string>() {
+                {"Resi", "08822 / 43 67"} // Fügt einen Eintrag zum Telefonbuch hinzu
+            };
+
+            // Hier könnte man auch unser generisches SetDefault von
+            // weiter oben benutzen:
+            Console.WriteLine(SetDefault<string,string>(phonebook, "Xaver", "kein Telefon")); // kein Telefon
+            // TKey und TValue müssen nicht zwingend angegeben werden, da sie
+            // auch implizit vom Compiler ermittelt werden können
+            Console.WriteLine(SetDefault(phonebook, "Resi", "kein Telefon")); // 08822 / 43 67
+
+            // Lambdas - konzise Syntax für Inline-Funktionen
+            Func<int, int> square = (x) => x * x; // Das letzte Element vom Typ T ist der Rückgabewert
+            Console.WriteLine(square(3)); // 9
+
+            // Disposables - einfaches Management von nicht verwalteten Ressourcen
+            // So gut wie alle Objekte die auf nicht verwaltete Ressourcen
+            // (Dateien, Geräte, ...) zugreifen, implementieren das Interface
+            // IDisposable. Das using Statement stellt sicher dass die vom
+            // IDisposable benutzten Ressourcen nach der Benutzung wieder
+            // freigegeben werden:
+            using (StreamWriter writer = new StreamWriter("log.txt"))
+            {
+                writer.WriteLine("Alles bestens!");
+                // Am Ende des Codeblocks werden die Ressourcen wieder
+                // freigegeben - auch im Falle einer Exception
+            }
+
+            // Parallel Klasse
+            // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
+            var websites = new string[] {
+                "http://www.google.com", "http://www.reddit.com",
+                "http://www.shaunmccarthy.com"
+            };
+            var responses = new Dictionary<string, string>();
+
+            // Für jeden Request wird ein neuer Thread erzeugt, der nächste
+            // Schritt wird erst nach Beendigung aller Tasks ausgeführt
+            Parallel.ForEach(websites,
+                // maximal 3 Threads gleichzeitig
+                new ParallelOptions() {MaxDegreeOfParallelism = 3},
+                website =>
+            {
+                // Hier folgt eine langwierige, asynchrone Operation
+                using (var r = WebRequest.Create(new Uri(website)).GetResponse())
+                {
+                    responses[website] = r.ContentType;
+                }
+            });
+
+            // Dieser Code wird erst nach Beendigung aller Requests ausgeführt
+            foreach (var key in responses.Keys)
+            {
+                Console.WriteLine("{0}:{1}", key, responses[key]);
+            }
+
+            // Dynamische Objekte (gut um mit anderen Sprachen zu arbeiten)
+            dynamic student = new ExpandoObject();
+            // hier muss keine Typ angegeben werden
+            student.FirstName = "Christian";
+
+            // Einem solchen Objekt kann man sogar Methoden zuordnen.
+            // Das Beispiel gibt einen String zurück und erwartet einen String
+            student.Introduce = new Func<string, string>(
+                (introduceTo) => string.Format("Hallo {0}, das ist {1}", student.FirstName, introduceTo));
+            Console.WriteLine(student.Introduce("Bettina"));
+
+            // IQueryable<T> - So gut wie alle Aufzählungstypen implementieren
+            // dieses Interface, welches eine Vielzahl von funktionalen Methoden
+            // wie Map / Filter / Reduce zur Verfügung stellt:
+            var bikes = new List<Bicycle>();
+            // sortiert die Liste
+            bikes.Sort();
+            // sortiert nach Anzahl Räder
+            bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels));
+            var result = bikes
+                // diese Filter können auch aneinandergehängt werden
+                .Where(b => b.Wheels > 3) // (gibt ein IQueryable des vorherigen Typs zurück)
+                .Where(b => b.IsBroken && b.HasTassles)
+                // diese Zuordnung gibt ein IQueryable<String> zurück
+                .Select(b => b.ToString());
+
+            // "Reduce" - addiert alle Räder der Aufzählung zu einem Wert
+            var sum = bikes.Sum(b => b.Wheels);
+
+            // So erzeugt man ein implizit typisiertes Objekt, basierend auf
+            // den Parametern der Elemente:
+            var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
+            // Auch wenn wir es hier nicht demonstrieren können:
+            // In einer IDE wie VisualStudio kriegen wir hier sogar TypeAhead,
+            // da der Compiler in der Lage ist, die passenden Typen zu erkennen.
+            foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
+            {
+                Console.WriteLine(bikeSummary.Name);
+            }
+
+            // AsParallel-Methode
+            // Jetzt kommen die Schmankerl! Die AsParallel-Methode kombiniert
+            // LINQ und parallele Operationen:
+            var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
+            // Diese Berechnung passiert parallel! Benötigte Threads werden
+            // automatisch erzeugt, und die Rechenlast unter ihnen aufgeteilt.
+            // Ein Traum für die Verarbeitung von großen Datenmengen
+            // auf mehreren Cores!
+
+            // LINQ - bildet einen Datenspeicher auf IQueryable<T> Objekte ab
+            // LinqToSql beispielsweise speichert und liest aus einer
+            // SQL-Datenbank, LinqToXml aus einem XML-Dokument.
+            // LINQ-Operationen werden "lazy" ausgeführt.
+            var db = new BikeRepository();
+
+            // Die verzögerte Ausführung ist optimal für Datenbankabfragen
+            var filter = db.Bikes.Where(b => b.HasTassles); // noch keine Abfrage
+            // Es können noch mehr Filter hinzugefügt werden (auch mit
+            // Bedingungen) - ideal für z.B. "erweiterte Suchen"
+            if (42 > 6)
+            {
+                filter = filter.Where(b => b.IsBroken); // immer noch keine Abfrage
+            }
+
+            var query = filter
+                .OrderBy(b => b.Wheels)
+                .ThenBy(b => b.Name)
+                .Select(b => b.Name); // auch hier: immer noch keine Abfrage
+
+            // Erst hier wird die Datenbankabfrage wirklich ausgeführt,
+            // limitiert auf die Elemente die der foreach-Loop verwendet
+            foreach (string bike in query)
+            {
+                Console.WriteLine(result);
+            }
+
+        }
+
+    } // Ende der Klasse LearnCSharp
+
+    // Eine .cs-Datei kann auch mehrere Klassen enthalten
+
+    public static class Extensions
+    {
+        // Erweiterungsmethoden
+        public static void Print(this object obj)
+        {
+            Console.WriteLine(obj.ToString());
+        }
+    }
+
+    // Syntax zur Deklaration einer Klasse:
+    // <public/private/protected/internal> class <class name>{
+    //    // Datenfelder, Konstruktoren und Methoden leben alle
+    //    // innerhalb dieser Deklaration
+    // }
+
+    public class Bicycle
+    {
+        // Felder/Variablen der Klasse "Bicycle"
+        // Das Keyword public macht das Member von überall zugänglich
+        public int Cadence
+        {
+            get // get definiert eine Methode um die Eigenschaft abzurufen
+            {
+                return _cadence;
+            }
+            set // set definiert eine Methode um die Eigenschaft zu setzen
+            {
+                _cadence = value; // value ist der dem Setter übergebene Wert
+            }
+        }
+        private int _cadence;
+
+        // Das Keyword protected macht das Member nur für die Klasse selbst
+        // und ihre Subklassen zugänglich
+        protected virtual int Gear
+        {
+            get; // erzeugt eine Eigenschaft für die kein "Zwischenwert" benötigt wird
+            set;
+        }
+
+        // Das Keyword internal macht das Member innerhalb der Assembly zugänglich
+        internal int Wheels
+        {
+            get;
+            private set; // get/set kann auch über Keywords modifiziert werden
+        }
+
+        int _speed; // Member ohne vorangestellte Keywords sind standardmäßig
+                    // private, sie sind nur innerhalb der Klasse zugänglich.
+                    // Man kann aber natürlich auch das Keyword private benutzen.
+        private string Name { get; set; }
+
+        // Ein Enum ist ein klar definierter Satz an benannten Konstanten.
+        // Eigentlich ordnet es diese Konstanten nur bestimmten Werten zu
+        // (einer int-Zahl, solange nicht anders angegeben). Mögliche Typen für
+        // die Werte eines Enums sind byte, sbyte, short, ushort, int, uint,
+        // long, oder ulong. Alle Werte in einem Enum sind eindeutig.
+        public enum BikeBrand
+        {
+            Colnago,
+            EddyMerckx,
+            Bianchi = 42, // so kann man den Wert explizit setzen
+            Kynast // 43
+        }
+        // Nachdem dieser Typ in der Klasse "Bicycle" definiert ist,
+        // sollte Code ausserhalb der Klasse den Typen als Bicycle.Brand referenzieren
+
+        // Nachdem das Enum deklariert ist, können wir den Typen verwenden:
+        public BikeBrand Brand;
+
+        // Als static gekennzeichnete Member gehören dem Typ selbst,
+        // nicht seinen Instanzen. Man kann sie also ohne Referenz zu einem
+        // Objekt benutzen
+        // Console.WriteLine("Schon " + Bicycle.BicyclesCreated + " Fahrräder, nur für dieses Tutorial!");
+        static public int BicyclesCreated = 0;
+
+        // readonly-Werte werden zur Laufzeit gesetzt
+        // Ihr Wert kann nur bei ihrer Deklaration, oder in einem Konstruktor
+        // festgelegt werden
+        readonly bool _hasCardsInSpokes = false; // readonly und private
+
+        // Konstruktoren bestimmen was bei einer Instantiierung passiert.
+        // Das ist ein Default-Konstruktor:
+        public Bicycle()
+        {
+            // Member der Klasse können über das Keyword this erreicht werden
+            this.Gear = 1;
+            // oft ist das aber gar nicht nötig
+            Cadence = 50;
+            _speed = 5;
+            Name = "Bonanzarad";
+            Brand = BikeBrand.Kynast;
+            BicyclesCreated++;
+        }
+
+        // Das ist ein spezifischer Konstruktor (d.h. er erwartet Argumente):
+        public Bicycle(int startCadence, int startSpeed, int startGear,
+                       string name, bool hasCardsInSpokes, BikeBrand brand)
+            : base() // ruft zuerst den "base"-Konstruktor auf
+        {
+            Gear = startGear;
+            Cadence = startCadence;
+            _speed = startSpeed;
+            Name = name;
+            _hasCardsInSpokes = hasCardsInSpokes;
+            Brand = brand;
+        }
+
+        // Konstruktoren können aneinandergehängt werden:
+        public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
+            this(startCadence, startSpeed, 0, "richtig große Räder", true, brand)
+        {
+        }
+
+        // Syntax für Methoden:
+        // <public/private/protected> <return type> <function name>(<args>)
+
+        // Klassen können Getter und Setter für Werte definieren,
+        // oder diese Werte direkt als Eigenschaft implementieren
+        // (in C# der bevorzugte Weg)
+
+        // Parameter von Methoden können Default-Werte haben.
+        // "SpeedUp" kann man also auch ohne Parameter aufrufen:
+        public void SpeedUp(int increment = 1)
+        {
+            _speed += increment;
+        }
+
+        public void SlowDown(int decrement = 1)
+        {
+            _speed -= decrement;
+        }
+
+        // Eigenschaften mit get/set
+        // wenn es nur um den Zugriff auf Daten geht, ist eine Eigenschaft zu
+        // empfehlen. Diese können Getter und Setter haben, oder auch nur
+        // einen Getter bzw. einen Setter
+        private bool _hasTassles; // private Variable
+        public bool HasTassles // öffentliches Interface
+        {
+            get { return _hasTassles; }
+            set { _hasTassles = value; }
+        }
+
+        // Das kann man auch kürzer schreiben:
+        // Dieser Syntax erzeugt automatisch einen hinterlegten Wert,
+        // (entsprechend `private bool _isBroken`) der gesetzt
+        // bzw. zurückgegeben wird:
+        public bool IsBroken { get; private set; }
+        public int FrameSize
+        {
+            get;
+            // für Getter und Setter kann der Zugriff auch einzeln
+            // beschränkt werden, FrameSize kann also nur von innerhalb
+            // der Klasse "Bicycle" gesetzt werden
+            private set;
+        }
+
+        // Diese Methode gibt eine Reihe an Informationen über das Objekt aus:
+        public virtual string ToString()
+        {
+            return "Gang: " + Gear +
+                    " Kadenz: " + Cadence +
+                    " Geschwindigkeit: " + _speed +
+                    " Name: " + Name +
+                    " Hipster-Karten zwischen den Speichen: " + (_hasCardsInSpokes ? "Na klar!" : "Bloß nicht!") +
+                    "\n------------------------------\n"
+                    ;
+        }
+
+        // Auch Methoden können als static gekennzeichnet werden, nützlich
+        // beispielsweise für Helper-Methoden
+        public static bool DidWeCreateEnoughBicyclesYet()
+        {
+            // In einer statischen Methode können wir natürlich auch nur
+            // statische Member der Klasse referenzieren
+            return BicyclesCreated > 9000;
+        }
+        // Wenn eine Klasse nur statische Member enthält, kann es eine gute Idee
+        // sein die Klasse selbst als static zu kennzeichnen
+
+    } // Ende der Klasse "Bicycle"
+
+    // "PennyFarthing" ist eine Unterklasse von "Bicycle"
+    class PennyFarthing : Bicycle
+    {
+        // (Hochräder - englisch Penny Farthing - sind diese antiken Fahrräder
+        // mit riesigem Vorderrad. Sie haben keine Gangschaltung.)
+
+        // hier wird einfach der Elternkonstruktor aufgerufen
+        public PennyFarthing(int startCadence, int startSpeed) :
+            base(startCadence, startSpeed, 0, "Hochrad", true, BikeBrand.EddyMerckx)
+        {
+        }
+
+        protected override int Gear
+        {
+            get
+            {
+                return 0;
+            }
+            set
+            {
+                throw new ArgumentException("Ein Hochrad hat keine Gangschaltung, doh!");
+            }
+        }
+
+        public override string ToString()
+        {
+            string result = "Hochrad ";
+            result += base.ToString(); // ruft die "base"-Version der Methode auf
+            return result;
+        }
+    }
+
+    // Interfaces (auch Schnittstellen genant) definieren nur die Signaturen
+    // ihrer Member, enthalten aber auf keinen Fall ihre Implementierung:
+    interface IJumpable
+    {
+        // Alle Member eines Interfaces sind implizit public
+        void Jump(int meters);
+    }
+
+    interface IBreakable
+    {
+        // Interfaces können Eigenschaften, Methoden und Events definieren
+        bool Broken { get; }
+    }
+
+    // Eine Klasse kann nur von einer Klasse erben, kann aber eine beliebige
+    // Anzahl von Interfaces implementieren
+    class MountainBike : Bicycle, IJumpable, IBreakable
+    {
+        int damage = 0;
+
+        public void Jump(int meters)
+        {
+            damage += meters;
+        }
+
+        public bool Broken
+        {
+            get
+            {
+                return damage > 100;
+            }
+        }
+    }
+
+    // Das hier stellt eine Datenbankverbindung für das LinqToSql-Beispiel her.
+    // EntityFramework Code First ist großartig
+    // (ähnlich zu Ruby's ActiveRecord, aber bidirektional)
+    // http://msdn.microsoft.com/de-de/data/jj193542.aspx
+    public class BikeRepository : DbSet
+    {
+        public BikeRepository()
+            : base()
+        {
+        }
+
+        public DbSet<Bicycle> Bikes { get; set; }
+    }
+} // Ende des Namespaces
+```
+
+## In dieser Übersicht nicht enthalten sind die Themen:
+
+ * Flags
+ * Attributes
+ * Statische Eigenschaften
+ * Exceptions, Abstraction
+ * ASP.NET (Web Forms/MVC/WebMatrix)
+ * Winforms
+ * Windows Presentation Foundation (WPF)
+
+## Zum Weiterlesen gibt es viele gute Anlaufpunkte:
+
+ * [DotNetPerls](http://www.dotnetperls.com)
+ * [C# in Depth](http://manning.com/skeet2)
+ * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)
+ * [LINQ](http://shop.oreilly.com/product/9780596519254.do)
+ * [MSDN Library](http://msdn.microsoft.com/en-us/library/618ayhy6.aspx)
+ * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)
+ * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/overview/exploring-webmatrix)
+ * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)
+ * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
+
+[C# Coding Conventions](http://msdn.microsoft.com/de-de/library/vstudio/ff926074.aspx)
diff --git a/de-de/dynamic-programming-de.html.markdown b/de-de/dynamic-programming-de.html.markdown
index 58568b3b..9cf461d0 100644
--- a/de-de/dynamic-programming-de.html.markdown
+++ b/de-de/dynamic-programming-de.html.markdown
@@ -56,6 +56,7 @@ wie `largest_sequences_so_far` und dessen Index würde eine Menge Zeit sparen.
 
 Ein ähnliches Konzept könnte auch bei der Suche nach dem längsten Weg
 in gerichteten azyklischen Graphen angewandt werden.
+
 ```python
 for i=0 to n-1
     LS[i]=1
diff --git a/de-de/elixir-de.html.markdown b/de-de/elixir-de.html.markdown
index 254cca51..4acb8e23 100644
--- a/de-de/elixir-de.html.markdown
+++ b/de-de/elixir-de.html.markdown
@@ -1,423 +1,423 @@
----

-language: elixir

-contributors:

-    - ["Joao Marques", "http://github.com/mrshankly"]

-translators:

-    - ["Gregor Große-Bölting", "http://www.ideen-und-soehne.de"]

-filename: learnelixir-de.ex

-lang: de-de

----

-

-Elixir ist eine moderne, funktionale Sprache für die Erlang VM. Sie ist voll 

-kompatibel mit Erlang, verfügt aber über eine freundlichere Syntax und bringt 

-viele Features mit. 

-

-```ruby

-

-# Einzeilige Kommentare werden mit der Raute gesetzt.

-

-# Es gibt keine mehrzeiligen Kommentare;

-# es ist aber problemlos möglich mehrere einzeilige Kommentare hintereinander 

-# zu setzen (so wie hier).

-

-# Mit 'iex' ruft man die Elixir-Shell auf.

-# Zum kompilieren von Modulen dient der Befehl 'elixirc'.

-

-# Beide Befehle sollten als Umgebungsvariable gesetzt sein, wenn Elixir korrekt

-# installiert wurde.

-

-## ---------------------------

-## -- Basistypen

-## ---------------------------

-

-# Es gibt Nummern:

-3    # Integer

-0x1F # Integer

-3.0  # Float

-

-# Für bessere Lesbarkeit des Codes können Unterstriche "_" als Trennzeichen verwendet werden

-1_000_000 == 1000000  # Integer

-1_000.567 == 1000.567 # Float

-

-# Atome, das sind Literale, sind Konstanten mit Namen. Sie starten mit einem 

-# ':'.

-:hello # Atom

-

-# Außerdem gibt es Tupel, deren Werte im Arbeitsspeicher vorgehalten werden.

-{1,2,3} # Tupel

-

-# Die Werte innerhalb eines Tupels können mit der 'elem'-Funktion ausgelesen

-# werden:

-elem({1, 2, 3}, 0) # => 1

-

-# Listen sind als verkettete Listen implementiert.

-[1, 2, 3] # list

-

-# Auf Kopf und Rest einer Liste kann wie folgt zugegriffen werden:

-[ kopf | rest ] = [1,2,3]

-kopf # => 1

-rest # => [2, 3]

-

-# In Elixir, wie auch in Erlang, kennzeichnet '=' ein 'pattern matching'

-# (Musterabgleich) und keine Zuweisung.

-# Das heißt, dass die linke Seite auf die rechte Seite 'abgeglichen' wird.

-# Auf diese Weise kann im Beispiel oben auf Kopf und Rest der Liste zugegriffen

-# werden.

-

-# Ein Musterabgleich wird einen Fehler werfen, wenn die beiden Seiten nicht 

-# zusammenpassen. 

-# Im folgenden Beispiel haben die Tupel eine unterschiedliche Anzahl an

-# Elementen:

-{a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}

-

-# Es gibt außerdem 'binaries', 

-<<1,2,3>> # binary.

-

-# Strings und 'char lists'

-"hello" # String

-'hello' # Char-Liste

-

-# ... und mehrzeilige Strings

-"""

-Ich bin ein 

-mehrzeiliger String.

-"""

-#=> "Ich bin ein\nmehrzeiliger String.\n"

-

-# Alles Strings werden in UTF-8 enkodiert:

-"héllò" #=> "héllò"

-

-# Eigentlich sind Strings in Wahrheit nur binaries und 'char lists' einfach

-# Listen.

-<<?a, ?b, ?c>> #=> "abc"

-[?a, ?b, ?c]   #=> 'abc'

-

-# In Elixir gibt `?a` den ASCII-Integer für den Buchstaben zurück.

-?a #=> 97

-

-# Um Listen zu verbinden gibt es den Operator '++', für binaries nutzt man '<>'

-[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]

-'hello ' ++ 'world'  #=> 'hello world'

-

-<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>

-"hello " <> "world"  #=> "hello world"

-

-## ---------------------------

-## -- Operatoren

-## ---------------------------

-

-# Einfache Arithmetik

-1 + 1  #=> 2

-10 - 5 #=> 5

-5 * 2  #=> 10

-10 / 2 #=> 5.0

-

-# In Elixir gibt der Operator '/' immer einen Float-Wert zurück.

-

-# Für Division mit ganzzahligen Ergebnis gibt es 'div'

-div(10, 2) #=> 5

-

-# Um den Rest der ganzzahligen Division zu erhalten gibt es 'rem'

-rem(10, 3) #=> 1

-

-# Natürlich gibt es auch Operatoren für Booleans: 'or', 'and' und 'not'. Diese

-# Operatoren erwarten einen Boolean als erstes Argument. 

-true and true #=> true

-false or true #=> true

-# 1 and true    #=> ** (ArgumentError) argument error

-

-# Elixir bietet auch '||', '&&' und '!', die Argumente jedweden Typs 

-# akzeptieren. Alle Werte außer 'false' und 'nil' werden zu wahr evaluiert.

-1 || true  #=> 1

-false && 1 #=> false

-nil && 20  #=> nil

-

-!true #=> false

-

-# Für Vergleiche gibt es die Operatoren `==`, `!=`, `===`, `!==`, `<=`, `>=`,

-# `<` und `>` 

-1 == 1 #=> true

-1 != 1 #=> false

-1 < 2  #=> true

-

-# '===' und '!==' sind strikter beim Vergleich von Integern und Floats:

-1 == 1.0  #=> true

-1 === 1.0 #=> false

-

-# Es ist außerdem möglich zwei verschiedene Datentypen zu vergleichen:

-1 < :hello #=> true

-

-# Die gesamte Ordnung über die Datentypen ist wie folgt definiert:

-# number < atom < reference < functions < port < pid < tuple < list < bitstring

-

-# Um Joe Armstrong zu zitieren: "The actual order is not important, but that a

-# total ordering is well defined is important." 

-

-## ---------------------------

-## -- Kontrollstrukturen

-## ---------------------------

-

-# Es gibt die `if`-Verzweigung

-if false do

-  "Dies wird nie jemand sehen..."

-else

-  "...aber dies!"

-end

-

-# ...und ebenso `unless`

-unless true do

-  "Dies wird nie jemand sehen..."

-else

-  "...aber dies!"

-end

-

-# Du erinnerst dich an 'pattern matching'? Viele Kontrollstrukturen in Elixir

-# arbeiten damit.

-

-# 'case' erlaubt es uns Werte mit vielerlei Mustern zu vergleichen.

-case {:one, :two} do

-  {:four, :five} ->

-    "Das wird nicht passen"

-  {:one, x} ->

-    "Das schon und außerdem wird es ':two' dem Wert 'x' zuweisen."

-  _ ->

-    "Dieser Fall greift immer."

-end

-

-# Es ist eine übliche Praxis '_' einen Wert zuzuweisen, sofern dieser Wert

-# nicht weiter verwendet wird.

-# Wenn wir uns zum Beispiel nur für den Kopf einer Liste interessieren:

-[kopf | _] = [1,2,3]

-kopf #=> 1

-

-# Für bessere Lesbarkeit können wir auch das Folgende machen:

-[kopf | _rest] = [:a, :b, :c]

-kopf #=> :a

-

-# Mit 'cond' können diverse Bedingungen zur selben Zeit überprüft werden. Man

-# benutzt 'cond' statt viele if-Verzweigungen zu verschachteln.

-cond do

-  1 + 1 == 3 ->

-    "Ich werde nie aufgerufen."

-  2 * 5 == 12 ->

-    "Ich auch nicht."

-  1 + 2 == 3 ->

-    "Aber ich!"

-end

-

-# Es ist üblich eine letzte Bedingung einzufügen, die immer zu wahr evaluiert. 

-cond do

-  1 + 1 == 3 ->

-    "Ich werde nie aufgerufen."

-  2 * 5 == 12 ->

-    "Ich auch nicht."

-  true ->

-    "Aber ich! (dies ist im Grunde ein 'else')"

-end

-

-# 'try/catch' wird verwendet um Werte zu fangen, die zuvor 'geworfen' wurden.

-# Das Konstrukt unterstützt außerdem eine 'after'-Klausel die aufgerufen wird,

-# egal ob zuvor ein Wert gefangen wurde.

-try do

-  throw(:hello)

-catch

-  nachricht -> "#{nachricht} gefangen."

-after

-  IO.puts("Ich bin die 'after'-Klausel.")

-end

-#=> Ich bin die 'after'-Klausel.

-# ":hello gefangen"

-

-## ---------------------------

-## -- Module und Funktionen

-## ---------------------------

-

-# Anonyme Funktionen (man beachte den Punkt)

-square = fn(x) -> x * x end

-square.(5) #=> 25

-

-# Anonyme Funktionen unterstützen auch 'pattern' und 'guards'. Guards erlauben

-# es die Mustererkennung zu justieren und werden mit dem Schlüsselwort 'when'

-# eingeführt:

-f = fn

-  x, y when x > 0 -> x + y

-  x, y -> x * y

-end

-

-f.(1, 3)  #=> 4

-f.(-1, 3) #=> -3

-

-# Elixir bietet zahlreiche eingebaute Funktionen. Diese sind im gleichen

-# Geltungsbereich ('scope') verfügbar.

-is_number(10)    #=> true

-is_list("hello") #=> false

-elem({1,2,3}, 0) #=> 1

-

-# Mehrere Funktionen können in einem Modul gruppiert werden. Innerhalb eines

-# Moduls ist es möglich mit dem Schlüsselwort 'def' eine Funktion zu

-# definieren.

-defmodule Math do

-  def sum(a, b) do

-    a + b

-  end

-

-  def square(x) do

-    x * x

-  end

-end

-

-Math.sum(1, 2)  #=> 3

-Math.square(3) #=> 9

-

-# Um unser einfaches Mathe-Modul zu kompilieren muss es unter 'math.ex'

-# gesichert werden. Anschließend kann es mit 'elixirc' im Terminal aufgerufen

-# werden: elixirc math.ex

-

-# Innerhalb eines Moduls definieren wir private Funktionen mit 'defp'. Eine

-# Funktion, die mit 'def' erstellt wurde, kann von anderen Modulen aufgerufen

-# werden; eine private Funktion kann nur lokal angesprochen werden.

-defmodule PrivateMath do

-  def sum(a, b) do

-    do_sum(a, b)

-  end

-

-  defp do_sum(a, b) do

-    a + b

-  end

-end

-

-PrivateMath.sum(1, 2)    #=> 3

-# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)

-

-# Auch Funktionsdeklarationen unterstützen 'guards' und Mustererkennung:

-defmodule Geometry do

-  def area({:rectangle, w, h}) do

-    w * h

-  end

-

-  def area({:circle, r}) when is_number(r) do

-    3.14 * r * r

-  end

-end

-

-Geometry.area({:rectangle, 2, 3}) #=> 6

-Geometry.area({:circle, 3})       #=> 28.25999999999999801048

-# Geometry.area({:circle, "not_a_number"})

-#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1

-

-# Wegen der Unveränderlichkeit von Variablen ist Rekursion ein wichtiger

-# Bestandteil von Elixir.

-defmodule Recursion do

-  def sum_list([head | tail], acc) do

-    sum_list(tail, acc + head)

-  end

-

-  def sum_list([], acc) do

-    acc

-  end

-end

-

-Recursion.sum_list([1,2,3], 0) #=> 6

-

-# Elixir-Module unterstützen Attribute. Es gibt eingebaute Attribute, ebenso

-# ist es möglich eigene Attribute hinzuzufügen.

-defmodule MyMod do

-  @moduledoc """

-  Dies ist ein eingebautes Attribut in einem Beispiel-Modul

-  """

-

-  @my_data 100 # Dies ist ein selbst-definiertes Attribut.

-  IO.inspect(@my_data) #=> 100

-end

-

-## ---------------------------

-## -- 'Records' und Ausnahmebehandlung

-## ---------------------------

-

-# 'Records' sind im Grunde Strukturen, die es erlauben einem Wert einen eigenen

-# Namen zuzuweisen.

-defrecord Person, name: nil, age: 0, height: 0

-

-joe_info = Person.new(name: "Joe", age: 30, height: 180)

-#=> Person[name: "Joe", age: 30, height: 180]

-

-# Zugriff auf den Wert von 'name'

-joe_info.name #=> "Joe"

-

-# Den Wert von 'age' überschreiben

-joe_info = joe_info.age(31) #=> Person[name: "Joe", age: 31, height: 180]

-

-# Der 'try'-Block wird zusammen mit dem 'rescue'-Schlüsselwort dazu verwendet,

-# um Ausnahmen beziehungsweise Fehler zu behandeln. 

-try do

-  raise "Irgendein Fehler."

-rescue

-  RuntimeError -> "Laufzeit-Fehler gefangen."

-  _error -> "Und dies fängt jeden Fehler."

-end

-

-# Alle Ausnahmen haben das Attribut 'message'

-try do

-  raise "ein Fehler"

-rescue

-  x in [RuntimeError] ->

-    x.message

-end

-

-## ---------------------------

-## -- Nebenläufigkeit

-## ---------------------------

-

-# Elixir beruht auf dem Aktoren-Model zur Behandlung der Nebenläufigkeit. Alles

-# was man braucht um in Elixir nebenläufige Programme zu schreiben sind drei

-# Primitive: Prozesse erzeugen, Nachrichten senden und Nachrichten empfangen. 

-

-# Um einen neuen Prozess zu erzeugen nutzen wir die 'spawn'-Funktion, die

-# wiederum eine Funktion als Argument entgegen nimmt.

-f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>

-spawn(f) #=> #PID<0.40.0>

-

-# 'spawn' gibt eine pid (einen Identifikator des Prozesses) zurück. Diese kann

-# nun verwendet werden, um Nachrichten an den Prozess zu senden. Um 

-# zu senden nutzen wir den '<-' Operator. Damit das alles Sinn macht müssen wir

-# in der Lage sein Nachrichten zu empfangen. Dies wird mit dem 

-# 'receive'-Mechanismus sichergestellt:

-defmodule Geometry do

-  def area_loop do

-    receive do

-      {:rectangle, w, h} ->

-        IO.puts("Area = #{w * h}")

-        area_loop()

-      {:circle, r} ->

-        IO.puts("Area = #{3.14 * r * r}")

-        area_loop()

-    end

-  end

-end

-

-# Kompiliere das Modul, starte einen Prozess und gib die 'area_loop' Funktion

-# in der Shell mit, etwa so:

-pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>

-

-# Sende eine Nachricht an die 'pid', die ein Muster im 'receive'-Ausdruck

-# erfüllt:

-pid <- {:rectangle, 2, 3}

-#=> Area = 6

-#   {:rectangle,2,3}

-

-pid <- {:circle, 2}

-#=> Area = 12.56000000000000049738

-#   {:circle,2}

-

-# Die Shell selbst ist ein Prozess und mit dem Schlüsselwort 'self' kann man

-# die aktuelle pid herausfinden.

-self() #=> #PID<0.27.0>

-

-```

-

-## Referenzen und weitere Lektüre

-

-* [Getting started guide](http://elixir-lang.org/getting_started/1.html) auf der [elixir Website](http://elixir-lang.org)

-* [Elixir Documentation](http://elixir-lang.org/docs/master/)

-* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) von Fred Hebert

-* "Programming Erlang: Software for a Concurrent World" von Joe Armstrong

+---
+language: Elixir
+contributors:
+    - ["Joao Marques", "http://github.com/mrshankly"]
+translators:
+    - ["Gregor Große-Bölting", "http://www.ideen-und-soehne.de"]
+filename: learnelixir-de.ex
+lang: de-de
+---
+
+Elixir ist eine moderne, funktionale Sprache für die Erlang VM. Sie ist voll 
+kompatibel mit Erlang, verfügt aber über eine freundlichere Syntax und bringt 
+viele Features mit. 
+
+```ruby
+
+# Einzeilige Kommentare werden mit der Raute gesetzt.
+
+# Es gibt keine mehrzeiligen Kommentare;
+# es ist aber problemlos möglich mehrere einzeilige Kommentare hintereinander 
+# zu setzen (so wie hier).
+
+# Mit 'iex' ruft man die Elixir-Shell auf.
+# Zum kompilieren von Modulen dient der Befehl 'elixirc'.
+
+# Beide Befehle sollten als Umgebungsvariable gesetzt sein, wenn Elixir korrekt
+# installiert wurde.
+
+## ---------------------------
+## -- Basistypen
+## ---------------------------
+
+# Es gibt Nummern:
+3    # Integer
+0x1F # Integer
+3.0  # Float
+
+# Für bessere Lesbarkeit des Codes können Unterstriche "_" als Trennzeichen verwendet werden
+1_000_000 == 1000000  # Integer
+1_000.567 == 1000.567 # Float
+
+# Atome, das sind Literale, sind Konstanten mit Namen. Sie starten mit einem 
+# ':'.
+:hello # Atom
+
+# Außerdem gibt es Tupel, deren Werte im Arbeitsspeicher vorgehalten werden.
+{1,2,3} # Tupel
+
+# Die Werte innerhalb eines Tupels können mit der 'elem'-Funktion ausgelesen
+# werden:
+elem({1, 2, 3}, 0) # => 1
+
+# Listen sind als verkettete Listen implementiert.
+[1, 2, 3] # list
+
+# Auf Kopf und Rest einer Liste kann wie folgt zugegriffen werden:
+[ kopf | rest ] = [1,2,3]
+kopf # => 1
+rest # => [2, 3]
+
+# In Elixir, wie auch in Erlang, kennzeichnet '=' ein 'pattern matching'
+# (Musterabgleich) und keine Zuweisung.
+# Das heißt, dass die linke Seite auf die rechte Seite 'abgeglichen' wird.
+# Auf diese Weise kann im Beispiel oben auf Kopf und Rest der Liste zugegriffen
+# werden.
+
+# Ein Musterabgleich wird einen Fehler werfen, wenn die beiden Seiten nicht 
+# zusammenpassen. 
+# Im folgenden Beispiel haben die Tupel eine unterschiedliche Anzahl an
+# Elementen:
+{a, b, c} = {1, 2} #=> ** (MatchError) no match of right hand side value: {1,2}
+
+# Es gibt außerdem 'binaries', 
+<<1,2,3>> # binary.
+
+# Strings und 'char lists'
+"hello" # String
+'hello' # Char-Liste
+
+# ... und mehrzeilige Strings
+"""
+Ich bin ein 
+mehrzeiliger String.
+"""
+#=> "Ich bin ein\nmehrzeiliger String.\n"
+
+# Alles Strings werden in UTF-8 enkodiert:
+"héllò" #=> "héllò"
+
+# Eigentlich sind Strings in Wahrheit nur binaries und 'char lists' einfach
+# Listen.
+<<?a, ?b, ?c>> #=> "abc"
+[?a, ?b, ?c]   #=> 'abc'
+
+# In Elixir gibt `?a` den ASCII-Integer für den Buchstaben zurück.
+?a #=> 97
+
+# Um Listen zu verbinden gibt es den Operator '++', für binaries nutzt man '<>'
+[1,2,3] ++ [4,5]     #=> [1,2,3,4,5]
+'hello ' ++ 'world'  #=> 'hello world'
+
+<<1,2,3>> <> <<4,5>> #=> <<1,2,3,4,5>>
+"hello " <> "world"  #=> "hello world"
+
+## ---------------------------
+## -- Operatoren
+## ---------------------------
+
+# Einfache Arithmetik
+1 + 1  #=> 2
+10 - 5 #=> 5
+5 * 2  #=> 10
+10 / 2 #=> 5.0
+
+# In Elixir gibt der Operator '/' immer einen Float-Wert zurück.
+
+# Für Division mit ganzzahligen Ergebnis gibt es 'div'
+div(10, 2) #=> 5
+
+# Um den Rest der ganzzahligen Division zu erhalten gibt es 'rem'
+rem(10, 3) #=> 1
+
+# Natürlich gibt es auch Operatoren für Booleans: 'or', 'and' und 'not'. Diese
+# Operatoren erwarten einen Boolean als erstes Argument. 
+true and true #=> true
+false or true #=> true
+# 1 and true    #=> ** (ArgumentError) argument error
+
+# Elixir bietet auch '||', '&&' und '!', die Argumente jedweden Typs 
+# akzeptieren. Alle Werte außer 'false' und 'nil' werden zu wahr evaluiert.
+1 || true  #=> 1
+false && 1 #=> false
+nil && 20  #=> nil
+
+!true #=> false
+
+# Für Vergleiche gibt es die Operatoren `==`, `!=`, `===`, `!==`, `<=`, `>=`,
+# `<` und `>` 
+1 == 1 #=> true
+1 != 1 #=> false
+1 < 2  #=> true
+
+# '===' und '!==' sind strikter beim Vergleich von Integern und Floats:
+1 == 1.0  #=> true
+1 === 1.0 #=> false
+
+# Es ist außerdem möglich zwei verschiedene Datentypen zu vergleichen:
+1 < :hello #=> true
+
+# Die gesamte Ordnung über die Datentypen ist wie folgt definiert:
+# number < atom < reference < functions < port < pid < tuple < list < bitstring
+
+# Um Joe Armstrong zu zitieren: "The actual order is not important, but that a
+# total ordering is well defined is important." 
+
+## ---------------------------
+## -- Kontrollstrukturen
+## ---------------------------
+
+# Es gibt die `if`-Verzweigung
+if false do
+  "Dies wird nie jemand sehen..."
+else
+  "...aber dies!"
+end
+
+# ...und ebenso `unless`
+unless true do
+  "Dies wird nie jemand sehen..."
+else
+  "...aber dies!"
+end
+
+# Du erinnerst dich an 'pattern matching'? Viele Kontrollstrukturen in Elixir
+# arbeiten damit.
+
+# 'case' erlaubt es uns Werte mit vielerlei Mustern zu vergleichen.
+case {:one, :two} do
+  {:four, :five} ->
+    "Das wird nicht passen"
+  {:one, x} ->
+    "Das schon und außerdem wird es ':two' dem Wert 'x' zuweisen."
+  _ ->
+    "Dieser Fall greift immer."
+end
+
+# Es ist eine übliche Praxis '_' einen Wert zuzuweisen, sofern dieser Wert
+# nicht weiter verwendet wird.
+# Wenn wir uns zum Beispiel nur für den Kopf einer Liste interessieren:
+[kopf | _] = [1,2,3]
+kopf #=> 1
+
+# Für bessere Lesbarkeit können wir auch das Folgende machen:
+[kopf | _rest] = [:a, :b, :c]
+kopf #=> :a
+
+# Mit 'cond' können diverse Bedingungen zur selben Zeit überprüft werden. Man
+# benutzt 'cond' statt viele if-Verzweigungen zu verschachteln.
+cond do
+  1 + 1 == 3 ->
+    "Ich werde nie aufgerufen."
+  2 * 5 == 12 ->
+    "Ich auch nicht."
+  1 + 2 == 3 ->
+    "Aber ich!"
+end
+
+# Es ist üblich eine letzte Bedingung einzufügen, die immer zu wahr evaluiert. 
+cond do
+  1 + 1 == 3 ->
+    "Ich werde nie aufgerufen."
+  2 * 5 == 12 ->
+    "Ich auch nicht."
+  true ->
+    "Aber ich! (dies ist im Grunde ein 'else')"
+end
+
+# 'try/catch' wird verwendet um Werte zu fangen, die zuvor 'geworfen' wurden.
+# Das Konstrukt unterstützt außerdem eine 'after'-Klausel die aufgerufen wird,
+# egal ob zuvor ein Wert gefangen wurde.
+try do
+  throw(:hello)
+catch
+  nachricht -> "#{nachricht} gefangen."
+after
+  IO.puts("Ich bin die 'after'-Klausel.")
+end
+#=> Ich bin die 'after'-Klausel.
+# ":hello gefangen"
+
+## ---------------------------
+## -- Module und Funktionen
+## ---------------------------
+
+# Anonyme Funktionen (man beachte den Punkt)
+square = fn(x) -> x * x end
+square.(5) #=> 25
+
+# Anonyme Funktionen unterstützen auch 'pattern' und 'guards'. Guards erlauben
+# es die Mustererkennung zu justieren und werden mit dem Schlüsselwort 'when'
+# eingeführt:
+f = fn
+  x, y when x > 0 -> x + y
+  x, y -> x * y
+end
+
+f.(1, 3)  #=> 4
+f.(-1, 3) #=> -3
+
+# Elixir bietet zahlreiche eingebaute Funktionen. Diese sind im gleichen
+# Geltungsbereich ('scope') verfügbar.
+is_number(10)    #=> true
+is_list("hello") #=> false
+elem({1,2,3}, 0) #=> 1
+
+# Mehrere Funktionen können in einem Modul gruppiert werden. Innerhalb eines
+# Moduls ist es möglich mit dem Schlüsselwort 'def' eine Funktion zu
+# definieren.
+defmodule Math do
+  def sum(a, b) do
+    a + b
+  end
+
+  def square(x) do
+    x * x
+  end
+end
+
+Math.sum(1, 2)  #=> 3
+Math.square(3) #=> 9
+
+# Um unser einfaches Mathe-Modul zu kompilieren muss es unter 'math.ex'
+# gesichert werden. Anschließend kann es mit 'elixirc' im Terminal aufgerufen
+# werden: elixirc math.ex
+
+# Innerhalb eines Moduls definieren wir private Funktionen mit 'defp'. Eine
+# Funktion, die mit 'def' erstellt wurde, kann von anderen Modulen aufgerufen
+# werden; eine private Funktion kann nur lokal angesprochen werden.
+defmodule PrivateMath do
+  def sum(a, b) do
+    do_sum(a, b)
+  end
+
+  defp do_sum(a, b) do
+    a + b
+  end
+end
+
+PrivateMath.sum(1, 2)    #=> 3
+# PrivateMath.do_sum(1, 2) #=> ** (UndefinedFunctionError)
+
+# Auch Funktionsdeklarationen unterstützen 'guards' und Mustererkennung:
+defmodule Geometry do
+  def area({:rectangle, w, h}) do
+    w * h
+  end
+
+  def area({:circle, r}) when is_number(r) do
+    3.14 * r * r
+  end
+end
+
+Geometry.area({:rectangle, 2, 3}) #=> 6
+Geometry.area({:circle, 3})       #=> 28.25999999999999801048
+# Geometry.area({:circle, "not_a_number"})
+#=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
+
+# Wegen der Unveränderlichkeit von Variablen ist Rekursion ein wichtiger
+# Bestandteil von Elixir.
+defmodule Recursion do
+  def sum_list([head | tail], acc) do
+    sum_list(tail, acc + head)
+  end
+
+  def sum_list([], acc) do
+    acc
+  end
+end
+
+Recursion.sum_list([1,2,3], 0) #=> 6
+
+# Elixir-Module unterstützen Attribute. Es gibt eingebaute Attribute, ebenso
+# ist es möglich eigene Attribute hinzuzufügen.
+defmodule MyMod do
+  @moduledoc """
+  Dies ist ein eingebautes Attribut in einem Beispiel-Modul
+  """
+
+  @my_data 100 # Dies ist ein selbst-definiertes Attribut.
+  IO.inspect(@my_data) #=> 100
+end
+
+## ---------------------------
+## -- 'Records' und Ausnahmebehandlung
+## ---------------------------
+
+# 'Records' sind im Grunde Strukturen, die es erlauben einem Wert einen eigenen
+# Namen zuzuweisen.
+defrecord Person, name: nil, age: 0, height: 0
+
+joe_info = Person.new(name: "Joe", age: 30, height: 180)
+#=> Person[name: "Joe", age: 30, height: 180]
+
+# Zugriff auf den Wert von 'name'
+joe_info.name #=> "Joe"
+
+# Den Wert von 'age' überschreiben
+joe_info = joe_info.age(31) #=> Person[name: "Joe", age: 31, height: 180]
+
+# Der 'try'-Block wird zusammen mit dem 'rescue'-Schlüsselwort dazu verwendet,
+# um Ausnahmen beziehungsweise Fehler zu behandeln. 
+try do
+  raise "Irgendein Fehler."
+rescue
+  RuntimeError -> "Laufzeit-Fehler gefangen."
+  _error -> "Und dies fängt jeden Fehler."
+end
+
+# Alle Ausnahmen haben das Attribut 'message'
+try do
+  raise "ein Fehler"
+rescue
+  x in [RuntimeError] ->
+    x.message
+end
+
+## ---------------------------
+## -- Nebenläufigkeit
+## ---------------------------
+
+# Elixir beruht auf dem Aktoren-Model zur Behandlung der Nebenläufigkeit. Alles
+# was man braucht um in Elixir nebenläufige Programme zu schreiben sind drei
+# Primitive: Prozesse erzeugen, Nachrichten senden und Nachrichten empfangen. 
+
+# Um einen neuen Prozess zu erzeugen nutzen wir die 'spawn'-Funktion, die
+# wiederum eine Funktion als Argument entgegen nimmt.
+f = fn -> 2 * 2 end #=> #Function<erl_eval.20.80484245>
+spawn(f) #=> #PID<0.40.0>
+
+# 'spawn' gibt eine pid (einen Identifikator des Prozesses) zurück. Diese kann
+# nun verwendet werden, um Nachrichten an den Prozess zu senden. Um 
+# zu senden nutzen wir den '<-' Operator. Damit das alles Sinn macht müssen wir
+# in der Lage sein Nachrichten zu empfangen. Dies wird mit dem 
+# 'receive'-Mechanismus sichergestellt:
+defmodule Geometry do
+  def area_loop do
+    receive do
+      {:rectangle, w, h} ->
+        IO.puts("Area = #{w * h}")
+        area_loop()
+      {:circle, r} ->
+        IO.puts("Area = #{3.14 * r * r}")
+        area_loop()
+    end
+  end
+end
+
+# Kompiliere das Modul, starte einen Prozess und gib die 'area_loop' Funktion
+# in der Shell mit, etwa so:
+pid = spawn(fn -> Geometry.area_loop() end) #=> #PID<0.40.0>
+
+# Sende eine Nachricht an die 'pid', die ein Muster im 'receive'-Ausdruck
+# erfüllt:
+pid <- {:rectangle, 2, 3}
+#=> Area = 6
+#   {:rectangle,2,3}
+
+pid <- {:circle, 2}
+#=> Area = 12.56000000000000049738
+#   {:circle,2}
+
+# Die Shell selbst ist ein Prozess und mit dem Schlüsselwort 'self' kann man
+# die aktuelle pid herausfinden.
+self() #=> #PID<0.27.0>
+
+```
+
+## Referenzen und weitere Lektüre
+
+* [Getting started guide](http://elixir-lang.org/getting_started/1.html) auf der [elixir Website](http://elixir-lang.org)
+* [Elixir Documentation](http://elixir-lang.org/docs/master/)
+* ["Learn You Some Erlang for Great Good!"](http://learnyousomeerlang.com/) von Fred Hebert
+* "Programming Erlang: Software for a Concurrent World" von Joe Armstrong
diff --git a/de-de/elm-de.html.markdown b/de-de/elm-de.html.markdown
index 08832327..a6a8cd88 100644
--- a/de-de/elm-de.html.markdown
+++ b/de-de/elm-de.html.markdown
@@ -343,7 +343,7 @@ $ elm reactor
 -- Starte das REPL (read-eval-print-loop).
 $ elm repl
 
--- Bibliotheken werden durch den Github-Nutzernamen und ein Repository identifiziert.
+-- Bibliotheken werden durch den GitHub-Nutzernamen und ein Repository identifiziert.
 -- Installieren einer neuen Bibliothek.
 $ elm package install elm-lang/html
 -- Diese wird der elm-package.json Datei hinzugefügt.
diff --git a/de-de/git-de.html.markdown b/de-de/git-de.html.markdown
index 0896f513..3065a033 100644
--- a/de-de/git-de.html.markdown
+++ b/de-de/git-de.html.markdown
@@ -385,6 +385,4 @@ $ 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/)
diff --git a/de-de/go-de.html.markdown b/de-de/go-de.html.markdown
index 9409e181..1b09a1e1 100644
--- a/de-de/go-de.html.markdown
+++ b/de-de/go-de.html.markdown
@@ -82,7 +82,7 @@ Zeilenumbrüche beinhalten.` // Selber Zeichenketten-Typ
     // nicht-ASCII Literal.  Go Quelltext ist UTF-8 kompatibel.
     g := 'Σ' // Ein Runen-Typ, alias int32, gebraucht für unicode code points.
 
-    f := 3.14195 // float64, eine IEEE-754 64-bit Dezimalzahl
+    f := 3.14159 // float64, eine IEEE-754 64-bit Dezimalzahl
     c := 3 + 4i  // complex128, besteht intern aus zwei float64-er
 
     // "var"-Syntax mit Initalwert
@@ -308,13 +308,13 @@ func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 ```
 
 ## Weitere Resourcen
-Informationen zu Go findet man auf der [offiziellen Go Webseite](http://golang.org/).
+Informationen zu Go findet man auf der [offiziellen Go Webseite](https://go.dev/).
 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 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/)
+ist außerdem der Quelltext der [Go standard Bibliothek](https://go.dev/src/)
 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/).
+in der [offiziellen Dokumentation von Go](https://go.dev/pkg/).
diff --git a/de-de/javascript-de.html.markdown b/de-de/javascript-de.html.markdown
index f817ee9f..a71d4316 100644
--- a/de-de/javascript-de.html.markdown
+++ b/de-de/javascript-de.html.markdown
@@ -1,525 +1,525 @@
----

-language: javascript

-contributors:

-    - ["Leigh Brenecki", "https://leigh.net.au"]

-translators:

-    - ["ggb", "http://www.ideen-und-soehne.de"]

-filename: learnjavascript-de.js

-lang: de-de

----

-

-(Anmerkungen des Original-Autors:)

-JavaScript wurde im Jahr 1995 von Brendan Eich bei Netscape entwickelt. Ursprünglich war es als einfachere Skriptsprache für Websites gedacht, ergänzend zu Java, das für komplexere Webanwendungen verwendet wird. Die enge Integration in Websites und der in Browser eingebaute Support der Sprache haben dafür gesorgt, dass JavaScript weit häufiger für Web-Frontends verwendet wird als Java.

-

-Dabei ist JavaScript inzwischen nicht mehr auf Browser beschränkt: Node.js, ein Projekt, das eine eigene Laufzeitumgebung auf Grundlage von Google Chromes V8 mitbringt, wird derzeit immer populärer.

-

-Feedback ist herzlich Willkommen! Der ursprüngliche Autor ist unter [@excitedleigh](https://twitter.com/excitedleigh) oder [l@leigh.net.au](mailto:l@leigh.net.au) zu erreichen. Der Übersetzer unter [gregorbg@web.de](mailto:gregorbg@web.de).

-

-```js

-// Kommentare werden wie in C gesetzt: Einzeilige Kommentare starten mit zwei 

-// Slashes

-/* während mehrzeilige Kommentare mit einem 

-Slash und einem Stern anfangen und enden */

-

-// Statements können mit einem Semikolon beendet werden

-machWas();

-

-// ...müssen sie aber nicht, weil Semikola automatisch eingefügt werden, wenn 

-// eine neue Zeile beginnt, abgesehen von einigen Ausnahmen.

-machWas()

-

-// Obwohl wir uns für den Anfang nicht um diese Ausnahmen kümmern müssen ist 

-// es besser die Semikola immer zu setzen.

-

-///////////////////////////////////

-// 1. Nummern, Strings und Operationen

-

-// JavaScript hat einen Nummern-Typ (64-bit IEEE 754 double).

-3; // = 3

-1.5; // = 1.5

-

-// Beinahe alle grundlegenden arithmetischen Operationen arbeiten wie erwartet.

-1 + 1; // = 2

-0.1 + 0.2; // = 0.30000000000000004

-10 * 2; // = 20

-35 / 5; // = 7

-

-// Division funktioniert auch mit einem Ergebnis nach dem Komma.

-5 / 2; // = 2.5

-

-// Bit-weise Operationen sind auch möglich; wenn eine Bit-weise Operation 

-// ausgeführt wird, wird die Fließkomma-Zahl in einen 32-bit Integer (mit 

-// Vorzeichen) umgewandelt.

-1 << 2; // = 4

-

-// Die Rangfolge der Operationen kann mit Klammern erzwungen werden.

-(1 + 3) * 2; // = 8

-

-// Es gibt drei spezielle, nicht-reale Nummern-Werte:

-Infinity; // Ergebnis von z. B. 1 / 0

--Infinity; // Ergebnis von z. B. -1 / 0

-NaN; // Ergebnis von z. B. 0 / 0

-

-// Es gibt auch einen Boolean-Typ (für Wahrheitswerte).

-true;

-false;

-

-// Strings werden mit ' oder " erzeugt.

-'abc';

-"Hello, world";

-

-// Für die Negation wird das ! benutzt.

-!true; // = false

-!false; // = true

-

-// Gleichheit wird mit === geprüft.

-1 === 1; // = true

-2 === 1; // = false

-

-// Ungleichheit wird mit !== überprüft.

-1 !== 1; // = false

-2 !== 1; // = true

-

-// Andere Vergleichsoperatoren sind

-1 < 10; // = true

-1 > 10; // = false

-2 <= 2; // = true

-2 >= 2; // = true

-

-// Strings können mit + verbunden 

-"Hello " + "world!"; // = "Hello world!"

-

-// und mit < und > verglichen werden.

-"a" < "b"; // = true

-

-// Für den Vergleich von Werten mit "==" wird eine Typumwandlung erzwungen...

-"5" == 5; // = true

-

-// ...solange man nicht === verwendet.

-"5" === 5; // = false

-

-// Auf einzelne Buchstaben innerhalb eines Strings kann mit der Methode 

-// 'charAt' zugegriffen werden

-"This is a string".charAt(0);  // = "T"

-

-// Die Methode 'substring' gibt Teilbereiche eines Strings zurück

-"Hello world".substring(0, 5); // = "Hello"

-

-// 'length' ist eine Eigenschaft und wird folglich ohne '()' benutzt

-"Hello".length; // = 5

-

-// Es gibt außerdem die Werte 'null' und 'undefined'

-null; // wird verwendet um einen vorsätzlich gewählten 'Nicht'-Wert anzuzeigen

-undefined; // wird verwendet um anzuzeigen, dass der Wert (aktuell) nicht 

-           // verfügbar ist (obwohl genau genommen undefined selbst einen Wert 

-           // darstellt)

-

-// false, null, undefined, NaN, 0 und "" sind 'falsy', d. h. alles andere ist 

-// wahr. Man beachte, dass 0 falsch und "0" wahr ist, obwohl 0 == "0".

-

-///////////////////////////////////

-// 2. Variablen, Arrays und Objekte

-

-// Variablen werden mit dem Schlüsselwort 'var' und einem frei wählbaren 

-// Bezeichner deklariert. JavaScript ist dynamisch typisiert, so dass man einer

-// Variable keinen Typ zuweisen muss. Die Zuweisung verwendet ein einfaches =.

-var einWert = 5;

-

- // Wenn man das Schlüsselwort 'var' weglässt, bekommt man keinen Fehler

-einAndererWert = 10;

-

-// ...aber die Variable wird im globalen Kontext erzeugt, nicht in dem Kontext,

-// in dem sie erzeugt wurde.

-

-// Variablen die erzeugt wurden ohne ihnen einen Wert zuzuweisen, erhalten den

-// Wert 'undefined'.

-var einDritterWert; // = undefined

-

-// Es existiert eine Kurzform, um mathematische Operationen mit Variablen 

-// auszuführen:

-einWert += 5; // äquivalent zu einWert = einWert + 5; einWert ist nun also 10

-einWert *= 10; // einWert ist nach dieser Operation 100

-

-// Und es existiert eine weitere, sogar noch kürzere Form, um 1 zu addieren 

-// oder zu subtrahieren

-einWert++; // nun ist einWert 101

-einWert--; // wieder 100

-

-// Arrays sind geordnete Listen von Werten irgendeines Typs

-var myArray = ["Hello", 45, true];

-

-// Auf einzelne Elemente eines Arrays kann zugegriffen werden, in dem der Index

-// in eckigen Klammern hinter das Array geschrieben werden. Die Indexierung 

-// beginnt bei 0.

-myArray[1]; // = 45

-

-// Arrays haben keine feste Länge

-myArray.push("World");

-myArray.length; // = 4

-

-// und sind veränderlich

-myArray[3] = "Hello";

-

-// Die Objekte in JavaScript entsprechen 'dictionaries' oder 'maps' in anderen 

-// Sprachen: es handelt sich um ungeordnete Schlüssel-Wert-Paare.

-var myObj = { key1: "Hello", key2: "World" };

-

-// Schlüssel sind Strings, aber es werden keine Anführungszeichen benötigt, 

-// sofern es sich um reguläre JavaScript-Bezeichner handelt. Werte können von

-// jedem Typ sein.

-var myObj = { myKey: "myValue", "my other key": 4 };

-

-// Auf Attribute von Objekten kann ebenfalls mit eckigen Klammern zugegriffen

-// werden,

-myObj["my other key"]; // = 4

-

-// ... oder in dem man die Punkt-Notation verwendet, vorausgesetzt es handelt 

-// sich bei dem Schlüssel um einen validen Bezeichner.

-myObj.myKey; // = "myValue"

-

-// Objekte sind veränderlich, Werte können verändert und neue Schlüssel 

-// hinzugefügt werden.

-myObj.myThirdKey = true;

-

-// Der Zugriff auf einen noch nicht definierten Schlüssel, liefert ein 

-// undefined.

-myObj.myFourthKey; // = undefined

-

-///////////////////////////////////

-// 3. Logik und Kontrollstrukturen

-

-// Die if-Struktur arbeitet, wie man es erwartet.

-var count = 1;

-if (count == 3){

-    // wird evaluiert, wenn count gleich 3 ist

-} else if (count == 4) {

-    // wird evaluiert, wenn count gleich 4 ist

-} else {

-    // wird evaluiert, wenn es weder 3 noch 4 ist

-}

-

-// Genauso 'while'.

-while (true) {

-    // Eine unendliche Schleife!

-}

-

-// Do-while-Scheifen arbeiten wie while-Schleifen, abgesehen davon, dass sie 

-// immer mindestens einmal ausgeführt werden.

-var input;

-do {

-    input = getInput();

-} while ( !isValid( input ) )

-

-// Die for-Schleife arbeitet genau wie in C und Java:

-// Initialisierung; Bedingung, unter der die Ausführung fortgesetzt wird; 

-// Iteration.

-for ( var i = 0; i < 5; i++ ) {

-    // wird 5-mal ausgeführt

-}

-

-// '&&' ist das logische und, '||' ist das logische oder

-if (house.size == "big" && house.colour == "blue"){

-    house.contains = "bear";

-    // Die Größe des Hauses ist groß und die Farbe blau.

-}

-if (colour == "red" || colour == "blue"){

-    // Die Farbe ist entweder rot oder blau.

-}

-

-// Die Auswertung von '&&' und '||' erfolgt so, dass abgebrochen wird, wenn die

-// Bedingung erfüllt ist (bei oder) oder nicht-erfüllt ist (bei und). Das ist 

-// nützlich, um einen Default-Wert zu setzen.

-var name = otherName || "default";

-

-// Ein 'switch' Statement prüft Gleichheit mit ===

-// ohne ein 'break' nach jedem Fall

-// werden auch die Fälle nach dem korrekten aufgerufen

-grade = 'B';

-switch (grade) {

-  case 'A':

-    console.log("Great job");

-    break;

-  case 'B':

-    console.log("OK job");

-    break;

-  case 'C':

-    console.log("You can do better");

-    break;

-  default:

-    console.log("Oy vey");

-    break;

-}

-

-///////////////////////////////////

-// 4. Funktionen, Geltungsbereich und Closures

-

-// In JavaScript werden Funktionen mit dem Schlüsselwort 'function' deklariert.

-function myFunction(thing){

-    return thing.toUpperCase();

-}

-myFunction("foo"); // = "FOO"

-

-// Vorsicht: der Ausdruck der den Rückgabewert einer Funktion bildet muss

-// auf der selben Zeile beginnen auf der auch das 'return' Keyword steht

-// Sonst wird hier ein automatisches Semikolon eingefügt und die Funktion

-// gibt 'undefined' zurück

-function myFunction()

-{

-    return // <- Hier wird automatisch ein Semikolon eingefügt

-    {

-        thisIsAn: 'object literal'

-    }

-}

-myFunction(); // = undefined

-

-// In JavaScript sind Funktionen 'Bürger erster Klasse', also können sie wie 

-// Variablen verwendet und als Parameter anderen Funktionen übergeben werden 

-// - zum Beispiel, um einen 'event handler' zu 'beliefern'.

-function myFunction() {

-    // wird ausgeführt, nachdem 5 Sekunden vergangen sind

-}

-setTimeout(myFunction, 5000);

-

-// Funktionen können auch deklariert werden, ohne ihnen einen Namen zuzuweisen.

-// Es ist möglich diese anonymen Funktionen direkt als (oder im) Argument 

-// einer anderen Funktion zu definieren.

-setTimeout(function(){

-    // wird ausgeführt, nachdem 5 Sekunden vergangen sind

-}, 5000);

-

-// JavaScript hat einen Geltungsbereich, der sich auf Funktionen erstreckt: 

-// Funktionen haben ihren eigenen Geltungsbereich, andere Blöcke nicht.

-if(true) {

-    var i = 5;

-}

-i; // = 5 - nicht undefined, wie man es von einer Sprache erwarten würde, die 

-   // ihren Geltungsbereich nach Blöcken richtet

-

-// Daraus ergibt sich ein bestimmtes Muster für sofort-ausführbare, anonyme 

-// Funktionen, die es vermeiden, dass der globale Geltungsbereich von Variablen

-// 'verschmutzt' wird.

-(function(){

-    var temporary = 5;

-    // Auf eine Variable im globalen Geltungsbereich kann zugegriffen werden, 

-    // sofern sie im globalen Objekt definiert ist (in einem Webbrowser ist 

-    // dies immer das 'window'-Objekt, in anderen Umgebungen, bspw. Node.js, 

-    // kann das anders aussehen). 

-    window.permanent = 10;

-})();

-temporary; // wirft einen ReferenceError

-permanent; // = 10

-

-// Eines der mächtigsten Charakteristika von JavaScript sind Closures. Wird 

-// eine Funktion innerhalb einer anderen Funktion definiert, dann hat die 

-// innere Funktion Zugriff auf alle Variablen der äußeren Funktion, sogar dann,

-// wenn die äußere Funktion beendet wurde.

-function sayHelloInFiveSeconds(name){

-    var prompt = "Hello, " + name + "!";

-    function inner(){

-        alert(prompt);

-    }

-    setTimeout(inner, 5000);

-    // setTimeout wird asynchron ausgeführt. Also wird sayHelloInFiveSeconds 

-    // sofort verlassen und setTimeout wird die innere Funktion 'im nachhinein' 

-    // aufrufen. Dennoch: Weil sayHelloInFiveSeconds eine Hülle um die innere 

-    // Funktion bildet, hat die innere Funktion immer noch Zugriff auf die 

-    // Variable prompt.

-}

-sayHelloInFiveSeconds("Adam");  // wird nach 5 Sekunden ein Popup mit der 

-                                // Nachricht "Hello, Adam!" öffnen.

-

-///////////////////////////////////

-// 5. Mehr über Objekte, Konstruktoren und Prototypen

-

-// Objekte können Funktionen enthalten.

-var myObj = {

-    myFunc: function(){

-        return "Hello world!";

-    }

-};

-myObj.myFunc(); // = "Hello world!"

-

-// Wenn Funktionen aufgerufen werden, die zu einem Objekt gehören, können sie 

-// auf das eigene Objekt mit dem Schlüsselwort 'this' zugreifen.

-myObj = {

-    myString: "Hello world!",

-    myFunc: function(){

-        return this.myString;

-    }

-};

-myObj.myFunc(); // = "Hello world!"

-

-// Worauf 'this' gesetzt wird, ist davon abhängig, wie die Funktion aufgerufen 

-// wird, nicht wo sie definiert wurde. Unsere Funktion wird daher nicht 

-// funktionieren, sofern sie außerhalb des Kontextes des Objekts aufgerufen 

-// wird.

-var myFunc = myObj.myFunc;

-myFunc(); // = undefined

-

-// Umgekehrt ist es möglich eine Funktion einem Objekt zuzuweisen und dadurch 

-// Zugriff auf den this-Kontext zu erhalten, sogar dann, wenn die Funktion dem

-// Objekt nach dessen Definition zugewiesen wird.

-var myOtherFunc = function(){

-    return this.myString.toUpperCase();

-}

-myObj.myOtherFunc = myOtherFunc;

-myObj.myOtherFunc(); // = "HELLO WORLD!"

-

-// Mit den Methoden 'call' und 'apply' kann der Kontext eines Funktionsaufrufs

-// verändert werden

-

-var anotherFunc = function(s){

-    return this.myString + s;

-}

-anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"

-

-// 'apply' funktioniert beiahe identisch, erwartet die übergebenen Argumente

-// aber in einem Array

-

-anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"

-

-// Das ist hilfreich wenn man einer Funktion eine beliebige Zahl Argumente

-// übergeben kann

-

-Math.min(42, 6, 27); // = 6

-Math.min([42, 6, 27]); // = NaN (uh-oh!)

-Math.min.apply(Math, [42, 6, 27]); // = 6

-

-// 'call' und 'apply' beeinflussen aber nur den spezifischen Aufruf.

-// Um den Kontext einer Funktion dauerhaft zu ändern wird 'bind' benutzt.

-

-var boundFunc = anotherFunc.bind(myObj);

-boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"

-

-// Mit 'bind' lassen sich Funktionen auch teilweise anwenden / "curryen".

-var product = function(a, b){ return a * b; }

-var doubler = product.bind(this, 2);

-doubler(8); // = 16

-

-// Wenn eine Funktion mit dem Schlüsselwort 'new' aufgerufen wird, dann wird 

-// ein neues Objekt erzeugt. Funktionen, die darauf ausgelegt sind in dieser 

-// Art aufgerufen zu werden, werden Konstruktoren genannt.

-var MyConstructor = function(){

-    this.myNumber = 5;

-}

-myNewObj = new MyConstructor(); // = {myNumber: 5}

-myNewObj.myNumber; // = 5

-

-// Jedes JavaScript-Objekt hat einen Prototyp. Wenn man versucht auf eine 

-// Eigenschaft des Objekts zuzugreifen, das nicht im Objekt selbst existiert,

-// schaut der Interpreter in dessen Prototyp nach.

-

-// Einige JavaScript-Implementierungen erlauben den direkten Zugriff auf den 

-// Prototyp eines Objekts durch die magische Eigenschaft __proto__. Obwohl das

-// nützlich ist, um  Prototypen im Allgemeinen zu erklären, ist das nicht Teil

-// des Standards; zum Standard-Weg der Nutzung von Prototypen kommen wir 

-// später.

-var myObj = {

-    myString: "Hello world!",

-};

-var myPrototype = {

-    meaningOfLife: 42,

-    myFunc: function(){

-        return this.myString.toLowerCase()

-    }

-};

-myObj.__proto__ = myPrototype;

-myObj.meaningOfLife; // = 42

-

-// Das funktioniert auch bei Funktionen.

-myObj.myFunc(); // = "hello world!"

-

-// Sollte die Eigenschaft nicht im Prototypen des Objekts enthalten sein, dann

-// wird im Prototypen des Prototypen nachgesehen und so weiter.

-myPrototype.__proto__ = {

-    myBoolean: true

-};

-myObj.myBoolean; // = true

-

-// Dafür wird nichts hin und her kopiert; jedes Objekt speichert eine Referenz

-// auf seinen Prototypen. Das heißt wenn der Prototyp geändert wird, dann 

-// werden die Änderungen überall sichtbar.

-myPrototype.meaningOfLife = 43;

-myObj.meaningOfLife; // = 43

-

-// Es wurde bereits erwähnt, dass __proto__ nicht zum Standard gehört und es 

-// gibt ebenso keinen Standard-Weg, um den Prototyp eines existierenden Objekts

-// zu ändern. Es gibt dennoch zwei Wege, wie man ein neues Objekt mit einem 

-// gegebenen Prototypen erzeugt.

-

-// Der erste Weg ist die Methode Object.create, die eine jüngere Ergänzung des

-// JavaScript-Standards ist und daher noch nicht in allen Implementierungen 

-// verfügbar.

-var myObj = Object.create(myPrototype);

-myObj.meaningOfLife; // = 43

-

-// Der zweite Weg, der immer funktioniert, hat mit den Konstruktoren zu tun. 

-// Konstruktoren haben eine Eigenschaft, die Prototyp heißt.  Dabei handelt es

-// sich *nicht* um den Prototypen der Konstruktor-Funktion; stattdessen handelt

-// es sich um den Prototypen, der einem neuen Objekt mitgegeben wird, wenn es 

-// mit dem Konstruktor und dem Schlüsselwort 'new' erzeugt wird.

-MyConstructor.prototype = {

-    getMyNumber: function(){

-        return this.myNumber

-    }

-};

-var myNewObj2 = new MyConstructor();

-myNewObj2.getMyNumber(); // = 5

-

-// Alle primitiven Typen, also strings und numbers, haben auch Konstruktoren, 

-// die zu dem Typ äquivalente Wrapper-Objekte erzeugen. 

-var myNumber = 12;

-var myNumberObj = new Number(12);

-myNumber == myNumberObj; // = true

-

-// Genau genommen: Sie sind nicht exakt äquivalent.

-typeof myNumber; // = 'number'

-typeof myNumberObj; // = 'object'

-myNumber === myNumberObj; // = false

-if (0){

-    // Dieser Teil wird nicht ausgeführt, weil 0 'falsy' ist.

-}

-

-// Das Wrapper-Objekt und die regulären, eingebauten Typen, teilen sich einen 

-// Prototyp; so ist es möglich zum Beispiel einem String weitere Funktionen 

-// hinzuzufügen.

-String.prototype.firstCharacter = function(){

-    return this.charAt(0);

-}

-"abc".firstCharacter(); // = "a"

-

-// Diese Tatsache wird häufig bei einer Methode mit dem Namen 'polyfilling'

-// verwendet: Dabei wird ein neues Feature von JavaScript in einer älteren 

-// Untermenge der Sprache integriert, so dass bestimmte Funktionen auch in 

-// älteren Umgebungen und Browsern verwendet werden können.

-

-// Ein Beispiel: Es wurde erwähnt, dass die Methode Object.create nicht in 

-// allen Umgebungen verfügbar ist - wir können sie dennoch verwenden, mit einem

-// 'polyfill':

-if (Object.create === undefined){ // überschreib nichts, was eventuell bereits

-                                  // existiert

-    Object.create = function(proto){

-        // erstelle einen vorübergehenden Konstruktor mit dem richtigen

-        // Prototypen

-        var Constructor = function(){};

-        Constructor.prototype = proto;

-        // verwende es dann, um ein neues Objekt mit einem passenden 

-        // Prototypen zurückzugeben

-        return new Constructor();

-    }

-}

-```

-

-## Zur weiteren Lektüre (englisch)

-

-Das [Mozilla Developer Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) bietet eine ausgezeichnete Dokumentation für die Verwendung von JavaScript im Browser. Es ist außerdem ein Wiki und ermöglicht es damit anderen zu helfen, wenn man selbst ein wenig Wissen angesammelt hat.

-

-MDN's [A re-introduction to JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) führt sehr viele der hier vorgestellten Konzepte im Detail aus. 

-

-Dieses Tutorial hat nur die Sprache JavaScript vorgestellt; um mehr über den  Einsatz in Websites zu lernen, ist es ein guter Start etwas über das [Document Object Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core) zu lernen.

-

-[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) ist eine tiefgehende Einführung in die kontra-intuitiven Parts der Sprache.

-

-[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) ist ein Klassiker unter den Referenzen.

-

-Zusätzlich zu direkten Beiträgen zu diesem Artikel ist der Inhalt in Anlehnung an Louie Dinh's Python-Tutorial auf dieser Seite und das [JS Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) des Mozilla Developer Network entstanden.

+---
+language: javascript
+contributors:
+    - ["Leigh Brenecki", "https://leigh.net.au"]
+translators:
+    - ["ggb", "http://www.ideen-und-soehne.de"]
+filename: learnjavascript-de.js
+lang: de-de
+---
+
+(Anmerkungen des Original-Autors:)
+JavaScript wurde im Jahr 1995 von Brendan Eich bei Netscape entwickelt. Ursprünglich war es als einfachere Skriptsprache für Websites gedacht, ergänzend zu Java, das für komplexere Webanwendungen verwendet wird. Die enge Integration in Websites und der in Browser eingebaute Support der Sprache haben dafür gesorgt, dass JavaScript weit häufiger für Web-Frontends verwendet wird als Java.
+
+Dabei ist JavaScript inzwischen nicht mehr auf Browser beschränkt: Node.js, ein Projekt, das eine eigene Laufzeitumgebung auf Grundlage von Google Chromes V8 mitbringt, wird derzeit immer populärer.
+
+Feedback ist herzlich Willkommen! Der ursprüngliche Autor ist unter [@excitedleigh](https://twitter.com/excitedleigh) oder [l@leigh.net.au](mailto:l@leigh.net.au) zu erreichen. Der Übersetzer unter [gregorbg@web.de](mailto:gregorbg@web.de).
+
+```js
+// Kommentare werden wie in C gesetzt: Einzeilige Kommentare starten mit zwei 
+// Slashes
+/* während mehrzeilige Kommentare mit einem 
+Slash und einem Stern anfangen und enden */
+
+// Statements können mit einem Semikolon beendet werden
+machWas();
+
+// ...müssen sie aber nicht, weil Semikola automatisch eingefügt werden, wenn 
+// eine neue Zeile beginnt, abgesehen von einigen Ausnahmen.
+machWas()
+
+// Obwohl wir uns für den Anfang nicht um diese Ausnahmen kümmern müssen ist 
+// es besser die Semikola immer zu setzen.
+
+///////////////////////////////////
+// 1. Nummern, Strings und Operationen
+
+// JavaScript hat einen Nummern-Typ (64-bit IEEE 754 double).
+3; // = 3
+1.5; // = 1.5
+
+// Beinahe alle grundlegenden arithmetischen Operationen arbeiten wie erwartet.
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Division funktioniert auch mit einem Ergebnis nach dem Komma.
+5 / 2; // = 2.5
+
+// Bit-weise Operationen sind auch möglich; wenn eine Bit-weise Operation 
+// ausgeführt wird, wird die Fließkomma-Zahl in einen 32-bit Integer (mit 
+// Vorzeichen) umgewandelt.
+1 << 2; // = 4
+
+// Die Rangfolge der Operationen kann mit Klammern erzwungen werden.
+(1 + 3) * 2; // = 8
+
+// Es gibt drei spezielle, nicht-reale Nummern-Werte:
+Infinity; // Ergebnis von z. B. 1 / 0
+-Infinity; // Ergebnis von z. B. -1 / 0
+NaN; // Ergebnis von z. B. 0 / 0
+
+// Es gibt auch einen Boolean-Typ (für Wahrheitswerte).
+true;
+false;
+
+// Strings werden mit ' oder " erzeugt.
+'abc';
+"Hello, world";
+
+// Für die Negation wird das ! benutzt.
+!true; // = false
+!false; // = true
+
+// Gleichheit wird mit === geprüft.
+1 === 1; // = true
+2 === 1; // = false
+
+// Ungleichheit wird mit !== überprüft.
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Andere Vergleichsoperatoren sind
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Strings können mit + verbunden 
+"Hello " + "world!"; // = "Hello world!"
+
+// und mit < und > verglichen werden.
+"a" < "b"; // = true
+
+// Für den Vergleich von Werten mit "==" wird eine Typumwandlung erzwungen...
+"5" == 5; // = true
+
+// ...solange man nicht === verwendet.
+"5" === 5; // = false
+
+// Auf einzelne Buchstaben innerhalb eines Strings kann mit der Methode 
+// 'charAt' zugegriffen werden
+"This is a string".charAt(0);  // = "T"
+
+// Die Methode 'substring' gibt Teilbereiche eines Strings zurück
+"Hello world".substring(0, 5); // = "Hello"
+
+// 'length' ist eine Eigenschaft und wird folglich ohne '()' benutzt
+"Hello".length; // = 5
+
+// Es gibt außerdem die Werte 'null' und 'undefined'
+null; // wird verwendet um einen vorsätzlich gewählten 'Nicht'-Wert anzuzeigen
+undefined; // wird verwendet um anzuzeigen, dass der Wert (aktuell) nicht 
+           // verfügbar ist (obwohl genau genommen undefined selbst einen Wert 
+           // darstellt)
+
+// false, null, undefined, NaN, 0 und "" sind 'falsy', d. h. alles andere ist 
+// wahr. Man beachte, dass 0 falsch und "0" wahr ist, obwohl 0 == "0".
+
+///////////////////////////////////
+// 2. Variablen, Arrays und Objekte
+
+// Variablen werden mit dem Schlüsselwort 'var' und einem frei wählbaren 
+// Bezeichner deklariert. JavaScript ist dynamisch typisiert, so dass man einer
+// Variable keinen Typ zuweisen muss. Die Zuweisung verwendet ein einfaches =.
+var einWert = 5;
+
+ // Wenn man das Schlüsselwort 'var' weglässt, bekommt man keinen Fehler
+einAndererWert = 10;
+
+// ...aber die Variable wird im globalen Kontext erzeugt, nicht in dem Kontext,
+// in dem sie erzeugt wurde.
+
+// Variablen die erzeugt wurden ohne ihnen einen Wert zuzuweisen, erhalten den
+// Wert 'undefined'.
+var einDritterWert; // = undefined
+
+// Es existiert eine Kurzform, um mathematische Operationen mit Variablen 
+// auszuführen:
+einWert += 5; // äquivalent zu einWert = einWert + 5; einWert ist nun also 10
+einWert *= 10; // einWert ist nach dieser Operation 100
+
+// Und es existiert eine weitere, sogar noch kürzere Form, um 1 zu addieren 
+// oder zu subtrahieren
+einWert++; // nun ist einWert 101
+einWert--; // wieder 100
+
+// Arrays sind geordnete Listen von Werten irgendeines Typs
+var myArray = ["Hello", 45, true];
+
+// Auf einzelne Elemente eines Arrays kann zugegriffen werden, in dem der Index
+// in eckigen Klammern hinter das Array geschrieben werden. Die Indexierung 
+// beginnt bei 0.
+myArray[1]; // = 45
+
+// Arrays haben keine feste Länge
+myArray.push("World");
+myArray.length; // = 4
+
+// und sind veränderlich
+myArray[3] = "Hello";
+
+// Die Objekte in JavaScript entsprechen 'dictionaries' oder 'maps' in anderen 
+// Sprachen: es handelt sich um ungeordnete Schlüssel-Wert-Paare.
+var myObj = { key1: "Hello", key2: "World" };
+
+// Schlüssel sind Strings, aber es werden keine Anführungszeichen benötigt, 
+// sofern es sich um reguläre JavaScript-Bezeichner handelt. Werte können von
+// jedem Typ sein.
+var myObj = { myKey: "myValue", "my other key": 4 };
+
+// Auf Attribute von Objekten kann ebenfalls mit eckigen Klammern zugegriffen
+// werden,
+myObj["my other key"]; // = 4
+
+// ... oder in dem man die Punkt-Notation verwendet, vorausgesetzt es handelt 
+// sich bei dem Schlüssel um einen validen Bezeichner.
+myObj.myKey; // = "myValue"
+
+// Objekte sind veränderlich, Werte können verändert und neue Schlüssel 
+// hinzugefügt werden.
+myObj.myThirdKey = true;
+
+// Der Zugriff auf einen noch nicht definierten Schlüssel, liefert ein 
+// undefined.
+myObj.myFourthKey; // = undefined
+
+///////////////////////////////////
+// 3. Logik und Kontrollstrukturen
+
+// Die if-Struktur arbeitet, wie man es erwartet.
+var count = 1;
+if (count == 3){
+    // wird evaluiert, wenn count gleich 3 ist
+} else if (count == 4) {
+    // wird evaluiert, wenn count gleich 4 ist
+} else {
+    // wird evaluiert, wenn es weder 3 noch 4 ist
+}
+
+// Genauso 'while'.
+while (true) {
+    // Eine unendliche Schleife!
+}
+
+// Do-while-Scheifen arbeiten wie while-Schleifen, abgesehen davon, dass sie 
+// immer mindestens einmal ausgeführt werden.
+var input;
+do {
+    input = getInput();
+} while ( !isValid( input ) )
+
+// Die for-Schleife arbeitet genau wie in C und Java:
+// Initialisierung; Bedingung, unter der die Ausführung fortgesetzt wird; 
+// Iteration.
+for ( var i = 0; i < 5; i++ ) {
+    // wird 5-mal ausgeführt
+}
+
+// '&&' ist das logische und, '||' ist das logische oder
+if (house.size == "big" && house.colour == "blue"){
+    house.contains = "bear";
+    // Die Größe des Hauses ist groß und die Farbe blau.
+}
+if (colour == "red" || colour == "blue"){
+    // Die Farbe ist entweder rot oder blau.
+}
+
+// Die Auswertung von '&&' und '||' erfolgt so, dass abgebrochen wird, wenn die
+// Bedingung erfüllt ist (bei oder) oder nicht-erfüllt ist (bei und). Das ist 
+// nützlich, um einen Default-Wert zu setzen.
+var name = otherName || "default";
+
+// Ein 'switch' Statement prüft Gleichheit mit ===
+// ohne ein 'break' nach jedem Fall
+// werden auch die Fälle nach dem korrekten aufgerufen
+grade = 'B';
+switch (grade) {
+  case 'A':
+    console.log("Great job");
+    break;
+  case 'B':
+    console.log("OK job");
+    break;
+  case 'C':
+    console.log("You can do better");
+    break;
+  default:
+    console.log("Oy vey");
+    break;
+}
+
+///////////////////////////////////
+// 4. Funktionen, Geltungsbereich und Closures
+
+// In JavaScript werden Funktionen mit dem Schlüsselwort 'function' deklariert.
+function myFunction(thing){
+    return thing.toUpperCase();
+}
+myFunction("foo"); // = "FOO"
+
+// Vorsicht: der Ausdruck der den Rückgabewert einer Funktion bildet muss
+// auf der selben Zeile beginnen auf der auch das 'return' Keyword steht
+// Sonst wird hier ein automatisches Semikolon eingefügt und die Funktion
+// gibt 'undefined' zurück
+function myFunction()
+{
+    return // <- Hier wird automatisch ein Semikolon eingefügt
+    {
+        thisIsAn: 'object literal'
+    }
+}
+myFunction(); // = undefined
+
+// In JavaScript sind Funktionen 'Bürger erster Klasse', also können sie wie 
+// Variablen verwendet und als Parameter anderen Funktionen übergeben werden 
+// - zum Beispiel, um einen 'event handler' zu 'beliefern'.
+function myFunction() {
+    // wird ausgeführt, nachdem 5 Sekunden vergangen sind
+}
+setTimeout(myFunction, 5000);
+
+// Funktionen können auch deklariert werden, ohne ihnen einen Namen zuzuweisen.
+// Es ist möglich diese anonymen Funktionen direkt als (oder im) Argument 
+// einer anderen Funktion zu definieren.
+setTimeout(function(){
+    // wird ausgeführt, nachdem 5 Sekunden vergangen sind
+}, 5000);
+
+// JavaScript hat einen Geltungsbereich, der sich auf Funktionen erstreckt: 
+// Funktionen haben ihren eigenen Geltungsbereich, andere Blöcke nicht.
+if(true) {
+    var i = 5;
+}
+i; // = 5 - nicht undefined, wie man es von einer Sprache erwarten würde, die 
+   // ihren Geltungsbereich nach Blöcken richtet
+
+// Daraus ergibt sich ein bestimmtes Muster für sofort-ausführbare, anonyme 
+// Funktionen, die es vermeiden, dass der globale Geltungsbereich von Variablen
+// 'verschmutzt' wird.
+(function(){
+    var temporary = 5;
+    // Auf eine Variable im globalen Geltungsbereich kann zugegriffen werden, 
+    // sofern sie im globalen Objekt definiert ist (in einem Webbrowser ist 
+    // dies immer das 'window'-Objekt, in anderen Umgebungen, bspw. Node.js, 
+    // kann das anders aussehen). 
+    window.permanent = 10;
+})();
+temporary; // wirft einen ReferenceError
+permanent; // = 10
+
+// Eines der mächtigsten Charakteristika von JavaScript sind Closures. Wird 
+// eine Funktion innerhalb einer anderen Funktion definiert, dann hat die 
+// innere Funktion Zugriff auf alle Variablen der äußeren Funktion, sogar dann,
+// wenn die äußere Funktion beendet wurde.
+function sayHelloInFiveSeconds(name){
+    var prompt = "Hello, " + name + "!";
+    function inner(){
+        alert(prompt);
+    }
+    setTimeout(inner, 5000);
+    // setTimeout wird asynchron ausgeführt. Also wird sayHelloInFiveSeconds 
+    // sofort verlassen und setTimeout wird die innere Funktion 'im nachhinein' 
+    // aufrufen. Dennoch: Weil sayHelloInFiveSeconds eine Hülle um die innere 
+    // Funktion bildet, hat die innere Funktion immer noch Zugriff auf die 
+    // Variable prompt.
+}
+sayHelloInFiveSeconds("Adam");  // wird nach 5 Sekunden ein Popup mit der 
+                                // Nachricht "Hello, Adam!" öffnen.
+
+///////////////////////////////////
+// 5. Mehr über Objekte, Konstruktoren und Prototypen
+
+// Objekte können Funktionen enthalten.
+var myObj = {
+    myFunc: function(){
+        return "Hello world!";
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+// Wenn Funktionen aufgerufen werden, die zu einem Objekt gehören, können sie 
+// auf das eigene Objekt mit dem Schlüsselwort 'this' zugreifen.
+myObj = {
+    myString: "Hello world!",
+    myFunc: function(){
+        return this.myString;
+    }
+};
+myObj.myFunc(); // = "Hello world!"
+
+// Worauf 'this' gesetzt wird, ist davon abhängig, wie die Funktion aufgerufen 
+// wird, nicht wo sie definiert wurde. Unsere Funktion wird daher nicht 
+// funktionieren, sofern sie außerhalb des Kontextes des Objekts aufgerufen 
+// wird.
+var myFunc = myObj.myFunc;
+myFunc(); // = undefined
+
+// Umgekehrt ist es möglich eine Funktion einem Objekt zuzuweisen und dadurch 
+// Zugriff auf den this-Kontext zu erhalten, sogar dann, wenn die Funktion dem
+// Objekt nach dessen Definition zugewiesen wird.
+var myOtherFunc = function(){
+    return this.myString.toUpperCase();
+}
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = "HELLO WORLD!"
+
+// Mit den Methoden 'call' und 'apply' kann der Kontext eines Funktionsaufrufs
+// verändert werden
+
+var anotherFunc = function(s){
+    return this.myString + s;
+}
+anotherFunc.call(myObj, " And Hello Moon!"); // = "Hello World! And Hello Moon!"
+
+// 'apply' funktioniert beiahe identisch, erwartet die übergebenen Argumente
+// aber in einem Array
+
+anotherFunc.apply(myObj, [" And Hello Sun!"]); // = "Hello World! And Hello Sun!"
+
+// Das ist hilfreich wenn man einer Funktion eine beliebige Zahl Argumente
+// übergeben kann
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (uh-oh!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// 'call' und 'apply' beeinflussen aber nur den spezifischen Aufruf.
+// Um den Kontext einer Funktion dauerhaft zu ändern wird 'bind' benutzt.
+
+var boundFunc = anotherFunc.bind(myObj);
+boundFunc(" And Hello Saturn!"); // = "Hello World! And Hello Saturn!"
+
+// Mit 'bind' lassen sich Funktionen auch teilweise anwenden / "curryen".
+var product = function(a, b){ return a * b; }
+var doubler = product.bind(this, 2);
+doubler(8); // = 16
+
+// Wenn eine Funktion mit dem Schlüsselwort 'new' aufgerufen wird, dann wird 
+// ein neues Objekt erzeugt. Funktionen, die darauf ausgelegt sind in dieser 
+// Art aufgerufen zu werden, werden Konstruktoren genannt.
+var MyConstructor = function(){
+    this.myNumber = 5;
+}
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+// Jedes JavaScript-Objekt hat einen Prototyp. Wenn man versucht auf eine 
+// Eigenschaft des Objekts zuzugreifen, das nicht im Objekt selbst existiert,
+// schaut der Interpreter in dessen Prototyp nach.
+
+// Einige JavaScript-Implementierungen erlauben den direkten Zugriff auf den 
+// Prototyp eines Objekts durch die magische Eigenschaft __proto__. Obwohl das
+// nützlich ist, um  Prototypen im Allgemeinen zu erklären, ist das nicht Teil
+// des Standards; zum Standard-Weg der Nutzung von Prototypen kommen wir 
+// später.
+var myObj = {
+    myString: "Hello world!",
+};
+var myPrototype = {
+    meaningOfLife: 42,
+    myFunc: function(){
+        return this.myString.toLowerCase()
+    }
+};
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+
+// Das funktioniert auch bei Funktionen.
+myObj.myFunc(); // = "hello world!"
+
+// Sollte die Eigenschaft nicht im Prototypen des Objekts enthalten sein, dann
+// wird im Prototypen des Prototypen nachgesehen und so weiter.
+myPrototype.__proto__ = {
+    myBoolean: true
+};
+myObj.myBoolean; // = true
+
+// Dafür wird nichts hin und her kopiert; jedes Objekt speichert eine Referenz
+// auf seinen Prototypen. Das heißt wenn der Prototyp geändert wird, dann 
+// werden die Änderungen überall sichtbar.
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+// Es wurde bereits erwähnt, dass __proto__ nicht zum Standard gehört und es 
+// gibt ebenso keinen Standard-Weg, um den Prototyp eines existierenden Objekts
+// zu ändern. Es gibt dennoch zwei Wege, wie man ein neues Objekt mit einem 
+// gegebenen Prototypen erzeugt.
+
+// Der erste Weg ist die Methode Object.create, die eine jüngere Ergänzung des
+// JavaScript-Standards ist und daher noch nicht in allen Implementierungen 
+// verfügbar.
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+// Der zweite Weg, der immer funktioniert, hat mit den Konstruktoren zu tun. 
+// Konstruktoren haben eine Eigenschaft, die Prototyp heißt.  Dabei handelt es
+// sich *nicht* um den Prototypen der Konstruktor-Funktion; stattdessen handelt
+// es sich um den Prototypen, der einem neuen Objekt mitgegeben wird, wenn es 
+// mit dem Konstruktor und dem Schlüsselwort 'new' erzeugt wird.
+MyConstructor.prototype = {
+    getMyNumber: function(){
+        return this.myNumber
+    }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+
+// Alle primitiven Typen, also strings und numbers, haben auch Konstruktoren, 
+// die zu dem Typ äquivalente Wrapper-Objekte erzeugen. 
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+// Genau genommen: Sie sind nicht exakt äquivalent.
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0){
+    // Dieser Teil wird nicht ausgeführt, weil 0 'falsy' ist.
+}
+
+// Das Wrapper-Objekt und die regulären, eingebauten Typen, teilen sich einen 
+// Prototyp; so ist es möglich zum Beispiel einem String weitere Funktionen 
+// hinzuzufügen.
+String.prototype.firstCharacter = function(){
+    return this.charAt(0);
+}
+"abc".firstCharacter(); // = "a"
+
+// Diese Tatsache wird häufig bei einer Methode mit dem Namen 'polyfilling'
+// verwendet: Dabei wird ein neues Feature von JavaScript in einer älteren 
+// Untermenge der Sprache integriert, so dass bestimmte Funktionen auch in 
+// älteren Umgebungen und Browsern verwendet werden können.
+
+// Ein Beispiel: Es wurde erwähnt, dass die Methode Object.create nicht in 
+// allen Umgebungen verfügbar ist - wir können sie dennoch verwenden, mit einem
+// 'polyfill':
+if (Object.create === undefined){ // überschreib nichts, was eventuell bereits
+                                  // existiert
+    Object.create = function(proto){
+        // erstelle einen vorübergehenden Konstruktor mit dem richtigen
+        // Prototypen
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // verwende es dann, um ein neues Objekt mit einem passenden 
+        // Prototypen zurückzugeben
+        return new Constructor();
+    }
+}
+```
+
+## Zur weiteren Lektüre (englisch)
+
+Das [Mozilla Developer Network](https://developer.mozilla.org/en-US/docs/Web/JavaScript) bietet eine ausgezeichnete Dokumentation für die Verwendung von JavaScript im Browser. Es ist außerdem ein Wiki und ermöglicht es damit anderen zu helfen, wenn man selbst ein wenig Wissen angesammelt hat.
+
+MDN's [A re-introduction to JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) führt sehr viele der hier vorgestellten Konzepte im Detail aus. 
+
+Dieses Tutorial hat nur die Sprache JavaScript vorgestellt; um mehr über den  Einsatz in Websites zu lernen, ist es ein guter Start etwas über das [Document Object Model](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core) zu lernen.
+
+[JavaScript Garden](http://bonsaiden.github.io/JavaScript-Garden/) ist eine tiefgehende Einführung in die kontra-intuitiven Parts der Sprache.
+
+[JavaScript: The Definitive Guide](http://www.amazon.com/gp/product/0596805527/) ist ein Klassiker unter den Referenzen.
+
+Zusätzlich zu direkten Beiträgen zu diesem Artikel ist der Inhalt in Anlehnung an Louie Dinh's Python-Tutorial auf dieser Seite und das [JS Tutorial](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) des Mozilla Developer Network entstanden.
diff --git a/de-de/make-de.html.markdown b/de-de/make-de.html.markdown
index 1bae332c..3674f2f5 100644
--- a/de-de/make-de.html.markdown
+++ b/de-de/make-de.html.markdown
@@ -1,263 +1,263 @@
----

-category: tool

-tool: make

-contributors:

-    - ["Robert Steed", "https://github.com/robochat"]

-    - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]

-translators:

-  - ["Martin Schimandl", "https://github.com/Git-Jiro"]

-filename: Makefile-de

-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äftigt 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, dass 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, dass 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)

-

+---
+category: tool
+tool: make
+contributors:
+    - ["Robert Steed", "https://github.com/robochat"]
+    - ["Stephan Fuhrmann", "https://github.com/sfuhrm"]
+translators:
+  - ["Martin Schimandl", "https://github.com/Git-Jiro"]
+filename: Makefile-de
+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äftigt 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, dass 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, dass 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)
+
diff --git a/de-de/nix-de.html.markdown b/de-de/nix-de.html.markdown
index ffe8dffc..a55a91c7 100644
--- a/de-de/nix-de.html.markdown
+++ b/de-de/nix-de.html.markdown
@@ -356,6 +356,9 @@ with builtins; [
 
 * [Susan Potter - Nix Cookbook - Nix By Example]
   (https://ops.functionalalgebra.com/nix-by-example/)
-  
+
+* [Zero to Nix - Nix Tutorial]
+  (https://zero-to-nix.com/)
+
 * [Rommel Martinez - A Gentle Introduction to the Nix Family]
   (https://web.archive.org/web/20210121042658/https://ebzzry.io/en/nix/#nix)
diff --git a/de-de/pug-de.html.markdown b/de-de/pug-de.html.markdown
index c86494ce..ce31c648 100644
--- a/de-de/pug-de.html.markdown
+++ b/de-de/pug-de.html.markdown
@@ -162,13 +162,13 @@ case bestellungsStatus
 //- <p class="warn">Deine Bestellung steht noch aus</p>
 
 //- --INCLUDE--
-//- File path -> "includes/nav.png"
+//- File path -> "includes/nav.pug"
 h1 Firmenname
 nav
   a(href="index.html") Home
   a(href="about.html") Über uns
 
-//- Dateipfad -> "index.png"
+//- Dateipfad -> "index.pug"
 html
   body
     include includes/nav.pug
@@ -205,4 +205,4 @@ mixin comment(name, kommentar)
 ### Zusätzliche Ressourcen
 - [The Site](https://pugjs.org/)
 - [The Docs](https://pugjs.org/api/getting-started.html)
-- [Github Repo](https://github.com/pugjs/pug)
+- [GitHub Repo](https://github.com/pugjs/pug)
diff --git a/de-de/pyqt-de.html.markdown b/de-de/pyqt-de.html.markdown
index 93ee20d4..3b9b6ebb 100644
--- a/de-de/pyqt-de.html.markdown
+++ b/de-de/pyqt-de.html.markdown
@@ -21,7 +21,7 @@ Diese Version wurde in pyqt erstellt.
 ```python
 import sys
 from PyQt4 import QtGui
-	
+
 def window():
 	# Erschafft ein Anwendungsobjekt.
     app = QtGui.QApplication(sys.argv)
@@ -48,10 +48,10 @@ if __name__ == '__main__':
 
 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. 
+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 
+```python
 import sys
 from PyQt4.QtGui import *
 from PyQt4.QtCore import *
@@ -70,7 +70,7 @@ def window():
     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():
diff --git a/de-de/qt-de.html.markdown b/de-de/qt-de.html.markdown
index 480030fe..7d287cab 100644
--- a/de-de/qt-de.html.markdown
+++ b/de-de/qt-de.html.markdown
@@ -1,7 +1,7 @@
 ---
 category: tool
 tool: Qt Framework
-language: c++
+language: C++
 filename: learnqt-de.cpp
 contributors:
     - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
diff --git a/de-de/rst-de.html.markdown b/de-de/rst-de.html.markdown
index 072299f5..0eb2b6bf 100644
--- a/de-de/rst-de.html.markdown
+++ b/de-de/rst-de.html.markdown
@@ -86,14 +86,14 @@ erstellt werden, aber ich empfehle dir dafür die komplette Dokumentation zu les
 
 Es gibt mehrere Möglichkeiten um Links zu machen:
 
-- Wenn man einen Unterstrich hinter einem Wort hinzufügt: Github_ Zusätzlich 
+- Wenn man einen Unterstrich hinter einem Wort hinzufügt: GitHub_ Zusätzlich 
 muss man die Zielurl nach dem Text hinzufügen. 
 (Dies hat den Vorteil, dass man keine unnötigen Urls in lesbaren Text einfügt.
 - Wenn man die vollständige Url eingibt : https://github.com/
 (Dies wird automatisch in ein Link konvertiert.)
-- Wenn man es mehr Markdown ähnlich eingibt: `Github <https://github.com/>`_ .
+- Wenn man es mehr Markdown ähnlich eingibt: `GitHub <https://github.com/>`_ .
 
-.. _Github https://github.com/
+.. _GitHub https://github.com/
 
 ```
 
diff --git a/de-de/ruby-de.html.markdown b/de-de/ruby-de.html.markdown
index 8025a8c0..23571377 100644
--- a/de-de/ruby-de.html.markdown
+++ b/de-de/ruby-de.html.markdown
@@ -685,4 +685,4 @@ _(z.T. auf Englisch)_
 - [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
 - [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Eine ältere [freie Ausgabe](http://ruby-doc.com/docs/ProgrammingRuby/) ist online verfügbar.
 - [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - Ein von der Community erstellter Ruby coding style guide.
-- [Try Ruby](http://tryruby.org) - Lerne die Grundlagen der Ruby Programmiersprache, interaktiv im Browser.
+- [Try Ruby](https://try.ruby-lang.org/) - Lerne die Grundlagen der Ruby Programmiersprache, interaktiv im Browser.
diff --git a/de-de/rust-de.html.markdown b/de-de/rust-de.html.markdown
index faa4ec2b..6208db68 100644
--- a/de-de/rust-de.html.markdown
+++ b/de-de/rust-de.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: rust
+language: Rust
 contributors:
     - ["P1start", "http://p1start.github.io/"]
 translators:
@@ -255,7 +255,7 @@ fn main() {
 
     // `for` Schleife/Iterationen
     let array = [1, 2, 3];
-    for i in array.iter() {
+    for i in array {
         println!("{}", i);
     }
 
diff --git a/de-de/vim-de.html.markdown b/de-de/vim-de.html.markdown
index 8abf9a14..d0b4eb9d 100644
--- a/de-de/vim-de.html.markdown
+++ b/de-de/vim-de.html.markdown
@@ -3,95 +3,92 @@ category: tool
 tool: vim
 lang: de-de
 contributors:
-    - ["RadhikaG", "https://github.com/RadhikaG"]
+- ["RadhikaG", "https://github.com/RadhikaG"]
 translators:
-    - ["caminsha", "https://github.com/caminsha"]
+- ["caminsha", "https://github.com/caminsha"]
 filename: LearnVim-de.txt
 ---
 
-
 [Vim](http://www.vim.org)
 (Vi IMproved) ist ein Klon von vi, dem bekannten Editor für Unix. Es ist ein
-Texteditor, welcher mit Fokus auf Geschwindigkeit und Prouktivität entwickelt 
-wurde.
-Vim hat viele Keybindings für ein schnelles navigieren und schnelles bearbeiten
-einer Datei.
+Texteditor, welcher mit Fokus auf Geschwindigkeit und Produktivität entwickelt
+wurde. Vim hat viele Keybindings für ein schnelles navigieren und schnelles
+bearbeiten einer Datei.
 
 ## Grundlagen, um in Vim zu navigieren
 
 ```
-    vim <filename>   # Öffne <filename> in Vim
-    :help <topic>    # Open up built-in help docs about <topic> if any exists
-    :help <topic>    # Öffne die eingebaute Hilfe zum Thema  <topic>, wenn
-                     # es existiert
-    :q               # Schließe vim
-    :w               # Speichere diese Datei
-    :wq              # Speichere diese Datei und schließe vim
-    ZZ               # Speichere diese Datei und schließe vim
-    :q!              # Schließe vim ohne die Datei zu speichern
-                     # ! *zwingt* die Ausführung von :q,
-                     # daher wird die Datei nicht gespeichert.
-    ZQ               # Beende vim ohne die Datei zu speichern
-    :x               # Speichere die Datei und beende vim
-                     # Dies ist eine kürzere Version von :wq
-
-    u                # Änderung rückgängig machen
-    CTRL+R           # Änderung wiederherstellen
-
-    h                # Den Cursor um ein Zeichen nach links bewegen
-    j                # Den Cursor eine Zeile nach unten bewegen
-    k                # Den Cursor eine Zeile nach oben bewegen
-    l                # Den Cursor um ein Zeichen nach rechts bewegen
-
-    Ctrl+B 	         # Gehe eine Bildschirmanzeige zurück
-    Ctrl+F 	         # Gehe eine Bildschirmanzeige vorwärts
-    Ctrl+D 	         # Gehe eine halbe Bildschirmanzeige vorwärts
-    Ctrl+U           # Gehe eine halbe Bildschirmanzeige zurück
-
-    # Navigieren innerhalb einer Zeile
-
-    0                # Navigiere zum Anfang der Zeile
-    $                # Navigiere zum Ende der Zeile
-    ^                # Navigiere zum ersten Zeichen, welches kein Leerzeichen ist
-
-    # Im Text suchen
-
-    /word            # Hebt alle Ergebnisse nach dem Cursor hervor
-    ?word            # Hebt alle Ergebnisse vor dem Cursor hervor
-    n                # Bewegt den Cursor zum nächsten Ergebnis nach der Suche
-    N                # Bewegt den Cursor zum vorherigen Ergebnis der Suche
-
-    :%s/foo/bar/g    # Ersetze "foo" durch "bar" in allen Zeilen
-    :s/foo/bar/g     # Ersetze "foo" durch "bar" in der aktuellen Zeile
-    :%s/\n/\r/g      # Ersetze das newline-Zeichen bei allen Zeilen durch
-                     # ein carriage return
-
-    # Zu einzelnen Zeichen springen
-
-    f<character>     # Springe vorwärts und auf dem Zeichen  <character>
-    t<character>     # Springe vorwärts und lande vor dem Zeichen <character>
-
-    # Zum Beispiel,
-    f<               # Springe vorwärts und lande auf <
-    t<               # Springe vorwärts und lande vor <
-
-    # Wortweise navigieren
-
-    w                # Springe um ein Wort vorwärts
-    b                # Gehe ein Wort zurück
-    e                # Springe zum Ende des aktuellen Wortes
-
-    # Weitere Befehle, um zu navigieren
-
-    gg               # Gehe an den Start der Datei
-    G                # Gehe an das Ende der Datei
-    :NUM             # Springe zur Zeile NUM (NUM kann eine beliebige Zahl sein)
-    H                # Navigiere zum Start der aktuellen Bildschirmanzeige
-    M                # Navigiere in die Mitte der aktuellen Bildschirmanzeige
-    L                # Navigiere an das Ende der aktuellen Bildschirmanzeige
+vim <filename>   # Öffne <filename> in Vim
+:help <topic>    # Öffne die eingebaute Hilfe zum Thema  <topic>, wenn
+                 # es existiert
+:q               # Schließe vim
+:w               # Speichere diese Datei
+:wq              # Speichere diese Datei und schließe vim
+ZZ               # Speichere diese Datei und schließe vim
+:q!              # Schließe vim ohne die Datei zu speichern
+                 # ! *zwingt* die Ausführung von :q,
+                 # daher wird die Datei nicht gespeichert.
+ZQ               # Beende vim ohne die Datei zu speichern
+:x               # Speichere die Datei und beende vim
+                 # Dies ist eine kürzere Version von :wq
+
+u                # Änderung rückgängig machen
+CTRL+R           # Änderung wiederherstellen
+
+h                # Den Cursor um ein Zeichen nach links bewegen
+j                # Den Cursor eine Zeile nach unten bewegen
+k                # Den Cursor eine Zeile nach oben bewegen
+l                # Den Cursor um ein Zeichen nach rechts bewegen
+
+Ctrl+B           # Gehe eine Bildschirmanzeige zurück
+Ctrl+F           # Gehe eine Bildschirmanzeige vorwärts
+Ctrl+D           # Gehe eine halbe Bildschirmanzeige vorwärts
+Ctrl+U           # Gehe eine halbe Bildschirmanzeige zurück
+
+# Navigieren innerhalb einer Zeile
+
+0                # Navigiere zum Anfang der Zeile
+$                # Navigiere zum Ende der Zeile
+^                # Navigiere zum ersten Zeichen, welches kein Leerzeichen ist
+
+# Im Text suchen
+
+/word            # Hebt alle Ergebnisse nach dem Cursor hervor
+?word            # Hebt alle Ergebnisse vor dem Cursor hervor
+n                # Bewegt den Cursor zum nächsten Ergebnis nach der Suche
+N                # Bewegt den Cursor zum vorherigen Ergebnis der Suche
+
+:%s/foo/bar/g    # Ersetze "foo" durch "bar" in allen Zeilen
+:s/foo/bar/g     # Ersetze "foo" durch "bar" in der aktuellen Zeile
+:%s/\n/\r/g      # Ersetze das newline-Zeichen bei allen Zeilen durch
+                 # ein carriage return
+
+# Zu einzelnen Zeichen springen
+
+f<character>     # Springe vorwärts und auf dem Zeichen  <character>
+t<character>     # Springe vorwärts und lande vor dem Zeichen <character>
+
+# Zum Beispiel,
+f<               # Springe vorwärts und lande auf <
+t<               # Springe vorwärts und lande vor <
+
+# Wortweise navigieren
+
+w                # Springe um ein Wort vorwärts
+b                # Gehe ein Wort zurück
+e                # Springe zum Ende des aktuellen Wortes
+
+# Weitere Befehle, um zu navigieren
+
+gg               # Gehe an den Start der Datei
+G                # Gehe an das Ende der Datei
+:NUM             # Springe zur Zeile NUM (NUM kann eine beliebige Zahl sein)
+H                # Navigiere zum Start der aktuellen Bildschirmanzeige
+M                # Navigiere in die Mitte der aktuellen Bildschirmanzeige
+L                # Navigiere an das Ende der aktuellen Bildschirmanzeige
 ```
 
-## Hilfsdokumente:
+## Hilfsdokumente
 
 Vim hat eine eingebaute Dokumentation, welche mit `:help <topic>` aufgerufen
 werden kann.
@@ -99,34 +96,33 @@ Zum Beispiel öffnet `:help navigation` die Dokumentation über das Navigieren
 
 `:help` kann auch ohne ein Argument verwendet werden. Dies zeigt den Standard-
 Hilfsdialog an, welcher den Start mit vim einfacher macht.
-that aims to make getting started with vim more approachable!
 
-## Modi:
+## Modi
 
 Vim basiert auf dem Konzept von **modes**.
 
-- Command Mode - Vim startet in diesem Modus, hier kann man navigieren und Befehle eingeben
+- Command Mode - Vims erster Modus, hier kann man navigieren und Befehle eingeben
 - Insert Mode  - Wird verwendet, um Änderungen in der Datei zu machen.
-- Visual Mode  - Wird verwendet, um Text zu markieren und Operationen durchzuführen
+- Visual Mode  - Wird verwendet, um Text zu markieren und diesen zu verändern
 - Ex Mode      - Wird verwendet, um im ':'-Prompt Befehle einzugeben
 
 ```
-    i                # Führt vim in den Insert Mode, vor der Cursorposition
-    a                # Führt vim in den Insert Mode, nach der Cursorposition
-    v                # Führt vim in den Visual Mode
-    :                # Führt vim in den Ex Mode
-    <esc>            # Führt zurück in den Command Mode, egal in welchem Mode
-                     # man sich gerade befindet.
-
-    # Kopieren und einfügen von Text
-
-    y                # Kopiere alles, was im Moment ausgewählt ist
-    yy               # Kopiert die aktuelle Zeile
-    d                # Löscht alles, was im Moment ausgewählt ist
-    dd               # Löscht die aktuelle Zeile
-    p                # Fügt den kopierten Text nach dem Cursor ein
-    P                # Fügt den kopierten Text vor dem Cursor ein
-    x                # Löscht das Zeichen unter dem Cursor
+i                # Führt vim in den Insert Mode, vor der Cursorposition
+a                # Führt vim in den Insert Mode, nach der Cursorposition
+v                # Führt vim in den Visual Mode
+:                # Führt vim in den Ex Mode
+<esc>            # Führt zurück in den Command Mode, egal in welchem Mode
+                 # man sich gerade befindet.
+
+# Kopieren und einfügen von Text
+
+y                # Kopiere alles, was im Moment ausgewählt ist
+yy               # Kopiert die aktuelle Zeile
+d                # Löscht alles, was im Moment ausgewählt ist
+dd               # Löscht die aktuelle Zeile
+p                # Fügt den kopierten Text nach dem Cursor ein
+P                # Fügt den kopierten Text vor dem Cursor ein
+x                # Löscht das Zeichen unter dem Cursor
 ```
 
 ## Die 'Grammatik' von Vim
@@ -141,68 +137,67 @@ Vim kann als Satz von Kommandos angesehen werden, welche im Format
 Einige wichtige Beispiele von 'Verb', 'Modifier' und 'Nouns':
 
 ```
-    # 'Verb'
-
-    d                # löschen
-    c                # ändern
-    y                # kopieren
-    v                # visuelles auswählen
-
-    # 'Modifiers'
-
-    i                # innerhalb
-    a                # außerhalb
-    NUM              # Nummer (NUM kann irgendeine Zahl sein)
-    f                # Sucht nach etwas und landet darauf
-    t                # Sucht nach etwas und stoppt davor
-    /                # Suche eine Zeichenfolge ab dem Cursor
-    ?                # Suche eine Zeichenfolge vor dem Cursor
-
-    # 'Nouns'
-
-    w                # Wort
-    s                # Satz
-    p                # Abschnitt
-    b                # Block
-
-    # Beispielsätze resp. Kommandos
-
-    d2w              # lösche zwei Wörter
-    cis              # Ändere innerhalb des Satzes.
-    yip              # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt, 
-                     # in welchem du bist)
-    ct<              # Ändere bis zur spitzen Klammer
-                     # Ändere den Text von deiner aktuellen Cursorposition bis
-                     # zur nächsten spitzen Klammer
-    d$               # Lösche bis zum Ende der Zeile
+# 'Verb'
+
+d                # löschen
+c                # ändern
+y                # kopieren
+v                # visuelles auswählen
+
+# 'Modifiers'
+
+i                # innerhalb
+a                # außerhalb
+NUM              # Nummer (NUM kann irgendeine Zahl sein)
+f                # Sucht nach etwas und landet darauf
+t                # Sucht nach etwas und stoppt davor
+/                # Suche eine Zeichenfolge ab dem Cursor
+?                # Suche eine Zeichenfolge vor dem Cursor
+
+# 'Nouns'
+
+w                # Wort
+s                # Satz
+p                # Abschnitt
+b                # Block
+
+# Beispielsätze resp. Kommandos
+
+d2w              # lösche zwei Wörter
+cis              # Ändere innerhalb des Satzes.
+yip              # Kopiere innerhalb des Abschnitts (kopiere den Abschnitt,
+                 # in welchem du bist)
+ct<              # Ändere bis zur spitzen Klammer
+                 # Ändere den Text von deiner aktuellen Cursorposition bis
+                 # zur nächsten spitzen Klammer
+d$               # Lösche bis zum Ende der Zeile
 ```
 
 ## Einige Shortcuts und Tricks
 
 ```
-    >                # Rücke die Auswahl um einen Block ein
-    <                # Lösche eine Einrückung der Auswahl
-    :earlier 15m     # Stellt das Dokument so wieder her, wie es vor 15 
-                     # Minuten war
-    :later 15m       # den oberen Befehl rückgängig machen
-    ddp              # Vertauschen zweier aufeinanderfolgenden Zeilen
-                     # Zuerst dd, dann p
-    .                # Wiederhole die vorherige Aktion
-    :w !sudo tee %   # Speichere die Datei als Root
-    :set syntax=c    # Stelle das Syntax-Highlighting für 'C' ein
-    :sort            # Alle Zeilen sortieren
-    :sort!           # Alle Zeilen rückwärts sortieren
-    :sort u          # Alle Zeilen sortieren und Duplikate entfernen
-    ~                # Umschalten der Groß-/Kleinschreibung des ausgewählten Textes
-    u                # Ausgewählten Text zu Kleinschreibung ändern
-    U                # Ausgewählten Text zu Großschreibung ändern
-    
-    # Text-Folding (Textfaltung)
-    zf               # Erstelle eine Faltung des ausgewählten Textes
-    zo               # Öffne die aktuelle Faltung
-    zc               # Schließe die aktuelle Faltung
-    zR               # Öffne alle Faltungen
-    zM               # Schließe alle Faltungen
+>                # Rücke die Auswahl um einen Block ein
+<                # Lösche eine Einrückung der Auswahl
+:earlier 15m     # Stellt das Dokument so wieder her, wie es vor 15 Minuten war
+:later 15m       # den oberen Befehl rückgängig machen
+ddp              # Vertauschen zweier aufeinanderfolgenden Zeilen
+                 # Zuerst dd, dann p
+.                # Wiederhole die vorherige Aktion
+:w !sudo tee %   # Speichere die Datei als Root
+:set syntax=c    # Stelle das Syntax-Highlighting für 'C' ein
+:sort            # Alle Zeilen sortieren
+:sort!           # Alle Zeilen rückwärts sortieren
+:sort u          # Alle Zeilen sortieren und Duplikate entfernen
+~                # Umschalten der Groß-/Kleinschreibung des ausgewählten Textes
+u                # Ausgewählten Text zu Kleinschreibung ändern
+U                # Ausgewählten Text zu Großschreibung ändern
+
+# Text-Folding (Textfaltung)
+zf               # Erstelle eine Faltung des ausgewählten Textes
+zo               # Öffne die aktuelle Faltung
+zc               # Schließe die aktuelle Faltung
+zR               # Öffne alle Faltungen
+zM               # Schließe alle Faltungen
 ```
 
 ## Makros
@@ -213,9 +208,9 @@ Kommandos, welche du braucht, aufgenommen bis die Aufnahme gestoppt wird.
 Wenn du ein Makro ausführst, werden exakt die gleichen Schritte gemacht.
 
 ```
-    qa               # Starte das Aufnehmen des Makros 'a'
-    q                # Beende das Aufnehmen
-    @a               # Führe das Makro 'a' aus
+qa               # Starte das Aufnehmen des Makros 'a'
+q                # Beende das Aufnehmen
+@a               # Führe das Makro 'a' aus
 ```
 
 ### Konfigurieren mit ~/.vimrc
diff --git a/de-de/visualbasic-de.html.markdown b/de-de/visualbasic-de.html.markdown
new file mode 100644
index 00000000..6194e906
--- /dev/null
+++ b/de-de/visualbasic-de.html.markdown
@@ -0,0 +1,290 @@
+---
+language: Visual Basic
+contributors:
+    - ["Brian Martin", "http://brianmartin.biz"]
+translators:
+    - ["Enno Nagel", "https://github.com/konfekt"]
+filename: learnvisualbasic-de.vb
+lang: de-de
+---
+
+```visualbasic
+Module Modul1
+
+Sub Main()
+  ' Ein kurzer Blick auf Visual Basic-Konsolenanwendungen
+  ' bevor wir tiefer in das Thema eintauchen.
+  ' Das Hochkomma leitet eine Kommentarzeile ein.
+  ' Um dieses Tutorial innerhalb des Visual Basic Compilers zu erkunden,
+  ' habe ich ein Navigationssystem erstellt.
+  ' Dieses System wird im weiteren Verlauf des Tutorials erklärt;
+  ' Sie werden nach und nach verstehen, was das alles bedeutet.
+  Console.Title = ("Lerne X in Y Minuten")
+  Console.WriteLine ("NAVIGATION") 'Anzeige
+  Console.WriteLine ("")
+  Console.ForegroundColor = ConsoleColor.Green
+  Console.WriteLine ("1. Ausgabe von 'Hallo, Welt'")
+  Console.WriteLine ("2. Eingabe 'Hallo, Welt'")
+  Console.WriteLine ("3. ganze Zahlen berechnen")
+  Console.WriteLine ("4. Berechne Dezimalzahlen")
+  Console.WriteLine ("5. ein funktionaler Taschenrechner")
+  Console.WriteLine ("6. 'Do While'-Schleifen verwenden")
+  Console.WriteLine ("7. Verwendung von 'For While'-Schleifen")
+  Console.WriteLine ("8. Bedingte Anweisungen")
+  Console.WriteLine ("9. Ein Getränk auswählen")
+  Console.WriteLine ("50. Über")
+  Console.WriteLine ("Wählen Sie eine Zahl aus der obigen Liste")
+  Dim selection As String = Console.Readline()
+  Select Case auswahl
+    Case "1" 'Ausgabe "Hallo, Welt"
+      Console.Clear() 'Löscht die Konsole und öffnet die private Subroutine
+      AusgabeHalloWelt() 'Öffnet die genannte private Subroutine
+    Case "2" 'Eingabe "hallo, Welt"
+      Console.Clear()
+      EingabeHalloWelt()
+    Case "3" 'Berechne ganze Zahlen
+      Console.Clear()
+      BerechneGanzeZahlen()
+    Case "4" 'Dezimalzahlen berechnen
+      Console.Clear()
+      BerechneDezimalZahlen()
+    Case "5" 'Ein funktionaler Taschenrechner
+      Console.Clear()
+      Taschenrechner()
+    Case "6" 'Verwendung von "Do While"-Schleifen
+      Console.Clear()
+      WhileSchleife()
+    Case "7" 'Verwendung von "For While"-Schleifen
+      Console.Clear()
+      ForSchleife()
+    Case "8" 'Bedingte Anweisungen
+      Console.Clear()
+      BedingteAnweisung()
+    Case "9" 'If/Else-Anweisung
+      Console.Clear()
+      IfElseAnweisung() 'Ein Getränk auswählen
+    Case "50" '"Über" Infobox
+      Console.Clear()
+      Console.Title = ("Lernen Sie X in Y Minuten :: Über")
+      MsgBox ("Tutorial geschrieben von Brian Martin (@BrianMartinn)")
+      Console.Clear()
+      Main()
+      Console.ReadLine()
+
+  End Select
+End Sub
+
+'Eins - Ich habe Zahlen verwendet, um mich durch das obige Navigationssystem zu
+'führen auf das ich später zurückkomme, um es zu implementieren.
+
+'wir verwenden private Unterprogramme, um verschiedene Abschnitte des Programms
+'zu trennen.
+Private Sub AusgabeHalloWelt()
+  'Titel der Konsolenanwendung
+  Console.Title = "Ausgabe 'Hallo, Welt' | Lerne X in Y Minuten"
+  'Verwenden Sie Console.Write("") oder Console.WriteLine(""), um die Ausgabe
+  'anzuzeigen, gefolgt von Console.Read(), oder Console.Readline()
+  'Console.ReadLine() zeigt die Ausgabe auf der Konsole an.
+  Console.WriteLine ("Hallo, Welt")
+  Console.ReadLine()
+End Sub
+
+'Zwei
+Private Sub EingabeHalloWelt()
+  Console.Title = "Hallo, Welt, ich bin.. | Lerne X in Y Minuten"
+  'Variablen
+  'Vom Benutzer eingegebene Daten müssen gespeichert werden.
+  'Variablen beginnen ebenfalls mit Dim und enden mit As VariableType.
+
+  'In diesem Lernprogramm wollen wir Ihren Namen wissen und das Programm
+  'auf ihn antworten.
+  Dim nutzername As String
+  ' Wir verwenden "String", weil es sich um eine textbasierte Variable handelt.
+  Console.WriteLine ("Hallo, wie ist Ihr Name?") 'Frage nach dem Benutzernamen.
+  nutzername = Console.ReadLine() 'Benutzernamen speichern.
+  Console.WriteLine ("Hallo, " + nutzername) 'Ausgabe ist Hallo, Name
+  Console.ReadLine() 'Die obige Ausgabe anzeigen.
+  'Der obige Code stellt Ihnen eine Frage und zeigt die Antwort an.
+  'Neben anderen Variablentypen gibt es Integer, den wir für ganze Zahlen
+  'verwenden werden.
+End Sub
+
+'Drei
+Private Sub BerechneGanzeZahlen()
+  Console.Title = "Berechne ganze Zahlen | Lerne X in Y Minuten"
+  Console.Write ("Erste Zahl: ") 'Schreiben Sie eine ganze Zahl, 1, 2, 104, usw
+  Dim a As Integer = Console.ReadLine()
+  Console.Write ("Zweite Zahl: ") 'Schreiben Sie eine weitere ganze Zahl.
+  Dim b As Integer = Console.ReadLine()
+  Dim c As Integer = a + b
+  Console.WriteLine (c)
+  Console.ReadLine()
+  'Dies ist ein einfacher Taschenrechner
+End Sub
+
+'Vier
+Private Sub BerechneDezimalZahlen()
+  Console.Title = "Berechne mit dem Typ Double | Lerne X in Y Minuten"
+  'Natürlich würden wir gerne Dezimalzahlen addieren.
+  'Also könnten wir von Integer auf Double umstellen.
+
+  'Schreiben Sie eine Bruchzahl, 1.2, 2.4, 50.1, 104.9 usw
+  Console.Write ("Erste Zahl: ")
+  Dim a As Double = Console.Readline()
+  Console.Write ("Zweite Zahl: ") 'Schreiben Sie die zweite Zahl.
+  Dim b As Double = Console.Readline()
+  Dim c As Double = a + b
+  Console.WriteLine (c)
+  Console.ReadLine()
+  'Dieses Programm kann 1.1 und 2.2 addieren
+End Sub
+
+'Fünf
+Private Sub Taschenrechner()
+  Console.Title = "Der Funktionsrechner | Lerne X in Y Minuten"
+  'Wenn Sie aber wollen, dass der Rechner subtrahiert, dividiert,
+  'multipliziert und addiert.
+  'Kopieren Sie den obigen Text und fügen Sie ihn ein.
+  Console.Write ("Erste Zahl: ")
+  Dim a As Double = Console.Readline()
+  Console.Write ("Zweite Zahl: ")
+  Dim b As Integer = Console.Readline()
+  Dim c As Integer = a + b
+  Dim d As Integer = a * b
+  Dim e As Integer = a - b
+  Dim f As Integer = a / b
+
+  'Mit den folgenden Zeilen können wir  die Werte a und b
+  'subtrahieren, multiplizieren und dividieren
+  Console.Write (a.ToString() + " + " + b.ToString())
+  'Wir wollen den Ergebnissen einen linken Rand von 3 Leerzeichen geben.
+  Console.WriteLine (" = " + c.ToString.PadLeft(3))
+  Console.Write (a.ToString() + " * " + b.ToString())
+  Console.WriteLine (" = " + d.ToString.PadLeft(3))
+  Console.Write (a.ToString() + " - " + b.ToString())
+  Console.WriteLine (" = " + e.ToString.PadLeft(3))
+  Console.Write (a.ToString() + " / " + b.ToString())
+  Console.WriteLine (" = " + f.ToString.PadLeft(3))
+  Console.ReadLine()
+
+End Sub
+
+'Sechs
+Private Sub WhileSchleife()
+  'Gleich zur vorherigen privaten Subroutine.
+  'Diesmal fragen wir den Benutzer, ob er fortfahren möchte (ja oder nein?).
+  'Wir verwenden die Do While-Schleife, weil wir nicht wissen, ob der Benutzer
+  'das Programm mehr als einmal verwenden möchte.
+  Console.Title = "Do While-Schleifen verwenden | X in Y Minuten lernen"
+  Dim antwort As String 'Wir verwenden "String", weil die Antwort ein Text ist
+  Do 'Wir beginnen das Programm mit
+    Console.Write ("Erste Zahl: ")
+    Dim a As Double = Console.Readline()
+    Console.Write ("Zweite Zahl: ")
+    Dim b As Integer = Console.Readline()
+    Dim c As Integer = a + b
+    Dim d As Integer = a * b
+    Dim e As Integer = a - b
+    Dim f As Integer = a / b
+
+    Console.Write (a.ToString() + " + " + b.ToString())
+    Console.WriteLine (" = " + c.ToString.PadLeft(3))
+    Console.Write (a.ToString() + " * " + b.ToString())
+    Console.WriteLine (" = " + d.ToString.PadLeft(3))
+    Console.Write (a.ToString() + " - " + b.ToString())
+    Console.WriteLine (" = " + e.ToString.PadLeft(3))
+    Console.Write (a.ToString() + " / " + b.ToString())
+    Console.WriteLine (" = " + f.ToString.PadLeft(3))
+    Console.ReadLine()
+    'Fragen Sie den Benutzer, ob er fortfahren möchte. Unglücklicherweise
+    'werden Groß- und Kleinschreibung unterschieden.
+    Console.Write ("Möchten Sie fortfahren? (j / n)")
+    'Das Programm nimmt die Variable, zeigt sie an und beginnt von vorne.
+    antwort = Console.Readline()
+    'Der Befehl, der diese Variable zum Laufen bringt, ist in diesem Fall "j"
+  Loop While antwort = "j"
+
+End Sub
+
+'Sieben
+Private Sub ForSchleife()
+  'Manchmal muss das Programm nur einmal ausgeführt werden.
+  'In diesem Programm werden wir von 10 loszählen.
+
+  Console.Title = "Mit "For"-Schleifen | X in Y Minuten lernen"
+  'Deklarieren Sie die Variable und ab welcher Zahl in Schritt -1 gezählt
+  'werden soll, Schritt -2, Schritt -3, usw.
+  For i As Integer = 10 To 0 Schritt -1
+    Console.WriteLine (i.ToString) 'Zählerwert anzeigen
+  Next i 'Berechne den neuen Wert
+  Console.WriteLine ("Start") 'Starten wir das Programm, baby!!!!
+  Console.ReadLine() 'BANG!!!! - Vielleicht war ich zu aufgeregt :)
+End Sub
+
+'Acht
+Private Sub BedingteAnweisung()
+  Console.Title = "Bedingte Anweisungen | X in Y Minuten lernen"
+  Dim username As String = Console.Readline()
+  'Aufforderung zur Eingabe des Benutzernamens.
+  Console.WriteLine ("Hallo, wie ist Ihr Name?")
+  username = Console.ReadLine() 'Benutzernamen speichern.
+  If username = "Adam" Then
+    Console.WriteLine ("Hallo, Adam")
+    Console.WriteLine ("Danke, dass Sie diese nützliche Website erstellt haben")
+    Console.ReadLine()
+  Else
+    Console.WriteLine ("Hallo, " + Benutzername)
+    Console.WriteLine ("Haben Sie www.learnxinyminutes.com besucht?")
+    Console.ReadLine() 'Beendet und zeigt die obige Anweisung an.
+  End If
+End Sub
+
+  'Neun
+Private Sub IfElseAnweisung()
+    Console.Title = "If / Else-Anweisung | X in Y Minuten lernen"
+    'Manchmal ist es wichtig, mehr als zwei Alternativen in Betracht zu ziehen.
+    'Manchmal sind einige von ihnen besser.
+    'In diesem Fall brauchen wir mehr als eine "if"-Anweisung.
+    'Eine "if"-Anweisung ist für Verkaufsautomaten geeignet.
+    'Der Benutzer gibt einen Code ein (A1, A2, A3), aus dem er wählen kann.
+    'Alle Auswahlmöglichkeiten können in einer einzigen "if"-Anweisung
+    'kombiniert werden.
+
+    Dim auswahl As String = Console.ReadLine 'Der Wert der Auswahl
+    Console.WriteLine ("A1. für 7Up")
+    Console.WriteLine ("A2. für Fanta")
+    Console.WriteLine ("A3. für Dr. Pepper")
+    Console.WriteLine ("A4. für Coca-Cola")
+    Console.ReadLine()
+  If auswahl = "A1" Dann
+    Console.WriteLine ("7up")
+    Console.ReadLine()
+  ElseIf auswahl = "A2" Then
+    Console.WriteLine ("fanta")
+    Console.ReadLine()
+  ElseIf auswahl = "A3" Then
+    Console.WriteLine ("Dr. Pfeffer")
+    Console.ReadLine()
+  ElseIf auswahl = "A4" Then
+    Console.WriteLine ("Coca-Cola")
+    Console.ReadLine()
+  Else
+    Console.WriteLine ("Ein Produkt auswählen")
+    Console.ReadLine()
+  End If
+
+End Sub
+
+End Module
+```
+
+## Referenzen
+
+Für diejenigen, die mehr wissen wollen, hat Brian Martin ein umfassenderes
+[Visual Basic Tutorial](http://www.vbbootcamp.co.uk/ "Visual Basic Tutorial")
+erstellt.
+
+Die gesamte Syntax sollte gültig sein.
+Kopieren Sie den Code und fügen Sie ihn in den Visual Basic Compiler ein und
+führen Sie das Programm aus (F5).
+
diff --git a/de-de/yaml-de.html.markdown b/de-de/yaml-de.html.markdown
index 0332c912..00e4fd94 100644
--- a/de-de/yaml-de.html.markdown
+++ b/de-de/yaml-de.html.markdown
@@ -112,7 +112,7 @@ python_komplexe_Zahlen: !!python/komplex 1+2j
 ####################
 
 # Strings und Zahlen sind nicht die einzigen Skalare, welche YAML versteht.
-# ISO-formatierte Datumsangaben and Zeiangaben können ebenso geparsed werden.
+# ISO-formatierte Datumsangaben and Zeitangaben können ebenso geparsed werden.
 DatumZeit: 2001-12-15T02:59:43.1Z
 DatumZeit_mit_Leerzeichen: 2001-12-14 21:59:43.10 -5
 Datum: 2002-12-14