summaryrefslogtreecommitdiffhomepage
path: root/de-de
diff options
context:
space:
mode:
Diffstat (limited to 'de-de')
-rw-r--r--de-de/latex-de.html.markdown235
-rw-r--r--de-de/ruby-de.html.markdown613
-rw-r--r--de-de/ruby-ecosystem-de.html.markdown149
-rw-r--r--de-de/scala-de.html.markdown816
4 files changed, 1813 insertions, 0 deletions
diff --git a/de-de/latex-de.html.markdown b/de-de/latex-de.html.markdown
new file mode 100644
index 00000000..2c18b8fd
--- /dev/null
+++ b/de-de/latex-de.html.markdown
@@ -0,0 +1,235 @@
+---
+language: latex
+contributors:
+ - ["Chaitanya Krishna Ande", "http://icymist.github.io"]
+ - ["Colton Kohnke", "http://github.com/voltnor"]
+ - ["Sricharan Chiruvolu", "http://sricharan.xyz"]
+translators:
+ - ["Moritz Kammerer", "https://github.com/phxql"]
+lang: de-de
+filename: latex-de.tex
+---
+```
+% Alle Kommentare starten fangen mit % an
+% Es gibt keine Kommentare über mehrere Zeilen
+
+% LateX ist keine "What You See Is What You Get" Textverarbeitungssoftware wie z.B.
+% MS Word oder OpenOffice Writer
+
+% Jedes LateX-Kommando startet mit einem Backslash (\)
+
+% LateX-Dokumente starten immer mit der Definition des Dokuments, die sie darstellen
+% Weitere Dokumententypen sind z.B. book, report, presentations, etc.
+% Optionen des Dokuments stehen zwischen den eckigen Klammern []. In diesem Fall
+% wollen wir einen 12 Punkte-Font verwenden.
+\documentclass[12pt]{article}
+
+% Als nächstes definieren wir die Pakete, die wir verwenden wollen.
+% Wenn du z.B. Grafiken, farbigen Text oder Quelltext in dein Dokument einbetten möchtest,
+% musst du die Fähigkeiten von Latex durch Hinzufügen von Paketen erweitern.
+% Wir verwenden die Pakete float und caption für Bilder.
+\usepackage{caption}
+\usepackage{float}
+
+% Mit diesem Paket können leichter Umlaute getippt werden
+\usepackage[utf8]{inputenc}
+
+% Es können durchaus noch weitere Optione für das Dokument gesetzt werden!
+\author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu}
+\date{\today}
+\title{Learn LaTeX in Y Minutes!}
+
+% Nun kann's losgehen mit unserem Dokument.
+% Alles vor dieser Zeile wird die Preamble genannt.
+\begin{document}
+% Wenn wir den Autor, das Datum und den Titel gesetzt haben, kann
+% LateX für uns eine Titelseite generieren
+\maketitle
+
+% Die meisten Paper haben ein Abstract. LateX bietet dafür einen vorgefertigen Befehl an.
+% Das Abstract sollte in der logischen Reihenfolge, also nach dem Titel, aber vor dem
+% Inhalt erscheinen.
+% Dieser Befehl ist in den Dokumentenklassen article und report verfügbar.
+\begin{abstract}
+ LateX documentation geschrieben in LateX! Wie ungewöhnlich und garantiert nicht meine Idee!
+\end{abstract}
+
+% Section Befehle sind intuitiv.
+% Alle Titel der sections werden automatisch in das Inhaltsverzeichnis übernommen.
+\section{Einleitung}
+Hi, mein Name ist Moritz und zusammen werden wir LateX erforschen!
+
+\section{Noch eine section}
+Das hier ist der Text für noch eine section. Ich glaube, wir brauchen eine subsection.
+
+\subsection{Das ist eine subsection} % Subsections sind auch ziemlich intuitiv.
+Ich glaube, wir brauchen noch eine.
+
+\subsubsection{Pythagoras}
+So ist's schon viel besser.
+\label{subsec:pythagoras}
+
+% Wenn wir den Stern nach section schreiben, dann unterdrückt LateX die Nummerierung.
+% Das funktioniert auch bei anderen Befehlen.
+\section*{Das ist eine unnummerierte section}
+Es müssen nicht alle sections nummeriert sein!
+
+\section{Ein paar Notizen}
+LateX ist ziemlich gut darin, Text so zu platzieren, dass es gut aussieht.
+Falls eine Zeile \\ mal \\ woanders \\ umgebrochen \\ werden \\ soll, füge
+\textbackslash\textbackslash in den Code ein.\\
+
+\section{Listen}
+Listen sind eine der einfachsten Dinge in LateX. Ich muss morgen einkaufen gehen,
+also lass uns eine Einkaufsliste schreiben:
+\begin{enumerate} % Dieser Befehl erstellt eine "enumerate" Umgebung.
+ % \item bringt enumerate dazu, eins weiterzuzählen.
+ \item Salat.
+ \item 27 Wassermelonen.
+ \item einen Hasen.
+ % Wir können die Nummer des Eintrags durch [] überschreiben
+ \item[Wie viele?] Mittelgroße Wasserpistolen.
+
+ Kein Listeneintrag, aber immer noch Teil von enumerate.
+
+\end{enumerate} % Alle Umgebungen müssen ein end haben.
+
+\section{Mathe}
+
+Einer der Haupteinsatzzwecke von LateX ist das Schreiben von akademischen
+Artikeln oder Papern. Meistens stammen diese aus dem Bereich der Mathe oder
+anderen Wissenschaften. Und deswegen müssen wir in der Lage sein, spezielle
+Symbole zu unserem Paper hinzuzufügen! \\
+
+Mathe kennt sehr viele Symbole, viel mehr als auf einer Tastatur zu finden sind;
+Symbole für Mengen und relationen, Pfeile, Operatoren und Griechische Buchstaben,
+um nur ein paar zu nennen.\\
+
+Mengen und Relationen spielen eine sehr wichtige Rolle in vielen mathematischen
+Papern. So schreibt man in LateX, dass alle y zu X gehören: $\forall$ y $\in$ X. \\
+
+% Achte auf die $ Zeichen vor und nach den Symbolen. Wenn wir in LateX schreiben,
+% geschieht dies standardmäßig im Textmodus. Die Mathe-Symbole existieren allerdings
+% nur im Mathe-Modus. Wir können den Mathe-Modus durch das $ Zeichen aktivieren und
+% ihn mit $ wieder verlassen. Variablen können auch im Mathe-Modus angezeigt werden.
+
+Mein Lieblingsbuchstabe im Griechischen ist $\xi$. Ich mag auch $\beta$, $\gamma$ und $\sigma$.
+Bis jetzt habe ich noch keinen griechischen Buchstaben gefunden, den LateX nicht kennt!
+
+Operatoren sind ebenfalls wichtige Bestandteile von mathematischen Dokumenten:
+Trigonometrische Funktionen ($\sin$, $\cos$, $\tan$),
+Logarithmus und Exponenten ($\log$, $\exp$),
+Grenzwerte ($\lim$), etc. haben vordefinierte Befehle.
+Lass uns eine Gleichung schreiben: \\
+
+$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$\\
+
+Brüche (Zähler / Nenner) können so geschrieben werden:
+
+% 10 / 7
+$^{10}/_{7}$
+
+% Komplexere Brüche können so geschrieben werden:
+% \frac{Zähler}{Nenner}
+$\frac{n!}{k!(n - k)!}$ \\
+
+Wir können Gleichungen auch in einer equation Umgebung verwenden.
+
+% Dies zeigt Mathe in einer equation Umgebung an
+\begin{equation} % Aktiviert automatisch den Mathe-Modus.
+ c^2 = a^2 + b^2.
+ \label{eq:pythagoras} % Pythagoras referenzieren
+\end{equation} % Alle \begin Befehle müssen einen \end Befehl besitzen
+
+Wir können nun unsere Gleichung referenzieren!
+Gleichung ~\ref{eq:pythagoras} ist auch als das Theorem des Pythagoras bekannt. Dieses wird in
+Abschnitt ~\ref{subsec:pythagoras} behandelt. Es können sehr viele Sachen mit Labels versehen werden:
+Grafiken, Gleichungen, Sections, etc.
+
+Summen und Integrale können mit den sum und int Befehlen dargestellt werden:
+
+% Manche LateX-Compiler beschweren sich, wenn Leerzeilen in Gleichungen auftauchen
+\begin{equation}
+ \sum_{i=0}^{5} f_{i}
+\end{equation}
+\begin{equation}
+ \int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x
+\end{equation}
+
+\section{Grafiken}
+
+Lass uns eine Grafik einfügen. Das Platzieren von Grafiken kann etwas trickreich sein.
+Aber keine Sorge, ich muss auch jedes mal nachschauen, welche Option wie wirkt.
+
+\begin{figure}[H] % H ist die Platzierungsoption
+ \centering % Zentriert die Grafik auf der Seite
+ % Fügt eine Grafik ein, die auf 80% der Seitenbreite einnimmt.
+ %\includegraphics[width=0.8\linewidth]{right-triangle.png}
+ % Auskommentiert, damit es nicht im Dokument auftaucht.
+ \caption{Dreieck mit den Seiten $a$, $b$, $c$}
+ \label{fig:right-triangle}
+\end{figure}
+
+\subsection{Tabellen}
+Wir können Tabellen genauso wie Grafiken einfügen.
+
+\begin{table}[H]
+ \caption{Überschrift der Tabelle.}
+ % Die {} Argumente geben an, wie eine Zeile der Tabelle dargestellt werden soll.
+ % Auch hier muss ich jedes Mal nachschauen. Jedes. einzelne. Mal.
+ \begin{tabular}{c|cc}
+ Nummer & Nachname & Vorname \\ % Spalten werden durch & getrennt
+ \hline % Eine horizontale Linie
+ 1 & Biggus & Dickus \\
+ 2 & Monty & Python
+ \end{tabular}
+\end{table}
+
+% \section{Links} % Kommen bald!
+
+\section{Verhindern, dass LateX etwas kompiliert (z.B. Quelltext)}
+Angenommen, wir wollen Quelltext in unserem LateX-Dokument. LateX soll
+in diesem Fall nicht den Quelltext als LateX-Kommandos interpretieren,
+sondern es einfach ins Dokument schreiben. Um das hinzubekommen, verwenden
+wir eine verbatim Umgebung.
+
+% Es gibt noch weitere Pakete für Quelltexte (z.B. minty, lstlisting, etc.)
+% aber verbatim ist das simpelste.
+\begin{verbatim}
+ print("Hello World!")
+ a%b; % Schau dir das an! Wir können % im verbatim verwenden!
+ random = 4; #decided by fair random dice roll
+\end{verbatim}
+
+\section{Kompilieren}
+
+Ich vermute, du wunderst dich, wie du dieses tolle Dokument in ein PDF
+verwandeln kannst. (Ja, dieses Dokument kompiliert wirklich!) \\
+
+Dafür musst du folgende Schritte durchführen:
+ \begin{enumerate}
+ \item Schreibe das Dokument. (den LateX-Quelltext).
+ \item Kompiliere den Quelltext in ein PDF.
+ Das Kompilieren sieht so ähnlich wie das hier aus (Linux): \\
+ \begin{verbatim}
+ $pdflatex learn-latex.tex learn-latex.pdf
+ \end{verbatim}
+ \end{enumerate}
+
+Manche LateX-Editoren kombinieren Schritt 1 und 2. Du siehst also nur Schritt 1 und Schritt
+2 wird unsichtbar im Hintergrund ausgeführt.
+
+Alle Formatierungsoptionen werden in Schritt 1 in den Quelltext geschrieben. Schritt 2 verwendet
+dann diese Informationen und kümmert sich drum, dass das Dokument korrekt erstellt wird.
+
+\section{Ende}
+
+Das war's erst mal!
+
+% Dokument beenden
+\end{document}
+```
+## Mehr Informationen über LateX
+
+* Das tolle LaTeX wikibook: [https://de.wikibooks.org/wiki/LaTeX-Kompendium](https://de.wikibooks.org/wiki/LaTeX-Kompendium)
+* Ein Tutorial (englisch): [http://www.latex-tutorial.com/](http://www.latex-tutorial.com/)
diff --git a/de-de/ruby-de.html.markdown b/de-de/ruby-de.html.markdown
new file mode 100644
index 00000000..bdeaa30b
--- /dev/null
+++ b/de-de/ruby-de.html.markdown
@@ -0,0 +1,613 @@
+---
+language: ruby
+contributors:
+ - ["David Underwood", "http://theflyingdeveloper.com"]
+ - ["Joel Walden", "http://joelwalden.net"]
+ - ["Luke Holder", "http://twitter.com/lukeholder"]
+ - ["Tristan Hume", "http://thume.ca/"]
+ - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+ - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+ - ["Ariel Krakowski", "http://www.learneroo.com"]
+ - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+ - ["Levi Bostian", "https://github.com/levibostian"]
+ - ["Rahil Momin", "https://github.com/iamrahil"]
+translators:
+ - ["Christian Albrecht", "https://github.com/coastalchief"]
+filename: ruby-de.rb
+lang: de-de
+---
+
+# Dies ist ein Kommentar
+
+=begin
+Dies sind multi-line
+Kommentare. Niemand benutzt
+die wirklich.
+=end
+
+# Objekte - Alles ist ein Objekt
+
+## Zahlen sind Objekte
+```
+3.class #=> Fixnum
+3.to_s #=> "3"
+```
+
+### Simple Arithmetik
+```
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+2**5 #=> 32
+```
+
+// Arithmetik ist aber eigentlich nur syntaktischer Zucker
+// um eine Methode eines Objekt aufzurufen
+```
+1.+(3) #=> 4
+10.* 5 #=> 50
+```
+
+## Special values sind Objekte
+```
+nil # Nothing to see here
+true # truth
+false # falsehood
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+```
+
+## Objektvergleiche
+### Gleicheit
+```
+1 == 1 #=> true
+2 == 1 #=> false
+```
+### Ungleichheit
+```
+1 != 1 #=> false
+2 != 1 #=> true
+```
+### Neben false selbst, nil ist ein anderer 'falsey' Wert
+```
+!nil #=> true
+!false #=> true
+!0 #=> false
+```
+### Weitere Vergleiche
+```
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+```
+### 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.
+
+#### and
+##### `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.
+do_something() or log_error()
+
+## Strings sind Objekte
+```
+'I am a string'.class #=> String
+"I am a string too".class #=> String
+
+
+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.
+
+### 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
+```
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+```
+## Benennung
+### Konvention ist snake_case
+```
+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.
+
+```
+:pending.class #=> Symbol
+status = :pending
+status == :pending #=> true
+status == 'pending' #=> false
+status == :approved #=> false
+```
+# Arrays
+
+## Ein Array anlegen
+```
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+```
+
+## 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önnen von vorne indiziert werden
+```
+array[0] #=> 1
+array[12] #=> nil
+```
+
+## Arrays können von hinten indiziert werden
+```
+array[-1] #=> 5
+```
+
+## Arrays können mit Stard Index und Länge indiziert werden
+```
+array[2, 3] #=> [3, 4, 5]
+```
+
+## Arrays können mit einer Range indiziert werden
+```
+array[1..3] #=> [2, 3, 4]
+```
+
+## Einen Wert hinzufügen
+```
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+array.push(6) #=> [1, 2, 3, 4, 5, 6]
+```
+
+## Testen, ob ein Element schon vorhanden ist
+```
+array.include?(1) #=> true
+```
+
+# Hashes
+Hashes sind das Hauptfeature um Key/Values zu speichern
+
+```
+
+## Ein Hash anlegen
+```
+hash = { 'color' => 'green', 'number' => 5 }
+hash.keys #=> ['color', 'number']
+```
+
+## Wert per key herausfinden
+```
+hash['color'] #=> 'green'
+hash['number'] #=> 5
+hash['nothing here'] #=> nil
+// Asking a hash for a key that doesn't exist returns nil:
+```
+
+## Symbols können auch keys sein
+```
+new_hash = { defcon: 3, action: true }
+new_hash.keys #=> [:defcon, :action]
+```
+
+## Testen ob ein Key oder ein Value existiert
+```
+new_hash.has_key?(:defcon) #=> true
+new_hash.has_value?(3) #=> true
+```
+
+### Tip: Arrays und Hashes sind Enumerable
+### Und haben gemeinsame, hilfreiche Methoden wie:
+### each, map, count, and more
+
+# Kontrolstrukturen
+## if
+```
+if true
+ 'if statement'
+elsif false
+ 'else if, optional'
+else
+ 'else, also 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.
+
+```
+(1..5).each do |counter|
+ puts "iteration #{counter}"
+end
+```
+
+Die each Methode einer Range führt den Block für jedes Element der Range aus.
+
+Dem Block wird ein "counter" parameter übergeben.
+
+### Den Block kann man auch in geschweiften Klammern schreiben
+```
+(1..5).each { |counter| puts "iteration #{counter}" }
+```
+
+### Each kann auch über den Inhalt von Datenstrukturen iterieren
+```
+array.each do |element|
+ puts "#{element} is part of the array"
+end
+hash.each do |key, value|
+ puts "#{key} is #{value}"
+end
+
+counter = 1
+while counter <= 5 do
+ puts "iteration #{counter}"
+ counter += 1
+end
+```
+
+## case
+```
+grade = 'B'
+
+case grade
+when 'A'
+ puts 'Way to go kiddo'
+when 'B'
+ puts 'Better luck next time'
+when 'C'
+ puts 'You can do better'
+when 'D'
+ puts 'Scraping through'
+when 'F'
+ puts 'You failed!'
+else
+ puts 'Alternative grading system, eh?'
+end
+=> "Better luck next time"
+```
+
+### Case können auch ranges
+```
+grade = 82
+case grade
+when 90..100
+ puts 'Hooray!'
+when 80...90
+ puts 'OK job'
+else
+ puts 'You failed!'
+end
+=> "OK job"
+```
+
+# exception handling:
+```
+begin
+ # code here that might raise an exception
+ raise NoMemoryError, 'You ran out of memory.'
+rescue NoMemoryError => exception_variable
+ puts 'NoMemoryError was raised', exception_variable
+rescue RuntimeError => other_exception_variable
+ puts 'RuntimeError was raised now'
+else
+ puts 'This runs if no exceptions were thrown at all'
+ensure
+ puts 'This code always runs no matter what'
+end
+```
+# Funktionen
+```
+def double(x)
+ x * 2
+end
+```
+## Funktionen (und Blocks)
+## geben implizit den Wert des letzten Statements zurück
+```
+double(2) #=> 4
+```
+
+### Klammern sind optional wenn das Ergebnis nicht mehdeutig ist
+```
+double 3 #=> 6
+double double 3 #=> 12
+def sum(x, y)
+ x + y
+end
+```
+
+### Methoden Parameter werden per 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
+```
+def surround
+ puts '{'
+ yield
+ puts '}'
+end
+surround { puts 'hello world' }
+```
+
+## Einen Block kann man auch einer Methoden übergeben
+### "&" kennzeichnet die Referenz zum übergebenen Block
+```
+def guests(&block)
+ block.call 'some_argument'
+end
+```
+
+### Eine Liste von Parametern kann man auch übergeben,
+### Diese wird in ein Array konvertiert
+### "*" kennzeichnet dies.
+```
+def guests(*array)
+ array.each { |guest| puts guest }
+end
+```
+# Klassen
+## Werden mit dem class Schlüsselwort definiert
+```
+class Human
+```
+
+### Konstruktor bzw. Initializer
+```
+ def initialize(name, age = 0)
+ # Assign the argument to the "name" instance variable for the instance
+ @name = name
+ # If no age given, we will fall back to the default in the arguments list.
+ @age = age
+ end
+```
+
+### setter Methode
+```
+ def name=(name)
+ @name = name
+ end
+```
+### getter Methode
+```
+ def name
+ @name
+ end
+```
+
+#### getter können mit der attr_accessor Methode vereinfacht definiert werden
+```
+ attr_accessor :name
+ # Getter/setter methods can also be created individually like this
+ 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.
+ def self.say(msg)
+ puts msg
+ end
+ def species
+ @@species
+ end
+end
+```
+
+## Eine Klasse instanziieren
+```
+jim = Human.new('Jim Halpert')
+dwight = Human.new('Dwight K. Schrute')
+```
+
+## Methodenaufrufe
+```
+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
+```
+Human.say('Hi') #=> "Hi"
+```
+
+## Variable Gültigkeit
+### Variablen die mit "$" starten, gelten global
+```
+$var = "I'm a global var"
+defined? $var #=> "global-variable"
+```
+
+### Variablen die mit "@" starten, gelten für die Instanz
+```
+@var = "I'm an instance var"
+defined? @var #=> "instance-variable"
+```
+
+### Variablen die mit "@@" starten, gelten für die Klasse
+```
+@@var = "I'm a class var"
+defined? @@var #=> "class variable"
+```
+
+### Variablen die mit einem Großbuchstaben anfangen, sind Konstanten
+```
+Var = "I'm a constant"
+defined? Var #=> "constant"
+```
+
+## Class ist auch ein Objekt
+### Hat also auch Instanzvariablen
+### Eine Klassenvariable wird innerhalb der Klasse und Ableitungen geteilt.
+
+### Basis Klasse
+```
+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 # 2
+```
+
+### Eine Klasseninstanzvariable wird nicht geteilt
+```
+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
+```
+```
+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
+```
+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
+ end
+ 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
+
+//EN
+
+- [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/)
+- [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.
diff --git a/de-de/ruby-ecosystem-de.html.markdown b/de-de/ruby-ecosystem-de.html.markdown
new file mode 100644
index 00000000..a7e1f75f
--- /dev/null
+++ b/de-de/ruby-ecosystem-de.html.markdown
@@ -0,0 +1,149 @@
+---
+category: tool
+tool: ruby ecosystem
+contributors:
+ - ["Jon Smock", "http://github.com/jonsmock"]
+ - ["Rafal Chmiel", "http://github.com/rafalchmiel"]
+translators:
+ - ["Christian Albrecht", "https://github.com/coastalchief"]
+filename: ruby-ecosystem-de.txt
+lang: de-de
+---
+
+Hier gibt es einen Überblick über die gängigsten Tools zur Verwaltung
+von verschiedenen Ruby Versionen, Gems und Dependencies.
+
+## Ruby Managers
+
+Einige Betriebssysteme haben bereits eine Ruby Version vorinstalliert
+oder bieten sie als Package zum Download an. Die meisten Rubyisten
+benutzen diese aber eher nicht und wenn, dann um damit einen Ruby
+Manager zu installieren. Damit kann man komfortabel zwischen den
+verschiedenen Versionen hin und herspringen.
+
+Dies sind die beliebtesten:
+
+* [RVM](https://rvm.io/) - Installiert und wechselt zwischen rubies
+ RVM kennt verschiedene Ruby Versionen und hat das Konzept der gemsets,
+ um gem Abhängigkeiten pro Projekt zu managen.
+* [ruby-build](https://github.com/sstephenson/ruby-build)
+ Installiert nur rubies, kann diese aber sehr gut verwalten
+* [rbenv](https://github.com/sstephenson/rbenv) - Wechselt Ruby Versionen.
+ Wird zusammen mit ruby-build benutzt. Hiermit kann man kontrollieren,
+ wie rubies laden.
+* [chruby](https://github.com/postmodern/chruby) - Wechselt Ruby Versionen.
+ Ähnlich rbenv.
+
+## Ruby Versionen
+
+Ruby wurde von Yukihiro "Matz" Matsumoto vor gut 20 Jahren veröffentlicht.
+Matz ist nach wie vor in die Entwicklung involviert. Daher kommt auch der
+Name der Referenzimplementierung: MRI (Matz' Reference Implementation).
+
+Die aktuellste Version ist **2.2.3** und wurde im August 2015 veröffentlicht!
+
+Hier eine kurze Versionshistorie:
+
+* 2.0.0 - Release im Februar 2013 -- Release zum 20. Geburtstag der Sprache
+ [Rubies are forever](http://www.heise.de/developer/artikel/Ruby-2-0-als-Geschenk-zum-20-Geburtstag-1808109.html)
+* 1.9.3 - Release im Oktober 2011
+ [End of Life](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/)
+* 1.8.7 - Release im Juni 2006
+ [End of Life](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/).
+
+Die Veränderung zwischen 1.8.7 und 1.9.x war sehr groß und eine Migration
+nicht so einfach möglich. Der Versionssprung auf 2.0.0 war verglichen dazu
+weit weniger dramatisch.
+Beispielsweise hat 1.9. Encodings und eine Bytecode VM eingeführt.
+Es gibt immer noch Projekte die auf der stabilen Version 1.8.7 laufen,
+aber diese sind mittlerweile in der Minderheit. Die meisten Projekte
+laufen auf 1.9.x oder auf 2.x.
+
+## Ruby Implementierungen
+
+Das Ruby Ecosystem beinhaltet viele verschiedene Implementierungen von Ruby,
+jedes mit seinen eigenen Vorteilen und verschiedenen Graden von
+Kompatibilität. Auch wenn alle diese Implementierungen in verschiedenen
+Sprachen geschrieben sind, sind sie doch **alle Ruby**.
+Jede Implementierung bietet neben ihren speziellen Features immer auch
+die Möglichkeit normale ruby Dateien auszuführen.
+
+Am ausgereiftesten und stabilsten:
+
+* [MRI](https://github.com/ruby/ruby) - Geschrieben in C, das ist die Referenz Implementierung.
+ Sie ist 100% kompatibel (mit sich selbst ;-). Alle anderen rubies
+ bleiben kompatibel mit MRI (siehe [RubySpec](#rubyspec) weiter unten).
+* [JRuby](http://jruby.org/) - Geschrieben in Java and Ruby, Robust und ziemlich schnell.
+ Der größte Vorteil von JRuby ist die Interoperabilität mit JVM/Java und damit die
+ Benutzung von Ruby im Java Ecosystem.
+* [Rubinius](http://rubini.us/) - Geschrieben in Ruby mit C++ bytecode VM.
+ Auch sehr ausgereift und schnell.
+
+Mittel ausgereift / kompatibel:
+
+* [Maglev](http://maglev.github.io/) - Baut auf Gemstone, ein Smalltalk VM.
+ Dieses Projekt versucht das großartige Smalltalk Tooling in die Ruby Welt
+ zu bringen.
+* [RubyMotion](http://www.rubymotion.com/) - Ruby in der iOS Entwicklung.
+
+Weniger ausgereift/kompatibel:
+
+* [Topaz](http://topazruby.com/) - Geschrieben in RPython (via PyPy)
+ Topaz ist noch ziemlich jung und versucht die schnellste Implementierung
+ zu werden.
+* [IronRuby](http://ironruby.net/) - Geschrieben in C# für die .NET Plaftform
+ Das letzte Release von IronRuby ist mittlerweile 5 Jahre her.
+
+Die Ruby Implementierungen haben ihre eigenen Versionsnummern, sind aber
+trotzdem immer zu einer MRI Version kompatibel.
+Viele können sogar zwischen verschiedenen Modi wechseln (1.8 mode -> 1.9 mode)
+
+## RubySpec
+
+Die meisten Ruby Implementierungen vertrauen der [RubySpec](http://rubyspec.org/).
+sehr stark. Da Ruby keine offizielle Spezifikation hat, hat die
+Community ausführbare Specs (in Ruby) geschrieben, um so die Kompatibilität
+zur MRI testen zu können.
+
+## RubyGems
+
+[RubyGems](http://rubygems.org/) ist der Community Paket Manager von Ruby.
+RubyGems kommt mit Ruby zusammen, so dass kein extra Tool nötig ist.
+
+Ruby Pakete werden "gems" genannt und könnten auf RubyGems.org
+veröffentlicht werden. Jedes Gem enthält den Source Code und Meta Daten,
+wie die Versionsnummer, weitere Abhängigkeiten, Autoren und Lizenzen.
+
+## Bundler
+
+[Bundler](http://bundler.io/) ist ein Tool um Abhängigkeiten zwischen
+Gems aufzulösen und zu managen. Dazu werden diese in einem gemfile
+zusammengefasst und Bundler kümmert sich darum die Abhängigkeiten
+untereinander rekursiv aufzulösen. Entweder es klappt und alle gems
+konnten runtergeladen werden, oder es wird abgebrochen und
+der Konflikt gemeldet.
+Zum Beispiel:
+Wenn Gem A die Version 3 oder höher von Gem Z braucht, aber Gem B
+von Gem Z die Version 2, dann ist das ein Konflikt.
+
+# Testing
+
+Test-Driven Development ist ein essentieller Teil der Ruby Kultur.
+Ruby bringt sein eigenes Unit-Test framework mit, minitest. Darüberhinaus
+gibt es noch viele weitere Testframeworks mit unterschiedlichsten Zielen:
+
+* [TestUnit](http://ruby-doc.org/stdlib-1.8.7/libdoc/test/unit/rdoc/Test/Unit.html) - Eingebaut in Ruby 1.8
+ "Unit-style" Testframework
+* [minitest](http://ruby-doc.org/stdlib-2.0.0/libdoc/minitest/rdoc/MiniTest.html) - Eingebaut in Ruby 1.9/2.0
+ "Unit-style" Testframework
+* [RSpec](http://rspec.info/) - Ein Testframework welches auf verständliche Testdefinition setzt
+* [Cucumber](http://cukes.info/) - Ein BDD Testframework welches Gherkin tests parsen kann
+
+## Be Nice
+Die Ruby Community ist stolz darauf eine offene, vielfältige und einladende
+Community zu sein. Es gibt viele aktive Ruby User Gruppen und diverse
+Ruby Konferenzen. Matz selbst ist so oft es geht dabei.
+
+* [Euruko](http://www.euruko2015.org)
+* [User Groups](https://www.ruby-lang.org/de/community/user-groups/)
+
diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown
new file mode 100644
index 00000000..7fd299b4
--- /dev/null
+++ b/de-de/scala-de.html.markdown
@@ -0,0 +1,816 @@
+---
+language: Scala
+contributors:
+ - ["George Petrov", "http://github.com/petrovg"]
+ - ["Dominic Bou-Samra", "http://dbousamra.github.com"]
+ - ["Geoff Liu", "http://geoffliu.me"]
+ - ["Ha-Duong Nguyen", "http://reference-error.org"]
+translators:
+ - ["Christian Albrecht", "https://github.com/coastalchief"]
+filename: learnscala-de.scala
+lang: de-de
+---
+
+Scala ist eine funktionale und objektorientierte Programmiersprache
+für die Java Virtual Machine (JVM), um allgemeine Programmieraufgaben
+zu erledigen. Scala hat einen akademischen Hintergrund und wurde an
+der EPFL (Lausanne / Schweiz) unter der Leitung von Martin Odersky entwickelt.
+
+
+# 0. Umgebung einrichten
+Scala Umgebung einrichten:
+
+1. Scala binaries herunterladen- http://www.scala-lang.org/downloads
+2. Unzip/untar in ein Verzeichnis
+3. das bin Unterverzeichnis der `PATH` Umgebungsvariable hinzufügen
+4. Mit dem Kommando `scala` wird die REPL gestartet und zeigt als Prompt:
+```
+scala>
+```
+
+Die REPL (Read-Eval-Print Loop) ist der interaktive Scala Interpreter.
+Hier kann man jeden Scala Ausdruck verwenden und das Ergebnis wird direkt
+ausgegeben.
+Als nächstes beschäftigen wir uns mit ein paar Scala Basics.
+
+# 1. Basics
+
+Einzeilige Kommentare beginnen mit zwei vorwärts Slash
+
+/*
+ Mehrzeilige Kommentare, werden starten
+ mit Slash-Stern und enden mit Stern-Slash
+*/
+
+// Einen Wert, und eine zusätzliche neue Zeile ausgeben
+```
+println("Hello world!")
+println(10)
+```
+
+// Einen Wert, ohne eine zusätzliche neue Zeile ausgeben
+```
+print("Hello world")
+```
+
+// Variablen werden entweder mit var oder val deklariert.
+// Deklarationen mit val sind immutable, also unveränderlich
+// Deklarationen mit var sind mutable, also veränderlich
+// Immutability ist gut.
+```
+val x = 10 // x ist 10
+x = 20 // error: reassignment to val
+var y = 10
+y = 20 // y ist jetzt 20
+```
+
+Scala ist eine statisch getypte Sprache, auch wenn in dem o.g. Beispiel
+keine Typen an x und y geschrieben haben.
+In Scala ist etwas eingebaut, was sich Type Inference nennt. D.h. das der
+Scala Compiler in den meisten Fällen erraten kann, von welchen Typ eine ist,
+so dass der Typ nicht jedes mal angegeben werden soll.
+Einen Typ gibt man bei einer Variablendeklaration wie folgt an:
+```
+val z: Int = 10
+val a: Double = 1.0
+```
+
+// Bei automatischer Umwandlung von Int auf Double wird aus 10 eine 10.0
+```
+val b: Double = 10
+```
+
+// Boolean Werte
+```
+true
+false
+```
+
+// Boolean Operationen
+```
+!true // false
+!false // true
+true == false // false
+10 > 5 // true
+```
+
+// Mathematische Operationen sind wie gewohnt
+```
+1 + 1 // 2
+2 - 1 // 1
+5 * 3 // 15
+6 / 2 // 3
+6 / 4 // 1
+6.0 / 4 // 1.5
+```
+
+// Die Auswertung eines Ausdrucks in der REPL gibt den Typ
+// und das Ergebnis zurück.
+```
+ scala> 1 + 7
+ res29: Int = 8
+```
+
+Das bedeutet, dass das Resultat der Auswertung von 1 + 7 ein Objekt
+von Typ Int ist und einen Wert 0 hat.
+"res29" ist ein sequentiell generierter name, um das Ergebnis des
+Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein...
+
+
+"Scala strings werden in doppelten Anführungszeichen eingeschlossen"
+'a' // A Scala Char
+// 'Einzeln ge-quotete strings gibt es nicht!' <= This causes an error
+
+// Für Strings gibt es die üblichen Java Methoden
+```
+"hello world".length
+"hello world".substring(2, 6)
+"hello world".replace("C", "3")
+```
+
+// Zusätzlich gibt es noch extra Scala Methoden
+// siehe: scala.collection.immutable.StringOps
+```
+"hello world".take(5)
+"hello world".drop(5)
+```
+
+// String interpolation: prefix "s"
+```
+val n = 45
+s"We have $n apples" // => "We have 45 apples"
+```
+
+// Ausdrücke im innern von interpolierten Strings gibt es auch
+```
+val a = Array(11, 9, 6)
+val n = 100
+s"My second daughter is ${a(0) - a(2)} years old." // => "My second daughter is 5 years old."
+s"We have double the amount of ${n / 2.0} in apples." // => "We have double the amount of 22.5 in apples."
+s"Power of 2: ${math.pow(2, 2)}" // => "Power of 2: 4"
+```
+
+// Formatierung der interpolierten Strings mit dem prefix "f"
+```
+f"Power of 5: ${math.pow(5, 2)}%1.0f" // "Power of 5: 25"
+f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454"
+```
+
+// Raw Strings, ignorieren Sonderzeichen.
+```
+raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r."
+```
+
+// Manche Zeichen müssen "escaped" werden, z.B.
+// ein doppeltes Anführungszeichen in innern eines Strings.
+```
+"They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown""
+```
+
+// Dreifache Anführungszeichen erlauben es, dass ein String über mehrere Zeilen geht
+// und Anführungszeichen enthalten kann.
+```
+val html = """<form id="daform">
+ <p>Press belo', Joe</p>
+ <input type="submit">
+ </form>"""
+```
+
+# 2. Funktionen
+
+// Funktionen werden so definiert
+//
+// def functionName(args...): ReturnType = { body... }
+//
+// Beachte: Es gibt kein return Schlüsselwort. In Scala ist der letzte Ausdruck
+// in einer Funktion der Rückgabewert.
+```
+def sumOfSquares(x: Int, y: Int): Int = {
+ val x2 = x * x
+ val y2 = y * y
+ x2 + y2
+}
+```
+
+// Die geschweiften Klammern können weggelassen werden, wenn
+// die Funktion nur aus einem einzigen Ausdruck besteht:
+```
+def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y
+```
+
+// Syntax für Funktionsaufrufe:
+```
+sumOfSquares(3, 4) // => 25
+```
+
+// In den meisten Fällen (mit Ausnahme von rekursiven Funktionen), können
+// Rückgabetypen auch weggelassen werden, da dieselbe Typ Inference, wie bei
+// Variablen, auch bei Funktionen greift:
+```
+def sq(x: Int) = x * x // Compiler errät, dass der return type Int ist
+```
+
+// Funktionen können default parameter haben:
+```
+def addWithDefault(x: Int, y: Int = 5) = x + y
+addWithDefault(1, 2) // => 3
+addWithDefault(1) // => 6
+```
+
+// Anonyme Funktionen sehen so aus:
+```
+(x: Int) => x * x
+```
+
+// Im Gegensatz zu def bei normalen Funktionen, kann bei anonymen Funktionen
+// sogar der Eingabetyp weggelassen werden, wenn der Kontext klar ist.
+// Beachte den Typ "Int => Int", dies beschreibt eine Funktion,
+// welche Int als Parameter erwartet und Int zurückgibt.
+```
+val sq: Int => Int = x => x * x
+```
+
+// Anonyme Funktionen benutzt man ganz normal:
+```
+sq(10) // => 100
+```
+
+// Wenn ein Parameter einer anonymen Funktion nur einmal verwendet wird,
+// bietet Scala einen sehr kurzen Weg diesen Parameter zu benutzen,
+// indem die Parameter als Unterstrich "_" in der Parameterreihenfolge
+// verwendet werden. Diese anonymen Funktionen werden sehr häufig
+// verwendet.
+```
+val addOne: Int => Int = _ + 1
+val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3)
+addOne(5) // => 6
+weirdSum(2, 4) // => 16
+```
+
+// Es gibt einen keyword return in Scala. Allerdings ist seine Verwendung
+// nicht immer ratsam und kann fehlerbehaftet sein. "return" gibt nur aus
+// dem innersten def, welches den return Ausdruck umgibt, zurück.
+// "return" hat keinen Effekt in anonymen Funktionen:
+```
+def foo(x: Int): Int = {
+ val anonFunc: Int => Int = { z =>
+ if (z > 5)
+ return z // Zeile macht z zum return Wert von foo
+ else
+ z + 2 // Zeile ist der return Wert von anonFunc
+ }
+ anonFunc(x) // Zeile ist der return Wert von foo
+}
+```
+
+# 3. Flow Control
+
+## Wertebereiche und Schleifen
+```
+1 to 5
+val r = 1 to 5
+r.foreach(println)
+r foreach println
+(5 to 1 by -1) foreach (println)
+```
+// Scala ist syntaktisch sehr grosszügig, Semikolons am Zeilenende
+// sind optional, beim Aufruf von Methoden können die Punkte
+// und Klammern entfallen und Operatoren sind im Grunde austauschbare Methoden
+
+// while Schleife
+```
+var i = 0
+while (i < 10) { println("i " + i); i += 1 }
+i // i ausgeben, res3: Int = 10
+```
+
+// Beachte: while ist eine Schleife im klassischen Sinne -
+// Sie läuft sequentiell ab und verändert die loop-Variable.
+// While in Scala läuft schneller ab als in Java und die o.g.
+// Kombinatoren und Zusammenlegungen sind einfacher zu verstehen
+// und zu parellelisieren.
+
+// Ein do while Schleife
+```
+do {
+ println("x ist immer noch weniger wie 10")
+ x += 1
+} while (x < 10)
+```
+
+// Endrekursionen sind ideomatisch um sich wiederholende
+// Dinge in Scala zu lösen. Rekursive Funtionen benötigen explizit einen
+// return Typ, der Compiler kann ihn nicht erraten.
+// Unit, in diesem Beispiel.
+```
+def showNumbersInRange(a: Int, b: Int): Unit = {
+ print(a)
+ if (a < b)
+ showNumbersInRange(a + 1, b)
+}
+showNumbersInRange(1, 14)
+```
+
+## Conditionals
+```
+val x = 10
+if (x == 1) println("yeah")
+if (x == 10) println("yeah")
+if (x == 11) println("yeah")
+if (x == 11) println ("yeah") else println("nay")
+println(if (x == 10) "yeah" else "nope")
+val text = if (x == 10) "yeah" else "nope"
+```
+
+# 4. Daten Strukturen (Array, Map, Set, Tuples)
+
+## Array
+```
+val a = Array(1, 2, 3, 5, 8, 13)
+a(0)
+a(3)
+a(21) // Exception
+```
+
+## Map - Speichert Key-Value-Paare
+```
+val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo")
+m("fork")
+m("spoon")
+m("bottle") // Exception
+val safeM = m.withDefaultValue("no lo se")
+safeM("bottle")
+```
+## Set - Speichert Unikate, unsortiert (sortiert -> SortedSet)
+```
+val s = Set(1, 3, 7)
+s(0) //false
+s(1) //true
+val s = Set(1,1,3,3,7)
+s: scala.collection.immutable.Set[Int] = Set(1, 3, 7)
+```
+## Tuple - Speichert beliebige Daten und "verbindet" sie miteinander
+// Ein Tuple ist keine Collection.
+```
+(1, 2)
+(4, 3, 2)
+(1, 2, "three")
+(a, 2, "three")
+```
+
+// Hier ist der Rückgabewert der Funktion ein Tuple
+// Die Funktion gibt das Ergebnis, so wie den Rest zurück.
+```
+val divideInts = (x: Int, y: Int) => (x / y, x % y)
+divideInts(10, 3)
+```
+
+// Um die Elemente eines Tuples anzusprechen, benutzt man diese
+// Notation: _._n wobei n der index des Elements ist (Index startet bei 1)
+```
+val d = divideInts(10, 3)
+d._1
+d._2
+```
+# 5. Objekt Orientierte Programmierung
+
+Bislang waren alle gezeigten Sprachelemente einfache Ausdrücke, welche zwar
+zum Ausprobieren und Lernen in der REPL gut geeignet sind, jedoch in
+einem Scala file selten alleine zu finden sind.
+Die einzigen Top-Level Konstrukte in Scala sind nämlich:
+
+- Klassen (classes)
+- Objekte (objects)
+- case classes
+- traits
+
+Diesen Sprachelemente wenden wir uns jetzt zu.
+
+## Klassen
+
+// Zum Erstellen von Objekten benötigt man eine Klasse, wie in vielen
+// anderen Sprachen auch.
+
+// erzeugt Klasse mit default Konstruktor
+```
+class Hund
+scala> val t = new Hund
+t: Hund = Hund@7103745
+```
+
+// Der Konstruktor wird direkt hinter dem Klassennamen deklariert.
+```
+class Hund(sorte: String)
+scala> val t = new Hund("Dackel")
+t: Hund = Hund@14be750c
+scala> t.sorte //error: value sorte is not a member of Hund
+```
+
+// Per val wird aus dem Attribut ein unveränderliches Feld der Klasse
+// Per var wird aus dem Attribut ein veränderliches Feld der Klasse
+```
+class Hund(val sorte: String)
+scala> val t = new Hund("Dackel")
+t: Hund = Hund@74a85515
+scala> t.sorte
+res18: String = Dackel
+```
+
+// Methoden werden mit def geschrieben
+```
+def bark = "Woof, woof!"
+```
+
+// Felder und Methoden können public, protected und private sein
+// default ist public
+// private ist nur innerhalb des deklarierten Bereichs sichtbar
+```
+class Hund {
+ private def x = ...
+ def y = ...
+}
+```
+
+// protected ist nur innerhalb des deklarierten und aller
+// erbenden Bereiche sichtbar
+```
+class Hund {
+ protected def x = ...
+}
+class Dackel extends Hund {
+ // x ist sichtbar
+}
+```
+## Object
+Wird ein Objekt ohne das Schlüsselwort "new" instanziert, wird das sog.
+"companion object" aufgerufen. Mit dem "object" Schlüsselwort wird so
+ein Objekt (Typ UND Singleton) erstellt. Damit kann man dann eine Klasse
+benutzen ohne ein Objekt instanziieren zu müssen.
+Ein gültiges companion Objekt einer Klasse ist es aber erst dann, wenn
+es genauso heisst und in derselben Datei wie die Klasse definiert wurde.
+```
+object Hund {
+ def alleSorten = List("Pitbull", "Dackel", "Retriever")
+ def createHund(sorte: String) = new Hund(sorte)
+}
+```
+## Case classes
+Fallklassen bzw. Case classes sind Klassen die normale Klassen um extra
+Funktionalität erweitern. Mit Case Klassen bekommt man ein paar
+Dinge einfach dazu, ohne sich darum kümmern zu müssen. Z.B.
+ein companion object mit den entsprechenden Methoden,
+Hilfsmethoden wie toString(), equals() und hashCode() und auch noch
+Getter für unsere Attribute (das Angeben von val entfällt dadurch)
+```
+class Person(val name: String)
+class Hund(val sorte: String, val farbe: String, val halter: Person)
+```
+
+// Es genügt das Schlüsselwort case vor die Klasse zu schreiben.
+```
+case class Person(name: String)
+case class Hund(sorte: String, farbe: String, halter: Person)
+```
+
+// Für neue Instanzen brauch man kein "new"
+```
+val dackel = Hund("dackel", "grau", Person("peter"))
+val dogge = Hund("dogge", "grau", Person("peter"))
+
+```
+// getter
+```
+dackel.halter // => Person = Person(peter)
+```
+
+// equals
+```
+dogge == dackel // => false
+```
+
+// copy
+// otherGeorge == Person("george", "9876")
+```
+val otherGeorge = george.copy(phoneNumber = "9876")
+```
+## Traits
+Ähnlich wie Java interfaces, definiert man mit traits einen Objekttyp
+und Methodensignaturen. Scala erlaubt allerdings das teilweise
+implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt.
+Traits können von anderen Traits oder Klassen erben, aber nur von
+parameterlosen.
+```
+trait Hund {
+ def sorte: String
+ def farbe: String
+ def bellen: Boolean = true
+ def beissen: Boolean
+}
+class Bernhardiner extends Hund{
+ val sorte = "Bernhardiner"
+ val farbe = "braun"
+ def beissen = false
+}
+```
+
+```
+scala> b
+res0: Bernhardiner = Bernhardiner@3e57cd70
+scala> b.sorte
+res1: String = Bernhardiner
+scala> b.bellen
+res2: Boolean = true
+scala> b.beissen
+res3: Boolean = false
+```
+
+// Traits können auch via Mixins (Schlüsselwort "with") eingebunden werden
+```
+trait Bellen {
+ def bellen: String = "Woof"
+}
+trait Hund {
+ def sorte: String
+ def farbe: String
+}
+class Bernhardiner extends Hund with Bellen{
+ val sorte = "Bernhardiner"
+ val farbe = "braun"
+}
+scala> val b = new Bernhardiner
+b: Bernhardiner = Bernhardiner@7b69c6ba
+scala> b.bellen
+res0: String = Woof
+```
+
+# 6. Pattern Matching
+Pattern matching in Scala ist ein sehr nützliches und wesentlich
+mächtigeres Feature als Vergleichsfunktionen in Java. In Scala
+benötigt ein case Statement kein "break", ein fall-through gibt es nicht.
+Mehrere Überprüfungen können mit einem Statement gemacht werden.
+Pattern matching wird mit dem Schlüsselwort "match" gemacht.
+```
+val x = ...
+x match {
+ case 2 =>
+ case 3 =>
+ case _ =>
+}
+```
+
+// Pattern Matching kann auf beliebige Typen prüfen
+```
+val any: Any = ...
+val gleicht = any match {
+ case 2 | 3 | 5 => "Zahl"
+ case "woof" => "String"
+ case true | false => "Boolean"
+ case 45.35 => "Double"
+ case _ => "Unbekannt"
+}
+```
+
+// und auf Objektgleichheit
+```
+def matchPerson(person: Person): String = person match {
+ case Person("George", nummer) => "George! Die Nummer ist " + number
+ case Person("Kate", nummer) => "Kate! Die Nummer ist " + nummer
+ case Person(name, nummer) => "Irgendjemand: " + name + ", Telefon: " + nummer
+}
+```
+
+// Und viele mehr...
+```
+val email = "(.*)@(.*)".r // regex
+def matchEverything(obj: Any): String = obj match {
+ // Werte:
+ case "Hello world" => "Got the string Hello world"
+ // Typen:
+ case x: Double => "Got a Double: " + x
+ // Conditions:
+ case x: Int if x > 10000 => "Got a pretty big number!"
+ // Case Classes:
+ case Person(name, number) => s"Got contact info for $name!"
+ // RegEx:
+ case email(name, domain) => s"Got email address $name@$domain"
+ // Tuples:
+ case (a: Int, b: Double, c: String) => s"Got a tuple: $a, $b, $c"
+ // Strukturen:
+ case List(1, b, c) => s"Got a list with three elements and starts with 1: 1, $b, $c"
+ // Patterns kann man ineinander schachteln:
+ case List(List((1, 2, "YAY"))) => "Got a list of list of tuple"
+}
+```
+
+// Jedes Objekt mit einer "unapply" Methode kann per Pattern geprüft werden
+// Ganze Funktionen können Patterns sein
+```
+val patternFunc: Person => String = {
+ case Person("George", number) => s"George's number: $number"
+ case Person(name, number) => s"Random person's number: $number"
+}
+```
+
+# 7. Higher-order functions
+Scala erlaubt, das Methoden und Funktion wiederum Funtionen und Methoden
+als Aufrufparameter oder Return Wert verwenden. Diese Methoden heissen
+higher-order functions
+Es gibt zahlreiche higher-order functions nicht nur für Listen, auch für
+die meisten anderen Collection Typen, sowie andere Klassen in Scala
+Nennenswerte sind:
+"filter", "map", "reduce", "foldLeft"/"foldRight", "exists", "forall"
+
+## List
+```
+def isGleichVier(a:Int) = a == 4
+val list = List(1, 2, 3, 4)
+val resultExists4 = list.exists(isEqualToFour)
+```
+
+## map
+// map nimmt eine Funktion und führt sie auf jedem Element aus und erzeugt
+// eine neue Liste
+
+// Funktion erwartet ein Int und returned ein Int
+```
+val add10: Int => Int = _ + 10
+```
+
+// add10 wird auf jedes Element angewendet
+```
+List(1, 2, 3) map add10 // => List(11, 12, 13)
+```
+
+// Anonyme Funktionen können anstatt definierter Funktionen verwendet werden
+```
+List(1, 2, 3) map (x => x + 10)
+```
+
+// Der Unterstrich wird anstelle eines Parameters einer anonymen Funktion
+// verwendet. Er wird an die Variable gebunden.
+```
+List(1, 2, 3) map (_ + 10)
+```
+
+// Wenn der anonyme Block und die Funtion beide EIN Argument erwarten,
+// kann sogar der Unterstrich weggelassen werden.
+```
+List("Dom", "Bob", "Natalia") foreach println
+```
+
+## filter
+// filter nimmt ein Prädikat (eine Funktion von A -> Boolean) und findet
+// alle Elemente die auf das Prädikat passen
+```
+List(1, 2, 3) filter (_ > 2) // => List(3)
+case class Person(name: String, age: Int)
+List(
+ Person(name = "Dom", age = 23),
+ Person(name = "Bob", age = 30)
+).filter(_.age > 25) // List(Person("Bob", 30))
+```
+
+## reduce
+// reduce nimmt zwei Elemente und kombiniert sie zu einem Element,
+// und zwar solange bis nur noch ein Element da ist.
+
+## foreach
+// foreach gibt es für einige Collections
+```
+val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100)
+aListOfNumbers foreach (x => println(x))
+aListOfNumbers foreach println
+```
+## For comprehensions
+// Eine for-comprehension definiert eine Beziehung zwischen zwei Datensets.
+// Dies ist keine for-Schleife.
+```
+for { n <- s } yield sq(n)
+val nSquared2 = for { n <- s } yield sq(n)
+for { n <- nSquared2 if n < 10 } yield n
+for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
+```
+
+/////////////////////////////////////////////////
+# 8. Implicits
+/////////////////////////////////////////////////
+
+**ACHTUNG:**
+Implicits sind ein sehr mächtiges Sprachfeature von Scala. Es sehr einfach
+sie falsch zu benutzen und Anfänger sollten sie mit Vorsicht oder am
+besten erst dann benutzen, wenn man versteht wie sie funktionieren.
+Dieses Tutorial enthält Implicits, da sie in Scala an jeder Stelle
+vorkommen und man auch mit einer Lib die Implicits benutzt nichts sinnvolles
+machen kann.
+Hier soll ein Grundverständnis geschaffen werden, wie sie funktionieren.
+
+// Mit dem Schlüsselwort implicit können Methoden, Werte, Funktion, Objekte
+// zu "implicit Methods" werden.
+```
+implicit val myImplicitInt = 100
+implicit def myImplicitFunction(sorte: String) = new Hund("Golden " + sorte)
+```
+
+// implicit ändert nicht das Verhalten eines Wertes oder einer Funktion
+```
+myImplicitInt + 2 // => 102
+myImplicitFunction("Pitbull").sorte // => "Golden Pitbull"
+```
+
+// Der Unterschied ist, dass diese Werte ausgewählt werden können, wenn ein
+// anderer Codeteil einen implicit Wert benötigt, zum Beispiel innerhalb von
+// implicit Funktionsparametern
+
+// Diese Funktion hat zwei Parameter: einen normalen und einen implicit
+```
+def sendGreetings(toWhom: String)(implicit howMany: Int) =
+ s"Hello $toWhom, $howMany blessings to you and yours!"
+```
+
+// Werden beide Parameter gefüllt, verhält sich die Funktion wie erwartet
+```
+sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours!"
+```
+
+// Wird der implicit Parameter jedoch weggelassen, wird ein anderer
+// implicit Wert vom gleichen Typ genommen. Der Compiler sucht im
+// lexikalischen Scope und im companion object nach einem implicit Wert,
+// der vom Typ passt, oder nach einer implicit Methode mit der er in den
+// geforderten Typ konvertieren kann.
+
+// Hier also: "myImplicitInt", da ein Int gesucht wird
+```
+sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!"
+```
+
+// bzw. "myImplicitFunction"
+// Der String wird erst mit Hilfe der Funktion in Hund konvertiert, und
+// dann wird die Methode aufgerufen
+```
+"Retriever".sorte // => "Golden Retriever"
+```
+
+# 9. Misc
+## Importe
+```
+import scala.collection.immutable.List
+```
+
+// Importiere alle Unterpackages
+```
+import scala.collection.immutable._
+```
+
+// Importiere verschiedene Klassen mit einem Statement
+```
+import scala.collection.immutable.{List, Map}
+```
+
+// Einen Import kann man mit '=>' umbenennen
+```
+import scala.collection.immutable.{List => ImmutableList}
+```
+
+// Importiere alle Klasses, mit Ausnahem von....
+// Hier ohne: Map and Set:
+```
+import scala.collection.immutable.{Map => _, Set => _, _}
+```
+## Main
+```
+object Application {
+ def main(args: Array[String]): Unit = {
+ // stuff goes here.
+ }
+}
+```
+
+## I/O
+// Eine Datei Zeile für Zeile lesen
+```
+import scala.io.Source
+for(line <- Source.fromFile("myfile.txt").getLines())
+ println(line)
+```
+
+// Eine Datei schreiben
+```
+val writer = new PrintWriter("myfile.txt")
+writer.write("Schreibe Zeile" + util.Properties.lineSeparator)
+writer.write("Und noch eine Zeile" + util.Properties.lineSeparator)
+writer.close()
+```
+
+## Weiterführende Hinweise
+
+// DE
+* [Scala Tutorial](https://scalatutorial.wordpress.com)
+* [Scala Tutorial](http://scalatutorial.de)
+
+// EN
+* [Scala for the impatient](http://horstmann.com/scala/)
+* [Twitter Scala school](http://twitter.github.io/scala_school/)
+* [The scala documentation](http://docs.scala-lang.org/)
+* [Try Scala in your browser](http://scalatutorials.com/tour/)
+* [Neophytes Guide to Scala](http://danielwestheide.com/scala/neophytes.html)
+* Join the [Scala user group](https://groups.google.com/forum/#!forum/scala-user)