[ruby/de] Update to be in sync with English version

1 files changed, 429 insertions, 353 deletions

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.