18 files changed, 519 insertions, 375 deletions

diff --git a/bash.html.markdown b/bash.html.markdown
index 0adc2efe..59aeaaf4 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -230,7 +230,9 @@ cat file.txt
 
 # We can also read the file using `cat`:
 Contents=$(cat file.txt)
-echo "START OF FILE\n$Contents\nEND OF FILE" # "\n" prints a new line character
+# "\n" prints a new line character
+# "-e" to interpret the newline escape characters as escape characters 
+echo -e "START OF FILE\n$Contents\nEND OF FILE"
 # => START OF FILE
 # => [contents of file.txt]
 # => END OF FILE
diff --git a/dart.html.markdown b/dart.html.markdown
index 2672dc6a..ee695d33 100644
--- a/dart.html.markdown
+++ b/dart.html.markdown
@@ -6,7 +6,7 @@ contributors:
   - ["Vince Ramces Oliveros", "https://github.com/ram231"]
 ---
 
-**Dart** is a single threaded, general puprose programming languages.
+**Dart** is a single threaded, general purpose programming language.
 It borrows a lot from other mainstream languages.
 It supports Streams, Futures(known as Promises in JavaScript), Generics, First-class functions(closures) and static type checking.
 Dart can run in any platform such as Web, CLI, Desktop, Mobile and IoT devices.
diff --git a/de-de/ruby-de.html.markdown b/de-de/ruby-de.html.markdown
index e14603cd..8025a8c0 100644
--- a/de-de/ruby-de.html.markdown
+++ b/de-de/ruby-de.html.markdown
@@ -1,5 +1,6 @@
 ---
 language: ruby
+filename: ruby-de.rb
 contributors:
   - ["David Underwood", "http://theflyingdeveloper.com"]
   - ["Joel Walden", "http://joelwalden.net"]
@@ -11,602 +12,677 @@ contributors:
   - ["Dzianis Dashkevich", "https://github.com/dskecse"]
   - ["Levi Bostian", "https://github.com/levibostian"]
   - ["Rahil Momin", "https://github.com/iamrahil"]
+  - ["Gabriel Halley", "https://github.com/ghalley"]
+  - ["Persa Zula", "http://persazula.com"]
+  - ["Jake Faris", "https://github.com/farisj"]
+  - ["Corey Ward", "https://github.com/coreyward"]
+  - ["Jannik Siebert", "https://github.com/janniks"]
+  - ["Keith Miyake", "https://github.com/kaymmm"]
 translators:
   - ["Christian Albrecht", "https://github.com/coastalchief"]
   - ["Dennis Keller", "https://github.com/denniskeller"]
-filename: ruby-de.rb
+  - ["Paul Götze", "https://gitub.com/paulgoetze"]
 lang: de-de
 ---
 
-# Dies ist ein Kommentar
+```ruby
+# Das ist ein Kommentar
 
 =begin
-Dies sind multi-line
-Kommentare. Niemand benutzt
-die wirklich.
+Das ist ein mehrzeiliger Kommentar.
+Die Anfangszeile muss mit "=begin" beginnen
+und die Endzeile muss mit "=end" beginnen. 
+
+Alternativ kannst du jede Zeile in einem 
+mehrzeiligen Kommentar mit dem # Zeichen beginnen. 
 =end
 
-# Objekte - Alles ist ein Objekt
+# In Ruby ist (fast) alles ein Objekt.
+# Das schließt Zahlen ein...
+3.class #=> Integer
 
-## Zahlen sind Objekte
-```
-3.class #=> Fixnum
-3.to_s #=> "3"
-```
+# ...und Zeichenketten (Strings)...
+"Hallo".class #=> String
 
-### Simple Arithmetik
-```
+# ...und sogar Methoden!
+"Hallo".method(:class).class #=> Method
+
+# Simple Arithmetik
 1 + 1 #=> 2
 8 - 1 #=> 7
 10 * 2 #=> 20
 35 / 5 #=> 7
-2**5 #=> 32
-```
+2 ** 5 #=> 32
+5 % 3 #=> 2
 
-// Arithmetik ist aber eigentlich nur syntaktischer Zucker
-// um eine Methode eines Objekt aufzurufen
-```
+# Bitweise Operatoren
+3 & 5 #=> 1
+3 | 5 #=> 7
+3 ^ 5 #=> 6
+
+# Arithmetik ist aber eigentlich nur syntaktischer Zucker
+# um eine Methode eines Objekts aufzurufen
 1.+(3) #=> 4
 10.* 5 #=> 50
-```
+100.methods.include?(:/) #=> true
 
-## Special values sind Objekte
-```
-nil # Nothing to see here
-true # truth
-false # falsehood
+## Spezielle Werte sind Objekte
+nil # Equivalent zu null in anderen Sprachen
+true # Wahrheitswert
+false # Falschheitswert
 
 nil.class #=> NilClass
 true.class #=> TrueClass
 false.class #=> FalseClass
-```
 
-## Objektvergleiche
-### Gleicheit
-```
+# Gleicheit
 1 == 1 #=> true
 2 == 1 #=> false
-```
-### Ungleichheit
-```
+
+# Ungleichheit
 1 != 1 #=> false
 2 != 1 #=> true
-```
-### Neben false selbst, nil ist ein anderer 'falsey' Wert
-```
-!nil   #=> true
-!false #=> true
-!0     #=> false
-```
-### Weitere Vergleiche
-```
+
+# Neben false selbst, ist nil der einzige andere 
+# zu Falsch evaluierende Wert
+
+!!nil   #=> false
+!!false #=> false
+!!0     #=> true
+!!""    #=> true
+
+# Weitere Vergleiche
 1 < 10 #=> true
 1 > 10 #=> false
 2 <= 2 #=> true
 2 >= 2 #=> true
-```
+
+# Kombinierter Vergleichsoperator (gibt `1` zurück wenn das erste Argument 
+# größer ist, und `-1`, wenn das zweite Argument größer ist, sonst `0`)
+1 <=> 10 #=> -1 (1 < 10)
+10 <=> 1 #=> 1 (10 > 1)
+1 <=> 1 #=> 0 (1 == 1)
+
 ### Logische Operatoren
-```
 true && false #=> false
 true || false #=> true
-!true #=> false
-```
 
-Es gibt alternative Versionen der logischen Operatoren mit niedrigerer
-Wertigkeit. Diese werden meistens bei Flow-Control eingesetzt, um
-verschiedenen Ausdrücke zu verketten bis einer true oder false zurück
-liefert.
+# Es gibt alternative Versionen der logischen Operatoren mit niedrigerer
+# Wertigkeit. Diese werden meistens zur Flusskontrolle eingesetzt, um
+# verschiedenen Ausdrücke zu verketten bis einer true oder false zurück
+# liefert.
 
-#### and
-##### `do_something_else` wird nur ausgewertet wenn `do_something` true ist.
+# `do_something_else` wird nur ausgewertet wenn `do_something` true ist.
 do_something() and do_something_else()
-
-#### or
-#####`log_error` wird nur ausgewertet wenn `do_something` false ist.
+# `log_error` wird nur ausgewertet wenn `do_something` false ist.
 do_something() or log_error()
 
-## Strings sind Objekte
-```
-'I am a string'.class #=> String
-"I am a string too".class #=> String
+# String Interpolation
 
+placeholder = 'Ruby'
+"Ich kann in #{placeholder} Platzhalter mit doppelten Anführungszeichen füllen."
+#=> "Ich kann in Ruby Platzhalter mit doppelten Anführungszeichen füllen."
 
-platzhalter = 'Ruby'
-"Ich kann in #{placeholder} Platzhalter mit doppelten Anführungsstrichen füllen."
-```
-Einfache Anführungszeichen sollten bevorzugt werden.
-Doppelte Anführungszeichen führen interne Berechnungen durch.
+# Du kannst Strings mit `+` verbinden, nicht jedoch mit anderen Typen
+'hallo ' + 'Welt'  #=> "hallo Welt"
+'Hallo ' + 3 #=> TypeError: no implicit conversion of Integer into String
+'hallo ' + 3.to_s #=> "hallo 3"
+"hallo #{3}" #=> "hallo 3"
+
+# ...oder Strings mit Operatoren kombinieren
+'hallo ' * 3 #=> "hallo hallo hallo "
+
+# ...oder Strings an andere Strings anhängen
+'hallo' << ' Welt' #=> "hallo Welt"
+
+# Du kannst Text mit einer neuen Zeile am Ende ausgeben
+puts "Ich gebe Text aus!"
+#=> Ich gebe Text aus!
+#=> nil
+
+# ...oder Text ohne einen Zeilenumbruch ausgeben
+print "Ich gebe Text aus!"
+#=> "Ich gebe Text aus!" => nil
 
-### Strings können verbunden werden, aber nicht mit Zahlen
-```
-'hello ' + 'world'  #=> "hello world"
-'hello ' + 3 #=> TypeError: can't convert Fixnum into String
-```
-#### Zahl muss in String konvertiert werden
-```
-'hello ' + 3.to_s #=> "hello 3"
-```
-### Text ausgeben
-```
-puts "I'm printing!"
-```
 # Variablen
-## Zuweisungen
-### Diese Zuweisung gibt den zugeordneten Wert zurück
-```
 x = 25 #=> 25
 x #=> 25
-```
-### Damit funktionieren auch mehrfache Zuweisungen
-```
+
+# Beachte, dass Zuweisungen den zugewiesenen Wert zurückgeben.
+# D.h. du kannst mehrfache Zuweisungen machen.
+
 x = y = 10 #=> 10
 x #=> 10
 y #=> 10
-```
-## Benennung
-### Konvention ist snake_case
-```
+
+# Nutze snake_case für Variablennamen.
 snake_case = true
-```
-### Benutze verständliche Variablennamen
-```
-path_to_project_root = '/good/name/'
-path = '/bad/name/'
-```
-# Symbols (sind auch Objekte)
-Symbols sind unveränderliche, wiederverwendbare Konstanten, welche intern
-als integer repräsentiert werden. Sie werden häufig anstelle von Strings
-verwendet, um sinnvoll Werte zu übermitteln.
-Symbols werden mit dem Doppelpunkt gekennzeichnet.
 
-```
+# Nutze verständliche Variablennamen.
+path_to_project_root = '/guter/Name/'
+m = '/schlechter/Name/'
+
+
+# Symbole sind unveränderliche, wiederverwendbare Konstanten, welche intern
+# als Integer repräsentiert werden. Sie werden häufig anstelle von Strings
+# verwendet, um semantisch sinnvoll Werte zu übermitteln.
+# Symbols werden mit dem Doppelpunkt gekennzeichnet.
+
 :pending.class #=> Symbol
+
 status = :pending
+
 status == :pending #=> true
+
 status == 'pending' #=> false
+
 status == :approved #=> false
-```
+
+# Strings können in Symbole konvertiert werden und umgekehrt.
+status.to_s #=> "pending"
+"argon".to_sym #=> :argon
+
 # Arrays
 
-## Ein Array anlegen
-```
+# Das ist ein Array.
 array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
-```
 
-## Array können verschiedene Typen beinhalten
-```
+# Array können verschiedene Typen beinhalten
 [1, 'hello', false] #=> [1, "hello", false]
-```
 
-## Wie bei arithmetischen Ausdrücken auch wird beim Zugriff auf
-## [0] eigentlich die Methode [] des Array Objekts aufgerufen.
-```
-array.[] 0 #=> 1
-array.[] 12 #=> nil
-```
+## Arrays könnenindiziert werden.
 
-## Arrays können von vorne indiziert werden
-```
+# Von vorne...
 array[0] #=> 1
+array.first #=> 1
 array[12] #=> nil
-```
 
-## Arrays können von hinten indiziert werden
-```
+# ...oder von hinten...
 array[-1] #=> 5
-```
+array.last #=> 5
 
-## Arrays können mit Start Index und Länge indiziert werden
-```
+# ...oder mit einem Startindex und einer Länge...
 array[2, 3] #=> [3, 4, 5]
-```
 
-## Arrays können mit einer Range indiziert werden
-```
+# ...oder mit einem Range...
 array[1..3] #=> [2, 3, 4]
-```
 
-## Einen Wert hinzufügen
-```
+# Du kanns ein Array umkehren.
+# Gib ein neues Array mit umgkehrten Werten zurück
+[1,2,3].reverse #=> [3,2,1]
+
+# Kehre ein Array an Ort und Stelle um, um die Variable mit den 
+# umgekehrten Werten zu aktualisieren.
+a = [1,2,3]
+a.reverse! #=> a==[3,2,1] wegen des Aufrufs von reverse mit Ausrufezeichens ('!')
+
+# Wie bei der Arithmetik, ist Zugriff mit [index] nur 
+# syntaktischer Zucker für den Aufruf der `[]` Methode auf dem Objekt.
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# Du kannst Werte zu einem Array hinzufügen...
 array << 6 #=> [1, 2, 3, 4, 5, 6]
+# Oder so
 array.push(6) #=> [1, 2, 3, 4, 5, 6]
-```
 
-## Testen, ob ein Element schon vorhanden ist
-```
+# ...und testen ob ein Element schon vorhanden ist
 array.include?(1) #=> true
-```
 
-# Hashes
-Hashes sind das Hauptfeature um Key/Values zu speichern
+# Hashes sind Rubys Hauptdatenstruktur for Schlüssel/Wert Paare.
+# Hashes werden durch geschweifte Klammern gekennzeichnet.
+hash = { 'Farbe' => 'grün', 'Nummer' => 5 }
 
-## Ein Hash anlegen
-```
-hash = { 'color' => 'green', 'number' => 5 }
-hash.keys #=> ['color', 'number']
-```
+hash.keys #=> ['farbe', 'nummer']
 
-## Wert per key herausfinden
-```
-hash['color'] #=> 'green'
-hash['number'] #=> 5
-hash['nothing here'] #=> nil
-// Fragen an einen Hash nach einem Schlüssel, der nicht existiert, ruft nil hervor:
-```
+# Hashes can be quickly looked up by key.
+hash['Farbe'] #=> "grün"
+hash['Nummer'] #=> 5
 
-##  Symbols können auch keys sein
-```
-new_hash = { defcon: 3, action: true }
-new_hash.keys #=> [:defcon, :action]
-```
+# Abfragen eines nicht vorhandenen Schlüssels, gibt nil zurück. 
+hash['nicht vorhanden'] #=> nil
 
-## Testen ob ein Key oder ein Value existiert
-```
-new_hash.has_key?(:defcon) #=> true
-new_hash.has_value?(3) #=> true
-```
+# Wenn du Symbole als Schlüssel in einem Hash verwendest, kannst du
+# eine alternative Syntax verwenden.
+hash = { :defcon => 3, :action => true }
+hash.keys #=> [:defcon, :action]
 
-### Tipp:  Arrays und Hashes sind Enumerable
-### Und haben gemeinsame, hilfreiche Methoden wie:
-### each, map, count, and more
+hash = { defcon: 3, action: true }
+hash.keys #=> [:defcon, :action]
+
+# Testen ob ein Schlüssel oder Wert im Hash existiert
+hash.key?(:defcon) #=> true
+hash.value?(3) #=> true
+
+# Tipp: Arrays und Hashes sind Enumerables!
+# Sie haben viele nützliche Methoden gemein, wie each, map, count, und andere.
 
 # Kontrolstrukturen
-## if
-```
+
+# Bedingungen
 if true
-  'if statement'
+  'wenn Bedingung'
 elsif false
-  'else if, optional'
+  'sonst wenn, optional'
 else
-  'else, also optional'
+  'sonst, auch optional'
 end
-```
-## for - Allerdings werden for Schleifen nicht oft vewendet.
-```
-for counter in 1..5
-  puts "iteration #{counter}"
-end
-```
-## Stattdessen: "each" Methode und einen Bloch übergeben
-Ein Block ist ein Codeteil, den man einer Methode übergeben kann
-Ähnelt stark lambdas, anonymen Funktionen oder Closures in anderen
-Programmiersprachen.
 
-```
+# Wenn eine Kontrollstruktur keinen Code-Block, sondern einen einzigen 
+# Ausdruck ausführt, dann kannst du die nachgestellte if-Notation verwenden
+warnings = ['Nachname fehlt', 'Adresse zu kurz']
+puts("Vorhandene Warnungen:\n" + warnings.join("\n"))  if !warnings.empty?
+
+# Formuliere die Bedingung um, wenn sich `unless` besser liest als `if`
+puts("Vorhandene Warnungen:\n" + warnings.join("\n")) unless warnings.empty?
+
+# Schleifen
+# Traditionell ist das Benutzen von `for` Schleifen in Ruby eher unüblich.
+# Stattdessen werden diese mit Hilfe von Enumerables implementiert, was mit
+# dem Aufrufen von `each` einhergeht.
 (1..5).each do |counter|
-  puts "iteration #{counter}"
+  puts "Iteration #{counter}"
+end
+
+# Was in etwa das selbe ist wie Folgendes (selten in Ruby zu sehen).
+for counter in 1..5
+  puts "Iteration #{counter}"
 end
-```
 
-Die each Methode einer Range führt den Block für jedes Element der Range aus.
+# Das `do |variable| ... end` Konstrukt wird `block` genannt. 
+# Blocks sind vergleichbar mit Lambdas, anonymen Funktionen 
+# oder Closures in anderen Programmiersprachen.
+# Sie können als Objekte übergeben, aufgerufen oder als Methoden 
+# zugewiesen werden.
 
-Dem Block wird ein "counter" parameter übergeben.
+# Die `each` Methode eines Ranges führt den Block einmal für jedes 
+# Element des Ranges aus. 
+# Dem Block wird eine counter Variable als Parameter übergeben.
 
-### Den Block kann man auch in geschweiften Klammern schreiben
-```
-(1..5).each { |counter| puts "iteration #{counter}" }
-```
+# Du kannst einen Block auch mit geschweiften Klammern schreiben.
+(1..5).each { |counter| puts "Iteration #{counter}" }
 
-### Each kann auch über den Inhalt von Datenstrukturen iterieren
-```
+# Each kann auch über den Inhalt von Datenstrukturen iterieren.
 array.each do |element|
-  puts "#{element} is part of the array"
+  puts "#{element} is Teil des Arrays"
 end
+
 hash.each do |key, value|
-  puts "#{key} is #{value}"
+  puts "#{key} ist #{value}"
+end
+
+# Um auf den Laufindex zuzugreifen kannst du `each_with_index` verwenden
+# und eine index Variable definieren. 
+array.each_with_index do |element, index|
+  puts "#{element} ist Nummer #{index} im Array"
 end
 
 counter = 1
 while counter <= 5 do
-  puts "iteration #{counter}"
+  puts "Iteration #{counter}"
   counter += 1
 end
-```
+#=> Iteration 1
+#=> Iteration 2
+#=> Iteration 3
+#=> Iteration 4
+#=> Iteration 5
+
+# Es gibt einige andere hilfreiche Schleifenfunktionen in Ruby.
+# Wie etwa 'map', 'reduce', 'inject' und viele andere mehr. 
+# Map zum Beispiel iteriert über das Array, führt für jedes Element 
+# die Anweisungen aus, 
+# die im Block definiert sind und gibt ein völlig neues Array zurück.
+array = [1,2,3,4,5]
+doubled = array.map do |element|
+  element * 2
+end
+puts doubled
+#=> [2,4,6,8,10]
+puts array
+#=> [1,2,3,4,5]
 
-## case
-```
+# Case Konstruct
 grade = 'B'
 
 case grade
 when 'A'
-  puts 'Way to go kiddo'
+  puts 'So wird’s gemacht'
 when 'B'
-  puts 'Better luck next time'
+  puts 'Viel Glück beim nächsten Mal'
 when 'C'
-  puts 'You can do better'
+  puts 'Das kannst du besser'
 when 'D'
-  puts 'Scraping through'
+  puts 'Gerade so durch'
 when 'F'
-  puts 'You failed!'
+  puts 'Durchgefallen!'
 else
-  puts 'Alternative grading system, eh?'
+  puts 'Anderes Bewertungssystem, was?'
 end
-=> "Better luck next time"
-```
+#=> "Viel Glück beim nächsten Mal"
 
-### Case können auch ranges
-```
+# Case kann auch Ranges benutzen
 grade = 82
 case grade
 when 90..100
-  puts 'Hooray!'
+  puts 'Hurra!'
 when 80...90
-  puts 'OK job'
+  puts 'OK gemacht'
 else
-  puts 'You failed!'
+  puts 'Durchgefallen!'
 end
-=> "OK job"
-```
+#=> "OK gemacht"
 
-# Exception handling:
-```
+# Fehlerbehandlung
 begin
-  # code here that might raise an exception
-  raise NoMemoryError, 'You ran out of memory.'
+  # Code der einen Fehler wirft...
+  raise NoMemoryError, 'Dein Speicher ist voll.'
 rescue NoMemoryError => exception_variable
-  puts 'NoMemoryError was raised', exception_variable
+  puts 'NoMemoryError ist aufgetreten', exception_variable
 rescue RuntimeError => other_exception_variable
-  puts 'RuntimeError was raised now'
+  puts 'RuntimeError ist aufgetreten'
 else
-  puts 'This runs if no exceptions were thrown at all'
+  puts 'Das wird ausgeführt, wenn keine Fehler geworfen wurden'
 ensure
-  puts 'This code always runs no matter what'
+  puts 'Dieser Code wird immer ausgeführt, egal was vorher passiert'
 end
-```
-# Funktionen
-```
+
+# Methoden
+
 def double(x)
   x * 2
 end
-```
-## Funktionen (und Blocks)
-## geben implizit den Wert des letzten Statements zurück
-```
+
+# Methoden (und Blocks) geben implizit den Wert des letzten Anweisung zurück.
 double(2) #=> 4
-```
 
-### Klammern sind optional wenn das Ergebnis nicht mehrdeutig ist
-```
+# Klammern sind optional wenn die Anweisung dadurch nicht mehrdeutig wird.
 double 3 #=> 6
+
 double double 3 #=> 12
+
 def sum(x, y)
   x + y
 end
-```
 
-### Methoden Parameter werden per Komma getrennt
-```
+# Die Argumente einer Methode werden durch ein Komma getrennt.
 sum 3, 4 #=> 7
+
 sum sum(3, 4), 5 #=> 12
-```
 
-## yield
-### Alle Methoden haben einen impliziten, optionalen block Parameter
-### Dieser wird mit dem Schlüsselword "yield" aufgerufen
-```
+# yield
+# Alle Methoden haben implizit einen optionalen block Parameter.
+# Dieser kann durch das Schlüsselwort 'yield' ausgeführt werden.
 def surround
   puts '{'
   yield
   puts '}'
 end
-surround { puts 'hello world' }
-```
 
-## Einen Block kann man auch einer Methoden übergeben
-### "&" kennzeichnet die Referenz zum übergebenen Block
-```
+surround { puts 'hallo Welt' }
+
+#=> {
+#=> hallo Welt
+#=> }
+
+# Blocks können in ein 'Proc' Objekt umgewandelt werden. 
+# Dieses ist eine Art Container um den Block und erlaubt ihn an eine 
+# andere Methode zu übergeben, ihn in einen anderen Gültigkeitsbereicht 
+# einzubinden oder ihn andersweitig zu verändern.
+# Am häufigsten findet man dies bei Parameterlisten von Methoden, in Form 
+# eines letzten '&block' Parameters, der den Block – wenn es einen gibt – 
+# entgegen nimmt und ihn in ein 'Proc' umwandelt. Die Benennung '&block' ist 
+# hier nur eine Konvention; es würde genauso mit '&pineapple' funktionieren. 
 def guests(&block)
-  block.call 'some_argument'
+  block.class #=> Proc
+  block.call(4)
 end
-```
 
-### Eine Liste von Parametern kann man auch übergeben,
-### Diese wird in ein Array konvertiert
-### "*" kennzeichnet dies.
-```
+# Die 'call' Methode eines Proc ist ganz ähnlich zum Aufruf von 'yield', wenn 
+# ein Block vorhanden ist. Die Argumente, die 'call' übergeben werden, werden 
+# als Argumente and den Block weitergereicht.
+
+guests { |n| "Du hast #{n} Gäste." }
+# => "Du hast 4 Gäste."
+
+# Du kannst eine Liste von Argumenten übergeben, die dann in ein Array 
+# umgewandelt werden. Dafür gibt es den splat-Operator (`*`).
 def guests(*array)
   array.each { |guest| puts guest }
 end
-```
+
+# Destrukturierung
+
+# Ruby destrukturiert Arrays automatisch beim Zuweisen mehrerer Variablen.
+a, b, c = [1, 2, 3]
+a #=> 1
+b #=> 2
+c #=> 3
+
+# In manchen Fällen will man den splat-Operator (`*`) verwenden um ein Array in
+# eine Liste zu destrukturieren.
+ranked_competitors = ["John", "Sally", "Dingus", "Moe", "Marcy"]
+
+def best(first, second, third)
+  puts "Gewinner sind #{first}, #{second} und #{third}."
+end
+
+best *ranked_competitors.first(3) #=> Gewinner sind John, Sally and Dingus.
+
+# Der splat-Operator kann auch in Parametern verwendet werden.
+def best(first, second, third, *others)
+  puts "Gewinner sind #{first}, #{second} und #{third}."
+  puts "Es gab #{others.count} andere Teilnehmer."
+end
+
+best *ranked_competitors 
+#=> Gewinner sind John, Sally und Dingus.
+#=> Es gab 2 andere Teilnehmer.
+
+# Per Konvention enden alle Methoden, die einen Wahrheitswert zurück geben, mit einem
+# Fragezeichen.
+5.even? #=> false
+5.odd? #=> true
+
+# Wenn ein Methodenname mit einem Ausrufezeichen endet, dann tut diese Methode 
+# per Konvention etwas Destruktives, wie z.B. das aufrufende Objekt zu 
+# verändern.
+# Viele Mehtoden haben eine !-Version um eine direkte Änderung zu machen und 
+# eine Nicht-!-Version, die ein neues Objekt mit den Veränderungen zurück gibt.
+company_name = "Dunder Mifflin"
+company_name.upcase #=> "DUNDER MIFFLIN"
+company_name #=> "Dunder Mifflin"
+# Diesmal verändern wir company_name direkt.
+company_name.upcase! #=> "DUNDER MIFFLIN"
+company_name #=> "DUNDER MIFFLIN"
+
 # Klassen
-## Werden mit dem class Schlüsselwort definiert
-```
+
+# Du kannst eine Klasse mit dem Schlüsselwort 'class' definieren.
 class Human
-```
 
-### Konstruktor bzw. Initializer
-```
+  # Eine Klassenvariable. Sie wird von allen Instanzen einer Klasse geteilt.
+  @@species = 'H. sapiens'
+
+  # Konstruktor bzw. Initializer
   def initialize(name, age = 0)
-    # Assign the argument to the "name" instance variable for the instance
+    # Weise das Argument der Instanzvariable 'name' zu.
     @name = name
-    # If no age given, we will fall back to the default in the arguments list.
+    # Wenn kein 'age' angegeben wurde wird der Standartwert aus der Argumentenlist verwendet.
     @age = age
   end
-```
 
-### setter Methode
-```
+  # Setter Methode
   def name=(name)
     @name = name
   end
-```
-### getter Methode
-```
+
+  # Getter Methode
   def name
     @name
   end
-```
 
-#### getter können mit der attr_accessor Methode vereinfacht definiert werden
-```
+  # Getter & Setter können auch kürzer mit der attr_accessor Methode erstellt werden.
   attr_accessor :name
-  # Getter/setter methods can also be created individually like this
+
+  # Getter & Setter Methoden können auch einzeln erstellt werden.
   attr_reader :name
   attr_writer :name
-  # A class method uses self to distinguish from instance methods.
-  # It can only be called on the class, not an instance.
+
+  # Eine Klassenmethode unterscheidet sich durch ein 'self' von einer 
+  # Instanzmethode.
+  # Sie kann nur auf der Klasse und nicht auf einer Instanz der Klasse 
+  # aufgerufen werden.  
   def self.say(msg)
     puts msg
   end
+
   def species
     @@species
   end
 end
-```
 
-## Eine Klasse instanziieren
-```
+# Instanziieren einer Klasse
 jim = Human.new('Jim Halpert')
 dwight = Human.new('Dwight K. Schrute')
-```
 
-## Methodenaufrufe
-```
+# Du kannst die Methoden des erstellten Objekts 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"
-```
 
-## Eine Klassenmethode aufrufen
-```
+# Aufrufen einer Klassenmethode
 Human.say('Hi') #=> "Hi"
-```
 
-## Variable Gültigkeit
-### Variablen die mit "$" starten, gelten global
-```
-$var = "I'm a global var"
+# Der Gültigkeitsbereich einer Variablen wird durch ihren Namen definiert.
+# Variablen, die mit $ beginnen sind global gültig.
+$var = "Ich bin eine globale Variable"
 defined? $var #=> "global-variable"
-```
 
-### Variablen die mit "@" starten, gelten für die Instanz
-```
-@var = "I'm an instance var"
+# Variablen, die mit @ beginnen, sind innerhalb einer Instanz gültig.
+@var = "Ich bin eine Instanzvariable"
 defined? @var #=> "instance-variable"
-```
 
-### Variablen die mit "@@" starten, gelten für die Klasse
-```
-@@var = "I'm a class var"
+# Variablen, die mit @@ beginnen, sind für die Klasse gültig.
+@@var = "Ich bin eine Klassenvariable"
 defined? @@var #=> "class variable"
-```
 
-### Variablen die mit einem Großbuchstaben anfangen, sind Konstanten
-```
-Var = "I'm a constant"
+# Variablen, die mit einem Großbuchstaben beginnen, sind Konstanten
+Var = "Ich bin eine Konstante"
 defined? Var #=> "constant"
-```
 
-## Class ist auch ein Objekt
-### Hat also auch Instanzvariablen
-### Eine Klassenvariable wird innerhalb der Klasse und Ableitungen geteilt.
+# Class ist in Ruby auch ein Objekt. Deshalb kann eine Klasse Instanzvariablen
+# haben. Eine Klassenvariable wird zwischen der Klasse und all ihren 
+# Ableitungen geteilt.
 
-### Basis Klasse
-```
+# Basis Klasse
 class Human
   @@foo = 0
+
   def self.foo
     @@foo
   end
+
   def self.foo=(value)
     @@foo = value
   end
 end
-```
 
-### Abgeleitete Klasse
-```
+# Abgeleitete Klasse
 class Worker < Human
 end
-Human.foo # 0
-Worker.foo # 0
-Human.foo = 2 # 2
-Worker.foo # 2
-```
 
-### Eine Klasseninstanzvariable wird nicht geteilt
-```
+Human.foo #=> 0
+Worker.foo #=> 0
+
+Human.foo = 2
+Worker.foo #=> 2
+
+# Ableitungen einer Klasse haben keinen Zugriff auf eine Eine Klassen-Instanzvariable.
 class Human
   @bar = 0
+
   def self.bar
     @bar
   end
+
   def self.bar=(value)
     @bar = value
   end
 end
-```
-```
+
 class Doctor < Human
 end
-```
-```
-Human.bar # 0
-Doctor.bar # nil
-```
-```
+
+Human.bar #=> 0
+Doctor.bar #=> nil
+
 module ModuleExample
   def foo
     'foo'
   end
 end
-```
-### Module einbinden, heisst ihre Methoden an die Instanzen der Klasse zu binden
-### Module erweitern, heisst ihre Mothden an die Klasse selbst zu binden
-```
+
+# Ein Einbinden (include) eines Moduls bindet seine Methoden an die Instanzen 
+# der Klasse.
+# Ein Erweitern (extend) eines Moduls bindet seine Methoden an die Klasse 
+# selbst.
 class Person
   include ModuleExample
 end
-```
-```
+
 class Book
   extend ModuleExample
 end
-```
-```
-Person.foo     # => NoMethodError: undefined method `foo' for Person:Class
-Person.new.foo # => 'foo'
-Book.foo       # => 'foo'
-Book.new.foo   # => NoMethodError: undefined method `foo'
-```
-### Callbacks werden ausgeführt, wenn ein Modul eingebunden oder erweitert wird
-```
-  module ConcernExample
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.send(:include, InstanceMethods)
-    end
-    module ClassMethods
-      def bar
-        'bar'
-      end
-    end
-    module InstanceMethods
-      def qux
-        'qux'
-      end
+
+Person.foo     #=> NoMethodError: undefined method `foo' for Person:Class
+Person.new.foo #=> "foo"
+Book.foo       #=> "foo"
+Book.new.foo   #=> NoMethodError: undefined method `foo'
+
+
+# Callbacks werden ausgeführt, wenn ein Modul eingebunden oder erweitert wird.
+module ConcernExample
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+
+  module ClassMethods
+    def bar
+      'bar'
     end
   end
-  class Something
-    include ConcernExample
+
+  module InstanceMethods
+    def qux
+      'qux'
+    end
   end
-```
-```
-Something.bar     # => 'bar'
-Something.qux     # => NoMethodError: undefined method `qux'
-Something.new.bar # => NoMethodError: undefined method `bar'
-Something.new.qux # => 'qux'
+end
+
+class Something
+  include ConcernExample
+end
+
+Something.bar     #=> "bar"
+Something.qux     #=> NoMethodError: undefined method `qux'
+Something.new.bar #=> NoMethodError: undefined method `bar'
+Something.new.qux #=> "qux"
 ```
 
-## Weiterführende Hinweise
+## Weitere Links
 
-//EN
+_(z.T. auf Englisch)_
 
-- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
-- [Official Documentation](http://www.ruby-doc.org/core-2.1.1/)
+- [Offizielle Ruby Website](https://www.ruby-lang.org/de/)
+- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - Eine Variante dieses Dokuments mit in-Browser Challenges.
+- [RubyMonk](https://rubymonk.com/) - Lerne Ruby mit einer Reihe interaktiver Tutorials.
+- [Offizielle Dokumentation](http://ruby-doc.org/core)
 - [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/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
-- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
+- [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.
diff --git a/el-gr/vim-gr.html.markdown b/el-gr/vim-gr.html.markdown
index 42ba3739..679a5488 100644
--- a/el-gr/vim-gr.html.markdown
+++ b/el-gr/vim-gr.html.markdown
@@ -4,6 +4,7 @@ tool: vim
 contributors:
     - ["RadhikaG", "https://github.com/RadhikaG"]
 filename: LearnVim.txt
+lang: el-gr
 ---
 
 
diff --git a/elixir.html.markdown b/elixir.html.markdown
index 0b717ca6..0226ecaf 100644
--- a/elixir.html.markdown
+++ b/elixir.html.markdown
@@ -457,3 +457,4 @@ Agent.update(my_agent, fn colors -> ["blue" | colors] end)
 * [Elixir Cheat Sheet](https://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
 * ["Learn You Some Erlang for Great Good!"](https://learnyousomeerlang.com/) by Fred Hebert
 * ["Programming Erlang: Software for a Concurrent World"](https://pragprog.com/book/jaerlang2/programming-erlang) by Joe Armstrong
+* [Introduction to Elixir](https://learn-elixir.com/)
diff --git a/git.html.markdown b/git.html.markdown
index aa96c90a..a40ef01b 100644
--- a/git.html.markdown
+++ b/git.html.markdown
@@ -82,12 +82,12 @@ pushed to other repositories, or not!
 ### Branch
 
 A branch is essentially a pointer to the last commit you made. As you go on
-committing, this pointer will automatically update to point the latest commit.
+committing, this pointer will automatically update to point to the latest commit.
 
 ### Tag
 
 A tag is a mark on specific point in history. Typically people use this
-functionality to mark release points (v1.0, and so on)
+functionality to mark release points (v1.0, and so on).
 
 ### HEAD and head (component of .git dir)
 
diff --git a/matlab.html.markdown b/matlab.html.markdown
index 5790bcc6..4ca31857 100644
--- a/matlab.html.markdown
+++ b/matlab.html.markdown
@@ -234,7 +234,7 @@ A'  % Concise version of complex transpose
 % On their own, the arithmetic operators act on whole matrices. When preceded
 % by a period, they act on each element instead. For example:
 A * B % Matrix multiplication
-A .* B % Multiple each element in A by its corresponding element in B
+A .* B % Multiply each element in A by its corresponding element in B
 
 % There are several pairs of functions, where one acts on each element, and
 % the other (whose name ends in m) acts on the whole matrix.
diff --git a/nl-nl/json-nl.html.markdown b/nl-nl/json-nl.html.markdown
index 906112ff..d243802d 100644
--- a/nl-nl/json-nl.html.markdown
+++ b/nl-nl/json-nl.html.markdown
@@ -5,26 +5,27 @@ contributors:
   - ["Anna Harren", "https://github.com/iirelu"]
   - ["Marco Scannadinari", "https://github.com/marcoms"]
   - ["himanshu", "https://github.com/himanshu81494"]
+  - ["Maarten Jacobs", "https://github.com/maartenJacobs"]
 translators:
   - ["Niels van Velzen", "https://nielsvanvelzen.me"]
 lang: nl-nl
 ---
 
-Gezien JSON een zeer eenvouding formaat heeft zal dit een van de simpelste
+Gezien JSON een zeer eenvouding formaat heeft zal dit één van de simpelste
 Learn X in Y Minutes ooit zijn.
 
-JSON heeft volgens de specificaties geen commentaar, ondanks dat hebben de
+JSON heeft volgens de specificaties geen commentaar. Ondanks dat hebben de
 meeste parsers support voor C-stijl (`//`, `/* */`) commentaar.
 Sommige parsers staan zelfs trailing komma's toe.
-(Een komma na het laatste element in een array of ahter de laatste eigenshap van een object).
-Het is wel beter om dit soort dingen te vermijden omdat het niet overal zal werken.
+(Een komma na het laatste element in een array of achter de laatste eigenschap van een object).
+Het is wel beter om dit soort dingen te vermijden omdat het niet in elke parser zal werken.
 
 In het voorbeeld zal alleen 100% geldige JSON gebruikt worden.
 
 Data types gesupport door JSON zijn: nummers, strings, booleans, arrays, objecten en null.
 Gesupporte browsers zijn: Firefox(Mozilla) 3.5, Internet Explorer 8, Chrome, Opera 10, Safari 4.
-De extensie voor JSON bestanden is ".json". De MIME type is "application/json"
-Enkele nadelen van JSON zijn het gebrek een type definities en een manier van DTD.
+De extensie voor JSON bestanden is ".json". De MIME type is "application/json".
+Enkele nadelen van JSON zijn het gebrek aan type definities en een manier van DTD.
 
 ```json
 {
diff --git a/p5.html.markdown b/p5.html.markdown
index be22d3e5..f6084b98 100644
--- a/p5.html.markdown
+++ b/p5.html.markdown
@@ -7,7 +7,7 @@ contributors:
 filename: p5.js
 ---
 
-p5.js is a JavaScript library that starts with the original goal of [Processing](http://processing.org"), to make coding accessible for artists, designers, educators, and beginners, and reinterprets this for today's web.
+p5.js is a JavaScript library that starts with the original goal of [Processing](https://processing.org), to make coding accessible for artists, designers, educators, and beginners, and reinterprets this for today's web.
 Since p5 is a JavaScript library, you should learn [Javascript](https://learnxinyminutes.com/docs/javascript/) first.
 
 ```js
diff --git a/php.html.markdown b/php.html.markdown
index d4103e97..e1411085 100644
--- a/php.html.markdown
+++ b/php.html.markdown
@@ -41,12 +41,15 @@ Hello World Again!
  */
 
 // Variables begin with the $ symbol.
-// A valid variable name starts with a letter or underscore,
+// A valid variable name starts with a letter or an underscore,
 // followed by any number of letters, numbers, or underscores.
 
+// You don't have to (and cannot) declare variables.
+// Once you assign a value, PHP will create the variable with the right type.
+
 // Boolean values are case-insensitive
 $boolean = true;  // or TRUE or True
-$boolean = false; // or FALSE or False
+$boolean = FALSE; // or false or False
 
 // Integers
 $int1 = 12;   // => 12
diff --git a/powershell.html.markdown b/powershell.html.markdown
index 5d74024d..6efd984c 100644
--- a/powershell.html.markdown
+++ b/powershell.html.markdown
@@ -55,6 +55,11 @@ The tutorial starts here:
 ```powershell
 # As you already figured, comments start with #
 
+<#
+  Multi-line comments
+  like so
+#>
+
 # Simple hello world example:
 echo Hello world!
 # echo is an alias for Write-Output (=cmdlet)
@@ -68,6 +73,8 @@ $aString="Some string"
 # Or like this:
 $aNumber = 5 -as [double]
 $aList = 1,2,3,4,5
+# Reverse an array *Note this is a mutation on the existing array
+[array]::Reverse($aList)
 $anEmptyList = @()
 $aString = $aList -join '--' # yes, -split exists also
 $aHashtable = @{name1='val1'; name2='val2'}
@@ -100,6 +107,10 @@ echo "Bound arguments in a function, script or code block: $PSBoundParameters"
 echo "Unbound arguments: $($Args -join ', ')."
 # More builtins: `help about_Automatic_Variables`
 
+# Find the datatype of variables or properties you're working with
+$true.GetType()
+$aHashtable.name2.GetType()
+
 # Inline another file (dot operator)
 . .\otherScriptName.ps1
 
@@ -184,7 +195,7 @@ Get-Process | Sort-Object ID -Descending | Select-Object -First 10 Name,ID,VM `
 Get-EventLog Application -After (Get-Date).AddHours(-2) | Format-List
 
 # Use % as a shorthand for ForEach-Object
-(a,b,c) | ForEach-Object `
+('a','b','c') | ForEach-Object `
 	-Begin { "Starting"; $counter = 0 } `
 	-Process { "Processing $_"; $counter++ } `
 	-End { "Finishing: $counter" }
@@ -198,12 +209,13 @@ ps | Format-Table ID,Name,@{n='VM(MB)';e={'{0:n2}' -f ($_.VM / 1MB)}} -autoSize
 
 ### Functions
 # The [string] attribute is optional.
-function foo([string]$name) {
+# Function names should follow Verb-Noun convention
+function Get-Foo([string]$name) {
 	echo "Hey $name, have a function"
 }
 
 # Calling your function
-foo "Say my name"
+Get-Foo "Say my name"
 
 # Functions with named parameters, parameter attributes, parsable documentation
 <#
@@ -283,7 +295,22 @@ Pop-Location # change back to previous working directory
 # Unblock a directory after download
 Get-ChildItem -Recurse | Unblock-File
 
+# You can also pass arguments to a Function with a hash table
+# This is called Splatting
+# Normal Command
+Export-Csv -InputObject $csv -Path 'c:\mypath' -Encoding UTF8 -NoTypeInformation
+# With Splatting
+$csvArguments = @{
+    InputObject = $csv
+    Path = 'c:\mypath'
+    Encoding = 'UTF8'
+    NoTypeInformation = $true
+}
+Export-Csv @csvArguments
+
 # Open Windows Explorer in working directory
+Invoke-Item .
+# Or the alias
 ii .
 
 # Any key to exit
@@ -318,6 +345,7 @@ Interesting Projects
 * [PSGet](https://github.com/psget/psget) NuGet for PowerShell
 * [PSReadLine](https://github.com/lzybkr/PSReadLine/) A bash inspired readline implementation for PowerShell (So good that it now ships with Windows10 by default!)
 * [Posh-Git](https://github.com/dahlbyk/posh-git/) Fancy Git Prompt (Recommended!)
+* [Oh-My-Posh](https://github.com/JanDeDobbeleer/oh-my-posh) Shell customization similar to the popular Oh-My-Zsh on Mac
 * [PSake](https://github.com/psake/psake) Build automation tool
 * [Pester](https://github.com/pester/Pester) BDD Testing Framework
 * [Jump-Location](https://github.com/tkellogg/Jump-Location) Powershell `cd` that reads your mind
diff --git a/python.html.markdown b/python.html.markdown
index 53303442..44ed7ed9 100644
--- a/python.html.markdown
+++ b/python.html.markdown
@@ -132,7 +132,7 @@ b == a            # => True, a's and b's objects are equal
 "Hello " "world!"    # => "Hello world!"
 
 # A string can be treated like a list of characters
-"This is a string"[0]  # => 'T'
+"Hello world!"[0]  # => 'H'
 
 # You can find the length of a string
 len("This is a string")  # => 16
diff --git a/rst.html.markdown b/rst.html.markdown
index 2423622e..bdc73c7a 100644
--- a/rst.html.markdown
+++ b/rst.html.markdown
@@ -49,9 +49,11 @@ Subtitles with dashes
 
 You can put text in *italic* or in **bold**, you can "mark" text as code with double backquote ``print()``.
 
+Special characters can be escaped using a backslash, e.g. \\ or \*.
+
 Lists are similar to Markdown, but a little more involved.
 
-Remember to line up list symbols (like - or *) with the left edge of the previous text block, and remember to use blank lines to separate new lists from parent lists:    
+Remember to line up list symbols (like - or \*) with the left edge of the previous text block, and remember to use blank lines to separate new lists from parent lists:    
 
 - First item
 - Second item
@@ -86,7 +88,7 @@ There are multiple ways to make links:
 - By typing a full comprehensible URL : https://github.com/ (will be automatically converted to a link)
 - By making a more Markdown-like link: `Github <https://github.com/>`_ .
 
-.. _Github https://github.com/
+.. _Github: https://github.com/
 
 ```
 
diff --git a/ru-ru/ruby-ru.html.markdown b/ru-ru/ruby-ru.html.markdown
index b1fd04e1..8b263be6 100644
--- a/ru-ru/ruby-ru.html.markdown
+++ b/ru-ru/ruby-ru.html.markdown
@@ -480,7 +480,7 @@ class Human
     @name
   end
 
-  # Тоже самое можно определить с помощью att_accessor
+  # Тоже самое можно определить с помощью attr_accessor
   attr_accessor :name
 
   # Также можно создать методы только для записи или чтения
diff --git a/ruby.html.markdown b/ruby.html.markdown
index 376f4a47..d21c727f 100644
--- a/ruby.html.markdown
+++ b/ruby.html.markdown
@@ -430,6 +430,16 @@ def guests(*array)
   array.each { |guest| puts guest }
 end
 
+# There is also the shorthand block syntax. It's most useful when you need
+# to call a simple method on all array items.
+upcased = ['Watch', 'these', 'words', 'get', 'upcased'].map(&:upcase)
+puts upcased
+#=> ["WATCH", "THESE", "WORDS", "GET", "UPCASED"]
+ 
+sum = [1, 2, 3, 4, 5].reduce(&:+)
+puts sum
+#=> 15
+
 # Destructuring
 
 # Ruby will automatically destructure arrays on assignment to multiple variables.
diff --git a/set-theory.html.markdown b/set-theory.html.markdown
index 988c4397..c6bc39c5 100644
--- a/set-theory.html.markdown
+++ b/set-theory.html.markdown
@@ -29,11 +29,13 @@ These operators don't require a lot of text to describe.
 * `Z`, the set of all integers. `{…,-2,-1,0,1,2,…}`
 * `Q`, the set of all rational numbers.
 * `R`, the set of all real numbers.
+
 ### The empty set
 * The set containing no items is called the empty set. Representation: `∅`
 * The empty set can be described as `∅ = {x|x ≠ x}`
 * The empty set is always unique.
 * The empty set is the subset of all sets.
+
 ```
 A = {x|x∈N,x < 0}
 A = ∅
@@ -42,6 +44,7 @@ A = ∅
 |∅|   = 0
 |{∅}| = 1
 ```
+
 ## Representing sets
 ### Enumeration
 * List all items of the set, e.g. `A = {a,b,c,d}`
@@ -49,6 +52,7 @@ A = ∅
 
 ### Description
 * Describes the features of all items in the set. Syntax: `{body|condtion}`
+
 ```
 A = {x|x is a vowel}
 B = {x|x ∈ N, x < 10l}
@@ -84,6 +88,7 @@ C = {2x|x ∈ N}
 * The number of items in a set is called the base number of that set. Representation: `|A|`
 * If the base number of the set is finite, this set is a finite set.
 * If the base number of the set is infinite, this set is an infinite set.
+
 ```
 A   = {A,B,C}
 |A| = 3
@@ -94,6 +99,7 @@ B   = {a,{b,c}}
 
 ### Powerset
 * Let `A` be any set. The set that contains all possible subsets of `A` is called a powerset (written as `P(A)`).
+
 ```
 P(A) = {x|x ⊆ A}
 
@@ -103,41 +109,54 @@ P(A) = {x|x ⊆ A}
 ## Set operations among two sets
 ### Union
 Given two sets `A` and `B`, the union of the two sets are the items that appear in either `A` or `B`, written as `A ∪ B`.
+
 ```
 A ∪ B = {x|x∈A∨x∈B}
 ```
+
 ### Intersection
 Given two sets `A` and `B`, the intersection of the two sets are the items that appear in both `A` and `B`, written as `A ∩ B`.
+
 ```
 A ∩ B = {x|x∈A,x∈B}
 ```
+
 ### Difference
 Given two sets `A` and `B`, the set difference of `A` with `B` is every item in `A` that does not belong to `B`.
+
 ```
 A \ B = {x|x∈A,x∉B}
 ```
+
 ### Symmetrical difference
 Given two sets `A` and `B`, the symmetrical difference is all items among `A` and `B` that doesn't appear in their intersections.
+
 ```
 A △ B = {x|(x∈A∧x∉B)∨(x∈B∧x∉A)}
 
 A △ B = (A \ B) ∪ (B \ A)
 ```
+
 ### Cartesian product
 Given two sets `A` and `B`, the cartesian product between `A` and `B` consists of a set containing all combinations of items of `A` and `B`.
+
 ```
 A × B = { {x, y} | x ∈ A, y ∈ B }
 ```
+
 ## "Generalized" operations
 ### General union
 Better known as "flattening" of a set of sets.
+
 ```
 ∪A = {x|X∈A,x∈X}
 ∪A={a,b,c,d,e,f}
 ∪B={a}
 ∪C=a∪{c,d}
 ```
+
 ### General intersection
+
 ```
 ∩ A = A1 ∩ A2 ∩ … ∩ An
 ```
diff --git a/smalltalk.html.markdown b/smalltalk.html.markdown
index d6d369cc..58dccae4 100644
--- a/smalltalk.html.markdown
+++ b/smalltalk.html.markdown
@@ -388,7 +388,7 @@ y := $A max: $B.
 ```smalltalk
 | b x y |
 x := #Hello.                                      "symbol assignment"
-y := 'String', 'Concatenation'.                   "symbol concatenation (result is string)"
+y := #Symbol, #Concatenation.                     "symbol concatenation (result is string)"
 b := x isEmpty.                                   "test if symbol is empty"
 y := x size.                                      "string size"
 y := x at: 2.                                     "char at location"
diff --git a/vim.html.markdown b/vim.html.markdown
index 65efc25c..27d90f18 100644
--- a/vim.html.markdown
+++ b/vim.html.markdown
@@ -182,6 +182,7 @@ A few important examples of 'Verbs', 'Modifiers', and 'Nouns':
     ~                # Toggle letter case of selected text
     u                # Selected text to lower case
     U                # Selected text to upper case
+    J                # Join the current line with the next line
     
     # Fold text
     zf               # Create fold from selected text