summaryrefslogtreecommitdiffhomepage
path: root/de-de
diff options
context:
space:
mode:
Diffstat (limited to 'de-de')
-rw-r--r--de-de/java-de.html.markdown497
-rw-r--r--de-de/python3-de.html.markdown655
-rw-r--r--de-de/sass-de.html.markdown450
3 files changed, 1602 insertions, 0 deletions
diff --git a/de-de/java-de.html.markdown b/de-de/java-de.html.markdown
new file mode 100644
index 00000000..001c6888
--- /dev/null
+++ b/de-de/java-de.html.markdown
@@ -0,0 +1,497 @@
+---
+language: java
+filename: LearnJavaDe.java
+contributors:
+ - ["Jake Prather", "http://github.com/JakeHP"]
+ - ["Jakukyo Friel", "http://weakish.github.io"]
+ - ["Madison Dickson", "http://github.com/mix3d"]
+ - ["Simon Morgan", "http://sjm.io/"]
+translators:
+ - ["Michael Dähnert", "http://github.com/JaXt0r"]
+lang: de-de
+---
+
+Java ist eine Programmiersprache für vielfältige Aufgaben. Sie ist imperative und objektorientiert.
+Oftmals wird sie für Desktop- Webapplikationen sowie als Programmiersprache im Betriebssystem Android verwendet.
+[Weitere Informationen \(Englisch\](http://docs.oracle.com/javase/tutorial/java/)
+
+```java
+// Einzeilige Kommentare starten mit //
+/*
+Mehrzeilige Kommentare sehen so aus.
+*/
+/**
+JavaDoc Kommentare haben dieses Format. Sie werden verwendet um Klassen, Attribute sowie Methoden zu beschreiben.
+*/
+
+// Importieren der Klasse ArrayList aus dem Paket java.util
+import java.util.ArrayList;
+// Importieren aller Klassen innerhalb des Paketes java.security
+import java.security.*;
+
+// Jede .java Datei besteht aus einer äußeren öffentlichen (public) Klasse.
+// Der Name der Klasse muss identisch des Dateinamens sein.
+public class LearnJavaDe {
+
+ // Ein Programm muss eine main Methode als Eintrittspunkt besitzen.
+ public static void main (String[] args) {
+
+ // System.out.println() wird zum Schreiben von zeilenweisen Ausgaben verwendet.
+ System.out.println("Hello World!");
+ System.out.println(
+ "Integer: " + 10 +
+ " Double: " + 3.14 +
+ " Boolean: " + true);
+
+ // Zum Schreiben von Ausgaben ohne Zeilenumbruch wird System.out.print() verwendet.
+ System.out.print("Hello ");
+ System.out.print("World");
+
+
+ ///////////////////////////////////////
+ // Typen & Variablen
+ ///////////////////////////////////////
+
+ // Zum Deklarieren einer Variable nutze <type> <name>
+ // Byte - 8-bit vorzeichenbehaftete (signed), binäre Ganzzahl
+ // (-128 <= byte <= 127)
+ byte fooByte = 100;
+
+ // Short - 16-bit vorzeichenbehaftete (signed), binäre Ganzzahl
+ // (-32,768 <= short <= 32,767)
+ short fooShort = 10000;
+
+ // Integer - 32-bit vorzeichenbehaftete (signed), binäre Ganzzahl
+ // (-2,147,483,648 <= int <= 2,147,483,647)
+ int fooInt = 1;
+
+ // Long - 64-bit vorzeichenbehaftete (signed), binäre Ganzzahl
+ // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+ long fooLong = 100000L;
+ // L wird verwendet um zu kennzeichnen, dass ein Variablenwert vom Typ long ist.
+ // Ohne diesen Buchstaben wird die Zahl automatisch als Integer behandelt.
+
+ // Hinweis: Java besitzt keine vorzeichenlosen (unsigned) Typen.
+
+ // Float - Typ mit einfacher Genauigkeit (Single-precision), 32-bit IEEE 754 Fließkommazahl
+ float fooFloat = 234.5f;
+ // f wird verwendet um zu kennzeichnen, dass ein Variablenwert vom Typ float ist;
+ // Ohne diesen Buchstaben wird die Zahl automatisch als Integer behandelt.
+
+ // Double - Typ mit doppelter Genauigkeit (Double-precision), 64-bit IEEE 754 Fließkommazahl
+ double fooDouble = 123.4;
+
+ // Boolean - Wahr & Falsch (true & false)
+ boolean fooBoolean = true;
+ boolean barBoolean = false;
+
+ // Char - Ein einfacher 16-bit Unicode Buchstabe
+ char fooChar = 'A';
+
+ // final Variablen können von einem anderen Objekt nicht erneut zugeordnet werden.
+ final int HOURS_I_WORK_PER_WEEK = 9001;
+
+ // Zeichenketten (Strings)
+ String fooString = "My String Is Here!";
+
+ // \n ist ein Escape Zeichen welcher eine neue Zeile startet.
+ String barString = "Schreiben auf einer neuen Zeile?\nKein Problem!";
+ // \t ist ein Escape Zeichen welcher einen Tab-Zeichen anhängt.
+ String bazString = "Möchtest du einen Tabulator anhängen?\tKein Problem!";
+ System.out.println(fooString);
+ System.out.println(barString);
+ System.out.println(bazString);
+
+ // Arrays
+ // Die Arraygröße muss bei Instanziierung entschieden werden.
+ // Das folgende Format funktioniert bei Deklaration eines Arrays
+ // <datentyp>[] <variablenname> = new <datentyp>[<arraygröße>];
+ // <datentyp> <variablenname>[] = new <datentyp>[<arraygröße>];
+ int[] intArray = new int[10];
+ String[] stringArray = new String[1];
+ boolean boolArray[] = new boolean[100];
+
+ // Eine weitere Möglichkeit ein Array zu deklarieren & initialisieren.
+ int[] y = {9000, 1000, 1337};
+ String names[] = {"Bob", "John", "Fred", "Juan Pedro"};
+ boolean bools[] = new boolean[] {true, false, false};
+
+ // Indexierung eines Arrays - Zugriff auf ein Element
+ System.out.println("intArray @ 0: " + intArray[0]);
+
+ // Arrays sind 0-indexiert und veränderbar.
+ intArray[1] = 1;
+ System.out.println("intArray @ 1: " + intArray[1]); // => 1
+
+ // Weitere nennenswerte Typen
+ // ArrayLists - Ähnlich Arrays, allerdings werden mehr Funktionen geboten,
+ // ebenso ist die Arraygröße verwänderbar
+ // LinkedLists - Implementierung einer doppelt verlinkten Liste.
+ // Alle Operationen funktioneren so, wie es von einer doppelt verlinkten Liste erwartet wird.
+ // Weitere Informationen: https://de.wikipedia.org/wiki/Liste_(Datenstruktur)#Doppelt_.28mehrfach.29_verkettete_Liste
+ // Maps - Eine Sammlung von Objekten, welche eine Verknüpfung von Schlüsseln zu Werten (key => value) vornimmt.
+ // Eine Map kann keine Duplikate enthalten; Jeder Schlüssel kann genau einen Wert beinhalten.
+ // HashMaps - Diese Klasse nutzt eine Hashtabelle zur Implementierung eines Map Interfaces.
+ // Dies erlaubt es zur Laufzeit Standardoperationen wie gib (get) und einfügen (insert)
+ // selbst für große Mengen in einer konstanten Zeit auszuführen (Laufzeitverhalten O(n)).
+
+ ///////////////////////////////////////
+ // Operatoren
+ ///////////////////////////////////////
+ System.out.println("\n->Operatoren");
+
+ int i1 = 1, i2 = 2; // Kurform zur Deklaration mehrerer Variablen.
+
+ // Arithmetische Operationen sind einfach nutzbar.
+ System.out.println("1+2 = " + (i1 + i2)); // => 3
+ System.out.println("2-1 = " + (i2 - i1)); // => 1
+ System.out.println("2*1 = " + (i2 * i1)); // => 2
+ System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5 Nachkommazahl abgeschnitten)
+
+ // Modulo
+ System.out.println("11%3 = "+(11 % 3)); // => 2
+
+ // Vergleichsoperationen
+ System.out.println("3 == 2? " + (3 == 2)); // => false
+ System.out.println("3 != 2? " + (3 != 2)); // => true
+ System.out.println("3 > 2? " + (3 > 2)); // => true
+ System.out.println("3 < 2? " + (3 < 2)); // => false
+ System.out.println("2 <= 2? " + (2 <= 2)); // => true
+ System.out.println("2 >= 2? " + (2 >= 2)); // => true
+
+ // Bitwise Operatoren!
+ /*
+ ~ Unäres (unary) bitweise Komplement
+ << Vorzeichenbehaftete (signed) linke Verschiebung
+ >> Vorzeichenbehaftete (signed) rechte Verschiebung
+ >>> Vorzeichenlose (unsigned) linke Verschiebung
+ & Bitweise UND (AND)
+ ^ Bitweise exklusive ODER (OR)
+ | Bitweise inklusive ODER (OR)
+ */
+
+ // Inkrementierungen
+ int i = 0;
+ System.out.println("\n->Inc/Dec-rementierung");
+ // Die ++ und -- operatoren inkrementieren und dekrementieren jeweils um 1.
+ // Werden sie vor die Variable gesetzt, ink-/dekrementieren sie und geben anschließend ihren Wert zurück.
+ // Hinter der Variable geben sie ihren Wert zurück und ändern ihn anschließend.
+ System.out.println(i++); // i = 1, schreibt 0 (post-increment)
+ System.out.println(++i); // i = 2, schreibt 2 (pre-increment)
+ System.out.println(i--); // i = 1, schreibt 2 (post-decrement)
+ System.out.println(--i); // i = 0, schreibt 0 (pre-decrement)
+
+ ///////////////////////////////////////
+ // Kontrollstrukturen
+ ///////////////////////////////////////
+ System.out.println("\n->Kontrollstrukturen");
+
+ // If Bedingungen sind wie in den C-Sprachen aufgebaut
+ int j = 10;
+ if (j == 10){
+ System.out.println("Ich wurde geprinted");
+ } else if (j > 10) {
+ System.out.println("Ich nicht");
+ } else {
+ System.out.println("Ich auch nicht");
+ }
+
+ // While Schleife
+ int fooWhile = 0;
+ while(fooWhile < 100) {
+ System.out.println(fooWhile);
+ // Den Zähler inkrementieren
+ // 100x iterieren, fooWhile 0,1,2...99
+ fooWhile++;
+ }
+ System.out.println("fooWhile Wert: " + fooWhile);
+
+ // Do While Schleife
+ int fooDoWhile = 0;
+ do {
+ System.out.println(fooDoWhile);
+ // Den Zähler inkrementieren
+ // 99x iterieren, fooDoWhile 0->99
+ fooDoWhile++;
+ } while(fooDoWhile < 100);
+ System.out.println("fooDoWhile Wert: " + fooDoWhile);
+
+ // For Schleife
+ int fooFor;
+ // for Schleifenstruktur => for(<start_statement>; <Bedingung>; <Schritt>)
+ for (fooFor = 0; fooFor < 10; fooFor++) {
+ System.out.println(fooFor);
+ // 10x iterieren, fooFor 0->9
+ }
+ System.out.println("fooFor Wert: " + fooFor);
+
+ // For Each Schleife
+ // The for Schleife kann verwendet werden um über Arrays ebenso wie Objekte,
+ // welche das Interface Iterable implementieren zu iterieren.
+ int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+ // for each Schleifenstruktur => for (<Objekt> : <iterable>)
+ // Wird gelesen als: Iteriere für jedes Element im Iterable
+ // Hinweis: Der Objekttyp muss dem Elementtyp des Iterable entsprechen.
+
+ for (int bar : fooList) {
+ System.out.println(bar);
+ //9x iterieren und die Werte 1-9 auf jeweils einer neuen Zeile schreiben
+ }
+
+ // Switch Case
+ // A Schalter (switch) funktioniert mit den Datentypen byte, short, char und int.
+ // Ebenso kann er für Aufzählungen (Enums) verwendet werden (Enum Typen folgen weiter unten)
+ // der String Klasse (ab Java SE7) und ein paar spezielle Klassen, welche die primitiven Typen ummanteln (wrap):
+ // Character, Byte, Short, and Integer.
+ int monat = 3;
+ String monatsString;
+ switch (monat) {
+ case 1: monatsString = "Januar";
+ break;
+ case 2: monatsString = "Februar";
+ break;
+ case 3: monatsString = "März";
+ break;
+ default: monatsString = "Ein anderer Monat";
+ break;
+ }
+ System.out.println("Switch Case Ergebnis: " + monatsString);
+
+ // Bedingungsoperator (Conditional Shorthand)
+ // Der Operator '?' kann für schnelle Zuweisungen oder logische Verzweigungen genutzt werden.
+ // Er ist wie folgt zu lesen: Wenn die Bedingung wahr ist, nutze <erster Wert>
+ // ansonsten nutze <zweiter Wert>
+ int foo = 5;
+ String bar = (foo < 10) ? "A" : "B";
+ System.out.println(bar); // Schreibt A, denn die Bedingung ist wahr.
+
+
+ ////////////////////////////////////////
+ // Typkonvertierung und Type-Casting
+ ////////////////////////////////////////
+
+ // Konvertierung von Daten
+
+ // Konvertiere String nach Integer
+ Integer.parseInt("123");// Gibt die Integer Repräsentation von "123" zurück
+
+ // Konvertiere String nach Integer
+ Integer.toString(123);// Gibt die String Repräsentation von 123 zurück
+
+ // Für andere Konvertierungen sind die folgenden Klassen zu betrachten:
+ // Double
+ // Long
+ // String
+
+ // Tpe-Casting
+ // Java Objekte können benfalls konvertiert werden, hierbei gibt es vielfältige Konzepte.
+ // Weitere Informationen finden sich hier (englisch):
+ // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+
+ ///////////////////////////////////////
+ // Klassen und Funktionen
+ ///////////////////////////////////////
+
+ System.out.println("\n->Klassen & Funktionen");
+
+ // (Die Definition der Klasse Fahrrad folgt)
+
+ // Verwendung einer neuen Klasseninstanz
+ Fahrrad trek = new Fahrrad();
+
+ // Aufruf von Methoden des Objektes
+ trek.erhöheGeschwindigkeit(3); // Es sollten immer getter- und setter- Methoden verwendet werden
+ trek.setTrittfrequenz(100);
+
+ // toString gibt die StringRepräsentation des Objektes zurück.
+ System.out.println("trek info: " + trek.toString());
+
+ } // Ende der Main Methode
+} // Ende der LearnJavaDe Klasse
+
+
+// In einer .java-Datei können zusätzliche nicht öffentliche (non-public) äüßere Klassen vorhanden sein.
+
+
+// Syntax der Klassendeklaration:
+// <public/private/protected> class <Klassenname> {
+// // Es folgen Datenfelder, Konstruktoren, Funktionen.
+// // Funktionen werden in Java Methoden genannt.
+// }
+
+class Fahrrad {
+
+ // Felder/Variablen der Klasse Fahrrad
+ public int trittfrequenz; // Public: Kann von überall her angesprochen werden
+ private int geschwindigkeit; // Private: Nur innerhalb der Klasse sichtbar
+ protected int gang; // Protected: Erreichbar innerhalb der Klasse oder Subklassen (sub classes)
+ String name; // default: Nur innerhalb des Paketes verwendbar
+
+ // Eine Klasse kann mittelst Konstruktoren erstellt werden.
+ // Das ist ein Konstruktor
+ public Fahrrad() {
+ gang = 1;
+ trittfrequenz = 50;
+ geschwindigkeit = 5;
+ name = "Bontrager";
+ }
+
+ // Das ist ein Konstruktor mit Argumenten
+ public Bicycle(int initialTrittfrequenz, int initialGeschwindigkeit, int initialGang,
+ String name) {
+ this.gang = initialGang;
+ this.trittfrequenz = initialTrittfrequenz;
+ this.geschwindigkeit = initialGeschwindigkeit;
+ this.name = name;
+ }
+
+ // Syntax von Methoden (Funktionen):
+ // <public/private/protected> <Rückgabetyp> <Funktionsname>(<Argumente>)
+
+ // Java Klassen implementieren oftmals getter- und setter-Methoden ihrer Felder
+
+ // Syntax von Methodendeklarationen:
+ // <Sichtbarkeit> <Rückgabetyp> <Methodenname>(<Argumente>)
+ public int getTrittfrequenz() {
+ return tri;
+ }
+
+ // void Methoden benötigen kein return Statement.
+ public void setCadence(int newValue) {
+ cadence = newValue;
+ }
+
+ public void setGear(int newValue) {
+ gear = newValue;
+ }
+
+ public void erhöheGeschwindigkeit(int increment) {
+ speed += increment;
+ }
+
+ public void verringereGeschwindigkeit(int decrement) {
+ speed -= decrement;
+ }
+
+ public void setName(String newName) {
+ name = newName;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ //Methode zur Darstellung der Attributwerte des Objektes.
+ @Override
+ public String toString() {
+ return "Gang: " + gang + " Trittfrequenz: " + trittfrequenz + " Geschwindigkeit: " + geschwindigkeit +
+ " name: " + name;
+ }
+} // Ende der Klasse Fahrrad
+
+// Hochrad ist eine Subklasse von Fahrrad
+class Hochrad extends Fahrrad {
+ // (Hochräder sind Fahrräder mit einem extrem großen Vorderrad.
+ // Sie haben keine Gänge.)
+
+ public Hochrad(int initialTrittfrequenz, int initialGeschwindigkeit){
+ // Aufruf des Vater-Konstruktors (parent constructor) mit dem Wort super.
+ super(initialTrittfrequenz, initialGeschwindigkeit, 0, "Hochrad");
+ }
+
+ // Überschriebene Methoden sollten die Annotation @Override besitzen.
+ // Mehr zu Annotationen und deren Verwendungszwecken kann hier nachgelesen werden:
+ // (englisch) http://docs.oracle.com/javase/tutorial/java/annotations/
+ @Override
+ public void setGang(int gang) {
+ gang = 0;
+ }
+}
+
+// Schnittstellen (Interfaces)
+// Interface Deklaration
+// <Zugriffsrecht> interface <Name> extends <super-Interface> {
+// // Konstanten
+// // Methodendeklarationen
+// }
+
+// Beispiel - Nahrung:
+public interface Essbar {
+ public void essen(); // Jede Klasse, die dieses Interface implementiert
+ // muss auch diese Methode implementieren.
+}
+
+
+public interface Verdaulich {
+ public void verdauen();
+}
+
+
+// Nun können wir eine Klasse erstellen, die beide Interfaces implementiert.
+public class Frucht implements Essbar, Verdaulich {
+ @Override
+ public void essen() {
+ // ...
+ }
+
+ @Override
+ public void verdauen() {
+ // ...
+ }
+}
+
+// Mit Java kann man nur eine Klasse erweitern (extends) jedoch mehrere Interfaces implementieren.
+// z.B.:
+public class BeispielKlasse extends ParentBeispielKlasse implements InterfaceEins,
+ InterfaceZwei {
+ @Override
+ public void methodeInterfaceEins() {
+ }
+
+ @Override
+ public void methodeInterfaceZwei() {
+ }
+}
+```
+
+## Weitere Informationen (in englisch)
+
+Die folgenden Links dienen lediglich dazu Verständnis für die Kapitel aufzubauen.
+Für tiefergreifende Fragen ist Google der beste Startpunkt.
+
+**Offizielle Oracle Guides**:
+
+* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
+
+* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+ * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+ * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+ * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html)
+
+**Online Tutorials**
+
+* [Learneroo.com - Learn Java](http://www.learneroo.com)
+
+* [Codingbat.com](http://codingbat.com/java)
+
+
+**Bücher**:
+
+* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
+
+* [Thinking in Java](http://www.mindview.net/Books/TIJ/)
+
+* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
+
+* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)
diff --git a/de-de/python3-de.html.markdown b/de-de/python3-de.html.markdown
new file mode 100644
index 00000000..ef1786c8
--- /dev/null
+++ b/de-de/python3-de.html.markdown
@@ -0,0 +1,655 @@
+---
+language: python3
+contributors:
+ - ["Louie Dinh", "http://ldinh.ca"]
+translators:
+ - ["kultprok", "http:/www.kulturproktologie.de"]
+ - ["matthiaskern", "https://github.com/matthiaskern"]
+filename: learnpython3-de.py
+lang: de-de
+---
+
+Anmerkungen des ursprünglichen Autors:
+Python wurde in den frühen Neunzigern von Guido van Rossum entworfen. Es ist heute eine der beliebtesten Sprachen. Ich habe mich in Python wegen seiner syntaktischen Übersichtlichkeit verliebt. Eigentlich ist es ausführbarer Pseudocode.
+
+Feedback ist herzlich willkommen! Ihr erreicht mich unter [@louiedinh](http://twitter.com/louiedinh) oder louiedinh [at] [google's email service].
+
+Hinweis: Dieser Beitrag bezieht sich insplizit auf Python 3. Falls du lieber Python 2.7 lernen möchtest, schau [hier](http://learnxinyminutes.com/docs/python/) weiter.
+
+```python
+
+# Einzeilige Kommentare beginnen mit einer Raute (Doppelkreuz)
+
+""" Mehrzeilige Strings werden mit
+ drei '-Zeichen geschrieben und werden
+ oft als Kommentare genutzt.
+"""
+
+####################################################
+## 1. Primitive Datentypen und Operatoren
+####################################################
+
+# Die Zahlen
+3 #=> 3
+
+# Mathematik funktioniert so, wie man das erwartet
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+
+# Außer Division, welche automatisch Gleitkommazahlen zurückgibt
+35 / 5 # => 7.0
+
+# Eine Division kann mit "//" für positive sowie negative Werte abgerundet werden.
+5 // 3 # => 1
+5.0 // 3.0 # => 1.0 # works on floats too
+-5 // 3 # => -2
+-5.0 // 3.0 # => -2.0
+
+# Benutzt man eine Gleitkommazahl, ist auch das Ergebnis eine solche
+3 * 2.0 # => 6.0
+
+# Der Rest einer Division
+7 % 3 # => 1
+
+# Potenz
+2**4 # => 16
+
+# Rangfolge wird mit Klammern erzwungen
+(1 + 3) * 2 #=> 8
+
+# Boolesche Ausdrücke sind primitive Datentypen
+True
+False
+
+# Mit not wird negiert
+not True #=> False
+not False #=> True
+
+# Boolesche Operatoren
+# Hinweis: "and" und "or" müssen klein geschrieben werden
+True and False #=> False
+False or True #=> True
+
+# Für die Benutzung von Booleschen Operatoren und ganzen Zahlen
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True
+2 == True #=> False
+1 == True #=> True
+
+# Gleichheit ist ==
+1 == 1 #=> True
+2 == 1 #=> False
+
+# Ungleichheit ist !=
+1 != 1 #=> False
+2 != 1 #=> True
+
+# Ein paar weitere Vergleiche
+1 < 10 #=> True
+1 > 10 #=> False
+2 <= 2 #=> True
+2 >= 2 #=> True
+
+# Vergleiche können verknüpft werden!
+1 < 2 < 3 #=> True
+2 < 3 < 2 #=> False
+
+# Strings werden mit " oder ' gebildet
+"Das ist ein String."
+'Das ist auch ein String.'
+
+# Strings können auch addiert werden! Vermeide dies aber lieber.
+"Hallo " + "Welt!" #=> "Hallo Welt!"
+# Strings können ohne "+" addiert werden
+"Hallo " "welt!" # => "Hallo Welt!"
+
+# Ein String kann wie eine Liste von Zeichen verwendet werden
+"Das ist ein String"[0] #=> 'D'
+
+# .format kann Strings formatieren
+"{} können {} werden".format("Strings", "formatiert")
+
+# Schneller geht das mit Wiederholungen
+"{0} mag Spagetthi, {0} liebt es zu Schwimmen und ganz besonders mag {0} {1}".format("Hans", "Blattsalat")
+#=> "Hans mag Spagetthi, Hans liebt es zu Schwimmen und ganz besonders mag Hans Blattsalat"
+
+# Wir können Schlüsselwörter verwenden, wenn wir nicht abzählen wollen.
+"{name} will {food} essen".format(name="Bob", food="Lasagne")
+#=> "Bob will Lasagne kochen"
+
+#Falls dein Python 3 Code auch unter Python 2.5 oder darunter laufen soll, kann das alte Format benutzt werden:
+"%s können %s werden" % ("Strings", "interpoliert")
+
+
+# None ist ein Objekt
+None #=> None
+
+# Verwendet nicht das Symbol für Gleichheit `==`, um Objekte mit None zu vergleichen
+# Benutzt stattdessen `is`. Dieser Operator testet Objektidentität
+"etc" is None #=> False
+None is None #=> True
+
+
+
+# None, 0, und leere Strings/Listen werden alle als False bewertet.
+# Alle anderen Werte sind True
+bool(0) # => False
+bool("") # => False
+bool([]) #=> False
+bool({}) #=> False
+
+
+####################################################
+## 2. Variablen und Collections
+####################################################
+
+# Textausgabe ist sehr einfach
+print "Ich bin Python. Schön, dich kennenzulernen!"
+
+# Es gibt keinen Grund, Variablen vor der Zuweisung zu deklarieren.
+some_var = 5 # kleinschreibung_mit_unterstrichen entspricht der Norm
+some_var #=> 5
+
+# Das Ansprechen einer noch nicht deklarierte Variable löst eine Exception aus.
+# Unter "Kontrollstruktur" kann noch mehr über
+# Ausnahmebehandlung erfahren werden.
+some_unknown_var # Löst einen NameError aus
+
+# Listen speichern Sequenzen
+li = []
+# Wir können mit einer bereits gefüllten Liste anfangen
+other_li = [4, 5, 6]
+
+# append fügt Daten am Ende der Liste ein
+li.append(1) #li ist jetzt [1]
+li.append(2) #li ist jetzt [1, 2]
+li.append(4) #li ist jetzt [1, 2, 4]
+li.append(3) #li ist jetzt [1, 2, 4, 3]
+# Vom Ende der Liste mit pop entfernen
+li.pop() #=> 3 und li ist jetzt [1, 2, 4]
+# und dann wieder hinzufügen
+li.append(3) # li ist jetzt wieder [1, 2, 4, 3].
+
+# Greife auf Listen wie auf Arrays zu
+li[0] #=> 1
+# Das letzte Element ansehen
+li[-1] #=> 3
+
+# Bei Zugriffen außerhalb der Liste kommt es jedoch zu einem IndexError
+li[4] # Verursacht einen IndexError
+
+# Wir können uns Ranges mit Slice-Syntax ansehen
+li[1:3] #=> [2, 4]
+# Den Anfang auslassen
+li[2:] #=> [4, 3]
+# Das Ende auslassen
+li[:3] #=> [1, 2, 4]
+# Jeden Zweiten Eintrag auswählen
+li[::2] # =>[1, 4]
+# Eine umgekehrte Kopie zurückgeben
+li[::-1] # => [3, 4, 2, 1]
+# Jegliche Kombination dieser Syntax machen fortgeschrittene Slices möglich
+# li[Start:Ende:Schritt]
+
+# Ein bestimmtes Element mit del aus der Liste entfernen
+del li[2] # li ist jetzt [1, 2, 3]
+
+# Listen können addiert werden
+li + other_li #=> [1, 2, 3, 4, 5, 6] - Hinweis: li und other_li werden in Ruhe gelassen
+
+# Listen mit extend verknüpfen
+li.extend(other_li) # Jetzt ist li [1, 2, 3, 4, 5, 6]
+
+# Mit in auf Existenz eines Elements prüfen
+1 in li #=> True
+
+# Die Länge der Liste mit len ermitteln
+len(li) #=> 6
+
+
+# Tupel sind wie Listen, nur unveränderlich.
+tup = (1, 2, 3)
+tup[0] #=> 1
+tup[0] = 3 # Löst einen TypeError aus
+
+# Wir können all diese Listen-Dinge auch mit Tupeln anstellen
+len(tup) #=> 3
+tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
+tup[:2] #=> (1, 2)
+2 in tup #=> True
+
+# Wir können Tupel (oder Listen) in Variablen entpacken
+a, b, c = (1, 2, 3) # a ist jetzt 1, b ist jetzt 2 und c ist jetzt 3
+# Tupel werden standardmäßig erstellt, wenn wir uns die Klammern sparen
+d, e, f = 4, 5, 6
+# Es ist kinderleicht zwei Werte zu tauschen
+e, d = d, e # d is now 5 and e is now 4
+
+
+# Dictionarys (Wörterbucher) speichern Schlüssel-Werte-Paare
+empty_dict = {}
+# Hier ein gefülltes Wörterbuch
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Wir können Einträge mit [] nachschlagen
+filled_dict["one"] #=> 1
+
+# So holen wir alle Keys (Schlüssel) als Liste
+list(filled_dict.keys()) #=> ["three", "two", "one"]
+# Hinweis - Die Reihenfolge von Schlüsseln in der Liste ist nicht garantiert.
+# Einzelne Resultate können anders angeordnet sein.
+
+# Alle Values (Werte) als Liste
+list(filled_dict.values()) #=> [3, 2, 1]
+# Hinweis - Hier gelten dieselben Einschränkungen für die Reihenfolge wie bei Schlüsseln.
+
+# Das Vorhandensein eines Schlüssels im Wörterbuch mit "in" prüfen
+"one" in filled_dict #=> True
+1 in filled_dict #=> False
+
+# Einen nicht vorhandenenen Schlüssel zu suchen, löst einen KeyError aus
+filled_dict["four"] # KeyError
+
+# Mit der get-Methode verhindern wir das
+filled_dict.get("one") #=> 1
+filled_dict.get("four") #=> None
+# Die get-Methode unterstützt auch ein Standardargument, falls der Wert fehlt
+filled_dict.get("one", 4) #=> 1
+filled_dict.get("four", 4) #=> 4
+
+# Die setdefault-Methode ist ein sicherer Weg, ein neues Schlüssel-Wert-Paar anzulegen
+filled_dict.setdefault("five", 5) #filled_dict["five"] wird auf 5 gesetzt
+filled_dict.setdefault("five", 6) #filled_dict["five"] ist noch immer 5
+
+# Einträge zu einem Wörterbuch hinzufügen
+filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
+#filled_dict["four"] = 4 # noch ein Weg, Werte hinzuzufügen
+
+# Schlüssel von einem Wörterbuch entfernen
+del filled_dict["one"] # Entfert den Schlüssel "one"
+
+
+# Sets speichern Mengen
+empty_set = set()
+# Initialisieren wir ein Set mit ein paar Werten
+some_set = {1, 1, 2, 2, 3, 4} # some_set ist jetzt {1, 2, 3, 4}
+
+# Neue Variablen können einer Menge gleichgesetzt werden
+filled_set = some_set
+
+# Mehr Elemente hinzufügen
+filled_set.add(5) # filled_set ist jetzt {1, 2, 3, 4, 5}
+
+# Schnittmengen werden mit & gebildet
+other_set = {3, 4, 5, 6}
+filled_set & other_set #=> {3, 4, 5}
+
+# Mengen werden mit | vereinigt
+filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
+
+# Die Differenz einer Menge mit - bilden
+{1,2,3,4} - {2,3,5} #=> {1, 4}
+
+# Auf Vorhandensein von Elementen mit in prüfen
+2 in filled_set #=> True
+10 in filled_set #=> False
+
+
+####################################################
+## 3. Kontrollstruktur und Iteratoren
+####################################################
+
+# Erstellen wir mal eine Variable
+some_var = 5
+
+# Hier eine if-Anweisung. Die Einrückung ist in Python wichtig!
+# gibt "some_var ist kleiner als 10" aus
+if some_var > 10:
+ print "some_var ist viel größer als 10."
+elif some_var < 10: # Dieser elif-Absatz ist optional.
+ print "some_var ist kleiner als 10."
+else: # Das hier ist auch optional.
+ print "some_var ist tatsächlich 10."
+
+
+"""
+For-Schleifen iterieren über Listen
+Ausgabe:
+ hund ist ein Säugetier
+ katze ist ein Säugetier
+ maus ist ein Säugetier
+"""
+for animal in ["hund", "katze", "maus"]:
+ # Wir können Strings mit format() formatieren
+ print("{} ist ein Säugetier".format(animal))
+
+"""
+`range(Zahl)` gibt eine null-basierte Liste bis zur angegebenen Zahl wieder
+Ausgabe:
+ 0
+ 1
+ 2
+ 3
+"""
+for i in range(4):
+ print i
+
+"""
+"range(unten, oben)" gibt eine Liste von der unteren Zahl bis zur oberen Zahl aus
+Ausgabe:
+ 4
+ 5
+ 6
+ 7
+"""
+for i in range(4, 8):
+ print(i)
+
+"""
+While-Schleifen laufen, bis eine Bedingung erfüllt ist.
+Ausgabe:
+ 0
+ 1
+ 2
+ 3
+"""
+x = 0
+while x < 4:
+ print x
+ x += 1 # Kurzform für x = x + 1
+
+# Ausnahmebehandlung mit einem try/except-Block
+try:
+ # Mit raise wird ein Fehler ausgegeben
+ raise IndexError("Das hier ist ein Index-Fehler")
+except IndexError as e:
+ pass # Pass ist nur eine no-op. Normalerweise würden wir hier den Fehler klären.
+except (TypeError, NameError):
+ pass # Mehrere Fehler können zusammen geklärt werden, falls erforderlich.
+else: # Optional, hinter allen except-Blöcken
+ print("Keine Probleme!") # Wird nur ausgeführt, wenn keine Ausnahmen aufgetreten sind
+finally: # Wird immer ausgeführt
+ print("Hier können wir Ressourcen aufräumen")
+
+# alternativ zu einem try/finally Block um Aufzuräumen:
+with open("meineDatei.txt") as f:
+ for line in f:
+ print(line)
+
+# Python bietet ein fundamentales Konzept der Iteration.
+# Das Objekt, auf das die Interation, also die Wiederholung einer Methode angewandt wird heißt auf Englisch "iterable".
+# Die range Method gibt ein solches Objekt aus.
+
+filled_dict = {"one": 1, "two": 2, "three": 3}
+our_iterable = filled_dict.keys()
+print(our_iterable) #=> range(1,10). Dies ist ein "iterable" Objekt.
+
+# Über dieses können wir auch iterieren
+for i in our_iterable:
+ print(i) # Gibt one, two, three aus
+
+# Allerdings können wir die einzelnen Elemente nicht mit ihrem index ausgeben
+our_iterable[1] # TypeError
+
+# Ein iterable ist ein Objekt, das weiß wie es einen Iteratoren erschafft.
+our_iterator = iter(our_iterable)
+
+# Unser Iterator ist ein Objekt, das sich merkt, welchen Status es geraden hat während wir durch es gehen.
+# Das jeweeils nächste Objekt bekommen wir mit "next()"
+next(our_iterator) #=> "one"
+
+# Es hält den vorherigen Status
+next(our_iterator) #=> "two"
+next(our_iterator) #=> "three"
+
+# Nachdem alle Daten ausgegeben worden sind, kommt eine StopIterator Ausnahme zurück
+next(our_iterator) # Gibt StopIteration aus
+
+# Alle Elemente können mit "list()" ausgegeben werden
+list(filled_dict.keys()) #=> ["one", "two", "three"]
+
+
+
+####################################################
+## 4. Funktionen
+####################################################
+
+# Mit def neue Funktionen erstellen
+def add(x, y):
+ print "x ist %s und y ist %s" % (x, y)
+ return x + y # Werte werden mit return zurückgegeben
+
+# Funktionen mit Parametern aufrufen
+add(5, 6) #=> Ausgabe ist "x ist 5 und y ist 6" und gibt 11 zurück
+
+# Ein anderer Weg des Funktionsaufrufs sind Schlüsselwort-Argumente
+add(y=6, x=5) # Schlüsselwörter können in beliebiger Reihenfolge übergeben werden.
+
+# Wir können Funktionen mit beliebiger Anzahl von # Positionsargumenten definieren
+def varargs(*args):
+ return args
+
+varargs(1, 2, 3) #=> (1,2,3)
+
+
+# Wir können auch Funktionen mit beliebiger Anzahl
+# Schlüsselwort-Argumenten definieren
+def keyword_args(**kwargs):
+ return kwargs
+
+# Rufen wir es mal auf, um zu sehen, was passiert
+keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
+
+# Wir können beides gleichzeitig machem, wenn wir wollen
+def all_the_args(*args, **kwargs):
+ print args
+ print kwargs
+"""
+all_the_args(1, 2, a=3, b=4) Ausgabe:
+ (1, 2)
+ {"a": 3, "b": 4}
+"""
+
+# Beim Aufruf von Funktionen können wir das Gegenteil von varargs/kwargs machen!
+# Wir benutzen dann *, um Tupel auszuweiten, und ** für kwargs.
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+all_the_args(*args) # äquivalent zu foo(1, 2, 3, 4)
+all_the_args(**kwargs) # äquivalent zu foo(a=3, b=4)
+all_the_args(*args, **kwargs) # äquivalent zu foo(1, 2, 3, 4, a=3, b=4)
+
+
+# Anwendungsbereich von Funktionen
+x = 5
+
+def setX(num):
+ # lokale Variable x ist nicht die globale Variable x
+ x = num # => 43
+ print (x) # => 43
+
+def setGlobalX(num):
+ global x
+ print (x) # => 5
+ x = num # globale Variable x ist jetzt 6
+ print (x) # => 6
+
+setX(43)
+setGlobalX(6)
+
+
+# Python hat First-Class-Funktionen
+def create_adder(x):
+ def adder(y):
+ return x + y
+ return adder
+
+add_10 = create_adder(10)
+add_10(3) #=> 13
+
+# Es gibt auch anonyme Funktionen
+(lambda x: x > 2)(3) #=> True
+
+# Es gibt auch Funktionen höherer Ordnung als Built-Ins
+map(add_10, [1,2,3]) #=> [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
+
+# Wir können bei map- und filter-Funktionen auch List Comprehensions einsetzen
+[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+
+####################################################
+## 5. Klassen
+####################################################
+
+# Wir bilden die Unterklasse eines Objekts, um Klassen zu erhalten.
+class Human(object):
+
+ # Ein Klassenattribut. Es wird von allen Instanzen einer Klasse geteilt
+ species = "H. sapiens"
+
+ # Ein simpler Konstruktor
+ def __init__(self, name):
+ # Wir weisen das Argument name dem name-Attribut der Instanz zu
+ self.name = name
+
+ # Eine Instanzmethode. Alle Methoden erhalten self als erstes Argument.
+ def say(self, msg):
+ return "{name}: {message}".format(name=self.name, message=msg)
+
+ # Eine Klassenmethode wird von allen Instanzen geteilt.
+ # Sie werden mit der aufrufenden Klasse als erstem Argument aufgerufen
+ @classmethod
+ def get_species(cls):
+ return cls.species
+
+ # Eine statische Methode wird ohne Klasse oder Instanz aufgerufen
+ @staticmethod
+ def grunt():
+ return "*grunt*"
+
+
+# Eine Instanz einer Klasse erstellen
+i = Human(name="Ian")
+print i.say("hi") # gibt "Ian: hi" aus
+
+j = Human("Joel")
+print j.say("hello") #gibt "Joel: hello" aus
+
+# Rufen wir mal unsere Klassenmethode auf
+i.get_species() #=> "H. sapiens"
+
+# Ändern wir mal das gemeinsame Attribut
+Human.species = "H. neanderthalensis"
+i.get_species() #=> "H. neanderthalensis"
+j.get_species() #=> "H. neanderthalensis"
+
+# Aufruf der statischen Methode
+Human.grunt() #=> "*grunt*"
+
+
+####################################################
+## 6. Module
+####################################################
+
+# Wir können Module importieren
+import math
+print math.sqrt(16) #=> 4
+
+# Wir können auch nur spezielle Funktionen eines Moduls importieren
+from math import ceil, floor
+print ceil(3.7) #=> 4.0
+print floor(3.7) #=> 3.0
+
+# Wir können auch alle Funktionen eines Moduls importieren
+# Warnung: Dies wird nicht empfohlen
+from math import *
+
+# Wir können Modulnamen abkürzen
+import math as m
+math.sqrt(16) == m.sqrt(16) #=> True
+
+# Module sind in Python nur gewöhnliche Dateien. Wir
+# können unsere eigenen schreiben und importieren. Der Name des
+# Moduls ist der Dateiname.
+
+# Wir können auch die Funktionen und Attribute eines
+# Moduls herausfinden.
+import math
+dir(math)
+
+
+####################################################
+## 7. Fortgeschritten
+####################################################
+
+# Generatoren helfen um Code schnell und einfach zu schreiben
+def double_numbers(iterable):
+ for i in iterable:
+ yield i + i
+
+# Ein Generator erschafft Werte spontan
+# Statt alle Werte auf einmal, wird bei jeder Iteration einer erschaffen.
+# iteration. Das heißt, Werte größer als 15 werden nicht behandelt.
+# Die range-Methode ist auch ein Generator. Im Fall einer Liste von 1-900000000
+# würde das sehr viel Zeit in Anspruch nehmen.
+# Wenn wir eine variable mit einem Namen erschaffen wollen, das
+# normalerweise mit einem Python - Schlüsselwort kollidieren würde,
+# benutzen wir einen Unterstrich nach dem Wort.
+range_ = range(1, 900000000)
+# Alle Nummern bis zu einem Ergebnis von >=30 werden verdoppelt
+for i in double_numbers(range_):
+ print(i)
+ if i >= 30:
+ break
+
+
+# Dekoratoren
+# In diesem Beispiel die Methode beg umwickelt say
+# Beim Aufruf von beg, say wird aufgerufen
+# Falls say_please true ist, ändert sich die ausgegebene Nachricht
+from functools import wraps
+
+
+def beg(target_function):
+ @wraps(target_function)
+ def wrapper(*args, **kwargs):
+ msg, say_please = target_function(*args, **kwargs)
+ if say_please:
+ return "{} {}".format(msg, "Please! I am poor :(")
+ return msg
+
+ return wrapper
+
+
+@beg
+def say(say_please=False):
+ msg = "Can you buy me a beer?"
+ return msg, say_please
+
+
+print(say()) # Can you buy me a beer?
+print(say(say_please=True)) # Can you buy me a beer? Please! I am poor :(
+
+```
+
+## Lust auf mehr?
+
+### Kostenlos online (Englisch)
+
+* [Automate the Boring Stuff with Python](https://automatetheboringstuff.com)
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [The Official Docs](http://docs.python.org/3/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+* [Python Course](http://www.python-course.eu/index.php)
+* [First Steps With Python](https://realpython.com/learn/python-first-steps/)
+
+### Totholz (Englisch)
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
diff --git a/de-de/sass-de.html.markdown b/de-de/sass-de.html.markdown
new file mode 100644
index 00000000..0c14e249
--- /dev/null
+++ b/de-de/sass-de.html.markdown
@@ -0,0 +1,450 @@
+---
+language: sass
+filename: learnsass-de.scss
+contributors:
+ - ["Laura Kyle", "https://github.com/LauraNK"]
+ - ["Sean Corrales", "https://github.com/droidenator"]
+ - ["Kyle Mendes", "https://github.com/pink401k"]
+translators:
+ - ["Philipp Bochmann", "https://github.com/phbo85"]
+lang: de-de
+---
+Sass ist eine CSS-erweiternde Sprache, welche Features wie Variablen, Verschachtelung, Mixins und mehr hinzufügt.
+Sass (und andere Präprozessoren wie [Less](http://lesscss.org/)) helfen Entwicklern dabei ihren Code wartbar und DRY (Don't Repeat Yourself - wiederhole dich nicht) zu schreiben.
+
+Sass hat zwei verschiedene Syntax-Optionen. SCSS, mit der gleichen Syntax wie CSS aber mit den zusätzlichen Features von Sass. Oder Sass (die originale Syntax), welche Einrückung statt geschweiften Klammern und Semikolons benutzt.
+Dieses Tutorial wurde mit SCSS geschrieben.
+
+Wenn du bereits mit CSS3 vertraut bist, wirst du dir Sass relativ schnell aneignen. Es bietet keine neuen Styling-Eigenschaft, sondern Werkzeuge mit denen du dein CSS effizienter schreiben kannst und die Wartung viel einfacher machst.
+
+
+```scss
+
+
+//Einzeilige Kommentare werden entfernt, wenn Sass zu CSS kompiliert wird.
+
+/* Mehrzeilige Kommentare bleiben bestehen. */
+
+
+
+/* Variablen
+============================== */
+
+
+
+/* Du kannst einen CSS-Wert (wie eine Farbe) in einer Variable speichern.
+Benutze das '$'-Zeichen um eine Variable zu erstellen. */
+
+$primary-color: #A3A4FF;
+$secondary-color: #51527F;
+$body-font: 'Roboto', sans-serif;
+
+/* Du kannst die Variablen überall in deinem Stylesheet verwenden.
+Wenn du nun eine Farbe ändern willst, musst du das nur einmal tun. */
+
+body {
+ background-color: $primary-color;
+ color: $secondary-color;
+ font-family: $body-font;
+}
+
+/* Das wird kompiliert zu: */
+body {
+ background-color: #A3A4FF;
+ color: #51527F;
+ font-family: 'Roboto', sans-serif;
+}
+
+
+/* Dies ist viel besser wartbar als die Farbe
+an jeder Stelle im Stylesheet einzeln ändern zu müssen. */
+
+
+
+/* Mixins
+============================== */
+
+
+
+/* Wenn du merkst, dass du den gleichen Code für mehr als ein
+Element schreiben musst, kannst du ihn in einem mixin speichern.
+
+Dazu benutzt du '@mixin' plus einem Namen für dein mixin. */
+
+@mixin center {
+ display: block;
+ margin-left: auto;
+ margin-right: auto;
+ left: 0;
+ right: 0;
+}
+
+/* Du kannst das mixin mit '@include' und dem Namen des mixin benutzen. */
+
+div {
+ @include center;
+ background-color: $primary-color;
+}
+
+/* Das kompiliert zu: */
+div {
+ display: block;
+ margin-left: auto;
+ margin-right: auto;
+ left: 0;
+ right: 0;
+ background-color: #A3A4FF;
+}
+
+
+/* Du kannst Mixins benutzen, um shorthand Eigenschaften zu erstellen. */
+
+@mixin size($width, $height) {
+ width: $width;
+ height: $height;
+}
+
+/* Diese kannst du aufrufen und width und height als Parameter übergeben. */
+
+.rectangle {
+ @include size(100px, 60px);
+}
+
+.square {
+ @include size(40px, 40px);
+}
+
+/* Compiles to: */
+.rectangle {
+ width: 100px;
+ height: 60px;
+}
+
+.square {
+ width: 40px;
+ height: 40px;
+}
+
+
+
+/* Funktionen
+============================== */
+
+
+
+/* Sass bietet Funktionen, welche benutzt werden können um eine Reihe
+ von Aufgaben zu bewältigen. Berücksichtige das Folgende: */
+
+/* Funktionen können aufgerufen werden indem du ihren Namen benutzt
+ und die benötigten Parameter übergibst. */
+body {
+ width: round(10.25px);
+}
+
+.footer {
+ background-color: fade_out(#000000, 0.25)
+}
+
+/* Kompiliert: */
+
+body {
+ width: 10px;
+}
+
+.footer {
+ background-color: rgba(0, 0, 0, 0.75);
+}
+
+/* Du kannst auch deine eigenen Funktionen definieren. Funktionen ähneln
+ Mixins. Wenn du zwischen Funktionen und Mixins auswählen musst, denke
+ daran, dass Mixins am besten zur Generierung von CSS eignen, während
+ Funktionen besser für Logik in deinem Sass Code genutzt werden. Die
+ Beispiele mit in der Sektion "Mathematische Operatoren" sind ideale
+ Kandidaten für wiederverwendbare Funktionen. */
+
+/* Diese Funktion errechnet den Prozentwert aus target-size und parent-size
+ und gibt diesen zurück. */
+
+@function calculate-percentage($target-size, $parent-size) {
+ @return $target-size / $parent-size * 100%;
+}
+
+$main-content: calculate-percentage(600px, 960px);
+
+.main-content {
+ width: $main-content;
+}
+
+.sidebar {
+ width: calculate-percentage(300px, 960px);
+}
+
+/* Kompiliert: */
+
+.main-content {
+ width: 62.5%;
+}
+
+.sidebar {
+ width: 31.25%;
+}
+
+
+
+/* Extend (Vererbung)
+============================== */
+
+
+
+/* Extend ist ein Weg um Eigenschaften eines Selektoren mit einem anderem
+ zu teilen. */
+
+.display {
+ @include size(5em, 5em);
+ border: 5px solid $secondary-color;
+}
+
+.display-success {
+ @extend .display;
+ border-color: #22df56;
+}
+
+/* Kompiliert: */
+.display, .display-success {
+ width: 5em;
+ height: 5em;
+ border: 5px solid #51527F;
+}
+
+.display-success {
+ border-color: #22df56;
+}
+
+/* Aufgrund der Art wie Sass die Klassen zusammen gruppiert, welche
+ alle das gleiche Grund-Styling haben, ist Extend der Erstellung
+ eines Mixins vorzuziehen. Wenn dies mit einem Mixin gemacht worden
+ wäre, würden width, height und border für jedes Element dupliziert
+ werden, welches das Mixin aufruft. Dies beeinflusst zwar nicht
+ deinen Workflow, bläht aber die vom Sass-Compiler erzeugten Dateien
+ unnötige auf. */
+
+
+
+/* Nesting (Verschachtelung)
+============================== */
+
+
+
+/* Sass erlaubt es Selektoren in Selektoren zu verschachteln. */
+
+ul {
+ list-style-type: none;
+ margin-top: 2em;
+
+ li {
+ background-color: #FF0000;
+ }
+}
+
+/* '&' wird durch den übergeordneten Selektor ersetzt. */
+/* Du kannst auch Pseudo-Klassen verschachteln. */
+/* Denk daran, dass zu viel Verschachtelung deinen Code schlechter
+ wartbar macht.
+ Die Best Practices empfehlen nicht mehr als 3 Ebenen zu verschachteln.
+ Zum Beispiel: */
+
+ul {
+ list-style-type: none;
+ margin-top: 2em;
+
+ li {
+ background-color: red;
+
+ &:hover {
+ background-color: blue;
+ }
+
+ a {
+ color: white;
+ }
+ }
+}
+
+/* Kompiliert: */
+
+ul {
+ list-style-type: none;
+ margin-top: 2em;
+}
+
+ul li {
+ background-color: red;
+}
+
+ul li:hover {
+ background-color: blue;
+}
+
+ul li a {
+ color: white;
+}
+
+
+
+/* Partials und Imports
+============================== */
+
+
+
+/* Sass erlaubt dir das Erstellen partieller Dateien (partials).
+ Das hilft dir modularisierten Sass Code zu schreiben.
+ Partielle Dateien fangen mit einem '_' an, z.B. _reset.css.
+ Partielle Dateien werden nicht zu CSS generiert. */
+
+/* Schau dir folgendes CSS an, was wir in einer Datei namens _reset.css haben */
+
+html,
+body,
+ul,
+ol {
+ margin: 0;
+ padding: 0;
+}
+
+/* Mit @import kannst du in Sass partielle Dateien importieren.
+ Dies unterscheidet sich vom traditionellen CSS @import Statement
+ welches einen neuen HTTP Request macht, um die zu importierende Datei
+ zu holen. Sass nimmt die importierte Datei und kombiniert sie mit
+ dem kompilierten Code. */
+
+@import 'reset';
+
+body {
+ font-size: 16px;
+ font-family: Helvetica, Arial, Sans-serif;
+}
+
+/* Kompiliert: */
+
+html, body, ul, ol {
+ margin: 0;
+ padding: 0;
+}
+
+body {
+ font-size: 16px;
+ font-family: Helvetica, Arial, Sans-serif;
+}
+
+
+
+/* Platzhalter Selektoren
+============================== */
+
+
+
+/* Platzhalter sind nützlich, um ein CSS Statement zum Erweitern zu
+ erstellen. Wenn du ein CSS Statement erstellst, welches du ausschließlich
+ zur Verwendung mit @extend nutzen willst, kannst du das mit einem
+ Platzhalter tun. Platzhalter fangen mit einem '%' statt einem '.'
+ oder '#' an und erscheinen nicht im kompilierten CSS. */
+
+%content-window {
+ font-size: 14px;
+ padding: 10px;
+ color: #000;
+ border-radius: 4px;
+}
+
+.message-window {
+ @extend %content-window;
+ background-color: #0000ff;
+}
+
+/* Kompiliert: */
+
+.message-window {
+ font-size: 14px;
+ padding: 10px;
+ color: #000;
+ border-radius: 4px;
+}
+
+.message-window {
+ background-color: #0000ff;
+}
+
+
+
+/* Mathematische Operationen
+============================== */
+
+
+
+/* Sass bietet die folgenden Operatoren: +, -, *, /, und %. Diese können
+ nützlich sein, wenn du Werte direkt in Sass berechnen willst, anstatt
+ vorher manuell errechnete Werte zu verwenden. Unten folgt ein Beispiel
+ für ein einfaches zweispaltiges Design. */
+
+$content-area: 960px;
+$main-content: 600px;
+$sidebar-content: 300px;
+
+$main-size: $main-content / $content-area * 100%;
+$sidebar-size: $sidebar-content / $content-area * 100%;
+$gutter: 100% - ($main-size + $sidebar-size);
+
+body {
+ width: 100%;
+}
+
+.main-content {
+ width: $main-size;
+}
+
+.sidebar {
+ width: $sidebar-size;
+}
+
+.gutter {
+ width: $gutter;
+}
+
+/* Compiles to: */
+
+body {
+ width: 100%;
+}
+
+.main-content {
+ width: 62.5%;
+}
+
+.sidebar {
+ width: 31.25%;
+}
+
+.gutter {
+ width: 6.25%;
+}
+
+```
+
+## SASS oder Sass?
+Hast du dich jemals gefragt, ob Sass ein Akronym ist oder nicht? Hast du wahrscheinlich nicht, aber ich sage es dir trotzdem. Der Name der Sprache ist ein Wort, "Sass", und kein Akronym.
+Da die Leute durchgehend "SASS" geschrieben haben, hat der Ersteller der Sprache es scherzhaft "Syntactically Awesome StyleSheets" genannt.
+
+## Sass üben
+Wenn du mit Sass in deinem Browser spielen willst, schau dir [SassMeister](http://sassmeister.com/) an.
+Du kannst beide Syntax-Optionen benutzen, gehe einfach in die Einstellungen und wähle entweder Sass oder SCSS.
+
+## Kompatibilität
+Sass kann in jedem Projekt verwendet werden, solange du ein Programm hast, um es in CSS zu kompilieren.
+Du solltest verifizieren, dass das CSS, was du verwendest, mit deinen Ziel-Browsern kompatibel ist.
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) und [CanIUse](http://caniuse.com) sind gute Resourcen um die Kompatibilät zu überpüfen.
+
+
+## Literaturhinweise
+* [Offizielle Dokumentation](http://sass-lang.com/documentation/file.SASS_REFERENCE.html)
+* [The Sass Way](http://thesassway.com/) bietet Tutorials (Anfänger bis Fortgeschritten) und Artikel.