diff --git a/.gitignore b/.gitignore
index 6f90fd1907..ed61f68f56 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,6 +17,7 @@
 .settings
 .tmproj
 .nvmrc
+.vscode
 sftp-config.json
 Thumbs.db
 
diff --git a/1-js/01-getting-started/1-intro/article.md b/1-js/01-getting-started/1-intro/article.md
index 10bd54fedb..4e79ba1487 100644
--- a/1-js/01-getting-started/1-intro/article.md
+++ b/1-js/01-getting-started/1-intro/article.md
@@ -1,121 +1,120 @@
-# An Introduction to JavaScript
+# Eine Einführung in JavaScript
 
-Let's see what's so special about JavaScript, what we can achieve with it and which other technologies play well with it.
+Was ist das Besondere an [JavaScript](https://de.wikipedia.org/wiki/JavaScript), was können wir damit machen und welche anderen Technologien können wir mit JavaScript verwenden?
 
-## What is JavaScript?
+## Was ist JavaScript?
 
-*JavaScript* was initially created to *"make webpages alive"*.
+*JavaScript* wurde ursprünglich entwickelt um *"Webseiten lebendig werden zu lassen"*.
 
-The programs in this language are called *scripts*. They can be written right in the HTML and execute automatically as the page loads.
+Die Programme in dieser Sprache heißen *Scripte*. Sie können direkt innerhalb von [HTML](https://de.wikipedia.org/wiki/Hypertext_Markup_Language) geschrieben werden und kommen automatisch zur Ausführung wenn die Seite geladen wird.
 
-Scripts are provided and executed as a plain text. They don't need a special preparation or a compilation to run.
+Scripte werden als einfache Textdateien (plain text) geschrieben und auch ausgeführt. Sie benötigen keine besondere Vorbereitung und auch keine Kompilierung zur Ausführung.
 
-In this aspect, JavaScript is very different from another language called [Java](http://en.wikipedia.org/wiki/Java).
+In diesem Aspekt ist JavaScript sehr verschieden von der Programmiersprache [Java](https://de.wikipedia.org/wiki/Java_(Programmiersprache)), mit der es sich vor allem den Namen teilt.
 
-```smart header="Why <u>Java</u>Script?"
-When JavaScript was created, it initially had another name: "LiveScript". But Java language was very popular at that time, so it was decided that positioning a new language as a "younger brother" of Java would help.
+```smart header="Warum <u>Java</u>Script?"
+Als JavaScript entwickelt wurde, hatte es zuerst einen anderen Namen: "LiveScript". Allerdings war die Sprache Java zu dieser Zeit sehr populär und man entschied, dass die Positionierung der neuen Sprache als "jüngerer Bruder" von Java hilfreich sein könnte.
 
-But as it evolved, JavaScript became a fully independent language, with its own specification called [ECMAScript](http://en.wikipedia.org/wiki/ECMAScript), and now it has no relation to Java at all.
+Mit der Evolution von JavaScript wurde es zu einer völlig unabhängigen Sprache mit einer eigenen Spezifikation, [ECMAScript](http://en.wikipedia.org/wiki/ECMAScript). JavaScript steht heute in keinerlei Beziehung zu Java.
 ```
 
-At present, JavaScript can execute not only in the browser, but also on the server, or actually on any device where there exists a special program called [the JavaScript engine](https://en.wikipedia.org/wiki/JavaScript_engine).
+Mittlerweile kann JavaScript nicht nur im Browser, sondern auch auf dem Server ausgeführt werden. Genauer gesagt läuft JavaScript auf jedem Gerät für das ein spezielles Programm geschrieben wurde, die so genannte [JavaScript-Engine](https://en.wikipedia.org/wiki/JavaScript_engine).
 
-The browser has an embedded engine, sometimes it's also called a "JavaScript virtual machine".
+Browser besitzen eine eingebettete JavaScript-Engine, manchmal auch "Virtuelle JavaScript Maschine" genannt, in Anlehnung an die "Virtuelle Java Maschine".
 
-Different engines have different "codenames", for example:
+Unterschiedliche Browser verwenden verschiedene Engines mit einer Reihe von Codenamen. Hier ein paar Beispiele:
 
-- [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- in Chrome and Opera.
-- [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- in Firefox.
-- ...There are other codenames like "Trident", "Chakra" for different versions of IE, "ChakraCore" for Microsoft Edge, "Nitro" and "SquirrelFish" for Safari etc.
+- [V8](https://de.wikipedia.org/wiki/V8_(JavaScript-Implementierung)) -- in Chrome.
+- [SpiderMonkey](https://de.wikipedia.org/wiki/SpiderMonkey) -- in Firefox.
+- ...Es gibt noch einige weitere, wie "Trident", "Chakra" für verschiedene Versionen des Internet Explorers, "ChakraCore" für Microsoft Edge, "Nitro" und "SquirrelFish" für Safari etc.
 
-The terms above are good to remember, because they are used in developer articles on the internet. We'll use them too. For instance, if "a feature X is supported by V8", then it probably works in Chrome and Opera.
+Man sollte von diesen Namen gehört haben, da sie immer mal wieder in Entwicklerartikeln im Internet und auch in diesem Tutorial auftauchen. Aussagen wie "das Feature X wird von V8 unterstützt" bedeuten, dass etwas wahrscheinlich in Chrome funktionieren wird.
 
-```smart header="How engines work?"
+```smart header="Wie arbeiten Engines?"
 
-Engines are complicated. But the basics are easy.
+Engines sind recht kompliziert, aber die Grundlagen sind einfach.
 
-1. The engine (embedded if it's a browser) reads ("parses") the script.
-2. Then it converts ("compiles") the script to the machine language.
-3. And then the machine code runs, pretty fast.
+1. Die Engine (eine eingebettete, wenn wir einen Browser verwenden) ließt ("[parst](https://de.wikipedia.org/wiki/Parser)") das Script.
+2. Dann wird das Script in die Maschinensprache übersetzt ("[compiliert](https://de.wikipedia.org/wiki/Compiler)").
+3. Anschließend läuft dieser Maschinencode, meistens recht schnell.
 
-The engine applies optimizations on every stage of the process. It even watches the compiled script as it runs, analyzes the data that flows through it and applies optimizations to the machine code based on that knowledge. At the end, scripts are quite fast.
+In jedem dieser Schritte, versucht die Engine den Code zu optimieren. Die Engine beobachtet auch den laufenden Code und analysiert den auftretenden Datenfluss. Basierend auf diesen Daten wird der Maschinencode weiter optimiert was zu wirklich hohen Ausführungsgeschwindigkeiten führen kann.
 ```
 
-## What can in-browser JavaScript do?
+## Was ist mit JavaScript im Browser möglich?
 
-The modern JavaScript is a "safe" programming language. It does not provide low-level access to memory or CPU, because it was initially created for browsers which do not require it.
+Modernes JavaScript ist eine "sichere" Programmiersprache. Es sind keine systemnahen Zugriffe auf den Speicher oder die CPU möglich, da diese für den Einsatz im Browser auch nicht nötig sind.
 
-The capabilities greatly depend on the environment that runs JavaScript. For instance, [Node.JS](https://wikipedia.org/wiki/Node.js) supports functions that allow JavaScript to read/write arbitrary files, perform network requests etc.
+Die resultierenden Möglichkeiten werden sehr stark von der Umgebung beeinflusst in der wir JavaScript ausführen. Beispielsweise unterstützt [Node.JS](https://de.wikipedia.org/wiki/Node.js) Funktionen die es uns erlauben beliebige Dateien zu lesen und schreiben oder Netzwerkabfragen zu senden.
 
-In-browser JavaScript can do everything related to webpage manipulation, interaction with the user and the webserver.
+JavaScript im Browser bietet uns alle Möglichkeiten im Zusammenhang mit Webseitenmanipulation, Nutzerinteraktion und Interaktion mit dem Webserver.
 
-For instance, in-browser JavaScript is able to:
+Zum Beispiel kann JavaScript im Browser:
 
-- Add new HTML to the page, change the existing content, modify styles.
-- React to user actions, run on mouse clicks, pointer movements, key presses.
-- Send requests over the network to remote servers, download and upload files (so-called [AJAX](https://en.wikipedia.org/wiki/Ajax_(programming)) and [COMET](https://en.wikipedia.org/wiki/Comet_(programming)) technologies).
-- Get and set cookies, ask questions to the visitor, show messages.
-- Remember the data on the client-side ("local storage").
+- Neue HTML-Daten zur Seite hinzufügen, existierende Inhalte verändern oder CSS-Styles verändern.
+- Auf Nutzeraktivitäten wie Mauszeiger, Mausklicks oder Tastatureingaben reagieren.
+- Abfragen über das Netzwerk zu Servern senden um Dateien hoch oder runter zu laden (so genannte [AJAX](https://de.wikipedia.org/wiki/Ajax_(Programmierung)) oder [COMET](https://en.wikipedia.org/wiki/Comet_(programming)) Techniken).
+- Das Setzen und Abfragen von Cookies, die Ausgabe von Meldungen und das Einlesen von Nutzerdaten.
+- Speichern von Daten auf dem Gerät des Nutzers ("local storage").
 
-## What CAN'T in-browser JavaScript do?
+## Was kann JavaScript im Browser NICHT?
 
-JavaScript's abilities in the browser are limited for the sake of the user's safety. The aim is to prevent an evil webpage from accessing private information or harming the user's data.
+Die Fähigkeiten von JavaScript innerhalb des Browser sind beschnitten um die Sicherheit der Nutzer zu erhöhen. Damit soll verhindert werden das bösartige Webseiten private Informationen des Nutzers abgreifen können oder das System des Nutzers beschädigen.
 
-The examples of such restrictions are:
+Beispiele derartiger Restriktionen sind:
 
-- JavaScript on a webpage may not read/write arbitrary files on the hard disk, copy them or execute programs. It has no direct access to OS system functions.
+- JavaScript auf einer Webseite kann nicht auf beliebige Dateien der Festplatte zugreifen oder lokale Programme ausführen. Es hat auch keinen direkten Zugriff auf Betriebssystemfunktionen.
 
-    Modern browsers allow it to work with files, but the access is limited and only provided if the user does certain actions, like "dropping" a file into a browser window or selecting it via an `<input>` tag.
+    Moderne Browser erlauben es uns allerdings mit lokalen Dateien zu arbeiten, allerdings nur wenn der Nutzer gewisse Aktionen ausführt, so wie ziehen einer Datei ins Browserfenster oder auswählen einer Datei über ein `<input>`-Tag.
 
-    There are ways to interact with camera/microphone and other devices, but they require a user's explicit permission. So a JavaScript-enabled page may not sneakily enable a web-camera, observe the surroundings and send the information to the [NSA](https://en.wikipedia.org/wiki/National_Security_Agency).
-- Different tabs/windows generally do not know about each other. Sometimes they do, for example when one window uses JavaScript to open the other one. But even in this case, JavaScript from one page may not access the other if they come from different sites (from a different domain, protocol or port).
+    Es gibt auch die Möglichkeit mit Kameras und Mikrofonen sowie anderen Hardwarekomponenten zu arbeiten, aber hier ist eine explizite Erlaubnis vom Nutzer notwendig. Eine JavaScript-Webseite kann also nicht heimlich die Webcam aktivieren und Überwachungsbilder senden.
+- Verschiedene Browserfenster oder -tabs wissen nichts voneinander. Ausnahmen sind wenn ein Fenster JavaScript nutzt um ein weiteres zu öffnen, aber auch dann kann JavaScript von einer Seite nicht auf Daten der anderen Seite zugreifen, wenn sie aus verschiedenen Quellen (Domains, Protokoll, Port, etc.) kommen.
 
-    This is called the "Same Origin Policy". To work around that, *both pages* must contain a special JavaScript code that handles data exchange.
+    Dieses Verhalten wird "Same Origin Policy" genannt. Um es zu umgehen müssen *beide Seiten* speziellen JavaScript-Code enthalten, die den Datenaustausch handhaben.
 
-    The limitation is again for user's safety. A page from `http://anysite.com` which a user has opened must not be able to access another browser tab with the URL `http://gmail.com` and steal information from there.
-- JavaScript can easily communicate over the net to the server where the current page came from. But its ability to receive data from other sites/domains is crippled. Though possible, it requires explicit agreement (expressed in HTTP headers) from the remote side. Once again, that's safety limitations.
+    Diese Einschränkungen dienen wiederrum der Sicherheit der Nutzer. Ein Seite `http://anysite.com` die der Nutzer öffnet darf nicht auf einen geöffneten Tab `http://gmail.com` zugreifen und Daten daraus stehlen.
+- JavaScript kann sehr leicht über das Netzwerk mit dem Server kommunizieren von dem es geladen wurde. Doch die Fähigkeiten mit anderen Domains zu kommunizieren sind beschnitten. Obwohl grundsätzlich möglich, benötigen diese eine explizite Zustimmung (über HTTP-Header) von der entfernten Stelle. Auch diese Einschränkung dient der Nutzersicherheit.
 
 ![](limitations.png)
 
-Such limits do not exist if JavaScript is used outside of the browser, for example on a server. Modern browsers also allow installing plugin/extensions which may get extended permissions.
+Diese Einschränkungen bestehen nicht, wenn JavaScript außerhalb eines Browsers ausgeführt wird, beispielsweise auf einem Server. Moderne Browser erlauben es außerdem Erweiterungen oder Plug-ins zu installieren, die erweiterte Rechte erhalten können.
 
-## What makes JavaScript unique?
+## Was macht JavaScript so besonders?
 
-There are at least *three* great things about JavaScript:
+Es gibt mindestens *drei* wirklich großartige Dinge in JavaScript:
 
 ```compare
-+ Full integration with HTML/CSS.
-+ Simple things done simply.
-+ Supported by all major browsers and enabled by default.
++ Vollständige Integration in HTML/CSS.
++ Einfache Dinge sind einfach.
++ Unterstützung durch alle gängigen Browser, standardmäßig aktiviert.
 ```
 
-Combined, these three things exist only in JavaScript and no other browser technology.
+In dieser Kombination gibt es diese drei Eigenschaften nur bei JavaScript und bei keiner anderen Browsertechnik.
 
-That's what makes JavaScript unique. That's why it's the most widespread tool to create browser interfaces.
+Das macht JavaScript einzigartig und das ist der Grund weshalb es das meistgenutzte Werkzeug für Nutzerschnittstellen im Browser ist.
 
-While planning to learn a new technology, it's beneficial to check its perspectives. So let's move on to the modern trends that include new languages and browser abilities.
+Macht man sich daran eine neue Technik zu erlernen, lohnt es sich deren Perspektiven zu betrachten. Daher blicken wir noch kurz auf einige neue Trends unter den Sprachen und Browsern.
 
+## JavaScript und verwandte Sprachen
 
-## Languages "over" JavaScript
+Die Syntax von JavaScript erfüllt nicht die Bedürfnisse und Wünsche aller Nutzer. Verschiedene Leute wünschen sich verschiedene Eigenschaften.
 
-The syntax of JavaScript does not suit everyone's needs. Different people want different features.
+Das ist nichts weiter besonderes, da die Projekte und Anforderungen für jeden verschieden sind.
 
-That's to be expected, because projects and requirements are different for everyone.
+In letzter Zeit entstand so ein Strauß neuer Sprachen welche in JavaScript-Code übertragen (*transpiled*) werden, bevor sie im Browser ausgeführt werden.
 
-So recently a plethora of new languages appeared, which are *transpiled* (converted) to JavaScript before they run in the browser.
+Moderne Werkzeuge erlauben eine schnelle und transparente Übertragung nach JavaScript. Diese erlauben es Entwicklern in einer anderen Sprache zu programmieren, welche im Hintergrund automatisch zu JavaScript-Code umgewandelt wird.
 
-Modern tools make the transpilation very fast and transparent, actually allowing developers to code in another language and autoconverting it "under the hood".
+Einige Beispiele sind:
 
-Examples of such languages:
+- [CoffeeScript](http://coffeescript.org/) ist "syntaktischer Zucker" (syntactic sugar) für JavaScript. Es führt kürzere Syntax ein, die es erlaubt präziseren und klareren Code zu schreiben. Ruby-Entwickler fühlen sich hier schnell heimisch.
+- [TypeScript](http://www.typescriptlang.org/) bringt starke Typisierung (strict data typing) um die Entwicklung und Wartung  komplexerer Systeme zu vereinfachen. TypeScript wird von Microsoft aktiv weiter entwickelt.
+- [Dart](https://www.dartlang.org/) ist eine allein-lauffähige Sprache mit einer eigenen Engine die auch außerhalb des Browsers arbeiten kann (zum Beispiel in mobilen Apps). Ursprünglich von Google als ein JavaScript-Ersatz entwickelt, erfordern Browser eine Übertragung des Codes nach JavaScript wie auch in den anderen Fällen.
 
-- [CoffeeScript](http://coffeescript.org/) is a "syntactic sugar" for JavaScript, it introduces shorter syntax, allowing to write more precise and clear code. Usually Ruby devs like it.
-- [TypeScript](http://www.typescriptlang.org/) is concentrated on adding "strict data typing", to simplify development and support of complex systems. It is developed by Microsoft.
-- [Dart](https://www.dartlang.org/) is a standalone language that has its own engine that runs in non-browser environments (like mobile apps). It was initially offered by Google as a replacement for JavaScript, but as of now, browsers require it to be transpiled to JavaScript just like the ones above.
+Es gibt noch einige mehr. Auch wenn wir uns entscheiden sollten in einer dieser Sprachen entwickeln zu wollen, ist es eine gute Idee JavaScript zu beherrschen um zu verstehen was in unserem Code passiert.
 
-There are more. Of course even if we use one of those languages, we should also know JavaScript, to really understand what we're doing.
+## Zusammenfassung
 
-## Summary
-
-- JavaScript was initially created as a browser-only language, but now it is used in many other environments as well.
-- At this moment, JavaScript has a unique position as the most widely-adopted browser language with full integration with HTML/CSS.
-- There are many languages that get "transpiled" to JavaScript and provide certain features. It is recommended to take a look at them, at least briefly, after mastering JavaScript.
+- Ursprünglich wurde JavaScript entwickelt um lediglich innerhalb eines Browsers zu laufen, mitlerweile wird es aber auch in vielen anderen Bereichen eingesetzt.
+- Derzeit ist JavaScript die am weitesten verbreitete Browserprogrammiersprache mit HTML- und CSS-Fähigkeiten.
+- Es gibt einige Sprachen die zu JavaScript-Code übertragen werden und einige neue Eigenschaften zu JavaScript hinzufügen. Wenn man in die Grundlagen von JavaScript eingedrungen ist, lohnt sich ein Blick auf diese Alternativen.
diff --git a/1-js/01-getting-started/2-code-editors/article.md b/1-js/01-getting-started/2-code-editors/article.md
index 0d714cdb27..a0442ea64e 100644
--- a/1-js/01-getting-started/2-code-editors/article.md
+++ b/1-js/01-getting-started/2-code-editors/article.md
@@ -1,56 +1,54 @@
-# Code editors
+# Code-Editoren
 
-A code editor is the place where programmers spend most of their time.
+Der Code-Editor ist die Anwendung mit der ein Programmierer die meiste Zeit verbringt.
 
-There are two archetypes: IDE and lightweight editors. Many people feel comfortable choosing one tool of each type.
+Grundsätzlich gibt es zwei grobe Typen, die teilweise überlappen: integrierte Entwicklungsumgebungen ([IDE](https://de.wikipedia.org/wiki/Integrierte_Entwicklungsumgebung)) und reine [Texteditoren](https://de.wikipedia.org/wiki/Texteditor). Viele Entwickler bevorzugen es mit einem Werkzeug aus jeder dieser beiden Kategorie zu arbeiten.
 
-## IDE
+## IDEs
 
-The term [IDE](https://en.wikipedia.org/wiki/Integrated_development_environment) (Integrated Development Environment) means a powerful editor with many features that usually operates on a "whole project". As the name suggests, that's not just an editor, but a full-scale "development environment".
+Mit einer IDE meint man für gewöhnlich einen sehr mächtigen Editor mit sehr vielen Funktionen der oft ein ganzes "Projekt" und nicht nur einzelne Dateien verarbeitet. Wie der Name andeutet, handelt es sich um eine ausgewachsene Entwicklungsumgebung und nicht nur um einen Editor.
 
-An IDE loads the project (can be many files), allows navigation between files, provides autocompletion based on the whole project (not just the open file), integrates with a version management system (like [git](https://git-scm.com/)), a testing environment and other "project-level" stuff.
+Eine IDE lädt ein ganzes Projekt (oft aus vielen Dateien bestehend), erlaubt zwischen den Dateien zu navigieren, erlaubt automatische Namensergänzung über das ganze Projekt hinweg (nicht nur die geöffnete Datei), integriert eine Versionsverwaltung (wie [git](https://git-scm.com/)), eine Testumgebung und noch einiges mehr.
 
-If you haven't considered selecting an IDE yet, look at the following variants:
+Wenn Sie bisher noch keine IDE verwendet haben, lohnt sich ein Blick auf diese Programme:
 
-- [WebStorm](http://www.jetbrains.com/webstorm/) for frontend development and other editors of the same company if you need additional languages.
-- Visual Studio is fine if you're a .NET developer, and a free version is available ([Visual Studio Community](https://www.visualstudio.com/vs/community/))
+- [WebStorm](http://www.jetbrains.com/webstorm/) geeignet für Frontend-Entwicklung, andere Sprachen sind ebenfalls verfügbar.
+- Visual Studio ist gut geeignet für .NET-Entwickler, eine kostenlose Version ist erhältlich: ([Visual Studio Community](https://www.visualstudio.com/vs/community/))
 - [Netbeans](http://netbeans.org/).
 
-All of the IDEs except Visual Studio are available on Windows, MacOs and Linux. Visual Studio doesn't work on Linux.
+Alle IDEs, außer Visual Studio, sind für Mac, Linux und Windows erhältlich, Visual Studio wird nicht für Linux angeboten.
 
-Most IDEs are paid, but have a trial period. Their cost is usually negligible compared to a qualified developer's salary, so just choose the best one for you.
+Viele IDEs sind kostenpflichtig, aber die kosten sind gering im Vergleich zu einem Entwicklergehalt. Coden Sie also nicht nur als Hobby sollten Sie die IDE wählen mit der Sie am besten arbeiten können.
 
-## Lightweight editors
+## Texteditoren
 
-"Lightweight editors" are not as powerful as IDEs, but they're fast, elegant and simple.
+Texteditoren sind nicht so mächtig wie IDEs, dafür aber schnell, einfach und elegant.
 
-They are mainly used to instantly open and edit a file.
+Sie werden vor allem zum schnellen öffnen, betrachten und bearbeiten von einzelnen Dateien verwendet.
 
-The main difference between a "lightweight editor" and an "IDE" is that an IDE works on a project-level, so it loads much more data on start, analyzes the project structure if needed and so on. A lightweight editor is much faster if we need only one file.
+Der Hauptunterschied zwischen den beiden Gruppen ist, dass IDEs auf dem Projektlevel arbeiten und daher beim Start viel mehr Daten lädt um die Projektstruktur zu analysieren. Ein Texteditor ist daher oft schneller, wenn es darum geht, nur eine einzelne Datei zu öffnen.
 
-In practice, lightweight editors may have a lot of plugins including directory-level syntax analyzers and autocompleters, so there's no strict border between a lightweight editor and an IDE.
+Oft gibt es für Texteditoren eine Vielzahl von Erweiterungen die IDE-Funktionen nachbilden und das Arbeiten in Projekten unterstützen. Daher kann man keine klare Trennlinie zwischen IDE und Texteditor ziehen.
 
-The following options deserve your attention:
+Die vollgenden Alternativen sollten Sie sich anschauen, wenn Sie noch keinen Lieblingseditor haben:
 
-- [Visual Studio Code](https://code.visualstudio.com/) (cross-platform, free).
-- [Atom](https://atom.io/) (cross-platform, free).
-- [Sublime Text](http://www.sublimetext.com) (cross-platform, shareware).
-- [Notepad++](https://notepad-plus-plus.org/) (Windows, free).
-- [Vim](http://www.vim.org/) and [Emacs](https://www.gnu.org/software/emacs/) are also cool, if you know how to use them.
+- [Visual Studio Code](https://code.visualstudio.com/) (freie Software, alle Plattformen).
+- [Atom](https://atom.io/) (freie Software, alle Plattformen).
+- [Sublime Text](http://www.sublimetext.com) (80$, alle Plattformen).
+- [Notepad++](https://notepad-plus-plus.org/) (Freeware, Windows).
+- [Vim](http://www.vim.org/) und [Emacs](https://www.gnu.org/software/emacs/) sind äußerst mächtige Werkzeuge, haben aber sehr gewöhnungsbedürftige Interfaces und daher eine sehr steile Lernkurve. Beherrscht man aber einen davon, kann man sehr effizient mit Textdateien arbeiten.
 
-## My favorites
+## Meine Favoriten
 
-The personal preference of the author is to have both an IDE for projects and a lightweight editor for quick and easy file editing.
+Ich persönlich verwende:
 
-I'm using:
+- [WebStorm](http://www.jetbrains.com/webstorm/) für JS, 
+- Als mächtigen Texteditor [Visual Studio Code](https://code.visualstudio.com/) für größere Projekte und [Vim](http://www.vim.org/) um kleine Änderungen remote in der Konsole auf einem Server vornehmen zu können.
 
-- [WebStorm](http://www.jetbrains.com/webstorm/) for JS, and if there is one more language in the project, then I switch to one of the other Jetbrains offerings listed above.
-- As a lightweight editor -- [Sublime Text](http://www.sublimetext.com) or [Atom](https://atom.io/).
+## Lassen Sie uns nicht streiten
 
-## Let's not argue
+Die Editoren in der obigen Liste werden von mir oder anderen Autoren des Tutorials für gut befunden und womit diese gern arbeiten.
 
-The editors in the lists above are those that either I or my friends who I consider good developers have been using for a long time and are happy with.
+Es gibt noch viele andere großartige Editoren, wählen Sie den, der am besten zu Ihnen passt.
 
-There are other great editors in our big world. Please choose the one you like the most.
-
-The choice of an editor, like any other tool, is individual and depends on your projects, habits, personal preferences.
+Die Wahl eines Editors, wie bei jedem anderen Werkzeug, ist sehr individuell und richtet sich nach den Anforderungen des Projektes, Gewohnheiten und persönlichen Vorlieben.
diff --git a/1-js/01-getting-started/3-devtools/article.md b/1-js/01-getting-started/3-devtools/article.md
index f250502df0..a544cfaabe 100644
--- a/1-js/01-getting-started/3-devtools/article.md
+++ b/1-js/01-getting-started/3-devtools/article.md
@@ -1,58 +1,53 @@
-# Developer console
+# Entwicklerkonsole
 
-Code is prone to errors. You are quite likely to make errors... Oh, what am I talking about? You are *absolutely* going to make errors, at least if you're a human, not a [robot](https://en.wikipedia.org/wiki/Bender_(Futurama)).
+Code ist immer anfällig für Fehler. Auch Sie werden wahrscheinlich Fehler machen... Nein was sage ich, Sie werden *ganz bestimmt* Fehler machen, zumindest wenn Sie ein Mensch sind und kein [Roboter](https://en.wikipedia.org/wiki/Bender_(Futurama)).
 
-But in the browser, a user doesn't see the errors by default. So, if something goes wrong in the script, we won't see what's broken and can't fix it.
+Im Browser allerdings sehen wir standardmäßig keine Fehlermeldungen. Wenn also etwas in unserem Script schief läuft bekommen wir nicht mit was los ist und können daher auch das Problem nicht beheben.
 
-To see errors and get a lot of other useful information about scripts, browsers have embedded "developer tools".
+Um solche Fehler besser erkennen zu können und noch viele weitere nützliche Informationen über Scripte und deren Verhalten zu bekommen, besitzen Browser eingebaute Entwicklerwerkzeuge.
 
-Most often developers lean towards Chrome or Firefox for development, because those browsers have the best developer tools. Other browsers also provide developer tools, sometimes with special features, but are usually playing "catch-up" to Chrome or Firefox. So most people have a "favorite" browser and switch to others if a problem is browser-specific.
+Die meisten Entwickler verwenden Chrome oder Firefox für Ihre Entwicklungen, da diese Browser über die umfangreichsten Entwicklerwerkzeuge verfügen. Andere Browser bieten auch Entwicklerwerkzeuge, zum Teil mit sehr nützlichen, zusätzlichen Funktionen. Generell laufen diese aber Chrome und Firefox etwas hinterher. Viele Entwickler haben einen "Lieblingsbrowser" und wechseln zu einem anderen, falls spezielle Probleme auftreten.
 
-Developer tools are really powerful, there are many features. To start, we'll learn how to open them, look at errors and run JavaScript commands.
+Die Entwicklerwerkzeuge sind wirklich mächtig und es gibt zahlreiche Funktionen. Zu Beginn schauen wir uns an, wie man sie im Browser öffnet, sich Fehler anschaut und wie man JavaScript-Befehle ausführt.
 
-## Google Chrome
+## Chrome
 
-Open the page [bug.html](bug.html).
+Öffnen Sie die Seite [bug.html](bug.html).
 
-There's an error in the JavaScript code on it. It's hidden from a regular visitor's eyes, so let's open developer tools to see it.
+Im JavaScript-Code ist ein Fehler, der dem Auge des normalen Seitenbesuchers verborgen bleibt. Lassen Sie uns darauf einen Blick mithilfe der Entwicklerwerkzeuge werfen.
 
-Press `key:F12` or, if you're on Mac, then `key:Cmd+Opt+J`.
+Drücken Sie `key:F12` oder, `key:Cmd+Opt+J` an einem Mac.
 
-The developer tools will open on the Console tab by default.
-
-It looks somewhat like this:
+Standardmäßig öffnet sich der Konsolen-Tab, und es sieht ungefähr so aus:
 
 ![chrome](chrome.png)
 
-The exact look of developer tools depends on your version of Chrome. It changes from time to time, but should be similar.
-
-- Here we can see the red-colored error message. In this case the script contains an unknown "lalala" command.
-- On the right, there is a clickable link to the source `bug.html:12` with the line number where the error has occurred.
+Das genaue Aussehen hängt von der verwendeten Chrome-Version ab und ändert sich hin und wieder, sollte aber ähnlich aussehen.
 
-Below the error message there is a blue `>` symbol. It marks a "command line" where we can type JavaScript commands and press `key:Enter` to run them (`key:Shift+Enter` to input multi-line commands).
+- Wir sehen in rot eine Fehlermeldung, die besagt, dass unser Script einen unbekannten Befehl mit dem Namen "lalala" enthält.
+- Auf der rechten Seite befindet sich ein anklickbarer Link `bug.html:12` der auf die Codezeile mit dem Fehler verweist.
 
-Now we can see errors and that's enough for the start. We'll be back to developer tools later and cover debugging more in-depth in the chapter <info:debugging-chrome>.
+Unterhalb der Fehlermeldung befindet sich ein blaues `>`-Symbol. Es markiert eine Eingabekonsole in die wir JavaScript-Befehle eingeben können. Ein druck auf `key:Enter` lässt den Code ablaufen (`key:Shift+Enter` erlaubt es mehrzeilige Anweisungen einzugeben).
 
+So können wir Fehler einsehen und das ist an dieser Stelle erstmal genug. Wir gehen im Kapitel <info:debugging-chrome> noch einmal näher auf die Entwicklerwerkzeuge ein.
 
-## Firefox, Edge and others
+## Firefox, Edge und andere
 
-Most other browsers use `key:F12` to open developer tools.
+In den meisten Browsern kann man mit `key:F12` die Entwicklerwerkzeuge öffnen.
 
-The look & feel of them is quite similar. Once you know how to use one of them (you can start with Chrome), you can easily switch to another.
+Aussehen und Funktion ist sehr ähnlich. Hat man einen ausgiebiger kennengelernt, kann man leicht zu einem anderen Browser wechseln.
 
 ## Safari
 
-Safari (Mac browser, not supported by Windows/Linux) is a little bit special here. We need to enable the "Develop menu" first.
-
-Open Preferences and go to "Advanced" pane. There's a checkbox at the bottom:
+Safari (der Mac-Browser, keine Windows/Linux-Versionen) ist etwas spezieller. Hier muss zuerst das sog. "Entwicklermenü" eingeschaltet werden.
 
-![safari](safari.png)
+Öffnen Sie "Einstellungen" und gehen auf "Erweitert". Dort gibt es eine Option zum Anzeigen des Entwickler-Menüs. Ist diese aktiviert erscheint ein weiterer Menüeintrag mit zahlreichen Befehlen und Optionen.
 
-Now `key:Cmd+Opt+C` can toggle the console. Also note that the new top menu item named "Develop" has appeared. It has many commands and options.
+Nun erlaubt die Tastenkombination `key:Cmd+Opt+C` die Entwicklerkonsole zu öffnen.
 
-## Summary
+## Zusammenfassung
 
-- Developer tools allow us to see errors, run commands, examine variables and much more.
-- They can be opened with `key:F12` for most browsers under Windows. Chrome for Mac needs `key:Cmd+Opt+J`, Safari: `key:Cmd+Opt+C` (need to enable first).
+- Entwicklerwerkzeuge erlauben uns Fehler zu erkennen, Befehle auszuführen, den Inhalt von Variablen zu inspizieren und einiges mehr.
+- Sie werden durch `key:F12` unter Windows und Linux geöffnet. Chrome für Mac verwendet `key:Cmd+Opt+J` und Safari: `key:Cmd+Opt+C`.
 
-Now we have the environment ready. In the next section we'll get down to JavaScript.
+Nun haben wir unseren Werkzeugkasten gefüllt. Im nächsten Kapitel beginnen wir mit der JavaScript-Entwicklung.
diff --git a/1-js/01-getting-started/3-devtools/safari.png b/1-js/01-getting-started/3-devtools/safari.png
deleted file mode 100644
index 37598a2610..0000000000
Binary files a/1-js/01-getting-started/3-devtools/safari.png and /dev/null differ
diff --git a/1-js/01-getting-started/3-devtools/safari@2x.png b/1-js/01-getting-started/3-devtools/safari@2x.png
deleted file mode 100644
index c59cebef21..0000000000
Binary files a/1-js/01-getting-started/3-devtools/safari@2x.png and /dev/null differ
diff --git a/1-js/02-first-steps/01-hello-world/1-hello-alert/task.md b/1-js/02-first-steps/01-hello-world/1-hello-alert/task.md
index afed6a91d3..1d4a20561d 100644
--- a/1-js/02-first-steps/01-hello-world/1-hello-alert/task.md
+++ b/1-js/02-first-steps/01-hello-world/1-hello-alert/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Show an alert
+# Zeigen Sie eine Mitteilung an
 
-Create a page that shows a message "I'm JavaScript!".
+Erstellen Sie eine Webseite, die die Mitteilung "Hallo, JavaScript!" ausgibt.
 
-Do it in a sandbox, or on your hard drive, doesn't matter, just ensure that it works.
+Versuchen Sie es in einer Sandbox oder lokal auf Ihrem Rechner, ganz egal, hauptsache es funktioniert.
 
 [demo src="http://github.com/solution"]
 
diff --git a/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/task.md b/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/task.md
index 26168d6a76..27f992f898 100644
--- a/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/task.md
+++ b/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/task.md
@@ -2,8 +2,8 @@ importance: 5
 
 ---
 
-# Show an alert with an external script
+# Zeigen Sie eine Meldung mit einem externen Script an
 
-Take the solution of the previous task <info:task/hello-alert>. Modify it by extracting the script content into an external file `alert.js`, residing in the same folder.
+Verwenden Sie die Lösung aus der vorherigen Aufgabe <info:task/hello-alert>. Modifizieren Sie es durch Verschieben des Script-Inhaltes in die externe Datei `alert.js`, die sich im selben Ordner befindet.
 
-Open the page, ensure that the alert works.
+Öffnen Sie die Seite und prüfen ob die Mitteilung funktioniert.
diff --git a/1-js/02-first-steps/01-hello-world/article.md b/1-js/02-first-steps/01-hello-world/article.md
index 69d2ba976a..323acc94ce 100644
--- a/1-js/02-first-steps/01-hello-world/article.md
+++ b/1-js/02-first-steps/01-hello-world/article.md
@@ -1,17 +1,17 @@
 # Hello, world!
 
-The tutorial that you're reading is about core JavaScript, which is platform-independent. Further on, you will learn Node.JS and other platforms that use it.
+Dieses Tutorial behandelt Java-Script, im Kern eine plattformunabhängige Technik. Später wenden wir uns Node.js und anderen Plattformen zu die JavaScript verwenden.
 
-But, we need a working environment to run our scripts, and, just because this book is online, the browser is a good choice. We'll keep the amount of browser-specific commands (like `alert`) to a minimum, so that you don't spend time on them if you plan to concentrate on another environment like Node.JS. On the other hand, browser details are explained in detail in the [next part](/ui) of the tutorial.
+Doch zunächst benötigen wir eine Umgebung in der wir unsere Scripte ausführen können. Da dies ein Online-Buch ist, liegt es nahe, den Browser zu verwenden. Wir vermeiden so weit als möglich browserspezifische Anweisungen (wie `alert`) so dass Sie keine Zeit darauf verlieren, wenn ihr späteres Augenmerk eigentlich Node.js sein soll. Interessieren Sie sich aber für die Browserdetails, so behandeln wir diese ausführlich im [nächsten Teil](/ui) des Tutorials.
 
-So first, let's see how to attach a script to a webpage. For server-side environments, you can just execute it with a command like `"node my.js"` for Node.JS.
+Fangen wir aber damit an, wie man ein Script in eine Webseite einbettet. Befinden Sie sich in einer serverseitigen Umgebung können Sie ein Script mit einem Kommando wie `"node my.js"` mit Node.js ausführen.
 
 
-## The "script" tag
+## Das "script"-Tag
 
-JavaScript programs can be inserted in any part of an HTML document with the help of the `<script>` tag.
+JavaScript-Programme können überall innerhalb eines HTML-Dokuments mit Hilfe des `<script>`-Tags platziert werden.
 
-For instance:
+Zum Beispiel:
 
 ```html run height=100
 <!DOCTYPE HTML>
@@ -19,7 +19,7 @@ For instance:
 
 <body>
 
-  <p>Before the script...</p>
+  <p>Vor dem Script...</p>
 
 *!*
   <script>
@@ -27,7 +27,7 @@ For instance:
   </script>
 */!*
 
-  <p>...After the script.</p>
+  <p>...Nach dem Script.</p>
 
 </body>
 
@@ -35,56 +35,53 @@ For instance:
 ```
 
 ```online
-You can run the example by clicking on the "Play" button in its right-top corner.
+Sie können die Beispiele in diesem Tutorial laufen lassen, indem Sie den "Play"-Knopf in der oberen rechten Ecke anklicken.
 ```
 
-The `<script>` tag contains JavaScript code which is automatically executed when the browser meets the tag.
+Das `<script>`-Tag beinhaltet JavaScript-Code der automatisch ausgeführt wird, wenn der Browser den Tag erreicht.
 
+## Der moderne Dialekt
 
-## The modern markup
+Das `<script>`-Tag besitzt einige Attribute die heute nicht mehr eingesetzt werden, die man aber in älterem Code finden kann:
 
-The `<script>` tag has a few attributes that are rarely used nowadays, but we can find them in old code:
+**Das `type`-Attribut: <code>&lt;script <u>type</u>=...&gt;</code>**
 
- The `type` attribute: <code>&lt;script <u>type</u>=...&gt;</code>
+Der alte HTML4-Standard sah vor, dass Scripte einen Typ haben müssen, typischerweise `type="text/javascript"`. Der aktuelle HTML-Standard nimmt diesen Typ als Standardwert an; eine Angabe des Attributes ist nicht notwendig.
 
- : The old standard HTML4 required a script to have a type. Usually it was `type="text/javascript"`. The modern HTML standard assumes this `type` by default. No attribute is required.
+**Das `language`-Attribut: <code>&lt;script <u>language</u>=...&gt;</code>**
 
- The `language` attribute: <code>&lt;script <u>language</u>=...&gt;</code>
-  : This attribute was meant to show the language of the script. As of now, this attribute makes no sense, the language is JavaScript by default. No need to use it.
+Dieses Attribut sollte die Programmiersprache des Scripts anzeigen. Da diese standardmäßig JavaScript ist, gibt es keine Notwendigkeit das Attribut zu verwenden.
 
-Comments before and after scripts.
-: In really ancient books and guides, one may find comments inside `<script>`, like this:
-
-    ```html no-beautify
-    <script type="text/javascript"><!--
-        ...
-    //--></script>
-    ```
-
-    These comments were supposed to hide the code from an old browser that didn't know about a `<script>` tag. But all browsers born in the past 15+ years don't have any issues. We mention it here, because such comments serve as a sign. If you see that somewhere -- that code is probably really old and not worth looking into.
+**Kommentare vor und nach Scripten**
 
+In sehr alten Anleitungen, Büchern und Codes findet man Kommentare innerhalb von `<script>`, so wie diesen:
+```html no-beautify
+<script type="text/javascript"><!--
+...
+//--></script>
+```
 
-## External scripts
+Solche Kommentare sollten den Script-Code vor älteren Browsern verstecken, die mit dem `<script>`-Tag noch nichts anfangen konnten. Aber alle Browser aus mindestens den letzten 15 Jahren haben dieses Problem nicht. Wir zeigen dieses Idiom hier als ein Warnzeichen. Wenn Sie es irgendwo entdecken, können Sie davon ausgehen, dass der Code wirklich sehr alt ist und es sich nicht lohnt, sich näher damit zu befassen.
 
-If we have a lot of JavaScript code, we can put it into a separate file.
+## Externe Scripte
 
-The script file is attached to HTML with the `src` attribute:
+Wenn wir sehr viel JavaScript-Code auf unserer Seite haben, können wir diesen in einer separaten Datei platzieren. Die Datei wird mit dem `src`-Attribute zur HTML-Webseite hinzugefügt:
 
 ```html
-<script src="http://github.com/path/to/script.js"></script>
+<script src="http://github.com/pfad/zum/script.js"></script>
 ```
 
-Here `/path/to/script.js` is an absolute path to the file with the script (from the site root).
+`/fad/zum/script.js` ist eine absolute Pfadangabe zur Script-Datei, ausgehend vom Wurzelverzeichnis der Seite.
 
-It is also possible to provide a path relative to the current page. For instance, `src="http://github.com/script.js"` would mean a file `"script.js"` in the current folder.
+Alternativ können auch relative Pfade angegeben werden. Zum Beispiel heißt `src="http://github.com/script.js"` das eine Datei `"script.js"` im aktuellen Ordner verwendet werden soll.
 
-We can give a full URL as well, for instance:
+Auch eine vollständige URL kann angegeben werden:
 
 ```html
 <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js"></script>
 ```
 
-To attach several scripts, use multiple tags:
+Mehrere Scripte können mit mehreren `script`-Tags geladen werden:
 
 ```html
 <script src="http://github.com/js/script1.js"></script>
@@ -93,29 +90,23 @@ To attach several scripts, use multiple tags:
 ```
 
 ```smart
-As a rule, only the simplest scripts are put into HTML. More complex ones reside in separate files.
-
-The benefit of a separate file is that the browser will download it and then store in its [cache](https://en.wikipedia.org/wiki/Web_cache).
+Nur die aller einfachsten Scripte sollten direkt in eine HTML-Datei geschrieben werden. Komplexere Dinge landen in einer eigenen Datei.
 
-After this, other pages that want the same script will take it from the cache instead of downloading it. So the file is actually downloaded only once.
-
-That saves traffic and makes pages faster.
+Ein Vorteil davon ist, dass Browser diese Dateien in ihrem [Cache](https://de.wikipedia.org/wiki/Cache) vorhalten, nachdem sie einmal geladen wurden. Verwendet eine andere Seite das selbe Script, kann dieses aus dem Cache genommen werden und muss nicht nochmal aus dem Web geladen werden. Das spart Web-Traffic und beschleunigt Seiten.
 ```
 
-````warn header="If `src` is set, the script content is ignored."
-A single `<script>` tag can't have both the `src` attribute and the code inside.
+````warn header="Wenn `src` gesetzt wurde, wird der Inhalt von `<script>` ignoriert."
+Ein einzelner `<script>`-Tag kann kein `src`-Attribute und JavaScript-Code beinhalten.
 
-This won't work:
+Das hier würde nicht funktionieren:
 
 ```html
 <script *!*src*/!*="file.js">
-  alert(1); // the content is ignored, because src is set
+  alert(1); // Der Inhalt wird ignoriert, das src verwendet wird
 </script>
 ```
 
-We must choose: either it's an external `<script src="http://github.com/%E2%80%A6">` or a regular `<script>` with code.
-
-The example above can be split into two scripts to work:
+Wir können das Beispiel in zwei Scripte aufteilen um es lauffähig zu machen:
 
 ```html
 <script src="http://github.com/file.js"></script>
@@ -125,11 +116,10 @@ The example above can be split into two scripts to work:
 ```
 ````
 
-## Summary
-
-- We can use a `<script>` tag to add JavaScript code to the page.
-- The `type` and `language` attributes are not required.
-- A script in an external file can be inserted with `<script src="http://github.com/path/to/script.js"></script>`.
+## Zusammenfassung
 
+- Wir können das `<script>`-Tag verwenden um JavaScript-Code zu einer Webseite hinzuzufügen.
+- Die Attribute `type` und `language` werden nicht länger benötigt.
+- Ein Script aus einer anderen Datei kann mit `<script src="http://github.com/pfad/zum/script.js"></script>` geladen werden.
 
-There is much more to learn about browser scripts and their interaction with the web-page. But let's keep in mind that this part of the tutorial is devoted to the JavaScript language, so we shouldn't distract ourselves from it. We'll be using a browser as a way to run JavaScript, which is very convenient for online reading, but yet one of many.
+Es gibt noch viel mehr über Scripte im Browser und deren Interaktion mit Webseiten zu sagen. In diesem Teil des Tutorials soll es aber nur um die Sprache JavaScript gehen und wir wollen uns davon zunächst nicht ablenken. Wir nutzen den Browser zunächst als eine bequeme Möglichkeit um JavaScript-Code ablaufen zu lassen.
\ No newline at end of file
diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index ebaa375279..785e9dea04 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -1,44 +1,44 @@
-# Code structure
+# Code-Struktur
 
-The first thing to study is the building blocks of the code.
+Die erste Sache die wir uns anschauen werden, sind die Grundbausteine für unseren Code.
 
-## Statements
+## Anweisungen
 
-Statements are syntax constructs and commands that perform actions.
+Anweisungen (Statements) sind Syntaxkonstrukte und Kommandos die Dinge ausführen.
 
-We've already seen a statement `alert('Hello, world!')`, which shows the message.
+Wir haben schon die Anweisung `alert('Hello, world!')` gesehen, um eine Mitteilung auszugeben.
 
-We can have as many statements in the code as we want. Another statement can be separated with a semicolon.
+Unser Code kann beliebig viele Anweisungen enthalten. Aufeinander folgende Anweisungen werden mit einem Semikolon (;) getrennt.
 
-For example, here we split the message into two:
+Zum Beispiel können wir unsere Mitteilung in zwei Mitteilungen zerlegen:
 
 ```js run no-beautify
 alert('Hello'); alert('World');
 ```
 
-Usually each statement is written on a separate line -- thus the code becomes more readable:
+Für gewöhnlich wird jede Anweisung auf eine eigene Zeile geschrieben um die Lesbarkeit des Codes zu erhöhen:
 
 ```js run no-beautify
 alert('Hello');
 alert('World');
 ```
 
-## Semicolons [#semicolon]
+## Semikolons [#semicolon]
 
-A semicolon may be omitted in most cases when a line break exists.
+In den meisten Fällen können wir das Semikolon auch weglassen, wenn ein Zeilenumbruch vorhanden ist.
 
-This would also work:
+Beispielsweise funktioniert auch:
 
 ```js run no-beautify
 alert('Hello')
 alert('World')
 ```
 
-Here JavaScript interprets the line break as an "implicit" semicolon. That's also called an [automatic semicolon insertion](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion).
+Der Zeilenumbruch wird von JavaScript als implizites Semikolon interpretiert. Dieses verhalten wird auch "autmatisches Einfügen von Semikolons" ([automatic semicolon insertion](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion)) genannt.
 
-**In most cases a newline implies a semicolon. But "in most cases" does not mean "always"!**
+**In den meisten Fällen impliziert ein Zeilenumbruch ein Semikolon. Aber "in den meisten Fällen" ist nicht "immer"!**
 
-There are cases when a newline does not mean a semicolon, for example:
+Es gibt Fälle in denen ein Zeilenumbruch kein automatisches Semikolon erzeugt, zum Beispiel:
 
 ```js run no-beautify
 alert(3 +
@@ -46,114 +46,112 @@ alert(3 +
 + 2);
 ```
 
-The code outputs `6`, because JavaScript does not insert semicolons here. It is intuitively obvious that if the line ends with a plus `"+"`, then it is an "incomplete expression", no semicolon required. And in this case that works as intended.
+Dieser Code erzeugt die Ausgabe `6`, weil JavaScript hier keine Semikolons einfügt. In diesem Fall erkennen wir sofort, dass eine Zeile die mit einem Plus `"+"` endet, einen unvollständigen Ausdruck (incomplete expression) enthält und folglich kein Semikolon benötigt. In diesem Fall funktioniert es auch wie erwartet.
 
-**But there are situations where JavaScript "fails" to assume a semicolon where it is really needed.**
+**Aber es gibt Fälle in denen JavaScript nicht erfolgreich errät wo Semikolons wirklich benötigt werden.**
 
-Errors which occur in such cases are quite hard to find and fix.
+Die Fehler die aus diesen Fällen resultieren sind oft sehr schwer zu finden und zu beheben.
 
-````smart header="An example of an error"
-If you're curious to see a concrete example of such an error, check this code out:
+````smart header="Beispiel für einen Fehler"
+Ein konkretes Beispiel für einen solchen Fehler zeigt der folgende Code:
 
 ```js run
 [1, 2].forEach(alert)
 ```
 
-No need to think about the meaning of the brackets `[]` and `forEach` yet. We'll study them later, for now it does not matter. Let's just remember the result: it shows `1`, then `2`.
+Im Moment kümmern wir uns nicht um die Bedeutung der eckigen Klammern `[]` und des `forEach`. Wir werden uns später um diese Sprachelemente kümmern, im Moment spielen sie keine besondere Rolle. Schauen wir uns nur kurz das Ergebnis an: wir bekommen zuerst `1` und dann `2` angezeigt.
 
-Now let's add an `alert` before the code and *not* finish it with a semicolon:
+Fügen wir jetzt ein `alert` vor dem Code ein, welches *nicht* mit einem Semikolon abgeschlossen wird:
 
 ```js run no-beautify
-alert("There will be an error")
+alert("Hier entsteht ein Fehler")
 
 [1, 2].forEach(alert)
 ```
 
-Now if we run it, only the first `alert` is shown, and then we have an error!
+Jetzt wird nur der erste `alert`angezeigt, danach bekommen wir eine Fehlermeldung!
 
-But everything is fine again if we add a semicolon after `alert`:
+Allerdings ist wieder alles in Ordnung, wenn wir ein Semikolon nach dem ersten `alert` einfügen:
 ```js run
-alert("All fine now");
+alert("Alles in Ordnung");
 
 [1, 2].forEach(alert)  
 ```
 
-Now we have the "All fine now" message and then `1` and `2`.
+Jetzt bekommen wir zuerst die "Alles in Ordnung" Meldung und dann  `1` und `2`.
 
-
-The error in the no-semicolon variant occurs because JavaScript does not imply a semicolon before square brackets `[...]`.
-
-So, because the semicolon is not auto-inserted, the code in the first example is treated as a single statement. That's how the engine sees it:
+Der Fehler in der semikolonfreien Variante entsteht, weil JavaScript keine impliziten Semikolons vor eckigen Klammern `[...]` einfügt. Daher wird der Code als eine einzige Anweisung interpretiert. So sieht die JavaScript-Engine unseren Code:
 
 ```js run no-beautify
-alert("There will be an error")[1, 2].forEach(alert)
+alert("Hier entsteht ein Fehler")[1, 2].forEach(alert)
 ```
 
-But it should be two separate statements, not a single one. Such a merging in this case is just wrong, hence the error. There are other situations when such a thing happens.
+Gemeint hatten wir aber zwei getrennte Anweisungen, nicht eine einzelne. Die Zusammenführung der Anweisungen erzeugt hier den Fehler. Es gibt noch andere Situationen in denen dieses Problem auftritt.
 ````
 
-It's recommended to put semicolons between statements even if they are separated by newlines. This rule is widely adopted by the community. Let's note once again -- *it is possible* to leave out semicolons most of the time. But it's safer -- especially for a beginner -- to use them.
+Es wird empfohlen alle Anweisungen durch Semikolons zu trennen, auch wenn sie durch Zeilenumbrüche getrennt sind. Diese Regel findet in der Community eine breite Anwendung. Fassen wir noch einmal zusammen: *Es ist möglich* in vielen Fällen Semikolons weg zu lassen. Es ist aber sicherer und eine gute Angewohnheit -- besonders für Anfänger -- sie immer zu verwenden.
 
-## Comments
+## Kommentare
 
-As time goes on, the program becomes more and more complex. It becomes necessary to add *comments* which describe what happens and why.
+Im Laufe der Zeit wird jedes Programm immer komplexer. Daher wird es notwendig *Kommentare* zum Code hinzuzufügen die beschreiben was im Code vor sich geht.
 
-Comments can be put into any place of the script. They don't affect the execution, because the engine simply ignores them.
+Kommentare dürfen an jeder Stelle im Script platziert werden. Sie beeinflussen nicht den Ablauf des Scriptes da sie wärend der Ausführung einfach ignoriert werden.
 
-**One-line comments start with two forward slash characters `//`.**
+**Einzeilige Kommentare beginnen mit zwei Schrägstrichen `//`.**
 
-The rest of the line is a comment. It may occupy a full line of its own or follow a statement.
+Der Rest der Zeile hinter den Schrägstrichen ist ein Kommentar. Er kann eine einzelne, ganze Zeile einnehmen oder nach einer anderen Anweisung folgen.
 
-Like here:
+So wie hier:
 ```js run
-// This comment occupies a line of its own
+// Dieser Kommentar nimmt eine ganze Zeile für sich ein.
 alert('Hello');
 
-alert('World'); // This comment follows the statement
+alert('World'); // Dieser Kommentar folgt auf eine Anweisung
 ```
 
-**Multiline comments start with a forward slash and an asterisk <code>/&#42;</code> and end with an asterisk and a forward slash <code>&#42;/</code>.**
+**Mehrzeilige Kommentare beginnen mit einem Schrägstrich gefolgt von einem Sternchen <code>/&#42;</code> und enden mit einem Sternchen gefolgt von einem Schrägstrich <code>&#42;/</code>.**
 
-Like this:
+So wie hier:
 
 ```js run
-/* An example with two messages.
-This is a multiline comment.
+/* 
+Ein Beispiel mit zwei Mitteilungen.
+Dies ist ein mehrzeiliger Kommentar.
 */
 alert('Hello');
 alert('World');
 ```
 
-The content of comments is ignored, so if we put code inside <code>/&#42; ... &#42;/</code> it won't execute.
+Der Inhalt der Kommentare wird ignoriert, wenn wir also Code innerhalb von <code>/&#42; ... &#42;/</code> platzieren, wird dieser nicht ausgeführt.
 
-Sometimes it comes in handy to temporarily disable a part of code:
+Hin und wieder ist es praktisch mit Kommentaren Teile des Codes von der Ausführung auszunehmen:
 
 ```js run
-/* Commenting out the code
+/* Auskommentieren von Code
 alert('Hello');
 */
 alert('World');
 ```
 
-```smart header="Use hotkeys!"
-In most editors a line of code can be commented out by `key:Ctrl+/` hotkey for a single-line comment and something like `key:Ctrl+Shift+/` -- for multiline comments (select a piece of code and press the hotkey). For Mac try `key:Cmd` instead of `key:Ctrl`.
+```smart header="Nützliche Tastenkombinationen"
+In vielen Texteditoren kann eine einzelne Codezeile mit der Tastenkombination `key:Ctrl+/` auskommentiert werden. Die Tastenkombination für mehrzeilige Kommentare (zuerst mehrere Zeilen auswählen) lautet oft `key:Ctrl+Shift+/` oder ähnlich. An einem Mac verwenden Sie `key:Cmd` anstelle von `key:Ctrl`.
 ```
 
-````warn header="Nested comments are not supported!"
-There may not be `/*...*/` inside another `/*...*/`.
+````warn header="Verschachtelte Kommentare werden nicht unterstützt!"
+Es sollte kein `/*...*/` innerhalb von `/*...*/` geben.
 
-Such code will die with an error:
+Dieser Code wird mit einer Fehlermeldung abbrechen:
 
 ```js run no-beautify
 /*
-  /* nested comment ?!? */
+  /* Verschachtelter Kommentar ?!? */
 */
 alert( 'World' );
 ```
 ````
 
-Please, don't hesitate to comment your code.
+Bitte zögern Sie nicht, Ihren Code zu kommentieren!
 
-Comments increase the overall code footprint, but that's not a problem at all. There are many tools which minify the code before publishing to the production server. They remove comments, so they don't appear in the working scripts. Therefore comments do not have any negative effects on production at all.
+Kommentare vergrößern zwar die Größe des Gesamtcodes, aber das stellt kein Problem dar. Es existieren zahlreiche Werkzeuge die unseren Code minimieren können bevor wie ihn auf einen Produktivserver laden. Diese entfernen unter anderem Kommentare, so dass diese nicht in den Scripten auftauchen, die an Endnutzer ausgeliefert werden. Kommentare haben also keinen Einfluss auf die ausgelieferte, produktive Seite.
 
-Further in the tutorial, there will be a chapter <info:coding-style> that also explains how to write better comments.
+Im weiteren Verlauf des Tutorials werden wir uns noch mit gutem Codierstil (<info:coding-style>) auseinander setzen. Hierbei werden wir auch beleuchtenwie man bessere und aussagekräftige Kommentare schreibt.
diff --git a/1-js/02-first-steps/03-strict-mode/article.md b/1-js/02-first-steps/03-strict-mode/article.md
index 35b4ef2b47..4863b309d5 100644
--- a/1-js/02-first-steps/03-strict-mode/article.md
+++ b/1-js/02-first-steps/03-strict-mode/article.md
@@ -1,61 +1,56 @@
-# The modern mode, "use strict"
+# Moderne Spracheigenschaften: "use strict"
 
-For a long time JavaScript was evolving without compatibility issues. New features were added to the language, but the old functionality did not change.
+Für eine lange Zeit entwickelte sich JavaScript ohne irgendwelche Kompatibilitätsprobleme aufzuwerfen. Neue Features wurden einfach hinzugefügt, doch die alte Funktionalität wurde nicht verändert.
 
-That had the benefit of never breaking existing code. But the downside was that any mistake or an imperfect decision made by JavaScript creators got stuck in the language forever.
+Das hatte den Vorteil, dass existierender Code immer lauffähig blieb. Nachteilig war, dass alle kleinen Schludereien oder fragwürdigen Designentscheidungen aus der frühen Zeit von JavaScript auf ewig der Sprache erhalten blieben.
 
-It had been so until 2009 when ECMAScript 5 (ES5) appeared. It added new features to the language and modified some of the existing ones. To keep the old code working, most modifications are off by default. One needs to enable them explicitly with a special directive `"use strict"`.
+Das blieb so bis 2009 der ECMAScript 5 Standard (ES5) erschien. Es wurden neue Features zur Sprache hinzugefügt und einige der existierenden Eigenschaften wurden verändert. Um alten Code lauffähig zu halten sind die meisten dieser Änderungen standardmäßig deaktiviert. Sie müssen erst durch eine spezielle Direktive eingeschaltet werden: `"use strict"`.
 
 ## "use strict"
 
-The directive looks like a string: `"use strict"` or `'use strict'`. When it is located on the top of the script, then the whole script works the "modern" way.
-
-For example
+Die Direktive erscheint wie ein String: `"use strict"` oder `'use strict'`. Wenn diese am Anfang des Scripts platziert wird, arbeitet das ganze Script nach den modernen Regeln, zum Beispiel:
 
 ```js
 "use strict";
 
-// this code works the modern way
+// Dieser Code arbeitet nach den modernen Regeln
 ...
 ```
 
-We will learn functions (a way to group commands) soon.
-
-Looking ahead let's just note that `"use strict"` can be put at the start of a function (most kinds of functions) instead of the whole script. Then strict mode is enabled in that function only. But usually people use it for the whole script.
-
+Wir werden bald Funktionen in JavaScript (eine Gruppierung von Anweisungen) kennen lernen. Hier nur soviel, dass wir `"use strict"` auch am Anfang einer Funktion verwenden können, anstatt für das ganze Script. Der `strict`-Modus ist dann nur für diese Funktion aktiviert. Für gewöhnlich verwendet man den `strict`-Modus aber für ein ganzes Script.
 
-````warn header="Ensure that \"use strict\" is at the top"
-Please make sure that `"use strict"` is on the top of the script, otherwise the strict mode may not be enabled.
+````warn header="Versichern Sie sich, dass \"use strict\" am Anfang des Scriptest steht"
+Versichern Sie sich, dass `"use strict"` am Anfang des Scriptest steht, sonst wird der `strict`-Modus möglicherweise nicht aktiviert.
 
-There is no strict mode here:
+Hier wird der `strict`-Modus nicht verwendet:
 
 ```js no-strict
 alert("some code");
-// "use strict" below is ignored, must be on the top
+// "use strict" weiter unten wird ignoriert, es müsste am Anfang stehen
 
 "use strict";
 
-// strict mode is not activated
+// `strict`-Modus ist nicht aktiviert
 ```
 
-Only comments may appear above `"use strict"`.
+Lediglich Kommentare dürfen vor `"use strict"` auftreten.
 ````
 
-```warn header="There's no way to cancel `use strict`"
-There is no directive `"no use strict"` or alike, that would return the old behavior.
+```warn header="Man kann `use strict` nicht wieder abschalten"
+Es gibt keine Direktive `"no use strict"` oder ähnliches, die die alte Verhaltensweise wieder herstellt.
 
-Once we enter the strict mode, there's no return.
+Hat man in einem Script den `strict`-Modus eingeschaltet, gibt es dort kein Zurück mehr.
 ```
 
-## Always "use strict"
+## Verwenden Sie immer "use strict"
 
-The differences of `"use strict"` versus the "default" mode are still to be covered.
+Mit den genauen Unterschiede von `"use strict"` und dem alten "Default"-Modus müssen wir uns später noch genauer auseinandersetzen.
 
-In the next chapters, as we learn language features, we'll make notes about the differences of the strict mode. Luckily, there are not so many. And they actually make our life better.
+In den nächsten Kapiteln, wenn wir die Spracheigenschaften behandeln, werden wir immer wieder auf die Unterschiede hinweisen. Glücklicherweise gibt es nicht besonders viele und die, die es gibt machen unser Leben einfacher.
 
-At this point in time it's enough to know about it in general:
+Zum jetzigen Zeitpunkt genügt es uns das Folgende zu wissen:
 
-1. The `"use strict"` directive switches the engine to the "modern" mode, changing the behavior of some built-in features. We'll see the details as we study.
-2. The strict mode is enabled by `"use strict"` at the top. Also there are several language features like "classes" and "modules" that enable strict mode automatically.
-3. The strict mode is supported by all modern browsers.
-4. It's always recommended to start scripts with `"use strict"`. All examples in this tutorial assume so, unless (very rarely) specified otherwise.
+1. Die `"use strict"`-Direktive schaltet die Engine in den "modernen" Modus und verändert das Verhalten einiger eingebauter Funktionen.
+2. Der `strict`-Modus wird mit `"use strict"` am Anfang des Scripts eingeschaltet. Es gibt auch einige Sprachfeatures wie Klassen und Module die den `strict`-Modus automatisch einschalten.
+3. Alle modernen Browser unterstützen den `strict`-Modus.
+4. Es ist grundsätzlich empfehlenswert Scripte mit `"use strict"` zu beginnen. Alle Beispiele in diesem Tutorial verwenden es; außer (sehr selten) es ist anders angegeben.
diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md
index 264755f8c6..e62cd58129 100644
--- a/1-js/02-first-steps/04-variables/article.md
+++ b/1-js/02-first-steps/04-variables/article.md
@@ -1,262 +1,252 @@
-# Variables
+# Variablen
 
-Most of the time, a JavaScript application needs to work with information. Here are 2 examples:
-1. An online-shop -- the information might include goods being sold and a shopping cart. 
-2. A chat application -- the information might include users, messages, and much more.
+In sehr vielen Fällen muss eine JavaScript-Anwendung in irgendeiner Form mit Informationen arbeiten. Hier sind zwei Beispiele:
+1. Ein Online-Shop -- die Informationen können die angebotenen Güter, ein Warenkorb oder gewährte Rabatte sein. 
+2. Eine Chat-Anwendung -- die Informationen können Benutzernamen, Nachrichten, Bilder und noch vieles weitere sein.
 
-Variables are used to store this information.
+Variablen werden in Programmen verwendet um solche Informationen zu speichern und zu verarbeiten.
 
-## A variable
+## Allgemeines zu Variablen
 
-A [variable](https://en.wikipedia.org/wiki/Variable_(computer_science)) is a "named storage" for data. We can use variables to store goodies, visitors and other data.
+Eine [Variable](https://de.wikipedia.org/wiki/Variable_(Programmierung)) ist ein abstrakter, benannter Behälter für Daten. Innerhalb von Variablen können wir in JavaScript beliebige Daten speichern.
 
-To create a variable in JavaScript, we need to use the `let` keyword.
+Um eine Variable in JavaScript zu kreieren, wird die Anweisung `let` verwendet.
 
-The statement below creates (in other words: *declares* or *defines*) a variable with the name "message":
+Die folgende Anweisung erzeugt (auch *deklariert* oder *definiert*) eine Variable mit dem Namen "mitteilung":
 
 ```js
-let message;
+let mitteilung;
 ```
 
-Now we can put some data into it by using the assignment operator `=`:
+Nun können wir mit dem Zuweisungsoperator `=` Daten in die Variable schreiben:
 
 ```js
-let message;
+let mitteilung;
 
 *!*
-message = 'Hello'; // store the string
+mitteilung = 'Hallo'; // Speichert eine Zeichenkette
 */!*
 ```
 
-The string is now saved into the memory area associated with the variable. We can access it using the variable name:
+Die Zeichenkette ist nun in einem Speicherbereich abgelegt, der mit dem Variablennamen assoziiert ist. Auf diesen können wir zugreifen, indem wir den Variablennamen verwenden:
 
 ```js run
-let message;
-message = 'Hello!';
+let mitteilung;
+mitteilung = 'Hallo!';
 
 *!*
-alert(message); // shows the variable content
+alert(mitteilung); // Zeigt den Inhalt der Variable an
 */!*
 ```
 
-To be concise we can merge the variable declaration and assignment into a single line:
+Um den Code etwas zu verkürzen, können wir die Variablendeklaration und die Zuweisung in einer Zeile zusammenführen:
 
 ```js run
-let message = 'Hello!'; // define the variable and assign the value
+let mitteilung = 'Hallo!'; // Definiert die Variable und weißt einen Wert zu
 
-alert(message); // Hello!
+alert(mitteilung); // Hallo!
 ```
 
-We can also declare multiple variables in one line:
+Wir können auch mehrere Variablen auf einer Zeile deklarieren:
 
 ```js no-beautify
-let user = 'John', age = 25, message = 'Hello';
+let nutzer = 'Paul', alter = 25, mitteilung = 'Hallo';
 ```
 
-That might seem shorter, but it's not recommended. For the sake of better readability, please use a single line per variable.
+Das ist zwar etwas kürzer, aber trotzdem nicht zu empfehlen. Um die Lesbarkeit zu erhöhen, sollte für jede Variable eine neue Zeile verwendet werden.
 
-The multiline variant is a bit longer, but easier to read:
+Die mehrzeilige Variante ist zwar etwas länger, aber auch viel einfacher zu lesen:
 
 ```js
-let user = 'John';
-let age = 25;
-let message = 'Hello';
+let nutzer = 'Paul'; 
+let alter = 25; 
+let mitteilung = 'Hallo';
 ```
 
-Some people also write many variables like that:
+Manche Entwickler schreiben viele Variablendeklarationen auch so:
+
 ```js no-beautify
-let user = 'John',
-  age = 25,
-  message = 'Hello';
+let nutzer = 'Paul',
+  alter = 25, 
+  mitteilung = 'Hallo';
 ```
 
-...Or even in the "comma-first" style:
+...Oder auch mit vorgezogenen Kommata:
 
 ```js no-beautify
-let user = 'John'
-  , age = 25
-  , message = 'Hello';
+let nutzer = 'Paul'
+  , alter = 25
+  , mitteilung = 'Hallo';
 ```
 
-Technically, all these variants do the same. So, it's a matter of personal taste and aesthetics.
-
+Alle diese Varianten arbeiten genau identisch. Es ist also eine Frage des Geschmacks (oder einer Konvention, wenn Sie in einem Team entwickeln) wie die Deklarationen verwendet werden.
 
-````smart header="`var` instead of `let`"
-In older scripts you may also find another keyword: `var` instead of `let`:
+````smart header="`var` anstelle von `let`"
+In älteren Scripten findet man auch eine andere Anweisung: `var` anstelle von `let`:
 
 ```js
-*!*var*/!* message = 'Hello';
+*!*var*/!* mitteilung = 'Hallo';
 ```
 
-The `var` keyword is *almost* the same as `let`. It also declares a variable, but in a slightly different, "old-school" fashion.
-
-There are subtle differences between `let` and `var`, but they do not matter for us yet. We'll cover them in detail later, in the chapter <info:var>.
+Die Anweisung `var` ist *fast* identisch zu `let`. Auch hier wird eine Variable deklariert, aber auf eine etwas "veraltete" Weise. Die Unterschiede sollen uns im Moment nicht weiter kümmern, wir kommen darauf im Kapitel <info:var> zurück.
 ````
 
-## A real-life analogy
+## Variablen -- eine Analogie
 
-We can easily grasp the concept of a "variable" if we imagine it as a "box" for data, with a uniquely-named sticker on it.
+Eine intuitive Vorstellung vom Konzept einer Variable können wir erhalten, wenn wir uns Variablen wie Schachteln mit eindeutiger Beschriftung vorstellen.
 
-For instance, the variable `message` can be imagined as a box labeled `"message"` with the value `"Hello!"` in it:
+Die Variable `mitteilung` wäre also eine Schachtel mit der Aufschrift `"mitteilung"`; im Inneren wäre die Botschaft `"Hallo!"` enthalten:
 
 ![](variable.png)
 
-We can put any value into the box.
-
-Also we can change it. The value can be changed as many times as needed:
+Wir können jeden beliebigen Wert in diese Schachtel packen. Wir können den Wert in der Schachtel auch verändern und das so oft wie wir wollen:
 
 ```js run
-let message;
+let mitteilung;
 
-message = 'Hello!';
+mitteilung = 'Hallo!';
 
-message = 'World!'; // value changed
+mitteilung = 'Nutzer!'; // Geänderter Variablenwert
 
-alert(message);
+alert(mitteilung); 
 ```
 
-When the value is changed, the old data is removed from the variable:
+Wenn man den Wert einer Variablen ändert, werden die alten Daten aus der Variablen entfernt:
 
 ![](variable-change.png)
 
-We can also declare two variables and copy data from one into the other.
+Wir können auch mehrere Variablen deklarieren und Daten zwischen diesen hin und her kopieren:
 
 ```js run
-let hello = 'Hello world!';
+let hallo = 'Hallo Nutzer!';
 
-let message;
+let mitteilung;
 
 *!*
-// copy 'Hello world' from hello into message
-message = hello;
+// kopiere 'Hallo Nutzer' von hallo nach mitteilung
+mitteilung = hello;
 */!*
 
 // now two variables hold the same data
-alert(hello); // Hello world!
-alert(message); // Hello world!
+alert(hallo); // Hallo Nutzer!
+alert(mitteilung); // Hallo Nutzer!
 ```
 
-```smart header="Functional languages"
-It may be interesting to know that there also exist [functional](https://en.wikipedia.org/wiki/Functional_programming) programming languages that forbid changing a variable value. For example, [Scala](http://www.scala-lang.org/) or [Erlang](http://www.erlang.org/).
+```smart header="Funktionale Sprachen"
+An dieser Stelle wollen wir noch erwähnen, dass es auch [funktionale](https://de.wikipedia.org/wiki/Funktionale_Programmierung) Programmiersprachen gibt, die das Ändern von Variablenwerten verbieten. Beispiele sind [Scala](http://www.scala-lang.org/) oder [Erlang](http://www.erlang.org/).
 
-In such languages, once the value is stored "in the box", it's there forever. If we need to store something else, the language forces us to create a new box (declare a new variable). We can't reuse the old one.
+In diesen Sprachen bleiben die Werte, die man einmal in die "Schachtel" gepackt hat für immer in der "Schachtel" erhalten. Wenn wir andere Daten speichern wollen, zwingen uns diese Sprachen dazu eine neue Variable zu deklarieren (eine neue Schachtel zu verwenden). Wir können die alten nicht erneut verwenden.
 
-Though it may seem a little bit odd at first sight, these languages are quite capable of serious development. More than that, there are areas like parallel computations where this limitation confers certain benefits. Studying such a language (even if not planning to use it soon) is recommended to broaden the mind.
+Auch wenn dieses Vorgehen im ersten Moment etwas eigenartig wirkt, sind diese Sprachen doch mächtig genug, um auch ernsthafte Entwicklungsprojekte damit durchzuführen. In bestimmten Bereichen, wie etwa parallelem Computing, haben diese Limitierungen sogar große Vorteile. Die Beschäftigung mit so einer Sprache ist sehr vorteilhaft auch wenn man sie nicht direkt einzusetzen gedenkt. Wenn man neue Sprachen erlernt, kann man sehr gut seinen Horizont erweitern.
 ```
 
-## Variable naming [#variable-naming]
+## Variablen Namen [#variable-naming]
 
-There are two limitations for a variable name in JavaScript:
+Es gibt in JavaScript zwei Beschränkungen für Variablennamen:
 
-1. The name must contain only letters, digits, symbols `$` and `_`.
-2. The first character must not be a digit.
+1. Der Name darf nur Buchstaben, Ziffern und die Symbole `$` sowie `_` enthalten.
+2. Das erste Zeichen des Names darf keine Ziffer sein.
 
-Valid names, for instance:
+Beispiele für gültige Namen sind:
 
 ```js
-let userName;
+let nutzerName;
 let test123;
 ```
 
-When the name contains multiple words, [camelCase](https://en.wikipedia.org/wiki/CamelCase) is commonly used. That is: words go one after another, each word starts with a capital letter: `myVeryLongName`.
+Besteht der Name aus mehreren Wörtern, wird häufig die [camelCase](https://de.wikipedia.org/wiki/Binnenmajuskel)-Schreibweise verwendet. Dabei schreibt man die Wörter, ohne Leerzeichentrennung, direkt hintereinander. Jedes Wort beginnt mit einem großen Buchstaben: `einWirklichLangerName`.
 
-What's interesting -- the dollar sign `'$'` and the underscore `'_'` can also be used in names. They are regular symbols, just like letters, without any special meaning.
+Als weitere Zeichen können wir das Dollarzeichen `'$'` und den Unterstrich `'_'` in unseren Variablennamen verwenden. Sie wirken wie normale Zeichen, ohne spezielle Bedeutung.
 
-These names are valid:
+Weitere gültige Variablennamen wären:
 
 ```js run untrusted
-let $ = 1; // declared a variable with the name "$"
-let _ = 2; // and now a variable with the name "_"
+let $ = 1; // Eine Variable mit dem Namen "$"
+let _ = 2; // Eine Variable mit dem Namen "_"
 
 alert($ + _); // 3
 ```
 
-Examples of incorrect variable names:
+Einige Beispiele für ungültige Variablennamen:
 
 ```js no-beautify
-let 1a; // cannot start with a digit
+let 1a; // Darf nicht mit einer Ziffer beginnen
 
-let my-name; // a hyphen '-' is not allowed in the name
+let my-name; // Bindestriche "-" sind nicht erlaubt
 ```
 
-```smart header="Case matters"
-Variables named `apple` and `AppLE` -- are two different variables.
+```smart header="Groß- und Kleinschreibung wird unterschieden"
+Die Namen `apfel` und `ApfeL` bezeichnen zwei unterschiedliche Variablen.
 ```
 
-````smart header="Non-english letters are allowed, but not recommended"
-It is possible to use any language, including cyrillic letters or even hieroglyphs, like this:
+````smart header="Nicht-Englische Buchstaben funktionieren auch"
+Wir können jede andere Sprache für Variablennamen verwenden, auch deutsche Umlaute, kyrillische Buchstaben oder Hieroglyphen:
 
 ```js
+let münze = '...';
 let имя = '...';
 let 我 = '...';
 ```
 
-Technically, there is no error here, such names are allowed, but there is an international tradition to use English in variable names. Even if we're writing a small script, it may have a long life ahead. People from other countries may need to read it some time.
+Wir erhalten hier keine Fehlermeldung, die Variablennamen sind erlaubt. Doch es ist eine gute Tradition Englische Variablennamen zu verwenden. Auch wenn wir nur kleine Scripte schreiben wollen, oft überdauern diese für eine lange Zeit und müssen vielleicht später mal bearbeitet werden.
 ````
 
-````warn header="Reserved names"
-There is a list of reserved words, which cannot be used as variable names, because they are used by the language itself.
-
-For example, words `let`, `class`, `return`, `function` are reserved.
+````warn header="Reservierte Namen"
+Es gibt eine Liste mit reservierten Namen, die wir nicht verwenden dürfen um unsere Variablen zu benennen, weil sie schon von der Sprache selbst verwendet werden. Beispiele sind `let`, `class`, `return` und `function`.
 
-The code below gives a syntax error:
+Der folgende Code produziert einen Fehler:
 
 ```js run no-beautify
-let let = 5; // can't name a variable "let", error!
-let return = 5; // also can't name it "return", error!
+let let = 5; // "let" ist kein gültiger Variablenname!
+let return = 5; // "return" ist auch nicht zulässig!
 ```
 ````
 
-````warn header="An assignment without `use strict`"
+````warn header="Zuweisungen ohne `use strict`"
 
-Normally, we need to define a variable before using it. But in the old times, it was technically possible to create a variable by a mere assignment of the value, without `let`. This still works now if we don't put `use strict`. The behavior is kept for compatibility with old scripts.
+Normalerweise müssen wir eine Variable deklarieren bevor wir sie benutzen können. In den alten Zeiten war es aber möglich, eine Variable zu erzeugen, indem man einfach einen Wert zugewiesen hat, ohne `let` zu verwenden. Das funktioniert auch heute noch, wenn wir nicht `use strict` verwenden. Dieses Verhalten wurde beibehalten um die Kompatibilität mit alten Scripten zu gewährleisten.
 
 ```js run no-strict
-// note: no "use strict" in this example
+// kein "use strict" in diesem Beispiel
 
-num = 5; // the variable "num" is created if didn't exist
+num = 5; // die Variable "num" wird erzeugt, wenn sie noch nicht vorhanden war
 
 alert(num); // 5
 ```
 
-That's a bad practice, it gives an error in the strict mode:
+Das ist eine schlechte Programmierpraxis, im "strict"-Modus erzeugt sie einen Fehler:
 
 ```js run untrusted
 "use strict";
 
 *!*
-num = 5; // error: num is not defined
+num = 5; // Fehler: "num" nicht definiert
 */!*
 ```
 
 ````
 
-## Constants
+## Konstanten
 
-To declare a constant (unchanging) variable, one can use `const` instead of `let`:
+Um Konstanten (Variablen, die ihren Wert nicht ändern) zu deklarieren können wir `const` anstelle von `let` verwenden:
 
 ```js
 const myBirthday = '18.04.1982';
 ```
 
-Variables declared using `const` are called "constants". They cannot be changed. An attempt to do it would cause an error:
+Versuchen wir eine Konstante zu verändern, erzeugen wir einen Fehler:
 
 ```js run
 const myBirthday = '18.04.1982';
 
-myBirthday = '01.01.2001'; // error, can't reassign the constant!
+myBirthday = '01.01.2001'; // Fehler: Können keinen neuen Wert zuweisen!
 ```
 
-When a programmer is sure that the variable should never change, he can use `const` to guarantee it, and also to clearly show that fact to everyone.
+Wenn wir sicher sind, dass eine Variable ihren Wert niemals ändern soll, können wir `const` verwenden um das zu garantieren. Außerdem zeigen wir so anderen Entwicklern direkt an, dass diese Variable einen unveränderlichen Wert enthält.
 
+### Konstanten in Großbuchstaben
 
-### Uppercase constants
-
-There is a widespread practice to use constants as aliases for difficult-to-remember values that are known prior to execution.
-
-Such constants are named using capital letters and underscores.
-
-Like this:
+Es ist verbreitete Praxis Konstanten zu verwenden um schwierig zu merkenden Werten einen Namen zu geben. Es ist eine Konvention solche Werte mit Großbuchstaben und Unterstrichen zu benennen, so wie hier:
 
 ```js run
 const COLOR_RED = "#F00";
@@ -264,69 +254,65 @@ const COLOR_GREEN = "#0F0";
 const COLOR_BLUE = "#00F";
 const COLOR_ORANGE = "#FF7F00";
 
-// ...when we need to pick a color
+// ...um eine der Farben zu verwenden
 let color = COLOR_ORANGE;
 alert(color); // #FF7F00
 ```
 
-Benefits:
+Vorteile:
 
-- `COLOR_ORANGE` is much easier to remember than `"#FF7F00"`.
-- It is much easier to mistype in `"#FF7F00"` than in `COLOR_ORANGE`.
-- When reading the code, `COLOR_ORANGE` is much more meaningful than `#FF7F00`.
+- `COLOR_ORANGE` lässt sich sehr viel einfacher merken als `"#FF7F00"`.
+- Man kann sich bei `"#FF7F00"` viel leichter vertippen als bei `COLOR_ORANGE` (besonders, wenn man die Codevervollständigung einer IDE verwendet).
+- Ließt man den Code, dann ist `COLOR_ORANGE` sehr viel aussagekräftiger als`#FF7F00`.
 
-When should we use capitals for a constant, and when should we name them normally? Let's make that clear.
+Wann sollten wir unsere Konstanten nun in Großbuchstaben schreiben und wann normal? Sehen wir uns noch ein Beispiel an.
 
-Being a "constant" just means that the value never changes. But there are constants that are known prior to execution (like a hexadecimal value for red), and there are those that are *calculated* in run-time, during the execution, but do not change after the assignment.
+Eine Konstante enthält einfach Werte die sich niemals ändern. Es gibt aber Werte, die wir bereits vor der Ausführung des Scripts kennen (wie hexadezimale Farbwerte), diese erhalten Namen in Großbuchstaben. Werden jedoch Werte vom Script selber berechnet und dann in der Konstante abgespeichert, verwendet man einen normal geschriebenen Namen
 
-For instance:
+Ein Beispiel wäre:
 ```js
-const pageLoadTime = /* time taken by a webpage to load */;
+const pageLoadTime = /* Zeit, bis die Seite geladen ist */;
 ```
 
-The value of `pageLoadTime` is not known prior to the page load, so it's named normally. But it's still a constant, because it doesn't change after assignment.
-
-In other words, capital-named constants are only used as aliases for "hard-coded" values.  
-
-## Name things right
+Der Wert `pageLoadTime` ist nicht vor der Ausführung des Scripts bekannt, daher kein großgeschriebener Name. Der Wert kann sich aber nach der Zuweisung nicht mehr ändern, daher verwenden wir eine Konstante und keine gewöhnliche Variable.
 
-Talking about variables, there's one more extremely important thing.
+## Gute Variablennamen
 
-Please name the variables sensibly. Take time to think if needed.
+Es gibt zuletzt noch einen wichtigen Punkt über Variablen zu sagen. Benennen Sie Variablen unbedingt sorgfältig. Nehmen Sie sich einen augenblick Zeit um über einen guten Namen nachzudenken.
 
-Variable naming is one of the most important and complex skills in programming. A quick glance at variable names can reveal which code is written by a beginner and which by an experienced developer.
+Variablenbenennung ist eine der wichtigsten Fähigkeiten für einen Programmierer. Ein kurzer Blick auf die verwendeten Variablennamen in einem Programm erlaubt uns zu entscheiden, ob der Code von einem Anfänger oder einem erfahrenen Entwickler geschrieben wurde.
 
-In a real project, most of the time is spent on modifying and extending the existing code base, rather than writing something completely separate from scratch. And when we return to the code after some time of doing something else, it's much easier to find information that is well-labeled. Or, in other words, when the variables have good names.
+In realen Projekten wird die meiste Zeit darauf verwendet existierenden Code zu verändern oder zu erweitern. Man arbeitet also mit der bestehenden Codebasis und schreibt relativ selten etwas komplett Neues von Grund auf. Kehren wir nach einiger Zeit zu unserem Code zurück ist es einfacher sich zurecht zu finden, wenn die Dinge richtig beschriftet sind; also wenn unsere Variablen gut gewählte Namen tragen.
 
-Please spend some time thinking about the right name for a variable before declaring it. This will repay you a lot.
+Widmen Sie also der Suche nach einem guten Variablennamen etwas Zeit. Diese kleine Investition wird sich früher oder später sicher auszahlen.
 
-Some good-to-follow rules are:
+Hier einige Richtlinien für gute Variablennamen:
 
-- Use human-readable names like `userName` or `shoppingCart`.
-- Stay away from abbreviations or short names like `a`, `b`, `c`, unless you really know what you're doing.
-- Make the name maximally descriptive and concise. Examples of bad names are `data` and `value`. Such a name says nothing. It is only ok to use them if it's exceptionally obvious from the context which data or value is meant.
-- Agree on terms within your team and in your own mind. If a site visitor is called a "user" then we should name related variables like `currentUser` or `newUser`, but not `currentVisitor` or a `newManInTown`.
+- Verwenden Sie sprechende Variablennamen wie `userName` oder `shoppingCart`.
+- Vermeiden Sie Abkürzungen: GDP scheint Ihnen jetzt völlig eindeutig, aber andere Entwickler, oder Sie selbst in einigen Monaten können damit vielleicht nichts mehr anfangen. Vor allem Einbuchstabennamen wie `a`, `b`, `c` sollten nur in Ausnahmen verwendet werden. Eine wichtige Ausnahme sind Schleifenzähler.
+- Variablennamen sollten möglichst gut beschreiben was sie enthalten und eindeutig sein. Schlechte Beispiele wären `data` und `value`. Solche Namen sagen nichts aus und sollten höchsten Verwendet werden, wenn aus dem Kontext eindeutig hervor geht, welche "data" gemeint sind.
+- Verständigen Sie sich auf einige Regeln, entweder im Team oder in Ihrem Kopf. Wenn ein Seitenbesucher "user" genannt wird, sollten damit verbundene Variablen eher `currentUser` oder `newUser` heißen, weniger `currentVisitor` oder `newManInTown`.
 
-Sounds simple? Indeed it is, but creating good descriptive-and-concise names in practice is not. Go for it.
+Sie finden das klingt einfach? Natürlich, aber in der Praxis ist es eine große Herausforderung durchgängig gute Variablennamen zu verwenden. Versuchen Sie es trotzdem.
 
-```smart header="Reuse or create?"
-And the last note. There are some lazy programmers who, instead of declaring a new variable, tend to reuse the existing ones.
+```smart header="Wiederverwenden oder nicht?"
+Zu guter Letzt, es gibt einige faule Programmierer, die, anstatt neue Variablen zu deklarieren, bereits existierende wiederverwenden.
 
-As a result, the variable is like a box where people throw different things without changing the sticker. What is inside it now? Who knows... We need to come closer and check.
+Das führt dazu, dass Variablen wie eine Schachtel sind, in die verschiedene Sachen gestopft werden, ohne die Beschriftung zu ändern. Wir wollen wissen was gerade drin ist? Schwer zu sagen... Wir müssen erstmal genauer nachschauen.
 
-Such a programmer saves a little bit on variable declaration, but loses ten times more on debugging the code.
+Man spart zwar ein paar Sekunden bei der Deklaration von Variablen, aber verliert ein Vielfaches an Zeit, wenn man einen Fehler sucht oder später versucht zu verstehen, was der eigene Code tut.
 
-An extra variable is good, not evil.
+Eine neue Variable zu deklarieren ist etwas Gutes, nicht des Teufels.
 
-Modern JavaScript minifiers and browsers optimize code well enough, so it won't create performance issues. Using different variables for different values can even help the engine to optimize.
+Codeoptimierer und Browser optimieren den Code gut genug, als das es keine Leistungsunterschiede gibt. Verwenden wir verschiedene Variablen für unterschiedliche Daten, kann das sogar der Engine helfen, unseren Code zu optimieren.
 ```
 
-## Summary
+## Zusammenfassung
 
-We can declare variables to store data. That can be done using `var` or `let` or `const`.
+Mit den Anweisungen `let`, `var` oder `const` können wir Variablen deklarieren die dann Daten speichern können.
 
-- `let` -- is a modern variable declaration. The code must be in strict mode to use `let` in Chrome (V8).
-- `var` -- is an old-school variable declaration. Normally we don't use it at all, but we'll cover subtle differences from `let` in the chapter <info:var>, just in case you need them.
-- `const` -- is like `let`, but the value of the variable can't be changed.
+- `let` -- ist die moderne Deklarationsform. Der Code muss im `strict`-Modus vorliegen um `let` verwenden zu können (Chrome, V8).
+- `var` -- ist die ältere Variablendeklaration. Normalerweise werden wir diese Form nicht verwenden, aber wir behandeln die kleinen Unterschiede zu `let` im Kapitel <info:var>, nur für den Fall, dass man mal darüber stolpert.
+- `const` -- verhält sich wie `let`, doch der Inhalt der Variablen kann nicht verändert werden.
 
-Variables should be named in a way that allows us to easily understand what's inside.
+Variablen sollten so benannt sein, dass man einfach erkennen kann, was sie enthalten.
\ No newline at end of file
diff --git a/1-js/02-first-steps/05-types/article.md b/1-js/02-first-steps/05-types/article.md
index 9ed9a2d3b0..636da6c0d0 100644
--- a/1-js/02-first-steps/05-types/article.md
+++ b/1-js/02-first-steps/05-types/article.md
@@ -1,14 +1,14 @@
-# Data types
+# Datentypen
 
-A variable in JavaScript can contain any data. A variable can at one moment be a string and later receive a numeric value:
+Eine Variable in JavaScript kann beliebige Daten enthalten. Zu einem Zeitpunkt kann die Variable eine Zeichenkette enthalten und einen Augenblick später einen Zahlenwert:
 
 ```js
 // no error
-let message = "hello";
+let message = "Hallo";
 message = 123456;
 ```
 
-Programming languages that allow such things are called "dynamically typed", meaning that there are data types, but variables are not bound to any of them.
+Programmiersprachen die so etwas erlauben, heißen dynamisch typisiert. Das bedeutet, dass es zwar Datentypen gibt, eine Variable aber nicht auf einen davon festgelegt ist (anders als etwa in C oder Fortran).
 
 There are seven basic data types in JavaScript. Here we'll study the basics, and in the next chapters we'll talk about each of them in detail.
 
diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 4ccb4fea62..cf2973b99a 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -1,24 +1,27 @@
-# Logical operators
+# Logische Operatoren
 
-There are three logical operators in JavaScript: `||` (OR), `&&` (AND), `!` (NOT).
+Es gibt drei logische Operatoren in JavaScript:
+- ODER: `||` (OR)
+- UND: `&&` (AND) 
+- NICHT: `!` (NOT)
 
-Although they are called "logical", they can be applied to values of any type, not only boolean. The result can also be of any type.
+Obwohl sie ein "logisch" im Namen haben, können sie auf alle Variablentypen angewendet werden, nicht nur Boolesche Variablen. Die Rückgabewerte können ebenfalls ein beliebiger Variablentyp sein.
 
-Let's see the details.
+Aber schauen wir auf die Details.
 
-## || (OR)
+## ODER ||
 
-The "OR" operator is represented with two vertical line symbols:
+Der ODER-Operator (OR) wird durch zwei vertikale Linien dargestellt:
 
 ```js
 result = a || b;
 ```
 
-In classical programming, logical OR is meant to manipulate boolean values only. If any of its arguments are `true`, then it returns `true`, otherwise it returns `false`.
+In klassischen Programmiersprachen ist der ODER-Operator lediglich vorgesehen um mit Booleschen Variablen zu arbeiten. Wenn eines der Argumente den Wert `true` (WAHR) hat, ist der Rückgabewert auch `true`, ansonsten `false` (FALSCH).
 
-In JavaScript the operator is a little bit more tricky and powerful. But first let's see what happens with boolean values.
+In JavaScript ist der Operator ein wenig diffiziler und mächtiger, aber zuerst schauen wir uns die Verwendung mit Booleschen Werten an.
 
-There are four possible logical combinations:
+Es gibt vier mögliche Eingabekombinationen:
 
 ```js run
 alert( true || true );   // true
@@ -27,21 +30,21 @@ alert( true || false );  // true
 alert( false || false ); // false
 ```
 
-As we can see, the result is always `true` except for the case when both operands are `false`.
+Wir sehen, dass der Rückgabewert immer `true` ist, außer wenn beide Operanden den Wert `false` haben.
 
-If an operand is not boolean, then it's converted to boolean for the evaluation.
+Ist einer der Operanten kein Boolescher Wert, wird er zu einem Booleschen konvertiert, bevor die Operation durchgeführt wird.
 
-For instance, a number `1` is treated as `true`, a number `0` -- as `false`:
+Ein wichtiges Beispiel sind die Zahl `1` die als `true` und `0` die als `false` interpretiert werden:
 
 ```js run
-if (1 || 0) { // works just like if( true || false )
-  alert( 'truthy!' );
+if (1 || 0) { // Funktioniert wie if( true || false )
+  alert( 'Wahr!' );
 }
 ```
 
-Most of the time, OR `||` is used in an `if` statement to test if *any* of the given conditions is correct.
+Sehr oft wird die ODER-Operation `||` in `if`-Statements verwendet um zu überprüfen ob *irgendeine* der Bedingungen WAHR ist.
 
-For example:
+Zum Beispiel:
 
 ```js run
 let hour = 9;
@@ -49,55 +52,53 @@ let hour = 9;
 *!*
 if (hour < 10 || hour > 18) {
 */!*
-  alert( 'The office is closed.' );
+  alert( 'Unser Büro ist geschlossen.' );
 }
 ```
 
-We can pass more conditions:
+Durch Verkettung können auch mehr als zwei Eingaben verwendet werden:
 
 ```js run
 let hour = 12;
 let isWeekend = true;
 
 if (hour < 10 || hour > 18 || isWeekend) {
-  alert( 'The office is closed.' ); // it is the weekend
+  alert( 'Unser Büro ist geschlossen.' ); // Weil Wochenende ist
 }
 ```
 
-## OR seeks the first truthy value
+## ODER ermittelt den ersten wahren Wert
 
-The logic described above is somewhat classical. Now let's bring in the "extra" features of JavaScript.
+Unsere bisherigen Beobachtungen entsprechen ganz der klassischen Logik. JavaScript bringt aber noch einige interessante Aspekte neu hinzu.
 
-The extended algorithm works as follows.
-
-Given multiple OR'ed values:
+Nehmen wir an, wir haben mehrere ODER-Verknüpfte Werte:
 
 ```js
-result = value1 || value2 || value3;
+Ergebnis = Wert1 || Wert2 || Wert3;
 ```
 
-The OR `||` operator does the following:
+Der ODER-Operator `||` verhält sich nun wie folgt:
 
-- Evaluate operands from left to right.
-- For each operand, convert it to boolean. If the result is `true`, then stop and return the original value of that operand.
-- If all other operands have been assessed (i.e. all were `false`), return the last operand.
+- Die Operanden werden von links nach rechts Ausgewertet.
+- Jeder Operand wird in einen Booleschen Wert konvertiert. Wenn das Ergebnis `true` ist, wird die Auswertung gestoppt und der ursprüngliche (nicht konvertierte) Wert des Operanden zurückgegeben.
+- Wurden alle Operanden bearbeitet (und alle liefern `false` zurück), wird der der Originalwert des letzten Operanden zurückgegeben.
 
-A value is returned in its original form, without the conversion.
+Es wird immer der origignale, nicht konvertierte Wert des Operanden zurückgegeben.
 
-In other words, a chain of OR `"||"` returns the first truthy value or the last one if no such value is found.
+Anders formuliert, liefert eine Kette von ODER-Operationen `"||"` den ersten wahr aussehenden Wert zurück oder den letzten Wert, falls kein wahrer Wert existiert.
 
-For instance:
+Zum Beispiel:
 
 ```js run
-alert( 1 || 0 ); // 1 (1 is truthy)
-alert( true || 'no matter what' ); // (true is truthy)
+alert( 1 || 0 ); // 1 
+alert( true || 'Egal was hier steht' ); // true
 
-alert( null || 1 ); // 1 (1 is the first truthy value)
-alert( null || 0 || 1 ); // 1 (the first truthy value)
-alert( undefined || null || 0 ); // 0 (all falsy, returns the last value)
+alert( null || 1 ); // 1 
+alert( null || 0 || 1 ); // 1 
+alert( undefined || null || 0 ); // 0 (alle false, letzter Wert wird zurückgegeben)
 ```
 
-That leads to some interesting usages compared to a "pure, classical, boolean-only OR".
+Dieses Verhalten erlaubt einige interessante Verwendungsmöglichkeiten, die über die klassische, logische Verwendung des Booleschen ODER hinaus gehen.
 
 1. **Getting the first truthy value from the list of variables or expressions.**
 
diff --git a/1-js/03-code-quality/01-debugging-chrome/article.md b/1-js/03-code-quality/01-debugging-chrome/article.md
index d09493a2eb..f337186f55 100644
--- a/1-js/03-code-quality/01-debugging-chrome/article.md
+++ b/1-js/03-code-quality/01-debugging-chrome/article.md
@@ -1,183 +1,183 @@
-# Debugging in Chrome
+# Debuggen in Chrome
 
-Before writing more complex code, let's talk about debugging.
+Bevor wir komplexeren Code schreiben, lass uns über Debuggen sprechen.
 
-All modern browsers and most other environments support "debugging" -- a special UI in developer tools that makes finding and fixing errors much easier.
+Alle modernen Browser und die meisten anderen Umgebungen unterstützen "debuggen" -- eine spezielle UI in den Entwicklerwerkzeugen, welches es einfacher macht Fehler zu finden und zu beheben.
 
-We'll be using Chrome here, because it's probably the most feature-rich in this aspect.
+Wir werden hier Chrome verwenden, da er wahrscheinlich den Funktionsreichsten in diesem Bereich hat.
 
-## The "sources" pane
+## Der "sources" Bereich
 
-Your Chrome version may look a little bit different, but it still should be obvious what's there.
+Deine Chrome Version sieht vielleicht etwas anders aus, aber es sollte trotzdem offensichtlich sein, was es gibt.
 
-- Open the [example page](debugging/index.html) in Chrome.
-- Turn on developer tools with `key:F12` (Mac: `key:Cmd+Opt+I`).
-- Select the `sources` pane.
+- Öffne die [Beispielseite](debugging/index.html) in Chrome.
+- Öffne die Entwicklerwerkzeugen mit `key:F12` (Mac: `key:Cmd+Opt+I`).
+- Öffne den `sources` Bereich.
 
-Here's what you should see if you are doing it for the first time:
+Folgendes sollten Sie sehen, wenn Sie dies zum ersten Mal machst:
 
 ![](chrome-open-sources.png)
 
-The toggler button <span class="devtools" style="background-position:-168px -76px"></span> opens the tab with files.
+Die Schaltfäche <span class="devtools" style="background-position:-168px -76px"></span> öffnet die Registerkarte mit den Dateien.
 
-Let's click it and select `index.html` and then `hello.js` in the tree view. Here's what should show up:
+Wir klicken darauf und wählen `index.html` aus und danach `hello.js` in der Baumansicht. Danach sollte es etwa so bei Ihnen aussehen:
 
 ![](chrome-tabs.png)
 
-Here we can see three zones:
+Hier können wir 3 Bereiche erkennen:
 
-1. The **Resources zone** lists HTML, JavaScript, CSS and other files, including images that are attached to the page. Chrome extensions may appear here too.
-2. The **Source zone** shows the source code.
-3. The **Information and control zone** is for debugging, we'll explore it soon.
+1. Der **Ressourcen Bereich** listet HTML, JavaScript, CSS und andere Dateien auf, einschließlich Bilder die in der Seite eingebunden.
+2. Der **Source Bereich** zeigt den Source Code.
+3. Der **Information und Kontroll Bereich** ist für das Debuggen, wir werden ihn bald erkunden.
 
-Now you could click the same toggler <span class="devtools" style="background-position:-200px -76px"></span> again to hide the resources list and give the code some space.
+Jetzt können Sie auf die selbe Schaltfläche <span class="devtools" style="background-position:-200px -76px"></span> erneut klicken um die Ressourcen Liste zu verstecken um dem Code platz zu schaffen.
 
 ## Console
 
-If we press `Esc`, then a console opens below. We can type commands there and press `key:Enter` to execute.
+Wenn wir  `Esc` drücken, dann öffnet sich darunter eine Console. Wir können dort Befehle eingeben und mit  `key:Enter` ausführen.
 
-After a statement is executed, its result is shown below.
+Nachdem eine Anweisung ausgeführt wurde, wird das Ergebnis darunter angezeigt.
 
-For example, here `1+2` results in `3`, and `hello("debugger")` returns nothing, so the result is `undefined`:
+Als Beispiel, hier `1+2` ergibt  `3`, und `hello("debugger")`  liefert nichts, daher ist das Ergebnis  `undefined`:
 
 ![](chrome-sources-console.png)
 
-## Breakpoints
+## Haltepunkte
 
-Let's examine what's going on within the code of the [example page](debugging/index.html). In `hello.js`, click at line number `4`. Yes, right on the `4` digit, not on the code.
+ Lassen Sie uns untersuchen, was innerhalb des Codes der [Beispielseite](debugging/index.html) vor sich geht. In `hello.js`, klicke auf die Zeilennummer  `4`. Ja, direkt auf die Zahl `4`, nicht im Code.
 
-Congratulations! You've set a breakpoint. Please also click on the number for line `8`.
+Herzlichen Glückwunsch! Sie haben einen Haltepunkt gesetzt. Bitte klicken Sie auch auf die Nummer für Zeile `8`.
 
-It should look like this (blue is where you should click):
+Es sollte wie folgt aussehen (Blau markiert an welcher stelle Sie klicken sollen):
 
 ![](chrome-sources-breakpoint.png)
 
-A *breakpoint* is a point of code where the debugger will automatically pause the JavaScript execution.
+Ein *Haltepunkt* ist ein Punkt im Code an der der Debugger automatisch anhalten wird, während der JavaScript ausführung.
 
-While the code is paused, we can examine current variables, execute commands in the console etc. In other words, we can debug it.
+Währen der Code angehalten ist können wir die aktuellen Variablen untersuchen, Befehle in der Console ausführen etc. In anderen Worten, wir können es debuggen.
 
-We can always find a list of breakpoints in the right pane. That's useful when we have many breakpoints in various files. It allows to:
-- Quickly jump to the breakpoint in the code (by clicking on it in the right pane).
-- Temporarily disable the breakpoint by unchecking it.
-- Remove the breakpoint by right-clicking and selecting Remove.
-- ...And so on.
+Wir können immer eine Liste von Haltepunkten im rechten Bereich finden. Dies ist nützlich, wenn wir viele Haltepunkte in verschiedenen Dateien haben. Das erlaubt uns:
+- Schnell zu einem Haltepunkt im Code zu springen (durch klicken auf ihn im rechten Bereich).
+- Temporär einen Haltepunkt auszuschalten indem wir in abwählen.
+- Den Haltepunkt zu entfernen durch rechts klicken und entfernen auswählen .
+- ...Und so weiter.
 
 ```smart header="Conditional breakpoints"
-*Right click* on the line number allows to create a *conditional* breakpoint. It only triggers when the given expression is truthy.
+*Rechts-Klick* auf die Zeilennummer erlaubt es uns ein *bedingten* Haltepunkt. Er wird nur ausgelöst wenn der gegebene  Ausdruck wahr ist.
 
-That's handy when we need to stop only for a certain variable value or for certain function parameters.
+Das ist praktisch, wenn wir nur für einen bestimmten Variablenwert oder für bestimmte Funktionsparameter anhalten müssen.
 ```
 
-## Debugger command
+## Debugger Befehl
 
-We can also pause the code by using the `debugger` command, like this:
+Wir können auch den Code anhalten durch das nutzen des `debugger` Befehles,  so wie hier:
 
 ```js
 function hello(name) {
   let phrase = `Hello, ${name}!`;
 
 *!*
-  debugger;  // <-- the debugger stops here
+  debugger;  // <-- der Debugger hält hier an
 */!*
 
   say(phrase);
 }
 ```
 
-That's very convenient when we are in a code editor and don't want to switch to the browser and look up the script in developer tools to set the breakpoint.
+Das ist sehr praktisch, wenn wir uns in einem Code-Editor befinden und nicht zum Browser wechseln und das Script in den Entwicklertools nachschlagen wollen, um den Haltepunkt zu setzen.
 
 
-## Pause and look around
+## Pause und umhersehen 
 
-In our example, `hello()` is called during the page load, so the easiest way to activate the debugger is to reload the page. So let's press `key:F5` (Windows, Linux) or `key:Cmd+R` (Mac).
+In unserem Beispiel, `hello()`  wir währen des Seitenladens aufgerufen, so das der einfachste Weg ist um den Debugger zu aktivieren, das Neuladen der Seite ist. Also lass uns  `key:F5` drücken (Windows, Linux) oder `key:Cmd+R` (Mac).
 
-As the breakpoint is set, the execution pauses at the 4th line:
+Ist der Haltepunkt gesetzt, hält die Ausführung in der 4 Zeile an:
 
 ![](chrome-sources-debugger-pause.png)
 
-Please open the informational dropdowns to the right (labeled with arrows). They allow you to examine the current code state:
+Bitte öffne die Dropdown-Listen für Informationen auf der rechten Seite  (markiert mit Pfeilen). Diese erlaubt Ihnen den aktuellen Code-Zustand zu untersuchen:
 
-1. **`Watch` -- shows current values for any expressions.**
+1. **`Watch` -- zeigt aktuelle Werte für beliebige Ausdrücke an.**
 
-    You can click the plus `+` and input an expression. The debugger will show its value at any moment, automatically recalculating it in the process of execution.
+    Sie können das Plus anklicken `+` und einen Ausdruck eingeben. Der Debugger wird den Wert zu jedem Moment anzeigen, er wird automatisch neu berechnet während die Ausführung läuft.
 
-2. **`Call Stack` -- shows the nested calls chain.**
+2. **`Call Stack` -- zeigt die verschachtelte Aufrufkette an.**
 
-    At the current moment the debugger is inside `hello()` call, called by a script in `index.html` (no function there, so it's called "anonymous").
+   Im aktuellen Moment ist der Debugger im `hello()` aufruf, aufgerufen durch ein Script in `index.html` (hier ist keine Funktion, daher wird es "anonym" aufgerufen).
 
-    If you click on a stack item, the debugger jumps to the corresponding code, and all its variables can be examined as well.
-3. **`Scope` -- current variables.**
+    Wenn Sie auf ein Stack Item klicken, springt der Debugger zum zugehörigen Code, und alle seine Variablen können ebenfalls untersucht werden.
+3. **`Scope` -- aktuelle Variablen.**
 
-    `Local` shows local function variables. You can also see their values highlighted right over the source.
+    `Local` zeigt lokale Funktionsvariablen. Sie können ihre Werte auch direkt über dem Code hervorgehoben sehen .
 
-    `Global` has global variables (out of any functions).
+    `Global` hat globale Variablen (außerhalb von allen Funktionen).
 
-    There's also `this` keyword there that we didn't study yet, but we'll do that soon.
+    Dort ist auch das `this` Schlüsselwort, welches wir bisher nicht kennengelernt haben, aber das werden wir bald tun.
 
-## Tracing the execution
+## Verfolgung der Ausführung
 
-Now it's time to *trace* the script.
+Nun ist es an der Zeit, das Skript zu verfolgen.
 
-There are buttons for it at the top of the right pane. Let's engage them.
+Hierfür gibt es Schaltflächen im oberen rechten Bereich. Nehmen wir diese ins Visier.
 
-<span class="devtools" style="background-position:-7px -76px"></span> -- continue the execution, hotkey `key:F8`.
-: Resumes the execution. If there are no additional breakpoints, then the execution just continues and the debugger loses control.
+<span class="devtools" style="background-position:-7px -76px"></span> -- die Ausführung weiter fortsetzen,  Kurztaste `key:F8`.
+: Setzt die Ausführung fort. Gibt es keine weiteren Haltepunkte, wird die Ausführung einfach fortgesetzt und der Debugger verliert die Kontrolle.
 
-    Here's what we can see after a click on it:
+Hier ist, was wir nach einem Klick darauf sehen können:
 
-    ![](chrome-sources-debugger-trace-1.png)
+![](chrome-sources-debugger-trace-1.png)
 
-    The execution has resumed, reached another breakpoint inside `say()` and paused there. Take a look at the "Call stack" at the right. It has increased by one more call. We're inside `say()` now.
+    Die Ausführung wurde fortgesetzt, erreicht einen anderen Haltepunkt innerhalb von `say()` und hält dort an. Werfen Sie einen Blick auf den  "Call stack" auf der rechten Seite. Es hat sich um einen weiteren Anruf erhöht. Wir sind nun innerhalb von `say()`.
 
-<span class="devtools" style="background-position:-137px -76px"></span> -- make a step (run the next command), but *don't go into the function*, hotkey `key:F10`.
-: If we click it now, `alert` will be shown. The important thing is that `alert` can be any function, the execution "steps over it", skipping the function internals.
+<span class="devtools" style="background-position:-137px -76px"></span> -- einen Schritt tun (den nächsten Befehl ausführen), aber *nicht in die Funktion hinein gehen*, Kurztaste `key:F10`.
+: Wenn wir es jetzt anklicken, wird ein `alert` angezeigt. Das Wichtige dabei ist `alert` kann jede Funktion sein, die Ausführung "geht darüber hinweg", es überspringt den Funktionsinhalt.
 
-<span class="devtools" style="background-position:-72px -76px"></span> -- make a step, hotkey `key:F11`.
-: The same as the previous one, but "steps into" nested functions. Clicking this will step through all script actions one by one.
+<span class="devtools" style="background-position:-72px -76px"></span> -- einen Schritt tun, Kurztaste `key:F11`.
+: Wie der Vorherige, allerdings "hineingehen" in geschachtelte Funktionen . Wenn Sie darauf klicken, werden alle Skript-Aktionen nacheinander ausgeführt.
 
-<span class="devtools" style="background-position:-104px -76px"></span> -- continue the execution till the end of the current function, hotkey `key:Shift+F11`.
-: The execution would stop at the very last line of the current function. That's handy when we accidentally entered a nested call using <span class="devtools" style="background-position:-72px -76px"></span>, but it does not interest us, and we want to continue to its end as soon as possible.
+<span class="devtools" style="background-position:-104px -76px"></span> -- fortsetzen der Ausführung bis zum Ende der aktuellen Funktion, Kurztaste `key:Shift+F11`.
+: Die Ausführung stoppt an der aller letzten Zeile der aktuellen Funktion. Dies ist nett wenn man ausversehen eine verschachtelte Funktion aufgerufen hat <span class="devtools" style="background-position:-72px -76px"></span>, diese interessiert uns aber nicht, und wir wollen diese so schnell wie möglich wieder verlassen.
 
-<span class="devtools" style="background-position:-7px -28px"></span> -- enable/disable all breakpoints.
-: That button does not move the execution. Just a mass on/off for breakpoints.
+<span class="devtools" style="background-position:-7px -28px"></span> -- aktivieren/deaktivieren aller Haltepunkte.
+: Diese Schaltfläche bewegt die Ausführung nicht. Sie aktiviert/deaktiviert nur alle Haltepunkte.
 
-<span class="devtools" style="background-position:-264px -4px"></span> -- enable/disable automatic pause in case of an error.
-: When enabled, and the developer tools is open, a script error automatically pauses the execution. Then we can analyze variables to see what went wrong. So if our script dies with an error, we can open debugger, enable this option and reload the page to see where it dies and what's the context at that moment.
+<span class="devtools" style="background-position:-264px -4px"></span> -- aktivieren/deaktivieren der automatischen Pause im Falle eines Fehlers.
+: Ist dies aktiviert, und die Entwicklerwerkzeuge sind offen, ein Script Fehler führt zu einem automatischen Anhalten der Ausführung. Dann können wir die Variablen analysieren um zu sehen was falsch lief. Das heißt wenn unser Script mit einem Fehler stirbt, können wir den Debugger öffnen, diese Option aktivieren und die Seite neuladen um zu sehen an welcher Stelle es stirbt und was der Kontext an dieser Stelle ist.
 
 ```smart header="Continue to here"
-Right click on a line of code opens the context menu with a great option called "Continue to here".
+Rechtsklick auf die Zeile öffnet das Kontext Menu mit einer großartigen Option mit dem Namen: "Continue to here".
 
-That's handy when we want to move multiple steps forward, but we're too lazy to set a breakpoint.
+Dies ist Nützlich wenn wir mehrere Schritte vorwärts wollen, aber wir zu faul sind um Haltepunkte zu setzten.
 ```
 
 ## Logging
 
-To output something to console, there's `console.log` function.
+Um irgendetwas in der Console anzuzeigen , gibt es die `console.log` Funktion.
 
-For instance, this outputs values from `0` to `4` to console:
+Zum Beispiel gibt dies Werte von `0` bis `4` in der Console aus:
 
 ```js run
-// open console to see
+// öffne die Console um es zu sehen
 for (let i = 0; i < 5; i++) {
   console.log("value", i);
 }
 ```
 
-Regular users don't see that output, it is in the console. To see it, either open the Console tab of developer tools or press `key:Esc` while in another tab: that opens the console at the bottom.
+Normalerweise sieht der Nutzer diese Ausgabe nicht, sie erscheint in der Console. Um sie zu sehen, öffne entweder den Console Bereich in den Entwicklerwerkzeugen oder drücke `key:Esc` während Sie sich in einer anderen Registerkarte befinden: dies öffnet die Console an der Unterseite.
 
-If we have enough logging in our code, then we can see what's going on from the records, without the debugger.
+Wenn wir genügend Logging in unserem Code haben, dann können wir sehen, was in den Datensätzen vor sich geht, ohne den Debugger.
 
-## Summary
+## Übersicht
 
-As we can see, there are three main ways to pause a script:
-1. A breakpoint.
-2. The `debugger` statements.
-3. An error (if dev tools are open and the button <span class="devtools" style="background-position:-264px -4px"></span> is "on")
+Wie wir sehen können, gibt es drei Hauptmöglichkeiten ein Script zu unterbrechen:
+1. Ein Haltepunkt.
+2. Das `debugger` Statement.
+3. Ein Fehler (wenn die Entwicklerwerkzeuge geöffnet sind und die Schaltfläche <span class="devtools" style="background-position:-264px -4px"></span> auf "on" ist)
 
-Then we can examine variables and step on to see where the execution goes wrong.
+Dann können wir Variablen untersuchen und weitermachen, um zu sehen, wo die Ausführung falsch läuft.
 
-There are many more options in developer tools than covered here. The full manual is at <https://developers.google.com/web/tools/chrome-devtools>.
+Es gibt noch viel mehr Möglichkeiten in den Entwicklerwerkzeugen als hier beschrieben sind. Das vollständige Handbuch finden Sie unter <https://developers.google.com/web/tools/chrome-devtools>.
 
-The information from this chapter is enough to begin debugging, but later, especially if you do a lot of browser stuff, please go there and look through more advanced capabilities of developer tools.
+Die Informationen aus diesem Kapitel reichen aus, um mit dem Debuggen zu beginnen, aber später, besonders wenn Sie viel Browserarbeit leisten, gehen Sie bitte dorthin und schauen Sie sich die erweiterten Funktionen der Entwicklerwerkzeuge an.
 
-Oh, and also you can click at various places of dev tools and just see what's showing up. That's probably the fastest route to learn dev tools. Don't forget about the right click as well!
+Oh, und auch Sie können an verschiedenen Stellen der Entwicklungswerkzeuge klicken und einfach sehen, was angezeigt wird. Das ist wahrscheinlich der schnellste Weg, um Entwicklungswerkzeuge zu erlernen. Vergiss auch den Rechtsklick nicht!
diff --git a/3-animation/1-bezier-curve/article.md b/3-animation/1-bezier-curve/article.md
index 0d4162570d..4baff9a9fd 100644
--- a/3-animation/1-bezier-curve/article.md
+++ b/3-animation/1-bezier-curve/article.md
@@ -1,193 +1,182 @@
-# Bezier curve
+# Bézierkurven
 
-Bezier curves are used in computer graphics to draw shapes, for CSS animation and in many other places.
+Bézierkurven werden in der Computergrafik verwendet um Formen zu beschreiben, für CSS-Animationen und auch an vielen anderen Stellen.
 
-They are actually a very simple thing, worth to study once and then feel comfortable in the world of vector graphics and advanced animations.
+Sie sind letztlich eine recht einfache Konstruktion, die es sich einmal detailliert zu studieren lohnt um sich in der Welt der Vektorgrafik und der Animationen heimisch zu fühlen.
 
-## Control points
+## Kontrollpunkte
 
-A [bezier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve) is defined by control points.
+Eine [Bézierkurve](https://de.wikipedia.org/wiki/Bézierkurve) wird durch Kontrollpunkte definiert.
 
-There may be 2, 3, 4 or more.
+Es kann 2, 3, 4 oder auch mehr geben.
 
-For instance, two points curve:
+Zum Beispiel sieht eine Bézierkurve mit zwei Kontrollpunkten wie folgt aus:
 
 ![](bezier2.png)
 
-Three points curve:
+Eine Bézierkurve mit drei Kontrollpunkten:
 
 ![](bezier3.png)
 
-Four points curve:
+Und eine Bézierkurve mit vier Kontrollpunkten:
 
 ![](bezier4.png)
 
-If you look closely at these curves, you can immediately notice:
+Ein etwas genauerer Blick auf diese Kurven offenbart uns einige interessante Eigenschaften:
 
-1. **Points are not always on curve.** That's perfectly normal, later we'll see how the curve is built.
-2. **The curve order equals the number of points minus one**.
-For two points we have a linear curve (that's a straight line), for three points -- quadratic curve (parabolic), for three points -- cubic curve.
-3. **A curve is always inside the [convex hull](https://en.wikipedia.org/wiki/Convex_hull) of control points:**
+1. **Kontrollpunkte müssen nicht auf der Kurve liegen.** Wir werden später sehen, wie genau die Bézierkurven konstruiert werden.
+2. **Die Ordnung der Kurve ist gleich die Anzahl der Kontrollpunkte minus eins**
+Aus zwei Kontrollpunkten erhalten wir eine gerade Linie, aus drei Punkten eine quadratische Kurve und aus vier Kontrollpunkten eine kubische Kurve.
+3. **Die Bézierkurve liegt immer innerhalb der [konvexen Hülle](https://de.wikipedia.org/wiki/Konvexe_Hülle) der Kontrollpunkte:**
 
     ![](bezier4-e.png) ![](bezier3-e.png)
 
-Because of that last property, in computer graphics it's possible to optimize intersection tests. If convex hulls do not intersect, then curves do not either. So checking for the convex hulls intersection first can give a very fast "no intersection" result. Checking the intersection or convex hulls is much easier, because they are rectangles, triangles and so on (see the picture above), much simpler figures than the curve.
+Von der letzten Eigenschaft können wir gebrauch machen, wenn wir Kurven auf Überschneidungen testen wollen. Überschneiden sich die konvexen Hüllen nicht, dann tun es die zugehörigen Bézierkurven auch nicht. Prüft man also zuerst ob keine Überschneidungen der konvexen Hüllen vorliegen, so hat man einen schnellen Ausschlusstest für die Kurvenüberschneidung. Da die konvexen Hüllen eine einfacherer Form haben als die Kurven selbst, ist hier ein schnellerer Test auf Überschneidungen möglich.
 
-The main value of Bezier curves for drawing -- by moving the points the curve is changing *in intuitively obvious way*.
+Einen großen Wert bieten Bézierkurven beim Erstellen von Zeichnungen. Verschiebt man die Kontrollpunkte, verändert die Kurve ihre Form in einer sehr intuitiven Art und Weise.
 
-Try to move control points using a mouse in the example below:
+Versuchen Sie die Kontrollpunkte im untenstehenden Beispiel mit der Maus zu verschieben und sehen Sie, was dabei passiert:
 
 [iframe src="http://github.com/demo.svg?nocpath=1&p=0,0,0.5,0,0.5,1,1,1" height=370]
 
-**As you can notice, the curve stretches along the tangential lines 1 -> 2 and 3 -> 4.**
+**Man kann feststellen, dass sich die Bézierkurve entlang der Tangenten zwischen 1 -> 2 und 3 -> 4 erstreckt.**
 
-After some practice it becomes obvious how to place points to get the needed curve. And by connecting several curves we can get practically anything.
-
-Here are some examples:
+Mit etwas Übung schafft man es schnell, die Punkte so zu platzieren, dass man die gewünschte Kurve erhält. Aus der Verbindung mehrerer Kurven kann man praktisch jedes Objekt modellieren, hier ein paar Beispiele:
 
 ![](bezier-car.png) ![](bezier-letter.png) ![](bezier-vase.png)
 
-## Maths
-
-A Bezier curve can be described using a mathematical formula.
+## Die Mathematik dahinter
 
-As we'll see soon -- there's no need to know it. But for completeness -- here it is.
+Bézierkurven werden durch vergleichsweise einfache Formeln beschrieben. Wir werden bald sehen, dass man diese nicht unbedingt kennen muss, aber zur Vollständigkeit schauen wir sie uns kurz an.
 
-Given the coordinates of control points <code>P<sub>i</sub></code>: the first control point has coordinates <code>P<sub>1</sub> = (x<sub>1</sub>, y<sub>1</sub>)</code>, the second: <code>P<sub>2</sub> = (x<sub>2</sub>, y<sub>2</sub>)</code>, and so on, the curve coordinates are described by the equation that depends on the parameter `t` from the segment `[0,1]`.
+Die Kontrollpunkte <code>P<sub>i</sub></code> lauten: Der erste Kontrollpunkt hat die Koordinaten <code>P<sub>1</sub> = (x<sub>1</sub>, y<sub>1</sub>)</code>, der zweite Kontrollpunkt: <code>P<sub>2</sub> = (x<sub>2</sub>, y<sub>2</sub>)</code>, und so weiter. Die Koordinaten der Bézierkurve werden von Gleichungen beschrieben die vom Parameter `t` im Interval `[0, 1]` abhängen.
 
-- The formula for a 2-points curve:
+- Die Formel für eine 2-Punktkurve lautet:
 
     <code>P = (1-t)P<sub>1</sub> + tP<sub>2</sub></code>
-- For three points:
+- Für eine 3-Punktkurve:
 
     <code>P = (1−t)<sup>2</sup>P<sub>1</sub> + 2(1−t)tP<sub>2</sub> + t<sup>2</sup>P<sub>3</sub></code>
-- For four points:
+- Für eine 4-Punktkurve:
 
     <code>P = (1−t)<sup>3</sup>P<sub>1</sub> + 3(1−t)<sup>2</sup>tP<sub>2</sub>  +3(1−t)t<sup>2</sup>P<sub>3</sub> + t<sup>3</sup>P<sub>4</sub></code>
 
-These are vector equations.
+Diese drei Gleichungen sind Vektorgleichungen.
 
-We can rewrite them coordinate-by-coordinate, for instance the 3-point curve:
+Wir können die Gleichungen auch für jede Koordinate einzeln aufschreiben. Die 3-Punktkurve wird dann zum Beispiel zu:
 
 - <code>x = (1−t)<sup>2</sup>x<sub>1</sub> + 2(1−t)tx<sub>2</sub> + t<sup>2</sup>x<sub>3</sub></code>
 - <code>y = (1−t)<sup>2</sup>y<sub>1</sub> + 2(1−t)ty<sub>2</sub> + t<sup>2</sup>y<sub>3</sub></code>
 
-Instead of <code>x<sub>1</sub>, y<sub>1</sub>, x<sub>2</sub>, y<sub>2</sub>, x<sub>3</sub>, y<sub>3</sub></code> we should put coordinates of 3 control points.
+Wir ersetzen dann <code>x<sub>1</sub>, y<sub>1</sub>, x<sub>2</sub>, y<sub>2</sub>, x<sub>3</sub>, y<sub>3</sub></code> durch die Koordinaten von unseren Kontrollpunkten.
 
-For instance, if control points are  `(0,0)`, `(0.5, 1)` and `(1, 0)`, the equations are:
+Lauten also zum Beispiel unsere Kontrollpunkte `(0, 0)`, `(0.5, 1)` und `(1, 0)`, werden unsere Gleichungen zu:
 
 - <code>x = (1−t)<sup>2</sup> * 0 + 2(1−t)t * 0.5 + t<sup>2</sup> * 1 = (1-t)t + t<sup>2</sup> = t</code>
 - <code>y = (1−t)<sup>2</sup> * 0 + 2(1−t)t * 1 + t<sup>2</sup> * 0 = 2(1-t)t = –t<sup>2</sup> + 2t</code>
 
-Now as `t` runs from `0` to `1`, the set of values `(x,y)` for each `t` forms the curve.
-
-That's probably too scientific, not very obvious why curves look like that, and how they depend on control points.
+Läuft nun unser Parameter `t` von `0` bis `1`, ein `(x,y)`-Wertepaar für jedes `t` beschreibt die Form der Kurve.
 
-So here's the drawing algorithm that may be easier to understand.
+Diese Beschreibung ist vielleicht nicht sehr intuitiv, denn es ist nicht sehr offensichtlich wie die resultierende Bézierkurve aussehen wird und wie die Position der Kontrollpunkte beeinflusst wird.
 
-## De Casteljau's algorithm
+Schauen wir uns daher einen Algorithmus an, der die Bézierkurve konstruiert und etwas intuitiver zugänglich ist.
 
-[De Casteljau's algorithm](https://en.wikipedia.org/wiki/De_Casteljau%27s_algorithm) is identical to the mathematical definition of the curve, but visually shows how it is built.
+## De-Casteljau-Algorithmus
 
-Let's see it on the 3-points example.
+Der [De-Casteljau-Algorithm](https://de.wikipedia.org/wiki/De-Casteljau-Algorithmus) ist identisch zur oben gegebenen mathematischen Definition, zeigt aber visuell, wie die Bézierkurve konstruiert wird.
 
-Here's the demo, and the explanation follow.
+Schauen wir uns die Funktionsweise des Algorithmusses anhand des 3-Punktbeispiels an. Zunächst eine kleine Demo und anschließend die Erklärungen.
 
-Points can be moved by the mouse. Press the "play" button to run it.
+Die Punkte können mit der Maus verschoben werden. Drücken Sie den "Play"-Knopf um den Algorithmus ablaufen zu lassen.
 
 [iframe src="http://github.com/demo.svg?p=0,0,0.5,1,1,0&animate=1" height=370]
 
-**De Casteljau's algorithm of building the 3-point bezier curve:**
+**Der De-Casteljau-Algorithmus zur Konstruktion einer 3-Punkt-Bézierkurve:**
 
-1. Draw control points. In the demo above they are labeled: `1`, `2`, `3`.
-2. Build segments between control points 1 -> 2 -> 3. In the demo above they are <span style="color:#825E28">brown</span>.
-3. The parameter `t` moves from `0` to `1`. In the example above the step `0.05` is used: the loop goes over `0, 0.05, 0.1, 0.15, ... 0.95, 1`.
+1. Einzeichnen der Kontrollpunkte. In unserem Beispiel heißen diese `1`, `2` und `3`.
+2. Konstruiere Verbindungslinien zwischen den Kontrollpunkten 1 -> 2 und 2 -> 3. In unserem Beispiel in <span style="color:#825E28">braun</span> eingezeichnet.
+3. Der Parameter `t` läuft wieder von `0` bis `1`. In unserem Beispiel verwenden wir eine Schrittweite von `0.05`: `t` nimmt also die Werte `0, 0.05, 0.1, 0.15, ... 0.95, 1` an.
 
-    For each of these values of `t`:
+    Für jeden dieser Werte von `t`:
 
-    - On each <span style="color:#825E28">brown</span> segment we take a point located on the distance proportional to `t` from its beginning. As there are two segments, we have two points.
+    - Auf jedem der <span style="color:#825E28">braunen</span> Segmente suchen wir einen Punkt der um den Anteil `t` vom Anfang entfernt liegt. Da es zwei <span style="color:#825E28">braune</span> Segmente gibt, erhalten wir auch zwei Punkte.
 
-        For instance, for `t=0` -- both points will be at the beginning of segments, and for `t=0.25` -- on the 25% of segment length from the beginning, for `t=0.5` -- 50%(the middle), for `t=1` -- in the end of segments.
+        Zum Beispiel liegen für `t = 0` beide Punkte am Anfang der Segmente; für `t = 0.25` liegen die Punkte 25% der Segmentlänge vom Anfang entfernt; für `t = 0.5` in der Mitte der Segmente; und für `t = 1` am Ende der Segmente.
 
-    - Connect the points. On the picture below the connecting segment is painted <span style="color:#167490">blue</span>.
+    - Verbinde die so erhaltenen Punkte. In der folgenden Abbildung ist die Verbindungslinie in <span style="color:#167490">blau</span> eingezeichnet.
 
 
-| For `t=0.25`             | For `t=0.5`            |
+| Für `t=0.25`             | Für `t=0.5`            |
 | ------------------------ | ---------------------- |
 | ![](bezier3-draw1.png)   | ![](bezier3-draw2.png) |
 
-4. Now the <span style="color:#167490">blue</span> segment take a point on the distance proportional to the same value of `t`. That is, for `t=0.25` (the left picture) we have a point at the end of the left quarter of the segment, and for `t=0.5` (the right picture) -- in the middle of the segment. On pictures above that point is <span style="color:red">red</span>.
+4. Auf dem neuen <span style="color:#167490">blauen</span> Segment suchen wir einen Punkt der um den Anteil `t` vom Anfang entfernt liegt. Für `t = 0.25` (die linke Abbildung) erhalten wir einen Punkt ein Viertel der Segmentlänge vom Ende entfernt. Für `t = 0.5` (die rechte Abbildung) liegt der Punkt in der Segmentmitte. Der neue Punkt ist mit <span style="color:red">rot</span> in den Abbildungen eingezeichnet.
 
-5. As `t` runs from `0` to `1`, every value of `t` adds a point to the curve. The set of such points forms the Bezier curve. It's red and parabolic on the pictures above.
+5. Läuft nun `t` von `0` bis `1`, wird für jeden Wert von `t` ein Punkt der Kurve hinzugefügt. Alle diese Punkte zusammen bilden die Bézierkurve.
 
-That was a process for 3 points. But the same is for 4 points.
+Analog zu diesem Beispiel einer 3-Punktkurve, funktioniert auch die Konstruktion für eine 4-Punktkurve.
 
-The demo for 4 points (points can be moved by mouse):
+In der folgenden Demo können wieder die Punkte mit der Maus verschoben werden:
 
 [iframe src="http://github.com/demo.svg?p=0,0,0.5,0,0.5,1,1,1&animate=1" height=370]
 
-The algorithm:
+Der Algorithmus wird zu:
 
-- Control points are connected by segments: 1 -> 2, 2 -> 3, 3 -> 4. We have 3 <span style="color:#825E28">brown</span> segments.
-- For each `t` in the interval from `0` to `1`:
-    - We take points on these segments on the distance proportional to `t` from the beginning. These points are connected, so that we have two <span style="color:#0A0">green segments</span>.
-    - On these segments we take points proportional to `t`. We get one <span style="color:#167490">blue segment</span>.
-    - On the blue segment we take a point proportional to `t`. On the example above it's <span style="color:red">red</span>.
-- These points together form the curve.
+- Die vier Kontrollpunkte werden durch die drei <span style="color:#825E28">braunen</span> Segmente 1 -> 2, 2 -> 3 und 3 -> 4 verbunden.
+- Für jedes `t` aus dem Interval von `0` bis `1`:
+    - Suchen wir einen Punkt auf jedem Segment, der um den Anteil `t` vom Anfang entfernt liegt. Diese Punkte werden verbunden, so das wir zwei neue <span style="color:#0A0">grüne</span> Segmente erhalten.
+    - Auf diesen Segmenten suchen wir wieder Punkte die `t` vom Anfang entfernt liegen und wir erhalten ein neues <span style="color:#167490">blaues</span> Segment.
+    - Auf diesem <span style="color:#167490">blauen</span> Segment suchen wir wiederum einen Punkt der um `t` vom Anfang entfernt liegt. In unserem Beispiel ein <span style="color:red">roter</span> Punkt.
+- Diese Punkte zusammen bilden die Bézierkurve.
 
-The algorithm is recursive and can be generalized for any number of control points.
+Der Algorithmus arbeitet rekursiv und kann daher für eine beliebige Anzahl von Kontrollpunkten verallgemeinert werden.
 
-Given N of control points, we connect them to get initially N-1 segments.
+Haben wir `N` Kontrollpunkte vorliegen, verbinden wir diese und erhalten anfänglich `N - 1` Segmente.
 
-Then for each `t` from `0` to `1`:
-- Take a point on each of segment on the distance proportional to `t` and connect them -- there will be N-2 segments.
-- Take a point on each of these segments on the distance proportional to `t` and connect -- there will be N-3 segments, and so on...
-- Till we have one point. These points make the curve.
+Für jedes `t` von `0` bis `1`:
+- Suche auf jedem Segment einen Punkt der um den Anteil `t` vom Anfang entfernt liegt und verbinde diese; man erhält `N - 2` Segmente.
+- Wiederhole diesen Schritt, bis nur noch ein Punkt übrig bleibt. Diese Punkte bilden die Bézierkurve.
 
-Move examples of curves:
+Hier einige Beispiele:
 
 [iframe src="http://github.com/demo.svg?p=0,0,0,0.75,0.25,1,1,1&animate=1" height=370]
 
-With other points:
+Mit anderen Punkten:
 
 [iframe src="http://github.com/demo.svg?p=0,0,1,0.5,0,0.5,1,1&animate=1" height=370]
 
-Loop form:
+Eine Schleife:
 
 [iframe src="http://github.com/demo.svg?p=0,0,1,0.5,0,1,0.5,0&animate=1" height=370]
 
-Not smooth Bezier curve:
+Nicht stetige Bézierkurven:
 
 [iframe src="http://github.com/demo.svg?p=0,0,1,1,0,1,1,0&animate=1" height=370]
 
-As the algorithm is recursive, we can build Bezier curves of any order: using 5, 6 or more control points. But in practice they are less useful. Usually we take 2-3 points, and for complex lines glue several curves together. That's simpler to develop and calculate.
+Da der Algorithmus rekursiv arbeitet können wir Bézierkurven jeder beliebiger Ordnung, mit 5, 6 oder mehr Kontrollpunkten konstruieren. Von praktischer Bedeutung sind jedoch nur solche mit 2-4 Kontrollpunkten. Komplexere Figuren werden durch Verknüpfung mehrerer Kurven erstellt. Diese sind einfacher zu konstruieren und zu berechnen.
 
-```smart header="How to draw a curve *through* given points?"
-We use control points for a Bezier curve. As we can see, they are not on the curve. Or, to be precise, the first and the last ones do belong to curve, but others don't.
+```smart header="Wie zeichnet man eine Linie durch *gegebene* Punkte?"
+Bézierkurven werden durch ihre Kontrollpunkte definiert. Mit der Ausnahme von linearen Bézierkurven, liegen die Kontrollpunkte nicht nur auf der Kurve selbst.
 
-Sometimes we have another task: to draw a curve *through several points*, so that all of them are on a single smooth curve. That task is called  [interpolation](https://en.wikipedia.org/wiki/Interpolation), and here we don't cover it.
+Möchten wir also eine durchgehende Kurve durch *einige gegebene* Punkte zeichnen sind Bézierkurven nicht geeignet. Diese Aufgabe heißt [Interpolation](https://de.wikipedia.org/wiki/Interpolation_(Mathematik)), und wir gehen hier nicht näher darauf ein.
 
-There are mathematical formulas for such curves, for instance [Lagrange polynomial](https://en.wikipedia.org/wiki/Lagrange_polynomial).
-
-In computer graphics [spline interpolation](https://en.wikipedia.org/wiki/Spline_interpolation) is often used to build smooth curves that connect many points.
+Es gibt einige mathematische Verfahren zur [Polynominterpolation](https://de.wikipedia.org/wiki/Polynominterpolation) und in der Computergrafik verwendet man die [Spline-Interpolation](https://de.wikipedia.org/wiki/Spline-Interpolation) um viele Punkte durch eine optisch ansprechende Kurve zu verbinden.
 ```
 
-## Summary
-
-Bezier curves are defined by their control points.
+## Zusammenfassung
 
-We saw two definitions of Bezier curves:
+Bézierkurven werden durch ihre Kontrollpunkte definiert. Wir haben uns zwei Möglichkeiten angeschaut um sie zu konstruieren:
 
-1. Using a mathematical formulas.
-2. Using a drawing process: De Casteljau's algorithm
+1. Verwendung der Vektorgleichungen.
+2. Der intuitive Zeichnungsweg mit dem De-Casteljau-Algorithmus
 
-Good properties of Bezier curves:
+Vorteilhafte Eigenschaften von Bézierkurven:
 
-- We can draw smooth lines with a mouse by moving around control points.
-- Complex shapes can be made of several Bezier curves.
+- Wir können geschwungene Linien mit der Maus zeichnen, indem wir Kontrollpunkte bewegen.
+- Komplexe Formen können erstellt werden, indem man mehrere Bézierkurven miteinander verbindet.
 
-Usage:
+Verwendung:
 
-- In computer graphics, modeling, vector graphic editors. Fonts are described by Bezier curves.
-- In web development -- for graphics on Canvas and in the SVG format. By the way, "live" examples above are written in SVG. They are actually a single SVG document that is given different points as parameters. You can open it in a separate window and see the source: [demo.svg](demo.svg?p=0,0,1,0.5,0,0.5,1,1&animate=1).
-- In CSS animation to describe the path and speed of animation.
+- In der Computergrafik und Modellierung, in Vektorgrafikeditoren und für viele Schriftarten.
+- In der Webentwicklung für Grafiken zum Beispiel im SVG-Format. Übrigens sind die obigen Live-Beispiele in SVG geschrieben. Es ist immer die selbe Datei der verschiedene Startpunkte als Parameter übergeben werden. Sie können die Datei in einem separaten Fenster öffnen und den Quelltext betrachten [demo.svg](demo.svg?p=0,0,1,0.5,0,0.5,1,1&animate=1).
+- Bei CSS-Animationen um den Weg und die Geschwindigkeit der Animation zu kontrollieren.
diff --git a/README.md b/README.md
index 48b2c0c64f..fc068a1f9d 100755
--- a/README.md
+++ b/README.md
@@ -1,20 +1,13 @@
 
 # The JavaScript Tutorial
 
-This repository hosts the content of the Modern JavaScript Tutorial, published at [https://javascript.info](https://javascript.info).
+This repository hosts the German translation of the Modern JavaScript Tutorial. The original content is published at [https://javascript.info](https://javascript.info).
 
-## Translations
+## Translation
 
-Published:
-- Russian: [https://github.com/iliakan/javascript-tutorial-ru](https://github.com/iliakan/javascript-tutorial-ru).
+If you want to contribute to the translation fork this repository and go ahead. Submit your work via pull request.
 
-In progress:
-- Chinese: the ongoing translation at [https://github.com/iliakan/javascript-tutorial-cn](https://github.com/iliakan/javascript-tutorial-cn), go ahead and join if you know Chinese.
-- Spanish: https://github.com/lmauromb/javascript-tutorial-es
-
-If you'd like to translate it into your language then fork the English tutorial and go ahead. I can publish the translation with your credits on a domain like fr.javascript.info or you can do it on your domain.
-
-You can also send PR for this file to indicate that there's work in progress.
+The table of content below indicates already translated chapters via an active link to the translated file. Chapters without a link are stil in the original, english shape.
 
 Please note that the tutorial can run locally using <https://github.com/iliakan/javascript-tutorial-server/>.
 
@@ -28,8 +21,310 @@ The type of the material is defined by the file inside the folder:
 
   - `index.md` stands for a chapter
   - `article.md` stands for an article
-  - `task.md` stands for a task (solution must be provided in `solution.md` file aswell)
+  - `task.md` stands for a task (solution must be provided in `solution.md` file as well)
 
 Each of these files starts from the `# Main header`.
 
 Assets required for the material reside in the same folder.
+
+----
+
+## Übersetzungskonventionen
+
+Bei Übersetzungen von IT-Themen ins Deutsche begegnet man immer wieder Eigennamen, die keine gute Übersetzung finden und deshalb im Original stehen bleiben sollten. Für einige Wendungen gibt es aber durchaus treffende Deutsche Entsprechungen. Die folgende Tabelle sammelt einige Zweifelsfälle um eine einheitliche Verwendung über alle Kapitel im Tutorial zu gewährleisten.
+
+Wortgruppen die im Englischen getrennt geschrieben werden, wie "HTML file", sollten im Deutschen mit einem Bindestrich verbunden werden (HTML-Datei) um eine gute Lesbarkeit zu gewährleisten. 
+
+| English | Deutsch |
+|---------|---------|
+| browser | Browser |
+| code | Code |
+| command | Befehl |
+| cookie | Cookie |
+| engine | Engine |
+| header | Header |
+| low-level | systemnah |
+| page | Seite |
+| script | Script |
+| statement | Anweisung |
+| string | String |
+| tag | Tag |
+| tool | Werkzeug |
+
+----
+
+# The JavaScript language - TOC
+
+## An introduction
+
+[Eine Einführung in JavaScript](1-js/01-getting-started/1-intro/article.md)
+
+[Code-Editoren](1-js/01-getting-started/2-code-editors/article.md)
+
+[Entwicklerkonsole](1-js/01-getting-started/3-devtools/article.md)
+
+## JavaScript Fundamentals
+
+[Hello, world!](1-js/02-first-steps/01-hello-world/article.md)
+
+[Code-Struktur](1-js/02-first-steps/02-structure/article.md)
+
+[Moderne Spracheigenschaften: "use strict"](1-js/02-first-steps/03-strict-mode/article.md)
+
+[Variablen](1-js/02-first-steps/04-variables/article.md)
+
+[Datentypen](1-js/02-first-steps/05-types/article.md)
+
+Type Conversions
+
+Operators
+
+Comparisons
+
+Interaction: alert, prompt, confirm
+
+Conditional operators: if, '?'
+
+[Logische Operatoren](1-js/02-first-steps/11-logical-operators/article.md)
+
+Loops: while and for
+
+The "switch" statement
+
+Functions
+
+Function expressions and arrows
+
+JavaScript specials
+
+## Code quality
+
+[Debuggen in Chrome](1-js/03-code-quality/01-debugging-chrome/article.md)
+
+Coding style
+
+Comments
+
+Ninja code
+
+Automated testing with mocha
+
+Polyfills
+
+## Objects: the basics
+
+Objects
+
+Garbage collection
+
+Symbol type
+
+Object methods, "this"
+
+Object to primitive conversion
+
+Constructor, operator "new"
+
+## Data types
+
+Methods of primitives
+
+Numbers
+
+Strings
+
+Arrays
+
+Array methods
+
+Iterables
+
+Map, Set, WeakMap and WeakSet
+
+Object.keys, values, entries
+
+Destructuring assignment
+
+Date and time
+
+JSON methods, toJSON
+
+## Advanced working with functions
+
+Recursion and stack
+
+Rest parameters and spread operator
+
+Closure
+
+The old "var"
+
+Global object
+
+Function object, NFE
+
+The "new Function" syntax
+
+Scheduling: setTimeout and setInterval
+
+Decorators and forwarding, call/apply
+
+Function binding
+
+Currying and partials
+
+Arrow functions revisited
+
+## Objects, classes, inheritance
+
+Property flags and descriptors
+
+Property getters and setters
+
+Prototypal inheritance
+
+F.prototype
+
+Native prototypes
+
+Methods for prototypes
+
+Class patterns
+
+Classes
+
+Class inheritance, super
+
+Class checking: "instanceof"
+
+Mixins
+
+## Error handling
+
+Error handling, "try..catch"
+
+Custom errors, extending Error
+
+Browser: Document, Events, Interfaces
+
+## Document
+
+Browser environment, specs
+
+DOM tree
+
+Walking the DOM
+
+Searching: getElement* and querySelector*
+
+Node properties: type, tag and contents
+
+Attributes and properties
+
+Modifying the document
+
+Styles and classes
+
+Element size and scrolling
+
+Window sizes and scrolling
+
+Coordinates
+
+## Introduction into Events
+
+Introduction to browser events
+
+Bubbling and capturing
+
+Event delegation
+
+Browser default actions
+
+Dispatching custom events
+
+## Events in details
+
+Mouse events basics
+
+Moving: mouseover/out, mouseenter/leave
+
+Drag'n'Drop with mouse events
+
+Keyboard: keydown and keyup
+
+Scrolling
+
+Page lifecycle: DOMContentLoaded, load, beforeunload, unload
+
+Resource loading: onload and onerror
+
+## Forms, controls
+
+Form properties and methods
+
+Focusing: focus/blur
+
+Events: change, input, cut, copy, paste
+
+Form submission: event and method submit
+
+Additional articles
+
+## Animation
+
+[Bezierkurven](3-animation/1-bezier-curve/article.md)
+
+CSS-animations
+
+JavaScript animations
+
+## Frames and windows
+
+Popups and window methods
+
+Cross-window communication
+
+The clickjacking attack
+
+## Regular expressions
+
+Patterns and flags
+
+Methods of RegExp and String
+
+Character classes
+
+Escaping, special characters
+
+Sets and ranges [...]
+
+The unicode flag
+
+Quantifiers +, *, ? and {n}
+
+Greedy and lazy quantifiers
+
+Capturing groups
+
+Backreferences: \n and $n
+
+Alternation (OR) |
+
+String start ^ and finish $
+
+Multiline mode, flag "m"
+
+Lookahead (in progress)
+
+Infinite backtracking problem
+
+## Promises, async/await
+
+Introduction: callbacks
+
+Promise
+
+Promises chaining
+
+Promise API
diff --git a/TODO.md b/TODO.md
new file mode 100644
index 0000000000..f1a4e83ef5
--- /dev/null
+++ b/TODO.md
@@ -0,0 +1,3 @@
+im variablenkapitel darauf hinweisen, dass wir von jetzt an englische namen verwenden
+
+bezier3-draw1.png contains a white artefact
\ No newline at end of file