de: continued German translation until chapter 6.5.3 (#798)

* German translation until 6.5.3

* changed 'Sie' to 'Du'

* Apply suggestions from code review

Thanks @ronaldfw!

Co-authored-by: ronaldfw <wotzlaw@gmail.com>

---------

Co-authored-by: Martin Geisler <martin@geisler.net>
Co-authored-by: ronaldfw <wotzlaw@gmail.com>

po/de.po

@@ -1116,8 +1116,8 @@ msgid ""
 "  Book](https://doc.rust-lang.org/book/ch19-06-macros.html) and [Rust by\n"
 "  Example](https://doc.rust-lang.org/rust-by-example/macros.html) instead."
 msgstr ""
-"* Erfahren Sie, wie Sie Makros entwickeln, siehe [Kapitel 19.5 im Rust\n"
-"   Buch](https://doc.rust-lang.org/book/ch19-06-macros.html) und [Rust von\n"
+"* Um zu erfahren, wie Du Makros entwickelst, siehe [Kapitel 19.5 im Rust\n"
+"   Buch](https://doc.rust-lang.org/book/ch19-06-macros.html) und [Rust im\n"
 "   Beispiel](https://doc.rust-lang.org/rust-by-example/macros.html)."
 
 #: src/welcome.md:41
@@ -1491,7 +1491,7 @@ msgid ""
 "will need to install a number of packages as described on the [welcome\n"
 "page](../bare-metal.md)."
 msgstr ""
-"Für den Mikrocontroller-Teil müssen Sie das [BBC\n"
+"Für den Mikrocontroller-Teil solltest Du das [BBC\n"
 "micro:bit](https://microbit.org/) v2-Entwicklungsboard im Voraus kaufen. Alle\n"
 "müssen eine Reihe von Paketen installieren, wie auf der [Willkommens \n"
 "Seite](../bare-metal.md) beschrieben."
@@ -1514,8 +1514,8 @@ msgid ""
 "go. You can then copy/paste the examples into `src/main.rs` to experiment with\n"
 "them:"
 msgstr ""
-"Sie sollten eine neue Kiste (Crate) einrichten und die Abhängigkeiten (Dependencies) herunterladen "
-"und einsatzbereit machen. Anschließend können Sie die Beispiele kopieren und in „src/main.rs“ "
+"Du solltest eine neue Kiste (crate) einrichten und die Abhängigkeiten (dependencies) herunterladen "
+"und einsatzbereit machen. Anschließend kannst Du die Beispiele kopieren und in `src/main.rs` "
 "einfügen, um damit zu experimentieren:"
 
 #: src/running-the-course/course-structure.md:54
@@ -1715,12 +1715,12 @@ msgid ""
 "  library. You can have multiple versions of Rust installed at once and `rustup`\n"
 "  will let you switch between them as needed."
 msgstr ""
-"* `rustc`: der Rust-Compiler, der „.rs“-Dateien in Binärdateien und andere Zwischenformate "
+"* `rustc`: der Rust-Compiler, der `.rs`-Dateien in Binärdateien und andere Zwischenformate "
 "umwandelt\n"
 "\n"
 "* `cargo`: der Rust-Abhängigkeitsmanager (Dependency manager) und das Bauwerkzeug (Build-Tool). "
 "Cargo weiß, wie die Abhängigkeiten heruntergeladen werden müssen, die auf <https://crates.io> "
-"gehostet werden, und übergibt Sie sie an\n"
+"gehostet werden, und übergibt sie an\n"
 "   `rustc` beim Erstellen Ihres Projekts. Cargo verfügt außerdem über einen integrierten "
 "Testausführer, \n"
 "   der zum Ausführen von Unit-Tests verwendet wird."
@@ -1769,9 +1769,9 @@ msgid ""
 "      * It is also extensible with sub command plugins as well (such as [cargo clippy]).\n"
 "  * Read more from the [official Cargo Book]"
 msgstr ""
-"* Rust hat einen schnellen Veröffentlichungsplan. Alle sich Wochen wird eine neue Version "
-"veröffentlicht. Neue Versionen bleiben rückwärtskompatibel mit\n"
-"   Älteren Versionen und sie fügen neue Funktionen hinzu.\n"
+"* Rust hat einen schnellen Veröffentlichungsplan. Alle sechs Wochen wird eine neue Version "
+"veröffentlicht. Neue Versionen bleiben rückwärtskompatibel mit älteren Versionen und fügen neue "
+"Funktionen hinzu.\n"
 "\n"
 "* Es gibt drei Veröffentlichungskanäle: „stable“, „beta“ und „nightly“.\n"
 "\n"
@@ -1783,14 +1783,14 @@ msgstr ""
 "\n"
 "   * Editionen dürfen rückwärtsinkompatible Änderungen vornehmen.\n"
 "\n"
-"   * Um zu verhindern, dass Code nicht kaputt geht, sind Editionen optional: Sie wählen ihre "
-"Edition für ihre Kiste (Crate) in der Datei \"Cargo.toml\"\n"
+"   * Um zu verhindern, dass Code nicht kaputt geht, sind Editionen optional: Du wählst ihre "
+"Edition für deine Kiste (crate) in der Datei `Cargo.toml`\n"
 "\n"
 "   * Um eine Aufspaltung des Ökosystems zu vermeiden, können Rust-Compiler Code der für "
 "verschiedene Editionen geschrieben wurde vermischen.\n"
 "\n"
-"   * Erwähnen Sie, dass es ziemlich selten vorkommt, dass der Compiler jemals direkt und nicht "
-"über `cargo` verwendet wird (die meisten Benutzer tun dies nie).\n"
+"   * Erwähne, dass es ziemlich selten vorkommt, dass der Compiler jemals direkt und nicht über "
+"`cargo` verwendet wird (die meisten Benutzer tun dies nie).\n"
 "\n"
 "   * Es könnte erwähnenswert sein, dass Cargo selbst ein äußerst leistungsstarkes und umfassendes "
 "Tool ist. Es verfügt über viele erweiterte Funktionen, einschließlich, aber nicht beschränkt auf:\n"
@@ -1800,7 +1800,7 @@ msgstr ""
 "       * [Build-Skripting]\n"
 "       * [globale Installation]\n"
 "       * Es ist auch mit Unterbefehls-Plugins erweiterbar (z. B. [cargo clippy]).\n"
-"   * Lesen Sie mehr aus dem [offiziellen Cargo Buch]"
+"   * Lese mehr aus dem [offiziellen Cargo Buch]"
 
 #: src/cargo/code-samples.md:1
 msgid "# Code Samples in This Training"
@@ -1822,10 +1822,10 @@ msgid ""
 "exercises. On the last day, we will do a larger exercise which shows you how to\n"
 "work with dependencies and for that you need Cargo."
 msgstr ""
-"Die Installation von Cargo wird dennoch empfohlen: Es wird Ihnen die Bearbeitung der Übungen "
+"Die Installation von Cargo wird dennoch empfohlen: Es wird Dir die Bearbeitung der Übungen "
 "erleichtern.\n"
-"Am letzten Tag werden wir eine größere Übung machen, die Ihnen zeigt, wie\n"
-"Sie mit Abhängigkeiten (Dependencies) arbeiten und dafür benötigen Sie Cargo."
+"Am letzten Tag werden wir eine größere Übung machen, die zeigt, wie\n"
+"Du mit Abhängigkeiten (dependencies) arbeitest und dafür benötigst Du Cargo."
 
 #: src/cargo/code-samples.md:11
 msgid "The code blocks in this course are fully interactive:"
@@ -1845,7 +1845,7 @@ msgid ""
 "You can use <kbd>Ctrl + Enter</kbd> to execute the code when focus is in the\n"
 "text box."
 msgstr ""
-"Sie können <kbd>Strg + Eingabe</kbd> verwenden, um den Code auszuführen, wenn der Fokus auf dem "
+"Du kannst <kbd>Strg + Eingabe</kbd> verwenden, um den Code auszuführen, wenn der Fokus auf dem "
 "Textfeld ist."
 
 #: src/cargo/code-samples.md:24
@@ -1867,11 +1867,11 @@ msgid ""
 "  Playground."
 msgstr ""
 "* Die eingebetteten Testumgebungen (embedded Playgrounds) können keine Unit-Tests durchführen. "
-"Kopieren Sie die Datei und fügen Sie \n"
+"Kopiere die Datei und füge \n"
 "   den Code in der echten Testumgebung ein, um Unit-Tests zu demonstrieren.\n"
 "\n"
-"* Die eingebetteten Testumgebungen verlieren ihren Zustand, sobald Sie von der Seite weg "
-"navigieren!\n"
+"* Die eingebetteten Testumgebungen verlieren ihren Zustand, sobald Du von der Seite weg "
+"navigierst!\n"
 "   Aus diesem Grund sollten die Schüler die Übungen mit einer lokalen Rust-Installation oder in "
 "der\n"
 "   lokalen Testumgebung lösen."
@@ -1887,11 +1887,11 @@ msgid ""
 "Book][1]. This should give you a working `rustc` and `cargo`. At the time of\n"
 "writing, the latest stable Rust release has these version numbers:"
 msgstr ""
-"Wenn Sie mit dem Code auf Ihrem eigenen System experimentieren möchten, sollten Sie\n"
-"zuerst Rust zu installieren. Befolgen Sie dazu die [Anweisungen in dem Rust\n"
-"Buch 1]. Dies sollte Ihnen ein funktionierendes `rustc` und `cargo` geben. Zum "
+"Wenn Du mit dem Code auf Deinem eigenen System experimentieren möchten, solltest Du\n"
+"zuerst Rust installieren. Befolge dazu die [Anweisungen in dem Rust\n"
+"Buch 1]. Dies sollte ein funktionierendes `rustc` und `cargo` hervorbringen. Zum "
 "Verfassungszeitpunkt\n"
-"hat die neueste stabile Rust-Version diese Versionsnummer:"
+"hat die neueste stabile Rust-Version folgende Versionsnummer:"
 
 #: src/cargo/running-locally.md:8
 msgid ""
@@ -1908,8 +1908,8 @@ msgid ""
 "With this in place, follow these steps to build a Rust binary from one\n"
 "of the examples in this training:"
 msgstr ""
-"Wenn dies vorhanden ist, befolgen Sie diese Schritte, um eine Rust-Binärdatei aus einem Beispiel "
-"zu erstellen:"
+"Wenn dies vorhanden ist, befolge die folgenden Schritte, um eine Rust-Binärdatei aus einem "
+"Beispiel zu erstellen:"
 
 #: src/cargo/running-locally.md:18
 msgid ""
@@ -1961,6 +1961,46 @@ msgid ""
 "   run `cargo` commands, it will automatically download and compile missing\n"
 "   dependencies for you."
 msgstr ""
+"1. Klicke bei dem Beispiel, dass Du kopieren möchtest, auf die Schaltfläche „In die Zwischenablage "
+"kopieren“.\n"
+"2. Verwende `cargo new exercise`, um ein neues `exercise/`-Verzeichnis für Deinen Code zu "
+"erstellen:\n"
+"    ```shell\n"
+"    $ cargo new exercise\n"
+"         Created binary (application) `exercise` package\n"
+"    ```\n"
+"3. Navigiere zu `exercise/` und verwende `cargo run, um eine Binärdatei zu erstellen und "
+"auszuführen:\n"
+"    ```shell\n"
+"    $ cd exercise\n"
+"    $ cargo run\n"
+"       Compiling exercise v0.1.0 (/home/mgeisler/tmp/exercise)\n"
+"        Finished dev [unoptimized + debuginfo] target(s) in 0.75s\n"
+"         Running `target/debug/exercise`\n"
+"    Hello, world!\n"
+"    ```\n"
+"4. Ersetze den Platzhalter-Code in `src/main.rs` durch eigenen Code. Verwende beispielsweise das "
+"Beispiel auf der vorherigen Seite und lasse `src/main.rs` so aussehen:\n"
+"    ```rust\n"
+"    fn main() {\n"
+"        println!(\"Edit me!\");\n"
+"    }\n"
+"    ```\n"
+"5. Verwende `cargo run`, um die neue Binärdatei zu erstellen und auszuführen:\n"
+"    ```shell\n"
+"    $ cargo run\n"
+"       Compiling exercise v0.1.0 (/home/mgeisler/tmp/exercise)\n"
+"        Finished dev [unoptimized + debuginfo] target(s) in 0.24s\n"
+"         Running `target/debug/exercise`\n"
+"    Edit me!\n"
+"    ```\n"
+"6. Verwende `cargo check`, um Dein Projekt schnell auf Fehler zu überprüfen, und verwende `cargo "
+"build`, um es zu kompilieren, ohne es auszuführen. Du findest die Ausgabe in `target/debug/` für "
+"einen normalen Debug-Build. Verwende `cargo build --release`, um einen optimierten Release-Build "
+"in `target/release/` zu erstellen.\n"
+"7. Du kannst Abhängigkeiten (dependencies) zu Deinem Projekt hinzufügen, indem Du `Cargo.toml` "
+"bearbeitest. Wenn Du `cargo`-Befehle ausführst, werden fehlende Abhängigkeiten automatisch "
+"heruntergeladen und für Dich kompiliert."
 
 #: src/cargo/running-locally.md:70
 msgid ""
@@ -1968,9 +2008,9 @@ msgid ""
 "local editor. It will make their life easier since they will have a\n"
 "normal development environment."
 msgstr ""
-"Versuchen Sie, die Kursteilnehmer zu ermutigen, Cargo zu installieren und einen lokalen Texteditor "
-"zu verwenden\n"
-"Es wird ihr Leben einfacher machen, wenn alle eine lokale Entwicklungsumgebung haben."
+"Versuche, die Kursteilnehmer zu ermutigen, Cargo zu installieren und einen lokalen Texteditor zu "
+"verwenden\n"
+"Es wird Dein Leben einfacher machen, wenn alle eine lokale Entwicklungsumgebung haben."
 
 #: src/welcome-day-1.md:1
 msgid "# Welcome to Day 1"
@@ -2004,7 +2044,7 @@ msgstr ""
 
 #: src/welcome-day-1.md:16
 msgid "Please remind the students that:"
-msgstr "Bitte erinnern Sie die Schüler daran:"
+msgstr "Bitte erinnere die Kursteilnehmer daran:"
 
 #: src/welcome-day-1.md:18
 msgid ""
@@ -2040,14 +2080,14 @@ msgstr ""
 "Die Idee für den ersten Tag ist, Rust _gerade genug_ zu zeigen, um über den berühmten "
 "Ausleihenprüfer (borrow checker) sprechen zu können.\n"
 "Die Art und Weise, wie Rust mit Speicher umgeht, ist ein wichtiges Merkmal\n"
-"und das sollten Sie den Schülern direkt zeigen."
+"und das solltest Du den Kursteilnehmern direkt zeigen."
 
 #: src/welcome-day-1.md:33
 msgid ""
 "If you're teaching this in a classroom, this is a good place to go over the\n"
 "schedule. We suggest splitting the day into two parts (following the slides):"
 msgstr ""
-"Wenn Sie dies in einem Klassenzimmer unterrichten, ist dies ein guter Ort, um über den Zeitplan zu "
+"Wenn Du in einem Klassenzimmer unterrichtest, ist dies ein guter Ort, um über den Zeitplan zu "
 "gehen.\n"
 "Wir empfehlen, den Tag in zwei Teile aufzuteilen (nach den Folien):"
 
@@ -2064,7 +2104,7 @@ msgid ""
 "You can of course adjust this as necessary. Please make sure to include breaks,\n"
 "we recommend a break every hour!"
 msgstr ""
-"Dies können Sie natürlich bei Bedarf anpassen. Bitte achten Sie darauf, Pausen einzuplanen,\n"
+"Dies kannst Du natürlich bei Bedarf anpassen. Bitte achte darauf, Pausen einzuplanen.\n"
 "Wir empfehlen jede Stunde eine Pause!"
 
 #: src/welcome-day-1/what-is-rust.md:1
@@ -2130,7 +2170,7 @@ msgid ""
 "Let us jump into the simplest possible Rust program, a classic Hello World\n"
 "program:"
 msgstr ""
-"Lassen Sie uns in das einfachste Rust-Programm einsteigen, ein klassisches Hallo Welt\n"
+"Lasst uns in das einfachste Rust-Programm einsteigen, ein klassisches Hallo Welt\n"
 "Programm:"
 
 #: src/hello-world.md:6
@@ -2144,7 +2184,7 @@ msgstr ""
 
 #: src/hello-world.md:12
 msgid "What you see:"
-msgstr "Sie sehen:"
+msgstr "Du siehst:"
 
 #: src/hello-world.md:14
 msgid ""
@@ -2190,8 +2230,8 @@ msgstr ""
 "\n"
 "* Rust ist modern und unterstützt Dinge wie Unicode vollständig.\n"
 "\n"
-"* Rust verwendet Makros für Situationen, in denen Sie eine variable Anzahl von Argumenten haben "
-"möchte\n"
+"* Rust verwendet Makros für Situationen, in denen Du eine variable Anzahl von Argumenten haben "
+"möchtest\n"
 "   (keine [Funktionüberladung](basic-syntax/functions-interlude.md)).\n"
 "\n"
 "* Makros sind „hygienisch“, was bedeutet, dass sie nicht versehentlich Identifikatoren in ihrem "
@@ -2233,8 +2273,7 @@ msgid ""
 "inputs."
 msgstr ""
 "Der Code implementiert die Collatz-Vermutung: Es wird angenommen, dass die Schleife immer enden "
-"wird, allerdings ist das noch nicht bewiesen. Ändern Sie den Code und spielen Sie mit "
-"verschiedenen Eingaben."
+"wird, allerdings ist das noch nicht bewiesen. Ändere den Code und spiele mit verschiedenen Eingaben."
 
 #: src/hello-world/small-example.md:29
 msgid ""
@@ -2253,21 +2292,21 @@ msgid ""
 "  which has the rules of the formatting mini-language. It's important that the\n"
 "  students become familiar with searching in the standard library."
 msgstr ""
-"* Erklären Sie, dass alle Variablen statisch typisiert sind. Versuchen Sie, `i32` zu entfernen um "
-"Typinferenz (type inference) auszulösen. Versuchen Sie es stattdessen mit `i8` und lösen Sie einen "
+"* Erkläre, dass alle Variablen statisch typisiert sind. Versuche, `i32` zu entfernen um "
+"Typinferenz (type inference) auszulösen. Versuche es stattdessen mit `i8` und löse dadurch einen "
 "Ganzzahlüberlauf zur Laufzeit aus.\n"
 "\n"
-"* Ändern Sie `let mut x` in `let x`, besprechen Sie den Compilerfehler.\n"
+"* Ändere `let mut x` in `let x`, und bespreche den Compilerfehler.\n"
 "\n"
-"* Zeigen Sie, wie `print!` einen Kompilierungsfehler ausgibt, wenn die Argumente nicht mit dem "
-"Format-String übereinstimmen.\n"
+"* Zeige, wie `print!` einen Kompilierungsfehler ausgibt, wenn die Argumente nicht mit dem Format-"
+"String übereinstimmen.\n"
 "\n"
-"* Zeigen Sie, wie Sie `{}` als Platzhalter verwenden müssen, wenn Sie einen Ausdruck (Expression) "
-"drucken möchten,\n"
+"* Zeige, wie Du `{}` als Platzhalter verwenden musst, wenn Du einen Ausdruck (Expression) drucken "
+"möchtest,\n"
 "   der komplexer als nur eine einzelne Variable ist.\n"
 "\n"
-"* Zeigen Sie den Schülern die Standardbibliothek (standard library) und zeigen Sie ihnen, wie sie "
-"nach `std::fmt` suchen\n"
+"* Zeige den Kursteilnehmern die Standardbibliothek (standard library) und zeige ihnen, wie sie nach `std::"
+"fmt` suchen\n"
 "   welches die Regeln der Formatierungs-Minisprache enthält. Es ist wichtig, dass die\n"
 "   Kursteilnehmer mit der Suche in der Standardbibliothek vertraut gemacht werden."
 
@@ -2294,8 +2333,8 @@ msgid ""
 "Make sure to ask the class which languages they have experience with. Depending\n"
 "on the answer you can highlight different features of Rust:"
 msgstr ""
-"Fragen Sie den Kurs unbedingt, mit welchen Programmiersprachen sie Erfahrung haben. Abhängig\n"
-"von der Antwort können Sie verschiedene Funktionen von Rust hervorheben:"
+"Frage den Kurs unbedingt, mit welchen Programmiersprachen sie Erfahrung haben. Abhängig\n"
+"von der Antwort kannst Du verschiedene Funktionen von Rust hervorheben:"
 
 #: src/why-rust.md:14
 msgid ""
@@ -2311,18 +2350,18 @@ msgid ""
 msgstr ""
 "* Erfahrung mit C oder C++: Rust eliminiert eine ganze Klasse von _Laufzeitfehlern (runtime "
 "Errors)_\n"
-"   über den Ausleihenprüfer (borrow checker). Sie erhalten ähnliche Leistung wie in C und C++, "
-"aber haben\n"
-"   keine Probleme mit der Speicherunsicherheit. Darüber hinaus erhalten Sie eine moderne Sprache "
+"   über den Ausleihenprüfer (borrow checker). Du erhältst eine ähnliche Leistung wie in C und C++, "
+"aber hast\n"
+"   keine Probleme mit der Speicherunsicherheit. Darüber hinaus erhältst Du eine moderne Sprache "
 "mit\n"
 "   Konstrukten wie Mustervergleich (Pattern matching) und integriertes Abhängigkeitsmanagement "
 "(dependency management).\n"
 "\n"
-"* Erfahrung mit Java, Go, Python, JavaScript...: Sie erhalten die gleiche Speichersicherheit\n"
+"* Erfahrung mit Java, Go, Python, JavaScript...: Du erhältst die gleiche Speichersicherheit\n"
 "   wie in diesen Sprachen, dazu ein ähnlich hohes Sprachgefühl. Zusätzlich\n"
-"   erhalten Sie eine schnelle und vorhersehbare Leistung wie in C und C++ (keine "
+"   erhältst Du eine schnelle und vorhersehbare Leistung wie in C und C++ (keine "
 "Speicherbereinigung (garbage collector))\n"
-"   sowie Zugriff auf Low-Level-Hardware (falls Sie diese benötigen)."
+"   sowie Zugriff auf Low-Level-Hardware (falls benötigt)."
 
 #: src/why-rust/compile-time.md:1
 msgid "# Compile Time Guarantees"
@@ -2369,11 +2408,11 @@ msgid ""
 "* In fact, some will consider infinitely populating a collection a memory\n"
 "  leak and Rust does not protect from those."
 msgstr ""
-"* Sie können [`Box::leak`] verwenden, um einen Zeiger zu verlieren. Eine Nutzung dieser könnte\n"
+"* Du kannst [`Box::leak`] verwenden, um einen Zeiger zu verlieren. Eine Nutzung dieser könnte\n"
 "  sein, um zur Laufzeit initialisierte statische Variablen in Laufzeitgröße zu erhalten\n"
-"* Sie können [`std::mem::forget`] verwenden, um den Compiler einen Wert \"vergessen\" zu lassen\n"
+"* Du kannst [`std::mem::forget`] verwenden, um den Compiler einen Wert \"vergessen\" zu lassen\n"
 "  (was bedeutet, dass der Destruktor niemals ausgeführt wird).\n"
-"* Sie können auch versehentlich einen [Referenzzyklus] mit `Rc` oder `Arc` erstellen\n"
+"* Du kannst auch versehentlich einen [Referenzzyklus] mit `Rc` oder `Arc` erstellen\n"
 "* In der Tat werden einige in Betracht ziehen, eine Sammlung (Collection) unendlich  zu befüllen\n"
 "  Rust schützt nicht vor sowelchen Speicherlecks (memory leaks)."
 
@@ -2416,12 +2455,12 @@ msgstr ""
 "* Ganzzahlüberlauf (integer overflow) wird über ein Flag zur Kompilierzeit definiert. Die Optionen "
 "sind\n"
 "  entweder ein kontrollierter Abbruch des Programms (panic) oder eine Wrap-Around\n"
-"  Semantik. Standardmäßig erhalten Sie einen Abbruch (panic) im Debug-Modus (`cargo build`)\n"
+"  Semantik. Standardmäßig erhältst Du einen Abbruch (panic) im Debug-Modus (`cargo build`)\n"
 "  und ein Wrap-Around im Release-Modus (`cargo build --release`).\n"
 "\n"
 "* Die Grenzüberprüfung (bounds checking) kann nicht mit einem Compiler-Flag deaktiviert werden. Es "
 "kann auch\n"
-"   nicht direkt mit dem Schlüsselwort „unsafe“ deaktiviert werden. Jedoch können Sie Funktionen "
+"   nicht direkt mit dem Schlüsselwort „unsafe“ deaktiviert werden. Jedoch kannst Du Funktionen "
 "wie\n"
 "   `slice::get_unchecked` mit `unsafe` aufrufen\n"
 "   was keine Grenzenprüfung durchführt."
@@ -2506,8 +2545,8 @@ msgid ""
 "* [rust-analyzer] is a well supported LSP implementation used in major\n"
 "  IDEs and text editors."
 msgstr ""
-"* Kostenfreie Abstraktionen, ähnlich wie bei C++, bedeuten, dass Sie für Programmierkonstrukte auf "
-"höherer Ebene nicht mit Speicher oder CPU „bezahlen“ müssen. Beispielsweise sollte das Schreiben "
+"* Kostenfreie Abstraktionen, ähnlich wie bei C++, bedeuten, dass Du für Programmierkonstrukte auf "
+"höherer Ebene nicht mit Speicher oder CPU „bezahlen“ musst. Beispielsweise sollte das Schreiben "
 "einer Schleife mit `for` ungefähr zu denselben Low-Level-Anweisungen führen wie die Verwendung des "
 "Konstrukts `.iter().fold()`.\n"
 "\n"
@@ -2515,10 +2554,10 @@ msgstr ""
 "„Summentypen“, die es dem Typsystem ermöglichen, Dinge wie `Option<T>` und `Result<T, E>` "
 "auszudrücken.\n"
 "\n"
-"* Erinnern Sie die Teilnehmer daran, die Fehler zu lesen – viele Entwickler haben sich daran "
-"gewöhnt, lange Compiler-Ausgaben zu ignorieren. Der Rust-Compiler ist deutlich gesprächiger als "
-"andere Compiler. Es liefert Ihnen oft _umsetzbares_ Feedback, das Sie in Ihren Code einfach "
-"übernehmen können.\n"
+"* Erinnere die Teilnehmer daran, die Fehler zu lesen – viele Entwickler haben sich daran gewöhnt, "
+"lange Compiler-Ausgaben zu ignorieren. Der Rust-Compiler ist deutlich gesprächiger als andere "
+"Compiler. Es liefert Ihnen oft _umsetzbares_ Feedback, das Sie in Ihren Code einfach übernehmen "
+"können.\n"
 "\n"
 "* Die Rust-Standardbibliothek ist im Vergleich zu Sprachen wie Java, Python und Go klein. Rust "
 "bringt einige Dinge nicht mit, die Sie als normal betrachten könnten:\n"
@@ -2537,8 +2576,8 @@ msgstr ""
 "Standardbibliothek kleiner sein kann.\n"
 "\n"
 "   Das Auffinden guter Kisten von Drittanbietern kann ein Problem sein. Websites wie\n"
-"   <https://lib.rs/> hilft Ihnen dabei, indem es Ihnen ermöglicht, Gesundheitsmetriken für Kisten "
-"zu vergleichen, um eine gute und vertrauenswürdige zu finden.\n"
+"   <https://lib.rs/> hilft Dir dabei, indem es Dir ermöglicht, Gesundheitsmetriken für Kisten zu "
+"vergleichen, um eine gute und vertrauenswürdige zu finden.\n"
 "  \n"
 "* [rust-analyzer] ist eine gut unterstützte LSP-Implementierung, die in wichtigen IDEs und "
 "Texteditoren verwendet wird."
@@ -2642,9 +2681,9 @@ msgid ""
 "  }\n"
 "  ```"
 msgstr ""
-"- Mit puren Zeichenketten (raw strings) können Sie einen `&str`-Wert mit deaktivierten Escape-"
-"Zeichen erstellen: `r\"\\n\" == \"\\\\\\\\n\"`. Sie können doppelte Anführungszeichen einbetten, "
-"indem Sie auf beiden Seiten der Anführungszeichen die gleiche Anzahl von `#` verwenden:\n"
+"- Mit puren Zeichenketten (raw strings) kannst Du einen `&str`-Wert mit deaktivierten Escape-"
+"Zeichen erstellen: `r\"\\n\" == \"\\\\\\\\n\"`. Du kannst doppelte Anführungszeichen einbetten, "
+"indem Du auf beiden Seiten der Anführungszeichen die gleiche Anzahl von `#` verwendest:\n"
 "\n"
 "  ```rust,editable\n"
 "  fn main() {\n"
@@ -2653,7 +2692,7 @@ msgstr ""
 "  }\n"
 "  ```\n"
 "\n"
-"- Mit Byte-Strings können Sie direkt einen „&[u8]“-Wert erstellen:\n"
+"- Mit Byte-Strings kannst Du direkt einen „&[u8]“-Wert erstellen:\n"
 "\n"
 "  ```rust,editable\n"
 "  fn main() {\n"
@@ -2770,8 +2809,8 @@ msgstr ""
 "als auch der einzige gültige Wert dieses Typs – das heißt, sowohl der Typ als auch sein Wert "
 "werden als `()` ausgedrückt. Es wird beispielsweise verwendet, um anzuzeigen, dass eine Funktion "
 "oder ein Ausdruck keinen Rückgabewert hat, wie wir auf einer zukünftigen Folie sehen werden.\n"
-"     * Sie können es sich als `void` vorstellen, das Ihnen aus anderen Programmiersprachen bekannt "
-"sein kann."
+"     * Du kannst es Dir als `void` vorstellen, das Dir aus anderen Programmiersprachen bekannt "
+"sein könnte."
 
 #: src/basic-syntax/references.md:1
 msgid "# References"
@@ -2806,7 +2845,7 @@ msgid ""
 msgstr ""
 "* Wir müssen `ref_x` beim Zuweisen dereferenzieren, ähnlich wie bei C und C++-Zeigern.\n"
 "* Rust wird in einigen Fällen automatisch dereferenzieren, insbesondere beim Aufrufen von Methoden "
-"(probieren Sie `ref_x.count_ones()`).\n"
+"(probiere `ref_x.count_ones()`).\n"
 "* Referenzen, die als `mut` deklariert sind, können über ihre Lebensdauer an unterschiedliche "
 "Werte gebunden werden."
 
@@ -2816,7 +2855,7 @@ msgid ""
 "  &mut i32`. The first one represents a mutable reference which can be bound to\n"
 "  different values, while the second represents a reference to a mutable value."
 msgstr ""
-"* Beachten Sie unbedingt den Unterschied zwischen `let mut ref_x: &i32` und `let ref_x:\n"
+"* Beachte unbedingt den Unterschied zwischen `let mut ref_x: &i32` und `let ref_x:\n"
 "  &mut i32`. Das erste stellt eine veränderliche Referenz (mutable reference) dar, an die "
 "unterschiedliche Werte gebunden werden können,\n"
 "  während das zweite Beispiel einen Verweis auf einen veränderlichen Wert darstellt."
@@ -2882,7 +2921,7 @@ msgid ""
 "* Question: What happens if you modify `a[3]`?"
 msgstr ""
 "* Anteilstypen (slices) borgen (borrow) Daten vom Sliced-Typ.\n"
-"* Frage: Was passiert, wenn Sie `a[3]` ändern?"
+"* Frage: Was passiert, wenn Du `a[3]` änderst?"
 
 #: src/basic-syntax/slices.md:20
 msgid ""
@@ -2918,8 +2957,8 @@ msgstr ""
 "* Um einfach einen Anteilstyp des gesamten Arrays zu erstellen, können wir daher „&a[..]“ "
 "verwenden.\n"
 "\n"
-"* `s` ist ein Verweis (reference) auf einen Teil von `i32`. Beachten Sie, dass der Typ `s` "
-"(`&[i32]`) die Array-Länge nicht mehr erwähnt. Dadurch können wir Berechnungen für Anteilstypen "
+"* `s` ist ein Verweis (reference) auf einen Teil von `i32`. Beachte, dass der Typ `s` (`&[i32]`) "
+"die Array-Länge nicht mehr erwähnt. Dadurch können wir Berechnungen für Anteilstypen "
 "unterschiedlicher Größe durchführen.\n"
 " \n"
 "* Anteilstypen (slices) leihen (borrow) sich immer etwas von einem anderen Objekt aus. In diesem "
@@ -2927,19 +2966,18 @@ msgstr ""
 "Anteilstyp.\n"
 "    \n"
 "* Die Frage nach einer Werteänderung durch `a[3]` kann eine interessante Diskussion auslösen, aber "
-"die Antwort lautet: aus Gründen der Speichersicherheit können Sie dies nicht über `a` tun, nachdem "
-"Sie ein Slice erstellt haben. Allerdings können Sie die Werte sowohl von `a` als auch von `s` "
-"sicher lesen.\n"
-"   Weitere Einzelheiten werden im Abschnitt „Ausleihenprüfer“ (borrow checken) erläutert."
+"die Antwort lautet: aus Gründen der Speichersicherheit kannst Du dies nicht über `a` tun, nachdem "
+"Du ein Slice erstellt hast. Allerdings kannst Du die Werte sowohl von `a` als auch von `s` sicher "
+"lesen.\n"
+"   Weitere Einzelheiten werden im Abschnitt „Ausleihenprüfer“ (borrow checker) erläutert."
 
 #: src/basic-syntax/string-slices.md:1
 msgid "# `String` vs `str`"
 msgstr "# `String` vs `str`"
 
 #: src/basic-syntax/string-slices.md:3
-#, fuzzy
 msgid "We can now understand the two string types in Rust:"
-msgstr "Wir können jetzt die beiden String-Typen in Rust verstehen:"
+msgstr "Kommen wir jetzt zu den beiden String-Typen in Rust:"
 
 #: src/basic-syntax/string-slices.md:5
 msgid ""
@@ -2960,21 +2998,18 @@ msgid ""
 msgstr ""
 
 #: src/basic-syntax/string-slices.md:20
-#, fuzzy
 msgid "Rust terminology:"
-msgstr "Rost-Terminologie:"
+msgstr "Rust-Terminologie:"
 
 #: src/basic-syntax/string-slices.md:22
-#, fuzzy
 msgid ""
 "* `&str` an immutable reference to a string slice.\n"
 "* `String` a mutable string buffer."
 msgstr ""
-"* `&str` eine unveränderliche Referenz auf einen String-Slice.\n"
-"* `String` ein veränderlicher String-Puffer."
+"* `&str` eine unveränderliche (immutable) Referenz auf einen String-Slice.\n"
+"* `String` ein veränderlicher String-Puffer (mutable string buffer)."
 
 #: src/basic-syntax/string-slices.md:27
-#, fuzzy
 msgid ""
 "* `&str` introduces a string slice, which is an immutable reference to UTF-8 encoded string data \n"
 "  stored in a block of memory. String literals (`”Hello”`), are stored in the program’s binary.\n"
@@ -2997,33 +3032,38 @@ msgid ""
 "optimization).\n"
 "    "
 msgstr ""
-"* Das `format!()`-Makro ist eine bequeme Möglichkeit, einen eigenen String aus dynamischen Werten "
-"zu generieren. Es\n"
-"  akzeptiert die gleiche Formatspezifikation wie `println!()`.\n"
+"* `&str` führt einen String-Slice ein, der eine unveränderliche Referenz auf UTF-8-codierte String-"
+"Daten ist, die in einem Speicherblock gespeichert sind. String-Literale (`\"Hallo\"`) werden in "
+"der Binärdatei des Programms gespeichert.\n"
+"\n"
+"* Der `String`-Typ von Rust ist eine Verpackung (wrapper) um einen Byte-Vektor. Wie bei einem "
+"`Vec<T>` ist es im Besitz.\n"
 "    \n"
-"* Sie können `&str`-Slices von `String` über `&` und optional Bereichsauswahl ausleihen.\n"
+"* Wie bei vielen anderen Typen erstellt `String::from()` einen String aus einem String-Literal; "
+"`String::new()` erstellt einen neuen leeren String, zu dem String-Daten mit den Methoden `push()` "
+"und `push_str()` hinzugefügt werden können.\n"
+"\n"
+"* Das Makro `format!()` ist eine praktische Möglichkeit, einen aneigenbaren (owned) String aus "
+"dynamischen Werten zu generieren. Es akzeptiert die gleiche Formatspezifikation wie `println!()`.\n"
 "    \n"
-"* Für C++-Programmierer: Stellen Sie sich `&str` als `const char*` von C++ vor, aber dasjenige, "
-"das immer zeigt\n"
-"  zu einer gültigen Zeichenfolge im Speicher. Rust `String` ist ein grobes Äquivalent zu `std::"
-"string` aus C++\n"
-"  (Hauptunterschied: Es kann nur UTF-8-codierte Bytes enthalten und verwendet niemals eine Small-"
-"String-Optimierung).\n"
+"* Du kannst `&str`-Slices von `String` über `&` und optional eine Bereichsauswahl (range "
+"selection) ausleihen.\n"
 "    \n"
-"</details>"
+"* Für C++-Programmierer: Stell Dir `&str` als `const char*` aus C++ vor, der immer auf eine "
+"gültige Zeichenfolge im Speicher zeigt. Rust `String` ist ein grobes Äquivalent von `std::string` "
+"aus C++ (Hauptunterschied: Es kann nur UTF-8-codierte Bytes enthalten und wird niemals eine "
+"Optimierung für kleine Zeichenfolgen verwenden). "
 
 #: src/basic-syntax/functions.md:1
-#, fuzzy
 msgid "# Functions"
 msgstr "# Funktionen"
 
 #: src/basic-syntax/functions.md:3
-#, fuzzy
 msgid ""
 "A Rust version of the famous [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) interview "
 "question:"
 msgstr ""
-"Eine Rust-Version der berühmten [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) Interviewfrage:"
+"Eine Rust-Version der berühmten [FizzBuzz](https://de.wikipedia.org/wiki/Fizz_buzz) Interviewfrage:"
 
 #: src/basic-syntax/functions.md:5
 msgid ""
@@ -3069,15 +3109,24 @@ msgid ""
 "* The range expression in the `for` loop in `print_fizzbuzz_to()` contains `=n`, which causes it "
 "to include the upper bound."
 msgstr ""
+"* Wir beziehen uns in `main` auf eine unten beschriebene Funktion. Es sind weder Forward-"
+"Deklarationen noch Header erforderlich.\n"
+"* Auf Deklarationsparameter folgt ein Typ (das Gegenteil einiger Programmiersprachen) und dann ein "
+"Rückgabetyp.\n"
+"* Der letzte Ausdruck in einem Funktionskörper (oder einem beliebigen Block) wird zum "
+"Rückgabewert. Lasse einfach das `;` am Ende des Ausdrucks weg.\n"
+"* Einige Funktionen haben keinen Rückgabewert und geben den `Einheitentyp` (Unittyp) `()` zurück. "
+"Der Compiler schließt daraus, wenn der Rückgabetyp `->()` weggelassen wird.\n"
+"* Der Bereichsausdruck (range expression) in der `for`-Schleife in `print_fizzbuzz_to()` enthält "
+"`=n`, was dazu führt, dass die Obergrenze einschlossen wird."
 
 #: src/basic-syntax/rustdoc.md:1
-#, fuzzy
 msgid "# Rustdoc"
-msgstr "# Warum Rost?"
+msgstr "# Rustdoc"
 
 #: src/basic-syntax/rustdoc.md:3
 msgid "All language items in Rust can be documented using special `///` syntax."
-msgstr ""
+msgstr "Alle Sprachelemente in Rust können mit der speziellen `///`-Syntax dokumentiert werden."
 
 #: src/basic-syntax/rustdoc.md:5
 msgid ""
@@ -3101,6 +3150,10 @@ msgid ""
 "[rustdoc](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html) tool. It is\n"
 "idiomatic to document all public items in an API using this pattern."
 msgstr ""
+"Die Inhalte werden als Markdown behandelt. Alle veröffentlichten Rust-Bibliothekskästen (library "
+"crates) werden automatisch unter [`docs.rs`](https://docs.rs) mit [rustdoc](https://doc.rust-lang."
+"org/rustdoc/what-is-rustdoc.html) dokumentiert. Es ist idiomatisch, alle öffentlichen Elemente in "
+"einer API mithilfe dieses Musters zu dokumentieren."
 
 #: src/basic-syntax/rustdoc.md:24
 msgid ""
@@ -3113,20 +3166,26 @@ msgid ""
 "* Inner doc comments are discussed later (in the page on modules) and need not\n"
 "  be addressed here."
 msgstr ""
+"* Zeige den Schülern die generierten Dokumente für die Kiste (crate) `rand` unter [`docs.rs/rand`]"
+"(https://docs.rs/rand).\n"
+"\n"
+"* Dieser Kurs enthält keine Rustdocs auf Folien, um Platz zu sparen, aber im echten Code sollten "
+"Rustdoc-Kommentare vorhanden sein.\n"
+"\n"
+"* Inner doc Kommentare werden später besprochen (auf der Seite zu Modulen) und müssen hier nicht "
+"behandelt werden."
 
 #: src/basic-syntax/methods.md:1 src/methods.md:1
-#, fuzzy
 msgid "# Methods"
 msgstr "# Methoden"
 
 #: src/basic-syntax/methods.md:3
-#, fuzzy
 msgid ""
 "Methods are functions associated with a type. The `self` argument of a method is\n"
 "an instance of the type it is associated with:"
 msgstr ""
-"Rust hat Methoden, das sind einfach Funktionen, die einem bestimmten Typ zugeordnet sind. Der\n"
-"Das erste Argument einer Methode ist eine Instanz des Typs, dem sie zugeordnet ist:"
+"Methoden sind Funktionen, die einem bestimmten Typ zugeordnet sind.\n"
+"Das `self`-Argument einer Methode ist die Instanz des Typs, dem sie zugeordnet ist:"
 
 #: src/basic-syntax/methods.md:6
 msgid ""
@@ -3156,10 +3215,9 @@ msgid ""
 msgstr ""
 
 #: src/basic-syntax/methods.md:30
-#, fuzzy
 msgid "* We will look much more at methods in today's exercise and in tomorrow's class."
 msgstr ""
-"* Wir werden uns in der heutigen Übung und im morgigen Unterricht viel mehr mit Methoden befassen."
+"* Wir werden uns in der heutigen Übung und im morgigen Unterricht tiefer mit Methoden befassen."
 
 #: src/basic-syntax/methods.md:34
 msgid ""
@@ -3174,19 +3232,26 @@ msgid ""
 "- Add a `Rectangle::new_square(width: u32)` constructor to illustrate that\n"
 "  constructors can take arbitrary parameters."
 msgstr ""
+"* Füge einen `Rectangle::new`-Konstruktor hinzu und rufe diesen von `main` aus auf:\n"
+"\n"
+"    ```rust,editable,compile_fail\n"
+"    fn new(width: u32, height: u32) -> Rectangle {\n"
+"        Rectangle { width, height }\n"
+"    }\n"
+"    ```\n"
+"\n"
+"* Füge einen `Rectangle::new_square(width: u32)`-Konstruktor hinzu, um zu veranschaulichen, dass "
+"Konstruktoren beliebige Parameter annehmen können."
 
 #: src/basic-syntax/functions-interlude.md:1
-#, fuzzy
 msgid "# Function Overloading"
 msgstr "# Funktionsüberladung"
 
 #: src/basic-syntax/functions-interlude.md:3
-#, fuzzy
 msgid "Overloading is not supported:"
 msgstr "Überladen wird nicht unterstützt:"
 
 #: src/basic-syntax/functions-interlude.md:5
-#, fuzzy
 msgid ""
 "* Each function has a single implementation:\n"
 "  * Always takes a fixed number of parameters.\n"
@@ -3199,11 +3264,10 @@ msgstr ""
 "  * Akzeptiert immer eine feste Anzahl von Parametern.\n"
 "  * Akzeptiert immer einen einzelnen Satz von Parametertypen.\n"
 "* Standardwerte werden nicht unterstützt:\n"
-"  * Alle Aufrufseiten haben die gleiche Anzahl von Argumenten.\n"
+"  * Alle Aufrufstellen (call sites) haben die gleiche Anzahl von Argumenten.\n"
 "  * Makros werden manchmal als Alternative verwendet."
 
 #: src/basic-syntax/functions-interlude.md:12
-#, fuzzy
 msgid "However, function parameters can be generic:"
 msgstr "Funktionsparameter können jedoch generisch sein:"
 
@@ -3222,14 +3286,13 @@ msgid ""
 msgstr ""
 
 #: src/basic-syntax/functions-interlude.md:27
-#, fuzzy
 msgid ""
 "* When using generics, the standard library's `Into<T>` can provide a kind of limited\n"
 "  polymorphism on argument types. We will see more details in a later section."
 msgstr ""
-"* Bei Verwendung von Generics kann das `Into<T>` der Standardbibliothek eine Art Limitierung "
-"bieten\n"
-"  Polymorphismus auf Argumenttypen. Wir werden mehr Details in einem späteren Abschnitt sehen."
+"* Bei Verwendung von Generika (generics) kann `Into<T>` der Standardbibliothek eine Art "
+"eingeschränkten Polymorphismus für Argumenttypen bereitstellen. Weitere Einzelheiten erfährst Du "
+"in einem späteren Abschnitt."
 
 #: src/exercises/day-1/morning.md:1
 #, fuzzy
@@ -17768,25 +17831,23 @@ msgid "You will find solutions to the exercises on the following pages."
 msgstr "Auf den folgenden Seiten finden Sie Lösungen zu den Aufgaben."
 
 #: src/exercises/solutions.md:5
-#, fuzzy
 msgid ""
 "Feel free to ask questions about the solutions [on\n"
 "GitHub](https://github.com/google/comprehensive-rust/discussions). Let us know\n"
 "if you have a different or better solution than what is presented here."
 msgstr ""
-"Fühlen Sie sich frei, Fragen zu den Lösungen zu stellen [on\n"
-"GitHub](https://github.com/google/comprehensive-rust/discussions). Lass uns wissen\n"
-"wenn Sie eine andere oder bessere Lösung als die hier vorgestellte haben."
+"Habe keine falsche Scheu, fragen zu den Lösungen [auf\n"
+"GitHub](https://github.com/google/comprehensive-rust/discussions) zu stellen. Lass uns wissen\n"
+"wenn Du eine andere oder bessere Lösung als die hier vorgestellte hast."
 
 #: src/exercises/solutions.md:10
-#, fuzzy
 msgid ""
 "> **Note:** Please ignore the `// ANCHOR: label` and `// ANCHOR_END: label`\n"
 "> comments you see in the solutions. They are there to make it possible to\n"
 "> re-use parts of the solutions as the exercises."
 msgstr ""
-"> **Hinweis:** Bitte ignorieren Sie `// ANCHOR: label` und `// ANCHOR_END: label`\n"
-"> Kommentare, die Sie in den Lösungen sehen. Sie sind da, um es zu ermöglichen\n"
+"> **Hinweis:** Bitte ignoriere `// ANCHOR: label` und `// ANCHOR_END: label`\n"
+"> Kommentare, die Du in den Lösungen siehst. Sie sind da, um es zu ermöglichen\n"
 "> Teile der Lösungen als Aufgaben wiederverwenden."
 
 #: src/exercises/day-1/solutions-morning.md:1
@@ -17897,14 +17958,13 @@ msgstr ""
 "`&[&[i32]]` sein, da er die von Ihnen zurückgegebenen Daten besitzen muss."
 
 #: src/exercises/day-1/solutions-morning.md:82
-#, fuzzy
 msgid ""
 "You can attempt to use something like `Vec<Vec<i32>>`, but this doesn't work out-of-the-box "
 "either: it's hard to convert from `Vec<Vec<i32>>` to `&[&[i32]]` so now you cannot easily use "
 "`pretty_print` either."
 msgstr ""
-"Sie können versuchen, so etwas wie `Vec<Vec<i32>>` zu verwenden, aber das funktioniert auch nicht "
-"sehr gut: Es ist schwierig, `Vec<Vec<i32>>` in `&[&[i32]] umzuwandeln. ` also kannst du jetzt auch "
+"Du kannst versuchen, so etwas wie `Vec<Vec<i32>>` zu verwenden, aber das funktioniert auch nicht "
+"sehr gut: Es ist schwierig, `Vec<Vec<i32>>` in `&[&[i32]] umzuwandeln. ` also kannst Du jetzt auch "
 "`pretty_print` nicht einfach verwenden."
 
 #: src/exercises/day-1/solutions-morning.md:84