Merge branch 'master' into elixir-casing

5 files changed, 858 insertions, 7 deletions

diff --git a/de-de/asciidoc-de.html.markdown b/de-de/asciidoc-de.html.markdown
index f7d36b41..d0a62c66 100644
--- a/de-de/asciidoc-de.html.markdown
+++ b/de-de/asciidoc-de.html.markdown
@@ -4,7 +4,7 @@ contributors:
     - ["Ryan Mavilia", "http://unoriginality.rocks/"]
 translators:
   - ["Dennis Keller", "https://github.com/denniskeller"]
-filename: asciidoc-de.md
+filename: asciidoc-de.adoc
 lang: de-de
 ---
 
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/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/pug-de.html.markdown b/de-de/pug-de.html.markdown
index c86494ce..10172d6b 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
diff --git a/de-de/visualbasic-de.html.markdown b/de-de/visualbasic-de.html.markdown
new file mode 100644
index 00000000..a0dde471
--- /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
+---
+
+```
+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).
+