i18n: tutorial/de - proofreading of 5th chapter

Author: hzulla

etc/doc/tutorial/de/05.4-Threads.md

@@ -2,21 +2,21 @@
 
 # Threads[^1]
 
-Mal angenommen, du hast eine Killer-Basslinie und einen krassen Beat 
-gebaut. Wie kannst du beides zur selben Zeit spielen lassen? Eine 
-Möglichkeit ist es, beide Sounds per Hand ineinanderzuweben - erst 
+Mal angenommen, Du hast eine Killer-Basslinie und einen krassen Beat 
+gebaut. Wie kannst Du beides zur selben Zeit spielen lassen? Eine 
+Möglichkeit ist es, beide Sounds per Hand ineinander zu weben - erst 
 spielt der Bass ein bisschen, dann das Schlagzeug, dann der Bass etwas 
 mehr... Beides aufeinander zeitlich abzustimmen wird jedoch immer 
 schwieriger, vor allem, wenn noch mehr Sounds dazukommen sollen.
 
-Was, wenn Sonic Pi Sounds automatisch für dich ineinanderflechten 
+Was, wenn Sonic Pi Sounds automatisch für Dich ineinanderflechten 
 könnte? Kann es auch, und zwar mit einem besonderen Ding, welches 
 *Thread* heisst.
 
 ## Unendliche Schleifen
 
-Damit das nächste Beispiel nicht zu kompliziert wird, musst du dir 
-einfach vorstellen, dass dies deine Killer-Basslinie und dein krasser 
+Damit das nächste Beispiel nicht zu kompliziert wird, musst Du Dir 
+einfach vorstellen, dass dies Deine Killer-Basslinie und Dein krasser 
 Beat sind.
 
 ```
@@ -33,11 +33,11 @@ end
 ```
 
 Wir haben das früher schon besprochen, Schleifen sind wie *schwarze 
-Löcher* für ein Programm; läuft es einmal in die Schleife, dann kommt 
-es nicht mehr da raus,  bis du den Stopp-Button klickst. Wie also 
+Löcher* für ein Programm; läuft es einmal in die Schleife kommt 
+es nicht mehr da raus, bis Du den Stopp-Button klickst. Wie also 
 können wir beide Schleifen zur selben Zeit abspielen? Wir müssen Sonic 
-Pi sagen, dass wir einen bestimmten Codeteil  gleichzeitig mit dem Rest 
-des Codes starten möchten. Hierbei helfen uns Threads.
+Pi sagen, dass wir einen bestimmten Abschnitt gleichzeitig mit
+dem Rest des Codes starten möchten. Hierbei helfen uns Threads.
 
 ## Threads kommen zur Hilfe
 
@@ -59,8 +59,8 @@ end
 Indem wir die erste Schleife in einen `in_thread`-do/end-Block 
 hineinpacken, sagen wir Sonic Pi, es soll den Inhalt dieses 
 do/end-Blocks *genau zur selben Zeit* wie die nachfolgende Anweisung 
-ausführen (und das ist in diesem Fall die zweite Schleife). Probier's 
-aus, und du wirst den Beat zusammen mit der Basslinie hören!
+ausführen. Und das ist in diesem Fall die zweite Schleife. Probier's 
+aus, und Du wirst den Beat zusammen mit der Basslinie hören!
 
 Was nun, wenn wir obendrauf noch einen Synth legen wollten. Ungefähr 
 so:
@@ -116,20 +116,20 @@ end
 
 ## Ablauf in Threads
 
-Was dich vielleicht erstaunt: Wenn du den Ausführen-Button klickst, 
-erzeugst du tatsächlich einen neuen Thread, innerhalb dessen der Code 
-abläuft. Deshalb werden immer neue Soundschichten erzeugt, wenn du den 
+Was Dich vielleicht erstaunt: Wenn Du den Ausführen-Button klickst, 
+erzeugst Du tatsächlich einen neuen Thread, innerhalb dessen der Code 
+abläuft. Deshalb werden immer neue Soundschichten erzeugt, wenn Du den 
 Ausführen-Button wiederholt klickst. Weil die Abläufe Threads sind, 
 werden sie automatisch die Sounds verflechten.
 
 ## Geltungsbereich[^2]
 
-Wenn du dich besser mit Sonic Pi auskennst, wirst du herausfinden, dass 
-Threads die wichtigsten Bausteine für deine Musik sind. Eine 
+Wenn Du Dich besser mit Sonic Pi auskennst, wirst Du herausfinden, dass 
+Threads die wichtigsten Bausteine für Deine Musik sind. Eine 
 wesentliche Funktion, die Threads haben, ist es, *aktuelle 
 Einstellungen*, die für einen Thread gelten, von anderen Threads zu 
-isolieren. Was genau bedeutet das? Wenn du etwa einen Synths mit 
-`use_synth` durch einen anderen austauschst, dann veränderst du den 
+isolieren. Was genau bedeutet das? Wenn Du etwa einen Synths mit 
+`use_synth` durch einen anderen austauschst, dann veränderst Du den 
 Synth lediglich für den *aktuellen Tread* - kein anderer der laufenden 
 Treads bekommt den neuen Synth. Sehen wir uns das mal in der Praxis an:
 
@@ -147,14 +147,14 @@ sleep 1
 play 50
 ```
 
-Hast du gehört, dass sich der mittlere Klang von den anderen beiden 
+Hast Du gehört, dass sich der mittlere Klang von den anderen beiden 
 unterschied? Die `use_synth`-Anweisung hat sich nur auf den Thread 
 ausgewirkt, in dem sie auch stand und nicht auf den äußeren 
 Haupt-Thread.
 
 ## Vererbung
 
-Wenn du einen neuen Thread mit `in_thread` erzeugst, wird dieser vom 
+Wenn Du einen neuen Thread mit `in_thread` erzeugst, wird dieser vom 
 vorherigen alle Einstellungen automatisch erben. Sehen wir uns das an:
 
 ```
@@ -167,18 +167,18 @@ in_thread do
 end
 ```
 
-Hast du bemerkt, dass der zweite Ton mit dem `:tb303`-Synth gespielt 
+Hast Du bemerkt, dass der zweite Ton mit dem `:tb303`-Synth gespielt 
 wird, obwohl er in einem anderen Thread läuft? Jede der Einstellungen, 
 die mit den unterschiedlichen `use_*`-Ausdrücken vorgenommen wird, 
 verhält sich genauso.
 
-Wenn neue Threads erzeugt werden, dann erben sie alle Einstellungen von 
-ihren Eltern; wenn du aber Einstellungen innerhalb dieser neuen Threads 
+Wenn neue Threads erzeugt werden, erben sie alle Einstellungen von 
+ihren Eltern; wenn Du aber Einstellungen innerhalb dieser neuen Threads 
 änderst, haben diese keine Einfluss auf die Eltern-Threads.
 
 ## Threads benennen
 
-Schließlich kannst du deinen Treads Namen geben.
+Schließlich kannst Du Deinen Treads Namen geben.
 
 ```
 in_thread(name: :bass) do
@@ -197,8 +197,8 @@ in_thread(name: :drums) do
 end
 ```
 
-Sieh dir das Protokoll-Fenster an, wenn du diesen Code laufen läßt. 
-Siehst du, wie die  Namen der Threads ausgeben werden?
+Sieh Dir das Protokoll-Fenster an, wenn Du diesen Code laufen läßt. 
+Siehst Du, wie die Namen der Threads ausgeben werden?
 
 ```
 [Run 36, Time 4.0, Thread :bass]
@@ -209,7 +209,7 @@ Siehst du, wie die  Namen der Threads ausgeben werden?
 
 Eine letzte Anmerkungen zu Threads mit Namen: Ein mit einem bestimmten 
 Namen benannter Thread kann zur Zeit nur einmal laufen. Probieren wir 
-das aus. Sieh dir den folgenden Code an:
+das aus. Sieh Dir den folgenden Code an:
 
 ```
 in_thread do
@@ -221,14 +221,14 @@ end
 ```
 
 Kopiere das einmal in ein Arbeitsfenster und klicke den 
-Ausführen-Button. Klick' in noch ein paarmal. Hör' dir diese Kakophonie 
+Ausführen-Button. Klick' in noch ein paarmal. Hör' Dir diese Kakophonie 
 mehrerer Amen Breaks an, die ryhtmisch nicht unbedingt passend 
-zueinander ablaufen. Ok, jetzt kannst du auf Stopp klicken.
+zueinander ablaufen. Ok, jetzt kannst Du auf Stopp klicken.
 
-Dieses Verhalten konnten wir schon woanders sehen - wenn du den 
+Dieses Verhalten konnten wir schon woanders sehen - wenn Du den 
 Ausführen-Button klickst, legen sich die neuen Klänge über die schon 
-laufenden. Wenn eine Schleife abläuft, und du den Ausführen-Button 
-dreimal klickst, bekommst du drei Ebenen mit Schleifen, die simultan 
+laufenden. Wenn eine Schleife abläuft, und Du den Ausführen-Button 
+dreimal klickst, bekommst Du drei Ebenen mit Schleifen, die simultan 
 ablaufen.
 
 Mit benannten Treads ist das jedoch anders:
@@ -243,28 +243,28 @@ end
 ```
 
 Versuche mit diesem Code den Ausführen-Button mehrmals zu klicken. Du 
-wirst immer nur eine Amen Break-Schleife hören. Das kannst du auch im 
+wirst immer nur eine Amen Break-Schleife hören. Das kannst Du auch im 
 Protokoll sehen:
 
 ```
 ==> Skipping thread creation: thread with name :amen already exists.
 ```
 
-Sonic Pi sagt dir, dass ein Thread mit dem Namen `:amen` bereits läuft 
-und es deshalb keinen neuen erzeugt.
+Sonic Pi sagt Dir, dass ein Thread mit dem Namen `:amen` bereits läuft 
+und es deshalb keinen neuen startet.
 
-Vielleicht erscheint dir dieses Verhalten im Moment noch nicht sinnvoll 
+Vielleicht erscheint Dir dieses Verhalten im Moment noch nicht sinnvoll 
 - aber es wird sehr nützlich sein, wenn wir ins Live-Coding 
 einsteigen...
 
-[^1]: Im Deutschen bedeutet *thread* *Kette*, *Faden* oder *Strang*. 
-Der *Thread* ist jedoch für Programmiersprachen eine so typische Idee, 
-dass eine Übersetzung nur insoweit Sinn macht, dass du dir die Idee, 
-die hinter diesem Begriff steht, besser merken kannst. Weil niemand 
-beim Programmieren über eine Kette oder einen Faden spricht, werden wir 
-hier nur den englischen Begriff benutzen.
-
-[^2]: *Scope* bedeutet ins Deutsche übersetzt soviel wie 
-*Geltungsbereich*. Für die Zukunft ist es aber ganz gut, sich den 
-englischen Begriff zu merken, da auch dieser im Programmierbereich 
-häufig vorkommt.
+[^1]: Im Deutschen bedeutet *thread* *Kette*, *Faden* oder *Strang*.
+    Der *Thread* ist jedoch für Programmiersprachen eine so typische
+    Idee, dass eine Übersetzung nur insoweit Sinn macht, dass Du Dir
+    die Idee, die hinter diesem Begriff steht, besser merken kannst.
+    Weil niemand beim Programmieren über eine Kette oder einen Faden
+    spricht, werden wir hier nur den englischen Begriff benutzen.
+
+[^2]: *Scope* bedeutet ins Deutsche übersetzt soviel wie
+    *Geltungsbereich*. Für die Zukunft ist es aber ganz gut, sich den
+    englischen Begriff zu merken, da auch dieser im Programmierbereich
+    häufig vorkommt.

etc/doc/tutorial/de/05.5-Functions.md

@@ -2,10 +2,10 @@
 
 # Funktionen
 
-Wenn du einmal damit angefangen hast, mehr Code zu schreiben, dann 
-wirst du nach Wegen suchen, wie du die Dinge organisieren und 
+Wenn Du einmal damit angefangen hast, mehr Code zu schreiben, dann 
+wirst Du nach Wegen suchen, wie Du die Dinge organisieren und 
 strukturieren kannst, damit alles ordentlicher wird und einfacher zu 
-verstehen ist. Funktionen sind sehr geeignet, um das zu erreichen. Sie 
+verstehen ist. Funktionen sind sehr praktisch, um das zu erreichen. Sie 
 geben uns die Möglichkeit, einem Bündel von Codezeilen einen Namen zu 
 geben. Sehen wir uns das an.
 
@@ -23,13 +23,13 @@ end
 Hier haben wir eine neue Funktion mit dem Namen `foo` definiert. Wir 
 machen das mit unserem alten Freund, dem do/end-Block und dem 
 Zauberwort `define` gefolgt von dem Namen, den wir unserer Funktion 
-geben möchten. Wir müssen die Funktion  nicht unbedingt `foo` nennen, 
+geben möchten. Wir müssen die Funktion nicht unbedingt `foo` nennen, 
 wir können sie auch irgendwie anders nennen; zum Beispiel `bar`, `baz` 
-oder idealerweise einen für dich bedeutsamen Namen wie `main_section` 
+oder idealerweise einen für Dich bedeutsamen Namen wie `main_section` 
 (etwa: *Hauptteil*) oder `lead_riff` (etwa: *Leitfigur*).
 
 Denk' daran, vor den Funktionsnamen einen Doppelpunkt `:` zu stellen, 
-wenn du sie definierst.
+wenn Du sie definierst.
 
 ## Funktionen aufrufen
 
@@ -54,37 +54,37 @@ end
 ```
 
 Wir können `foo` sogar in Iterations-Blocks aufrufen und überall da, wo 
-wir auch `play` oder `sample` hätten benutzen können. Das gibt uns ein 
+wir auch `play` oder `sample` hätten benutzen können. Das gibt uns eine 
 große Ausdrucksfreiheit und wir können sinnvolle Worte bilden, die wir 
 in unseren Kompositionen verwenden.
 
-## Funktionen werden in unterschiedlichen Abläufen erinnert
+## Funktionen bleiben in Erinnerung
 
-Wenn du bislang den Ausführen-Button geklickt hast, startete Sonic Pi 
+Wenn Du bislang den Ausführen-Button geklickt hast, startete Sonic Pi 
 jedesmal aufs Neue ohne irgendwelche Vorgaben. Es berücksichtigt nichs, 
-außer dem, was im jeweiligen Arbeitsfenster steht. Du kannst dich nicht 
+außer dem, was im jeweiligen Arbeitsfenster steht. Du kannst Dich nicht 
 auf irgendwelchen Code beziehen, der in einem anderen Arbeitsfenster 
-oder einem anderen Thread steht. Funktionen ändern das jedoch. Wenn du 
+oder einem anderen Thread steht. Funktionen ändern das jedoch. Wenn Du 
 eine Funktion definierst, dann erinnert sich Sonic Pi daran. Probieren 
-wir das aus. Ersetzte den den gesamten Code in deinem Arbeitsfenster 
+wir das aus. Ersetze den den gesamten Code in Deinem Arbeitsfenster 
 durch:
 
 ```
 foo
 ```
 
-Klick' den Ausführen-Button und höre, wie deine Funktion spielt. Wo 
+Klick' den Ausführen-Button und höre, wie Deine Funktion spielt. Wo 
 wurde dieser Code gespeichert? Woher weiss Sonic Pi, was es zu spielen 
-hat? Sonic Pi hat deine Funktion einfach erinnert - also sogar nachdem 
-du den Code aus dem Arbeitsfenster gelöscht hast, wusste Sonic Pi, was 
-du geschrieben hattest. Dies funktioniert nur mit Funktionen, die du 
-mit `define` (und `defonce`) definiert hast.
+hat? Sonic Pi hat sich Deine Funktion einfach gemerkt - also sogar
+nachdem  Du den Code aus dem Arbeitsfenster gelöscht hast, wusste
+Sonic Pi, was Du geschrieben hattest. Dies funktioniert nur mit
+Funktionen, die Du mit `define` (und `defonce`) definiert hast.
 
 ## Funktionen parametrisieren
 
-Vielleicht interessiert dich, dass du deinen Funktionen beibringen 
-kannst, Argumente zu übernehmen, genauso, wie du z.B. `rrand` einen 
-Minimal- und einen Maximalwert übergeben kannst. Sehen wir uns das an:
+Du kannst Deinen Funktionen beibringen Argumente zu übernehmen,
+genau so, wie Du z.B. `rrand` einen Minimal- und einen Maximalwert
+übergeben kannst. Sehen wir uns das an:
 
 ```
 define :my_player do |n|
@@ -98,8 +98,8 @@ my_player 90
 
 Das ist jetzt nicht besonders aufregend, zeigt aber, worum es hier 
 geht. Wir haben unsere eigene Version von `play` mit dem Namen 
-`my_player` erschaffen, die parametrisiert ist - also Argumente 
-akzeptiert.
+`my_player` erschaffen. Diese ist parametrisiert - sie akzeptiert also
+Argumente.
 
 Die Parameter müssen nach dem `do` stehen, welches zum `define` des 
 do/end-Blocks gehört; sie werden von senkrechten Strichen (auch: 
@@ -110,8 +110,8 @@ Die Zauberei findet innerhalb des `define`-do/end-Blocks statt. Du
 kannst die Parameternamen so benutzen, als wären sie wirkliche Werte. 
 In diesem Beispiel spiele ich den Ton `n`. Du kannst die Parameter als 
 eine Art Versprechen ansehen, dass sie durch wirkliche Werte ersetzt 
-werden, wenn der Code läuft. Das machst du, indem du der Funktion einen 
-Parameter mitgibst, wenn du sie aufrufst. Ich tue das hier mit 
+werden, wenn der Code läuft. Das machst Du, indem Du der Funktion einen 
+Parameter mitgibst, wenn Du sie aufrufst. Ich tue das hier mit 
 `my_player 80`, um den Ton 80 zu spielen. Innerhalb der 
 Funktionsdefinition wird `n` nun durch 80 ersetzt, sodass `play n` sich 
 in `play 80` verwandelt. Wenn ich die Funktion erneut mit `my_player 
@@ -140,6 +140,5 @@ Hier habe ich `repeats` so benutzt, als ob es eine Zahl in der Zeile
 `repeats.times do` wäre. Zusätzlich habe ich `roots` so verwendet, als 
 ob es ein Notenname im Aufruf `play` wäre.
 
-Hier kannst du sehen, wie wir sehr aussagekräftig und leicht lesbar 
-schreiben können, indem wir eine Menge der Logik in eine Funktion 
-verschieben.
+Siehst Du? Unser Code wird sehr aussagekräftig und leichter lesbar,
+indem wir eine Menge der Logik in eine Funktion verschieben.