Sonic Pi - en to de translation catalogue (1258 entries)

en: 1 Welcome to Sonic Pi
de: 1 Willkommen bei Sonic Pi

en: Welcome friend :-)
de: Hallo zusammen :-)

en: Welcome to Sonic Pi. Hopefully you're as excited to get started making your own sounds as I am to show you. It's going to be a really *fun* ride where you'll learn all about music, synthesis, programming, composition, performance and more.
de: Willkommen bei Sonic Pi! Hoffentlich bist du ebenso gespannt darauf zu lernen, wie man mit Sonic Pi verrückte Klänge machen kann, wie ich gespannt darauf bin es dir zu zeigen. Es wird eine wirklich *unterhaltsame* Reise werden, bei der du alles über Musik, Synthese, Programmieren, Komposition, Auftritte (Performance) etc. lernen wirst.

en: But wait, how rude of me! Let me introduce myself - I'm [Sam Aaron](https://twitter.com/samaaron) - the chap that created Sonic Pi. You can find me at [@samaaron](http://twitter.com/samaaron) on Twitter and I'd be more than happy to say hello to you. You might also be interested in finding out more about my [Live Coding Performances](https://youtube.com/samaaron) where I code with Sonic Pi live in front of audiences.
de: Aber halt, wie unhöflich von mir! Darf ich mich vorstellen? Ich bin [Sam Aaron](http://twitter.com/samaaron) der Typ, der Sonic Pi entwickelt hat. Du kannst mich unter [@samaaron](http://twitter.com/samaaron) auf Twitter finden, und ich würde mich sehr freuen dich dort begrüßen zu können. Vielleicht interessierst du dich auch für meine [Live-Coding-Performances](https://youtube.com/samaaron), wo ich meine Musik mit Sonic Pi direkt vor Publikum schreibe.

en: If you have any thoughts, or ideas for improving Sonic Pi - please pass them on - feedback is so helpful. You never know, your idea might be the next big feature!
de: Wenn du irgendwelche Vorschläge oder Ideen zur Verbesserung von Sonic Pi hast – bitte schreibe sie mir – eure Kommentare sind sehr hilfreich. Es wäre ja schließlich auch möglich, dass deine Idee zum nächsten großen Feature in Sonic Pi wird!

en: This tutorial is divided up into sections grouped by category. Whilst I've written it to have an easy learning progression from start to finish, feel very free just to dip in and out of sections as you see fit. If you feel that there's something missing, do let me know and I'll consider it for a future version.
de: Dieses Tutorial ist in Abschnitte aufgeteilt, die nach Themen gruppiert sind. Auch wenn ich es so geschrieben habe, dass du damit vom Anfang bis zum Ende einfach lernen kann, kannst du ebenso gut an jeder anderen Stelle einsteigen, und wieder aussteigen, ganz wie es dir gefällt. Wenn du etwas im Tutorial vermisst, lass es mich wissen, und ich werde überlegen, wie ich das in zukünftige Versionen einbauen kann.

en: Finally, watching others live code is a really great way to learn. I regularly stream live on [https://youtube.com/samaaron](http://youtube.com/samaaron) so please do drop by, say hi and ask me lots of questions :-)
de: Anderen beim Live-Coding zuzusehen ist eine wirklich großartige Art zu lernen. Ich streame regelmäßig live auf [http://youtube.com/samaaron](http://youtube.com/samaaron). Also schau gerne vorbei, sag Hallo und stell' mir jede Menge Fragen :-)

en: OK, let's get started...
de: Ok, legen wir los …

en: 1.1 Live Coding
de: 1.1 Live-Coding

en: Live Coding
de: Live-Coding

en: One of the most exciting aspects of Sonic Pi is that it enables you to write and *modify code live* to make music, just like you might perform live with a guitar. This means that given some practice you can take Sonic Pi on stage and gig with it.
de: Einer der aufregendsten Aspekte von Sonic Pi ist, dass du Code *live schreiben und verändern* kannst, um Musik zu machen. Ganz so wie du auch mit einer Gitarre auftreten würdest. Mit anderen Worten: Wenn du etwas Übung hast, kannst du Sonic Pi mit auf die Bühne nehmen und jammen.

en: Free your mind
de: Mach den Kopf frei

en: Before we get into the real details of how Sonic Pi works in the rest of this tutorial, I'd like to give you an experience of what it's like to live code. Don't worry if you don't understand much (or any) of this. Just try to hold onto your seats and enjoy...
de: Bevor wir in diesem Tutorial in die ernsten Details von Sonic Pi eintauchen, möchte ich dir erst einmal zeigen, wie sich das anfühlt live Musik zu programmieren. Keine Sorge, wenn du nicht alles (oder auch nur irgend etwas davon) verstehst. Das macht nichts. Versuch' an deinem Platz zu bleiben - und genieße ...

en: A live loop
de: Ein Live-Loop

en: Let's get started, copy the following code into an empty buffer:
de: Lass uns loslegen. Kopiere den folgenden Code in einen leeren Puffer:

en: Now, press the `Run` button and you'll hear a nice fast bass drum beating away. If at any time you wish to stop the sound just hit the `Stop` button. Although don't hit it just yet... Instead, follow these steps:
de: Jetzt klicke die `run`-Schaltfläche und du wirst eine schöne Bass-Drum hören, die schnell vor sich hin hämmert. Mit einem Klick auf die `stop`-Schaltfläche hört die Musik wieder auf. Aber klicke bitte noch nicht gleich darauf ... probiere stattdessen die folgenden Schritte aus:

en: Make sure the bass drum sound is still running
de: Lass den Bass-Drum-Sound weiter laufen

en: Change the `sleep` value from `0.5` to something higher like `1`.
de: Setze den Wert von `sleep` von `0.5` auf einen höheren Wert, etwa `1`.

en: Press the `Run` button again
de: Klicke wieder die `run`-Schaltfläche

en: Notice how the drum speed has changed.
de: Achte darauf, wie die Geschwindigkeit des Bass-Drum-Beats sich verändert hat.

en: Finally, *remember this moment*, this is the first time you've live coded with Sonic Pi and it's unlikely to be your last...
de: Und schließlich, *merke dir diesen Moment*! Dies war das erste Mal, dass du mit Sonic Pi live Programm-Code geschrieben hast. Und es ist wahrscheinlich, dass es nicht das letzte Mal gewesen sein wird …

en: Ok, that was simple enough. Let's add something else into the mix. Above `sample :bd_haus` add the line `sample :ambi_choir, rate: 0.3`. Your code should look like this:
de: Ok, das war einfach. Fügen wir etwas anderes hinzu. Über `sample :bd_haus` füge die Zeile `sample :ambi_choir, rate: 0.3` ein. Dein Programm-Code sollte dann so aussehen:

en: Now, play around. Change the rates - what happens when you use high values, or small values or negative values? See what happens when you change the `rate:` value for the `:ambi_choir` sample just slightly (say to `0.29`). What happens if you choose a really small `sleep` value? See if you can make it go so fast your computer will stop with an error because it can't keep up (if that happens, just choose a bigger `sleep` time and hit `Run` again).
de: So, jetzt spiele damit herum. Verändere die Werte für `rate:` – was passiert, wenn du hohe, niedrige oder negative Zahlen einträgst? Achte darauf, wie sich eine sehr kleine Änderung des `rate:`-Wertes auf das `:ambi_choir`-Sample auswirkt (z. B. 0.29)? Was passiert wenn du einen wirklich kleinen `sleep`-Wert einträgst? Probiere aus, ob du es so schnell machen kannst, dass du einen Stopp und eine Fehlermeldung deines Computers auslöst, weil er nicht mehr hinterher kommt. (Wenn das geschieht, nimm einfach wieder einen größeren Wert für `sleep` und klicke wieder auf `Ausführen`).

en: Try commenting one of the `sample` lines out by adding a `#` to the beginning:
de: Versuche eine Zeile mit dem `sample`-Code auszukommentieren, indem du ein `#` an ihren Anfang schreibst:

en: Notice how it tells the computer to ignore it, so we don't hear it. This is called a comment. In Sonic Pi we can use comments to remove and add things into the mix.
de: Beachte wie das Zeichen den Computer anweist die Zeile zu ignorieren - wir hören das Ergebnis des Befehls in dieser Zeile nicht mehr. Was hinter einem `#` steht ist ein Kommentar. Wir können dieses Zeichen in Sonic Pi benutzen, um Dinge schnell aus dem Mix zu entfernen und später wieder hinzuzuzufügen.

en: Finally, let me leave you something fun to play with. Take the code below, and copy it into a spare buffer. Now, don't try to understand it too much other than see that there are two loops - so two things going round at the same time. Now, do what you do best - experiment and play around. Here are some suggestions:
de: Abschließend möchte ich dir etwas unterhaltsames zum Spielen geben. Nimm den Code unten und kopiere ihn in einen freien Puffer. Versuche nicht mehr davon zu verstehen, als dass da zwei Loops sind – zwei Schleifen, die gleichzeitig laufen und sich endlos wiederholen. Jetzt tue, was du am besten kannst - experimentiere und spiele damit herum. Hier ein paar Vorschläge:

en: Try changing the blue `rate:` values to hear the sample sound change.
de: Ändere die blauen Werte hinter `rate:` und achte darauf, wie sich das Sample verändert.

en: Try changing the `sleep` times and hear that both loops can spin round at different rates.
de: Ändere die `sleep`-Zeiten, und achte darauf, wie die beiden Schleifen mit unterschiedlicher Geschwindigkeit aneinander vorbei laufen.

en: Try uncommenting the sample line (remove the `#`) and enjoy the sound of the guitar played backwards.
de: Versuche die auskommentierte Sample-Zeile zu aktivieren (entferne das `#`) und genieße den Klang einer umgekehrt abgespielten Gitarre.

en: Try changing any of the blue `mix:` values to numbers between `0` (not in the mix) and `1` (fully in the mix).
de: Probiere, die blauen Werte für `mix:` auf Werte zwischen `0` (nicht im Mix) und `1` (voll im Mix) zu ändern.

en: Remember to press `Run` and you'll hear the change next time the loop goes round. If you end up in a pickle, don't worry - hit `Stop`, delete the code in the buffer and paste a fresh copy in and you're ready to jam again. Making mistakes is how you'll learn the quickest...
de: Denke daran `run` zu klicken, dann hörst du sofort beim nächsten Durchlauf eines Loops deine Änderungen. Wenn irgendwas schiefgeht – macht nichts! Klicke auf `stop`, lösche den kaputten Code im Puffer und fange mit einer frischen Kopie noch einmal von vorn an zu jammen. Am schnellsten lernst du, wenn du Fehler machst…

en: Now, keep playing and experimenting until your curiosity about how this all actually works kicks in and you start wondering what else you can do with this. You're now ready to read the rest of the tutorial.
de: Spiele solange herum und experimentiere, bis deine Neugierde einsetzt und du dich fragst, wie das hier alles eigentlich wirklich funktioniert, und was man noch so alles damit anstellen kann. Du bist jetzt bereit für den Rest dieses Tutorials.

en: So what are you waiting for...
de: Also, worauf wartest du…

en: 1.2 Exploring the Interface
de: 1.2 Die Programmoberfläche von Sonic Pi

en: The Sonic Pi Interface
de: Die Programmoberfläche von Sonic Pi

en: Sonic Pi has a very simple interface for coding music. Let's spend a little time exploring it.
de: Sonic PI hat eine sehr einfache Oberfläche für das Programmieren von Musik. Schauen wir sie uns einmal genauer an.

en: *A* - Play Controls
de: *A* - Wiedergabe-Steuerung

en: *B* - Editor Controls
de: *B* - Editor-Steuerung

en: *C* - Info and Help
de: *C* - Info und Hilfe

en: *D* - Code Editor
de: *D* - Code-Editor

en: *E* - Prefs Panel
de: *E* - Einstellungen

en: *F* - Log Viewer
de: *F* - Protokoll-Fenster

en: *G* - Help System
de: *G* - Hilfe-System

en: *H* - Scope Viewer
de: *H* - Oszilloskop

en: *I* - Cue Viewer
de: *F* - Protokoll-Fenster

en: A. Play Controls
de: A. Wiedergabe-Steuerung

en: These pink buttons are the main controls for starting and stopping sounds. There's the *Run* button for running the code in the editor, *Stop* for stopping all running code, *Save* for saving the code to an external file and *Record* to create a recording (a WAV file) of the sound playing.
de: Mittels diesen pinkfarbenen Schaltflächen kannst du Klänge abspielen und stoppen. Die *run*-Schaltfläche startet den Programm-Code im Editor, *stop* hält den laufenden Programm-Code an, *save* schreibt den Code in eine Datei und *rec* nimmt die Klänge, die gerade zu hören sind (in einer WAV-Datei) auf.

en: B. Editor Controls
de: B. Editor-Steuerung

en: These orange buttons allow you to manipulate the code editor. The *Size +* and *Size -* buttons allow you to make the text bigger and smaller.
de: Diese orangenen Schaltflächen erlauben dir, den Code-Editor zu manipulieren. Mit den *size +* und *size -* Knöpfen kannst du den Text vergrößern oder verkleinern.

en: C. Info and Help
de: C. Information und Hilfe

en: These blue buttons give you access to information, help and preferences. The *Info* button will open up the information window which contains information about Sonic Pi itself - the core team, history, contributors and community. The *Help* button toggles the help system (*G*) and the *Prefs* button toggles the preferences window which allows you to control some basic system parameters.
de: Die blauen Schaltflächen bieten dir Zugriff auf Informationen, die Hilfe und die Voreinstellungen. Der *info*-Schalter öffnet ein Fenster mit Informationen über Sonic Pi selbst - das Entwickler-Team, Geschichte, Mitwirkende und Community. Der *help*-Schalter zeigt/verbirgt das eingebaute Hilfesystem (*F*) und *prefs* zeigt/verbirgt das Fenster, wo du einige grundsätzliche Einstellungen vornehmen kannst.

en: D. Code Editor
de: D. Code-Editor

en: This is the area where you'll write your code and compose/perform music. It's a simple text editor where you can write code, delete it, cut and paste, etc. Think of it like a very basic version of Word or Google Docs. The editor will automatically colour words based on their meaning in the code. This may seem strange at first, but you'll soon find it very useful. For example, you'll know something is a number because it is blue.
de: In diesem Bereich schreibst du deinen Code und komponierst und führst deine Musik auf. Es ist ein einfacher Texteditor, in dem du Code schreiben, löschen, ausschneiden und einfügen kannst u.s.w. Stelle es dir als sehr einfache Version von Word oder Google Docs vor. Der Editor färbt bestimmte Begriffe automatisch ein, je nachdem, welche Bedeutung sie innerhalb des Codes haben. Am Anfang mag dir das vielleicht ein wenig merkwürdig erscheinen, aber du wirst es bald sehr nützlich finden. Zum Beispiel erkennst du Zahlen sofort daran, dass sie blau sind.

en: E. Prefs Panel
de: E. Einstellungen

en: Sonic Pi supports a number of tweakable preferences which can be accessed by toggling the *prefs* button in the Info and Help button set. This will toggle the visibility of the Prefs Panel which includes a number of options to be changed. Examples are forcing mono mode, inverting stereo, toggling log output verbosity and also a volume slider and audio selector on the Raspberry Pi.
de: Sonic Pi enthält eine Reihe von veränderbaren Einstellungen, die über den *prefs*-Schalter im Info- und Hilfe-Menü erreicht werden können. In den Einstellungen sind einige Optionen verfügbar, die geändert werden können, darunter z. B.: Wechsel in den Mono-Modus, Tauschen der Stereokanäle, Einstellung der Ausführlichkeit der Protokoll-Ausgabe und ein Volumen-Regler. Auf einem Raspberry Pi kannst du hier auch das Ausgabemodul für den Ton auswählen.

en: F. Log Viewer
de: F. Protokoll-Fenster

en: When you run your code, information about what the program is doing will be displayed in the log viewer. By default, you'll see a message for every sound you create with the exact time the sound was triggered. This is very useful for debugging your code and understanding what your code is doing.
de: Wenn du deinen Programm-Code laufen lässt, siehst du im Protokoll-Fenster, was das Programm gerade tut. Standardmäßig siehst du eine Nachricht für jeden erzeugten Klang und die exakte Zeit, wann der Klang ausgelöst wurde. Bei der Suche nach Fehlern (Debugging) in deinem Programm-Code kann das sehr hilfreich sein, und du verstehst schneller, was dein Code macht.

en: G. Help System
de: G. Hilfe-System

en: One of the most important parts of the Sonic Pi interface is the help system which appears at the bottom of the window. This can be toggled on and off by clicking on the blue *Help* button. The help system contains help and information about all aspects of Sonic Pi including this tutorial, a list of available synths, samples, examples, FX and a full list of all the functions Sonic Pi provides for coding music.
de: Eines der wichtigsten Elemente des Sonic Pi Programmfensters ist das Hilfe-System, das am unteren Ende des Fensters auftaucht. Du kannst es ein- und ausblenden, indem du den blauen `help`-Schalter klickst. Das Hilfe-System zeigt Hilfe und Informationen zu allen Aspekten von Sonic Pi an, einschließlich dieses Tutorials, einer Liste der mitgelieferten Synthesizer, Samples, Beispiele, Effekte (FX) sowie eine komplette Liste aller Funktionen (Sprachbefehle), die Sonic Pi zum Coden von Musik bereitstellt.

en: H. Scope Viewer
de: H. Oszilloskop

en: The scope viewer allows you to see the sound you're hearing. You can easily see that the saw wave looks like a saw and that the basic beep is a curvey sine wave. You can also see the difference between loud and quiet sounds by the size of the lines. There are 3 scopes to play with - the default is a combined scope for the left and right channels, there is a stereo scope which draws a separate scope for each channel. Finally there is a Lissajous curve scope which will show the phase relationship between the left and right channels and allows you to draw pretty pictures with sound (https://en.wikipedia.org/wiki/Lissajous_curve).
de: Das Oszilloskop kann dir die Töne die du hörst, anzeigen. Du kannst leicht erkennen, dass die Sägezahnwelle wie eine Säge aussieht und der Beep wie eine kurvige Sinus-Welle. Du kannst auch den Unterschied zwischen lauten und leisen Tönen anhand der Größe der Linien erkennen. Es gibt drei Oszilloskope, mit denen du spielen kannst. Standard ist ein aus dem linken und rechten Kanal kombiniertes Oszilloskop, es gibt daneben ein Stereo-Oszilloskop, das beide Kanäle einzeln anzeigt. Und zu guter Letzt gibt es das Lissajous-Oszilloskop, das dir die Phasen-Beziehung zwischen dem linken und rechten Kanal anzeigt - es ermöglicht dir auch das Zeichnen von Bildern mit Klängen (https://de.wikipedia.org/wiki/Lissajous-Figur).

en: I. Cue Viewer
de: I. Protokoll-Fenster

en: All internal and external events (called cues in Sonic Pi) are automatically logged in the Cue Viewer. For example, if you have a MIDI controller connected and press one of its buttons, you'll see a new cue event in the Cue Viewer telling you the name of the controller and which button you pressed. Once you've mastered the basics of making and producing sounds, you'll start to want to cue sounds or whole sections of sounds based on events such as these. A cue event is just an indication that something happened. For example, every time a live loop spins round, it sends a cue event out which is logged in the Cue Viewer. Also, external events such as MIDI messages from connected MIDI equipment and OSC messages from other programs or computers are also displayed in the Cue Viewer. It is also possible to directly generate cue events using the `cue` function. Anything that appears in the Cue Viewer can be used to trigger something happening. This is covered in more detail in Sections 10 to 12 of this tutorial.
de: Alle internen und externen Ereignisse (in Sonic Pi Cues genannt) werden automatisch im Cue-Protokoll angezeigt. Betätigst du zum Beispiel einen verbundenen MIDI-Controller, erscheint die Bezeichnung des betätigten Schalters/Reglers und des Controllers im Protokoll. Sobald du die Grundlagen der Erzeugung und Hervorbringung von Klängen gemeistert hast, wirst du auch Cues für Klänge oder ganze Abschnitte von Klängen mit diesen Mitteln steuern wollen. Cue-Ereignisse (cue events) sind Indikatoren dafür, dass etwas geschehen ist. Zum Beispiel schickt ein Live-Loop jedes Mal wenn er eine Runde ausführt ein solches Cue-Ereignis, das im Cue-Protokoll angezeigt wird. Auch externe Ereignisse, wie MIDI-Signale von angeschlossenen MIDI-Geräten, und OSC-Signale von anderen Programmen und Computern werden im Cue-Protokoll angezeigt. Zudem ist es auch möglich mithilfe der `cue`-Funktion Einträge im Protokoll zu generieren. In den Abschnitten 10 bis 12 lernst du im einzelnen, wie du Protokoll-Einträge als Trigger (Auslöser) für andere Abläufe benutzen kannst.

en: 1.3 Learning through Play
de: 1.3 Lernen durch Spielen

en: Learning through Play
de: Lernen durch Spielen

en: Sonic Pi encourages you to learn about both computing and music through play and experimentation. The most important thing is that you're having fun, and before you know it you'll have accidentally learned how to code, compose and perform.
de: Sonic Pi ermutigt dich etwas über Computer und Musik zu lernen - durch Spielen und Experimentieren. Das aller Wichtigste ist, dass du Spaß hast, und bevor du es überhaupt bemerkst, wirst du zufällig gelernt haben Code zu schreiben, Musik zu komponieren und aufzuführen.

en: There are no mistakes
de: Es gibt keine Fehler

en: Whilst we're on this subject, let me just give you one piece of advice I've learned over my years of live coding with music - *there are no mistakes, only opportunities*. This is something I've often heard in relation to jazz but it works equally well with live coding. No matter how experienced you are - from a complete beginner to a seasoned live coder, you'll run some code that has a completely unexpected outcome. It might sound insanely cool - in which case run with it. However, it might sound totally jarring and out of place. It doesn't matter that it happened - what matters is what you do next with it. Take the sound, manipulate it and morph it into something awesome. The crowd will go *wild*.
de: Wo wir gerade dabei sind, möchte ich dir noch einen Rat geben, etwas das ich in den Jahren, in denen ich Musik live programmiert habe gelernt habe - *es gibt keine Fehler, nur Gelegenheiten*. Ich habe das oft im Bezug auf Jazz gehört, aber es trifft ebenso gut auf Live-Coding zu. Es spielt keine Rolle, wie viel Erfahrung du hast, ob du ein absoluter Anfänger oder ein erfahrender Live-Coder bist. Du wirst Code laufen lassen, der vollkommen unerwartete Ergebnisse hervorbringt. Kann sein, dass es unglaublich cool klingt - dann mache da weiter. Wie dem auch sei, kann sein, dass es schrecklich klingt und vollkommen fehl am Platz ist. Es ist egal, wenn das passiert, wichtig ist, was du dann damit als Nächstes tust. Nimm den Klang, bearbeite ihn und verwandle ihn in etwas Tolles. Die Menge wird *durchdrehen*.

en: Start Simple
de: Beginne einfach

en: When you're learning, it's tempting to want to do amazing things *now*. However, just hold that thought and see it as a distant goal to reach *later*. For now, instead think of the *simplest* thing you could write which would be fun and rewarding that's a small step towards the amazing thing you have in your head. Once you have an idea about that simple step, then try and build it, play with it and then see what new ideas it gives you. Before long you'll be too busy having fun and making real progress.
de: Wenn du lernst, willst du die tollen Sachen vielleicht am liebsten *sofort* machen. Halte solche Gedanken fest, aber sieh sie als ein Ziel an, welches du etwas *später* erreichen wirst. Denke zunächst erst einmal an die *einfachste* Sache, die du schreiben kannst, die dir Spaß machen würde und dir lohnend erscheint; diese Sache ist ein kleiner Schritt auf dem Weg zu den faszinierenden Dingen, die dir im Kopf herum gehen. Wenn dir die Idee zu diesem einfachen Schritt klar ist, versuche ihn umzusetzen, spiele damit herum und finde heraus, auf was für neue Ideen du dadurch kommst. Du wirst bald sehr viel Spaß daran haben und echte Fortschritte machen.

en: Just make sure to share your work with others!
de: Stelle sicher, dass du deine Werke mit anderen teilst!

en: 2 Synths
de: 2 Synthesizer

en: Synths
de: Synthesizer

en: OK, enough of the intros - let's get into some sound.
de: Ok, genug der Einführung - lasst uns Klänge machen.

en: In this section we'll cover the basics of triggering and manipulating synths. Synth is short for synthesiser which is a fancy word for something which creates sounds. Typically synths are quite complicated to use - especially analog synths such as Eurorack modules connected together by a mess of wires. However, Sonic Pi gives you much of that power in a very simple and approachable manner.
de: In diesem Abschnitt behandeln wir die Grundlagen des Triggerns (Auslösen) und Manipulierens von Synths. Synth ist die Kurzform von Synthesizer - dem genauen Wortlaut für etwas, das Klänge erzeugt. Typischerweise sind Synths ziemlich kompliziert im Gebrauch, vor allem analoge Synths wie Eurorack-Module, untereinander verbunden mit einem Durcheinander von Kabeln. Sonic Pi gibt dir eine Vielzahl solcher Möglichkeiten auf eine einfache und gut zugängliche Art.

en: Don't be fooled by the immediate simplicity of Sonic Pi's interface. You can get very deep into very sophisticated sound manipulation if that's your thing. Hold on to your hats...
de: Lass dich nicht täuschen von der einfachen Programmoberfläche von Sonic Pi. Wenn du willst, kannst du damit sehr tief in sehr ausgeklügelte Klangmanipulationen eintauchen. Also festhalten...

en: 2.1 Your First Beeps
de: 2.1 Deine ersten Beeps

en: Your First Beeps
de: Deine ersten Beeps

en: Take a look at the following code:
de: Sieh dir den folgenden Code an:

en: This is where it all starts. Go ahead, copy and paste it into the code window at the top of the app (the big white space under the Run button). Now, press Run...
de: Damit fängt alles an. Leg los, kopiere und setze das in das Code-Fenster oben im Programm ein (der große weiße Bereich unter der `run`-Schaltfläche). Nun klicke auf `run`...

en: Intense. Press it again. And again. *And again...*
de: Stark. Klicke die Schaltfläche nochmal. Und nochmal. *Und nochmal...*

en: Woah, fun! I'm sure you could keep doing that all day. But wait, before you lose yourself in an infinite stream of beeps, try changing the number:
de: Wow, verrückt, ich bin sicher, du könntest das den ganzen Tag lang machen. Aber halt, bevor du dich in einem endlosen Strom von Piepstönen verlierst, versuche es mit einer anderen Zahl:

en: Can you hear the difference? Try a lower number:
de: Hörst du den Unterschied? Nimm eine kleinere Zahl:

en: So, lower numbers make lower pitched beeps and higher numbers make higher pitched beeps. Just like on a piano, the keys at the lower part of the piano (the left hand side) play lower notes and the keys on the higher part of the piano (the right hand side) play higher notes.
de: Also, niedrigere Zahlen machen tiefere Töne und höhere Zahlen höhere Töne. Wie bei einem Klavier erzeugen, von links nach rechts gesehen, die *niedrigeren* Tasten weiter links tiefere Töne als die *höheren* Tasten weiter rechts, die höhere Töne erzeugen.

en: It turns out that the C of the 4th octave (C in English notation) is identified by the number 60. `play 60` therefore plays the C of the 4th octave. To play the next piano key to the right, you have to add 1 to 60 and then type `play 61`, which in this case is the black key of the C sharp. To play the D, the next key to the right, `play 62`.
de: Es ist gut zu wissen, dass das C in der vierten Oktave mit der Zahl 60 bezeichnet wird. `play 60` spielt also ein C der vierten Oktave. Um den nächsthöheren Ton rechts davon auf der Klaviatur zu spielen, musst du 1 zu 60 addieren und `play 61` schreiben. Das ist dann die schwarze Taste rechts vom C, ein Cis (oder C# in englischer Schreibweise). Um nun ein D, den nächst höheren Ton rechts davon, zu spielen, schreibe `play 62`.

en: *Don't worry* if this means nothing to you - it didn't to me when I first started. All that matters right now is that you know that *low numbers make lower beeps* and *high numbers make higher beeps*.
de: *Keine Sorge*, wenn du keine Ahnung hast, was das alles bedeutet. Mir ging es genauso als ich anfing. Für den Beginn reicht es völlig zu wissen, *niedrigere Zahlen bedeuten tiefere Klänge* und *höhere Zahlen bedeuten höhere Klänge*.

en: Chords
de: Akkorde

en: Playing a note is quite fun, but playing many at the same time can be even better. Try it:
de: Eine Note zu spielen kann ganz lustig sein, aber mehrere zur selben Zeit zu spielen ist noch besser. Versuche es:

en: Jazzy! So, when you write multiple `play`s, they all play at the same time. Try it for yourself - which numbers sound good together? Which sound terrible? Experiment, explore and find out for yourself.
de: Jazzig! Wenn du also mehrere `play`s hinschreibst, spielen sie alle zur selben Zeit. Probiere selbst aus - welche Nummern klingen gut zusammen? Welche klingen fürchterlich? Experimentiere, erforsche und finde es für dich selbst heraus.

en: Melody
de: Melodie

en: So, playing notes and chords is fun - but how about a melody? What if you wanted to play one note after another and not at the same time? Well, that's easy, you just need to `sleep` between the notes:
de: Einzelne Noten und Akkorde zu spielen macht Spaß - aber wie wäre es mit einer Melodie? Was, wenn du eine Note nach der anderen spielen wolltest und nicht alle zur selben Zeit? Also, das ist ganz einfach, du brauchst nur ein `sleep` zwischen den Noten:

en: How lovely, a little arpeggio. So what does the `1` mean in `sleep 1`? Well it means the *duration of the sleep*. It actually means sleep for one beat, but for now we can think about it as sleeping for 1 second. So, what if we wanted to make our arpeggio a little faster? Well, we need to use shorter sleep values. What about a half i.e. `0.5`:
de: Wie hübsch, ein kleines Arpeggio. Was bedeutet die `1` in `sleep 1`? Sie gibt die *Dauer von sleep* an. Tatsächlich bedeutet das: Schlafe für einen Schlag. Aber vorläufig können wir uns vorstellen, dass es bedeutet: Schlafe für eine Sekunde. Wie könnten wir unser Arpeggio schneller ablaufen lassen? Dazu brauchen wir kürzere Werte für sleep. Wie wäre es z. B. mit der Hälfte, also `0.5`:

en: Notice how it plays faster. Now, try for yourself, change the times - use different times and notes.
de: Achte darauf, wie die Melodie nun schneller spielt. Probiere es für dich selbst aus, ändere die Zeiten - verwende unterschiedliche Zeiten und Noten.

en: One thing to try is in-between notes such as `play 52.3` and `play 52.63`. There's absolutely no need to stick to standard whole notes. Play around and have fun.
de: Versuche einmal Zwischennoten wie `play 52.3` und `play 52.63`. Es gibt überhaupt keinen Grund, nur ganze Zahlen zu verwenden. Spiel damit herum und hab Spaß dabei. *Beachte* dabei, dass Computer grundsätzlich die englische Schreibweise für Zahlen verwenden - setze also stets einen Punkt vor die Nachkommastellen (sic!), kein Komma!

en: Traditional Note Names
de: Traditionelle Notennamen

en: For those of you that already know some musical notation (don't worry if you don't - you don't need it to have fun) you might want to write a melody using note names such as C and F# rather than numbers. Sonic Pi has you covered. You can do the following:
de: *Beachte* für das folgende, dass Sonic Pi die englischen Notennamen verwendet, *Fis* ist *F sharp* oder auch *F#* und *Fes* ist *F flat* bzw. *Fb*. Die Note H heißt im Englischen *B*.
    Für die unter euch, die die musikalische Notation schon ein wenig kennen (keine Sorge, wenn nicht - du brauchst es nicht unbedingt) - vielleicht möchtet ihr eine Melodie mit Notennamen anstelle von Zahlen schreiben, also C oder F#. Auch das geht mit Sonic Pi. Du kannst folgendes machen:

en: Remember to put the colon `:` in front of your note name so that it goes pink. Also, you can specify the octave by adding a number after the note name:
de: Denk daran, direkt vor den Notennamen einen Doppelpunkt `:` zu stellen, sodass dieser sich Pink färbt. Du kannst ebenfalls die Oktave festlegen, indem du eine Zahl direkt hinter den Notennamen schreibst:

en: If you want to make a note sharp, add an `s` after the note name such as `play :Fs3` and if you want to make a note flat, add a `b` such as `play :Eb3`.
de: Wenn du eine Note um einen Halbton erhöhen willst, füge ein `s` hinzu, also `play :Fs3`. Und wenn du eine Note um einen Halbton verringern möchtest, füge ein `b` an, also `play :Eb3`.

en: There's also a handy shortcut for a rest (a musical way of saying not to play anything instead of a note) using `:r`, `:rest` or `nil`.
de: Es gibt auch eine praktische Abkürzung für eine Pause (eine musikalische Art zu sagen, dass anstelle einer Note nichts gespielt werden soll) mit `:r`, `:rest` oder `nil`.

en: 2.2 Synth Options
de: 2.2 Synth-Optionen

en: Synth Options: Amp and Pan
de: Synth-Optionen: Amp und Pan

en: As well as allowing you to control which note to play or which sample to trigger, Sonic Pi provides a whole range of options to craft and control the sounds. We'll be covering many of these in this tutorial and there's extensive documentation for each in the help system. However, for now we'll introduce two of the most useful: *amplitude* and *pan*. First, let's look at what options actually are.
de: Genauso wie es dich steuern lässt, welche Noten du erzeugst und welche Samples du abspielst, bietet dir Sonic Pi eine ganzen Bandbreite von Optionen, um die Klänge zu gestalten und zu steuern. Wir werden viele davon in diesem Tutorial behandeln, und für jede Option gibt es eine ausführliche Dokumentation im Hilfe-Fenster. Für den Moment werden wir uns zunächst zwei der nützlichsten ansehen: *Amplitude* (Lautstärke) und *Pan* (Panorama). Aber vorher will ich kurz erklären, was Optionen eigentlich sind.

en: Options
de: Optionen

en: Sonic Pi supports the notion of options (or opts for short) for its synths. Opts are controls you pass to `play` which modify and control aspects of the sound you hear. Each synth has its own set of opts for finely tuning its sound. However, there are common sets of opts shared by many sounds such as `amp:` and envelope opts (covered in another section).
de: Die Synths von Sonic Pi lassen sich über verschiedene Optionen (oder kurz: Opts) verändern. Opts sind Regler, die an `play` oder `sample` übergeben werden; sie verändern und steuern unterschiedliche Aspekte der Klänge, die du hörst. Jeder Synth hat seinen eigenen Satz Opts, um den Klang fein einzustellen. Es gibt auch Opts, die für viele Klänge identisch sind, z.B. `amp:` und Hüllkurven-Opts (die wir in einer anderen Sektion besprechen).

en: Opts are passed to calls to `play` by using a comma `,` and then the name of the opt such as `amp:` (don't forget the colon `:`) and then a space and the value of the opt. For example:
de: Opts werden den Aufrufen von `play` und `sample` nach einem Komma `,` übergeben, dem der Name der Option folgt, etwa `amp:` (vergiss den Doppelpunkt `:` nicht), dann eine Leerstelle und schließlich der Wert der Option. Zum Beispiel:

en: (Note that `cheese:` isn't a valid opt, we're just using it as an example).
de: (`cheese:` ist keine gültige Option, wir nehmen sie hier nur als Beispiel).

en: You can pass multiple opts by separating them with a comma:
de: Du kannst mehrere Opts hintereinander schreiben, indem du sie jeweils mit einem weiteren Komma abtrennst:

en: The order of the opts doesn't matter, so the following is identical:
de: Die Reihenfolge der Opts spielt keine Rolle, so dass die folgende Zeile hätte dasselbe Ergebnis:

en: Opts that aren't recognised by the synth are just ignored (like `cheese` and `beans` which are clearly ridiculous opt names!)
de: Opts, die der Synth nicht kennt, ignoriert er einfach. (wie `cheese` und `beans`, die ja nun wirklich alberne Namen für Optionen sind!)

en: If you accidentally use the same opt twice with different values, the last one wins. For example, `beans:` here will have the value 2 rather than 0.5:
de: Wenn du aus Versehen zweimal dieselbe Opt mit unterschiedlichen Werten benutzt, gewinnt die letzte. Im folgenden Beispiel wird `beans` den Wert 2 bekommen und nicht 0.5:

en: Many things in Sonic Pi accept opts, so just spend a little time learning how to use them and you'll be set! Let's play with our first opt: `amp:`.
de: Viele Dinge in Sonic Pi akzeptieren Optionen, also verbringe ein wenig Zeit damit zu lernen, wie du sie einsetzen kannst, und du wirst bald startklar sein! Spielen wir mal mit unserer ersten Opt: `amp:`.

en: Amplitude is a computer representation of the loudness of a sound. A *high amplitude produces a loud sound* and a *low amplitude produces a quiet sound*. Just as Sonic Pi uses numbers to represent time and notes, it uses numbers to represent amplitude. An amplitude of 0 is silent (you'll hear nothing) whereas an amplitude of 1 is normal volume. You can even crank up the amplitude higher to 2, 10, 100. However, you should note that when the overall amplitude of all the sounds gets too high, Sonic Pi uses what's called a compressor to squash them all to make sure things aren't too loud for your ears. This can often make the sound muddy and strange. So try to use low amplitudes, i.e. in the range 0 to 0.5 to avoid compression.
de: Die Amplitude ist wie der Computer die Lautheit eines Klangs repräsentiert. Eine *hohe Amplitude bringt einen lauten Klang hervor*, und eine *niedrige Amplitude ergibt einen leisen Klang*. So wie Sonic Pi Zahlen dazu benutzt, um Zeit und Töne darzustellen, bildet es auch die Lautstärke mit Hilfe von Zahlen ab. Eine Amplitude von 0 bedeutet Stille (du wirst nichts hören), eine Amplitude von 1 steht für normale Lautstärke. Du kannst die Amplitude aufdrehen auf 2, 10, 100. Aber Vorsicht: Wenn die Amplitude aller gemeinsamen Klänge zu hoch wird, setzt Sonic Pi einen so genannten Kompressor ein, der sie zusammen quetscht, damit die Klänge nicht zu laut für dein Ohr werden. Oft klingt das dann matschig und schräg. Verwende also lieber niedrige Amplituden, das heißt im Bereich zwischen 0 und 0.5, um Kompression zu verhindern.

en: Amp it up
de: Amp aufdrehen

en: To change the amplitude of a sound, you can use the `amp:` opt. For example, to play at half amplitude pass 0.5:
de: Um die Amplitude eines Klangs zu ändern, setze die Opt `amp:` ein. Um zum Beispiel mit halber Amplitude abzuspielen übergebe 0.5:

en: To play at double amplitude pass 2:
de: Für die doppelte Amplitude übergebe 2:

en: The `amp:` opt only modifies the call to `play` it's associated with. So, in this example, the first call to play is at half volume and the second is back to the default (1):
de: Die `amp:`-Opt beeinflusst nur den Aufruf von `play`, mit der sie unmittelbar zusammenhängt. Das heißt, in dem folgenden Beispiel wird der erste Aufruf von `play` mit halber Lautstärke gespielt und der zweite wieder mit der Standardlautstärke (1):

en: Of course, you can use different `amp:` values for each call to play:
de: Natürlich kannst du für jeden Aufruf von `play` andere Werte für `amp:` festlegen:

en: Another fun opt to use is `pan:` which controls the panning of a sound in stereo. Panning a sound to the left means that you hear it out of the left speaker, and panning it to the right means you hear it out of your right speaker. For our values, we use a -1 to represent fully left, 0 to represent center and 1 to represent fully right in the stereo field. Of course, we're free to use any value between -1 and 1 to control the exact positioning of our sound.
de: Eine weitere interessante Opt ist `pan:`. Ihr Wert gibt an, aus welcher Richtung der Klang kommt, wenn wir in Stereo hören. Panning nach links bedeutet, dass du denKlang aus dem linken Lautsprecher und Panning nach rechts, dass du ihn aus dem rechten Lautsprecher hörst. Für unsere Werte benutzen wir -1 , um den Klang ganz nach links zu schieben, 0 steht für die Mitte und mit 1 schieben wir den Klang ganz nach rechts. Natürlich können wir jeden Wert zwischen -1 und 1 verwenden, um die Klänge exakt im Stereofeld zu positionieren.

en: Let's play a beep out of the left speaker:
de: Lasst uns einen Beep nur aus dem linken Lautsprecher abspielen:

en: Now, let's play it out of the right speaker:
de: Jetzt aus dem rechten Lautsprecher:

en: Finally let's play it back out of the center of both (the default position):
de: Nun wollen wir den Klang aus der Mitte zwischen beiden Lautsprechern herauskommen lassen (die Standardposition):

en: Now, go and have fun changing the amplitude and panning of your sounds!
de: Jetzt leg' einfach los und verändere die Amplitude und das Panning deiner Klänge!

en: 2.3 Switching Synths
de: 2.3 Synths wechseln

en: Switching Synths
de: Synths wechseln

en: So far we've had quite a lot of fun making beeps. However, you're probably starting to get bored of the basic beep noise. Is that all Sonic Pi has to offer? Surely there's more to live coding than just playing beeps? Yes there is, and in this section we'll explore some of the exciting range of sounds that Sonic Pi has to offer.
de: Bisher hatten wir viel Spaß damit Pieptöne zu erzeugen. Aber wahrscheinlich langweilt es dich langsam, immer wieder denselben Klang zu hören. Ist das alles, was Sonic Pi zu bieten hat? Live-Coding kann doch sicher mehr als nur einen einfachen Piepton zu spielen? Aber klar doch! In diesem Abschnitt schauen wir uns die aufregende Vielfalt der Klänge, die uns Sonic Pi bietet, an.

en: Sonic Pi has a number of different instruments it calls synths (which is *short for synthesisers*). Whereas samples represent pre-recorded sounds, synths are capable of generating new sounds depending on how you control them (which we'll explore later in this tutorial). Sonic Pi's synths are very powerful and expressive and you'll have a lot of fun exploring and playing with them. First, let's learn how to select the current synth to use.
de: Sonic Pi verfügt über eine ganze Palette unterschiedlicher Instrumente, die es Synths nennt (kurz für *Synthesizer - Klangerzeuger*). Wohingegen Samples bereits aufgenommene Klänge sind. Synths erzeugen neue Klänge, je nachdem, wie du sie steuerst (was wir später in diesem Tutorial untersuchen werden). Die Synths in Sonic Pi sind sehr kraftvoll und ausdrucksstark, und du wirst viel Spaß damit haben sie zu erforschen und damit zu spielen. Lass uns zuerst lernen, wie ein Synth ausgewählt wird, um ihn zu verwenden.

en: Buzzy saws and prophets
de: Brummende Sägen und Propheten

en: A fun sound is the *saw wave* - let's give it a try:
de: Ein lustiger Klang ist die *Sägezahn-Welle* - probieren wir es mal aus:

en: Let's try another sound - the *prophet*:
de: Nehmen wir einen anderen Klang - den *Prophet*:

en: How about combining two sounds. First one after another:
de: Wie wäre es beide Klänge zu verbinden? Zuerst nacheinander:

en: Now multiple sounds at the same time (by not sleeping between successive calls to `play`):
de: Jetzt mehrere Töne gleichzeitig (keine Pausen mit `sleep` zwischen aufeinander folgenden Aufrufen von `play`):

en: Notice that the `use_synth` command only affects the following calls to `play`. Think of it like a *big switch* - new calls to `play` will play whatever synth it's currently pointing to. You can move the switch to a new synth with `use_synth`.
de: Achte darauf, wie das `use_synth`-Kommando nur die nachfolgenden `play`-Kommandos beeinflusst. Stell dir das wie einen *großen Schalter* vor - neue Aufrufe von `play` werden immer den Synth benutzen, auf den der Schalter gerade zeigt. Du kannst diesen Schalter mit `use_synth` auf einen anderen Synth umschalten.

en: Discovering Synths
de: Synths entdecken

en: To see which synths Sonic Pi has for you to play with take a look at the Synths option in the menu at the bottom of this help screen (between Examples & Fx). There are over 20 to choose from. Here are a few of my favourites:
de: Um zu entdecken welche Synths Sonic Pi für dich zum Spielen bereithält, schau im Synths-Option im Menü links unten im Hilfe-Fenster nach (gleich neben *FX*). Es gibt über 20 zur Auswahl. Hier sind einige meiner Favoriten:

en: Now play around with *switching synths during your music*. Have fun combining synths to make new sounds as well as using different synths for different sections of your music.
de: Spiele ein bisschen herum und *wechsle die Synths, während du spielst*. Kombiniere unterschiedliche Synths, um neue Klänge zu erzeugen, oder setze sie für unterschiedliche Sektionen in deinem Stück ein.

en: 2.4 Duration with Envelopes
de: 2.4 Dauer bei Hüllkurven

en: Duration with Envelopes
de: Dauer bei Hüllkurven

en: In an earlier section, we looked at how we can use the `sleep` command to control when to trigger our sounds. However, we haven't yet been able to control the duration of our sounds.
de: In einem früheren Abschnitt haben wir gesehen, wie wir mit dem `sleep`-Kommando steuern können, dass unsere Klänge ausgelöst (getriggert) werden. Bislang konnten wir aber noch nicht die Dauer unserer Känge steuern.

en: In order to give us a simple, yet powerful means of *controlling the duration* of our sounds, Sonic Pi provides the notion of an *ADSR amplitude envelope* (we'll cover what ADSR means later in this section). An amplitude envelope offers two useful aspects of control:
de: Dafür uns einfache und doch mächtige Mittel zur *Steuerung der Dauer* unserer Klänge zu geben, verwendet Sonic Pi den Begriff der *ADSR-Hüllkurve* (wir werden später in diesem Abschnitt die genaue Bedeutung von ADSR behandeln). Eine Hüllkurve bietet für die Steuerung zwei praktische Eigenschaften:

en: control over the duration of a sound
de: Steuerung der Dauer eines Klanges

en: control over the amplitude of a sound
de: Steuerung der Lautstärke eines Klanges

en: Duration
de: Dauer

en: The duration is the length the sound lasts for. A longer duration means that you hear the sound for longer. Sonic Pi's sounds all have a controllable amplitude envelope, and the total duration of that envelope is the duration of the sound. Therefore, by controlling the envelope you control the duration.
de: Die Dauer beschreibt, wie lange ein Klang anhält. Eine längere Dauer bedeutet, dass du den Klang länger hören kannst. Alle Klänge in Sonic Pi haben eine steuerbare Hüllkurve, und die gesamte Dauer dieser Hüllkurve bestimmt die Dauer des Klanges. Daher steuerst du mit der Dauer der Hüllkurve die Dauer des Klanges.

en: The ADSR envelope not only controls duration, it also gives you *fine control over the amplitude of the sound*. All audible sounds start and end silent and contain some non-silent part in-between. Envelopes allow you to slide and hold the amplitude of non-silent parts of the sound. It's like giving someone instructions on how to turn up and down the volume of a guitar amplifier. For example you might ask someone to "start at silence, slowly move up to full volume, hold it for a bit, then quickly fall back to silence." Sonic Pi allows you to program exactly this behaviour with envelopes.
de: Die ADSR-Hüllkurve steuert nicht nur die Dauer, sondern ermöglicht dir auch eine *genaue Kontrolle über den Verlauf der Lautstärke eines Klanges*. Alle hörbaren Klänge beginnen und enden mit Stille; alles was dazwischen liegt, ist nicht still. Hüllkurven erlauben es dir, die Lautstärke der hörbaren Anteile des Klanges zu verschieben, zu verlängern und zu verkürzen. Es ist so, als würdest du eine andere Person anweisen, wie sie mit dem Lautstärkeregler einen Gitarren-Verstärker lauter und leiser drehen soll. Du könntest sie z. B. bitten, "fang mit Stille an, dreh die Lautstärke langsam bis zum Anschlag hoch, lasse es eine Weile so und blende dann schnell runter, so dass es wieder still wird". Genau diese Anweisungen zu geben erlaubt dir Sonic Pi mit Hüllkurven.

en: Just to recap, as we have seen before, an amplitude of 0 is silence and an amplitude of 1 is normal volume.
de: Wie wir bereits gesehen haben, bedeutet eine Amplitude von 0 Stille und eine Amplitude von 1 entspricht normaler Lautstärke.

en: Now, let us look at each of the parts of the envelopes in turn.
de: Nun lasst uns auch einen Blick auf jeden einzelnen Teil einer Hüllkurve werfen.

en: Release Phase
de: Release-Zeit

en: The only part of the envelope that's used by default is the release time. This is the time it takes for the synth's sound to fade out. All synths have a release time of 1 which means that by default they have a duration of 1 beat (which at the default BPM of 60 is 1 second):
de: Der einzige Teil der Hüllkurve den Sonic Pi standardmäßig einsetzt ist die Release-Zeit. Das ist die Dauer mit der ein Synth-Klang ausklingt. Alle Synths haben eine Release-Zeit von 1, was bedeutet, dass sie eine Dauer von 1 Beat haben (beim Standard-BPM-Wert 60 entspricht das genau 1 Sekunde):

en: The note will be audible for 1 second. Go ahead and time it :-) This is short hand for the longer more explicit version:
de: Diesen Ton wirst du 1 Sekunde lang hören. Probiere es aus und stoppe die Zeit :-) Dies ist die Kurzform der etwas längeren, ausführlichen Variante:

en: Notice how this sounds exactly the same (the sound lasts for one second). However, it's now very easy to change the duration by modifying the value of the `release:` opt:
de: Achte darauf, wie dieser Ton exakt gleich klingt (der Klang ist eine Sekunden lang zu hören). Aber jetzt ist es sehr einfach die Dauer über die `release:`-Option zu verändern:

en: We can make the synth sound for a very short amount of time by using a very small release time:
de: Wir können den Synth mit einer sehr kurzen Release-Zeit sehr kurz klingen lassen:

en: The duration of the release of the sound is called the *release phase* and by default is a linear transition (i.e. a straight line). The following diagram illustrates this transition:
de: Die Dauer des Ausklingens eines Klangs wird *Release-Zeit* (*release phase*) genannt. Standardmäßig bedeutet dies ein lineares Ausklingen (das entspricht einer gerade Linie). Das folgende Diagramm zeigt diesen Übergang:

en: The vertical line at the far left of the diagram shows that the sound starts at 0 amplitude, but goes up to full amplitude immediately (this is the attack phase which we'll cover next). Once at full amplitude it then moves in a straight line down to zero taking the amount of time specified by `release:`. *Longer release times produce longer synth fade outs.*
de: Die senkrechte Linie ganz links im Bild zeigt, dass der Klang mit einer Amplitude von 0 startet, jedoch sofort auf die volle Höhe geht (das ist die Attack-Zeit, die wir gleich behandeln werden). Wenn die volle Höhe erreicht ist, geht die Amplitude in einer geraden Linie bis auf Null zurück, wobei dies so lange dauert, wie es mit `release` festgelegt wurde. *Lange Release-Zeiten erzeugen ein langes Ausklingen des Synths.*

en: You can therefore change the duration of your sound by changing the release time. Have a play adding release times to your music.
de: Du kannst daher mit der Release-Zeit die Dauer eines Klanges ändern. Spiele damit - füge deiner Musik unterschiedlichen Release-Zeiten hinzu.

en: Attack Phase
de: Attack-Zeit

en: By default, the *attack phase* is 0 for all synths which means they move from 0 amplitude to 1 immediately. This gives the synth an initial percussive sound. However, you may wish to fade your sound in. This can be achieved with the `attack:` opt. Try fading in some sounds:
de: Standardmäßig ist die Attack-Zeit für alle Synths 0, das bedeutet, die Amplitude geht unmittelbar von 0 auf 1. Daher setzt der Synth mit einem perkussiven Klang ein. Du möchtest den Klang vielleicht hingegen einblenden. Dies kann mit der `attack`-Opt erreicht werden. Versuche einige Klänge einzublenden:

en: You may use multiple opts at the same time. For example for a short attack and a long release try:
de: Du kannst mehrere Opts zur gleichen Zeit anwenden. Versuche zum Beispiel für eine kurze Attack-Zeit und eine lange Release-Zeit:

en: This short attack and long release envelope is illustrated in the following diagram:
de: Diese Hüllkurve mit einer kurzen Attack-Zeit und langer Release-Zeit sieht so aus:

en: ![attack release envelope](../../../etc/doc/images/tutorial/env-attack-release.png)
de: ![Anklingen und Abklingen](../../../etc/doc/images/tutorial/env-attack-release.png)

en: Of course, you may switch things around. Try a long attack and a short release:
de: Du kannst es natürlich auch anders herum machen. Probiere eine lange Attack-Zeit und eine kurze Release-Zeit aus:

en: ![long attack short release envelope](../../../etc/doc/images/tutorial/env-long-attack-short-release.png)
de: ![Langsames Anklingen, kurzes Abklingen](../../../etc/doc/images/tutorial/env-long-attack-short-release.png)

en: Finally, you can also have both short attack and release times for shorter sounds.
de: Letztlich kannst du auch eine kurze Attack- und Release-Zeit verwenden - für kürzere Klänge.

en: ![short attack short release envelope](../../../etc/doc/images/tutorial/env-short-attack-short-release.png)
de: ![Kurzes Anklingen, kurzes Abklingen](../../../etc/doc/images/tutorial/env-short-attack-short-release.png)

en: Sustain Phase
de: Sustain-Zeit

en: In addition to specifying attack and release times, you may also specify a sustain time to control the *sustain phase*. This is the time for which the sound is maintained at full amplitude between the attack and release phases.
de: Zusätzlich zu Attack- und Release-Zeiten kannst du auch eine Sustain-Zeit bestimmen. Diese ist die Zeitdauer, über die der Klang anhält, wenn er die eingestellte Lautstärke erreicht hat, also zwischen der Attack- und den Release-Phase.

en: ![ASR envelope](../../../etc/doc/images/tutorial/env-attack-sustain-release.png)
de: ![ASR Hüllkurve](../../../etc/doc/images/tutorial/env-attack-sustain-release.png)

en: The sustain time is useful for important sounds you wish to give full presence in the mix before entering an optional release phase. Of course, it's totally valid to set both the `attack:` and `release:` opts to 0 and just use the sustain to have absolutely no fade in or fade out to the sound. However, be warned, a release of 0 can produce clicks in the audio and it's often better to use a very small value such as 0.2.
de: Die Sustain-Zeit ist nützlich für wichtige Klänge, die du in einem Mix hervorheben willst, bevor sie eine optionale Release-Phase erreichen. Natürlich ist es ebenso möglich sowohl den Wert für `attack:` als auch den für `release:` auf 0 zu setzen und nur den Sustain zu gebrauchen - ohne Ein- und Ausblendung. Aber Achtung, eine Release-Zeit von 0 kann hörbare Klickgeräusche verursachen, und es ist meist besser einen sehr kleinen Wert wie z. B. 0.2 zu verwenden.

en: Decay Phase
de: Decay-Zeit

en: For an extra level of control, you can also specify a decay time. This is a phase of the envelope that fits between the attack and sustain phases and specifies a time where the amplitude will drop from the `attack_level:` to the `decay_level:` (which unless you explicitly set it will be set to the `sustain_level:`). By default, the `decay:` opt is 0 and both the attack and sustain levels are 1 so you'll need to specify them for the decay time to have any effect:
de: Auf einer weiteren Ebene kannst du auch eine Decay-Zeit festlegen. Das ist eine Phase innerhalb der Hüllkurve, die zwischen der Attack- und der Release-Phase liegt. Die Decay-Zeit legt die Dauer der Phase fest, in der die Amplitude abfällt - von `attack_level:` zu `decay_level:` (welches zunächst den gleichen Wert hat wie `sustain_level:`, solange du den Wert für `decay_level:` nicht ausdrücklich vorgibst). Standardmäßig steht die Opt `decay:` auf 0, und sowohl Attack- als auch das Sustain-Level stehen auf 1. Damit die Decay-Zeit einen hörbaren Effekt hat, musst du diese Pegel (Level) festlegen:

en: ![ADSR envelope](../../../etc/doc/images/tutorial/env-attack-decay-sustain-release.png)
de: ![ADSR Hüllkurve](../../../etc/doc/images/tutorial/env-attack-decay-sustain-release.png)

en: Decay Level
de: Decay-Level

en: One last trick is that although the `decay_level:` opt defaults to be the same value as `sustain_level:` you can explicitly set them to different values for full control over the envelope. This allows you to to create envelopes such as the following:
de: Ein weiterer Trick besteht darin, auch die Option `decay_level:` ausdrücklich auf einen anderen Wert zu setzen, da `decay_level:` ansonsten automatisch den Wert von `sustain_level:` erhält. So erlangst du die vollständige Kontrolle über die Hüllkurve. Du kannst nun Hüllkurven wie die folgende erzeugen:

en: ![ASR envelope](../../../etc/doc/images/tutorial/env-decay-level.png)
de: ![ASR Hüllkurve](../../../etc/doc/images/tutorial/env-decay-level.png)

en: It's also possible to set the `decay_level:` to be higher than `sustain_level:`:
de: Es ist auch möglich für `decay_level:` ein höherer Wert als für `sustain_level:` zu setzen:

en: ![ASR envelope](../../../etc/doc/images/tutorial/env-decay-level-2.png)
de: ![ASR Hüllkurve](../../../etc/doc/images/tutorial/env-decay-level-2.png)

en: ADSR Envelopes
de: ADSR-Hüllkurven

en: So to summarise, Sonic Pi's ADSR envelopes have the following phases:
de: Fassen wir zusammen: Die ADSR-Hüllkurven von Sonic Pi bestehen aus den folgenden Phasen:

en: *attack* - time from 0 amplitude to the `attack_level`,
de: *Attack* - die Zeit in der die Amplitude von 0 zu `attack_level` übergeht,

en: *decay* - time to move amplitude from `attack_level` to `decay_level`,
de: *Decay* - die Zeit in der die Amplitude von `attack_level` zu `sustain_level` übergeht,

en: *sustain* - time to move the amplitude from `decay_level` to `sustain_level`,
de: *Sustain* - die Zeit in der die Amplitude von `decay_level` zu `sustain_level` übergeht,

en: *release* - time to move amplitude from `sustain_level` to 0
de: *Release* - die Zeit in der die Amplitude von `sustain_level` auf 0 übergeht

en: It's important to note that the duration of a sound is the summation of the times of each of these phases. Therefore the following sound will have a duration of 0.5 + 1 + 2 + 0.5 = 4 beats:
de: Es ist wichtig festzuhalten, dass die Dauer eines Klanges der Summe der Zeiten jeder einzelnen dieser Phasen entspricht. Daher hat der folgende Klang eine Dauer von 0.5 + 1 + 2 + 0.5 = 4 Schlägen (Beats):

en: Now go and have a play adding envelopes to your sounds...
de: Nun leg los und spiele ein wenig damit herum deinen Klängen Hüllkurven hinzuzufügen...

en: Another great way to develop your music is to use pre-recorded sounds. In great hip-hop tradition, we call these pre-recorded sounds *samples*. So, if you take a microphone outside, go and record the gentle sound of rain hitting canvas, you've just created a sample.
de: Eine weitere großartige Möglichkeit deine Musik zu entwickeln stellt die Verwendung bereits aufgenommener Klänge dar. In der großen Tradition des Hip-Hop nennen wir diese aufgenommenen Klänge auch *Samples*. Wenn du mit einem Mikrophon nach draußen gehst und den zarten Klang von Regentropfen aufnimmst, die auf ein Zeltdach fallen - dann hast du ein Sample hergestellt.

en: Sonic Pi lets you do lots of fun things with samples. Not only does it ship with 130 public domain samples ready for you to jam with, it lets you play and manipulate your own. Let's get to it...
de: Mit Samples kannst du in Sonic Pi viele spaßige Sachen machen. Es hat nicht nur über 130 freie Samples mit an Bord, mit denen du sofort jammen kannst, du kannst auch eigene Samples verwenden und manipulieren. Legen wir damit los...

en: 3.1 Triggering Samples
de: 3.1 Samples ansteuern

en: Triggering Samples
de: Samples ansteuern

en: Playing beeps is only the beginning. Something that's a lot of fun is triggering pre-recorded samples. Try it:
de: Bleeps zu spielen ist nur der Anfang. Was auch eine Menge Spaß macht, ist mit aufgenommenen Samples zu spielen. Probier's mal:

en: Sonic Pi includes many samples for you to play with. You can use them just like you use the `play` command. To play multiple samples and notes just write them one after another:
de: Sonic Pi enthält viele Samples, mit denen du spielen kannst. Du kannst sie genauso benutzen wie du das `play`-Kommando benutzt. Um mehrere Samples gleichzeitig zu spielen, schreib sie einfach untereinander:

en: If you want to space them out in time, use the `sleep` command:
de: Wenn du sie über die Zeit verteilt spielen willst, verwende den `sleep`-Befehl:

en: Notice how Sonic Pi doesn't wait for a sound to finish before starting the next sound. The `sleep` command only describes the separation of the *triggering* of the sounds. This allows you to easily layer sounds together creating interesting overlap effects.
de: Achte darauf, dass Sonic Pi nicht wartet, bis ein Klang beendet ist, bevor es den nächsten startet? Der `sleep`-Befehl beschreibt nur, in welchem Abstand ein Klang erneut *getriggert* (ausgelöst) wird. Dies erlaubt dir Klänge in Schichten übereinander legen und interessante Überlappungseffekte herzustellen.

en: Discovering Samples
de: Samples entdecken

en: There are two ways to discover the range of samples provided in Sonic Pi. First, you can use this help system. Click on Samples in the menu at the bottom of this help screen, choose your category and then you'll see a list of available sounds.
de: Du kannst die Samples, die Sonic Pi mitbringt, auf zwei Arten entdecken. Erstens kannst du dieses Hilfe-System benutzen. Klicke links unten im Menü auf `Samples` , wähle eine Kategorie aus und du siehst eine Liste aller darin verfügbaren Klänge.

en: Alternatively you can use the *auto-completion system*. Simply type the start of a sample group such as: `sample :ambi_` and you'll see a drop-down of sample names appear for you to select. Try the following category prefixes:
de: Alternativ kannst du das *Auto-Completion System* (Auto-Vervollständigung) verwenden. Tippe einfach den Anfang des Namens einer Sample-Kategorie, wie z. B.: `sample :ambi_`, dann klappt ein Menü mit allen dazu passenden Sample-Namen auf. Versuche einen der folgenden Anfänge von Kategorie-Namen:

en: Now start mixing samples into your compositions!
de: Jetzt leg los und mixe Samples in deine Kompositionen!

en: 3.2 Sample Parameters
de: 3.2 Sample-Parameter

en: Sample Parameters: Amp and Pan
de: Sample-Parameter: Amp und Pan

en: As we saw with synths, we can easily control our sounds with parameters. Samples support exactly the same parameterisation mechanism. Let's revisit our friends `amp:` and `pan:`.
de: Genauso wie bei den Synths können wir unsere Klänge mit Parametern steuern. Samples unterstützen genau den selben Parameter-Mechanismus. Besuchen wir unsere Freunde `amp:` und `pan:` noch einmal.

en: Amping samples
de: Samples verstärken

en: You can change the amplitude of samples with exactly the same approach you used for synths:
de: Du kannst die Amplitude (Lautstärke) von Samples genau mit der selben Methode steuern wie bei den Synths:

en: Panning samples
de: Samples pannen

en: We're also able to use the `pan:` parameter on samples. For example, here's how we'd play the amen break in the left ear and then half way through play it again through the right ear:
de: Wir können auch den `pan:`-Parameter auf Samples anwenden. Hier zum Beispiel spielen wir den Amen-Break zunächst für das linke und nach der Hälfte nochmals für das rechte Ohr:

en: Note that 0.877 is half the duration of the `:loop_amen` sample in seconds.
de: 0.877 ist genau die Hälfte der Dauer des Amen-Breaks in Sekunden.

en: Finally, note that if you set some synth defaults with `use_synth_defaults` (which we will discuss later), these will be ignored by `sample`.
de: Beachte: Wenn du mit `use_synth_defaults` Grundeinstellungen für einen Synth setzt (was wir später behandeln werden), werden diese von Samples ignoriert.

en: 3.3 Stretching Samples
de: 3.3 Samples dehnen

en: Stretching Samples
de: Samples dehnen

en: Now that we can play a variety of synths and samples to create some music, it's time to learn how to modify both the synths and samples to make the music even more unique and interesting. First, let's explore the ability to *stretch* and *squash* samples.
de: Jetzt können wir schon eine Reihe Synths und Samples spielen, um damit Musik zu machen. Es wird Zeit zu lernen, wie wir diese Synths und Samples verändern können, um unsere Musik einzigartiger und spannender zu gestalten. Als Erstes erkunden wir, wie sich Samples *strecken* und *stauchen* lassen.

en: Sample Representation
de: Samples Representation

en: Samples are pre-recorded sounds stored as numbers which represent how to move the speaker cone to reproduce the sound. The speaker cone can move in and out, and so the numbers just need to represent how far in and out the cone needs to be for each moment in time. To be able to faithfully reproduce a recorded sound the sample typically needs to store many thousands of numbers per second! Sonic Pi takes this list of numbers and feeds them at the right speed to move your computer's speaker in and out in just the right way to reproduce the sound. However, it's also fun to change the speed with which the numbers are fed to the speaker to change the sound.
de: Samples sind aufgenommene Klänge, gespeichert als eine Reihe von Zahlen, die repräsentieren wie die Lautsprechermembran sich bewegen muss, um den Klang wiederzugeben. Die Lautsprechermembran kann sich nach innen und nach außen bewegen und die Zahlen geben deshalb an, wie weit sich die Membran zu jedem Zeitpunkt nach innen oder außen bewegen muss. Um einen Klang als Aufnahme wirklichkeitsgetreu wiederzugeben, muss das Sample für jede Sekunde viele tausend Zahlen speichern! Sonic Pi nimmt diese Zahlenreihe und gibt sie in der richtigen Geschwindigkeit (sample rate) aus, um den Lautsprecher in deinem Computer genau so bewegen, dass der Klang richtig wiedergegeben wird. Es macht aber auch Spaß, die Geschwindigkeit mit der die Zahlen ausgegeben werden zu ändern, um den Klang zu verändern.

en: Changing Rate
de: Geschwindigkeit ändern

en: Let's play with one of the ambient sounds: `:ambi_choir`. To play it with the default rate, you can pass a `rate:` opt to `sample`:
de: Lass uns mit einem der Ambient-Klänge spielen: `:ambi_choir`. Um die Standard-Geschwindigkeit zu verändern kannst du die Opt `rate:` an `sample` übergeben:

en: This plays it at normal rate (1), so nothing special yet. However, we're free to change that number to something else. How about `0.5`:
de: Das Sample wird unverändert mit der Standard-Geschwindigkeit (1) abgespielt, also nichts Besonderes. Aber wir können die Zahl jederzeit verändern. Wie wär's mit `0.5`?

en: Woah! What's going on here? Well, two things. Firstly, the sample takes twice as long to play, secondly the sound is an octave lower. Let's explore these things in a little more detail.
de: Wow! Was ist denn jetzt los? Also, hier passieren zwei Dinge. Erstens braucht das Sample doppelt so lange und zweitens klingt er eine Oktave niedriger. Sehen wir uns das ein bisschen genauer an.

en: Let's stretch
de: Lasst uns stretchen

en: A sample that's fun to stretch and compress is the Amen Break. At normal rate, we might imagine throwing it into a *drum 'n' bass* track:
de: Mit dem Amen-Break-Sample macht das Strecken und Stauchen besonders viel Spaß. Bei normaler Geschwindigkeit würden wir es vielleicht in einem *Drum 'n' Bass*-Track verwenden:

en: However by changing the rate we can switch up genres. Try half speed for *old school hip-hop*:
de: Aber mit einer anderen Geschwindigkeit passt es auch zu anderen Stilen. Probiere es aus mit halber Samplerate für *Hip-Hop alter Schule*:

en: If we speed it up, we enter *jungle* territory:
de: Wenn wir es beschleunigen, erreichen wir *Jungle*-Territorium:

en: Now for our final party trick - let's see what happens if we use a negative rate:
de: Und als letzten Party-Trick - schauen wir mal, was passiert, wenn wir eine negative Rate angeben:

en: A Simple Explanation of Sample Rate
de: Eine einfache Erklärung der Samplerate

en: A useful way to think of samples is as springs. Playback rate is like squashing and stretching the spring. If you play the sample at rate 2, you're *squashing the spring* to half its normal length. The sample therefore takes half the amount of time to play as it's shorter. If you play the sample at half rate, you're *stretching the spring* to double its length. The sample therefore takes twice the amount of time to play as it's longer. The more you squash (higher rate), the shorter it gets, the more you stretch (lower rate), the longer it gets.
de: Ein nützlicher Weg ist sich Samples als Sprungfedern vorzustellen. Samplerate (auch Abtastrate) ist, als ob man die Sprungfeder zusammendrückt oder auseinanderzieht. Wenn du ein Sample mit derRate 2 abspielst, *drückst du die Feder* zusammen, bis sie nur noch die Hälfte ihrer normalen Länge hat. Das Sample braucht nur die Hälfte der Abspielzeit, weil es kürzer ist. Wenn du das Sample mit halber Rate abspielst, *ziehst du die Feder* auf ihre doppelte Länge auseinander. Das Sample braucht nun doppelt so lange, weil es länger ist. Je mehr Du quetscht (höhere Rate), desto kürzer das Sample, je mehr du streckst (geringere Rate), desto länger das Sample.

en: Compressing a spring increases its density (the number of coils per cm) - this is similar to the sample sounding *higher pitched*. Stretching the spring decreases its density and is similar to the sound having a *lower pitch*.
de: Wenn du eine Sprungfeder zusammendrückt, erhöhst du ihre Dichte (die Anzahl der Windungen je Zentimeter) - das entspricht einem Sample, das *höher klingt*. Wenn du die Sprungfeder auseinanderziehst, verringerst du ihre Dichte, entspricht das einem, das *tiefer klingt*.

en: The Maths Behind Sample Rate
de: Die Mathematik hinter der Samplerate

en: (This section is provided for those that are interested in the details. Please feel free to skip it...)
de: (Dieser Abschnitt ist für diejenigen gedacht, die an den Details interessiert sind. Er kann gerne übersprungen werden...)

en: As we saw above, a sample is represented by a big long list of numbers representing where the speaker should be through time. We can take this list of numbers and use it to draw a graph which would look similar to this:
de: Wie wir oben gesehen haben, wird ein Sample durch eine lange Reihe von Zahlen dargestellt, die der Lautsprechermembran sagen, wo sie im Verlauf der Zeit sein soll. Wir können diese Zahlenreihe nehmen, um eine Kurve zu zeichnen, die ungefähr so aussieht:

en: ![sample graph](../../../etc/doc/images/tutorial/sample.png)
de: ![Beispielhafter Kurvenverlauf](../../../etc/doc/images/tutorial/sample.png)

en: You might have seen pictures like this before. It's called the *waveform* of a sample. It's just a graph of numbers. Typically a waveform like this will have 44100 points of data per second (this is due to the Nyquist-Shannon sampling theorem). So, if the sample lasts for 2 seconds, the waveform will be represented by 88200 numbers which we would feed to the speaker at a rate of 44100 points per second. Of course, we could feed it at double rate which would be 88200 points per second. This would therefore take only 1 second to play back. We could also play it back at half rate which would be 22050 points per second taking 4 seconds to play back.
de: Vielleicht hast du Bilder wie dieses schon einmal gesehen. Das ist die *Waveform* (Wellenform) eines Samples. Es ist einfach eine Kurve aus Zahlenwerten. Typischerweise besteht eine Kurve wie diese aus 44100 Datenpunkten je Sekunde (das hat mit dem Nyquist-Shannon-Abtasttheorem zu tun). Wenn also das Sample 2 Sekunden dauert, dann wird die Kurve aus 88200 Zahlen gebildet, die wir an den Lautsprecher mit einer Rate von 44100 Datenpunkten pro Sekunde senden. Natürlich könnten wir das Sample mit der doppelten Abtastrate senden, also 88200 Datenpunkten pro Sekunde. Dann würde das Sample nur eine Sekunde lang dauern. Wir können es auch mit der halben Rate abspielen; das wären dann 22050 Datenpunkte pro Sekunde und würde 4 Sekunden dauern.

en: The duration of the sample is affected by the playback rate:
de: Die Dauer des Samples ist abhängig von der Abtastrate:

en: Doubling the playback rate halves the playback time,
de: Wird die Abtastrate verdoppelt, halbiert das die Abspielzeit,

en: Halving the playback rate doubles the playback time,
de: Wird die Abtastrate halbiert, dann verdoppelt das die Abspielzeit,

en: Using a playback rate of one fourth quadruples the playback time,
de: Eine Abtastrate von einem Viertel vervierfacht die Abspielzeit,

en: Using a playback rate of 1/10 makes playback last 10 times longer.
de: Bei Verwendung einer Abtastrate von 1/10 dauert die Abspielzeit 10 mal länger.

en: We can represent this with the formula:
de: Wir können das in einer Formel abbilden:

en: new_sample_duration = (1 / rate) * sample_duration
de: neue_sample_dauer = (1 / rate) * sample_dauer

en: Changing the playback rate also affects the pitch of the sample. The frequency or pitch of a waveform is determined by how fast it moves up and down. Our brains somehow turn fast movement of speakers into high notes and slow movement of speakers into low notes. This is why you can sometimes even see a big bass speaker move as it pumps out super low bass - it's actually moving a lot slower in and out than a speaker producing higher notes.
de: Eine Veränderung der Samplerate beeinflusst auch die Tonhöhe des Samples. Die Frequenz oder Tonhöhe einer Kurve wird dadurch bestimmt, wie schnell sie hoch und runter geht. Unser Gehirn macht aus schnellen Bewegungen einer Lautsprechermembran hohe Töne und aus langsamen tiefe Töne. Deshalb kannst du manchmal sogar sehen, wie sich ein großer Basslautsprecher bewegt, wenn er einen sehr tiefen Ton ausgibt - tatsächlich bewegt er sich dann wesentlich langsamer als ein Lautsprecher, der hohe Töne wiedergibt.

en: If you take a waveform and squash it it will move up and down more times per second. This will make it sound higher pitched. It turns out that doubling the amount of up and down movements (oscillations) doubles the frequency. So, *playing your sample at double rate will double the frequency you hear it*. Also, *halving the rate will halve the frequency*. Other rates will affect the frequency accordingly.
de: Wenn du eine Wellenform nimmst und sie zusammendrückst, wird sie in jeder Sekunde häufiger hoch und runter gehen. Das lässt den Ton höher klingen. Es zeigt sich, dass die Tonhöhe sich verdoppelt, wenn die Auf- und Abbewegungen pro Sekunde (Oszillationen) verdoppelt werden. Also, *wenn du dein Sample mit doppelter Rate abspielst, wird es auch doppelt so hoch klingen*, und anders herum wird *eine Halbierung der Rate die Frequenz halbieren*. Entsprechend werden auch andere Raten die Tonhöhe beeinflussen.

en: 3.4 Enveloped Samples
de: 3.4 Samples mit Hüllkurven

en: Enveloped Samples
de: Samples mit Hüllkurven

en: It is also possible to modify the *duration* and *amplitude* of a sample using an ADSR envelope. However, this works slightly differently to the ADSR envelope available on synths. Sample envelopes only allow you to reduce the amplitude and duration of a sample - and never to increase it. The sample will stop when either the sample has finished playing or the envelope has completed - whichever is first. So, if you use a very long `release:`, it won't extend the duration of the sample.
de: Es ist auch möglich, die *Dauer* und *Amplitude* eines Samples mit einer ADSR-Hüllkurve zu verändern. Das funktioniert jedoch ein wenig anders als bei den ADSR-Hüllkurven für Synths. Sample-Hüllkurven können die Amplitude und die Dauer eines Samples nur verringern - niemals vergrößern. Das Sample wird entweder stoppen, wenn seine normale Laufzeit vorbei ist, oder wenn die Hüllkurve des Samples endet - je nach dem was zuerst passiert. Mit einem sehr langen `release:` lässt sich die Dauer eines Samples nicht verlängern.

en: Amen Envelopes
de: Amen-Hüllkurven

en: Let's return to our trusty friend the Amen Break:
de: Kommen wir zu unserem vertrauten Freund zurück, dem Amen-Break:

en: With no opts, we hear the full sample at full amplitude. If we want to fade this in over 1 second we can use the `attack:` param:
de: Ohne Opts hören wir das Sample in seiner gesamten Länge und mit voller Lautstärke. Wenn wir es über 1 Sekunde einblenden wollen, können wir den `attack:`-Parameter verwenden:

en: For a shorter fade in, choose a shorter attack value:
de: Wähle für ein kürzeres Einblenden einen kürzeren Attack-Wert:

en: Auto Sustain
de: Auto-Sustain

en: Where the ADSR envelope's behaviour differs from the standard synth envelope is in the *sustain* value. In the standard synth envelope, the sustain defaulted to 0 unless you set it manually. With samples, the sustain value defaults to an *automagical* value - the time left to play the rest of the sample. This is why we hear the full sample when we pass no defaults. If the attack, decay, sustain and release values were all 0 we'd never hear a peep. Sonic Pi therefore calculates how long the sample is, deducts any attack, decay and release times and uses the result as your sustain time. If the attack, decay and release values add up to more than the duration of the sample, the sustain is simply set to 0.
de: Wo sich das Verhalten der ADSR-Hüllkurve von der Hüllkurve für Standard-Synths unterscheidet ist der *Sustain*-Wert. Bei der Hüllkurve für Standard-Synths steht der Sustain standardmäßig auf 0 - solange du den Wert nicht ausdrücklich setzt. Bei Samples steht der Sustain-Wert standardmäßig auf *automagical* - das ist in jedem Moment die Zeit, die es braucht, bis der Rest des Samples abgelaufen ist. Darum hören wir das Sample komplett, wenn wir keine Default-Werte übergeben. Wenn die Werte für Attack, Decay, Sustain und Release alle auf 0 stünden, würden wir keinen Pieps hören. Daher berechnet Sonic Pi, wie lange das Sample an sich dauert, zieht jegliche Werte für Attack, Decay und Release davon ab und setzt die restliche Zeit als Sustain-Wert. Wenn die Werte von Attack, Decay und Release zusammengerechnet länger dauern als das gesamte Sample, wird der Sustain-Wert einfach auf 0 gesetzt.

en: Fade Outs
de: Ausblenden

en: To explore this, let's consider our Amen break in more detail. If we ask Sonic Pi how long the sample is:
de: Um das auszuprobieren, schauen wir uns den Amen-Break im Detail an. Wenn wir Sonic Pi fragen, wie lang das Sample ist:

en: It will print out `1.753310657596372` which is the length of the sample in seconds. Let's just round that to `1.75` for convenience here. Now, if we set the release to `0.75`, something surprising will happen:
de: Wird `1.753310657596372` ausgeben, was der Länge des Sample in Sekunden entspricht. Wir runden das zur Vereinfachung auf `1.75` ab. Wenn wir nun den Release-Wert auf `0.75` setzen, wird etwas erstaunliches passieren:

en: It will play the first second of the sample at full amplitude before then fading out over a period of 0.75 seconds. This is the *auto sustain* in action. By default, the release always works from the end of the sample. If our sample was 10.75 seconds long, it would play the first 10 seconds at full amplitude before fading out over 0.75s.
de: Die erste Sekunde des Sample wird mit voller Lautstärke gespielt, danach wird über eine Periode von 0.75 Sekunden ausgeblendet. Das ist der *Auto-Sustain* in Aktion. Standardmäßig berechnet Sonic Pi den Release immer vom Ende des Samples aus gesehen. Wenn unser Sample 10.75 Sekunden lang wäre, würden die ersten 10 Sekunden in voller Lautstärke gespielt, bevor über 0.75 Sekunden das Ausblenden erfolgt.

en: Remember: by default, `release:` fades out at the end of a sample.
de: Merke: Normalerweise blendet `release:` das Ende des Sample aus.

en: Fade In and Out
de: Ein- und Ausblenden

en: We can use both `attack:` and `release:` together with the auto sustain behaviour to fade both in and out over the duration of the sample:
de: Wir können beide, `attack:` und `release:`, gemeinsam mit dem Auto-Sustain nutzen, um über die Dauer des Samples ein- und auszublenden:

en: As the full duration of the sample is 1.75s and our attack and release phases add up to 1.5s, the sustain is automatically set to 0.25s. This allows us to easily fade the sample in and out.
de: Da die Gesamtdauer des Sample 1.75s beträgt und unsere Attack- und Release-Phasen zusammen 1.5s ergeben, erhält die Sustain-Phase automatisch eine Länge von 0.25s. So ist es ganz einfach, das Sample ein- und auszublenden.

en: Explicit sustain
de: Ausdrücklicher Sustain

en: We can easily get back to our normal synth ADSR behaviour by manually setting `sustain:` to a value such as 0:
de: Wir können ohne weiteres wieder das normale Synth-ADSR-Verhalten aktivieren, indem wir `sustain:` auf den Wert 0 setzen:

en: Now, our sample only plays for 0.75 seconds in total. With the default for `attack:` and `decay:` at 0, the sample jumps straight to full amplitude, sustains there for 0s then releases back down to 0 amplitude over the release period - 0.75s.
de: Jetzt spielt unser Sample insgesamt nur für 0.75 Sekunden. Mit dem Standardwert 0 für `attack:` und `decay:` springt das Sample direkt auf die volle Lautstärke, bleibt dort für 0s und fällt dann innerhalb der Release-Phase mit einer Dauer von 0.75s auf die Lautstärke 0 ab.

en: Percussive cymbals
de: Perkussive Becken

en: We can use this behaviour to good effect to turn longer sounding samples into shorter, more percussive versions. Consider the sample `:drum_cymbal_open`:
de: Wir können dieses Verhalten gut dazu benutzen, um länger klingende Samples in kürzere, perkussivere Versionen zu verwandeln. Sieh dir das Sample `:drum_cymbal_open` an:

en: You can hear the cymbal sound ringing out over a period of time. However, we can use our envelope to make it more percussive:
de: Du kannst hören, wie das Becken eine Zeit lang ausklingt. Mit einer leicht veränderten Hüllkurve können wir es perkussiver klingen lassen:

en: You can then emulate hitting the cymbal and then dampening it by increasing the sustain period:
de: Du kannst den Eindruck eines Anschlagens und Abdämpfens des Beckens erzeugen, indem du die Sustain-Phase erhöhst:

en: Now go and have fun putting envelopes over the samples. Try changing the rate too for really interesting results.
de: Jetzt versuche Hüllkurven über Samples zu legen. Verändere auch die Samplerate - damit kannst du wirklich interessante Ergebnisse erzielen.

en: 3.5 Partial Samples
de: 3.5 Teil-Samples

en: Partial Samples
de: Teil-Samples

en: This section will conclude our exploration of Sonic Pi's sample player. Let's do a quick recap. So far we've looked at how we can trigger samples:
de: Dieser Abschnitt schließt unsere Erkundung von Sonic Pi's Sample-Player ab. Fassen wir noch einmal zusammen. Wir haben uns angesehen, wie wir Samples abspielen können:

en: We then looked at how we can change the rate of samples such as playing them at half speed:
de: Dann haben wir gesehen, dass wir die Samplerate ändern können - etwa um ein Sample mit halber Geschwindigkeit abzuspielen:

en: Next, we looked at how we could fade a sample in (let's do it at half speed):
de: Als nächstes haben wir einen Blick darauf geworfen, wie wir ein Sample ein- und ausblenden können (z. B. mit halber Geschwindigkeit):

en: We also looked at how we could use the start of a sample percussively by giving `sustain:` an explicit value and setting both the attack and release to be short values:
de: Wir haben uns auch angeschaut, wie wir einen Sample-Anfang perkussiver klingen lassen können, indem wir `sustain:` ausdrücklich einen Wert zuweisen, und sowohl Attack als auch Release auf kurze Werte setzen:

en: However, wouldn't it be nice if we didn't have to always start at the beginning of the sample? Wouldn't it also be nice if we didn't have to always finish at the end of the sample?
de: Wäre es aber nicht toll, wenn wir ein Sample nicht immer vom Anfang starten lassen müssten? Wäre es nicht auch toll, wenn wir das Sample nicht immer erst am Ende stoppen könnten?

en: Choosing a starting point
de: Einen Startpunkt bestimmen

en: It is possible to choose an arbitrary starting point in the sample as a value between 0 and 1 where 0 is the start of the sample, 1 is the end and 0.5 is half way through the sample. Let's try playing only the last half of the amen break:
de: Es ist möglich einen beliebigen Startpunkt in einem Sample als Wert zwischen 0 und 1 auszuwählen. Dabei ist 0 der Anfang, 1 das Ende und 0.5 die Mitte des Samples. Versuchen wir also jetzt nur die zweite Hälfte des Amen Break zu spielen:

en: How about the last quarter of the sample:
de: Wie wäre es mit nur dem letzten Viertel des Samples:

en: Choosing a finish point
de: Einen Endpunkt bestimmen

en: Similarly, it is possible to choose an arbitrary finish point in the sample as a value between 0 and 1. Let's finish the amen break half way through:
de: Auf ähnliche Weise können wir mit einem Wert zwischen 0 und 1 einen beliebigen Endpunkt im Sample festlegen. Beenden wir den Amen-Break nach der ersten Hälfte:

en: Specifying start and finish
de: Start- und Endpunkt bestimmen

en: Of course, we can combine these two to play arbitrary segments of the audio file. How about only a small section in the middle:
de: Natürlich können wir diese beiden auch kombinieren, um so einen beliebigen Abschnitt des Samples abzuspielen. Wie wäre es mit nur einem kurzen Abschnitt in der Mitte:

en: What happens if we choose a start position after the finish position?
de: Was passiert, wenn wir eine Startposition hinter der Endposition auswählen?

en: Cool! It plays it backwards!
de: Cool! Es spielt rückwärts!

en: Combining with rate
de: Kombinieren mit Samplerate

en: We can combine this new ability to play arbitrary segments of audio with our friend `rate:`. For example, we can play a very small section of the middle of the amen break very slowly:
de: Wir können diese neue Fähigkeit, beliebige Abschnitte eines Klangs zu spielen, unserem Freund `rate:` kombinieren. Zum Beispiel können wir einen sehr kurzen Abschnitt des Amen-Breaks sehr langsam spielen:

en: Combining with envelopes
de: Kombinieren mit Hüllkurven

en: Finally, we can combine all of this with our ADSR envelopes to produce interesting results:
de: Und schließlich können wir all dies mit unseren ADSR-Hüllkurven kombinieren, um interessante Ergebnisse hervorzubringen:

en: Now go and have a play mashing up samples with all of this fun stuff...
de: Jetzt leg los und vermansche Samples mit all diesem spaßigen Zeug...

en: 3.6 External Samples
de: 3.6 Externe Samples

en: External Samples
de: Externe Samples

en: Whilst the built-in samples can get you up and started quickly, you might wish to experiment with other recorded sounds in your music. Sonic Pi totally supports this. First though, let's have a quick discussion on the portability of your piece.
de: Während die mitgelieferten Samples die schnell an den Start bringen und loslegen lassen, möchtest du vielleicht aber mit anderen aufgenommenen Klängen in deiner Musik experimentieren. Sonic Pi unterstützt das ausdrücklich. Lass uns aber zunächst über die Übertragbarkeit deines Stücks sprechen.

en: Portability
de: Übertragbarkeit

en: When you compose your piece purely with built-in synths and samples, the code is all you need to faithfully reproduce your music. Think about that for a moment - that's amazing! A simple piece of text you can email around or stick in a [Gist](https://gist.github.com) represents everything you need to reproduce your sounds. That makes it *really easy to share* with your friends as they just need to get hold of the code.
de: Wenn du dein Stück nur basierend auf den eingebauten Synths und Samples komponierst, braucht es nur den Code, um deine Musik originalgetreu wiederzugeben. Denke einen Augenblick darüber nach - das ist erstaunlich! Ein einfaches Stück Text, das du per E-Mail herumschicken oder in einem [Gist](https://gist.github.com) ablegen kannst, repräsentiert alles, was du brauchst, um deine Klänge zu reproduzieren. *Das macht es sehr einfach mit deinen Freunden zu teilen.* Sie brauchen nur den Code von dir.

en: However, if you start using your own pre-recorded samples, you lose this portability. This is because to reproduce your music other people not only need your code, they need your samples too. This limits the ability for others to manipulate, mash-up and experiment with your work. Of course this shouldn't stop you from using your own samples, it's just something to consider.
de: Wie auch immer, wenn du anfängst selbst aufgenommene Samples zu verwenden, verlierst du diese Übertragbarkeit. Das liegt daran, dass die Leute, um deine Musik zu reproduzieren nicht nur den Code, sondern auch deine Samples benötigen. Das schränkt die Möglichkeit für andere ein, mit deiner Arbeit zu experimentieren, sie zu verändern, sie zu vermanschen (mash-up). Natürlich sollte dich das nicht davon abhalten deine eigenen Samples zu verwenden, es ist nur etwas, das du in deine Überlegungen einbeziehen solltest.

en: Local Samples
de: Lokale Samples

en: Sonic Pi will automatically load and play the sample. You can also pass all the standard params you're used to passing `sample`:
de: Sonic Pi wird das Sample nun automatisch laden und spielen. Du kannst auch all die Standard-Parameter, die du bereits kennst, an `sample` übergeben:

en: 3.7 Sample Packs
de: 3.7 Sample-Pakete

en: Sample Packs
de: Sample-Pakete

en: **Note: this section of the tutorial covers the advanced topic of working with large directories of your own samples. This will be the case if you've downloaded or bought your own sample packs and wish to use them within Sonic Pi.**
de: **Hinweis: Dieser Abschnitt des Tutorials behandelt das fortgeschrittene Thema der Arbeit mit großen Verzeichnissen deiner eigenen Samples. Dies wird nützlich sein, wenn du deine eigenen Sample Packs heruntergeladen oder gekauft hast und diese in Sonic Pi nutzen möchtest.**

en: **Feel free to skip this if you're happy working with the built-in samples.**
de: **Überspringe diesen Abschnitt, wenn dir die mitgelieferten Samples für die Arbeit ausreichen.**

en: When working with large folders of external samples it can be cumbersome to have to type the whole path every time to trigger an individual sample.
de: Wenn du mit großen Ordnern mit externen Samples arbeitest, kann es mühselig sein, jedes Mal den vollständigen Pfad eingeben zu müssen, um ein bestimmtes Sample abzuspielen.

en: For example, say you have the following folder on your machine:
de: Sagen wir, du hast zum Beispiel folgenden Ordner auf deinem Computer:

en: /path/to/my/samples/
de: /pfad/zu/meinen/samples/

en: When we look inside that folder we find the following samples:
de: Wenn wir in diesen Ordner schauen, finden wir die folgenden Samples:

en: Typically in order to play the piano sample we can use the full path:
de: Üblicherweise können wir den vollständigen Pfad nutzen um das Piano-Sample abzuspielen:

en: sample "/path/to/my/samples/120_Bb_piano1.wav"
de: sample "/pfad/zu/meinen/samples/120_Bb_piano1.wav"

en: If we want to then play the guitar sample we can use its full path too:
de: Wenn wir dann das Gitarren-Sample abspielen wollen, können wir ebenfalls den vollständigen Pfad nutzen:

en: sample "/path/to/my/samples/120_Bb_guit.wav"
de: sample "/pfad/zu/meinen/samples/120_Bb_guit.wav"

en: However, both of these calls to sample requires us to *know* the names of the samples within our directory. What if we just want to listen to each sample in turn quickly?
de: Wie auch immer, beide Aufrufe verlangen von uns, dass wir die Namen der Samples innerhalb des Verzeichnisses *kennen*. Was, wenn wir einfach nur schnell die einzelnen Samples nacheinander abhören wollen?

en: Indexing Sample Packs
de: Sample-Packs indizieren

en: If we want to play the first sample in a directory we just need to pass the directory's name to `sample` and the index `0` as follows:
de: Wenn wir das erste Sample in einem Verzeichnis abspielen wollen, müssen wir nur den Verzeichnisnamen an `sample` und den Index `0` eingeben. Folgendermaßen:

en: sample "/path/to/my/samples/", 0
de: sample "/pfad/zu/meinen/samples/", 0

en: We can even make a shortcut to our directory path using a variable:
de: Wir können sogar eine Verknüpfung zu unserem Verzeichnispfad anlegen, indem wir eine Variable nutzen:

en: samps = "/path/to/my/samples/"
    sample samps, 0
de: samps = "/pfad/zu/meinen/samples/"
    sample samps, 0

en: Now, if we want to play the second sample in our directory, we just need to add 1 to our index:
de: Wenn wir nun das zweite Sample in unserem Verzeichnis abspielen wollen, müssen wir lediglich 1 zu unserem Index hinzufügen:

en: samps = "/path/to/my/samples/"
    sample samps, 1
de: samps = "/pfad/zu/meinen/samples/"
    sample samps, 1

en: Notice that we no longer need to know the names of the samples in the directory - we just need to know the directory itself (or have a shortcut to it). If we ask for an index which is larger than the number of samples, it simply wraps round just like Rings. Therefore, whatever number we use we're guaranteed to get one of the samples in that directory.
de: Beachte, dass wir nicht mehr die Namen der Samples im Verzeichnis kennen müssen - wir müssen nur das Verzeichnis selbst kennen (oder eine Verknüpfung dort hin). Wenn wir nach einer Index-Zahl fragen, die größer ist als die Anzahl an Samples, fängt die Liste einfach von vorne an - wie bei Ringen. Also egal welche Index-Zahl wir nutzen, es ist garantiert, dass wir eines der Samples aus dem Verzeichnis bekommen.

en: Filtering Sample Packs
de: Sample-Packs filtern

en: Usually indexing is enough, but sometimes we need more power to sort and organise our samples. Luckily many sample packs add useful information in the filenames. Let's take another look at the sample file names in our directory:
de: Gewöhnlich reicht das Indizieren aus, aber manchmal benötigen wir machtvollere Mittel, um unsere Samples zu organisieren. Glücklicherweise packen viele Sample-Packs nützliche Informationen in die Dateinamen. Lass uns einen weiteren Blick auf die Dateinamen der Samples in unserem Verzeichnis werfen:

en: Notice that in these filenames we have quite a bit of information. Firstly, we have the BPM of the sample (beats per minute) at the start. So, the piano sample is at 120 BPM and our first three melodies are at 100 BPM. Also, our sample names contain the key. So the guitar sample is in Bb and the melodies are in A#. This information is very useful for mixing in these samples with our other code. For example, we know we can only play the piano sample with code that's in 120 BPM and in the key of Bb.
de: Achte darauf, dass In diesen Dateinamen einiges an Informationen enthalten ist. Zuerst haben wir die BPM ("beats per minute") des Samples am Beginn. D.h. das Piano-Sample ist in 120 BPM und unsere ersten drei Melodien sind in 100 BPM. Außerdem steht in den Sample-Namen die Tonart. Das Gitarren-Sample ist in Bb, und die Melodien sind in A#. Diese Information ist für das Mixen der Samples mit unserem Code sehr wichtig. Zum Beispiel wissen wir, dass wir das Piano-Sample nur mit Code verwenden können, der 120 BPM und die Tonart Bb hat.

en: It turns out that we can use this particular naming convention of our sample sets in the code to help us filter out the ones we want. For example, if we're working at 120 BPM, we can filter down to all the samples that contain the string `"120"` with the following:
de: Es stellt sich heraus, dass wir dies spezielle Namensgebung unserer Sample-Sets im Code nutzen können, um die Samples herauszufiltern, die wir wollen. Wenn wir zum Beispiel mit 120 BPM arbeiten, können wir mit folgendem Code alle Samples filtern, deren Name den String `"120"` enthält:

en: samps = "/path/to/my/samples/"
    sample samps, "120"
de: samps = "/pfad/zu/meinen/samples/"
    sample samps, "120"

en: This will play us the first match. If we want the second match we just need to use the index:
de: Dieser Code wird uns das erste passende Sample abspielen. Wenn wir das zweite passende Sample abspielen wollen, müssen wir nur eine Index-Zahl nutzen:

en: samps = "/path/to/my/samples/"
    sample samps, "120", 1
de: samps = "/pfad/zu/meinen/samples/“
    sample samps, "120", 1

en: We can even use multiple filters at the same time. For example, if we want a sample whose filename contains both the substrings `"120"` and `"A#"` we can find it easily with the following code:
de: Wir können sogar mehrere Filter gleichzeitig nutzen. Wenn wir ein Sample wollen, dessen Name sowohl den String `"120"` als auch den String `"A#"` enthält, können wir das leicht mit dem folgenden Code erreichen:

en: samps = "/path/to/my/samples/"
    sample samps, "120", "A#"
de: samps = "/pfad/zu/meinen/samples/"
    sample samps, "120", "A#"

en: Finally, we're still free to add our usual opts to the call to `sample`:
de: Schließlich können wir auch noch unsere üblichen Optionen dem `sample`-Aufruf anhängen:

en: samps = "/path/to/my/samples/"
    sample samps, "120", "Bb", 1, lpf: 70, amp: 2
de: samps = "/pfad/zu/meinen/samples/"
    sample samps, "120", "Bb", 1, lpf: 70, amp: 2

en: Sources
de: Quellen

en: The sample filter pre-arg system understands two types of information: *sources* and *filters*. Sources are information used to create the list of potential candidates. A source can take two forms:
de: Das Filter-System für Samples versteht zwei Typen von Informationen: Quellen und Filter. Quellen sind Informationen, um eine Liste möglicher Kandidaten zu versammeln. Eine Quelle kann in zwei Formen angegeben werden:

en: `"/path/to/samples"` - a string representing a valid path to a directory
de: "/pfad/zu/samples" - eine Zeichenkette (string), die einen gültigen Pfad zu einem Verzeichnis angibt

en: `"/path/to/samples/foo.wav"` - a string representing a valid path to a sample
de: "/pfad/zu/samples/foo.wav" - eine Zeichenkette (string), die einen gültigen Pfad zu einem Sample angibt

en: For example, take a look at the following code:
de: Schau Dir z. B. den folgenden Code an:

en: samps = "/path/to/my/samples/"
    samps2 = "/path/to/my/samples2/"
    path = "/path/to/my/samples3/foo.wav"
    sample samps, samps2, path, 0
de: samps = "/pfad/zu/meinen/samples/"
    samps2 = "/pfad/zu/meinen/samples2/"
    path = "/pfad/zu/meinen/samples3/foo.wav"
    sample samps, samps2, path, 0

en: Here, we're combining the contents of the samples within two directories and adding a specific sample. If `"/path/to/my/samples/"` contained 3 samples and `"/path/to/my/samples2/"` contained 12, we'd have 16 potential samples to index and filter (3 + 12 + 1).
de: Hier kombinieren wir alle Samples aus zwei Verzeichnissen und fügen noch ein einzelnes Sample hinzu. Wenn `"/pfad/zu/meinen/samples/"` 3 Samples und `"/path/to/my/samples2/"` 12 Samples enthielte, hätten wir insgesamt 16 mögliche Samples, die wir indexieren und filtern können (3 + 12 + 1).

en: By default, only the sample files within a directory are gathered into the candidate list. Sometimes you might have a number of nested folders of samples you wish to search and filter within. You can therefore do a recursive search for all samples within all subfolders of a particular folder by adding `**` to the end of the path:
de: Standardmäßig werden nur die Sample-Dateien des angegebenen Verzeichnisses in der Kandidatenliste gesammelt. Manchmal möchtest du vielleicht eine ganze Reihe ineinander verschachtelter Ordner mit Samples durchsuchen und filtern. Das kannst du mit einer rekursiven Suche nach allen Samples in allen Unterordnern erreichen, indem du `**` an das Ende des Pfads hängst:

en: Take care though as searching through a very large set of folders may take a long time. However, the contents of all folder sources are cached, so the delay will only happen the first time.
de: Beachte jedoch, dass eine Suche über viele Verzeichnisse hinweg viel Zeit in Anspruch nehmen kann. Allerdings wird der Inhalt aller Ordner, die du als Quellen angegeben hast, zwischengespeichert - die Verzögerung wird also nur bei der ersten Suche auftreten.

en: Finally, note that the sources *must go first*. If no source is given, then the set of built-in samples will be selected as the default list of candidates to work with.
de: Ein wichtiger Punkt zum Abschluss: Die Quelle *muss als erstes angegeben werden*. Wenn keine Quelle angegeben wird, werden die mitgelieferten Samples als die Standardliste der Kandidaten ausgewählt, mit denen du dann weiter arbeitest.

en: Filters
de: Filter

en: Once you have a list of candidates you may use the following filtering types to further reduce the selection:
de: Wenn du erst einmal eine Kandidatenliste hast, kannst du die folgenden Filtertypen nutzen, um die Auswahl weiter einzugrenzen:

en: `"foo"` Strings will filter on substring occurrence within file name (minus directory path and extension).
de: `"foo"` filtert alle Dateinamen, in denen diese Zeichenkette vorkommt (abzüglich des Verzeichnispfades und der Dateiendung).

en: `/fo[oO]/` Regular Expressions will filter on pattern matching of file name (minus directory path and extension).
de: `/fo[oO]/` filtert alle Dateinamen, die diesem regulären Ausdruck entsprechen (abzüglich des Verzeichnispfades und der Dateiendung).

en: `:foo` - Keywords will filter candidates on whether the keyword is a direct match of the filename (minus directory path and extension).
de: `:foo` - filtert alle Kandidaten, bei denen dieses Schlüsselwort genau dem Dateinamen entspricht (abzüglich des Verzeichnispfades und der Dateiendung).

en: `lambda{|a| ... }` - Procs with one argument will be treated as a candidate filter or generator function. It will be passed the list of current candidates and must return a new list of candidates (a list of valid paths to sample files).
de: `lambda{|a| ... }` - Procs mit einem Argument werden als Filter für Kandidaten oder Generator-Funktionen behandelt. Diesem wird die Liste der aktuellen Kandidaten übergeben, und er gibt eine neue Liste von Kandidaten zurück (eine Liste gültiger Pfade zu Sample-Dateien).

en: `1` - Numbers will select the candidate with that index (wrapping round like a ring if necessary).
de: `1` - Zahlen wählen direkt den Kandidaten aus, dessen Indexposition dieser Zahl entspricht (wenn nötig wird wie bei einem Ring von vorne begonnen).

en: For example, we can filter over all the samples in a directory containing the string `"foo"` and play the first matching sample at half speed:
de: Wir können z. B. alle Samples in einem Verzeichnis herausfiltern, deren Dateinamen die Zeichenkette `"foo"` enthalten, und davon das erste passende Sample mit halber Geschwindigkeit spielen:

en: See the help for `sample` for many detailed usage examples. Note that the ordering of the filters is honoured.
de: Sieh' dir die Hilfe zu `sample` an, sie enthält viele detaillierte Anwendungsbeispiele. Achte darauf, welche Rolle die Sortierung der Filter spielt.

en: Composites
de: Verbünde

en: Finally, you may use lists wherever you may place a source or filter. The list will be automatically flattened and the contents will be treated as regular sources and filters. Therefore the following calls to `sample` are semantically equivalent:
de: Abschließend sei gesagt, dass du Listen überall verwenden kannst, wo du eine Quelle oder einen Filter einsetzt. Die Liste wird automatisch eingebettet und ihre Inhalte behandelt wie normale Quellen- oder Filterangaben. Daher sind die folgenden Aufrufe von `sample` alle gleichbedeutend:

en: Wrapping Up
de: Zum Abschluss

en: This was an advanced section for people that need real power to manipulate and use sample packs. If most of this section didn't make too much sense, don't worry. It's likely you don't need any of this functionality just yet. However, you'll know when you do need it and you can come back and re-read this when you start working with large directories of samples.
de: Das war ein fortgeschrittener Abschnitt für Leute, die machtvollere Möglichkeiten benötigen, um mit Sample-Paketen zu hantieren und sie zu nutzen. Wenn vieles davon für dich im Moment noch wenig Sinn ergeben hat, keine Sorge. Es ist gut möglich, dass du vieles davon jetzt noch nicht brauchst. Dennoch, du wirst merken, wann du es brauchst, und du kannst zurückkommen und den Abschnitt noch einmal lesen, wenn du anfängst mit umfangreicheren Sample-Sammlungen zu hantieren.

en: 4 Randomisation
de: 4 Zufälligkeit

en: Randomisation
de: Zufälligkeit

en: A great way to add some interest into your music is using some random numbers. Sonic Pi has some great functionality for adding randomness to your music, but before we start we need to learn a shocking truth: in Sonic Pi *random is not truly random*. What on earth does this mean? Well, let's see.
de: Eine tolle Möglichkeit deine Musik interessant zu gestalten ist die Nutzung von Zufallszahlen. Sonic Pi bietet einige tolle Funktionen, um deiner Musik Zufälligkeiten hinzuzufügen. Aber bevor wir damit anfangen, musst du noch eine schockierende Wahrheit erfahren: In Sonic Pi bedeutet *zufällig nicht wirklich zufällig*. Was zum Teufel soll das heißen? Nun, das werden wir sehen.

en: Repeatability
de: Wiederholbarkeit

en: A really useful random function is `rrand` which will give you a random value between two numbers - a *min* and a *max*. (`rrand` is short for ranged random). Let's try playing a random note:
de: Eine wirklich nützliche Zufallsfunktion ist `rrand`. Sie liefert dir einen zufälligen Wert zwischen zwei Zahlen - einem *Minimal-* und einem *Maximalwert* - (`rrand` ist ein Kürzel für *ranged random*, also eine Zufallszahl aus einem bestimmten Zahlenbereich). Versuchen wir mal eine zufällig ausgewählte Note zu spielen:

en: Ooh, it played a random note. It played note `83.7527`. A nice random note between 50 and 95. Woah, wait, did I just predict the exact random note you got too? Something fishy is going on here. Try running the code again. What? It chose `83.7527` again? That can't be random!
de: Oh, es hat eine zufällige Note gespielt. Es hat Note `83.7527`gespielt. Eine nette zufällige Note zwischen 50 und 100. Aber halt, habe ich gerade diese angeblich zufällige Note exakt bestimmt? Da ist doch etwas nicht ganz sauber. Lasse den Programm-Code noch einmal laufen. Wie bitte? Es hat wieder `83.7527`gewählt? Das kann kein Zufall sein!

en: The answer is that it is not truly random, it's pseudo-random. Sonic Pi will give you random-like numbers in a repeatable manner. This is very useful for ensuring that the music you create on your machine sounds identical on everybody else's machine - even if you use some randomness in your composition.
de: Die Antwort ist, es ist nicht wirklich zufällig, es ist pseudo-zufällig. Sonic Pi liefert dir zufallsähnliche Zahlen, die sich wiederholen. Das ist sehr nützlich, um sicherzustellen, dass die Musik die du auf deinem Rechner erzeugst, auf jedem anderen Rechner identisch klingt - auch dann, wenn du Zufälligkeiten in deiner Komposition verwendest.

en: Of course, in a given piece of music, if it 'randomly' chose `83.7527` every time, then it wouldn't be very interesting. However, it doesn't. Try the following:
de: Klar, wenn es, in einem bestimmten Musikstück, jedes Mal 'zufällig' die `83.7527` wählen würde, dann wäre das nicht besonders interessant. Aber das tut es auch nicht. Probiere folgendes:

en: Yes! It finally sounds random. Within a given *run* subsequent calls to random functions will return random values. However, the next run will produce exactly the same sequence of random values and sound exactly the same. It's as if all Sonic Pi code went back in time to exactly the same point every time the Run button was pressed. It's the Groundhog Day of music synthesis!
de: Ja! Jetzt klingt es zufällig. Innerhalb eines gegebenen *Programmlaufes* liefern weitere Aufrufe von Zufallsfunktionen auch zufällige Werte. Trotzdem wird der nächste Programmlauf genau die selbe Abfolge von Zufallswerten liefern und entsprechend auch genau gleich klingen. Es ist als ob Sonic Pi Code immer an denselben Zeitpunkt zurückspringt, wenn der Ausführen-Schalter geklickt wird. Das ist der Murmeltier-Tag der musikalischen Synthese!

en: Haunted Bells
de: Gesiterglocken

en: A lovely illustration of randomisation in action is the haunted bells example which loops the `:perc_bell` sample with a random rate and sleep time between bell sounds:
de: Ein schönes Beispiel von Zufälligkeit in Aktion ist das Geisterglocken-Beispiel, in dem das `:perc_bell`-Sample mit einer zufälligen Samplerate und Pausenzeit zwischen den Glockenklängen abgespielt wird:

en: loop do
      sample :perc_bell, rate: rrand(0.125, 1.5)
      sleep rrand(0.2, 2)
    end
de: loop do
      sample :perc_bell, rate: (rrand 0.125, 1.5)
      sleep rrand(0.2, 2)
    end

en: Random cutoff
de: Zufällige Begrenzung

en: Another fun example of randomisation is to modify the cutoff of a synth randomly. A great synth to try this out on is the `:tb303` emulator:
de: Ein anderes unterhaltsames Beispiel für Zufälligkeit ist, einen Synth-Klang zufällig in der Tonhöhe zu begrenzen. Ein toller Synth um das auszuprobieren ist der `:tb303`-Emulator:

en: Random seeds
de: Zufallsstartpunkte

en: So, what if you don't like this particular sequence of random numbers Sonic Pi provides? Well it's totally possible to choose a different starting point via `use_random_seed`. The default seed happens to be 0, so choose a different seed for a different random experience!
de: Was, wenn dir eine bestimmte Zufallsabfolge, die Sonic Pi liefert, dir nicht gefällt? Nun, mit `use_random_seed` lässt sich sehr gut ein anderer Startpunkt für diese Zufallsabfolge wählen. Der Standard-Startpunkt ist die 0, wähle also einen anderen Startpunkt, und du machst eine andere Zufallserfahrung!

en: Consider the following:
de: Sieh dir folgenden Code an:

en: Every time you run this code, you'll hear the same sequence of 5 notes. To get a different sequence simply change the seed:
de: Jedes Mal, wenn du diesen Programm-Code laufen lässt, hörst du dieselbe Folge von 5 Noten. Um eine andere Folge zu bekommen, setze einen anderen Startpunkt:

en: This will produce a different sequence of 5 notes. By changing the seed and listening to the results you can find something that you like - and when you share it with others, they will hear exactly what you heard too.
de: Nun produziert Sonic Pi eine andere Folge aus 5 Tönen. Indem du den Startpunkt änderst und dir die Ergebnisse anhörst, kannst du eine Folge finden, die dir gefällt - und wenn du den Code an andere weitergibst, werden sie genau das hören, was auch du gehört hast.

en: Let's have a look at some other useful random functions.
de: Schauen wir uns noch einige andere nützliche Zufallsfunktionen an.

en: choose
de: Auswählen

en: A very common thing to do is to choose an item randomly from a list of known items. For example, I may want to play one note from the following: 60, 65 or 72. I can achieve this with `choose` which lets me choose an item from a list. First, I need to put my numbers in a list which is done by wrapping them in square brackets and separating them with commas: `[60, 65, 72]`. Next I just need to pass them to `choose`:
de: Eine Sache, die sehr häufig gemacht wird, ist aus einer Liste bekannter Elemente eines zufällig auszuwählen. Zum Beispiel möchte ich vielleicht einen Ton aus der folgenden Liste spielen: 60, 65 oder 72. Das kann ich mit `choose` erreichen, das mich ein Element aus einer Liste wählen lässt. Zuerst musst ich meine Zahlen in eine Liste packen, indem ich sie, durch Kommas getrennt, in eckige Klammern setze. Danach muss ich sie einfach nur an `choose` übergeben:

en: Let's hear what that sounds like:
de: Hören wir uns das mal an:

en: We've already seen `rrand`, but let's run over it again. It returns a random number between two values exclusively. That means it will never return either the top or bottom number - always something in between the two. The number will always be a float - meaning it's not a whole number but a fraction of a number. Examples of floats returned by `rrand(20, 110)`:
de: Wir haben `rrand` schon kennengelernt, aber sehen wir uns das noch einmal genauer an. Es liefert eine zufällige Zahl zwischen zwei Werten - ausschließlich dieser Werte selbst. Das bedeutet, dass weder der minimale noch der maximale Wert jemals ausgegeben werden, immer nur was zwischen den beiden liegt. Diese Zahl wird immer eine Gleitkommazahl (floating point number) sein - also keine ganze Zahl, sondern eine Bruchzahl (Erinnere dich: Computer verwenden für Rechenoperationen stets die englische Schreibweise - daher Punkt, nicht Komma!). Hier Beispiele für Gleitkommazahlen beim Aufruf von `rrand(20, 110)`:

en: Occasionally you'll want a whole random number, not a float. This is where `rrand_i` comes to the rescue. It works similarly to `rrand` except it may return the min and max values as potential random values (which means it's inclusive rather than exclusive of the range). Examples of numbers returned by `rrand_i(20, 110)` are:
de: Gelegentlich wirst du jedoch eine ganze Zahl wollen, keine Gleitkommazahl. Hier kommt `rrand_i` (*i* für englisch integer, ganze Zahl) zur Hilfe. Es funktioniert ähnlich wie `rrand`, kann jedoch auch den minimalen oder maximalen Wert als mögliche Zufallszahl liefern. (was bedeutet, dass es einschließlich der begrenzenden Werte funktioniert und nicht ausschließlich). Beispiele wären die Werte, die von `rand_i(20,110)` ausgeben werden:

en: This will return a random float between 0 (inclusive) and the max value you specify (exclusive). By default it will return a value between 0 and one. It's therefore useful for choosing random `amp:` values:
de: Dies wird eine zufällige Gleitkommazahl zwischen 0 (inklusiv) und einem von dir spezifizierten Maximalwert (exklusiv) zurückgeben. Standardmäßig wird ein Wert zwischen 0 und 1 ausgegeben. Daher ist es nützlich für eine Auswahl zufälliger Werte für `amp:`:

en: Similar to the relationship between `rrand_i` and `rrand`, `rand_i` will return a random whole number between 0 and the max value you specify.
de: Ähnlich wie im Verhältnis von `rrand_i` zu `rrand`, wird `rand_i` eine zufällige ganze Zahl zwischen 0 und dem angegebenen Maximalwert zurückgeben.

en: Sometimes you want to emulate a dice throw - this is a special case of `rrand_i` where the lower value is always 1. A call to `dice` requires you to specify the number of sides on the dice. A standard dice has 6 sides, so `dice(6)` will act very similarly - returning values of either 1, 2, 3, 4, 5, or 6. However, just like fantasy role-play games, you might find value in a 4 sided dice, or a 12 sided dice, or a 20 sided dice - perhaps even a 120 sided dice!
de: Manchmal wirst du so tun wollen, als würdest du würfeln (dice) - dies ist ein Sonderfall von `rrand_i`, bei dem der kleinste Wert immer die 1 ist. Ein Aufruf von `dice` verlangt von dir die Anzahl von Seiten zu bestimmen, die der Würfel haben soll. Ein normaler Würfel hat 6 Seiten, `dice(6)` wird dem entsprechend einen der Werte 1, 2, 3, 4, 5 oder 6 zurückgeben. Wie auch immer, in einem Rollenspiel würdest auch Nutzen in einem 4-seitigen Würfel sehen, oder einem 12-seitigen, oder einem 20-seitigen, vielleicht sogar in einem 120-seitigem!

en: Finally you may wish to emulate throwing the top score of a dice such as a 6 in a standard dice. `one_in` therefore returns true with a probability of one in the number of sides on the dice. Therefore `one_in(6)` will return true with a probability of 1 in 6 or false otherwise. True and false values are very useful for `if` statements which we will cover in a subsequent section of this tutorial.
de: Schließlich könnte es noch so sein, dass du so tun willst, als ob du beim Würfeln mit einem Standardwürfel eine 6 hast - also den höchsten Wert. `one_in` gibt dafür mit einer Wahrscheinlichkeit von 1 im Verhältnis zur Anzahl Würfelseiten den Wert wahr (true) zurück. Daher wird `one_in(6)` mit einer Wahrscheinlichkeit von 1 zu 6 wahr, ansonsten falsch (false). Wahr- und Falsch-Werte sind sehr nützlich bei `if`-Anweisungen, welche wir in einem späteren Abschnitt dieses Tutorials behandeln werden.

en: Now, go and jumble up your code with some randomness!
de: Jetzt los, bringe deinen Code mit ein wenig Zufälligkeit durcheinander!

en: 5 Programming Structures
de: 5 Programmstrukturen

en: Programming Structures
de: Programmstrukturen

en: Now that you've learned the basics of creating sounds with `play` and `sample` and creating simple melodies and rhythms by `sleep`ing between sounds, you might be wondering what else the world of code can offer you...
de: Jetzt, da du die Grundlagen für die Erzeugung von Klängen mit `play` und `sample` und die Erzeugung von Melodien und Rhythmen durch den Einsatz von `sleep` zwischen den Klängen gelernt hast, fragst du dich vielleicht, was dir die Welt des Codes darüber hinaus zu bieten hat...

en: Well, you're in for an exciting treat! It turns out that basic programming structures such as looping, conditionals, functions and threads give you amazingly powerful tools to express your musical ideas.
de: Nun, ich denke, da kommen noch einige aufregende Sachen auf dich zu! Es ist nämlich so, dass grundlegende Programmstrukturen wie Schleifen (loops), Bedingungen (conditionals), Funktionen (functions) und Stränge (threads) unglaublich machtvolle Werkzeuge sind, um deine musikalischen Ideen auszudrücken.

en: Let's get stuck in with the basics...
de: Sehen wir uns die Grundlagen eingehender an...

en: 5.1 Blocks
de: 5.1 Blöcke

en: Blocks
de: Blöcke

en: A structure you'll see a lot in Sonic Pi is the block. Blocks allow us to do useful things with large chunks of code. For example, with synth and sample parameters we were able to change something that happened on a single line. However, sometimes we want to do something meaningful to a number of lines of code. For example, we may wish to loop it, to add reverb to it, to only run it 1 time out of 5, etc. Consider the following code:
de: Eine Struktur, der du in Sonic Pi häufig begegnen wirst, ist der Block. Blöcke erlauben uns, mit größeren Abschnitten von Programm-Code nützliche Dinge zu tun. Z. B. konnten wir bisher mit Synth- und Sample-Parametern etwas verändern, das in einer einzelnen Zeile des Codes geschah. Manchmal aber möchten wir etwas Sinnvolles mit einer ganzen Abfolge von Code-Zeilen anstellen. Zum Beispiel möchten wir diese in einer Schleife ablaufen lassen, Hall hinzufügen, sie nur 1 von 5 Malen ablaufen lassen etc. Sieh dir folgenden Code an:

en: To do something with a chunk of code, we need to tell Sonic Pi where the code block *starts* and where it *ends*. We use `do` for start and `end` for end. For example:
de: Um etwas auf einen mehrzeiligen Code-Abschnitt anzuwenden, müssen wir Sonic Pi sagen, wo der Code-Block *anfängt*, und wo er *aufhört*. Wir verwenden `do` für den Anfang und `end` für das Ende. So zum Beispiel:

en: However, this isn't yet complete and won't work (try it and you'll get an error) as we haven't told Sonic Pi what we want to do with this *do/end block*. We tell Sonic Pi this by writing some special code before the `do`. We'll see a number of these special pieces of code later on in this tutorial. For now, it's important to know that wrapping your code within `do` and `end` tells Sonic Pi you wish to do something special with that chunk of code.
de: Das ist aber noch nicht vollständig und wird nicht funktionieren (versuche es, und du wirst eine Fehlermeldung erhalten), weil wir Sonic Pi noch nicht gesagt haben, was wir mit diesem *do/end-Block* anstellen wollen. Wir teilen es Sonic Pi mit, indem wir noch einen speziellen Ausdruck vor das `do` setzen. Wir werden später in diesem Tutorial noch eine Reihe solcher Ausdrücke kennenlernen. Für den Moment ist wichtig zu wissen, dass, wenn du deinen Code zwischen `do` und `end` zusammenfasst, dies Sonic Pi sagt, dass du mit diesem Codeabschnitt etwas Bestimmtes machen willst.

en: 5.2 Iteration and Loops
de: 5.2 Wiederholung und Schleifen

en: Iteration and Loops
de: Iteration und Schleifen

en: So far we've spent a lot of time looking at the different sounds you can make with `play` and `sample` blocks. We've also learned how to trigger these sounds through time using `sleep`.
de: Bislang haben wir viel Zeit damit verbracht, uns die unterschiedliche Klänge anzusehen, die du mit `play`- und `sample`-Blöcken erzeugen kannst. Wir haben auch gelernt, wie wir das Triggern dieser Klänge mit `sleep` steuern können.

en: As you've probably found out, there's a *lot* of fun you can have with these basic building blocks. However, a whole new dimension of fun opens up when you start using the power of code to structure your music and compositions. In the next few sections we'll explore some of these powerful new tools. First up is iteration and loops.
de: Du hast ja wahrscheinlich herausgefunden, dass du mit diesen Grundbausteinen schon *viel* Spaß haben kannst. Eine ganz neue Dimension eröffnet sich jedoch, wenn du anfängst die Macht des Programm-Codes zu nutzen, um deine Musiken und Kompositionen zu strukturieren. In den nächsten Abschnitten sehen wir uns einige wirkungsvolle neue Werkzeuge dafür an. Als erstes kommen Iterationen (wiederholte Abläufe) und Schleifen (Loops) dran.

en: Repetition
de: Wiederholung

en: Have you written some code you'd like to repeat a few times? For example, you might have something like this:
de: Möchtest du Code, den du geschrieben hast, einige Male wiederholen? Vielleicht hast du z. B. so etwas:

en: What if we wished to repeat this 3 times? Well, we could do something simple and just copy and paste it three times:
de: Was, wenn du das drei Male wiederholen wolltest? Nun, wir könnten etwas ganz Einfaches tun, es kopieren und dreimal hintereinander einfügen:

en: Now that's a lot of code! What happens if you want to change the sample to `:elec_plip`? You're going to have to find all the places with the original `:elec_blup` and switch them over. More importantly, what if you wanted to repeat the original piece of code 50 times or 1000? Now that would be a lot of code, and a lot of lines of code to alter if you wanted to make a change.
de: Nun, das ist eine Menge Code! Was wäre, wenn du das Sample in `:elec_plip` ändern wolltest? Du müsstest alle Stellen mit `:elec_blub` finden und sie ändern. Und darüber hinaus: Was, wenn du den ursprünglichen Code-Block 50 oder 1000 Mal wiederholen wolltest? Das wäre wirklich eine Menge Code, und eine Menge Zeilen, die du bearbeiten müsstest, wenn du etwas ändern wolltest.

en: In fact, repeating the code should be as easy as saying *do this three times*. Well, it pretty much is. Remember our old friend the code block? We can use it to mark the start and end of the code we'd like to repeat three times. We then use the special code `3.times`. So, instead of writing *do this three times*, we write `3.times do` - that's not too hard. Just remember to write `end` at the end of the code you'd like to repeat:
de: Tatsächlich, Programm-Code wiederholt ablaufen zu lassen sollte so einfach sein wie zu sagen, *mache das drei Mal*. Nun, so ist es auch in etwa. Erinnere dich an unseren Freund, den Code-Block? Wir können damit den Anfang und das Ende des Codes markieren, den wir drei Mal wiederholen wollen. Dafür benutzen wir den speziellen Ausdruck `3.times`. Anstelle von *mache das drei Mal* schreiben wir `3.times do` - das ist nicht besonders schwer. Denke daran an das Ende des Codes, den du wiederholen möchtest, `end` zu schreiben:

en: Now isn't that much neater than cutting and pasting! We can use this to create lots of nice repeating structures:
de: Na, ist das nicht viel eleganter als zu kopieren und einzufügen? Wir können dies verwenden um viele schöne sich wiederholende Strukturen zu erzeugen:

en: Nesting Iterations
de: Iterationen verschachteln

en: We can put iterations inside other iterations to create interesting patterns. For example:
de: Wir können Iterationen in anderen Iterationen verpacken, um interessante Muster zu erzeugen. Zum Beispiel:

en: Looping
de: Schleifen abspielen

en: If you want something to repeat a lot of times, you might find yourself using really large numbers such as `1000.times do`. In this case, you're probably better off asking Sonic Pi to repeat forever (at least until you press the stop button!). Let's loop the amen break forever:
de: Wenn du etwas sehr oft wiederholen möchtest, könnte es sein, dass du mit sehr hohen Zahlen arbeiten musst, wie zum Beispiel `1000.times do`. In einem solchen Fall ergibt es möglicherweise mehr Sinn Sonic Pi zu bitten, den Code endlos zu wiederholen (zumindest, bis du auf die Stopp-Schaltfläche klickst!). Lass uns den Amen-Break unendlich oft wiederholen:

en: The important thing to know about loops is that they act like black holes for code. Once the code enters a loop it can never leave until you press stop - it will just go round and round the loop forever. This means if you have code after the loop you will *never* hear it. For example, the cymbal after this loop will never play:
de: Eine wichtige Sache bei Schleifen (Loops) ist, dass es sich mit ihnen für den Code wie mit schwarzen Löchern verhält. Wenn der Code einmal in einer Schleife abläuft, kann er diese nicht verlassen, bis du auf Stopp klickst - ansonsten wird er für immer in dieser Schleife weiterlaufen. Das bedeutet, wenn hinter deiner Schleife noch weiterer Code steht, wirst du diesen *nie* hören. Zum Beispiel wird das Becken hinter dieser Schleife niemals spielen:

en: Now, get structuring your code with iteration and loops!
de: Jetzt fang an und strukturiere deinen Code mit Iterationen und Schleifen!

en: 5.3 Conditionals
de: 5.3 Bedingungen

en: Conditionals
de: Bedingungen

en: A common thing you'll likely find yourself wanting to do is to not only play a random note (see the previous section on randomness) but also make a random decision and based on the outcome run some code or some other code. For example, you might want to randomly play a drum or a cymbal. We can achieve this with an `if` statement.
de: Was du dir wahrscheinlich wünschen wirst, ist nicht einfach nur eine zufällige Note zu spielen (siehe auch den letzten Abschnitt über Zufälligkeit), sondern auch eine zufällige Entscheidung treffen zu können, und je nachdem wie diese ausfällt, den einen oder den anderen Code ablaufen zu lassen. Zum Beispiel könnte es sein, dass du einer Zufälligkeit folgend entweder eine Trommel oder ein Becken abspielen möchtest. Das können wir mit einem `if`-Ausdruck erreichen.

en: Flipping a Coin
de: Eine Münze werfen

en: So, let's flip a coin: if it's heads, play a drum, if it's tails, play a cymbal. Easy. We can emulate a coin flip with our `one_in` function (introduced in the section on randomness) specifying a probability of 1 in 2: `one_in(2)`. We can then use the result of this to decide between two pieces of code, the code to play the drum and the code to play the cymbal:
de: Werfen wir also ein Münze: Bei Kopf, spiele eine Trommel, bei Zahl, ein Becken. Das ist leicht. Wir können den Münzwurf mit unserer `one_in`-Funktion nachbilden (eingeführt im Kapitel über Zufälligkeit), indem wir eine Wahrscheinlichkeit von 1 aus 2 angeben: `one_in(2)`. Das Ergebnis dieser Berechnung können wir nutzen, um zwischen zwei Code-Abschnitten auszuwählen, entweder den Code, um die Trommel zu spielen oder den Code, um das Becken zu spielen:

en: Notice that `if` statements have three parts:
de: Merke dir, dass `if`-Anweisungen drei Teile haben:

en: The question to ask
de: Die Frage, die gestellt wird

en: The first choice of code to run (if the answer to the question is yes)
de: Die Auswahl von Programm-Code, der laufen soll (wenn die Antwort auf die Frage ein Ja ist)

en: The second choice of code to run (if the answer to the question is no)
de: Die zweite Auswahl von Programm-Code, der laufen soll (wenn die Antwort auf die Frage ein Nein ist)

en: Typically in programming languages, the notion of yes is represented by the term `true` and the notion of no is represented by the term `false`. So we need to find a question that will give us a `true` or `false` answer which is exactly what `one_in` does.
de: In Programmiersprachen steht typischerweise für das Ja der Ausdruck `true` und für das Nein der Ausdruck `false`. Also müssen wir eine Frage finden, auf die wir eine Antwort erhalten, die entweder `true` (wahr) oder `false` (falsch) ist. Das ist genau das, was `one_in` tut.

en: Notice how the first choice is wrapped between the `if` and the `else` and the second choice is wrapped between the `else` and the `end`. Just like do/end blocks you can put multiple lines of code in either place. For example:
de: Beachte, wie hier die erste Wahl zwischen dem `if` und dem `else` und die zweite Wahl zwischen dem `else` und dem `end` eingeschlossen wird. So wie bei den do/end-Blöcken kannst du beliebig viele Codezeilen an beiden Stellen einfügen. Zum Beispiel:

en: This time we're sleeping for a different amount of time depending on which choice we make.
de: Dieses Mal lassen wir den Code unterschiedlich lange schlafen, je nachdem welche Auswahl getroffen wird.

en: Simple if
de: Einfaches if

en: Sometimes you want to optionally execute just one line of code. This is possible by placing `if` and then the question at the end. For example:
de: Manchmal möchtest du wahlweise nur eine Code-Zeile ausführen. Das ist möglich, indem du ein `if` setzt und dahinter die Frage an das Ende, zum Beispiel:

en: This will play chords of different numbers with the chance of each note playing having a different probability.
de: Dieses Beispiel spielt Akkorde, bestehend aus verschiedenen Noten, wobei die Chance gespielt zu werden für die einzelnen Noten jeweils eine andere Wahrscheinlichkeit hat.

en: So you've made your killer bassline and a phat beat. How do you play them at the same time? One solution is to weave them together manually - play some bass, then a bit of drums, then more bass... However, the timing soon gets hard to think about, especially when you start weaving in more elements.
de: Nun hast du also eine Killer-Basslinie und einen krassen Beat gebaut. Wie kannst du beide zur selben Zeit spielen lassen? Eine Möglichkeit ist, beide Sounds per Hand miteinander zu verweben - spiele erst den Bass ein bisschen, dann das Schlagzeug, dann den Bass etwas mehr... Beides zeitlich aufeinander abzustimmen wird jedoch gedanklich bald immer schwieriger, vor allem, wenn noch mehr Klänge dazukommen sollen.

en: What if Sonic Pi could weave things for you automatically? Well, it can, and you do it with a special thing called a *thread*.
de: Was, wenn Sonic Pi Klänge automatisch für dich miteinander verweben könnte? Nun, das kann es, und zwar erreichst du das mit einem besonderen Ding, welches *Thread* (*Strang*) genannt wird.

en: Infinite Loops
de: Unendliche Schleifen

en: To keep this example simple, you'll have to imagine that this is a phat beat and a killer bassline:
de: Damit dieses Beispiel nicht zu kompliziert wird, musst du dir einfach vorstellen, dass dies deine Killer-Basslinie und dein krasser Beat sind:

en: As we've discussed previously, loops are like *black holes* for the program. Once you enter a loop you can never exit from it until you hit stop. How do we play both loops at the same time? We have to tell Sonic Pi that we want to start something at the same time as the rest of the code. This is where threads come to the rescue.
de: Wir haben das früher schon besprochen, Schleifen sind wie *schwarze Löcher* für ein Programm. Läuft es einmal in die Schleife kommt es da nicht mehr raus, bis du auf Stopp klickst. Wie also können wir beide Schleifen zur selben Zeit abspielen? Wir müssen Sonic Pi sagen, dass wir einen bestimmten Abschnitt gleichzeitig mit dem Rest des Codes starten möchten. Hierbei helfen uns Reihenfolgen (threads).

en: Threads to the Rescue
de: Threads als Rettung

en: By wrapping the first loop in an `in_thread` do/end block we tell Sonic Pi to run the contents of the do/end block at *exactly* the same time as the next statement after the do/end block (which happens to be the second loop). Try it and you'll hear both the drums and the bassline weaved together!
de: Indem wir die erste Schleife in einen `in_thread`-do/end-Block hinein packen, sagen wir Sonic Pi, es soll den Inhalt dieses do/end-Blocks *genau* zur selben Zeit wie nächste Anweisung nach dem do/end-Block ausführen (und das ist in diesem Fall die zweite Schleife). Probiere es aus, und du wirst den Beat und die Basslinie miteinander verwoben hören!

en: Now, what if we wanted to add a synth on top. Something like:
de: Mal angenommen, wir wollten darüber noch einen Synth hinzufügen. Ungefähr so:

en: Now we have the same problem as before. The first loop is played at the same time as the second loop due to the `in_thread`. However, *the third loop is never reached*. We therefore need another thread:
de: Jetzt haben wir das gleiche Problem wie vorhin. Die erste Schleife wird durch das `in_thread` zur selben Zeit wie die zweite gespielt. Aber *die dritte Schleife wird nie erreicht*. Also brauchen wir einen weiteren Thread:

en: Runs as threads
de: Ausführen als Thread

en: What may surprise you is that when you press the Run button, you're actually creating a new thread for the code to run. This is why pressing it multiple times will layer sounds over each other. As the runs themselves are threads, they will automatically weave the sounds together for you.
de: Was dich vielleicht erstaunt: Wenn du auf Ausführen klickst, erzeugst du eigentlich einen neuen Thread, innerhalb dessen der Programm-Code abläuft. Deshalb entstehen immer neue Klangschichten, wenn du wiederholt auf Ausführen klickst. Weil diese Abläufe jeweils für sich Threads sind, werden sie automatisch die Klänge für dich miteinander verweben.

en: Scope
de: Bereich

en: As you learn how to master Sonic Pi, you'll learn that threads are the most important building blocks for your music. One of the important jobs they have is to isolate the notion of *current settings* from other threads. What does this mean? Well, when you switch synths using `use_synth` you're actually just switching the synth in the *current thread* - no other thread will have their synth switched. Let's see this in action:
de: Während du Sonic Pi besser zu meistern lernst, wirst du auch herausfinden, dass Threads die wichtigsten Bausteine für deine Musik sind. Eine der wichtigen Aufgaben die sie ausführen, ist die *aktuellen Einstellungen*, die für einen Thread gelten, von anderen Threads zu isolieren. Was genau bedeutet das? Nun, wenn du etwa einen Synth mit `use_synth` durch einen anderen ersetzt, dann veränderst du den Synth lediglich für den *aktuellen Thread* - bei keinem anderen der laufenden Threads wird der Synth ersetzt. Sehen wir uns das mal in Aktion an:

en: Notice how the middle sound was different to the others? The `use_synth` statement only affected the thread it was in and not the outer main run thread.
de: Bemerke, wie sich der mittlere Klang von den anderen beiden unterschieden hat? Die `use_synth`-Anweisung hat sich nur auf den Thread ausgewirkt, in dem sie auch stand, aber nicht auf den äußeren ausführenden Thread.

en: Inheritance
de: Vererbung

en: When you create a new thread with `in_thread`, the new thread will automatically inherit all of the current settings from the current thread. Let's see that:
de: Wenn du einen neuen Thread mit `in_thread` erzeugst, wird der neue Thread alle Einstellungen automatisch vom vorherigen Thread erben. Sehen wir uns das an:

en: Notice how the second note is played with the `:tb303` synth even though it was played from a separate thread? Any of the settings modified with the various `use_*` functions will behave in the same way.
de: Achte darauf, dass der zweite Ton mit dem `:tb303`-Synth gespielt wird, obwohl er in einem anderen Thread läuft? Jede der Einstellungen, vorgenommen mit den unterschiedlichen `use_*`-Ausdrücken, wird sich genauso verhalten.

en: When threads are created, they inherit all the settings from their parent but they don't share any changes back.
de: Wenn neue Threads erzeugt werden, erben sie alle Einstellungen von ihren Eltern. Aber Änderungen der Einstellungen innerhalb dieser neuen Threads haben umgekehrt keinen Einfluss auf die Eltern.

en: Naming Threads
de: Threads benennen

en: Finally, we can give our threads names:
de: Und schließlich können wir unseren Threads auch Namen geben:

en: Look at the log pane when you run this code. See how the log reports the name of the thread with the message?
de: Achte auf das Protokoll-Fenster, wenn du diesen Code laufen lässt. Siehst du, wie das Protokoll mit den Nachrichten auch die Namen der Threads ausgibt?

en: Only One Thread per Name Allowed
de: Nur ein Thread pro Name erlaubt

en: One last thing to know about named threads is that only one thread of a given name may be running at the same time. Let's explore this. Consider the following code:
de: Eine letzte Anmerkung zu Threads mit Namen: Es kann nur ein Thread gleichen Namens zur selben Zeit laufen. Probieren wir das aus. Sieh dir folgenden Code an:

en: Go ahead and paste that into a buffer and press the Run button. Press it again a couple of times. Listen to the cacophony of multiple amen breaks looping out of time with each other. Ok, you can press Stop now.
de: Kopiere das einmal in einen Puffer und klicke auf `Ausführen`. Klicke noch ein paar mal darauf. Hör dir diese Kakophonie mehrerer Amen-Breaks an, die rhythmisch nicht unbedingt passend zueinander ablaufen. Ok, du kannst jetzt Stopp klicken.

en: This is the behaviour we've seen again and again - if you press the Run button, sound layers on top of any existing sound. Therefore if you have a loop and press the Run button three times, you'll have three layers of loops playing simultaneously.
de: Dieses Verhalten haben wir bereits öfter gesehen - wenn du die `Ausführen`-Schaltfläche klickst, legen sich Klänge über alle bereits laufenden Klänge. Wenn du eine Schleife hast und dreimal auf `Ausführen` klickst, bekommst du drei Ebenen mit Schleifen, die gleichzeitig spielen.

en: However, with named threads it is different:
de: Bei benannten Threads jedoch ist das anders:

en: Try pressing the Run button multiple times with this code. You'll only ever hear one amen break loop. You'll also see this in the log:
de: Versuche bei diesem Code den `Ausführen`-Schalter mehrmals zu klicken. Du wirst immer nur eine Amen-Break-Schleife hören. Das kannst Du auch im Protokoll sehen:

en: Sonic Pi is telling you that a thread with the name `:amen` is already playing, so it's not creating another.
de: Sonic Pi teilt dir mit, dass ein Thread mit dem Namen `:amen` bereits läuft und es deshalb keinen weiteren erzeugt.

en: This behaviour may not seem immediately useful to you now - but it will be very handy when we start to live code...
de: Vielleicht erscheint dir dieses Verhalten im Moment noch nicht nützlich - aber es wird sehr nützlich sein, wenn wir ins Live-Coding einsteigen ...

en: 5.5 Functions
de: 5.5 Funktionen

en: Functions
de: Funktionen

en: Once you start writing lots of code, you may wish to find a way to organise and structure things to make them tidier and easier to understand. Functions are a very powerful way to do this. They give us the ability to give a name to a bunch of code. Let's take a look.
de: Wenn du einmal damit angefangen hast größere Mengen Programm-Code zu schreiben, dann wirst du nach Wegen suchen, wie du die Dinge organisieren und strukturieren kannst, um sie sauberer und verständlicher zu machen. Funktionen sind ein sehr wirkungsvoller Weg das zu tun. Sie geben uns die Möglichkeit, einem Haufen Programm-Code einen Namen zu geben. Sehen wir uns das an.

en: Defining functions
de: Funktionen definieren

en: Here, we've defined a new function called `foo`. We do this with our old friend the do/end block and the magic word `define` followed by the name we wish to give to our function. We didn't have to call it `foo`, we could have called it anything we want such as `bar`, `baz` or ideally something meaningful to you like `main_section` or `lead_riff`.
de: 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, wir können sie auch irgendwie anders nennen; zum Beispiel `bar`, `baz` oder idealerweise einen für dich bedeutsamen Namen wie `haupt_sektion` oder `hintergrund_akkorde`.

en: Calling functions
de: Funktionen aufrufen

en: Once we have defined our function we can call it by just writing its name:
de: Wenn wir unsere Funktion definiert haben, können wir sie über die Eingabe ihres Namens aufrufen:

en: We can even use `foo` inside iteration blocks or anywhere we may have written `play` or `sample`. This gives us a great way to express ourselves and to create new meaningful words for use in our compositions.
de: Wir können `foo` sogar in Blocks mit Iterationen verwenden - oder überall da, wo wir sonst auch `play` oder `sample` schreiben würden. Das gibt uns eine sehr weit gehende Möglichkeit uns auszudrücken, und können sinnvolle Worte einsetzen, um sie in unseren Kompositionen zu verwenden.

en: Functions are remembered across runs
de: Funktionen bleiben in Erinnerung

en: So far, every time you've pressed the Run button, Sonic Pi has started from a completely blank slate. It knows nothing except for what is in the buffer. You can't reference code in another buffer or another thread. However, functions change that. When you define a function, Sonic Pi *remembers* it. Let's try it. Delete all the code in your buffer and replace it with:
de: Wenn du bisher auf `Ausführen` geklickt hast, ist Sonic Pi jedes Mal aufs Neue ohne irgendwelche Vorgaben gestartet. Es berücksichtigt dabei nichts, außer dem, was im jeweiligen Puffer steht. Du kannst dich nicht auf irgendwelchen Programm-Code beziehen, der in einem anderen Puffer oder in einem anderen Thread steht. Funktionen ändern das jedoch. Wenn du eine Funktion definierst, dann *erinnert* sich Sonic Pi daran. Probieren wir das aus. Lösche den gesamten Code in deinem Puffer und ersetze ihn durch:

en: Press the Run button - and hear your function play. Where did the code go? How did Sonic Pi know what to play? Sonic Pi just remembered your function - so even after you deleted it from the buffer, it remembered what you had typed. This behaviour only works with functions created using `define` (and `defonce`).
de: Klicke auf `Ausführen` - und höre deine Funktion spielen. Wo wurde dieser Code gespeichert? Woher wusste Sonic Pi, was es zu spielen hat? Sonic Pi hat sich deine Funktion einfach gemerkt - sogar, nachdem du den Programm-Code aus dem Puffer gelöscht hast, wusste Sonic Pi noch, was du geschrieben hattest. Dies funktioniert nur mit Funktionen, die du mit `define` (und `defonce`) erzeugt hast.

en: Parameterised functions
de: Funktionen parametrisieren

en: You might be interested in knowing that just like you can pass min and max values to `rrand`, you can teach your functions to accept arguments. Let's take a look:
de: Es wird dich vielleicht interessieren, dass so wie du `rrand` einen Minimal- und Maximalwert übergeben kannst, du auch deinen Funktionen beibringen kannst Argumente zu akzeptieren. Sehen wir uns das an:

en: This isn't very exciting, but it illustrates the point. We've created our own version of `play` called `my_player` which is parameterised.
de: Das ist nicht besonders aufregend, zeigt aber, worum es hier geht. Wir haben unsere eigene Version von `play` mit dem Namen `my_player` erschaffen. Diese ist parametrisiert - sie akzeptiert also Argumente.

en: The parameters need to go after the `do` of the `define` do/end block, surrounded by vertical goalposts `|` and separated by commas `,`. You may use any words you want for the parameter names.
de: Die Parameter müssen hinter dem `do` des `define`-do/end-Blocks stehen, umgeben von senkrechten Strichen (pipes) `|`und durch Kommas `,` getrennt. Du kannst beliebige Wörter als Parameternamen verwenden.

en: The magic happens inside the `define` do/end block. You may use the parameter names as if they were real values. In this example I'm playing note `n`. You can consider the parameters as a kind of promise that when the code runs, they will be replaced with actual values. You do this by passing a parameter to the function when you call it. I do this with `my_player 80` to play note 80. Inside the function definition, `n` is now replaced with 80, so `play n` turns into `play 80`. When I call it again with `my_player 90`, `n` is now replaced with 90, so `play n` turns into `play 90`.
de: Die Magie passiert innerhalb des `define`-do/end-Blocks. 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 wenn der Programm-Code läuft, sie durch wirkliche Werte ersetzt werden. Du machst das, indem du der Funktion beim Aufruf einen Parameter mitgibst. Ich tue das hier mit `my_player 80`, um die Note 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 90` aufrufe, wird `n` durch 90 ersetzt, sodass sich jetzt `play n` in `play 90` verwandelt.

en: Let's see a more interesting example:
de: Sehen wir uns ein interessanteres Beispiel an:

en: Here I used `repeats` as if it was a number in the line `repeats.times do`. I also used `root` as if it was a note name in my call to `play`.
de: 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 in meinem Aufruf von `play` wäre.

en: See how we're able to write something very expressive and easy to read by moving a lot of our logic into a function!
de: Sieh dir an, wie wir hier etwas sehr Ausdrucksstarkes und leicht zu Lesendes schreiben konnten, indem wir vieles von unserer Programmlogik in Funktionen verschieben!

en: 5.6 Variables
de: 5.6 Variablen

en: Variables
de: Variablen

en: A useful thing to do in your code is to create names for things. Sonic Pi makes this very easy: you write the name you wish to use, an equal sign (`=`), then the thing you want to remember:
de: Beim Programmieren ist es sehr nützlich, Namen für Dinge zu vergeben. Sonic Pi vereinfacht dies sehr: Du schreibst den Namen, den du verwenden möchtest, dann ein Gleichheitszeichen (`=`) und dann das Ding, welches du dir merken möchtest:

en: Here, we've 'remembered' the symbol `:loop_amen` in the variable `sample_name`. We can now use `sample_name` everywhere we might have used `:loop_amen`. For example:
de: Hier haben wir uns das Symbol `:loop_amen` mit der Variablen `sample_name` *gemerkt*. Wir können nun `sample_name` überall da verwenden, wo wir auch `loop_amen` verwenden würden. Zum Beispiel:

en: There are three main reasons for using variables in Sonic Pi: communicating meaning, managing repetition and capturing the results of things.
de: Es gibt drei wesentliche Gründe Variablen in Sonic Pi zu nutzen: Bedeutung vermitteln, Wiederholung steuern und Ergebnisse erfassen und speichern.

en: Communicating Meaning
de: Bedeutung vermitteln

en: When you write code it's easy to just think you're telling the computer how to do stuff - as long as the computer understands it's OK. However, it's important to remember that it's not just the computer that reads the code. Other people may read it too and try to understand what's going on. Also, you're likely to read your own code in the future and try to understand what's going on. Although it might seem obvious to you now - it might not be so obvious to others or even your future self!
de: Wenn du Programm-Code schreibst, ist es leicht zu denken, dass du dem nur Computer sagst, wie er etwas tun soll - solange der Computer das versteht, ist das in Ordnung. Vergiss aber nicht, dass nicht nur der Computer deinen Code lesen wird. Andere Leute könnten den Code auch lesen und versuchen zu verstehen, was da vor sich geht. Es ist möglich, dass du den Code später auch selbst noch einmal lesen wirst und verstehen willst, was er bedeutet. Obwohl dir jetzt alles noch ganz offensichtlich erscheint - wahrscheinlich ist es für andere nicht ganz so offensichtlich und vielleicht auch nicht für dich in der Zukunft!

en: One way to help others understand what your code is doing is to write comments (as we saw in a previous section). Another is to use meaningful variable names. Look at this code:
de: Ein Weg um andere darin zu unterstützen deinen Programm-Code zu verstehen, ist das Schreiben von Kommentaren (wie wir im vorherigen Abschnitt gesehen haben). Ein andererr besteht darin sinnvolle Namen für deine Variablen verwenden. Sie dir diesen Code an:

en: Why does it use the number `1.7533`? Where did this number come from? What does it mean? However, look at this code:
de: Warum steht hier die Zahl `1.7533`? Woher kommt diese Zahl? Was bedeutet sie? Sieh dir zum Vergleich diesen Code an:

en: Now, it's much clearer what `1.7533` means: it's the duration of the sample `:loop_amen`! Of course, you might say why not simply write:
de: Nun, es ist viel klarer, was `1.7533` bedeutet: Es ist die Dauer des Samples `:loop_amen`! Natürlich könntest du jetzt sagen, warum nicht einfach schreiben:

en: Which, of course, is a very nice way of communicating the intent of the code.
de: Was natürlich auch ein sehr guter Weg ist, die Absicht hinter dem Code mitzuteilen.

en: Managing Repetition
de: Wiederholungen steuern

en: Often you see a lot of repetition in your code and when you want to change things, you have to change it in a lot of places. Take a look at this code:
de: Oft wirst du in deinem Programm-Code Wiederholungen begegnen, und wenn du eine Sache ändern willst, musst du das an vielen Stellen tun. Schau dir diesen Code an:

en: We're doing a lot of things with `:loop_amen`! What if we wanted to hear what it sounded like with another loop sample such as `:loop_garzul`? We'd have to find and replace all `:loop_amen`s with `:loop_garzul`. That might be fine if you have lots of time - but what if you're performing on stage? Sometimes you don't have the luxury of time - especially if you want to keep people dancing.
de: Wir machen hier eine ganze Menge mit dem `:loop_amen`! Was wäre, wenn wir es mit einem anderen Loop-Sample hören wollten, wie zum Beispiel `:loop_garzul`? Wir müssten alle `:loop_amen` suchen und mit `:loop_garzul` ersetzen. Das mag in Ordnung sein, wenn du viel Zeit hast - aber was, wenn du gerade auf der Bühne stehst und performst? Manchmal hast du nicht den Luxus der Zeit - vor allem dann nicht, wenn du willst, dass die Leute weiter tanzen.

en: What if you'd written your code like this:
de: Was wäre, wenn du den Code so geschrieben hättest:

en: Now, that does exactly the same as above (try it). It also gives us the ability to just change one line `sample_name = :loop_amen` to `sample_name = :loop_garzul` and we change it in many places through the magic of variables.
de: Das tut genau dasselbe wie der Code weiter oben (probiere es aus). Und es gibt uns auch die Möglichkeit, dass wir nur eine Zeile von `sample_name = :loop_amen` in `sample_name = :loop_garzul` ändern - und damit zugleich an vielen anderen Stellen durch die Magie der Variablen.

en: Capturing Results
de: Ergebnisse speichern

en: Finally, a good motivation for using variables is to capture the results of things. For example, you may wish to do things with the duration of a sample:
de: Schließlich, eine gute Motivation Variablen zu verwenden ist die Ergebnisse von etwas festzuhalten. Z. B. möchtest du vielleicht irgendetwas mit der Dauer eines Samples anstellen:

en: We can now use `sd` anywhere we need the duration of the `:loop_amen` sample.
de: Wir können nun `sd` überall dort einsetzen, wo wir die Länge von `:loop_amen` brauchen.

en: Perhaps more importantly, a variable allows us to capture the result of a call to `play` or `sample`:
de: Vielleicht noch wichtiger, erlaubt uns eine Variable das Ergebnis eines Aufrufs von `play` oder `sample` zu speichern:

en: Now we have caught and remembered `s` as a variable, which allows us to control the synth as it is running:
de: Jetzt haben wir `s` als Variable festgehalten und gespeichert, das erlaubt es uns einen Synth zu steuern, während er läuft:

en: We'll look into controlling synths in more detail in a later section.
de: Wir werden uns die Steuerung von Synths in einem späteren Abschnitt noch detaillierter ansehen.

en: Warning: Variables and Threads
de: Warnung: Variablen und Threads

en: Whilst variables are great for giving things names and capturing the results of things, it is important to know that they should typically only be used locally within a thread. For example, *don't do this*:
de: Während Variablen sehr gut dazu geeignet sind, Dingen Namen zu geben oder ein Ergebnis festzuhalten, ist es wichtig zu wissen, dass sie typischerweise nur im lokalen Kontext eines Threads verwendet werden sollten. Zum Beispiel, *tu das hier nicht*:

en: In the above example we assign a ring of numbers to a variable `a` and then used it within two separate `live_loop`s. In the first live loop every `0.5`s we sort the ring (to `(ring 1, 2, 3, 4, 5, 6)`) and then print it out to the log. If you run the code, you'll find that the printed list *is not always sorted!*. This may surprise you - especially that sometimes the list is printed as sorted, and sometimes it is not. This is called non-deterministic behaviour and is the result of a rather nasty problem called a race-condition. The problem is due to the fact that the second live loop is also manipulating the list (in this case shuffling it) and by the time the list is printed, sometimes it has just been sorted and sometimes it has just been shuffled. Both live loops are racing to do something different to the same variable and every time round a different loop 'wins'.
de: In dem Beispiel oben weisen wir einen Ring aus Zahlen einer Variablen `a` zu und verwenden sie dann in zwei separaten `live_loop`. Innerhalb der ersten Schleife sortieren wir alle `0.5` Sekunden den Ring (zu `(ring 1, 2, 3, 4, 5, 6)`) und geben dies im Protokoll aus. Wenn du nun den Code ausführst, wirst du bemerken, dass die ausgegebene Liste *nicht immer sortiert ist!*. Das könnte dich überraschen - insbesondere, da manchmal die Liste sortiert ist und manchmal nicht. Dies wird als nicht-vorhersagbares Verhalten bezeichnet, und ist das Ergebnis eines eher üblen Problems, 'Race-Condition' genannt. Das Problem resultiert aus der Tatsache, dass die zweite Schleife ebenfalls die Liste verändert (in diesem Fall wird sie gemischt) und zum Zeitpunkt der Ausgabe die Liste manchmal sortiert und manchmal gemischt ist. Beide Schleifen befinden sich im Wettlauf miteinander die selbe Variable zu verändern, und es gewinnt manchmal die eine und manchmal die andere.

en: There are two solutions to this. Firstly, *don't use the same variable in multiple live loops or threads*. For example, the following code will always print a sorted list as each live loop has its own separate variable:
de: Hierzu gibt es zwei Lösungen: Zunächst, *verwende nie die gleiche Variable in mehreren Live-Loops oder Threads*. Beispielsweise gibt der folgende Code die Liste immer richtig sortiert aus, da jeder Live-Loop eine eigene Variable verwendet:

en: However, sometimes we do want to share things across threads. For example, the current key, BPM, synth etc. In these cases, the solution is to use Sonic Pi's special thread-safe state system via the fns `get` and `set`. This is discussed later on in section 10.
de: Allerdings wollen wir manchmal auch Werte zwischen verschiedene Threads teilen, zum Beispiel die aktuelle Tonart, BPM , den aktuellen Synth etc. In diesen Fällen ist die beste Lösung Sonic Pi spezielles Thread-Safe-State-System mit Hilfe der Funktionen `get` und `set` zu verwenden. Dies werden wir etwas später in Abschnitt 10 behandeln.

en: 5.7 Thread Synchronisation
de: 5.7 Threads synchronisieren

en: Thread Synchronisation
de: Threads synchronisieren

en: Once you have become sufficiently advanced live coding with a number of functions and threads simultaneously, you've probably noticed that it's pretty easy to make a mistake in one of the threads which kills it. That's no big deal, because you can easily restart the thread by hitting Run. However, when you restart the thread it is now *out of time* with the original threads.
de: Sobald du ausreichend vertraut damit bist, mit mehreren gleichzeitig ablaufenden Funktionen und Threads live zu programmieren, wirst du bemerken, dass es ziemlich leicht ist in einem einzelnen Thread einen Fehler zu machen, der ihn zum Absturz bringt. Das ist nicht weiter schlimm, da du den Thread ja mit einem Klick auf `Ausführen` einfach neu starten kannst. Wenn du den Thread aber neu startest, dann läuft er *nicht mehr im Takt* mit den anderen Threads.

en: Inherited Time
de: Vererbte Zeit

en: As we discussed earlier, new threads created with `in_thread` inherit all of the settings from the parent thread. This includes the current time. This means that threads are always in time with each other when started simultaneously.
de: Wie wir bereits vorher gesehen haben, erben neue Threads die mit `in_thread` erzeugt werden alle ihre Einstellungen von einem Eltern-Thread. Das schließt auch die aktuelle Zeit mit ein. Das bedeutet, dass Threads immer miteinander im Takt sind, wenn sie gleichzeitig gestartet werden.

en: However, when you start a thread on its own it starts with its own time which is unlikely to be in sync with any of the other currently running threads.
de: Wenn du aber einen Thread für sich alleine startest, spielt dieser in seinem eigenen Takt, der wahrscheinlich nicht mit irgendeinem der anderen gerade laufenden Threads synchron ist.

en: Cue and Sync
de: Cue und Sync

en: Sonic Pi provides a solution to this problem with the functions `cue` and `sync`.
de: Sonic Pi bietet mit den Funktionen `cue` und `sync` eine Lösung für dieses Problem.

en: `cue` allows us to send out heartbeat messages to all other threads. By default the other threads aren't interested and ignore these heartbeat messages. However, you can easily register interest with the `sync` function.
de: `cue` erlaubt es uns, mit einem Taktgeber regelmäßig Signale an alle anderen Threads zu versenden. Normalerweise zeigen die anderen Threads an solchen Takt-Signalen kein Interesse und ignorieren sie. Mit der `sync`-Funktion kann du jedoch erreichen, dass ein anderer Thread Interesse zeigt.

en: The important thing to be aware of is that `sync` is similar to `sleep` in that it stops the current thread from doing anything for a period of time. However, with `sleep` you specify how long you want to wait while with `sync` you don't know how long you will wait - as `sync` waits for the next `cue` from another thread which may be soon or a long time away.
de: Wichtig ist dabei sich darüber bewusst zu sein, dass `sync` ähnlich wie `sleep` funktioniert, indem es den aktuellen Thread für eine bestimmte Dauer anhält. Allerdings legst du bei `sleep`fest, wie lange du warten willst, während du bei `sync` nicht weißt, wie lange gewartet werden wird - da `sync` auf den nächsten `cue` eines anderen Threads wartet - was eine kürzere oder längere Dauer sein kann.

en: Let's explore this in a little more detail:
de: Sehen wir uns das im Detail an:

en: Here we have two threads - one acting like a metronome, not playing any sounds but sending out `:tick` heartbeat messages every beat. The second thread is synchronising on `tick` messages and when it receives one it inherits the time of the `cue` thread and continues running.
de: Hier haben wir zwei Threads - einer arbeitet wie ein Metronom, er spielt nichts, aber sendet bei jedem Schlag das Taktgeber-Signal `:tick`. Der zweite Thread synchronisiert sich mit den `tick`-Signalen, und wenn er ein Signal erhält, erbt er dadurch den Takt vom `cue`-Thread und läuft weiter.

en: As a result, we will hear the `:drum_heavy_kick` sample exactly when the other thread sends the `:tick` message, even if the two threads didn't start their execution at the same time:
de: Im Ergebnis hören wir das `:drum_heavy_kick`-Sample genau dann, wenn der andere Thread das `:tick`-Signal sendet, auch dann wenn die Ausführung beider Threads gar nicht zur selben Zeit gestartet war:

en: That naughty `sleep` call would typically make the second thread out of phase with the first. However, as we're using `cue` and `sync`, we automatically sync the threads bypassing any accidental timing offsets.
de: Der dreiste Aufruf von `sleep` würde normalerweise den zweiten Thread gegenüber dem ersten aus dem Takt bringen. Da wir jedoch `cue` und `sync` verwenden, synchronisieren wir beide Threads automatisch und umgehen dabei ungewollte Abweichungen in der Zeit.

en: Cue Names
de: Cue-Namen

en: You are free to use whatever name you'd like for your `cue` messages - not just `:tick`. You just need to ensure that any other threads are `sync`ing on the correct name - otherwise they'll be waiting for ever (or at least until you press the Stop button).
de: Du kannst deine `cue`-Signale benennen, wie du willst - nicht nur mit `:tick`. Du musst nur sicherstellen, dass jegliche anderen Threads, die sich mit `sync` synchronisieren, auch diesen Namen verwenden - ansonsten werden sie endlos warten (oder zumindest so lange bis du auf `Stopp` klickst).

en: Let's play with a few `cue` names:
de: Lass uns mit ein paar Namen für `cue` spielen:

en: Here we have a main `cue` loop which is randomly sending one of the heartbeat names `:foo`, `:bar` or `:baz`. We then also have three loop threads syncing on each of those names independently and then playing a different sample. The net effect is that we hear a sound every 0.5 beats as each of the `sync` threads is randomly synced with the `cue` thread and plays its sample.
de: Hier haben wir eine taktgebende `cue`-Schleife, die auf Zufallsbasis einen der drei Taktgeber-Namen `:foo`, `:bar` oder `:baz` aussendet. Wir haben außerdem drei Schleifen-Threads, die sich unabhängig voneinander, jeder für sich, mit einem der Namen synchronisieren und dann jeweils ein anderes Sample spielen. Im Endeffekt hören wir jeden halben Schlag einen Klang, da jeder der `sync`-Threads mit dem `cue`-Thread auf Zufallsbasis synchronisiert ist und entsprechend sein Sample abspielt.

en: This of course also works if you order the threads in reverse as the `sync` threads will simply sit and wait for the next `cue`.
de: Das funktioniert natürlich auch, wenn du die Reihenfolge der Threads umkehrst, da die `sync`-Threads einfach dasitzen und auf den nächsten `cue` warten.

en: 6 FX
de: 6 Effekte

en: Studio FX
de: Studio-Effekte

en: One of the most rewarding and fun aspects of Sonic Pi is the ability to easily add studio effects to your sounds. For example, you may wish to add some reverb to parts of your piece, or some echo or perhaps even distort or wobble your basslines.
de: Einer der lohnendsten und unterhaltsamsten Aspekte von Sonic Pi ist, dass du deinen Klängen sehr einfach Studio-Effekte hinzufügen kannst. Zum Beispiel möchtest du vielleicht Teilen deines Stückes etwas Hall (Reverb) hinzufügen, oder etwas Echo, oder vielleicht sogar deine Basslinien verzerren (Distortion) oder wabern lassen (Wobble).

en: Sonic Pi provides a very simple yet powerful way of adding FX. It even allows you to chain them (so you can pass your sounds through distortion, then echo and then reverb) and also control each individual FX unit with opts (in a similar way to giving params to synths and samples). You can even modify the opts of the FX whilst it's still running. So, for example, you could increase the reverb on your bass throughout the track...
de: Sonic Pi bietet einen sehr einfachen aber mächtigen Weg Effekte hinzuzufügen. Es erlaubt dir sogar sie miteinander verketten (so dass du einen Klang durch Verzerrung, dann Echo und dann Hall schicken kannst) und auch jeden Effekt einzeln mit Parametern zu steuern (ganz ähnlich wie Parameter an Synths und Samples übergeben werden). Du kannst die Parameter eines Effektes sogar ändern, während er noch läuft. Zum Beispiel könntest du so den Hall auf deiner Basslinie im Verlauf des Stückes anheben ...

en: Guitar Pedals
de: Gitarren-Pedale

en: Guitar -> Distortion -> Reverb -> Amplifier
de: Gitarre -> Verzerrer -> Hall -> Verstärker

en: Let's explore FX!
de: Lass uns Effekte ausprobieren!

en: 6.1 Adding FX
de: 6.1 Effekte hinzufügen

en: Adding FX
de: Effekte hinzufügen

en: In this section we'll look at a couple of FX: reverb and echo. We'll see how to use them, how to control their opts and how to chain them.
de: In diesem Abschnitt sehen wir uns zwei Effekte an: Hall und Echo. Wir werden sehen, wie diese Effekte verwendet werden, wie ihre Parameter gesteuert werden, und wie sie verketten werden.

en: Sonic Pi's FX system uses blocks. So if you haven't read section 5.1 you might want to take a quick look and then head back.
de: Das Effekt-System von Sonic Pi verwendet so genannte Code-Blöcke. Falls du Abschnitt 5.1 des Tutorials noch nicht gelesen hast, wirf einen kurzen Blick darauf und komme dann hierher zurück.

en: Reverb
de: Hall

en: If we want to use reverb we write `with_fx :reverb` as the special code to our block like this:
de: Um den Hall-Effekt zu benutzen schreiben wir `with_fx :reverb` als speziellen Programm-Code zu unserem Code-Block. Und zwar so:

en: Now play this code and you'll hear it played with reverb. It sounds good, doesn't it! Everything sounds pretty nice with reverb.
de: Führe diesen Code-Block aus, und du wirst ihn mit Hall hören. Hört sich gut an, nicht wahr! t Mit Hall hört sich alles recht hübsch an.

en: Now let's look what happens if we have code outside the do/end block:
de: Lass uns schauen, was passiert, wenn wir Programm-Code außerhalb des do/end-Blocks hinzufügen:

en: Notice how the final `play 55` isn't played with reverb. This is because it is *outside* the do/end block, so it isn't captured by the reverb FX.
de: Beachte wie das letzte `play 55` nicht mit Hall abgespielt wird. Der Grund dafür ist, dass es sich *außerhalb* des do/end-Blocks befindet und deshalb nicht von unserem Hall erfasst wird.

en: Similarly, if you make sounds before the do/end block, they also won't be captured:
de: Entsprechend werden Klänge, die du vor dem do/end-Block einfügst, auch nicht von dem Hall-Effekt erfasst:

en: There are many FX to choose from. How about some echo?
de: Es stehen viele Effekte zur Auswahl. Wie wäre es mit etwas Echo?

en: One of the powerful aspects of Sonic Pi's FX blocks is that they may be passed opts similar to opts we've already seen with `play` and `sample`. For example a fun echo opt to play with is `phase:` which represents the duration of a given echo in beats. Let's make the echo slower:
de: Einer der machtvollen Aspekte von Effekt-Blöcken in Sonic PI ist, dass wir ihnen opts übergeben können, genauso wie wir es schon bei `play` und `sample` gesehen haben. Ein spannender Echo-Parameter ist zum Beispiel `phase:`, der die Dauer des Echos in Beats darstellt. Lass uns das Echo langsamer machen:

en: Let's also make the echo faster:
de: Lass uns das Echo auch schneller machen:

en: Let's make the echo take longer to fade away by setting the `decay:` time to 8 beats:
de: Lassen wir nun das Echo langsamer ausschwingen, indem wir den `decay:`-Wert auf 8 Schläge setzen:

en: Nesting FX
de: Effekte verschachteln

en: One of the most powerful aspects of the FX blocks is that you can nest them. This allows you to very easily chain FX together. For example, what if you wanted to play some code with echo and then with reverb? Easy, just put one inside the other:
de: Einer der mächtigsten Aspekte von Effekt-Blöcken ist, dass du sie verschachteln kannst. Das erlaubt dir Effekte ganz einfach aneinanderzuhängen. Was, zum Beispiel, wenn du einen Code-Block zuerst mit Echo und dann mit Hall versehen willst? Ganz einfach, verschachtele die Code-Blöcke ineinander:

en: Think about the audio flowing from the inside out. The sound of all the code within the inner do/end block such as `play 50` is first sent to the echo FX and the sound of the echo FX is in turn sent out to the reverb FX.
de: Stell dir das was du hörst, als etwas vor, das von innen nach außen fließt. Der Klang aus dem gesamten Programm-Code im inneren do/end-Block, wie `play 50`, wird zuerst zu dem Echo-Effekt gesendet, und der Echo-Effekt danach zu dem Hall-Effekt.

en: Discovering FX
de: Effekte entdecken

en: Sonic Pi ships with a large number of FX for you to play with. To find out which ones are available, click on FX in the far left of this help system and you'll see a list of available options. Here's a list of some of my favourites:
de: Sonic Pi bringt eine Vielzahl von Effekten mit, die du verwenden kannst. Um herauszufinden, welche verfügbar sind, klicke links unten im Menü des Hilfe-Fensters auf FX, und du siehst eine Liste der verfügbaren Optionen. Hier eine Liste einiger meiner Favoriten:

en: wobble,
de: Wobble,

en: reverb,
de: Reverb,

en: echo,
de: Echo,

en: distortion,
de: Distortion,

en: slicer
de: Slicer

en: 6.2 FX in Practice
de: 6.2 Praktische Anwendung von Effekten

en: FX in Practice
de: Praktische Anwendung von Effekten

en: Although they look deceptively simple on the outside, FX are actually quite complex beasts internally. Their simplicity often entices people to overuse them in their pieces. This may be fine if you have a powerful machine, but if - like me - you use a Raspberry Pi to jam with, you need to be careful about how much work you ask it to do if you want to ensure the beats keep flowing.
de: Auch wenn sie äußerlich sehr einfach aussehen, sind Effekte in Sonic Pi doch höchst komplexe Gebilde. Ihre anscheinende Einfachheit verleitet Leute oft dazu, zu viele Effekte in ihren Stücken zu verwenden. Das mag Spaß machen, wenn du über einen sehr starken Computer verfügst. Aber falls du - so wie ich - einen Raspberry Pi zum Jammen benutzt, musst du darauf achten, wieviel Arbeit du der Maschine abverlangst, wenn du sicher gehen willst, dass die Beats weiter im Takt laufen.

en: Consider this code:
de: Sieh dir den folgenden Programm-Code an:

en: In this code we're playing note 60 with a very short release time, so it's a short note. We also want reverb so we've wrapped it in a reverb block. All good so far. Except...
de: In diesem Programm-Code spielen wir die Note 60 mit einer sehr kurzen Release-Zeit und erzeugen somit einen kurze Note. Wir wollen außerdem einen Hall-Effekt, also haben wir ihn in einen Reverb-Block gepackt. Soweit ist alles gut, abgesehen von ...

en: Let's look at what the code does. First we have a `loop` which means everything inside of it is repeated forever. Next we have a `with_fx` block. This means we will create a new reverb FX *every time we loop*. This is like having a separate FX reverb pedal for every time you pluck a string on a guitar. It's cool that you can do this, but it's not always what you want. For example, this code will struggle to run nicely on a Raspberry Pi. All the work of creating the reverb and then waiting until it needs to be stopped and removed is all handled by `with_fx` for you, but this takes CPU power which may be precious.
de: Lass uns ansehen, was der Code hier macht. Zunächst haben wir einen `loop`-Befehl, was bedeutet, dass alles darin für immer in einer Schleife wiederholt wird. Dann haben wir einen `with_fx:`-do/end-Block. Das bedeutet, dass wir mit jeder *Wiederholung der Schleife* einen neuen Hall-Effekt erzeugen. Und das ist so, als ob wir für jedes Mal, wenn wir eine Gitarrenseite spielen, ein zusätzliches Hall-Effekt-Pedal an die Effektkette hängen würden. Es ist cool, dass du das machen kannst, aber es ist möglicherweise nicht das, was du eigentlich willst. So wird zum Beispiel dieser Programm-Code Schwierigkeiten haben flüssig auf einem Raspberry Pi zu laufen. Die gesamte Arbeit den Hall zu erzeugen und dann abzuwarten, bis er gestoppt und entfernt werden muss, wird von `with_fx:` für dich erledigt - dafür werden Prozessor-Ressourcen benötigt, die vielleicht anderweitig wertvoll wären.

en: How do we make it more similar to a traditional setup where our guitarist has just *one* reverb pedal which all sounds pass through? Simple:
de: Wie können wir einen Code-Block schreiben, der einem traditionellen Aufbau entspricht, bei dem die Gitarre nur *ein* Hall-Effekt-Pedal benutzt, durch das der gesamte Klang geschickt wird? Einfach:

en: We put our loop *inside* the `with_fx` block. This way we only create a single reverb for all notes played in our loop. This code is a lot more efficient and would work fine on a Raspberry Pi.
de: Wir haben unsere Schleife *ins Innere* des `with_fx:`-Blocks gepackt. So erzeugen wir nur noch einen einzelnen Hall-Effekt für alle Noten, die in der Schleife gespielt werden. Dieser Programm-Code ist sehr viel effizienter und würde auch auf einem Raspberry Pi gut funktionieren.

en: A compromise is to use `with_fx` over an iteration within a loop:
de: Ein Kompromiss ist `with_fx:` über eine Iteration innerhalb einer Schleife zu verwenden:

en: This way we've lifted the `with_fx` out of the inner part of the `loop` and we're now creating a new reverb every 16 notes.
de: Somit wird die `with_fx:`-Funktion aus dem Inneren Teil der Schleife geholt, und der Programm-Code erzeugt jetzt nur noch alle 16 Noten einen neuen Hall-Effekt.

en: This is such a common pattern that `with_fx` supports an opt to do exactly this but without having to write the `16.times` block:
de: Dieser Muster taucht so häufig auf, dass `with_fx` eine Option akzeptiert, die erlaubt genau dies zu tun, ohne den `16.times`-Block zu schreiben:

en: Both the `reps: 16` and `16.times do` examples will behave identically. The `reps: 16` essentially repeats the code in the `do/end` block 16 times so you can use them both interchangeably and choose the one that feels best for you.
de: Beide, das `reps: 16`- und das `16.times do`-Beispiel verhalten sich identisch. `reps: 16` wiederholt den Programm-Code im `do/end`-Block 16 mal, sodass du beide Ausdrücke austauschbar verwenden und den auswählen kannst, der sich am besten für dich anfühlt.

en: Remember, there are no mistakes, just possibilities. However, some of these approaches will have a different sound and also different performance characteristics. So play around and use the approach that sounds best to you whilst also working within the performance constraints of your platform.
de: Denke daran, es gibt keine Fehler, nur Möglichkeiten! Wie auch immer, einige dieser Ansätze werden sich klanglich unterscheiden und auch unterschiedlich verhalten. Spiel also herum, und verwende den Ansatz, der für dich am besten klingt und zugleich innerhalb der Beschränkungen deiner Plattform funktioniert.

en: 7 Control
de: 7 Steuerung

en: Controlling running sounds
de: Steuerung laufender Klänge

en: So far we've looked at how you can trigger synths and samples, and also how to change their default opts such as amplitude, pan, envelope settings and more. Each sound triggered is essentially its own sound with its own list of options set for the duration of the sound.
de: Bisher haben wir uns angesehen, wie du Synths und Samples starten und ihre Standard-Parameter wie Lautstärke, Position im Stereofeld, Hüllkurven und so weiter anpassen kannst. Jeder gespielte Klang ist im Grunde genommen ein eigener Klang mit einer eigenen Liste an Optionen, gesetzt für die Dauer, während der er klingt.

en: Wouldn't it also be cool if you could change a sound's opts whilst it's still playing, just like you might bend a string of a guitar whilst it's still vibrating?
de: Wäre es nicht auch cool, wenn du die Parameter eines Klanges verändern könntest - noch während er erklingt - etwa so, wie du an einer Gitarrensaite ziehen würdest, während sie noch schwingt?

en: You're in luck - this section will show you how to do exactly this.
de: Glück gehabt - dieser Abschnitt wird dir zeigen, wie du genau das tun kannst.

en: 7.1 Controlling Running Synths
de: 7.1 Steuerung laufender Synths

en: Controlling Running Synths
de: Steuerung laufender Synths

en: So far we've only concerned ourselves with triggering new sounds and FX. However, Sonic Pi gives us the ability to manipulate and control currently running sounds. We do this by using a variable to capture a reference to a synth:
de: Bisher haben wir uns nur damit befasst neue Klänge und Effekte zu triggern. Mit Sonic Pi kannst du aber laufende Klänge auch steuern und verändern. Um das zu tun, fassen wir eine Referenz zu einem Synth in einer Variable:

en: Here, we have a run-local variable `s` which represents the synth playing note 60. Note that this is *run-local* - you can't access it from other runs like functions.
de: Jetzt haben wir eine lokal ausgeführte Variable `s`, die einen Synth repräsentiert, der die Note 60 spielt. Beachte, dass sie *lokal ausgeführt* wird - das bedeutet, du kannst nicht von andere Ausführungen, wie z. B. Funktionen auf sie zugreifen.

en: Once we have `s`, we can start controlling it via the `control` function:
de: Sobald wir `s` gesetzt haben, können wir es mit der `control`-Funktion steuern:

en: The thing to notice is that we're not triggering 4 different synths here - we're just triggering one synth and then change the pitch 3 times afterwards, while it's playing.
de: Wichtig zu bemerken ist hier, dass wir nicht 4 verschiedene Synths starten - wir starten nur einen Synth und ändern dann seine Tonhöhe dreimal im Nachhinein, während er noch spielt.

en: We can pass any of the standard opts to `control`, so you can control things like `amp:`, `cutoff:` or `pan:`.
de: Wir können jeden der Standard-Parameter an die `control`-Funktion übergeben, so kannst du Dinge wie `amp:`, `cutoff:` oder `pan:` steuern.

en: Non-controllable Options
de: Nicht-steuerbare Parameter

en: Some of the opts can't be controlled once the synth has started. This is the case for all the ADSR envelope parameters. You can find out which opts are controllable by looking at their documentation in the help system. If the documentation says *Can not be changed once set*, you know it's not possible to control the opt after the synth has started.
de: Manche der Optionen können nach dem Start des Synths nicht mehr kontrolliert werden. Das ist der Fall bei allen ADSR-Hüllkurven-Parametern. Welche Opts steuerbar sind, kannst du herausfinden, indem du ihre Dokumentation im Hilfe-Fenster ansiehst. Wenn dort steht *Can not be changed once set*, dann weißt du, dass es nicht möglich ist diese Option zu steuern, nachdem der Synth gestartet ist.

en: 7.2 Controlling FX
de: 7.2 Steuerung von Effekten

en: Controlling FX
de: Steuerung von Effekten

en: It is also possible to control FX, although this is achieved in a slightly different way:
de: Es ist auch möglich Effekte zu steuern, allerdings funktioniert das ein wenig anders:

en: Instead of using a variable, we use the goalpost parameters of the do/end block. Inside the `|` bars, we need to specify a unique name for our running FX which we then reference from the containing do/end block. This behaviour is identical to using parameterised functions.
de: Anstatt eine Variable zu verwenden, nutzen wir die Parameter zwischen den so genannten Pipes des do/end-Blocks. Innerhalb dieser Pipes `|`, müssen wir einen eindeutigen Namen für unseren laufenden Effekt vergeben, den wir dann innerhalb des do/end-Blocks verwenden. Dieses Verhalten ist das gleiche wie bei parametrisierten Funktionen.

en: Now go and control some synths and FX!
de: Jetzt los - steuere ein paar Synths und Effekte!

en: 7.3 Sliding Options
de: 7.3 Gleitende Parameter

en: Sliding Opts
de: Gleitende Parameter

en: Whilst exploring the synth and FX opts, you might have noticed that there are a number of opts ending with `_slide`. You might have even tried calling them and seeing no effect. This is because they're not normal parameters, they're special opts that only work when you control synths as introduced in the previous section.
de: Während du die Synth- und Effekt-Optionen erforscht hast, ist dir vielleicht aufgefallen, dass einige von ihnen auf `_slide` enden. Vielleicht hast du sogar ausprobiert sie aufzurufen und keinen Effekt bemerkt. Das liegt daran, dass dies keine normalen Parameter sind, sie sind besondere Opts, die nur dann funktionieren, wenn du Synths steuerst, wie im letzten Abschnitt beschrieben.

en: Consider the following example:
de: Schau dir das folgende Beispiel an:

en: Here, you can hear the synth pitch changing immediately on each `control` call. However, we might want the pitch to slide between changes. As we're controlling the `note:` parameter, to add slide, we need to set the `note_slide` parameter of the synth:
de: Hier kannst du hören, wie sich die Tonhöhe des Synth unmittelbar bei jedem Aufruf von `control` ändert. Vielleicht möchtest du aber, dass die Tonhöhe sich gleitend zwischen den Aufrufen verändert. Wenn wir die Opt `note:` verwenden, müssen wir, um gleitende Übergänge zu erhalten, den `note_slide:`-Parameter des Synth setzen:

en: Now we hear the notes being bent between the `control` calls. It sounds nice, doesn't it? You can speed up the slide by using a shorter time such as `note_slide: 0.2` or slow it down by using a longer slide time.
de: Nun hören wir, wie die Noten zwischen den `control`-Aufrufen gezogen werden. Hört sich gut an, oder? Mit einer kürzeren Dauer wie beispielsweise `note_slide: 0,2` kannst du den Übergang beschleunigen, oder ihn mit einer längeren Slide-Dauer verlangsamen.

en: Every parameter that can be controlled has a corresponding `_slide` parameter for you to play with.
de: Jeder steuerbare Parameter hat einen entsprechenden `_slide`-Parameter, mit dem du spielen kannst.

en: Sliding is sticky
de: Gleiten ist klebrig

en: Once you've set a `_slide` parameter on a running synth, it will be remembered and used every time you slide the corresponding parameter. To stop sliding you must set the `_slide` value to 0 before the next `control` call.
de: Nachdem du einmal einen `_slide` Parameter auf einem laufenden Synth gesetzt hast, wird er erinnert - und er wird jedes mal genutzt, wenn du den dazu gehörenden Parameter nutzt. Um das Gleiten zu stoppen, musst du den `_slide` Wert vor dem nächsten `control`-Aufruf auf 0 setzen.

en: Sliding FX Opts
de: Gleitende Effekt-Parameter

en: It is also possible to slide FX opts:
de: Es ist ebenso möglich, Effekt-Opts gleiten zu lassen:

en: Now have fun sliding things around for smooth transitions and flowing control...
de: Und jetzt hab Spaß damit die Dinge ein wenig herumgleiten zu lassen - für weiche Übergänge und Steuerung der Abläufe ...

en: 8 Data Structures
de: 8 Datenstrukturen

en: Data Structures
de: Datenstrukturen

en: A very useful tool in a programmer's toolkit is a data structure.
de: Ein sehr praktisches Werkzeug im Werkzeugkasten jeder Programmiererin und jedes Programmierers sind Datenstrukturen.

en: Sometimes you may wish to represent and use more than one thing. For example, you may find it useful to have a series of notes to play one after another. Programming languages have data structures to allow you do exactly this.
de: Manchmal möchtest du mehr als ein einzelnes Ding darstellen oder verwenden. Du könntest z. B. nützlich finden, eine Reihe von Noten zu haben und sie dann nacheinander abzuspielen. Programmiersprachen verwenden Datenstrukturen für genau diesen Zweck.

en: There are many exciting and exotic data structures available to programmers - and people are always inventing new ones. However, for now we only really need to consider a very simple data structure - the list.
de: Es gibt einige aufregende und exotische Datenstrukturen die Programmiererinnen und Programmierern zur Verfügung stehen - und es werden immer noch weitere erfunden. Für unsere Zwecke jedoch benötigen wir vorerst nur eine, sehr einfache, Datenstruktur - die Liste.

en: Let's look at it in more detail. We'll cover its basic form and then also how lists can be used to represent scales and chords.
de: Lass uns das im Detail ansehen. Wir werden uns die Grundform einer Liste anschauen und wie man sie verwendet, um Skalen und Akkorde abzubilden.

en: 8.1 Lists
de: 8.1 Listen

en: Lists
de: Listen

en: In this section we'll take a look at a data structure which is very useful - the list. We met it very briefly before in the section on randomisation when we randomly chose from a list of notes to play:
de: In diesem Abschnitt werden wir uns eine sehr nützliche Datenstruktur ansehen - die Liste. Wir hatten schon einmal in dem Abschnitt über Zufälligkeit kurz mit ihr zu tun, als wir die zu spielenden Noten zufällig aus einer Liste ausgewählt haben:

en: In this section we'll explore using lists to also represent chords and scales. First let's recap how we might play a chord. Remember that if we don't use `sleep`, sounds all happen at the same time:
de: In diesem Abschnitt erforschen wir, wie wir Akkorde und Skalen mit Listen darstellen können. Zuerst rufen wir uns wieder in Erinnerung, wie wir einen Akkord spielen könnten. Erinnere dich, dass ohne `sleep` alle Töne zur gleichen Zeit gespielt werden:

en: Let's look at other ways to represent this code.
de: Lass uns weitere Möglichkeiten ansehen diesen Programm-Code zu schreiben.

en: Playing a List
de: Abspielen einer Liste

en: One option is to place all the notes in a list: `[52, 55, 59]`. Our friendly `play` function is smart enough to know how to play a list of notes. Try it:
de: Eine Möglichkeit ist, alle Noten aus einer Liste heraus abzuspielen: `[52, 55, 59]`. Unsere freundliche Funktion `play` ist schlau genug, um zu wissen, wie man eine Liste von Noten abspielt. Probiere es aus:

en: Ooh, that's already nicer to read. Playing a list of notes doesn't stop you from using any of the parameters as normal:
de: Oh, das lässt sich schon viel besser lesen. Eine Liste von Noten abzuspielen hindert dich nicht daran, alle Parameter so zu verwenden wie sonst auch:

en: Of course, you can also use the traditional note names instead of the MIDI numbers:
de: Natürlich kannst du auch die traditionellen Notennamen anstelle der MIDI-Nummern verwenden:

en: Now those of you lucky enough to have studied some music theory might recognise that chord as *E Minor* played in the 3rd octave.
de: Die Glücklichen unter euch, die ein wenig Musiktheorie gelernt haben, haben den Akkord vielleicht erkannt: Es ist *E-Moll*, gespielt in der 3. Oktave.

en: Accessing a List
de: Auf Listen zugreifen

en: Another very useful feature of a list is the ability to get information out of it. This may sound a bit strange, but it's no more complicated than someone asking you to turn a book to page 23. With a list, you'd say, what's the element at index 23? The only strange thing is that in programming indexes usually start at 0 not 1.
de: Ein weiteres sehr nützliches Merkmal von Listen ist, dass man die in ihnen enthaltenen Informationen auslesen kann. Das klingt vielleicht etwas eigenartig, aber es ist nicht komplizierter, als eine Person zu bitten Seite 23 in einem Buch aufzuschlagen. Eine Liste fragst du einfach, was das Element mit der Indexnummer 23 ist. Das einzig seltsame in diesem Fall ist , dass beim Programmieren Indizes üblicherweise bei 0 beginnen - nicht bei 1.

en: With list indexes we don't count 1, 2, 3... Instead we count 0, 1, 2...
de: Listen-Indizes zählen wir also nicht 1, 2, 3 ... sondern 0, 1 ,2 ...

en: Let's look at this in a little more detail. Take a look at this list:
de: Lass uns das im Detail ansehen. Sieh dir diese Liste an:

en: There's nothing especially scary about this. Now, what's the second element in that list? Yes, of course, it's `55`. That was easy. Let's see if we can get the computer to answer it for us too:
de: Nichts besonders Beängstigendes. Was ist das zweite Element in dieser Liste? Natürlich, es ist `55`. Das war einfach. Lass uns sehen, ob wir nicht auch den Computer dazu bringen können, die Frage für uns zu beantworten:

en: OK, that looks a bit weird if you've never seen anything like it before. Trust me though, it's not too hard. There are three parts to the line above: the word `puts` , our list `52, 55, 59` and our index `[1]`. Firstly we're saying `puts` because we want Sonic Pi to print the answer out for us in the log. Next, we're giving it our list, and finally our index is asking for the second element. We need to surround our index with square brackets and because counting starts at `0`, the index for the second element is `1`. Look:
de: OK, das sieht etwas seltsam aus, wenn du so etwas noch nie gesehen hast. Aber vertrau mir, es ist nicht allzu schwer. Die Zeile oben besteht aus drei Teilen: dem Wort `puts`, unserer Liste `52, 55, 59` und unserem Index `[1]`. Zuerst sagen wir `puts`, weil wir wollen, dass Sonic Pi die Antwort für uns ins Protokoll schreibt. Als nächstes übergeben wir unsere Liste, und am Ende fragen wir mit dem Index nach dem zweiten Element in der Liste. Den Index müssen wir mit eckigen Klammern umschließen, und da das Zählen mit `0` beginnt, ist die Index-Zahl für das zweite Element `1`. Schau:

en: Try running the code `puts [52, 55, 59][1]` and you'll see `55` pop up in the log. Change the index `1` to other indexes, try longer lists and think about how you might use a list in your next code jam. For example, what musical structures might be represented as a series of numbers...
de: Versuche mal, den Programm-Code `puts [52, 55, 59][1]` auszuführen, dann wirst du sehen, dass `55` im Protokoll erscheint. Ändere den Index `1` in andere Indizes, probiere längere Listen aus - und denke darüber nach, wie du Listen einsetzen könntest, wenn du demnächst Code live programmieren und damit jammen willst. Zum Beispiel, welche musikalischen Strukturen könnten als eine Reihe von Zahlen geschrieben werden ...

en: 8.2 Chords
de: 8.2 Akkorde

en: Sonic Pi has built-in support for chord names which will return lists. Try it for yourself:
de: Sonic Pi bietet dir auch Unterstützung dabei, dir den Namen eines Akkords in eine Liste seiner Töne zu übersetzen. Probiere es selbst aus:

en: Now, we're really getting somewhere. That looks a lot more pretty than the raw lists (and is easier to read for other people). So what other chords does Sonic Pi support? Well, a *lot*. Try some of these:
de: Damit kommen wir nun wirklich weiter. Das sieht schon viel besser aus als einfache Listen (und es ist für andere viel leichter zu lesen). Welche Akkordauflösungen unterstützt Sonic Pi noch? Naja, *viele*. Probiere ein paar hiervon aus:

en: We can easily turn chords into arpeggios with the function `play_pattern`:
de: Wir können Akkorde leicht in Arpeggios umwandeln, indem wir die Funktion `play_pattern` verwenden:

en: We can even pass a list of times which it will treat as a circle of times:
de: Wir können sogar eine Liste von Zeiten übergeben, die nacheinander verwendet und wiederholt werden:

en: This is the equivalent to:
de: Das bedeutet das gleiche wie:

en: Which would you prefer to write?
de: Was würdest du lieber schreiben?

en: Note that `play_pattern` and `play_pattern_timed` alter the sustain of the notes to fill the times. You can remove this behavior by setting the `sustain:` opt to `0`:
de: Beachte, dass `play_pattern` und `play_pattern_timed` den Sustain der Noten an die Zeiten anpassen. Indem du `sustain:` auf `0` einstellst, kannst du das verhindern.

en: 8.3 Scales
de: 8.3 Skalen

en: Scales
de: Skalen

en: Sonic Pi has support for a wide range of scales. How about playing a C3 major scale?
de: Sonic Pi unterstützt weite Auswahl von Tonleitern. Wie wäre es mit einer C3-Dur-Skala?

en: We can even ask for more octaves:
de: Wir können sie auch über mehrere Oktaven spielen lassen:

en: How about all the notes in a pentatonic scale?
de: Und wie wäre es mit allen Noten einer pentatonischen Skala?

en: Random notes
de: Zufällige Noten

en: Chords and scales are great ways of constraining a random choice to something meaningful. Have a play with this example which picks random notes from the chord E3 minor:
de: Akkorde und Skalen sind gute Methoden, um eine zufällige Auswahl auf etwas Bedeutungsvolles einzugrenzen. Spiele einmal mit diesem Beispiel, das zufällig Noten aus dem E-Moll-Akkord in der 3. Oktave auswählt:

en: Try switching in different chord names and cutoff ranges.
de: Probiere auch verschiedene Akkord-Namen und Cut-Off-Bereiche aus.

en: Discovering Chords and Scales
de: Akkorde und Skalen entdecken

en: To find out which scales and chords are supported by Sonic Pi simply click the Lang button on the far left of this tutorial and then choose either chord or scale in the API list. In the information in the main panel, scroll down until you see a long list of chords or scales (depending on which you're looking at).
de: Um herauszufinden, welche Skalen und Akkorde Sonic Pi unterstützt, klicke einfach auf die `Codes`-Schaltfläche unten links in diesem Tutorial und wähle entweder chord (Akkord) oder scale (Skala, Tonleiter) aus der API-Liste. Im Info-Bereich im Hauptfenster scrolle nach unten, bist du eine lange Liste von Akkorden oder Skalen findest (je nach dem auf welches Fenster du gerade schaust).

en: Have fun and remember: there are no mistakes, only opportunities.
de: Viel Spaß und nicht vergessen: Es gibt keine Fehler, nur Möglichkeiten.

en: 8.4 Rings
de: 8.4 Ringe

en: Rings
de: Ringe

en: An interesting spin on standard lists are rings. If you know some programming, you might have come across ring buffers or ring arrays. Here, we'll just go for ring - it's short and simple.
de: Eine interessanter Dreh bei einfachen Listen sind Ringe. Wenn du ein bisschen Programmiererfahrung hast, bist du vielleicht schon einmal auf Ring-Buffer (Ringspeicher) oder Ring-Arrays gestoßen. Wir nennen sie hier - kurz und einfach - Ring.

en: In the previous section on lists we saw how we could fetch elements out of them by using the indexing mechanism:
de: Im vorherigen Abschnitt über Listen haben wir gesehen, wie wir über den Index-Mechanismus Elemente aus einer Liste holen können:

en: Now, what happens if you want index `100`? Well, there's clearly no element at index 100 as the list has only three elements in it. So Sonic Pi will return you `nil` which means nothing.
de: Was passiert jetzt wohl, wenn du den Index `100` abfragen willst? Nun, es gibt offensichtlich kein Element mit dem Index 100, da die Liste nur drei Elemente enthält. Also gibt Sonic Pi `nil` zurück, das steht für 'nichts'.

en: However, consider you have a counter such as the current beat which continually increases. Let's create our counter and our list:
de: Stell dir jedoch vor, du hast einen Zähler, wie den aktuellen Beat (Schlag), der kontinuierlich wächst. Lass uns damit unseren Zähler und unsere Liste anlegen:

en: We can now use our counter to access a note in our list:
de: Wir können jetzt unseren Zähler verwenden, um auf eine Note in unserer Liste zuzugreifen:

en: Great, we got `52`. Now, let's increment our counter and get another note:
de: Super, da kam `52` heraus. Nun Lass uns den Zähler erhöhen (increment) und auf eine andere Note zugreifen:

en: Super, we now get `55` and if we do it again we get `59`. However, if we do it again, we'll run out of numbers in our list and get `nil`. What if we wanted to just loop back round and start at the beginning of the list again? This is what rings are for.
de: Gut, jetzt kommt `55` und beim folgenden Mal `59` heraus. Wenn wir das jedoch noch einmal machen, werden wir keine Zahlen mehr in unserer Liste haben, und wir bekommen `nil` zurück. Was wäre, wenn wir in diesem Fall einfach wieder vom Anfang der Liste an zählen wollten? Genau dafür gibt es Ringe.

en: Creating Rings
de: Ringe erzeugen

en: We can create rings one of two ways. Either we use the `ring` function with the elements of the ring as parameters:
de: Wir können Ringe auf zwei Arten erzeugen. Entweder wir nutzen die `ring`-Funktion, mit den gewünschten Elementen aus dem Rings als Parameter:

en: Or we can take a normal list and convert it to a ring by sending it the `.ring` message:
de: Oder wir nehmen eine normale Liste und wandeln sie mit der Nachricht `.ring` in einen Ring um:

en: Indexing Rings
de: Ringe indizieren

en: Once we have a ring, you can use it in exactly the same way you would use a normal list with the exception that you can use indexes that are negative or larger than the size of the ring and they'll wrap round to always point at one of the ring's elements:
de: Sobald du einen Ring hast, kannst du ihn genauso verwenden wie du eine normale Liste verwenden würdest, mit einer Ausnahme: Du kannst darauf auch solche Indizes verwenden, die negativ oder größer als der Ringinhalt sind - diese machen dann eine Schleife wieder zum Anfang, um immer auf ein Element des Rings zu verweisen:

en: Using Rings
de: Ringe verwenden

en: Let's say we're using a variable to represent the current beat number. We can use this as an index into our ring to fetch notes to play, or release times or anything useful we've stored in our ring regardless of the beat number we're currently on.
de: Lass uns annehmen, wir verwenden eine Variable, die stets die aktuelle Schlagzahl abbildet. Wir können diese Variable in unserem Ring als Index verwenden, um so Noten, Release-Zeiten oder andere sinnvolle Dinge abzurufen, unabhängig davon bei welcher Schlagzahl wir uns gerade befinden.

en: Scales and Chords are Rings
de: Skalen und Akkorde sind Ringe

en: A useful thing to know is that the lists returned by `scale` and `chord` are also rings and allow you to access them with arbitrary indexes.
de: Es ist nützlich zu wissen, das die Listen, die von `scale` und `chord` zurückgegeben werden, auch Ringe sind und du so mit beliebigen Indizes auf sie zugreifen kannst.

en: Ring Constructors
de: Ring-Konstruktoren

en: In addition to `ring` there are a number of other functions which will construct a ring for us.
de: Zusätzlich zu `ring` gibt es eine Anzahl weiterer Funktionen, die Ringe für uns erzeugen.

en: `range` invites you specify a starting point, end point and step size.
de: `range` lädt dich dazu ein, einen Startpunkt, einen Endpunkt und eine Schrittgröße festzulegen.

en: `bools` allows you to use `1`s and `0`s to succinctly represent booleans.
de: `bools` erlaubt dir `1`en und `0`en als Kurzform für boolesche Werte zu nutzen.

en: `knit` allows you to knit a sequence of repeated values.
de: `knit` erlaubt dir, eine Abfolge zu wiederholender Werte zu stricken (to knit).

en: `spread` creates a ring of bools with a Euclidean distribution.
de: `spread` erzeugt einen Ring boolescher Werte in euklidischer Verteilung.

en: Take a look at their respective documentation for more information.
de: Für weitere Information sieh dir die Dokumentation zur jeweiligen Funktion an.

en: 8.5 Ring Chains
de: 8.5 Ring-Ketten

en: Ring Chains
de: Ring-Ketten

en: In addition to the constructors such as `range` and `spread` another way of creating new rings is to manipulate existing rings.
de: Neben der Verwendung von Konstruktoren wie `range` und `spread` können wir neue Ringe auch dadurch erzeugen, das wir bereits existierende Ringe verändern.

en: Chain Commands
de: Befehle verketten

en: To explore this, take a simple ring:
de: Um dies auszuprobieren, verwende einen einfachen Ring:

en: What if we wanted it backwards? Well we'd use the chain command `.reverse` to take the ring and turn it around:
de: Was, wenn wir diese Reihe umkehren wollen? Nun, wir verwenden den Verkettungsbefehl `.reverse`, um den Ring umzudrehen:

en: Now, what if we wanted the first three values from the ring?
de: Ok, und wenn wir nur die ersten 3 Werte aus dem Ring haben wollten?

en: Finally, what if we wanted to shuffle the ring?
de: Und schließlich, wenn wir den Ring mischen wollten?

en: Multiple Chains
de: Mehrfache Ketten

en: This is already a powerful way of creating new rings. However, the *real* power comes when you chain a few of these commands together.
de: Auf diese Art haben wir bereits mächtige Möglichkeiten neue Ringe zu erzeugen. Noch *mächtiger* werden sie allerdings, wenn du mehrere dieser Befehle verkettest.

en: How about shuffling the ring, dropping 1 element and then taking the next 3?
de: Wie wäre es den Ring zu mischen, das erste Element wegzulassen, und dann die 3 folgenden Elemente zu verwenden?

en: Let's take this in stages:
de: Lass uns das Schritt für Schritt durchgehen:

en: `(ring 10, 20, 30, 40, 50)` - our initial ring
de: `(ring 10, 20, 30, 40, 50)` - dein anfänglicher Ring

en: `(ring 10, 20, 30, 40, 50).shuffle` - shuffles - `(ring 40, 30, 10, 50, 20)`
de: `(ring 10, 20, 30, 40, 50).shuffle` - mischt ihn zu - `(ring 40, 30, 10, 50, 20)`

en: `(ring 10, 20, 30, 40, 50).shuffle.drop(1)` - drop 1 - `(ring 30, 10, 50, 20)`
de: `(ring 10, 20, 30, 40, 50).shuffle.drop(1)` - mischt und lässt dann das erste Element weg - `(ring 30, 10, 50, 20)`

en: `(ring 10, 20, 30, 40, 50).shuffle.drop(1).take(3)` - take 3 - `(ring 30, 10, 50)`
de: `(ring 10, 20, 30, 40, 50).shuffle.drop(1).take(3)` - mischt, lässt das erste Element weg und nimmt 3 - `(ring 30, 10, 50)`

en: Can you see how we can just create a long chain of these methods by just *sticking them together*. We can combine these in any order we want creating an extremely rich and powerful way of generating new rings from existing ones.
de: Kannst du sehen, wie wir eine lange Kette dieser Methoden einfach dadurch erzeugen können, dass wir sie *aneinander kleben*? Wir können das in jeder beliebigen Reihenfolge tun, und damit haben wir einen *extrem mächtigen* Weg, um neue Ringe aus bereits bestehenden zu erzeugen.

en: Immutability
de: Unveränderlichkeit

en: These rings have a powerful and important property. They are immutable which means that they can not change. This means that the chaining methods described in this section *do not change rings* rather they *create new rings*. This means you're free to share rings across threads and start chaining them within a thread knowing you won't be affecting any other thread using the same ring.
de: Diese Ringe haben eine mächtige und wichtige Eigenschaft. Sie sind unveränderlich (immutable) - sie können nicht verändert werden. Das bedeutet, dass die Verkettungsmethoden, von denen wir in diesem Abschnitt sprechen, *die Ringe nicht verändern* sondern eher *neue Ringe erzeugen*. Das bedeutet, du kannst Ringe über verschiedene Threads hinweg teilen und anfangen sie innerhalb eines Threads zu verketten, ohne dabei irgend einen anderen Thread zu verändern, der auf den gleichen Ring zugreift.

en: Available Chain Methods
de: Verfügbare Verkettungsmethoden

en: Here's a list of the available chain methods for you to play with:
de: Dies ist eine Liste der Verkettungsmethoden, mit denen du spielen kannst:

en: `.reverse` - returns a reversed version of the ring
de: `.reverse` - gibt eine umgedrehte Version des Ringes zurück

en: `.sort` - creates a sorted version of the ring
de: `.sort` - erzeugt eine sortierte Version des Ringes

en: `.shuffle` - creates a shuffled version of the ring
de: `.shuffle` - erzeugt eine gemischte Version des Ringes

en: `.pick` - returns a ring with the results of calling `.choose` once
de: `.pick` - liefert einen Ring mit den Resultaten wie 1 mal `.choose`

en: `.pick(3)` - returns a ring with the results of calling `.choose` 3 times
de: `.pick(3)` - liefert einen Ring mit den selben Resultaten wie 3 mal `.choose`

en: `.take(5)` - returns a new ring containing only the first 5 elements
de: `.take(5)` - liefert einen Ring, der nur die ersten 5 Elemente enthält

en: `.drop(3)` - returns a new ring with everything but the first 3 elements
de: `.drop(3)` - liefert einen Ring, der alles außer den ersten 3 Elementen enthält

en: `.butlast` - returns a new ring with the last element missing
de: `.butlast` - liefert einen Ring ohne das letzte Element

en: `.drop_last(3)` - returns a new ring with the last 3 elements missing
de: `.drop_last(3)` - liefert einen Ring ohne die letzten 3 Elemente

en: `.take_last(6)`- returns a new ring with only the last 6 elements
de: `.take_last(6)`- liefert einen Ring, der nur die letzten 6 Elemente enthält

en: `.stretch(2)` - repeats each element in the ring twice
de: `.stretch(2)` - wiederholt jedes Element im Ring zweimal

en: `.repeat(3)` - repeats the entire ring 3 times
de: `.repeat(3)` - wiederholt den Ring als Ganzes 3 mal

en: `.mirror` - adds the ring to a reversed version of itself
de: `.mirror` - hängt eine umgekehrte Version des Rings an den Ring an

en: `.reflect` - same as mirror but doesn't duplicate middle value
de: `.reflect` - wie `.mirror`, verdoppelt aber nicht den mittleren Wert

en: `.scale(2)` - returns a new ring with all elements multiplied by 2 (assumes ring contains numbers only)
de: `.scale(2)` - liefert einen neuen Ring mit allen Elementen multipliziert mit 2 (setzt voraus, dass der Ring nur Zahlen enthält)

en: Of course, those chain methods that take numbers can take other numbers too! So feel free to call `.drop(5)` instead of `.drop(3)` if you want to drop the first 5 elements.
de: Natürlich können solche Verkettungsmethoden, die Zahlenparameter annehmen auch andere Werte annehmen. So kannst du anstelle von `.drop(3)` z. B. auch `.drop(5)` aufrufen, wenn du die ersten fünf Elemente wegfallen lassen willst.

en: 9 Live Coding
de: 9 Live-Coding

en: One of the most exciting aspects of Sonic Pi is that it enables you to write and modify code live to make music, just like you might perform live with a guitar. One advantage of this approach is to give you more feedback whilst composing (get a simple loop running and keep tweaking it till it sounds just perfect). However, the main advantage is that you can take Sonic Pi on stage and gig with it.
de: Einer der aufregendsten Aspekte von Sonic Pi ist, dass es dir ermöglicht den Programm-Code für deine Musik live zu schreiben und zu verändern, ganz so wie wenn du mit einer Gitarre live auftreten würdest. Ein Vorteil dieses Ansatzes ist, dass du mehr Rückmeldung erhältst, noch während du komponierst - bringe eine einfache Schleife (Loop) an den Start und bearbeite sie so lange, bis sie perfekt klingt. Wie auch immer, der eigentliche Vorteil besteht darin, dass du Sonic Pi mit auf die Bühne nehmen und damit einen Auftritt absolvieren kannst.

en: In this section we'll cover the fundamentals of turning your static code compositions into dynamic performances.
de: In diesem Abschnitt behandeln wir die Grundlagen davon, wie du deine statischen Programm-Code-Kompositionen in dynamische Performances verwandeln kannst.

en: Hold on to your seats...
de: Halt dich fest ...

en: 9.1 Live Coding Fundamentals
de: 9.1 Live-Coding: Grundlagen

en: Now we've learned enough to really start having some fun. In this section we'll draw from all the previous sections and show you how you can start making your music compositions live and turning them into a performance. For that we'll need 3 main ingredients:
de: Inzwischen haben wir genug gelernt, um tatsächlich mit dem Spaß anzufangen. In diesem Abschnitt verwenden wir alles, was wir in den vorherigen Abschnitten behandelt haben und zeigen dir, wie du damit beginnen kannst, deine Musik live zu komponieren und in eine Performance zu verwandeln. Dazu benötigen wir 3 wesentliche Zutaten:

en: An ability to write code that makes sounds - CHECK!
de: Die Fähigkeit Programm-Code zu schreiben, der Klänge erzeugt - CHECK!

en: An ability to write functions - CHECK!
de: Die Fähigkeit Funktionen zu schreiben - CHECK!

en: An ability to use (named) threads - CHECK!
de: Die Fähigkeit Threads (mit Namen) zu verwenden - CHECK!

en: Alrighty, let's get started. Let's live code our first sounds. We first need a function containing the code we want to play. Let's start simple. We also want to loop calls to that function in a thread:
de: Ok, lass uns loslegen. Lass uns unsere ersten Klänge live programmieren. Zuerst brauchen wir eine Funktion, die den abzuspielenden Code enthält. Lass uns einfach beginnen. Außerdem wollen wir Aufrufe an diese Funktion in einer Schleife in einem Thread ausführen:

en: If that looks a little too complicated to you, go back and re-read the sections on functions and threads. It's not too complicated if you've already wrapped your head around these things.
de: Wenn dir das ein bisschen zu kompliziert vorkommt, lies bitte noch einmal die Abschnitte über Funktionen und Threads durch. Es ist nicht mehr so kompliziert, wenn du sie erstmal verstanden hast.

en: What we have here is a function definition which just plays note 50 and sleeps for a beat. We then define a named thread called `:looper` which just loops around calling `my_sound` repeatedly.
de: Was wir hier haben, ist die Definition einer Funktion, welche einfach die Note 50 spielt und danach einen Schlag lang schläft. Dann definieren wir einen Thread (mit Namen) - wir nennen ihn `:looper`- und er ruft in einer Schleife `my_sound` auf.

en: If you run this code, you'll hear note 50 repeating again and again...
de: Wenn du diesen Code ausführst, wirst du immer und immer wieder die Note 50 hören...

en: Changing it up
de: Einen Gang hochschalten

en: Now, this is where the fun starts. Whilst the code is *still running* change 50 to another number, say 55, then press the Run button again. Woah! It changed! Live!
de: Nun, hier fängt der Spaß an. Während der Code *noch läuft*, ändere die 50 in eine andere Zahl, sagen wir 55, und klicke nochmals auf `Ausführen`. Wow! Es hat sich geändert! Live!

en: It didn't add a new layer because we're using named threads which only allow one thread for each name. Also, the sound changed because we *redefined* the function. We gave `:my_sound` a new definition. When the `:looper` thread looped around it simply called the new definition.
de: Es hat keine neue Ebene hinzugefügt, da wir einen benannten Thread verwendet haben und es für jeden Namen nur einen Thread geben kann. Der Klang hat sich geändert, weil wir die Funktion *umdefiniert* haben. Wir haben also `:my_sound` eine neue Definition gegeben. Während im`:looper`-Thread die Schleife lief, hat er darin einfach die neue Definition aufgerufen.

en: Try changing it again, change the note, change the sleep time. How about adding a `use_synth` statement? For example, change it to:
de: Verändere die Definition der Funktion noch einmal, ändere die Note, ändere die Pausenzeit. Und wie wäre es eine `use_synth`-Aussage hinzuzufügen? Z. B. ändere die Funktion in:

en: Now it sounds pretty interesting, but we can spice it up further. Instead of playing the same note again and again, try playing a chord:
de: Jetzt klingt es schon ganz interessant, wir können es aber noch ein bisschen interessanter machen. Anstatt immer wieder die gleiche Note zu spielen, versuche einen Akkord zu spielen:

en: How about playing random notes from the chord:
de: Und wie wäre es damit, zufällige Töne des Akkords zu spielen:

en: Or using a random cutoff value:
de: Oder einen zufälligen Cut-Off-Wert:

en: Finally, add some drums:
de: Und schließlich, füge etwas Schlagzeug hinzu:

en: Now things are getting exciting!
de: Jetzt wird die Sache langsam aufregend!

en: However, before you jump up and start live coding with functions and threads, stop what you're doing and read the next section on `live_loop` which will change the way you code in Sonic Pi forever...
de: Wie auch immer, bevor du jetzt aufspringst und anfängst mit Funktionen und Threads live zu programmieren, hör mit dem was du gerade machst auf und lies den nächsten Abschnitt über `live_loop` - das wird die Art wie du in Sonic Pi programmierst, für immer verändern ...

en: 9.2 Live Loops
de: 9.2 Live-Loops

en: Live Loops
de: Live-Loops

en: Ok, so this section of the tutorial is the real gem. If you only read one section, it should be this one. If you read the previous section on Live Coding Fundamentals, `live_loop` is a simple way of doing exactly that but without having to write so much.
de: Ok, dieser Abschnitt des Tutorials ist ein echtes Juwel. Wenn du nur einen einzigen Abschnitt lesen würdest, sollte es dieser sein. Wenn du den letzten Abschnitt über die Grundlagen von Live-Coding gelesen hast - `live_loop` ist eine einfache Art genau das gleiche zu tun, aber ohne dass du so viel schreiben musst.

en: If you didn't read the previous section, `live_loop` is the best way to jam with Sonic Pi.
de: Falls du den letzten Abschnitt nicht gelesen hast - `live_loop` ist der beste Weg, um mit Sonic Pi zu jammen.

en: Let's play. Write the following in a new buffer:
de: Lass uns spielen. Schreibe Folgendes in einen neuen Puffer:

en: Now press the Run button. You hear a basic beep every beat. Nothing fun there. However, don't press Stop just yet. Change the `60` to `65` and press Run again.
de: Jetzt klicke auf `Ausführen`. Du hörst mit jedem Schlag ein einfaches Piepen. Nichts unterhaltsames daran. Klicke aber noch nicht auf `Stopp`. Ändere die `60` in `65` und klicke wieder `Ausführen`.

en: Woah! It changed *automatically* without missing a beat. This is live coding.
de: Wow! Es hat sich *automatisch*geändert ohne einen Schlag auszulassen. Das ist Live-Coding.

en: Why not change it to be more bass like? Just update your code whilst it's playing:
de: Warum es nicht ein wenig mehr nach Bass klingen lassen? Aktualisiere deinen Programm-Code, während er abläuft:

en: Then hit Run.
de: Dann klicke auf `Ausführen`.

en: Let's make the cutoff move around:
de: Lassen wir den Cut-Off sich ein wenig bewegen:

en: Hit Run again.
de: Klicke wieder auf `Ausführen`.

en: Add some drums:
de: Füge etwas Schlagzeug hinzu:

en: Change the note from `e1` to `c1`:
de: Wechsle die Note von `e1` zu `c1`:

en: Now stop listening to me and play around yourself! Have fun!
de: Nun höre nicht weiter mir zu - spiele selbst herum! Viel Spaß!

en: 9.3 Multiple Live Loops
de: 9.3 Mehrere Live-Loops

en: Multiple Live Loops
de: Mehrere Live-Loops

en: Consider the following live loop:
de: Sieh dir den folgenden Live-Loop an:

en: You may have wondered why it needs the name `:foo`. This name is important because it signifies that this live loop is different from all other live loops.
de: Vielleicht fragst du dich, warum er den Namen `:foo` braucht. Dieser Name ist wichtig, weil er bedeutet, dass sich dieser Live-Loop von allen anderen Live-Loops unterscheidet.

en: *There can never be two live loops running with the same name*.
de: *Es kann nie zwei Live-Loops mit dem selben Namen geben, die zur gleichen Zeit laufen*.

en: This means that if we want multiple concurrently running live loops, we just need to give them different names:
de: Das bedeutet, wenn wir mehrere Live-Loops gleichzeitig laufen lassen wollen, müssen wir ihnen einfach nur verschiedene Namen geben:

en: You can now update and change each live loop independently and it all just works.
de: Du kannst jetzt beide Live-Loops unabhängig voneinander verändern, und alles funktioniert - einfach so.

en: Syncing Live Loops
de: Live-Loops synchronisieren

en: One thing you might have already noticed is that live loops work automatically with the thread cue mechanism we explored previously. Every time the live loop loops, it generates a new `cue` event with the name of the live loop. We can therefore `sync` on these cues to ensure our loops are in sync without having to stop anything.
de: Du hast vielleicht schon bemerkt, dass Live-Loops automatisch mit dem Thread-Cue-Mechanismus arbeiten, den wir uns bereits angeschaut haben. Mit jedem Mal wenn der Live-Loop einen Durchlauf beginnt, generiert er ein neues Cue-Ereignis, das den Namen des Live-Loops erhält. Wir können daher mit diesen Cues in `sync` bleiben und so sicherstellen, dass unsere Schleifen sich synchronisieren, ohne dass wir etwas anhalten müssen.

en: Consider this badly synced code:
de: Schau dir diesen schlecht synchronisierten Code an:

en: Let's see if we can fix the timing and sync without stopping it. First, let's fix the `:foo` loop to make the sleep a factor of 1 - something like `0.5` will do:
de: Lass uns versuchen das Timing zu korrigieren ohne den Live-Loop zu stoppen. Zuerst lass uns den Live-Loop `:foo`reparieren, indem wir seine Sleep-Zeit zu einem Divisor von 1 machen - so etwas wie `0.5`wird z. B. funktionieren:

en: We're not quite finished yet though - you'll notice that the beats don't quite line up correctly. This is because the loops are *out of phase*. Let's fix that by syncing one to the other:
de: Damit sind wir aber noch nicht ganz fertig - du wirst bemerken, dass die Beats nicht so recht zusammenpassen. Der Grund dafür ist, dass die Live-Loops *out of phase* sind. Lass uns das reparieren, indem wir den einen mit dem anderen synchronisieren:

en: Wow, everything is now perfectly in time - all without stopping.
de: Toll, jetzt passt das Timing perfekt - ohne dass wir die Live-Loops anhalten mussten.

en: Now, go forth and live code with live loops!
de: Jetzt leg los und programmiere live mit Live-Loops!

en: 9.4 Ticking
de: 9.4 Ticks verwenden

en: Ticking
de: Ticks verwenden

en: Something you'll likely find yourself doing a lot when live coding is looping through rings. You'll be putting notes into rings for melodies, sleeps for rhythms, chord progressions, timbral variations, etc. etc.
de: Du wirst sehen, dass du beim Live-Coding sehr häufig Ringe in deinen Live-Loops verwenden wirst. Du wirst Noten in Ringen setzen für Melodien, Pausen für Rhythmen, und du wirst aus ihnen Akkordfolgen, Klangvariatonen und ähnliches generieren.

en: Ticking Rings
de: Ticks und Ringe

en: Sonic Pi provides a *very* handy tool for working with rings within `live_loop`s. It's called the tick system. In the section about the rings we were talking about the counter that is constantly increasing, like a current beat number. Tick just implements this idea. It provides you with the ability to *tick through rings*. Let's look at an example:
de: Sonic Pi bietet ein *sehr* praktisches Werkzeug, um in einem `live_loop` mit Ringen zu arbeiten. Es nennt sich Tick-System. In dem Abschnitt über Ringe haben wir über den Counter gesprochen, der etwas fortwährend hochzählt, wie z. B. eine Schlagzahl. Tick hat diese Idee eingebaut. Du kannst damit *durch einen Ring ticken*. Lass uns ein Beispiel ansehen:

en: This is equivalent to:
de: Das ist gleichbedeutend mit:

en: Here, we're just grabbing the scale E3 minor pentatonic and ticking through each element. This is done by adding `.tick` to the end of the scale declaration. This tick is local to the live loop, so each live loop can have its own independent tick:
de: Hier nehmen wir einfach die pentatonische E3-Moll-Skala (Tonleiter) und ticken durch jedes einzelne Element. Dafür wird `.tick` an das Ende der Tonleiter-Deklaration angefügt. Dieser Tick gilt nur lokal für diesen Live-Loop, so dass jeder Live-Loop seinen eigenen unabhängigen Tick haben kann:

en: You can also call `tick` as a standard fn and use the value as an index:
de: Du kannst `tick` als eine Standard-Funktion abfragen und den Wert als Index verwenden:

en: However, it is much nicer to call `.tick` at the end. The `tick` fn is for when you want to do fancy things with the tick value and for when you want to use ticks for other things than indexing into rings.
de: Aber eigentlich ist es viel einfacher, wenn du `.tick` am Ende anfügst. Die `tick`-Funktion ist dafür gedacht aufwendigere damit Dinge zu machen, oder wenn du Ticks für andere Dinge verwenden möchtest, als Werte aus einem Ring zu erhalten.

en: The magical thing about tick is that not only does it return a new index (or the value of the ring at that index) it also makes sure that next time you call tick, it's the next value. Take a look at the examples in the docs for `tick` for many ways of working with this. However, for now, it's important to point out that sometimes you'll want to just look at the current tick value and *not increase* it. This is available via the `look` fn. You can call `look` as a standard fn or by adding `.look` to the end of a ring.
de: Das Magische an Tick ist, dass er nicht nur nach jedem Aufruf einen neuen Index zurück gibt (oder den Wert aus dem Ring an diesem Indexpunkt), er stellt auch sicher, dass du beim nächsten Aufruf von Tick auch den nächsten Wert bekommst. Schau dir im Hilfe-Fenster die Beispiele für`.tick` an, um die vielen Möglichkeiten seiner Verwendung zu entdecken. Für den Moment jedoch ist es wichtig zu betonen, dass du manchmal nur den aktuellen Tick-Wert sehen willst, ohne den Tick *hochzuzählen*. Dafür gibt es die `look`-Funktion. Du kannst `look` als Standard-Funktion aufrufen oder indem du `.look` an einen Ring anfügst.

en: Naming Ticks
de: Namen für Ticks

en: Finally, sometimes you'll need more than one tick per live loop. This is achieved by giving your tick a name:
de: Schließlich wirst du gelegentlich auch mal mehr als einen Tick pro Live-Loop brauchen. das erreichst du, indem du deinem Tick einen Namen gibst:

en: Here we're using two ticks one for the note to play and another for the sleep time. As they're both in the same live loop, to keep them separate we need to give them unique names. This is exactly the same kind of thing as naming `live_loop`s - we just pass a symbol prefixed with a `:`. In the example above we called one tick `:foo` and the other `:bar`. If we want to `look` at these we also need to pass the name of the tick to `look`.
de: In diesem Beispiel verwenden wir zwei Ticks, einen für die Note und einen zweiten Tick für die Pausenwerte. Da beide sich im gleichen Live-Loop befinden, müssen wir ihnen zur Unterscheidung eindeutige Namen geben. Das ist exakt das gleiche Prinzip wie bei der Benennung von Live-Loops - wir übergeben einfach ein `:` gefolgt vom Namen. Im obigen Beispiel haben wir einen Tick `:foo` genannt und den anderen `:bar`. Auch wenn wir den Tick-Wert mit `look` nur abfragen wollen, müssen wir den Namen übergeben.

en: Don't make it too complicated
de: Mache es nicht zu kompliziert

en: Most of the power in the tick system isn't useful when you get started. Don't try and learn everything in this section. Just focus on ticking through a single ring. That'll give you most of the joy and simplicity of ticking through rings in your `live_loop`s.
de: Die meisten machtvollen Dinge im Tick-System sind wenig sinnvoll, wenn du gerade erst anfängst. Versuche nicht alles in diesem Abschnitt gleich zu lernen. Konzentriere darauf durch einen einzelnen Ring zu ticken. Das wird dir schon sehr viel von der Freude und der Einfachheit des Tickens in deinen `live_loop`s bringen.

en: Take a look at the documentation for `tick` where there are many useful examples and happy ticking!
de: Schau dir die Dokumentation für `tick`an - es gibt dort viele nützliche Beispiele. Viel Spaß beim Ticken!

en: 10 Time State
de: 10 Time-State (Stand der Zeit)

en: Time State
de: Time-State (Stand der Zeit)

en: Often it is useful to have information that is *shared across multiple threads or live loops*. For example, you might want to share a notion of the current key, BPM or even more abstract concepts such as the current 'complexity' (which you'd potentially interpret in different ways across different threads). We also don't want to lose any of our existing determinism guarantees when doing this. In other words, we'd still like to be able to share code with others and know exactly what they'll hear when they run it. At the end of Section 5.6 of this tutorial we briefly discussed why we *should not use variables to share information across threads* due to a loss of determinism (in turn due to race conditions).
de: Oftmals ist es sinnvoll, Informationen zu haben, die *über verschiedenen Threads or Live-Loops geteilt werden kann*. Beispielsweise möchtest du vielleicht die aktuelle Tonart, BPM oder auch abstraktere Konzepte wie z. B. die aktuelle 'Komplexität' (die wiederum in den verschiedenen Threads unterschiedlich interpretiert werden könnte) teilen. Wenn wir dies tun, möchten wir aber auch nicht auf die garantierte Bestimmbarkeit von Sonic Pi verzichten. In anderen Worten: Wir möchten immer noch Programm-Code mit anderen teilen und sicherstellen können, dass wir genau wissen, was sie hören, wenn sie ihn ausführen. Am Ende des Abschnitts 5.6. dieses Tutorials haben wir kurz darüber gesprochen, warum wir *Variablen nicht nutzen sollten, um Informationen zwischen Threads zu teilen*, da wir dadurch diese Vorhersagbarkeit verlieren (aufgrund von Race Conditions).

en: Meet `get` and `set`...
de: Sag Hallo zu`get` und `set`...

en: 10.1 Set and Get
de: 10.1 Set und Get

en: Set and Get
de: Set und Get

en: Sonic Pi has a global memory store called Time State. The two main things you do with it are to `set` information and `get` information. Let's dive deeper...
de: Sonic Pi verfügt über einen globalen Speicherbereich, der Time-State genannt wird. Die beiden wesentliche damit möglichen Dinge sind das Setzen von Informationen (Set) und das Holen von Information (Get). Lass uns das genauer ansehen ...

en: To store information into the Time State we need two things:
de: Um Informationen in den Time-State zu speichern benötigen wir zwei Dinge:

en: the information we want to store,
de: die Information, die wir speichern wollen,

en: a unique name (key) for the information.
de: einen eindeutigen Namen (Schlüssel) für die Information.

en: For example, we might want to store the number `3000` with the key `:intensity`. This is possible using the `set` function:
de: Zum Beispiel wollen wir vielleicht die Zahl `3000` unter dem Schlüsselnamen `:intensity` speichern. Das ist möglich mit der `set`-Funktion:

en: We can use any name for our key. If information has already been stored with that key, our new `set` will override it:
de: Wir können für den Schlüssel einen beliebigen Namen verwenden. Wurde unter diesem Schlüsselnamen bereits Information gespeichert, wird unser neuer `set` -Befehl diese überschreiben:

en: In the above example, as we stored both numbers under the same key, the last call to `set` 'wins', so the number associated with `:intensity` will be `3000` as the first call to `set` is effectively overridden.
de: In dem obigen Beispiel haben wir beide Werte unter dem gleichen Schlüsselnamen abgespeichert, und der letzte `set`-Befehl 'gewinnt', so dass die Zahl 3000 mit `:intensity` assoziiert wird, also unser erster `set`-Befehl damit überschrieben wurde.

en: To fetch information from the Time State we just need the key we used to `set` it, which in our case is `:intensity`. We then just need to call `get[:intensity]` which we can see by printing out the result to the log:
de: Um Informationen aus dem Time-State wiederzuholen, benötigen wir nur den Schlüssel, den wir bei `set` verwendet haben, also in unserem Fall `:intensity`. Wir müssen jetzt nur `get[:intensity]` aufrufen, und das Ergebnis wird uns im Protokoll angezeigt:

en: Notice that calls to `get` can return information that was `set` in a previous run. Once a piece of information has been `set` it is available until either the information is overridden (just like we clobbered the `:intensity` value of `1000` to `3000` above) or Sonic Pi is closed.
de: Beachte, dass Aufrufe von `get` Informationen zurückgeben können, die bei einem vorherigem Programm-Lauf gesetzt wurden. Wurde eine Information einmal mit Hilfe von `set` gesetzt, bleibt sie solange verfügbar, bis sie entweder überschrieben wird (so wie wir den Wert `1000` von `intensity` mit `3000` vertauscht haben) oder Sonic Pi beendet wird.

en: Multiple Threads
de: Mehrere Threads

en: The main benefit of the Time State system is that it can be safely used across threads or live loops. For example, you could have one live loop setting information and another one getting it:
de: Der wesentliche Vorteil des Time-State-Systems ist, dass es auf sichere Art und Weise zwischen Threads und zwischen Live-Loops verwendet werden kann. Beispielsweise könnte ein Live-Loop Informationen setzen und ein anderer diese auslesen:

en: The nice thing about using `get` and `set` across threads like this is that it will always produce the same result every time you hit run. Go on, try it. See if you get the following in your log:
de: Das Schöne an der Verwendung von `get` und `set` über Threads hinweg ist, dass immer das gleiche Ergebnis ausgegeben wird, wenn der Programm-Code gestartet wird. Los, probiere es selbst. Sieh nach, ob dir das Folgende im Protokoll ausgegeben wird:

en: {run: 0, time: 0.0}
     └─ 125.72265625
    {run: 0, time: 0.5}
     └─ 125.72265625
    {run: 0, time: 1.0}
     └─ 76.26220703125
    {run: 0, time: 1.5}
     └─ 76.26220703125
    {run: 0, time: 2.0}
     └─ 114.93408203125
    {run: 0, time: 2.5}
     └─ 114.93408203125
    {run: 0, time: 3.0}
     └─ 75.6048583984375
    {run: 0, time: 3.5}
     └─ 75.6048583984375
de: {run: 0, time: 0.0} 
     └─ 125.72265625
    {run: 0, time: 0.5}
     └─ 125.72265625
    {run: 0, time: 1.0}
     └─ 76.26220703125
    {run: 0, time: 1.5}
     └─ 76.26220703125
    {run: 0, time: 2.0}
     └─ 114.93408203125
    {run: 0, time: 2.5}
     └─ 114.93408203125
    {run: 0, time: 3.0}
     └─ 75.6048583984375
    {run: 0, time: 3.5}
     └─ 75.6048583984375

en: Try running it a few times - see, it's the same every time. This is what we call deterministic behaviour and it's really very important when we want to share our music as code and know that the person playing the code is hearing exactly what we wanted them to hear (just like playing an MP3 or internet stream sounds the same for all listeners).
de: Starte das Programm einfach mehrmals hintereinander - du siehst, dass das Ergebnis jedes Mal das Gleiche ist. Wir bezeichnen dies als deterministisches (vorhersagbares) Verhalten, und es ist sehr wichtig, wenn wir unsere Musik als Programm-Code weitergeben, zu wissen, dass die Person, die den Code ausführt, genau das hören wird, was wir sie hören lassen wollten (ähnlich wie beim Abspiel einer MP3 oder beim Streamen für alle Hörer dasselbe zu hören ist).

en: A Simple Deterministic State System
de: Ein einfaches deterministisches State-System

en: Back in Section 5.6 we discussed why using variables across threads can lead to random behaviour. This stops us from being able to reliably reproduce code such as this:
de: In Abschnitt 5.6 haben wir darüber gesprochen, wie die Nutzung von Variablen über verschiedenen Threads hinweg zu zufälligen Resultaten führen kann. Das hindert uns daran Programm-Code wie diesen zuverlässig zu reproduzieren:

en: ## An Example of Non-Deterministic Behaviour
    ## (due to race conditions caused by multiple
    ## live loops manipulating the same variable
    ## at the same time).
    ##  
    ## If you run this code you'll notice
    ## that the list that's printed is
    ## not always sorted!
    a = (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      a = a.shuffle
      sleep 0.5
    end
    live_loop :sorted do
      a = a.sort
      sleep 0.5
      puts "sorted: ", a
    end
de: ## Ein Beispiel für ein nicht-deterministisches Verhalten
    ## (aufgrund von Race Conditions, die durch
    ## mehrfache Live-Loops ausgelöst werden, die den Wert
    ## der selben Variable verändern).
    ##  
    ## Wenn du den Code startest, siehst du,
    ## dass die Liste, die ausgegeben wird,
    ## nicht immer sortiert ist!
    a = (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      a = a.shuffle
      sleep 0.5
    end
    live_loop :sorted do
      a = a.sort
      sleep 0.5
      puts "sorted: ", a
    end

en: Let's take a look at how this might look using `get` and `set`:
de: Lass uns sehen, wie wir hier `get` und `set` einsetzen könnten:

en: ## An Example of Deterministic Behaviour
    ## (despite concurrent access of shared state)
    ## using Sonic Pi's new Time State system.
    ##
    ## When this code is executed, the list that's
    ## printed is always sorted!
    set :a, (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      set :a, get[:a].shuffle
      sleep 0.5
    end
    live_loop :sorted do
      set :a, get[:a].sort
      sleep 0.5
      puts "sorted: ", get[:a]
    end
de: ## Ein Beispiel für deterministisches Verhalten
    ## (trotz gleichzeitigem Zugriff auf einen geteilten Zustand)
    ## mit Hilfe des Sonic Pi Time State Systems.
    ##
    ## Bei Ausführung dieses Codes,
    ## wird die Liste immer sortiert ausgegeben!
    set :a, (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      set :a, get[:a].shuffle
      sleep 0.5
    end
    live_loop :sorted do
      set :a, get[:a].sort
      sleep 0.5
      puts "sorted: ", get[:a]
    end

en: Notice how this code is pretty much identical to the version using a variable before it. However when you run the code, it behaves as you would expect with any typical Sonic Pi code - *it does the same thing every time* in this case thanks to the Time State system.
de: Beachte, dass dieser Code fast identisch ist mit dem Code, der eine Variable zum Teilen der Information verwendet hat. Wenn du ihn ausführst verhält er sich allerdings so, wie du es bei jedem typischen Sonic Pi Code erwarten würdest - *er verhält sich immer gleich*, in diesem Fall dank des Time-State-Systems.

en: Therefore, when sharing information across live loops and threads, use `get` and `set` instead of variables for deterministic, reproducible behaviour.
de: Deshalb verwende für ein vorhersagbares und reproduzierbares Verhalten anstelle von Variablen immer `get` und `set`, wenn du Daten zwischen Live-Loops und zwischen Threads teilst.

en: 10.2 Sync
de: 10.2 Synchronisation

en: Sync
de: Synchronisation

en: Section 5.7 introduced the functions `cue` and `sync` when dealing with the issue of synchronising threads. What it didn't explain was that it is the Time State system which provides this functionality. It just so happens that `set` is actually a variation of `cue` and is built on top of the same core functionality which is to insert information into the Time State system. Additionally, `sync` is also designed in such a way that it works seamlessly with Time State - any information that we plan to store in Time State we can sync on. In other words - *we `sync` on events yet to be inserted into Time State*.
de: In Abschnitt 5.7 haben wir die Funktionen `cue` und `sync` vorgestellt, für die Synchronisierung von Threads. Was wir dort nicht erklärt haben ist, dass es das Time-State-System ist, das diese Funktionalität bereitstellt. Tatsächlich ist `set` eine Variation von `cue` und baut auf er selben Kernfunktion auf, Informationen im Time-State-System zu hinterlegen. Darüber hinaus ist `sync`so gestaltet, dass es unmittelbar mit Time-State arbeitet - jegliche Information, die wir zukünftig im Time State ablegen wollen, kann auch zur Synchronisierung verwendet werden. Mit anderen Worten - *wir synchronisieren auf Ereignisse, die erst noch im Time-State gespeichert werden*.

en: Waiting for Events
de: Warten auf Ereignisse

en: Let's take a quick look at how to use `sync` to wait for new events to be added to Time State:
de: Lass uns mal ansehen, wie `sync` verwendet wird, um auf neue Ereignisse zu warten, die dem Time-State hinzugefügt werden:

en: In this example first we create a thread which waits for a `:foo` event to be added to the Time State. After this thread declaration we sleep for 2 beats and then `set` `:foo` to be `1`. This then releases the `sync` which then moves to the next line which is to trigger the `:ambi_lunar_land` sample.
de: In diesem Beispiel erstellen wir zuerst einen Thread, der darauf wartet, dass ein Ereignis ':foo' dem Time-State hinzugefügt wird. Nach dieser Thread-Deklaration schlafen wir für 2 Schläge, und dann setzen wir mit 'set' den Wert für ':foo' auf '1'. Dies entfernt `sync`, was dann auf die nächste Zeile übergeht, in der das ':ambi_lunar_land'-Sample getriggert wird.

en: Note that `sync` always waits for *future events* and that it will block the current thread waiting for a new event. Also, it will inherit the logical time of the thread which triggered it via `set` or `cue` so it may also be used to sync time.
de: Beachte, dass `sync` immer auf *zukünftige Ereignisse* wartet, und dass es den gegenwärtigen Thread blockieren wird, während es auf ein neues Ereignis wartet. Zusätzlich erbt es die logische Zeit des Threads, der es via `set` oder `cue` getriggert hat, sodass sich hierdurch auch die Zeit von zwei Threads synchronisieren lässt.

en: Passing values into the Future
de: Übergabe von Werten an die Zukunft

en: In the example above we set `:foo` to `1` which we did nothing with. We can actually get this value from the thread calling `sync`:
de: In diesem Beispiel setzen wir ':foo' auf '1', darüber hinaus haben wir damit nichts angefangen. Diesen Wert können wir im Thread tatsächlich abfragen ('get'), indem wir `sync` aufrufen:

en: Note that values that are passed through `set` and `cue` must be thread safe - i.e. immutable rings, numbers, symbols or frozen strings. Sonic Pi will throw an error if the value you are attempting to store in the Time State is not valid.
de: Beachte, dass Werte die mit Hilfe von `set` und `cue übergeben werden, thread-safe sein müssen - dies sind unveränderliche Ringe (immutable rings), Zahlen, Symbole oder eingefrorene Zeichenketten (frozen strings). Sonic Pi gibt einen Fehler aus, falls du einen Wert im Time-Store ablegen willst, der nicht gütig ist.

en: 10.3 Pattern Matching
de: 10.3 Muster-Abgleich

en: Pattern Matching
de: Muster-Abgleich

en: When getting and setting information into the Time State, it's possible to use more complex keys than basic symbols such as `:foo` and `:bar`. You can also use URL style strings called paths such as `"/foo/bar/baz"`. Once we start working with paths, we can then start taking advantage of Sonic Pi's sophisticated pattern matching system to `get` and `sync` with 'similar' rather than 'identical' paths. Let's take a look.
de: Beim Holen und Setzen von Informationen unter Verwendung von Time-State lassen sich komplexere Schlüssel verwenden als einfache Symbole wie `:foo` und `:bar`. Du kannst auch Zeichenketten in der Art von URLs verwenden, wie z.B. `"/foo/bar/baz"`. Sobald wir anfangen mit Pfaden zu arbeiten, können wir auch die Vorteile des ausgeklügelten Muster-Abgleich-Systems von Sonic Pi nutzen, um `get` und `sync` mit 'ähnlichen' und nicht mit 'identischen' Pfaden zu synchronisieren. Lass uns einen Blick darauf werfen.

en: Match any path segment
de: Abgleich mit allen Pfad-Segmenten

en: Let's assume we want to wait for the next event that has three path segments:
de: Lass uns annehmen wir möchten auf das nächste Ereignis warten, das die folgenden drei Pfad-Segmente enthält:

en: This will match any Time State event with exactly three path segments, regardless of their names. For example:
de: Dieses Muster wird zu jedem Time-State-Ereignis passen, das aus exakt drei Pfadsegmenten besteht, unabhängig von deren Namen. Zum Beispiel:

en: However, it will *not* match paths with fewer or more path segments. The following will not match:
de: Allerdings wird es *nicht* zu Ereignissen mit wenigeren oder mehr Pfad-Segmente passen. Die folgenden würden nicht passen:

en: Each `*` means *any content*. So we could match paths with just one segment with `/*` or paths with five segments with `/*/*/*/*/*`
de: Jeder `*` bedeutet *jeder Inhalt*. Das bedeutet, wir können Pfade mit nur einem Segment mit `/*` oder Pfade aus fünf Segmenten mit `/*/*/*/*/*` abgleichen

en: Matching partial segments
de: Abgleich mit Teilsegmenten

en: If we know what the segment is going to start or finish with, we can use a `*` in addition to a partial segment name. For example: `"/foo/b*/baz"` will match any path that has three segments, the first of which is `foo`, the last `baz` and the middle segment can be anything that starts with `b`. So, it would match:
de: Wenn wir wissen, womit das Segment beginnen oder enden wird, können wir ein `*` zusätzlich zum Namen eines Teilsegments verwenden. Zum Beispiel: `"/foo/b*/baz"`passt zu jedem Pfad, der drei Segmente hat, von denen das erste `foo`, das letzte `baz` und das mittlere Segment alles sein kann, was mit `b` beginnt. Also, es würde passen zu:

en: However, it wouldn't match the following:
de: Allerdings würde es nicht zu Folgendem passen:

en: You can also place the `*` at the start of the segment to specify the last characters of a segment: `"/foo/*zz/baz"` which will match any 3 segment `cue` or `set` where the first segment is `foo`, the last is `baz` and the middle segment ends with `zz` such as `"cue "/foo/whizz/baz"`.
de: Du kannst das `*` auch an den Anfang des Segments setzen, um die letzten Zeichen eines Segments anzugeben: `"/foo/*zz/baz"`, wird zu jedem `cue` or `set` bestehend aus 3 Segmenten passen, wo das erste Segment `foo`, das letzte `baz` ist und das mittlere Segment auf `zz` endet, so wie `"cue "/foo/whizz/baz"`.

en: Matching Nested Path Segments
de: Abgleich mit verschachtelten Pfadsegmenten

en: Sometimes you don't know how many path segments you want to match. In these cases you can use the powerful double star: `**` such as `"/foo/**/baz"` which will match:
de: Manchmal weißt du nicht, wie viele Pfadsegmente du abgleichen möchtest. In diesen Fällen kannst du den mächtigen Doppelstern `**` verwenden, wie in `"/foo/**/**/baz"`, das übereinstimmt mit:

en: Matching Single Letters
de: Abgleich mit einzelnen Buchstaben

en: You can use the `?` character to match against a single char such as `"/?oo/bar/baz"` which will match:
de: Du kannst das `?` verwenden, um mit einem beliebigen einzelnen Zeichen abzugleichen. `"/?oo/bar/baz"` passt zu:

en: Matching Multiple Words
de: Abgleich mit mehreren Wörtern

en: If you know that a segment may be one of a select number of words, you can use the `{` and `}` matchers to specify a list of choices such as `"/foo/{bar,beans,eggs}/quux"` which will only match the following:
de: Wenn du weißt, das ein Segment eines aus einer bestimmten Reihe von Wörtern ist, kannst du eine Auswahlliste zwischen `{` und `}` setzen, so wie `"/foo/{bar,beans,eggs}/quux"`, was nur auf das Folgende passt:

en: Matching Multiple Letters
de: Abgleich mit mehreren Zeichen

en: Finally, you can match against a selection of letters if you use the `[` and `]` matchers to specify a list of choices such as `"/foo/[abc]ux/baz"` which will match only:
de: Schließlich kannst du auch noch gegen eine Auswahl von Buchstaben abgleichen, indem du eine Auswahlliste zwischen `{` und `}` setzt, so wie `"/foo/[abc]ux/baz"`, was nur passen wird zu:

en: You can also use the `-` character to specify ranges of letters. For example `"/foo/[a-e]ux/baz"` which will match only:
de: Du kannst mit `-`auch Buchstabenbereiche angeben. Zum Beispiel `"/foo/[a-e]ux/baz"`, was nur passt zu:

en: Combining Matchers
de: Kombination von Abgleichen

en: OSC Pattern Matching
de: OSC Musterabgleich

en: Once you've mastered converting code to music, you might wonder - what's next? Sometimes the constraints of working purely within Sonic Pi's syntax and sound system can be exciting and put you into a new creative position. However, sometimes it is essential to break out of the code into the real world. We want two extra things:
de: Wenn du es geschafft hast Programm-Code in Musik zu verwandeln, fragst du dich vielleicht - was kommt als nächstes? Manchmal sind die Beschränkungen, die darin bestehen nur mit Sonic Pis Syntax und Soundsystem zu arbeiten, aufregend und versetzen dich in eine neue kreative Lage. Manchmal jedoch ist es nochmal etwas grundlegend anderes, aus dem Programm-Code auszubrechen - in die reale Welt. Wir brauchen zwei zusätzliche Dinge:

en: To be able to convert actions in the real world into Sonic Pi events to code with
de: Die Möglichkeit Ereignisse in der realen Welt in Sonic-Pi-Ereignisse umzuwandeln, um damit zu programmieren

en: To be able to use Sonic Pi's strong timing model and semantics to control and manipulate objects in the real world
de: Die Möglichkeit Sonic Pis starkes Takt-Modell und Semantik zu nutzen, um Objekte in der realen Welt zu steuern und zu verändern

en: Luckily there's a protocol that's been around since the 80s that enables exactly this kind of interaction - MIDI. There's an incredible number of external devices including keyboards, controllers, sequencers, and pro audio software that all support MIDI. We can use MIDI to receive data and also use it to send data.
de: Glücklicherweise gibt es ein Protokoll, das schon seit den 80ern existiert, das genau diese Art von Interaktion möglich macht - MIDI. Es gibt eine unglaubliche Anzahl an externen Geräten, unter anderem Keyboards, Controller, Sequencer, und professionelle Audio Software, die alle MIDI unterstützen. Wir können MIDI nutzen, um Daten zu empfangen und auch um Daten zu senden.

en: Sonic Pi provides full support for the MIDI protocol enabling you to connect your live code to the real world. Let's explore it further...
de: Sonic Pi bietet vollständige Unterstützung für das MIDI Protokoll, was es dir erlaubt deinen Live-Code mit der realen Welt zu verbinden. Lass uns das genauer untersuchen ...

en: In this section we will learn how to connect a MIDI controller to send events into Sonic Pi to control our synths and sounds. Go and grab a MIDI controller such as a keyboard or control surface and let's get physical!
de: In diesem Abschnitt werden wir lernen einen MIDI-Controller anzuschließen, um Ereignisse an Sonic Pi zu senden, mit denen unsere Synths und Klänge steuern. Besorge dir einen MIDI-Controller, wie z. B. ein Keyboard oder eine Controller-Oberfläche und lass uns handgreiflich werden!

en: Connecting a MIDI Controller
de: MIDI-Controller verbinden

en: In order to get information from an external MIDI device into Sonic Pi we first need to connect it to our computer. Typically this will be via a USB connection, although older equipment will have a 5-pin DIN connector for which you'll need hardware support for your computer (for example, some sound cards have MIDI DIN connectors). Once you've connected your device, launch Sonic Pi and take a look at the IO section of the Preferences panel. You should see your device listed there. If not, try hitting the 'Reset MIDI' button and see if it appears. If you're still not seeing anything, the next thing to try is to consult your operating system's MIDI config to see if it sees your device. Failing all that, feel free to ask questions in our friendly forums: https://in-thread.sonic-pi.net
de: Um Informationen von einem externen MIDI-Gerät in Sonic Pi zu bekommen müssen wir es zunächst an unseren Computer anschließen. Normalerweise wird das mittels einer USB-Verbindung sein, ältere Geräte hingegen haben einen 5-Pol-DIN-Stecker für den du Hardwareunterstützung in deinem Computer brauchst (manche Audio-Interfaces bzw. Soundkarten haben MIDI-DIN-Stecker). Nachdem du dein Gerät angeschlossen hast, starte Sonic Pi und wirf einen Blick auf den I/O-Bereich in den Einstellungen. Du solltest dein Gerät dort aufgelistet finden. Falls nicht, klicke auf 'MIDI zurücksetzen' und sieh nach, ob es auftaucht. Wenn du immer noch keinen Eintrag in der Liste findest, ist der nächste Schritt zu versuchen in der MIDI-Konfiguration deines Betriebssystems nachzusehen, um zu sehen ob dein Gerät erkannt wird. Wenn das alles fehlschlägt, kannst du gerne in unserem freundlichen öffentlichen Forum Fragen dazu stellen: https://in-thread.sonic-pi.net

en: Receiving MIDI Events
de: MIDI-Ereignisse empfangen

en: Once your device is connected, Sonic Pi will automatically receive events. You can see for yourself by manipulating your MIDI device and looking at the cue logger in the bottom right of the application window below the log (if this isn't visible go to Preferences->Editor->Show & Hide and enable the 'Show cue log' tickbox). You'll see a stream of events such as:
de: Sobald dein Gerät verbunden ist, wird Sonic Pi automatisch Ereignisse empfangen. Du kannst das selbst nachprüfen indem du dein MIDI-Gerät bedienst und auf das Cue-Protokoll unten rechts im Anwendungsfenster unterhalb des Protokolls schaust (falls es nicht sichtbar ist, gehe zu Einstellungen->Editor->Ein-/Ausblenden und aktiviere 'Zeige Cue-Protokoll'). Du wirst einen Datenstrom von Ereignissen sehen wie:

en: Once you can see a stream of messages like this, you've successfully connected your MIDI device. Congratulations, let's see what we can do with it!
de: Wenn du einen Strom von Signalen wie diesen siehst, hast du dein MIDI-Gerät erfolgreich verbunden. Glückwunsch, lass uns schauen, was wir damit machen können!

en: MIDI Time State
de: MIDI-Time-State

en: These events are broken into two sections. Firstly there's the name of the event such as `/midi:nanokey2_keyboard:0:1/note_on` and secondly there's the values of the event such as `[18, 62]`. Interestingly, these are the two things we need to store information in Time State. *Sonic Pi automatically inserts incoming MIDI events into Time State*. This means you can `get` the latest MIDI value and also `sync` waiting for the next MIDI value using everything we learned in section 10 of this tutorial.
de: Diese Ereignisse sind in zwei Abschnitte unterteilt. Als Erstes steht da der Name des Ereignisses, wie z. B. `/midi:nanokey2_keyboard:0:1/note_on` und zum Zweiten gibt es die Werte des Ereignisses wie z. B. `[18, 62]`. Interessanterweise sind das die zwei Dinge, die wir brauchen, um Ereignisse in Time-State zu speichern. *Sonic Pi fügt eingehende MIDI-Ereignisse automatisch in Time-State ein*. Das bedeutet du kannst auf den letzten MIDI -Wert mit `get` zugreifen, und auch mit `sync` auf den nächsten MIDI-Wert warten - dabei kannst du alles anwenden, was wir in Abschnitt 10 dieses Tutorials gelernt haben.

en: Controlling Code
de: Programm-Code steuern

en: Now we've connected a MIDI device, seen its events in the cue log and discovered that our knowledge of Time State is all we need to work with the events, we can now start having fun. Let's build a simple MIDI piano:
de: Nachdem wir jetzt ein MIDI-Gerät verbunden haben, dessen Ereignisse im Cue-Protokoll sehen konnten und wissen, dass unsere Kenntnisse über Time-State alles sind, was wir zum Arbeiten mit Ereignissen brauchen - können wir jetzt anfangen Spaß zu haben. Lass uns ein einfaches MIDI-Piano bauen:

en: There's a few things going on in the code above including some issues. Firstly, we have a simple `live_loop` which will repeat forever running the code between the `do`/`end` block. This was introduced in Section 9.2. Secondly, we're calling `sync` to wait for the next matching Time State event. We use a string representing the MIDI message we're looking for (which is the same as was displayed in the cue logger). Notice that this long string is provided to you by Sonic Pi's autocompletion system, so you don't have to type it all out by hand. In the log we saw that there were two values for each MIDI note on event, so we assign the result to two separate variables `note` and `velocity`. Finally we trigger the `:piano` synth passing our note.
de: Es passieren einige Dinge im obigen Code, einschließlich einiger Probleme. Zunächst haben wir da einen einfachen `live_loop`, der den Code zwischen dem `do`/`end` Block unendlich wiederholt. Das wurde im Abschnitt 9.2 behandelt. Danach rufen wir `sync` auf, um auf das nächste Time-State-Ereignis zu warten. Wir benutzen eine Zeichenkette, die das MIDI-Signal repräsentiert, nach dem wir suchen (es ist dasselbe, das uns im Cue-Protokoll angezeigt wurde). Achte darauf, wie dir Sonic Pi die vollständige Zeichenkette mit seinem Autovervollständigungssystem erstellt, sodass du sie nicht komplett von Hand eintippen musst. Im Protokoll haben wir gesehen, dass es zwei Werte für jedes MIDI-Note-on-Ereignis gab, also weisen wir das Ergebnis zwei separaten Variablen `note` und `velocity` zu. Schließlich triggern wir den `:piano`-Synth und übergeben unsere Note.

en: Now, you try it. Type in the code above, replace the sync key with a string matching your specific MIDI device and hit Run. Hey presto, you have a working piano! However, you'll probably notice a couple of problems: firstly all the notes are the same volume regardless of how hard you hit the keyboard. This can be easily fixed by using the velocity MIDI value and converting it to an amplitude. Given that MIDI has a range of 0->127, to convert this number to a value between 0->1 we just need to divide it by 127:
de: Jetzt probiere du es. Gib den obigen Programm-Code ein, ersetzte in sync den Schlüssel mit einer Zeichenkette, die zu deinem spezifischen MIDI-Gerät passt und klicke auf Ausführen. Hey, und schon hast du ein funktionierendes Klavier! Wahrscheinlich fallen dir jedoch ein paar Probleme auf: Unabhängig davon wie stark du die Tasten anschlägst, klingen die Noten immer gleich laut. Das lässt sich leicht dadurch beheben, dass wir den MIDI-Wert für Velocity (Anschlagstärke) nutzen und zu Lautstärke wandeln. Da MIDI einen Wertebereich von 0-127 hat, müssen wir diese Zahl in einen Wert zwischen 0->1 zu konvertieren, indem wir sie einfach durch 127 teilen:

en: Update the code and hit Run again. Now the velocity of the keyboard is honoured. Next, let's get rid of that pesky pause.
de: Aktualisiere deinen Code und klicke nochmals auf Ausführen. Jetzt wird der Anschlagstärke des Keyboards berücksichtigt. Als nächstes lass uns diese nervige Pause loswerden.

en: Removing Latency
de: Latenz entfernen

en: Before we can remove the pause, we need to know why it's there. In order to keep all the synths and FX well-timed across a variety of differently capable CPUs, Sonic Pi schedules the audio *in advance* by 0.5s by default. (Note that this added latency can be configured via the fns `set_sched_ahead_time!` and `use_sched_ahead_time`). This 0.5s latency is being added to our `:piano` synth triggers as it is added to all synths triggered by Sonic Pi. Typically we really want this added latency as it means all synths will be well timed. However, this only makes sense for synths triggered by code using `play` and `sleep`. In this case, we're actually triggering the `:piano` synth with our external MIDI device and therefore don't want Sonic Pi to control the timing for us. We can turn off this latency with the command `use_real_time` which disables the latency for the current thread. This means you can use real time mode for live loops that have their timing controlled by `sync`ing with external devices, and keep the default latency for all other live loops. Let's see:
de: Bevor wir die Pause entfernen können, müssen wir herausfinden, warum sie da ist. Um alle Synths und Effekte auf einer Vielzahl von unterschiedlich starken CPUs gut getaktet zu halten, setzt Sonic Pi Audio-Ereignisse standardmäßig 0,5 Sekunden *im Voraus* an. (Beachte, dass diese zusätzliche Latenz über die Funktionen `set_sched_ahead_time!` und `use_sched_ahead_time` konfiguriert werden kann). Diese 0,5 Sekunden Latenz werden zu unseren `:piano` Synth-Triggern hinzugefügt, so wie bei allen Synths, die von Sonic Pi getriggert werden. Typischerweise wollen wir diese hinzugefügte Latenz, weil sie bedeutet, dass alle Synths gut getaktet laufen werden. Das ergibt jedoch nur Sinn bei Synths, die von Programm-Code durch `play` und `sleep` getriggert werden. In diesem Fall triggern wir den `:piano`-Synth jedoch tatsächlich mit unserem externen MIDI-Gerät und möchten daher nicht, dass Sonic Pi das Timing für uns steuert. Wir können diese Latenz mit dem Befehl `use_real_time` ausschalten, der für den aktuellen Thread die Latenz ausschaltet. Das bedeutet, dass du den Echtzeitmodus `use_real_time` für Live-Loops verwenden kannst, die ihr Timing mittels `sync` mit externen Geräten synchronisieren, und für alle anderen Live-Loops die normale Latenz behalten kannst. Lass mal sehen:

en: Update your code to match the code above and hit Run again. Now we have a low latency piano with variable velocity coded in just 5 lines. Wasn't that easy!
de: Passe deinen Code entsprechend dem obigen Code an und klicke nochmals auf Ausführen. Jetzt haben wir ein Piano mit niedriger Latenz und variabler Anschlagstärke mit nur 5 Zeilen programmiert. Wenn das nicht einfach war!

en: Getting Values
de: Werte erhalten

en: Finally, as our MIDI events are going straight into the Time State, we can also use the `get` fn to retrieve the last seen value. This doesn't block the current thread and returns `nil` if there's no value to be found (which you can override by passing a default value - see the docs for `get`). Remember that you can call `get` in any thread at any time to see the latest matching Time State value. You can even use `time_warp` to jump back in time and call `get` to see past events...
de: Schließlich, da unsere MIDI-Ereignisse direkt in den Time-State gehen, können wir die `get`-Funktion benutzen, um den letzten gesehenen Wert zu erhalten. Dies blockiert nicht den aktuellen Thread und gibt `nil` zurück, wenn es keinen Wert gibt (was du überschreiben kannst, indem du einen Standardwert übergibst - sieh dir dafür die Dokumentation für `get` an). Erinnere dich, dass du `get` in jedem Thread und zu jeder Zeit aufrufen kannst, um den letzten passenden Time-State-Wert zu erhalten. Du kannst sogar `time_warp` benutzen, um in der Zeit zurück zu springen und mit `get` vergangene Events angezeigt zu bekommen ...

en: Now You are in Control
de: Jetzt hast du die Kontrolle

en: The exciting thing now is that you can now use the same code structures to `sync` and `get` MIDI information from any MIDI device and do whatever you want with the values. You can now choose what your MIDI device will do!
de: Das eigentlich Aufregende ist, dass du dieselben Code-Strukturen verwenden kannst, um mittels `sync` und `get` MIDI-Informationen mit jedem beliebigen MIDI-Gerät zu synchronisieren und du mit diesen Werten tun kannst, was du willst. Jetzt kannst du entscheiden, was dein MIDI-Gerät tun wird!

en: 11.2 MIDI Out
de: 11.2 MIDI-Ausgabe

en: MIDI Out
de: MIDI-Ausgabe

en: In addition to receiving MIDI events we can also send out MIDI events to trigger and control external hardware synths, keyboards and other devices. Sonic Pi provides a full set of fns for sending various MIDI messages such as:
de: Zusätzlich zum Empfangen von MIDI-Ereignissen können wir auch MIDI-Ereignisse aussenden, um externe Hardware-Synths, Keyboards und andere Geräte zu triggern und zu steuern. Sonic Pi bietet einen vollständigen Satz von Funktionen zum Senden verschiedener MIDI-Signale wie z. B:

en: Note on - `midi_note_on`
de: Note an - `midi_note_on`

en: Note off - `midi_note_off`
de: Note aus - `midi_note_off`

en: Control change - `midi_cc`
de: Steuerungsänderung - `midi_cc`

en: Pitch bend - `midi_pitch_bend`
de: Tonhöhenänderung - `midi_pitch_bend`

en: Clock ticks - `midi_clock_tick`
de: Taktgeber - `midi_clock_tick`

en: There are many other supported MIDI messages too - check out the API documentation for all the other fns that start with `midi_`.
de: Es gibt noch eine Menge weiterer MIDI-Signale, die unterstützt werden – sieh dir in der API-Dokumentation alle weiteren Funktionen an, die mit `midi_` beginnen.

en: Connecting to a MIDI Device
de: Mit einem MIDI-Gerät verbinden

en: In order to send a MIDI message to an external device, we must first have connected it. Check out the subsection 'Connecting a MIDI Controller' in section 11.1 for further details. Note that if you're using USB, connecting to a device which you're sending to (rather than receiving from) is the same procedure. However, if you're using the classic DIN connectors, make sure you connect to the MIDI out port of your computer. You should see your MIDI device listed in the preferences pane.
de: Um ein MIDI-Signal an ein externes Gerät zu senden, muss es zunächst angeschlossen sein. Für weitere Details sieh dir den Unterabschnitt 'Anschließen eines MIDI-Controllers' in Abschnitt 11.1 an. Beachte, dass, wenn du dich über USB mit einem Gerät verbindest, an das du sendest (anstatt zu empfangen) die Prozedur jeweils die gleiche ist. Wenn du jedoch die klassischen DIN-Anschlüsse verwendest, stelle sicher, dass du es mit dem MIDI-Ausgang deines Computers verbindest. Du solltest dein MIDI-Gerät in den Einstellungen sehen.

en: Sending MIDI events
de: MIDI-Ereignisse senden

en: The many `midi_*` fns work just like `play`, `sample` and `synth` in that they send a message at the current (logical) time. For example, to spread out calls to the `midi_*` fns you need to use `sleep` just like you did with `play`. Let's take a look:
de: Die vielen `midi_*`-Funktionen arbeiten ebenso wie `play`, `sample` und `synth`, indem sie ein Signal zur aktuellen (logischen) Zeit schicken . Um zum Beispiel Aufrufe an die `midi_*`-Funktionen zu verteilen, musst du `sleep` in der gleichen Weise benutzen wie du es bei `play` getan hast. Lass uns das ansehen:

en: This will send a MIDI note on event to the connected MIDI device with velocity 50. (Note that Sonic Pi will automatically convert notes in the form `:e3` to their corresponding MIDI number such as 52 in this case.)
de: Dies sendet ein MIDI-Note-on-Ereignis an das angeschlossene MIDI-Gerät mit Anschlagstärke 50. (Beachte, dass Sonic Pi Noten in der Form von `:e3` automatisch in ihre entsprechenden MIDI-Nummern konvertiert, wie z. B. 52 in diesem Fall.)

en: If your connected MIDI device is a synthesiser, you should be able to hear it playing a note. To disable it use `midi_note_off`:
de: Wenn dein MIDI-Gerät ein Synthesizer ist, solltest du hören können, wie er eine Note spielt. Um dies zu deaktivieren verwende `midi_note_off`:

en: Selecting a MIDI device
de: Auswahl eines MIDI-Gerätes

en: By default, Sonic Pi will send each MIDI message to all connected devices on all MIDI channels. This is to make it easy to work with a single connected device without having to configure anything. However, sometimes a MIDI device will treat MIDI channels in a special way (perhaps each note has a separate channel) and also you may wish to connect more than one MIDI device at the same time. In more complicated setups, you may wish to be more selective about which MIDI device receives which message(s) and on which channel.
de: Standardmäßig wird Sonic Pi jedes MIDI-Signal an alle angeschlossenen Geräte auf allen MIDI-Kanälen senden. Auf diese Art ist es leicht mit einem einzelnen verbundenen Gerät zu arbeiten, ohne zuvor etwas einstellen zu müssen. Allerdings kann es sein, dass ein MIDI-Gerät MIDI-Kanäle auf spezielle Art handhabt (möglicherweise hat jede Note einen eigenen Kanal) - und außerdem möchtest vielleicht mehr als ein MIDI-Gerät zur gleichen Zeit anschließen. Und bei etwas komplizierteren Setups, möchtest du wahrscheinlich genauer bestimmen, welches Gerät welche(s) Signal(e) erhält, und auf welchem Kanal.

en: We can specify which device to send to using the `port:` opt, using the device name as displayed in the preferences:
de: Wir können festlegen an welches Gerät wir senden, indem wir die `port:`-Option verwenden, in der wir den Gerätenamen verwenden, wie er in den Einstellungen angezeigt wird:

en: We can also specify which channel to send to using the `channel:` opt (using a value in the range 1-16):
de: Wir können ebenfalls angeben, an welchen Kanal gesendet werden soll, indem wir die Option `channel:` (mit einem Wert im Bereich 1-16) verwenden:

en: Of course we can also specify both at the same time to send to a specific device on a specific channel:
de: Natürlich können wir auch beides zugleich festlegen, um an ein bestimmtes Gerät auf einen bestimmten Kanal zu senden:

en: MIDI Studio
de: MIDI-Studio

en: Finally, a really fun thing to do is to connect the audio output of your MIDI synthesiser to one of the audio inputs of your soundcard. You can then control your synth with code using the `midi_*` fns and also manipulate the audio using `live_audio` and FX:
de: Und schließlich ist es eine wirklich spannende Sache, den Audio-Ausgang deines MIDI-Synthesizers mit einem der Audio-Eingänge deiner Soundkarte zu verbinden. So kannst du deinen Synthesizer mit den `midi_*`Funktionen steuern und gleichzeitig die erzeugten Klänge mit `live_audio` und Effekten verändern:

en: (The fn `midi` is available as a handy shortcut to sending both note on and note off events with a single command. Check out its documentation for further information).
de: (Die `midi`-Funktion ist eine handliche Kurzform, um `note on `- und `note off`-Ereignisse mit einem einzigen Befehl zu senden. Für weitere Informationen wirf einen Blick in ihre Dokumentation).

en: In addition to MIDI, another way to get information in and out of Sonic Pi is via the network using a simple protocol called OSC - Open Sound Control. This will let you send messages to and from external programs (both running on your computer and on external computers) which opens up the potential for control way beyond MIDI which has limitations due to its 1980s design.
de: Es gibt neben MIDI in Sonic Pi noch einen Weg über das Netzwerk ein- und ausgehende Informationen zu übertragen - das ist OSC - Open-Sound-Control, ein einfaches Netzwerkprotokoll. Es lässt dich Signale mit externen Programme austauschen (mit Programmen sowohl auf deinem wie auch auf externen Computern) und erweitert damit die Möglichkeiten zur Steuerung weit über MIDI hinaus, welches durch sein Design aus den 80ern bestimmten Einschränkungen unterliegt.

en: For example, you could write a program in another programming language which sends and receives OSC (there are OSC libraries for pretty much every common language) and work directly with Sonic Pi. What you can use this for is only limited by your imagination.
de: Zum Beispiel könntest du ein Programm in einer anderen Programmiersprache schreiben, welches OSC-Signale sendet und empfängt (es gibt OSC-Bibliotheken für so ziemlich alle gebräuchlichen Programmiersprachen) - und direkt mit Sonic Pi zusammenarbeitet. Wofür du das einsetzen kannst, wird nur durch deine Vorstellungskraft begrenzt.

en: 12.1 Receiving OSC
de: 12.1 OSC empfangen

en: Receiving OSC
de: OSC empfangen

en: By default when Sonic Pi is launched it listens to port 4560 for incoming OSC messages from programs on the same computer. This means that without any configuration, you can send Sonic Pi an OSC message and it will be displayed in the cue log just like incoming MIDI messages. This also means that any incoming OSC message is also automatically added to the Time State which means you can also use `get` and `sync` to work with the incoming data - just like with MIDI and synchronising `live_loops` - see sections 5.7 and 10.2 to recap how this works.
de: Standardmäßig lauscht Sonic Pi wenn es gestartet wird an Port 4560 auf eingehende OSC-Signale von Programmen auf demselben Computer. Das bedeutet, dass du ohne weitere Konfiguration Sonic Pi ein OSC-Signal senden kannst und dieses im Cue-Protokoll, genauso wie eingehende MIDI-Signale, angezeigt wird. Das heißt auch, jedes eingehende OSC-Signal wird automatisch zum Time-State hinzugefügt, was bedeutet, dass du `get` und `sync` verwenden kannst, um mit den eingehenden Daten zu arbeiten - genauso wie bei MIDI und der Synchronisierung von `live_loops` - sieh in den Abschnitten 5.7 und 10.2 nach, um zu rekapitulieren, wie das funktioniert.

en: A Basic OSC Listener
de: Ein einfacher OSC-Empfänger

en: Let's build a basic OSC listener:
de: Lass uns einen einfachen OSC-Empfänger bauen:

en: live_loop :foo do
      use_real_time
      a, b, c = sync "/osc*/trigger/prophet"
      synth :prophet, note: a, cutoff: b, sustain: c
    end
de: live_loop :foo do 
      use_real_time
      a, b, c = sync "/osc*/trigger/prophet"
      synth :prophet, note: a, cutoff: b, sustain: c
    end

en: In this example we described an OSC path `"/osc*/trigger/prophet"` which we're syncing on. This can be any valid OSC path (all letters and numbers are supported and the `/` is used like in a URL to break up the path to multiple words). The `/osc` prefix is added by Sonic Pi to all incoming OSC messages, so we need to send an OSC message with the path `/trigger/prophet` for our `sync` to stop blocking and the prophet synth to be triggered.
de: In diesem Beispiel geben wir einen OSC-Pfad an, mit dem wir uns synchronisieren, `"/osc*/trigger/prophet"`. Dies kann ein beliebiger gültiger OSC-Pfad sein (alle Buchstaben und Zahlen sind erlaubt, das `/`wird wie in einer URL verwendet um Wörter zu trennen). Das Präfix `/osc` wird von Sonic Pi allen eingehenden OSC-Signalen vorangestellt, also müssen wir eine OSC-Signal mit dem Pfad `/trigger/prophet` senden, damit der `sync`-Befehl beendet und der prophet-Synth getriggert wird.

en: Sending OSC to Sonic Pi
de: OSC an Sonic Pi senden

en: We can send OSC to Sonic Pi from any programming language that has an OSC library. For example, if we're sending OSC from Python we might do something like this:
de: Wir können OSC von jeder beliebigen Programmsprache, die eine Bibliothek für OSC bietet, aus an Sonic Pi senden. Wenn wir zum Beispiel OSC von Python aus senden, machen wir vielleicht so etwas:

en: from pythonosc import osc_message_builder
    from pythonosc import udp_client
    sender = udp_client.SimpleUDPClient('127.0.0.1', 4560)
    sender.send_message('/trigger/prophet', [70, 100, 8])
de: from pythonosc import osc_message_builder 
    from pythonosc import udp_client
    sender = udp_client.SimpleUDPClient('127.0.0.1', 4560)
    sender.send_message('/trigger/prophet', [70, 100, 8])

en: Or, if we're sending OSC from Clojure we might do something like this from the REPL:
de: Oder wenn wir OSC aus Clojure senden, machen wir vielleicht etwas wie dies aus dem REPL:

en: (use 'overtone.core)
    (def c (osc-client "127.0.0.1" 4560))
    (osc-send c "/trigger/prophet" 70 100 8)
de: (use 'overtone.core) 
    (def c (osc-client "127.0.0.1" 4560))
    (osc-send c "/trigger/prophet" 70 100 8)

en: Receiving from External Machines
de: Von externen Computern empfangen

en: Note, some programs such as TouchOSC for iPhone and Android support sending OSC as a standard feature. So, once you're listening to remote machines and know your IP address you can instantly start sending messages from apps like TouchOSC which enable you to build your own custom touch controls with sliders, buttons, dials etc. This can provide you with an enormous range of input options.
de: Beachte, dass manche Programme, wie z. B. TouchOSC für iPhone und Android, das Senden von OSC-Signalen von Haus aus unterstützen. Also kannst du, sobald du auf OSC-Signale von externen Geräten lauscht und du deine IP-Adresse kennst, anfangen OSC-Signale von Apps wie TouchOSC zu senden und deine eigenen Steuerungen mit Slidern, Schaltflächen, Drehknöpfen usw. zu bauen. Das kann dir eine enorme Bandbreite an Eingabemöglichkeiten erschließen.

en: 12.2 Sending OSC
de: 12.2 OSC senden

en: Sending OSC
de: OSC senden

en: In addition to receiving OSC and working with it using Time State, we can also send out OSC messages in time with our music (just like we can send out MIDI messages in time with our music). We just need to know which IP address and port we're sending to. Let's give it a try:
de: So wie wir OSC empfangen und mittels Time-State verarbeiten, können wir auch OSC senden (ganz so wie wir MIDI-Signale im Takt unserer Musik senden können). Wir müssen nur wissen an welche IP-Adresse und welchen Port wir senden. Lass uns das ausprobieren:

en: Sending OSC to other programs
de: OSC an andere Programme senden

en: Of course, sending OSC messages to ourselves may be fun but it's not that useful. The real benefit starts when we send messages to other programs:
de: Natürlich kann es lustig sein OSC-Signale an uns selbst zu senden, hilfreich ist es aber nicht. Den echten Nutzen erkennen wir dann, wenn wir Nachrichten an andere Programme senden:

en: In this case we're assuming there's another program on the same machine listening to port 123456. If there is, then it will receive a `"/hello/world` OSC message with which it can do what it wants.
de: In diesem Beispiel gehen wir davon aus, dass ein Programm auf dem selben Computer an Port 123456 lauscht. Falls dies der Fall ist, wird es ein OSC-Signal mit dem Inhalt `"/hello/world"` erhalten, welches es dann verarbeiten kann.

en: If our program is running on another machine, we need to know its IP address which we use instead of `"localhost"`:
de: Wenn dein Programm auf einer anderen Maschine läuft, müssen wir deren IP-Adresse kennen, welche wir anstelle von `"localhost"`verwenden:

en: Now we can send OSC messages to any device reachable to us via our local networks and even the internet!
de: Nun können wir OSC-Signale zu jedem erreichbaren Gerät senden, über das lokale Netzwerk und sogar auch über das Internet!

en: 13 Multichannel Audio
de: 13 Multikanal-Audio

en: Multichannel Audio
de: Multikanal-Audio

en: So far, in terms of sound production, we've explored triggering synths and recorded sounds via the fns `play`, `synth` and `sample`. These have then generated audio which has played through our stereo speaker system. However, many computers also have the ability to input sound, perhaps through a microphone, in addition to the ability to send sound out to more than two speakers. Often, this capability is made possible through the use of an external sound card - these are available for all platforms. In this section of the tutorial we'll take a look at how we can take advantage of these external sound cards and effortlessly work with multiple channels of audio in and out of Sonic Pi.
de: In Sachen Klangproduktion haben wir bis jetzt das Triggern von Synths und aufgenommenen Klängen über die Funktionen `play`, `synth` und `sample` erkundet. Diese haben dann hörbare Töne erzeugt, die über unser Stereo-Lautsprecher-System abgespielt wurden. Viele Computer verfügen jedoch auch über die Fähigkeit Klänge einzuspielen, über ein Mikrofon zum Beispiel, und zusätzlich auch über mehr als zwei Ausgänge auszuspielen. Oft wird diese Fähigkeit durch die Verwendung eines externen Audio-Interface möglich gemacht - es gibt sie für alle Plattformen. In diesem Abschnitt der Tutorials sehen wir uns an, wie wir ein solches externes Audio-Interface nutzen und damit mühelos mit mehreren Kanälen Audio auf Ein- und -Ausgängen in Sonic Pi arbeiten können.

en: 13.1 Sound In
de: 13.1 Sound-In

en: Sound In
de: Sound-In

en: One simple (and perhaps familiar) way of accessing sound inputs is using our friend `synth` by specifying the `:sound_in` synth:
de: Ein einfacher (und vielleicht schon bekannter) Weg um in Sonic Pi Audio-Eingänge zu verwenden ist mit Hilfe unseres Freundes `synth` bzw. der`:sound_in`-Funktion:

en: This will operate just like any synth such as `synth :dsaw` with the exception that the audio generated will be read directly from the first input of your system's sound card. On laptops, this is typically the built-in microphone, but if you have an external sound card, you can plug any audio input to the first input.
de: Dieser Synth wird genauso funktionieren wie jeder andere Synth, beispielsweise `synth:dsaw`, mit der Ausnahme dass das eingehende Audio-Signal direkt vom ersten Eingang deiner System-Sound-Karte gelesen wird. Auf Laptops ist dies normalerweise das eingebaute Mikrofon, falls du aber ein externes Audio-Interface verwendest, kannst du auch jedes andere Audio-Signal an den ersten Eingang anschließen.

en: Increasing the Duration
de: Erhöhung der Dauer

en: One thing you might notice is that just like `synth :dsaw` the `:sound_in` synth only lasts for 1 beat as it has a standard envelope. If you'd like to keep it open for a little longer, change the ADSR envelope settings. For example the following will keep the synth open for 8 beats before closing the connection:
de: Eine Sache die dir sicher auffallen wird, ist, dass genauso wie `synth:dsaw` der `:sound_in`-Synth nur für einen Beat lang hörbar ist, da er die Standard-Hüllkurve verwendet. Falls du ihn für etwas länger offen halten möchtest, kannst du die Einstellungen der ADSR-Hüllkurve ändern. Im folgenden Beispiel wird der Synth für 8 Schläge hörbar sein, bevor die Verbindung geschlossen wird:

en: Of course, just like any normal synth, you can easily layer on effects with the FX block:
de: Natürlich kannst du, genau wie bei jedem normalen Synth auch, mit dem FX block einfach Effekte anwenden:

en: If you have plugged in a guitar to your first input, you should be able to hear it with distortion and reverb until the synth terminates as expected.
de: Falls du nun eine Gitarre an den ersten Eingang angeschlossen hast, solltest du sie jetzt mit einer Verzerrung und Hall hören können, bis der Synth erwartungsgemäß endet.

en: You are free to use the `:sound_in` synth as many times as you like concurrently (just like you would do with any normal synth). For example, the following will play two `:sound_in` synths at the same time - one through distortion and one through reverb:
de: Du kannst den `:sound_in`-Synth so viele Male gleichzeitig einsetzen, wie du möchtest (genauso wie du es mit jedem anderen Synth machen würdest). Zum Beispiel werden im Folgenden zwei `:sound_in`-Synths gleichzeitig gespielt - einer mit Verzerrung der andere mit Hall:

en: Multiple Inputs
de: Mehrere Eingänge

en: You can select which audio input you want to play with the `input:` opt. You can also specify a stereo input (two consecutive inputs) using the `:sound_in_stereo` synth. For example, if you have a sound card with at least three inputs, you can treat the first two as a stereo stream and add distortion and the third as a mono stream and add reverb with the following code:
de: Du kannst über die `input:`-Option jeweils auswählen über welchem Audio-Eingang du spielen willst. Du kannst außerdem mit `:sound_in_stereo`-Synth auch einen Stereo-Eingang (zwei aufeinander folgende Eingänge) bestimmen. Mit dem folgenden Beispiel könntest du, wenn du über eine Sound-Karte mit mindestens drei Eingängen verfügst, die ersten beiden als Stereo-Signal behandeln und Verzerrung hinzufügen, und den dritten als Mono-Signal behandeln und Hall hinzufügen:

en: Potential Issues
de: Mögliche Probleme

en: However, although this is a useful technique, there are a couple of limitations to this approach. Firstly, it only works for a specific duration (due to it having an ADSR envelope) and secondly, there's no way to switch the FX around once the synth has been triggered. Both of these things are typical requests when working with external audio feeds such as microphones, guitars and external synthesisers. We'll therefore take a look at Sonic Pi's solution to the problem of manipulating a (potentially) infinite stream of live audio input: `live_audio`.
de: Obwohl dies eine nützliche Technik darstellt, gibt es doch einige Beschränkungen bei diesem Ansatz. Zunächst funktioniert sie nur über eine festgelegte Dauer (da sie an eine ADSR-Hüllkurve gebunden ist), und des weiteren gibt es keine Möglichkeit, die Effekte umzuschalten, sobald der Synth getriggert wurde. Beides sind typische Anforderungen, wenn wir mit externen Audio-Signalen wie Mikrophonen, Gitarren und externen Synthesizern arbeiten. Wir werden uns daher mit Sonic Pis Lösung zu dem Problem beschäftigen, mit einem (potentiell) unendlichen Audio-Signal an einem Audio-Eingang zu arbeiten: `live_audio`.

en: 13.2 Live Audio
de: 13.2 Live-Audio

en: Live Audio
de: Live-Audio

en: The `:sound_in` synth as described in the previous section provides a very flexible and familiar method for working with input audio. However, as also discussed it has a few issues when working with a single input of audio as a single instrument (such as a voice or guitar). By far the best approach to working with a single continuous stream of audio is to use `live_audio`.
de: Der `:sound_in`-Synth wie er im vorherigen Abschnitt beschrieben wurde, stellt eine sehr flexible und gängige Methode dar, um mit Audio-Eingangssignalen zu arbeiten. Allerdings gibt es, wie beschrieben, Beschränkungen bei der Behandlung einzelner Audio-Signalen als ein einzelnes Instrument (wie z. B. Stimme oder Gitarre). Mit Abstand der beste Ansatz für die Arbeit mit einem einzelnen anhaltenden Audio-Signal ist `live_audio` zu nutzen.

en: A Named Audio Input
de: Ein benannter Audio-Eingang

en: `live_audio` shares a couple of core design constraints with `live_loop` (hence the similar name). Firstly it must have a unique name and secondly only one `live_audio` stream with that name may exist at any one time. Let's take a look:
de: `live_audio` teilt einige der zentralen Design-Beschränkungen mit `live_loop` (daher der ähnliche Name). Erstens muss es einen eindeutigen Namen haben, und zweitens darf es zu jedem Zeitpunkt immer nur einen `live_audio`-Stream mit diesem Namen geben. Lass uns das mal ansehen:

en: This code will act in a similar fashion to `synth :sound_in` with some key differences: it runs forever (until you explicitly stop it) and you can *move* it to new FX contexts dynamically.
de: Dieser Code wird sich ähnlich verhalten wie `synth :sound_in`, mit einigen wesentlichen Unterschieden: er läuft ununterbrochen (bis du ihn ausdrücklich stoppst), und du kannst ihn dynamisch in neue Effekt-Blöcke *schieben*.

en: Working with FX
de: Mit Effekten arbeiten

en: On initial triggering `live_audio` works exactly as you might expect it to work with FX. For example, to start a live audio stream with added reverb simply use a `:reverb` FX block:
de: Beim ersten Trigger verhält sich `live_audio` exakt so, wie du es bei der Arbeit mit Effekten erwarten würdest. Zum Beispiel, um einen Live-Audio-Stream mit hinzugefügtem Hall zu starten, verwende einfach einen `:reverb`-Effekt-Block:

en: However, given that `live_audio` runs forever (at least until you stop it) it would be pretty limiting if, like typical synths, the live audio was bound within the `:reverb` FX for its entire existence. Luckily this is not the case and it was designed to be easy to move between different FX. Let's try it. Run the code above to hear live audio coming directly from the first input of your sound card. Note, if you're using a laptop, this will typically be out of your built-in microphone, so it's recommended to use headphones to stop feedback.
de: Wie auch immer, angenommen dass `live_audio` für immer läuft (zumindest bis du es stoppst), wäre es doch sehr beschränkend wenn, wie mit den anderen Synths, Live-Audio für seine gesamte Dauer an den Effekt-Block gebunden bliebe. Glücklicherweise ist das nicht der Fall, und Live-Audio wurde so entworfen, dass es einfach zwischen verschiedenen Effekten bewegt werden kann. Lass uns das versuchen. Lass den obigen Code laufen, um über Live-Audio direkt das Signal zu hören, das am ersten Eingang deiner Sound-Karte anliegt. Beachte: Wenn du ein Laptop benutzt, wird dies standardmäßig das eingebaute Mikrophon sein - es ist also empfehlenswert Kopfhörer zu verwenden, um Feedback zu vermeiden.

en: Now, whilst you're still hearing the audio live from the sound card with reverb, change the code to the following:
de: Nun, während du noch den Ton live von deiner Sound-Karte mit Hall hörst, ändere den Code in Folgendes:

en: Now, hit Run, and you'll immediately hear the audio played through the echo FX and no longer through reverb. If you wanted them both, just edit the code again and hit Run:
de: Nun klicke Ausführen, und sofort wirst du den Sound mit dem Echo-Effekt hören und nicht mehr mit Hall. Wenn du beide hören willst, ändere einfach wieder den Code und klicke Ausführen:

en: It's important to point out that you can call `live_audio :foo` from any thread or live loop and it will move the live audio synth to *that* thread's current FX context. You could therefore easily have multiple live loops calling `live_audio :foo` at different times resulting in the FX context being automatically swapped around for some interesting results.
de: Es ist wichtig darauf hinzuweisen, dass du `live_audio :foo` aus jedem Thread oder Live-Loop heraus aufrufen kannst, und es wird den Live-Audio-Synth in den Effekt-Kontext *dieses* Threads verschieben. Du könntest also leicht mehrere Live-Loops haben, die `live_audio :foo` automatisch zu unterschiedlichen Zeiten in unterschiedlichen Effekt-Kontexten aufrufen, was zu interessanten Ergebnissen führen kann.

en: Stopping live audio
de: Live-Audio stoppen

en: Unlike standard synths, as `live_audio` has no envelope, it will continue running forever (even if you delete the code, just like a function is still defined in memory if you delete the code in the editor). To stop it, you need to use the `:stop` arg:
de: Da Live-Audio anders als andere Synths keine Hüllkurve hat, wird es für immer weiterlaufen (sogar wenn du den Code löscht, genau wie bei einer Funktion, ist es immer noch im Speicher definiert, wenn du den Code im Editor löscht). Um es anzuhalten, musst du das `:stop`-Argument anwenden:

en: It can easily be restarted by calling it without the `:stop` arg again:
de: Es kann einfach neu gestartet werden, indem du es erneut ohne `:stop`-Argument ausführst:

en: Additionally all running live audio synths are stopped when you hit the global Stop button (as with all other running synths and FX).
de: Außerdem werden alle laufenden Live-Audio-Synths gestoppt, wenn du auf Stopp klickst (genau wie bei allen anderen Synths und Effekten).

en: Stereo input
de: Stereo-Eingang

en: With respect to audio channels, by default `live_audio` acts similarly to the `:sound_in` synth in that it takes a single mono input stream of audio and converts it to a stereo stream using the specified panning. However, just like `:sound_in_stereo` it's also possible to tell `live_audio` to read two consecutive audio inputs and treat them as the left and right channels directly. This is achieved via the `:stereo` opt. For example, to treat input 2 as the left signal and input 3 as the right signal, you need to configure the `input:` opt to 2 and enable stereo mode as follows:
de: In Bezug auf die Audio-Kanäle verhält sich Live-Audio standardmäßig wie der `:sound_in`-Synth, indem er einen einzelnes Mono-Eingangssignal nimmt und in einen Stereo-Stream wandelt, unter Verwendung der eingegebenen Panorama-Einstellung. Allerdings, wie bei `:sound_in_stereo` besteht auch hier die Möglichkeit, Live-Audio zwei aufeinander folgende Audio-Eingänge lesen zu lassen und sie direkt als linken und rechten Kanal zu behandeln. Dies lässt sich durch die `:stereo`-Option erreichen. Um zum Beispiel Eingang 2 als linkes Signal und Eingang 3 als rechtes Signal zu behandeln, musst du die `input:`-Option wie folgt auf 2 konfigurieren:

en: Note that once you have started a live audio stream in stereo mode, you cannot change it to mono without stopping and starting. Similarly, if you start it in the default mono mode, you can't switch to stereo without starting and stopping the stream.
de: Beachte, dass sobald du einen Audio-Stream in Stereo gestartet hast, du nicht zu Mono wechseln kannst, ohne erneut zu stoppen und zu starten. Ebenso, wenn du ihn im standardmäßigen Mono-Modus startest, kannst du nicht zu Stereo wechseln, ohne zu stoppen und zu starten.

en: 13.3 Sound Out
de: 13.3 Sound-Out

en: Sound Out
de: Sound-Out

en: So far in this section we've looked at how to get multiple streams of audio into Sonic Pi - either through the use of the `:sound_in` synth or via the powerful `live_audio` system. In addition to working with multiple streams of input audio, Sonic Pi can also output multiple streams of audio. This is achieved via the `:sound_out` FX.
de: Bisher haben wir in diesem Abschnitt behandelt, wie wir mehrere Audio-Streams in Sonic Pi einbinden können - entweder durch den `:sound_in`-Synth oder über das mächtige ` live_audio`-System. Über die Arbeit mit mehreren Audio-Streams aus Eingangssignalen hinaus, kann Sonic Pi ebenso mehrere Audio-Streams als Ausgangssignal ausgeben. Dies wird über den `:sound_out`-Effekt erreicht.

en: Output contexts
de: Ausgabe-Kontexte

en: Let's quickly recap on how Sonic Pi's synths and FX output their audio to their current FX context. For example, consider the following:
de: Lass uns kurz rekapitulieren, wie Sonic Pis Synths und Effekte ihr Audio-Signal an ihren gegenwärtigen Effekt-Kontext übergeben. Stell dir zum Beispiel Folgendes vor:

en: The simplest way to understand what's happening with the audio stream is to start at the innermost audio context and work our way out. In this case, the innermost context is labelled `A` and is the `:bd_haus` sample being triggered. The audio for this goes directly into its context which is `B` - the `:echo` FX. This then adds echo to the incoming audio and outputs it to its context which is `C` - the `:reverb` FX. This then adds reverb to the incoming audio and outputs to its context which is the top level - the left and right speakers (outputs 1 and 2 in your audio card). The audio flows outwards with a stereo signal all the way through.
de: Der einfachste Weg, um zu verstehen, was mit dem Audio-Stream passiert, ist beim innersten Audio-Kontext zu starten und uns langsam den Weg nach draußen entlang zu arbeiten. In diesem Fall ist der innerste Kontext mit `A` bezeichnet und ist das `:bd_haus`-Sample, das getriggert wird. Der Audio-Stream hiervon geht direkt in den Kontext `B`, welches der `:echo`-Effekt ist. Dieser fügt Echo dem eingehenden Audio-Stream hinzu und gibt es an seinen Kontext weiter - das ist `C` - der `:reverb`-Effekt. Dieser fügt dann Hall dem eingehenden Audio-Stream hinzu und gibt ihn an seinen Kontext weiter, welcher die oberste Ebene ist - der linke und rechte Lautsprecher (was in deinem Audio-Interface Ausgang 1 und Ausgang 2 entspricht). Der Klang fließt nach draußen den ganzen Weg hindurch als Stereo-Signal.

en: Sound Out FX
de: Sound-Out-Effekte

en: The above behaviour is true for all synths (including `live_audio`) and the majority of FX with the exception of `:sound_out`. The `:sound_out` FX does two things. Firstly it outputs its audio to its external context as described above. Secondly it *also* outputs its audio directly to an output on your sound card. Let's take a look:
de: Das oben genannte Verhalten trifft auf alle Synths zu (einschließlich `live_audio`) und auf den Großteil der Effekte, mit Ausnahme von `:sound_out`. Der `:sound_out`-Effekt tut zwei Dinge. Erstens gibt er seinen Audio-Stream wie oben beschrieben an seinen äußeren Kontext weiter. Zum Zweiten gibt er ihn *auch* an einen Ausgang deines Audio-Interface oder deiner Sound-Karte aus. Sehen wir uns das an:

en: In this example, our `:bd_haus` sample outputs its audio to its external context which is the `:sound_out` FX. This in turn outputs its audio to its external context the `:reverb` FX (as expected). However, it *also* outputs a mono mix to the 3rd output of the system's soundcard. The audio generated within `:sound_out` therefore has two destinations - the `:reverb` FX and audio card output 3.
de: In diesem Besipiel gibt unser `bd_haus`-Sample sein Audio an seinen äußeren Kontext, welches der `:sound_out`-Effekt ist. Dieser seinerseits gibt sein Audio an seinen externen Kontext, den `:reverb`-Effekt weiter (wie erwartet). Allerdings gibt er *auch* einen Mono-Mix an den Ausgang 3 des Audio-Interface oder der Sound-Karte des Systems. Der Audio-Stream, wie er innerhalb von `:sound_out` generiert wird hat also zwei Ziele, den `:reverb`-Effekt und den Audio-Ausgang 3.

en: Mono and Stereo out
de: Mono- und Stereoausgabe

en: As we've seen, by default, the `:sound_out` FX outputs a mono mix of the stereo input to a specific channel in addition to passing the stereo feed to the outer context (as expected). If outputting a mono mix isn't precisely what you want to do, there are a number of alternative options. Firstly, by using the `mode:` opt you can choose to output just the left or just the right input signal to the audio card. Or you can use the `:sound_out_stereo` FX to output to two consecutive sound card outputs. See the function documentation for more information and examples.
de: Wie wir gesehen haben, gibt der `:sound_out`-Effekt standardmäßig einen Mono-Mix des Stereo-Streams an einen bestimmten Kanal aus, zusätzlich dazu, dass er ihn (wie erwartet) an seinen äußeren Kontext weiter gibt. Wenn ein Mono-Mix nicht gerade das ist, was du nach draußen geben willst, hast du eine Reihe von Optionen. Zum Ersten, bei Verwendung der `mode:`-Option kannst du wählen nur den linken oder den rechten Kanal des Stereo-Streams an das Audio-Interface auszugeben. Oder du kannst den `:sound_out_stereo`-Effekt verwenden, um zwei aufeinanderfolgende Ausgänge des Audio-Interface zu verwenden. Wirf einen Blick in die Dokumentation der Funktion für weitere Informationen und Beispiele.

en: Direct Out
de: Direct-Out

en: As we have also seen, the default behaviour for `:sound_out` and `:sound_out_stereo` is to send the audio both to their external context (as is typical of all FX) *and* to the specified output on your soundcard. However, occasionally you may wish to *only* send to the output on your soundcard and not to the external context (and therefore not have any chance of the sound being mixed and sent to the standard output channels 1 and 2). This is possible by using the standard FX opt `amp:` which operates on the audio *after* the FX has been able to manipulate the audio:
de: Wie wir auch gesehen haben, ist es das standardmäßige Verhalten von `:sound_out` und `:sound_out_stereo` Audio sowohl an ihren äußeren Kontext (wie für alle Effekte typisch) *als auch* an den von dir bestimmten Audio-Ausgang deiner Sound-Karte zu schicken. Trotzdem wirst du gelegentlich vielleicht wünschen einen Audio-Stream *ausschließlich* an den Ausgang deiner Sound-Karte zu schicken und nicht an den äußeren Kontext (und daher deinen Audio-Stream auch nicht gemischt durch die Standard-Ausgänge 1 und 2 geschickt zu bekommen). Das ist möglich, indem du die Standard-Effekt-Option `amp:` benutzt, die den Audio-Stream bearbeitet, *nachdem* der Effekt den Audio-Stream bearbeitet hat:

en: In the above example, the `:loop_amen` sample is sent to its outer context, the `:sound_out` FX. This then sends a mono mix to audio card output 3 and then multiplies the audio by 0 which essentially silences it. It is this silenced signal which is then sent out to the `:sound_out`'s outer context which is the standard output. Therefore with this code, the default output channels will not receive any audio, and channel 3 will receive a mono mix of the amen drum break.
de: Im obigen Beispiel, wird das `:loop_amen`-Sample an seinen äußeren Kontext geschickt, den `:sound_out`-Effekt. Dieser sendet einen Mono-Mix and den Sound-Karten-Ausgang 3 und multipliziert danach den Audio-Stream mit 0, was diesen essentiell stumm schaltet. Dieses stummgeschaltete Signal wird anschließend an den äußeren Kontext des `:sound_out`-Effektes geschickt, welches der Standard-Ausgang ist. Daher werden bei diesem Code die Standard-Ausgangskanäle kein hörbares Signal erhalten, und an Ausgang 3 wird ein Mono-Mix des Amen-Drum-Break geschickt.

en: Conclusions
de: Abschließendes

en: This concludes the Sonic Pi introductory tutorial. Hopefully you've learned something along the way. Don't worry if you feel you didn't understand everything - just play and have fun and you'll pick things up in your own time. Feel free to dive back in when you have a question that might be covered in one of the sections.
de: Dieser Abschnitt beschließt das einführende Tutorial zu Sonic Pi. Hoffentlich konntest du auf dem Weg ein paar Dinge lernen. Mach dir keine Sorgen, wenn du das Gefühl hast, nicht alles verstanden zu haben - spiele einfach weiter, hab Spaß dabei, und du wirst alles weitere auf deinem Weg, in deinem eigenen Tempo entdecken. Tauche einfach wieder ein, wenn du das Gefühl hast , dass eine Frage in einem der Abschnitte des Tutorials beantwortet werden könnte.

en: If you have any questions that haven't been covered in the tutorial, then please jump onto the [Sonic Pi community forums](https://in-thread.sonic-pi.net/) and ask your question there. You'll find someone friendly and willing to lend a hand.
de: Wenn du Fragen hast, die nicht in diesem Tutorial behandelt wurden, dann komme damit bitte im [Sonic Pi Forum](http://groups.google.com/group/sonic-pi/) vorbei und stelle deine Frage dort. Du wirst dort Leute treffen, die freundlich sind und dir gerne weiterhelfen.

en: Finally, I also invite you to take a deeper look at the rest of the documentation in this help system. There are a number of features that haven't been covered in this tutorial that are waiting for your discovery.
de: Und abschließend lade ich dich auch dazu ein, dir die übrige Dokumentation im Hilfe-System einmal genauer anzuschauen. Es gibt noch eine ganze Reihe von Merkmalen von Sonic Pi, die in diesem Tutorial nicht behandelt wurden und darauf warten, von dir entdeckt zu werden.

en: So play, have fun, share your code, perform for your friends, show your screens and remember:
de: Also, spiele, hab Spaß, teile deinen Programm-Code, tritt vor deinen Freunden auf, zeige was du auf dem Monitor hast - und vergiss nicht:

en: *There are no mistakes, only opportunities.*
de: *Es gibt keine Fehler, nur Möglichkeiten.*

en: A Appendix A - MagPi Articles
de: A Anhang A - Artikel aus MagPi

en: MagPi Articles
de: Artikel aus MagPi

en: Appendix A collects all the Sonic Pi articles written for the MagPi magazine.
de: Anhang A bündelt Artikel über Sonic Pi, die für das MagPi-Magazin geschrieben wurden.

en: Dive into Topics
de: Einstieg in den Stoff

en: These articles aren't meant to be read in any strict order and contain a lot of cross-over material from the tutorial itself. Rather than try and teach you all of Sonic Pi, they instead each focus on a specific aspect of Sonic Pi and cover it in a fun and accessible way.
de: Diese Artikel müssen nicht in einer bestimmten Reihenfolge gelesen werden, und sie überschneiden sich in vielen Punkten mit dem Tutorial. Es geht weniger darum, dir alles über Sonic Pi beizubringen - eher fokussieren sie sich jeweils auf einen bestimmten Aspekt von Sonic Pi und behandeln ihn auf unterhaltsame und leicht zugängliche Weise.

en: Read the MagPi
de: Lese das MagPi

en: You can see them in their glorious professionally typeset form in the free PDF downloads of The MagPi here: https://www.raspberrypi.org/magpi/
de: Du kannst die Ausgaben von The MagPi in einem großartigen professionellem Layout als PDFs hier herunterladen: https://www.raspberrypi.org/magpi/

en: Suggest a Topic
de: Schlage ein Thema vor

en: If you don't see a topic that interests you covered in these articles - why not suggest one? The easiest way to do that is to tweet your suggestion to [@Sonic_Pi](http://twitter.com/sonic_pi). You never know - your suggestion might be the subject of the next article!
de: Wenn du kein Thema, das dich interessiert, in diesen Artikeln behandelt findest - warum nicht eines vorschlagen? Der einfachste Weg ist ein Tweet mit deinem Vorschlag an [@Sonic_Pi](http://twitter.com/sonic_pi). Du kannst nie wissen - dein Vorschlag könnte das Thema des nächsten Artikels sein!

en: A.1 Tips for Sonic Pi
de: A.1 Tipps zu Sonic Pi

en: Five Top Tips
de: Fünf Top-Tipps

en: 1. There are no mistakes
de: 1. Es gibt keine Fehler

en: The most important lesson to learn with Sonic Pi is that there really are no mistakes. The best way to learn is to just try and try and try. Try lots of different things out, stop worrying whether your code sounds good or not and start experimenting with as many different synths, notes, FX and opts as possible. You'll discover a lot of things that make you laugh because they sound just awful and some real gems that sound truly amazing. Simply drop the things you don't like and keep the things you do. The more 'mistakes' you allow yourself to make the quicker you'll learn and discover your personal coding sound.
de: Die wichtigste Lektion mit Sonic Pi ist, dass es wirklich keine Fehler gibt. Der beste Weg zu lernen, ist einfach es zu versuchen und zu versuchen und zu versuchen. Probiere viele verschiedene Dinge aus, kümmere dich nicht darum, ob dein Programm-Code gut oder schlecht klingt und fange an mit so vielen unterschiedlichen Synths, FXs und Optionen wie möglich zu experimentieren. Du wirst viele Dinge entdecken, die dich zum Lachen bringen, weil sie furchtbar klingen und auch richtige Edelsteine, die einfach toll klingen. Lass die Dinge, die dir nicht gefallen einfach beiseite und behalte, was dir gefällt. Je mehr 'Fehler' du dir zu machen erlaubst, desto schneller wirst du lernen und deinen eigenen Coding-Sound entdecken.

en: 2. Use the FX
de: 2. Verwende die Effekte

en: Say you've already mastered the Sonic Pi basics of making sounds with `sample`, `play`? What's next? Did you know that Sonic Pi supports over 27 studio FX to change the sound of your code? FX are like fancy image filters in drawing programs except that instead of blurring or making something black and white, you can add things like reverb, distortion and echo to your sound. Think of it like sticking the cable from your guitar to an effects pedal of your choice and then into the amplifier. Luckily, Sonic Pi makes using FX really easy and requires no cables! All you need to do is to choose which section of your code you'd like the FX added to and wrap it with the FX code. Let's look at an example. Say you had the following code:
de: Sagen wir mal, Du beherrschst die Grundlagen, wie man in Sonic Pi Sounds mit `sample`und `play` macht. Was jetzt? Hast Du gewusst, dass Sonic Pi über 27 Studio-FX unterstützt, mit denen Du den Sound deines Codes verändern kannst? FX sind sowas wie raffinierte Bildeffekte in Bildbearbeitungsprogrammen; nur das sie nicht unscharf oder schwarz/weiß machen, sondern dem Sound Hall, Verzerrung oder Echo hinzufügen. Stell' Dir vor, wie Du das Kabel von Deiner Gitarre ins Effekt-Pedal steckst und dann in den Verstärker. Glücklicherweise braucht man keine Kabel, und Sonic Pi macht es sehr einfach, FX einzusetzen. Du musst nur auswählen, auf welchen Teil Deines Codes Du einen FX anwenden willst und diesen Teil mit dem FX-Code umschließen. Sehen wir uns ein Beispiel an:

en: If you wanted to add FX to the `:loop_garzul` sample, you'd just tuck it inside a `with_fx` block like this:
de: Wenn Du einen FX auf das `:loop_gazul`-Sample anwenden möchtest, steckst du es einfach in einen `with_fx`-Block, und zwar so:

en: Now, if you wanted to add FX to the bass drum, go and wrap that with `with_fx` too:
de: Wenn Du jetzt einen FX zur Bassdrum hinzufügen möchtest, dann packe diese auch in ein `with_fx` ein:

en: Remember, you can wrap *any* code within `with_fx` and any sounds created will pass through that FX.
de: Denk' dran, Du kannst *jeden* Code mit einem `with_fx`umgeben und jeder Sound, der ausgegeben wird, geht durch diesen FX.

en: 3. Parameterise your synths
de: 3. Parametrisiere Deine Synths

en: In order to really discover your coding sound you'll soon want to know how to modify and control synths and FX. For example, you might want to change the duration of a note, add more reverb, or change the time between echoes. Luckily, Sonic Pi gives you an amazing level of control to do exactly this with special things called optional parameters or opts for short. Let's take a quick look. Copy this code into a workspace and hit run:
de: Um Deine codierten Klänge so richtig entdecken zu können, wirst Du sicher bald wissen wollen, wie Du Synths und FX steuern kannst. Vielleicht möchtest Du die Dauer eines Tons verändern, mehr Hall hinzufügen oder die Zeit zwischen zwei Echos verändern. Mit optionalen Parametern oder kurz Opts bietet Dir Sonic Pi viele Möglichkeiten, genau das zu tun. Schauen wir uns das mal kurz an. Kopiere diesen Code in einen Puffer und klicke auf Ausführen:

en: Ooh, a lovely guitar sound! Now, let's start playing with it. How about changing its rate?
de: Oh, was für ein wunderbarer Gitarren-Sound! Spielen wir ein bisschen damit. Wie wäre es damit, die Abspielgeschwindigkeit (rate) zu ändern?

en: Hey, what's that `rate: 0.5` bit I just added at the end? That's called an opt. All of Sonic Pi's synths and FX support them and there's loads to play around with. They're also available for FX too. Try this:
de: Was bedeutet der Schnipsel `rate: 0.5`, den ich hier am Ende hinzugefügt habe? Das ist ein Parameter. Alle Synths und FX in Sonic Pi unterstützen diesen und man kann viel damit anstellen. Versuche mal das hier:

en: The best way to quickly experiment and explore Sonic Pi is to live code. This allows you to start off some code and continually change and tweak it whilst it's still playing. For example, if you don't know what the cutoff parameter does to a sample, just play around. Let's have a try! Copy this code into one of your Sonic Pi workspaces:
de: Die beste Art Sonic Pi schnell kennenzulernen, ist, live zu coden. Du fängst mit irgendeinem Codeschnipsel an und veränderst und verbesserst, während der Code abgespielt wird. Wenn Du zum Beispiel nicht weißt, was der Cutoff-Parameter mit einem Sample macht, probiere es einfach aus. Fangen wir mal an! Kopiere diesen Code in einen Puffer von Sonic Pi:

en: Now, hit run and you'll hear a slightly muffled drum break. Now, change the `cutoff:` value to `80` and hit run again. Can you hear the difference? Try `90`, `100`, `110`...
de: Jetzt klicke auf ausführen und Du wirst einen leicht muffigen Drum-Break hören. Ändere den `cutoff:`-Wert auf `80` und klicke wieder ausführen. Hörst Du den Unterschied? Versuche es mit `90`, `100`, `110`...

en: Once you get the hang of using `live_loop`s you'll not turn back. Whenever I do a live coding gig I rely on `live_loop` as much as a drummer relies on their sticks. For more information about live coding check out Section 9 of the built-in tutorial.
de: Wenn Du die `live_loop`s einmal im Griff hast, willst du nichts mehr anders verwenden. Wann immer ich einen Live-Coding-Gig habe, brauche ich die `live_loop` wie ein Schlagzeuger seine Sticks. Um mehr über Live-Coding zu erfahren, sieh Dir den Abschnitt 9 im Tutorial an.

en: 5. Surf the random streams
de: 5. Mit dem Zufall spielen

en: Finally, one thing I love doing is cheating by getting Sonic Pi to compose things for me. A really great way to do this is using randomisation. It might sound complicated but it really isn't. Let's take a look. Copy this into a spare workspace:
de: Manchmal mogele ich, indem ich Sonic Pi für mich komponieren lasse. Mit Randomisierung lässt sich das großartig hinbekommen; das klingt vielleicht ein wenig kompliziert, ist es aber gar nicht. Sehen wir uns das an. Kopiere diesen Code in einen Puffer:

en: Now, when you play this, you'll hear a constant stream of random notes from the scale `:e2 :minor_pentatonic` played with the `:dsaw` synth. "Wait, wait! That's not a melody", I hear you shout! Well, here's the first part of the magic trick. Every time we go round the `live_loop` we can tell Sonic Pi to reset the random stream to a known point. This is a bit like going back in time in the TARDIS with the Doctor to a particular point in time and space. Let's try it - add the line `use_random_seed 1` to the `live_loop`:
de: Wenn Du das laufen lässt, wirst Du eine regelmäßige Reihenfolge von zufälligen Tönen der Skala `:e2 :minor_pentatonic` gespielt vom `:dsaw`-Synth hören. "Halt mal, das ist doch keine Melodie", höre ich Dich schon sagen. Okay, dies ist der erste Teil des Zaubertricks. Jedes Mal, wenn die `live_loop` durchgelaufen ist, können wir Sonic Pi sagen, es soll die Zufallsfolge an einen bestimmten Punkt zurücksetzen. Das ist ein bisschen so, als würden wir wie Dr. Who in seiner Zeitmaschine TARDIS an einen bestimmten Ort und zu einer bestimmten Zeit zurückkehren. Versuche es mal und schreibe die Zeile `use_random_seed 1` in die `live_loop`:

en: Now, every time the `live_loop` loops around, the random stream is reset. This means it chooses the same 16 notes every time. Hey presto! An instant melody. Now, here's the really exciting bit. Change the seed value from `1` to another number. Say `4923`. Wow! Another melody! So, just by changing one number (the random seed), you can explore as many melodic combinations as you can imagine! Now, that's the magic of code.
de: Jedes Mal, wenn die `live_loop`sich wiederholt, wird der Zufalls-Generator zurückgesetzt. Das bedeutet, es werden jedes mal die selben 16 Noten ausgewählt. Hey presto, eine Melodie! Doch jetzt kommt der richtig spannende Teil: Ändere den Wert von `seed` von `1` in irgendeine andere Zahl. Sagen wir z.B. `4923`. Wow! Eine andere Melodie! Also nur durch das Ändern einer Zahl (dem so genannten `random seed`), kannst Du jegliche nur vorstellbare melodische Kombinationen erforschen! Na, wenn das nicht die Magie des Codes ist.

en: This may sound like a far fetched story from a futuristic night club but coding music like this is a growing trend and is often described as Live Coding (http://toplap.org). One of the recent directions this approach to music making has taken is the Algorave (http://algorave.com) - events where artists like myself code music for people to dance to. However, you don't need to be in a nightclub to Live Code - with Sonic Pi v2.6+ you can do it anywhere you can take your Raspberry Pi and a pair of headphones or some speakers. Once you reach the end of this article, you'll be programming your own beats and modifying them live. Where you go afterwards will only be constrained by your imagination.
de: Es mag sich wie eine weit hergeholte Geschichte aus einem futuristischen Nachtklub anhört, aber Musik auf diese Weise zu programmieren, ist ein wachsender Trend, bekannt als Live-Coding (http://toplap.org). Eine aktuelle Richtung, die diese Art des Musikmachens eingeschlagen hat, ist der Algorave (http://algorave.com) - Veranstaltungen, auf denen Künstler wie ich Musik zum Tanzen programmieren. Du musst aber zum Live-Coden nicht in einem Nachtklub sein. Mit Sonic Pi v2.6+ kannst du überall loslegen, wohin du deinen Raspberry Pi und ein Paar Kopfhörer oder Lautsprecher mitnimmst. Wenn du das Ende dieses Artikels erreicht hast, wirst du bereits deine eigenen Beats programmieren und live bearbeitest. Wohin do von dort weiter gehst, wird einzig von deiner Vorstellungskraft beschränkt.

en: Live Loop
de: Live-Loop

en: The key to live coding with Sonic Pi is mastering the `live_loop`. Let's look at one:
de: Der Schlüssel zum 'live-coding' mit Sonic Pi ist das Beherrschen des 'live_loops'. Schauen wir uns einen an:

en: Redefining On-the-fly
de: Zur Laufzeit neu definieren

en: Ok, so what's so special about the `live_loop`? So far it just seems like a glorified `loop`! Well, the beauty of `live_loop`s is that you can redefine them on-the-fly. This means that whilst they're still running, you can change what they do. This is the secret to live coding with Sonic Pi. Let's have a play:
de: OK, aber was ist nun das besondere an einem `live_loop`? Bisher scheint er nur eine überbewertete "Schleife" zu sein! Nun, das Schöne am `live_loop` ist, dass du ihn im laufenden Programm neu definieren kannst. Das bedeutet, du kannst ändern was er machen soll, während er läuft. Das ist das Geheimnis hinter Live-Coding mit Sonic Pi. Lass uns das ausprobieren:

en: Now press the Run button or hit `Meta-r`. You're now listening to some gorgeous choir sounds. Now, whilst it's still playing, change the rate from `0.4` to `0.38`. Hit run again. Woah! Did you hear the choir change note? Change it back up to `0.4` to return back to how it was. Now, drop it to `0.2`, down to `0.19` and then back up to `0.4`. See how changing just one parameter on the fly can give you real control of the music? Now play around with the rate yourself - choose your own values. Try negative numbers, really small numbers and large numbers. Have fun!
de: Klicke auf die `Ausführen`-Schaltfläche oder drücke `Alt-R`. Du hörst jetzt einen wunderschönen Chor-Klang. Nun, während dieser noch läuft, ändere deie Rate von `0.4` auf `0.38`. Klicke erneut `Ausführen`. Wow! Hast du gehört, wie der Chor die Note gewechselt hat? Setze sie wieder auf `0.4`, zurück auf den alten Wert. Nun setze ihn runter auf `0.2`, runter bis `0.19` und dann wieder hoch auf `0.4`. Sieh wie du durch das Ändern nur eines Parameters, im laufenden Programm, die volle Kontrolle über die Musik erlangen kannst? Spiele ein bisschen mit den Werten für `rate` - wähle deine eigenen Werte. Probiere negative Zahlen, wirklich kleine Zahlen und große Zahlen. Viel Spaß!

en: Sleeping is important
de: Schlafen ist wichtig

en: One of the most important lessons about `live_loop`s is that they need rest. Consider the following `live_loop`:
de: Eine der wichtigsten Lektionen über 'live_loop's ist, dass sie Pausen brauchen. Betrachte einmal folgenden 'live_loop':

en: If you try running this code, you'll immediately see Sonic Pi complaining that the `live_loop` did not sleep. This is a safety system kicking in! Take a moment to think about what this code is asking the computer to do. That's right, it's asking the computer to play an infinite amount of choir samples in zero time. Without the safety system the poor computer will try and do this and crash and burn in the process. So remember, your `live_loop`s must contain a `sleep`.
de: Wenn du versuchst, diese Code auszuführen, wirst du bemerken, dass Sonic Pi sich beschwert, dass der `live_loop` nicht geschlafen hat. Das ist ein Sicherheitssystem! Nimm dir etwas Zeit und denk darüber nach, was dieser Code vom Computer verlangt. Genau, der Computer wird gefragt eine unendliche Anzahl an Samples zum Nullzeitpunkt zu spielen. Ohne das Sicherheitssystem wird der arme Computer das probieren und währenddessen abstürzen. Also immer daran denken: Deine `live_loop`s müssen ein `sleep` beinhalten.

en: Combining Sounds
de: Töne kombinieren

en: Music is full of things happening at the same time. Drums at the same time as bass at the same time as vocals at the same time as guitars... In computing we call this concurrency and Sonic Pi provides us with an amazingly simple way of playing things at the same time. Simply use more than one `live_loop`!
de: Musik ist voll von Dingen, die zur selben Zeit geschehen. Das Schlagzeug spielt zur selben Zeit wie der Bass, Gesang und die Gitarre… In der Informatik nennen wir das Nebenläufigkeit (concurrency). Sonic Pi bietet uns eine einfache Möglichkeit verschiedenste Dinge zur selben Zeit abspielen zu lassen. Benutze einfach mehr als einen `live_loop`!

en: One of the interesting things about using multiple `live_loop`s is that they each manage their own time. This means it's really easy to create interesting polyrhythmical structures and even play with phasing Steve Reich style. Check this out:
de: Eines der interessanten Dinge bei der Verwendung von `live_loop`in mehreren Instanzen ist, dass sie alle jeweils ihre eigene Zeit verwalten. Das bedeutet, dass es wirklich einfach ist, interessante polyrhythmische Strukturen zu erzeugen und sogar mit Phasenverschiebungen á la Steve Reich zu spielen. Schau dir das an:

en: Bringing it all together
de: Alles zusammenführen

en: In each of these tutorials, we'll end with a final example in the form of a new piece of music which draws from all of the ideas introduced. Read this code and see if you can imagine what it's doing. Then, copy it into a fresh Sonic Pi buffer and hit Run and actually hear what it sounds like. Finally, change one of the numbers or comment and uncomment things out. See if you can use this as a starting point for a new performance, and most of all have fun! See you next time...
de: Jedes dieser Tutorials werden wir mit einem abschließenden Code-Beispiel beenden, das sich aller zuvor behandelter Ideen bedient. Schau Dir diesen Code genau an und überlege Dir, was er tut. Kopiere ihn anschließend in einen neuen Sonic Pi-Puffer, drücke auf Start und hör Dir an, wie er klingt. Ändere zum Schluss etwas am Code, indem Du Parameter veränderst oder Dinge auskommentierst. Vielleicht kannst Du das als Ausgangspunkt für eine eigene Performance nutzen. Das Wichtigste ist auf jeden Fall der Spaß dabei. Bis zum nächsten Mal …

en: A.3 Coded Beats
de: A.3 Kodierte Beats

en: Coded Beats
de: Kodierte Beats

en: One of the most exciting and disrupting technical developments in modern music was the invention of samplers. These were boxes that allowed you to record any sound into them and then manipulate and play back those sounds in many interesting ways. For example, you could take an old record, find a drum solo (or break), record it into your sampler and then play it back on repeat at half-speed to provide the foundation for your latest beats. This is how early hip-hop music was born and today it's almost impossible to find electronic music that doesn't incorporate samples of some kind. Using samples is a really great way of easily introducing new and interesting elements into your live coded performances.
de: Eine der spannendsten und einflussreichsten technischen Entwicklungen der modernen Musik ist die Erfindung von Samplern. Sampler sind Musikinstrumente, die es einem erlauben Töne aufzunehmen, sie zu verändern und auf verschiedene Arten und Weisen wiederzugeben. Zum Beispiel ist es mit einem Sampler möglich ein Schlagzeug Solo (oder Break) von einer alten Schalplatte einzuspielen und es anschließend als Grundlage für einen neuen Beat zu verwenden, indem man es mit halber Geschwindigkeit wiedergibt. So ist früher Hip-Hop entstanden und heute gibt es kaum noch Elektronische Musik, die ohne irgendeine Art von Samples auskommt. Samples bieten dir eine großartige Möglichkeit auf einfache Art und Weise neue und interessante Elemente in Deine live gecodete Performance einfließen zu lassen.

en: So where can you get a sampler? Well you already have one - it's your Raspberry Pi! The built-in live coding app Sonic Pi has an extremely powerful sampler built into its core. Let's play with it!
de: Aber wo kriegen wir einen Sampler her? Wir haben bereits einen - es ist unser Raspberry Pi! Die mitgelieferte Live-Coding App Sonic Pi stellt uns einen mächtigen Sampler bereit. Lasst ihn uns ausprobieren!

en: The Amen Break
de: Der Amen Break

en: One of the most classic and recognisable drum break samples is called the Amen Break. It was first performed in 1969 in the song "Amen Brother" by the Winstons as part of a drum break. However, it was when it was discovered by early hip-hop musicians in the 80s and used in samplers that it started being heavily used in a wide variety of other styles such as drum and bass, breakbeat, hardcore techno and breakcore.
de: Eines der klassischen Schlagzeug-Break-Samples mit dem größten Wiedererkennungswert ist der Amen-Break. Er wurde erstmals 1969 von den Winstons in ihrem Song "Amen Brother" als Teil eines Drum-Break aufgenommen. Doch erst seine Wiederentdeckung durch frühe Hip-Hop-Musiker in den 80ern und sein Einsatz in Samplern führte zu einer Verwendung des Samples in einer großen Bandbreite von Musikstilen, wie Drum and Bass, Breakbeat, Hardcore Techno und Breakcore.

en: I'm sure you're excited to hear that it's also built right into Sonic Pi. Clear up a buffer and throw in the following code:
de: Ich bin mir sicher, Du freust Dich zu hören, dass das Sample direkt in Sonic Pi eingebaut ist. Bereite einfach einen Puffer vor und kopiere den folgenden Code hinein:

en: Hit *Run* and boom! You're listening to one of the most influential drum breaks in the history of dance music. However, this sample wasn't famous for being played as a one-shot, it was built for being looped.
de: Drücke auf *Start* und boom! Du hörst dir gerade eines der einflussreichsten Drum Breaks in der Geschichte der Tanzmusik an. Dieses Sample ist allerdings nicht damit berühmt geworden, einmal abgespielt zu werden. Vielmehr ist es wie gemacht dafür wiederholt zu werden.

en: Let's loop the Amen Break by using our old friend the `live_loop` introduced in this tutorial last month:
de: Lass uns den Amen Break in Schleife schalten, indem wir unseren alten Bekannten, den`live_loop` aus dem Tutorial vom letzten Monat, einsetzen:

en: OK, so it is looping, but there's an annoying pause every time round. That is because we asked it to sleep for `2` beats and with the default BPM of 60 the `:loop_amen` sample only lasts for `1.753` beats. We therefore have a silence of `2 - 1.753 = 0.247` beats. Even though it's short, it's still noticeable.
de: OK, es wiederholt sich. Allerdings kommt es am Ende eines Durchlaufs zu einer lästige Pause. Diese entsteht durch unserer Anweisung `2` Takte zu pausieren. Das `:loop_amen` Sample dauert bei einem voreingestellten BPM Wert von 60 nur `1.753` Takte. Das bedeutet kommt es am Sample Ende zu einer Pause von `2 - 1.753 = 0.247` Takten, was kurz, aber durchaus wahrnehmbar ist.

en: To fix this issue we can use the `beat_stretch:` opt to ask Sonic Pi to stretch (or shrink) the sample to match the specified number of beats.
de: Um dieses Problem zu beheben, können wir die `beat_stretch:` Option verwenden. Sie sagt Sonic Pi, dass das Sample auf die angegebene Anzahl von Takten ausgedehnt (bzw. gestaucht) werden soll.

en: Sonic Pi's `sample` and `synth` fns give you a lot of control via optional parameters such as `amp:`, `cutoff:` and `release:`. However, the term optional parameter is a real mouthful so we just call them *opts* to keep things nice and simple.
de: Sonic Pis Funktionen `sample` und `synth` geben uns über optionale Parameter wie `amp:`, `cutoff:` und `release:` viele zusätzliche Steuerungsmöglichkeiten. Da die Bezeichnung optionale Parameter allerdings recht lang ist, werden wir sie ab jetzt einfach *opts* nennen.

en: Now we're dancing! Although, perhaps we want to speed it up or slow it down to suit the mood.
de: Jetzt schwingen wir das Tanzbein! Vielleicht wollen wir es noch etwas schneller, oder doch einen Ton gemächlicher - je nach Stimmung.

en: Playing with Time
de: Mit der Zeit spielen

en: OK, so what if we want to change styles to old school hip hop or breakcore? One simple way of doing this is to play with time - or in other words mess with the tempo. This is super easy in Sonic Pi - just throw in a `use_bpm` into your live loop:
de: OK, wie sieht es aus, wenn wir den Stiel unserer Musik zu Hip Hop oder Breakcore ändern wollen? Eine einfache Möglichkeit das zu tun ist mit der Zeit zu spielen - oder in anderen Worten am Tempo herumbasteln. In Sonic Pi ist das super leicht - füge einfach `use_bpm` in deinen Live-Loop ein:

en: Whilst you're rapping over those slow beats, notice that we're still sleeping for 2 and our BPM is 30, yet everything is in time. The `beat_stretch` opt works with the current BPM to make sure everything just works.
de: Während du gerade zu diesen langsamen Beats rappst, beobachte, dass obwohl wir immer noch eine Pause von 2 machen und unsere BPM bei 30 liegen nichts verzögert klingt. Die `beat_stretch` Option berücksichtigt den aktuellen BPM Wert und bringt alles in Einklang.

en: Filtering
de: Filtern

en: Now we can live loop samples, let's look at some of the most fun opts provided by the `sample` synth. First up is `cutoff:` which controls the cutoff filter of the sampler. By default this is disabled but you can easily turn it on:
de: Nun können wir Samples in unseren Live-Loop integrieren. Schauen wir uns einige der interessanten Optionen des `sample` Synths an. Zunächst `cutoff:`, das den Cut-Off-Filter des Samplers steuert. Standardmäßig ist dieser ausgeschaltet. Aber du kannst ihn ganz einfach einschalten:

en: Go ahead and change the `cutoff:` opt. For example, increase it to 100, hit *Run* and wait for the loop to cycle round to hear the change in the sound. Notice that low values like 50 sound mellow and bassy and high values like 100 and 120 are more full-sounding and raspy. This is because the `cutoff:` opt will chop out the high frequency parts of the sound just like a lawn-mower chops off the top of the grass. The `cutoff:` opt is like the length setting - determining how much grass is left over.
de: Nun, ändere den Wert der `cutoff:` Option. Erhöhe ihn zum Beispiel auf 100, drücke auf *Start* und warte bis der Loop einmal durchgelaufen ist, um die Änderung zu hören. Du kannst beobachten, dass niedrige Werte wie 50 den Klang voll und basslastig machen, hohe Werte wie 100 und 200 aber voll und kratzend klingen. Das liegt daran, dass die `cutoff:` Option die Höhen wegschneidet - genau so wie ein Rasenmäher die Enden von Grashalmen abschneidet. Die `cutoff:` fungiert als eine Längeneinstellung. Sie legt fest, wie viel Grass nach dem Mähen übrig bleibt.

en: Another great tool to play with is the slicer FX. This will chop (slice) the sound up. Wrap the `sample` line with the FX code like this:
de: Ein anderes tolles Tool, das wir ausprobieren können, ist der FX Slicer. Er stückelt unseren Sound in Einzelsequenzen. Verpacke die `sample` Zeile dafür einfach mit dem folgenden FX Code:

en: Notice how the sound bounces up and down a little more. (You can hear the original sound without the FX by changing the `mix:` opt to `0`.) Now, try playing around with the `phase:` opt. This is the rate (in beats) of the slicing effect. A smaller value like `0.125` will slice faster and larger values like `0.5` will slice more slowly. Notice that successively halving or doubling the `phase:` opts val tends to always sound good. Finally, change the `wave:` opt to one of 0, 1, or 2 and hear how it changes the sound. These are the various wave shapes. 0 is a saw wave, (hard in, fade out) 1 is a square wave (hard in, hard out) and 2 is a triangle wave (fade in, fade out).
de: Beobachte, wie der Klang dadurch etwas mehr auf und ab federt. (Du kannst dir den ursprünglichen Klang ohne FX anhören, indem du die Option `mix:` auf `0` setzt.) Als nächstes, versuche dich an der `phase:` Option. Das ist die Rate (in Beats) in der gestückelt wird. Ein kleiner Wert wie `0.125` stückelt häufig, hohe Werte wie `0.5` stückeln hingegen langsamer. Beobachte, dass eine stufenweises Halbieren oder Vierteln der `phase:` tendenziell immer gut klingt. Setzte zuletzt die `wave:` Option auf 0, 1, oder 2 und höre dir an, wie die Änderung klingt. Die Werte stehen für unterschiedliche Schwingungsformen. 0 repräsentiert eine Sägezahnschwindung (hard in, fade out), 1 eine Rechteckschwingung (hard in, hard out) und 2 eine Dreieckschwingung (hard in, hard out).

en: Finally, let's go back in time and revisit the early Bristol drum and bass scene with this month's example. Don't worry too much about what all this means, just type it in, hit Run, then start live coding it by changing opt numbers and see where you can take it. Please do share what you create! See you next time...
de: Lass uns für unser letztes Beispiel einem Blick auf die frühe Drum and Bass Szene in Bristol werfen. Mach dir keinen Sorgen, wenn du nicht genau verstehst, wie das Beispiel funktioniert. Füge den Code einfach in Sonic Pi ein, klicke auf Ausführen und versuche dich am Live-Coden, indem du die Werte der verschiedenen Optionen veränderst. Vergesse nicht deine Kreationen mit anderen zu teilen! Bis zum nächsten Mal…

en: Whether it's the haunting drift of rumbling oscillators or the detuned punch of saw waves piercing through the mix, the lead synth plays an essential role on any electronic track. In last month's edition of this tutorial series we covered how to code our beats. In this tutorial we'll cover how to code up the three core components of a synth riff - the timbre, melody and rhythm.
de: Ob polterndere Oszillatoren oder die verstimmten Klänge von Sägezahnschwingungen, die sich durch ein Stück ziehen, der Lead Synth - der melodische Hauptpart eines Stücks - spielt in jeder elektronischen Komposition eine wichtige Rolle. Im der letzten Einheit dieses Tutorials haben wir gelernt, wie man Klänge erzeugt. Jetzt werden wir uns damit beschäftigen, wie wir die drei Hauptkomponenten eines Synth Riffs - Klangfarbe, Melodie und Rhythmus - coden können.

en: OK, so power up your Raspberry Pi, crack open Sonic Pi v2.6+ and let's make some noise!
de: OK, fahre deinen Raspberry Pi hoch, öffne Sonic Pi v2.6+ und auf gehts, lass und Musik machen!

en: Timbral Possibilities
de: Die Welt der Klangfarben

en: An essential part of any synth riff is changing and playing with the timbre of the sounds. We can control the timbre in Sonic Pi in two ways - choosing different synths for a dramatic change and setting the various synth opts for more subtle modifications. We can also use FX, but that's for another tutorial...
de: Ein essentieller Teil jeder Synth-Figur ist das Verändern und Spielen mit der Färbung der Klänge. Wir können die Klangfarbe in Sonic Pi Sonic Pi auf zwei Arten steuern - indem wir für dramatische Änderungen verschiedene Synths verwenden, und für dezente Modifizierungen die verschiedenen Synth-Optionen einsetzen. Wir können dafür auch Effekte einsetzen, aber das ist ein Tutorial für sich …

en: Let's create a simple live loop where we continually change the current synth:
de: Lass uns einen einfachen Live-Loop schreiben, in dem wir laufend den Synth ändern:

en: Take a look at the code. We're simply ticking through a ring of synth names (this will cycle through each of these in turn repeating the list over and over). We pass this synth name to the `use_synth` fn (function) which will change the `live_loop`'s current synth. We also play note `:e2` (E at the second octave), with a release time of 0.5 beats (half a second at the default BPM of 60) and with the `cutoff:` opt set to 100.
de: Schau dir den Code genauer an. Mit dem `tick` Befehl gehen wir Eintrag für Eintrag durch einen Ring von Synth Namen (wobei wir die Liste immer wieder wiederholen). Anschließend übergeben wir diesen Synth an die `use_synth` Funktion, die den aktuellen Synth unseres Live-Loops ändert. Außerdem spielen wir die Note `:e2` (e der zweiten Oktave) mit einer Abklingzeit von 0.5 Takten (0.5 Sekunden bei unser Standard-BPM von 60) und einem `cutoff:` Wert von 100.

en: Hear how the different synths have very different sounds even though they're all playing the same note. Now experiment and have a play. Change the release time to bigger and smaller values. For example, change the `attack:` and `release:` opts to see how different fade in/out times have a huge impact on the sound. Finally change the `cutoff:` opt to see how different cutoff values also massively influence the timbre (values between 60 and 130 are good). See how many different sounds you can create by just changing a few values. Once you've mastered that, just head to the Synths tab in the Help system for a full list of all the synths and all the available opts each individual synth supports to see just how much power you have under your coding fingertips.
de: Hörst du, wie die unterschiedlichen Synths vollkommen verschiedene Klänge erzeugen, obwohl sie alle die selbe Note spielen? Lass uns damit experimentieren. Erhöhe oder verkleinere den Wert der Abklingzeit. Ändere zum Beispiel die Werte der Optionen `attack:` und `release:`, um zu sehen, wie sich unterschiedliche Fade-In und Fade-Out Zeiten auf den Klang auswirken. Zuletzt kannst du den Wert der `cutoff:` Option ändern, um zu beobachten, wie unterschiedliche Cut-Off-Wert die Klangfarbe beeinflussen (Werte zwischen 60 und 130 sind gut). Probiert mal aus, wie viele verschiedene Klänge du erzeugen kannst, indem du an diesen wenigen Parametern rumschraubst. Wenn dir das gelingt, kannst du im dir im Help System den Eintrag zu Synth anschauen. Hier findest du eine Auflistung aller Synths und der Optionen, die sie bereitstellen. Ein Reich an Möglichkeiten liegt dir zu Füßen.

en: Timbre
de: Klangfarbe

en: Timbre is just a fancy word describing the sound of a sound. If you play the same note with different instruments such as a violin, guitar, or piano, the pitch (how high or low it sounds) would be the same, but the sound quality would be different. That sound quality - the thing which allows you to tell the difference between a piano and a guitar is the timbre.
de: Klangfarbe (engl. timbre) ist nur ein ausgefallenes Wort für den Klang eines Geräusches. Wenn man die selbe Note auf verschiedenen Instrumenten, wie zum Beispiel einer Geige, einer Gitarre oder einem Klavier spielt, so bleibt die Tonhöhe (wie hoch oder niedrig ein Ton ist) immer die selbe. Die Tonqualität hingegen unterscheidet sich. Dieser Unterschied, der einem erlaubt festzustellen, ob es sich um ein Klavier oder eine Gitarre handelt, ist die Klangfarbe.

en: Melodic Composition
de: Melodische Komposition

en: Another important aspect to our lead synth is the choice of notes we want to play. If you already have a good idea, then you can simply create a ring with your notes in and tick through them:
de: Ein anderer wichtiger Aspekt in der Zusammenstellung unseres Leas Synths ist die Wahl der Noten, die gespielt werden sollen. Wenn du bereits eine Idee dafür hast, kannst du einfach einen Ring erstellen, der über die gewünschte Notenfolge iteriert:

en: Here, we've defined our melody with a ring which includes both notes such as `:e3` and rests represented by `:r`. We're then using `.tick` to cycle through each note to give us a repeating riff.
de: Hier haben wir unsere Melodie mit Hilfe eines Rings definiert, der sich aus Noten wie `:e3` und Pausen - dargestellt durch `:r`- zusammensetzt. Wir nutzen `.tick` um über die Notenfolge zu iterieren und so einen sich wiederholenden Riff zu erzeugen.

en: Auto Melody
de: Automatische Melodie

en: It's not always easy to come up with a nice riff from scratch. Instead it's often easier to ask Sonic Pi for a selection of random riffs and to choose the one you like the best. To do that we need to combine three things: rings, randomisation and random seeds. Let's look at an example:
de: Es ist nicht leicht einen gut klingenden Riff aus dem Nichts zu zaubern. Statt dessen ist es oft hilfreich sich von Sonic Pi eine Auswahl von zufälligen Riffs ausgeben zu lassen und einen von diesen auszuwählen. Um das zu tun, verbinden wir drei bekannte Konzepte miteinander: Ringe, Randomisierung und Zufallszahlen. Schauen wir uns ein Beispiel an:

en: There's a few things going on - let's look at them in turn. First, we specify that we're using random seed 3. What does this mean? Well, the useful thing is that when we set the seed, we can predict what the next random value is going to be - it's the same as it was last time we set the seed to 3! Another useful thing to know is that shuffling a ring of notes works in the same way. In the example above we're essentially asking for the 'third shuffle' in the standard list of shuffles - which is also the same every time as we're always setting the random seed to the same value right before the shuffle. Finally we're just ticking through our shuffled notes to play the riff.
de: Es gibt ein paar Dinge, die wir uns der Reihe nach ansehen wollen. Zunächst legen wir fest, dass wir den Zufallswert 3 verwenden. Was bedeutet das? Nun, das Nützliche daran ist, dass wir, wenn wir den Seed setzen, vorhersagen können, was der nächste Zufallswert sein wird - es ist derselbe wie beim letzten Mal, als wir den Seed auf 3 gesetzt haben! Eine weitere nützliche Information ist, dass das Mischen eines Notenrings auf dieselbe Weise funktioniert. Im obigen Beispiel fragen wir im Wesentlichen nach dem "dritten Shuffle" in der Standardliste der Shuffles - was auch jedes Mal dasselbe ist, da wir den Zufallswert immer auf denselben Wert setzen, kurz bevor wir den Shuffle starten. Schließlich gehen wir einfach durch unsere gemischten Noten, um das Riff zu spielen.

en: Now, here's where the fun starts. If we change the random seed value to another number, say 3000, we get an entirely different shuffling of the notes. So now it's extremely easy to explore new melodies. Simply choose the list of notes we want to shuffle (scales are a great starting point) and then choose the seed we want to shuffle with. If we don't like the melody, just change one of those two things and try again. Repeat until you like what you hear!
de: Jetzt fängt der Spaß erst so richtig an. Wenn wir den Startwert(Seed) für den Zufallsgenerator auf eine andere Zahl, z. B. 3000, ändern, erhalten wir eine völlig andere Mischung der Noten. So ist es jetzt extrem einfach, neue Melodien zu erforschen. Wähle einfach die Liste der Noten aus, die du mischen möchten (Tonleitern sind ein guter Ausgangspunkt), und wählen Sie dann den Startwert(Seed), mit dem du mischen möchten. Wenn uns die Melodie nicht gefällt, ändern wir einfach einen dieser beiden Punkte und versuchen es erneut. Wiederhole den Vorgang, bis dir gefällt was du hörst!

en: Pseudo Randomisation
de: Pseudo-Randomisierung

en: Sonic Pi's randomisation is not actually random it's what's called pseudo random. Imagine if you were to roll a dice 100 times and write down the result of each roll onto a piece of paper. Sonic Pi has the equivalent of this list of results which it uses when you ask for a random value. Instead of rolling an actual dice, it just picks the next value from the list. Setting the random seed is just jumping to a specific point in that list.
de: Die Zufallsgenerierung von Sonic Pi ist nicht wirklich zufällig, sondern wird als Pseudozufall bezeichnet. Stell Dir vor, Du würdest 100 Mal würfeln und das Ergebnis jedes Wurfs auf ein Blatt Papier schreiben. Sonic Pi verfügt über das Äquivalent dieser Ergebnisliste, die verwendet wird, wenn man nach einem Zufallswert fragt. Anstatt zu würfeln, wird einfach der nächste Wert auf der Liste ausgewählt. Wenn Du einen Startwert(Seed) setzt, dann springst Du einfach zu einem bestimmten Punkt in dieser Liste.

en: Finding your Rhythm
de: Finde deinen Rythmus

en: Another important aspect to our riff is the rhythm - when to play a note and when not to. As we saw above we can use `:r` in our rings to insert rests. Another very powerful way is to use spreads which we'll cover in a future tutorial. Today we'll use randomisation to help us find our rhythm. Instead of playing every note we can use a conditional to play a note with a given probability. Let's take a look:
de: Ein weiteres wichtiges Merkmal unseres Riffs ist der Rhythmus, d.h. wann wir eine Note spielen und wann nicht. Wir haben bereits gesehen, dass wir `:r` nutzen können, um Pausen in einen Ring einzufügen. Eine weiter Möglichkeit auf den Rhythmus Einfluss zu nehmen sind sog. Spreads, über die wir in einem kommenden Tutorial mehr lernen werden. Heute nutzen wir Randomisierung, um unseren Rhythmus zu finden. Anstatt immer jede Note in einem Ring zu spielen, können wir über eine Bedingung festlegen, mit welcher Wahrscheinlichkeit sie abgespielt werden. Lass uns einen Blick darauf werfen:

en: A really useful fn to know is `one_in` which will give us a `true` or `false` value with the specified probability. Here, we're using a value of 2 so on average one time every two calls to `one_in` it will return `true`. In other words, 50% of the time it will return `true`. Using higher values will make it return `false` more often introducing more space into the riff.
de: Eine nützliche Funktion in diesem Zusammenhang ist die Funktion `one_in`, die `true` bzw. `false` mit einer bestimmten Wahrscheinlichkeit zurückgibt. Hier verwenden wir den Wert 2, d.h. `one_in` gibt durchschnittlich ein Mal alle zwei Aufrufe `true` zurück. Mit anderen Worten, `true` wird in 50% der Fälle zurückgegeben. Höhere Werte bewirken, dass statt `true` häufiger `false` zurückgegeben wird. Das führt zu mehr Lücken in unserem Riff.

en: Notice that we've added some iteration in here with `16.times`. This is because we only want to reset our random seed value every 16 notes so our rhythm repeats every 16 times. This doesn't affect the shuffling as that is still done immediately after the seed is set. We can use the iteration size to alter the length of the riff. Try changing the 16 to 8 or even 4 or 3 and see how it affects the rhythm of the riff.
de: Beobachte, dass wir mit dem Befehl `16.times` Wiederholung eingebaut haben. Das haben wir gemacht, damit sich unser Zufallsgenerator (der Rückgabewert der `one_in` Funktion) nur alle 16 Noten zurücksetzt und unser Rhythmus sich so alle 16 Schlägen wiederholt. Wir nehmen damit keinen Einfluss auf das durcheinander Mischen, weil letzteres direkt nach dem Initiieren des Zufallsgenerators passiert. Wir können über die Größe der Wiederholungen die Länge unseres Riffs verändern. Versuche mal die Zahl 16 auf 8 oder sogar 4 oder 3 zu ändern und schaue dir an, wie sich das auf den Rhythmus des Riffs auswirkt.

en: OK, so let's combine everything we've learned together into one final example. See you next time!
de: OK, lass uns zum Schluss alles, das wir gelernt haben, in einem abschließenden Beispiel nutzen. Bis zum nächsten Mal!

en: It's impossible to look through the history of electronic dance music without seeing the enormous impact of the tiny Roland TB-303 synthesiser. It's the secret sauce behind the original acid bass sound. Those classic squealing and squelching TB-303 bass riffs can be heard from the early Chicago House scene through to more recent electronic artists such as Plastikman, Squarepusher and Aphex Twin.
de: Wenn man sich die Geschichte der Elektronischen Tanzmusik anschaut, ist es schier unmöglich den enormen Einfluss, den der winzige Synthesizer Roland TB-303 hatte, zu übersehen. Er ist das Geheimnis hinter dem Klang des originalen Acid Bass. Diese klassisch quietschenden und quieksenden Bass Riffe des TB-303 kann man sowohl in der frühen Chicago House Szene als auch bei Interpreten moderner Elektronischen Musik wie Plastikman, Squarepusher und Aphex Twin hören.

en: Although getting your hands on an original TB-303 is not so easy you will be pleased to know that you can turn your Raspberry Pi into one using the power of Sonic Pi. Behold, fire up Sonic Pi and throw this code into an empty buffer and hit Run:
de: Obwohl es nicht leicht ist sich einen originalen TB-303 zu beschaffen, wirst Du Dich sicher freuen zu hören, dass Du Deinen Raspberry Pi mit Hilfe von Sonic Pi in einen TB-303 verwandeln kannst. Los gehts, wirf Sonic Pi an, kopiere den folgenden Code in einen leeren Puffer und klicke auf Ausführen:

en: Instant acid bass! Let's play around...
de: Siehe da! Wir haben einen Acid Bass! Lass uns weiter experimentieren…

en: Squelch that Bass
de: Bringe den Bass zum Glucksen

en: First, let's build a live arpeggiator to make things fun. In the last tutorial we looked at how riffs can just be a ring of notes that we tick through one after another, repeating when we get to the end. Let's create a live loop that does exactly that:
de: Lass uns zunächst einen live Arpeggiator bauen. In unserer letzten Tutorialeinheit haben wir gelernt, dass Riffs durch Ringe von Noten, die wir nach einander in einer sich wiederholenden Schleife wiedergeben, repräsentiert werden können. Lass uns einen Live-Loop schreiben, der das gleiche macht:

en: Take a look at each line.
de: Schaue dir jede Codeziele genau an.

en: On the first line we set the default synth to be `tb303` with the `use_synth` fn.
de: In der ersten Zeile setzen wir den Defaultwert der`use_synth` Funktion auf `tb303`.

en: On line two we create a live loop called `:squelch` which will just loop round and round.
de: In der zweiten Zeile erstellen wir einen Live-Loop vom Typen `:squelch`, der sich die ganze Zeit wiederholt.

en: Line three is where we create our riff - a ring of notes (E in octaves 1, 2, and 3) which we simply tick through with `.tick`. We define `n` to represent the current note in the riff. The equals sign just means to assign the value on the right to the name on the left. This will be different every time round the loop. The first time round, `n` will be set to `:e1`. The second time round it will be `:e2`, followed by `:e3`, and then back to `:e1`, cycling round forever.
de: In der dritten Zeile erstellen wir unseren Riff - einen Ring aus Noten (E in den Oktaven 1, 2, und 3), der diese mit Hilfe eines `.tick`s in Schleife durchläuft. Wir definieren `n` als die aktuelle Note in unserem Riff. Das Gleichheitszeichen hier bedeutet, dass wir den Wert auf der rechten Seite der Bezeichnung auf der linken Seite zuzuweisen. In jedem Durchlauf unseres Loops hat `n`also ein anderer Wert. Im ersten Durchlauf wird `n` auf `:e1` gesetzt. Im zweiten Durchlauf wird es auf `:e2`, gefolgt von `:e3` und dann wieder auf `:e1` usw. gesetzt.

en: Line four is where we actually trigger our `:tb303` synth. We're passing a few interesting opts here: `release:`, `cutoff:`, `res:` and `wave:` which we'll discuss below.
de: Mit Zeile viert wird der eigentliche `:tb303` Synth eingeleitet. Dabei werden einige interessante Optionen mitgegeben: `release:`, `cutoff:`, `res:` and `wave:` über die wir etwas später genauer sprechen werden.

en: Line five is our `sleep` - we're asking the live loop to loop round every `0.125`s or 8 times a second at the default BPM of 60.
de: In Zeile fünf machen wir eine Pause - wir geben unserem Live-Loop vor sich alle `0.125`s (oder 8 mal pro Sekunde bei einem BPM von 60) zu wiederholen.

en: Line six is the `end` to the live loop. This just tells Sonic Pi where the end of the live loop is.
de: Zeile sechs markiert das Ende (`end`) des Live-Loops. Sie teilt Sonic Pi nur mit, wo die zu wiederholende Sequenz zu Ende ist.

en: Whilst you're still figuring out what's going on, type in the code above and hit the Run button. You should hear the `:tb303` kick into action. Now, this is where the action is: let's start live coding.
de: Während du dir noch überlegst, wie das alles genau funktioniert, tippe den oben stehenden Code ab und klicke auf Ausführen. Du solltest den `:tb303` lostreten hören. Jetzt legen wir richtig los: lass uns mit dem Live-Coding beginnen.

en: Whilst the loop is still live, change the `cutoff:` opt to `110`. Now hit the Run button again. You should hear the sound become a little harsher and more squelchy. Dial in `120` and hit run. Now `130`. Listen how higher cutoff values make it sound more piercing and intense. Finally, drop it down to `80` when you feel like a rest. Then repeat as many times as you want. Don't worry, I'll still be here...
de: Während der Loop noch aktiv ist, ändere den `cutoff:`-Wert auf `110`. Drücke nun erneut den „Ausführen“-Knopf. Der Ton sollte sich nun etwas härter und quäkiger anhören. Ändere ihn jetzt auf `120` und drücke „Ausführen“. Jetzt `130`. Hörst du, wie höhere Cutoff-Werte den Klang durchdringender und intensiver machen? Ändere den Wert schließlich auf `80`, wenn du dich nach einer Pause sehnst. Wiederhole das Ganze dann so oft wie du willst. Keine Sorge, ich werde immer noch hier sein...

en: Another opt worth playing with is `res:`. This controls the level of resonance of the filter. A high resonance is characteristic of acid bass sounds. We currently have our `res:` set to `0.8`. Try cranking it up to `0.85`, then `0.9`, and finally `0.95`. You might find that a cutoff such as `110` or higher will make the differences easier to hear. Finally go wild and dial in `0.999` for some insane sounds. At a `res` this high, you're hearing the cutoff filter resonate so much it starts to make sounds of its own!
de: Eine weitere Option, mit der es sich zu spielen lohnt, ist `res:`. Damit wird der Resonanzgrad des Filters eingestellt. Eine hohe Resonanz ist charakteristisch für Acid-Bass-Sounds. Im Moment haben wir `res:` auf `0.8` eingestellt. Versuche, ihn auf `0.85`, dann `0.9` und schließlich `0.95` zu erhöhen. Möglicherweise wirst du feststellen, dass ein Cutoff-Wert wie `110` oder höher die Unterschiede besser hörbar macht. Jetzt mach mal etwas wildes und gib `0.999` ein: hörst du den verrückten Sound? Bei einer so hohen Auflösung hört man den Cutoff-Filter so stark mitschwingen, dass er anfängt, eigene Töne zu erzeugen!

en: Finally, for a big impact on the timbre try changing the `wave:` opt to `1`. This is the choice of source oscillator. The default is `0` which is a sawtooth wave. `1` is a pulse wave and `2` is a triangle wave.
de: Ändere zum Schluss die `wave:` Option auf `1`, um einen großen Einfluss auf die Klangfarbe zu nehmen. Dies legt die Art der Schwingungserzeugung fest. Der Standard ist mit `0` eine Sägezahnschwingung. `1` steht für eine Pulswelle und `2`für eine Dreiecksschwingung.

en: Of course, try different riffs by changing the notes in the ring or even picking notes from scales or chords. Have fun with your first acid bass synth.
de: Versuche natürlich auch verschiedene Riffs zu erzeugen, indem du die Noten im Ring änderst oder sogar Noten aus Skalen oder Akkorden auswählst. Viel Spaß mit deinem ersten Acid Bass Synth.

en: Deconstructing the TB-303
de: Den TB-303 zerlegen

en: The design of the original TB-303 is actually pretty simple. As you can see from the following diagram there's only 4 core parts.
de: Der Aufbau des originalen TB-303 ist eigentlich ganz einfach. Wie man dem folgenden Diagramm entnehmen kann, gibt es nur vier Hauptbestandteile.

en: First is the oscillator wave - the raw ingredients of the sound. In this case we have a square wave. Next there's the oscillator's amplitude envelope which controls the amp of the square wave through time. These are accessed in Sonic Pi by the `attack:`, `decay:`, `sustain:` and `release:` opts along with their level counterparts. For more information read Section 2.4 'Duration with Envelopes' in the built-in tutorial. We then pass our enveloped square wave through a resonant low pass filter. This chops off the higher frequencies as well as having that nice resonance effect. Now this is where the fun starts. The cutoff value of this filter is also controlled by its own envelope! This means we have amazing control over the timbre of the sound by playing with both of these envelopes. Let's take a look:
de: Zunächst haben wir die Oszillatorwelle – die Rohzutaten des Klangs. In diesem Fall haben wir eine Rechteckwelle. Als nächstes gibt es die Amplitudenhüllkurve des Oszillators, die den Verstärker der Rechteckwelle über die Zeit steuert. Der Zugriff auf diese erfolgt in Sonic Pi über die Optionen „attack:“, „decay:“, „sustain:“ und „release:“ zusammen mit ihren Level-Gegenstücken. Weitere Informationen finden Sie in Abschnitt 2.4 „Dauer mit Hüllkurven“ im integrierten Tutorial. Anschließend leiten wir unsere umhüllte Rechteckwelle durch einen resonanten Tiefpassfilter. Dadurch werden die höheren Frequenzen abgehackt und es entsteht ein schöner Resonanzeffekt. Jetzt beginnt der Spaß. Der Cutoff-Wert dieses Filters wird auch durch seine eigene Hüllkurve gesteuert! Das bedeutet, dass wir durch das Spielen mit beiden Hüllkurven eine erstaunliche Kontrolle über die Klangfarbe haben. Werfen wir einen Blick darauf:

en: Notice that I've passed everything through a `:reverb` FX for extra atmosphere - try other FX to see what works!
de: Beobachte, dass wir, um etwas mehr Stimmung zu erzeugen, alles durch einen `:reverb` FX schicken - probiere ein paar andere Effekte aus und schaue welche hier gut passen!

en: A.6 Musical Minecraft
de: A.6 Musisches Minecraft

en: Musical Minecraft
de: Musisches Minecraft

en: Hello and welcome back! In the previous tutorials we've focussed purely on the music possibilities of Sonic Pi - (turning your Raspberry Pi into a performance ready musical instrument). So far we've learned how to:
de: Hallo und willkommen zurück! In den zurückliegenden Tutorialeinheiten haben wir uns ausschließlich auf die musikalischen Möglichkeiten von Sonic Pi konzentriert (um unseren Raspberry Pi in ein konzertfähiges Musikinstrument zu verwandeln). Bisher haben wir gelernt wie man:

en: Live Code - changing the sounds on-the-fly,
de: Live-Coded - Klänge live improvisieren,

en: Code some huge beats,
de: gigantische Beats komponiert,

en: Generate powerful synth leads,
de: mächtige Lead Synths generiert,

en: Re-create the famous TB-303 acid-bass sound.
de: und den bekannten TB-303 Acid Bass nachbaut.

en: There's so much more to show you (which we will explore in future editions). However, this month, let's look at something Sonic Pi can do that you probably didn't realise: control Minecraft.
de: Es gibt noch so viel Dinge zu entdecken (was wir in zukünftigen Ausgaben des Tutorials auch machen werden). Diesen Monat lass uns einen Blick auf etwas werfen, was Sonic Pi kann, das du wahrscheinlich nicht erwartet hast: Minecraft steuern.

en: OK, let's get started. Boot up your Raspberry Pi, fire up Minecraft Pi and create a new world. Now start up Sonic Pi and re-size and move your windows so you can see both Sonic Pi and Minecraft Pi at the same time.
de: OK, lass uns loslegen. Fahre deinen Raspberry Pi hoch, werfe Minecraft Pi an und erstelle eine neue Welt. Starte nun Sonic Pi und verändere die Größe deiner Fenster so, dass du sowohl Sonic Pi als auch Minecraft Pi auf deinem Bildschirm sehen kannst.

en: In a fresh buffer type the following:
de: Gib Folgendes in einen leeren Puffer ein:

en: Now, hit Run. Boom! Your message appeared in Minecraft! How easy was that? Now, stop reading this for a moment and play about with your own messages. Have fun!
de: Drücke jetzt auf Ausführen. Boom! Deine Nachricht erscheint in Minecraft! Wie einfach war das denn? Lege nun dieses Tutorial kurz beiseite und spiele mit deinen eigenen Nachrichten herum. Viel Spaß!

en: ![Screen 0](../../../etc/doc/images/tutorial/articles/A.06-minecraft/Musical-Minecraft-0-small.png)
de: ![Bildschirm 0](../../../etc/doc/images/tutorial/articles/A.06-minecraft/Musical-Minecraft-0-small.png)

en: Sonic Teleporter
de: Schall-Teleporter

en: Now let's do some exploring. The standard option is to reach for the mouse and keyboard and start walking around. That works, but it's pretty slow and boring. It would be far better if we had some sort of teleport machine. Well, thanks to Sonic Pi, we have one. Try this:
de: Lass uns ein wenig erkunden. Die üblichste Option ist Maus und Tastatur zu ergreifen und einfach loszulaufen. Das funktioniert, ist aber langsam und langweilig. Es wäre doch viel besser, wenn wir eine Art Teleporter hätten. Dank Sonic Pi haben wir diesen. Probier dieses:

en: Crikey! That was a long way up. If you weren't in flying-mode then you would have fallen back down all the way to the ground. If you double-tap space to enter flying-mode and teleport again, you'll stay hovering at the location you zap to.
de: Meine Güte! Das war ein langer Weg nach oben. Wenn du dich nicht im Flugmodus befunden hättest, wärst du den ganzen Weg zurück auf den Boden gefallen. Wenn du doppelt auf die Leertaste drückst, um in den Flugmodus zu wechseln und dich wieder zu teleportieren, schwebst du weiterhin an der Stelle, an die du dich teleportiert hast.

en: Now, what do those numbers mean? We have three numbers which describe the coordinates of where in the world we want to go. We give each number a name - x, y and z:
de: Aber was bedeuten diese Zahlen? Wir haben drei Zahlen, welche die Koordinaten beschreiben, zu denen wir in der Welt gehen wollen. Jede der Zahlen bekommt einen Namen - x, y und z:

en: x - how far left and right (80 in our example)
de: x - wie weit links und rechts (80 in unserem Beispiel)

en: y - how high we want to be (40 in our example)
de: y - wie hoch wir sein wollen (40 in unserem Beispiel)

en: z - how far forward and back (100 in our example)
de: z - wie weit vorwärts und rückwärts (100 in unserem Beispiel)

en: By choosing different values for x, y and z we can teleport *anywhere* in our world. Try it! Choose different numbers and see where you can end up. If the screen goes black it's because you've teleported yourself under the ground or into a mountain. Just choose a higher y value to get back out above land. Keep on exploring until you find somewhere you like...
de: Indem wir unterschiedliche Werte für x, y und z wählen, können wir uns an *jeden* Ort der Welt teleportieren. Probiere es aus! Wähle verschiedene Zahlen aus und schaue, wo du landest. Falls der Bildschirm schwarz wird, hast du dich in den Boden oder in einen Berg teleportiert. Wähle in diesem Fall einen höheren y-Wert um wieder über den Boden zu kommen. Erkunde weiter, bis du einen Platz findest, der dir gefällt...

en: ![Screen 1](../../../etc/doc/images/tutorial/articles/A.06-minecraft/Musical-Minecraft-1-small.png)
de: ![Bildschirm 1](../../../etc/doc/images/tutorial/articles/A.06-minecraft/Musical-Minecraft-1-small.png)

en: Magic Blocks
de: Magische Blöcke

en: ![Screen 2](../../../etc/doc/images/tutorial/articles/A.06-minecraft/Musical-Minecraft-2-small.png)
de: ![Bildschirm 2](../../../etc/doc/images/tutorial/articles/A.06-minecraft/Musical-Minecraft-2-small.png)

en: Outrageous and Disruptive
de: Skandalös und disruptiv

en: Decoding the Habanera
de: Die Habanera dekodieren

en: Trying to live code the whole opera would be a bit of a challenge for this tutorial, so let's focus on one of the most famous parts - the bass line to the Habanera:
de: Der Versuch die gesamte Oper in diesem Tutorial zu kodieren, wäre wohl zu viel des Guten, daher werden wir uns auf einen der berühmtesten Teile fokussieren - die Basslinie der Habanera:

en: Notes
de: Anmerkungen

en: ![Notes](../../../etc/doc/images/tutorial/articles/A.07-bizet/notes.png)
de: ![Anmerkungen](../../../etc/doc/images/tutorial/articles/A.07-bizet/notes.png)

en: Rests
de: Pausen

en: Rhythm
de: Rhythmus

en: We're now in a position to start translating this bass line to Sonic Pi. Let's encode these notes and rests in a ring:
de: Wir sind jetzt in der Lage, um diese Basslinie für Sonic Pie zu übersetzen. Lass uns diese Noten kodieren und gut sein lassen:

en: Let's see what this sounds like. Throw it in a live loop and tick through it:
de: Lass uns schauen, wie es sich anhört. Stelle es in einen Live-Loop und ticke durch:

en: Moody Synths
de: Stimmungssynthesizer

en: Finally, let's combine all the ideas so far into a new remix of the Habanera. You might notice that I've included another part of the bass line as a comment. Once you've typed it all into a fresh buffer hit Run to hear the composition. Now, without hitting stop, *uncomment* the second line by removing the `#` and hit run again - how marvellous is that! Now, start mashing it around yourself and have fun.
de: Zum Schluss lass uns alle bisherigen Ideen in einen neuen Remix von Habanera kombinieren. Du wirst feststellen, dass ich einen weiteren Teil der Basslinie als Kommentar hinzugefügt habe. Wenn Du alles in einen neuen Puffer eingegeben hast, drücke *Run*, um Dir die Komposition anzuhören. Und jetzt, ohne auf Stopp zu drücken, entkommentiere die zweite Zeile, indem Du das `#`-Zeichen entfernst, und drücke dann noch einmal *Run* – wie fantastisch das ist! Jetzt misch alles wie es Dir gefällt – viel Spaß.

en: A.8 Become a Minecraft VJ
de: A.8 Werde ein Minecraft VJ

en: Become a Minecraft VJ
de: Werde ein Minecraft VJ

en: Let's get started...
de: Lass uns anfangen …

en: Getting Started
de: Erste Schritte

en: Let's start with a simple warm up exercise to refresh ourselves with the basics. First up, crack open your Raspberry Pi and then fire up both Minecraft and Sonic Pi. In Minecraft, create a new world, and in Sonic Pi choose a fresh buffer and write in this code:
de: Um unsere Grundlagen aufzufrischen, lass uns mit einer einfachen Übung zum Aufwärmen anfangen. Öffne zunächst Deinen Raspberry Pi, dann starte Minecraft und Sonic Pi. Erstelle eine neue Welt in Minecraft, und in Sonic Pi wählst Du einen neuen Puffer, dann schreibe diesen Code:

en: Hit the Run button and you'll see the message over in the Minecraft window. OK, we're ready to start, let's have some fun......
de: Klicke den Run-Button und Du wirst die Meldung im Minecraft-Fenster sehen. Ok, wir können nun loslegen, lass uns Spaß haben …

en: Sand Storms
de: Sandstürme

en: `sleep` - for inserting a delay between actions
de: `sleep` - um eine Verzögerung zwischen Aktionen einzufügen

en: `mc_location` - to find our current location
de: `mc_location` - um unsere aktuelle Position zu finden

en: `rrand` - to allow us to generate random values within a range
de: `rrand` - damit wir Zufallswerte innerhalb eines Bereichs erzeugen können

en: Let's make it rain a little first before unleashing the full power of the storm. Grab your current location and use it to create a few sand blocks up in the sky nearby:
de: Lass es uns etwas regnen lassen bevor wir die ganze Kraft des Sturms enthüllen. Versuche mit dem Wissen das du hast ein paar Sandblöke im Himmel zu erschaffen:

en: `xd` - the difference for x which will be between -10 and 10
de: `xd` - Die Abweichung für x. Sie muss zwischen -10 und 10 liegen

en: `zd` - the difference for z also between -10 and 10
de: `zd` - Die Abweichung für z, auch zwischen -10 und 10

en: `co` - a cutoff value for the low pass filter between 70 and 130
de: `co` - ein Cut-Off-Wert für den Tiefpassfilter zwischen 70 und 130

en: Epic Block Patterns
de: Epische Blockmuster

en: A.9 Randomisation
de: A.9 Zufälligkeit

en: There is no random
de: Es gibt keinen Zufall

en: A Random Melody
de: Eine zufällige Melodie

en: Type this into a spare buffer and hit Run. You'll hear a melody consisting of 'random' notes between 50 and 95. When it's finished, hit Run again to hear exactly the same melody again.
de: Tippe dies in einen freien Puffer und drücke *Run*. Du wirst eine Melodie hören, die aus zufälligen Noten zwischen 50 und 95 besteht. Wenn sie beendet ist, drücke *Run* noch einmal, um Dir exakt die gleiche Melodie erneut anzuhören.

en: Handy Randomisation Functions
de: Praktische Zufälligkeitsfunktionen

en: `rand` - Simply returns the next value in the random stream
de: `rand` - Gibt einfach den nächsten Wert des Zufallsparameter zurück

en: `rrand` - Returns a random value within a range
de: `rrand` - Gibt einen Zufallswert innerhalb eines Bereichs zurück

en: `rrand_i` - Returns a random whole number within a range
de: `rrand_i` - Gibt eine zufällige ganze Zahl innerhalb eines Bereichs zurück

en: `one_in` - Returns true or false with the given probability
de: `one_in` - Gibt wahr oder falsch mit der angegebenen Wahrscheinlichkeit zurück

en: `dice` - Imitates rolling a dice and returns a value between 1 and 6
de: `dice` - Imitiert den Wurf eines Würfels und gibt einen Wert zwischen 1 und 6 zurück

en: `choose` - Chooses a random value from a list
de: `choose` - Wählt einen zufälligen Wert aus einer Liste aus

en: A.10 Control
de: A.10 Steuerung

en: A Basic Sound
de: Ein Grundton

en: Let's create a nice simple sound. Fire up Sonic Pi and in a fresh buffer type the following:
de: Lass uns einen schönen einfachen Sound erzeugen. Starte Sonic Pi und gib in einen neuen Puffer Folgendes ein:

en: Modulatable Options
de: Modulierbare Optionen

en: Default: 0
de: Standard: 0

en: Must be zero or greater
de: Muss null oder größer sein

en: Can not be changed once set
de: Kann nicht mehr geändert werden, wenn einmal festgelegt

en: Scaled with current BPM value
de: Mit dem aktuellen BPM-Wert skaliert

en: Multiple Changes
de: Mehrere Änderungen

en: Copy the code into a spare buffer and take a listen. Don't stop there though - play around with the code. Change the slide times, change the notes, the synth, the FX and the sleep times and see if you can turn it into something completely different!
de: Kopiere den Code in einen freien Puffer und höre zu. Hör an dieser Stelle nicht auf – spiel mit dem Code herum. Ändere die Wechselzeiten, ändere die Noten, den Synth, die FX und die Pausenzeiten, und probier, etwas ganz Anderes daraus zu machen!

en: Let's have a play - to advance the beat we just need to call `tick`. Open up a fresh buffer, type in the following and hit Run:
de: Lass uns spielen – um den Beat zu erweitern, müssen wir nur `tick`aufrufen. Öffne einen neuen Puffer, gib Folgendes ein und drücke Run:

en: These concepts can all be found in the following code:
de: Diese Konzepte findest du alle in dem folgenden Code:

en: Multiple Simultaneous Beats
de: Mehrere gleichzeitige Beats

en: Sound as Data
de: Ton als Daten

en: Probability
de: Wahrscheinlichkeit

en: Random Beats
de: Zufällige Beats

en: Changing Probabilities
de: Wahrscheinlichkeiten ändern

en: Those of you that have played role play games will be familiar with lots of strangely shaped dice with different ranges. For example there is the tetrahedron shaped dice which has 4 sides and even a 20 sided dice in the shape of a icosahedron. The number of sides on the dice changes the chance, or probability of rolling a 1. The fewer sides, the more likely you are to roll a 1 and the more sides the less likely. For example, with a 4 sided dice, there's a one in 4 chance of rolling a 1 and with a 20 sided dice there's a one in 20 chance. Luckily, Sonic Pi has the handy `one_in` fn for describing exactly this. Let's play:
de: Diejenigen unter euch die schon einmal Rollenspiele gespielt haben, werden mit einer Menge seltsam geformter Würfel verschiedener Zahlenbereiche vertraut sein. Es gibt zum Beispiel den tetraederförmigen Würfel, der 4 Seiten hat und sogar einen 20-seitigen Würfel in der Form eines Ikosaeder. Die Anzahl der Seiten eines Würfels ändert die Chancen, oder die Wahrscheinlichkeit eine 1 zu würfeln. Je weniger Seiten, desto größer sind deine Chancen eine 1 zu würfeln, und je mehr Seiten, desto geringer. Zum Beispiel beträgt die Wahrscheinlichkeit eine 1 zu würfeln bei einem 4-seitigen Würfel 1 zu 4, und bei einem 20-seitigen Würfel beträgt sie 1 zu 20. Glücklicherweise verfügt Sonic Pi über die praktische `one_in`-Funktion, um genau dies zu beschreiben. Lass uns spielen:

en: Combining Probabilities
de: Wahrscheinlichkeiten kombinieren

en: Repeatable Rhythms
de: Wiederholbare Rhythmen

en: A.14 Amplitude Modulation
de: A.14 Amplitudenmodulation

en: Amplitude Modulation
de: Amplitudenmodulation

en: ![Phase Durations](../../../etc/doc/images/tutorial/articles/A.14-amplitude-modulation/slicer_phase_durations.png)
de: ![Dauer](../../../etc/doc/images/tutorial/articles/A.14-amplitude-modulation/slicer_phase_durations.png)

en: Probabilities
de: Wahrscheinlichkeiten

en: Changing tempo
de: Tempo ändern

en: When performing, it's often useful to keep a buffer free for working with the mixer like this.
de: Bei der Ausführung ist es oft hilfreich, einen Puffer frei zu halten, um, wie jetzt, mit dem Mixer zu arbeiten.

en: 5. Practice
de: 5. Übung

en: Practice regularly
de: Übe regelmäßig

en: Experiment Musically
de: Experimentiere musikalisch

en: Hear the Code
de: Höre den Code

en: Many musicians can look at a musical score and hear the music in their head without having to play it. This is a very useful skill and it's well worth incorporating into your live coding practice sessions. The important point is to be able to have some understanding of what the code is going to sound like. You don't need to be able to hear it exactly in your head, but instead it's useful to know if the code is going to be fast, slow, loud, rhythmic, melodic, random, etc. The final goal is then to be able to reverse this process - to be able to hear music in your head and know what code to write to make it. It may take you a long time to master this, but once you do, you'll be able to improvise on stage and express your ideas fluently.
de: Viele Musiker können auf ein Notenblatt schauen und die Musik in ihrem Kopf hören, ohne das sie gespielt wird. Das ist eine sehr nützliche Fähigkeit und es lohnt sich auch diese auf deine Live-Coding Übungen zu übertragen: Der wichtige Punkt ist, dass Du eine gewisse Vorstellungen darüber entwickelst, wie sich Dein Code anhören wird. Du musst es natürlich nicht genau in deinem Kopf hören können, aber es ist praktisch, ein Gefühl dafür zu haben, ob sich der Code schnell oder langsam, laut, rhythmisch, melodisch, zufällig usw. anhören wird. Das endgültige Ziel ist dann, diesen Prozess umkehren zu können und zu Musik, die Du dir in deinem Kopf vorstellst, den passenden Code schreiben zu können. Bis dahin wirst du wahrscheinlich sehr viel üben müssen, aber wenn du es dann kannst, wirst du es schaffen auf der Bühne improvisieren zu können und deine Ideen fließend umzusetzen.

en: Slowing Samples Down
de: Sample verlangsamen

en: sample :guit_em9, rate: 1
de: Sample :guit_em9, rate: 1

en: Notice that this has two effects on the audio. Firstly the sample sounds lower in pitch and secondly it takes twice as long to play back (see the sidebar for an explanation of why this is the case). We can even choose lower and lower rates moving towards `0`, so a `rate:` of `0.25` is a quarter speed, `0.1` is a tenth of the speed, etc. Try playing with some low rates and see if you can turn the sound into a low rumble.
de: Dies hat zwei Auswirkungen auf den Ton. Das Sample hört sich tiefer an und es dauert doppelt so lange es abzuspielen (eine Erklärung hierfür findest du in der Seitenleiste). Wir können den Wert von `rate` immer kleiner machen, indem wir uns `0` annähern. Eine Rate von `0.25` bedeutet ein Viertel der Geschwindigkeit, eine Rate von `0.1` ein Zehntel, usw. Spiele mit niedrige Raten herum und schaue, ob du es schaffst ein tiefes Murren zu erzeugen.

en: Speeding Samples Up
de: Sample beschleunigen

en: Now, let's speed it up a little:
de: Lassen wir es etwas schneller werden:

en: Reverse Gear
de: Rückwärtsgang

en: Now, play it backwards:
de: Jetzt lass es uns rückwärts abspielen:

en: Detuning
de: Verstimmung

en: Amplitude shaping
de: Amplitudenmodellierung

en: In education, magical meaningful experiences with computers and programming languages have been explored since the late '60s. Computer education pioneers Seymour Papert, Marvin Minsky and Cynthia Solomon explored simple Lisp-based languages that moved pens over large pieces of paper. With just a few simple commands it was possible to program the computer to draw any picture. They even experimented by extending their Logo language from drawing to music. Papert wrote about learning through experiencing the reconstruction of knowledge rather than its transmission. Getting people to play with things directly was an important part of his group's work.
de: In der Wissenschaft werden seit den späten 60er Jahren magische, bedeutungsvolle Erfahrungen mit Computern und Programmiersprachen erforscht. Die Pioniere des Computerunterrichts Seymour Papert, Marvin Minsky und Cynthia Solomon erforschten einfache Lisp-basierte Sprachen, die Stifte über große Papierstücke bewegten. Mit nur wenigen einfachen Befehlen war es möglich, den Computer so zu programmieren, dass er jedes beliebige Bild zeichnete. Sie experimentierten sogar damit, ihre Logo-Sprache vom Zeichnen auf Musik auszuweiten. Papert schrieb über das Lernen durch die Erfahrung der Rekonstruktion von Wissen und nicht durch dessen Vermittlung. Die Menschen dazu zu bringen, direkt mit den Dingen zu experimentieren, war ein wichtiger Teil der Arbeit seiner Gruppe.

en: ![Jylda Live Coding in the Sage Gateshead](../../../etc/doc/images/tutorial/articles/A.20-creative-coding-in-the-classroom/jylda-small.png) Jylda and Sam Aaron perform at the Thinking Digital Conference in the Sage Gateshead. Photo credit: TyneSight Photos.
de: ![Jylda Live Coding in the Sage Gateshead](../../../etc/doc/images/tutorial/articles/A.20-creative-coding-in-the-classroom/jylda-small.png) Jylda und Sam Aaron treten auf der Thinking Digital Conference im Sage Gateshead auf. Foto: TyneSight Photos.

en: Getting started is as simple as:
de: Der Einstieg ist ganz einfach:

en: live_loop :jungle do
     sample :loop_amen, onset: pick
     sleep 0.125
    end
de: live_loop :jungle do 
     sample :loop_amen, onset: pick
     sleep 0.125
    end

en: In this example we introduce a basic loop called :jungle which picks a random drum hit from our audio sample, waits for an eighth of a second and then picks another drum hit. This results in an endless stream of random drum beats to dance to whilst you experience what a loop is.
de: In diesem Beispiel führen wir eine einfache Schleife mit dem Namen `:jungle` ein, die einen zufälligen Trommelschlag aus unserem Audio Sample auswählt, eine achtel Sekunde wartet und dann einen weiteren Trommelschlag abspielt. Das Ergebnis ist eine endlose Folge von Trommelschlägen zum dabei Tanzen, während Du erfährst, was eine Schleife ist.

en: Essential Knowledge
de: Unentbehrliche Kenntnisse

en: This section will cover some very useful - in fact *essential* - knowledge for getting the most out of your Sonic Pi experience.
de: In diesem Kapitel findest Du sehr nützliches - nein, *unentbehrliches* - Wissen, um das Bestmögliche aus Sonic Pi herauszuholen.

en: We'll cover how to take advantage of the many keyboard shortcuts available to you, how to share your work and some tips on performing with Sonic Pi.
de: Wir behandeln viele der verfügbaren Tastaturkürzel, zeigen, wie Du Deine Ergebnisse mit anderen teilen kannst, und geben Dir Tipps für Auftritte mit Sonic Pi.

en: Using Shortcuts
de: Tastaturkürzel

en: Sonic Pi is as much an instrument as a coding environment. Shortcuts can therefore make playing Sonic Pi much more *efficient and natural* - especially when you're playing live in front of an audience.
de: Sonic Pi ist zu gleichen Teilen Musikinstrument und Programmierumgebung. Mit Tastaturkürzeln kannst Du Sonic Pi viel *effizienter und natürlicher* spielen - insbesondere, wenn Du live vor Publikum spielst.

en: Much of Sonic Pi can be controlled through the keyboard. As you gain more familiarity working and performing with Sonic Pi, you'll likely start using the shortcuts more and more. *I personally touch-type* (I recommend you consider learning too) and find myself frustrated whenever I need to reach for the mouse as it slows me down. I therefore use all of these shortcuts on a very regular basis!
de: Sehr vieles in Sonic Pi kann mit der Tastatur gesteuert werden. Je vertrauter Du mit Sonic Pi wirst, umso mehr wirst Du diese Tastaturkürzel verwenden. *Ich selbst tippe, ohne die Tastatur anzusehen* (und kann Dir nur empfehlen, das Zehnfingersystem auch zu lernen). Und ich bin jedes Mal frustriert, wenn ich zur Maus greifen muss, denn das macht mich langsam. Deshalb benutze ich ständig Tastaturkürzel!

en: Therefore, if you learn the shortcuts, you'll learn to use your keyboard effectively and you'll be live coding like a pro in no time.
de: Wer die Tastaturkürzel beherrscht, kann auch seine Tastatur viel effektiver benutzen und in kürzester Zeit wirst Du programmieren wie ein Profi.

en: However, *don't try and learn them all at once*, just try and remember the ones you use most and then keep adding more to your practice.
de: *Versuche aber nicht, alle auf einmal zu lernen*, merke dir erst einmal die, welche du am häufigsten brauchst und füge später weitere deinem Repertoire hinzu.

en: Consistency across Platforms
de: Konsistenz auf verschiedenen Plattformen

en: Imagine you're learning the clarinet. You'd expect all clarinets of all makes to have similar controls and fingerings. If they didn't, you'd have a tough time switching between different clarinets and you'd be stuck to using just one make.
de: Stell Dir vor, Du lernst Klarinette. Du kannst davon ausgehen, dass alle Klarinetten aller Marken gleiche Mechaniken und Fingersätze haben. Hätten sie das nicht, könntest Du nicht ohne weiteres zwischen verschiedenen Klarinetten hin- und her wechseln. Sondern müsstest immer bei einer Marke bleiben.

en: Unfortunately the three major operating systems (Linux, Mac OS X and Windows) come with their own standard defaults for actions such as cut and paste etc. Sonic Pi will try and honour these standards. However *priority is placed on consistency across platforms* within Sonic Pi rather than attempting to conform to a given platform's standards. This means that when you learn the shortcuts whilst playing with Sonic Pi on your Raspberry Pi, you can move to the Mac or PC and feel right at home.
de: Unglücklicherweise haben die drei wesentlichen Betriebssysteme (Linux, Mac OS X und Windows) alle ihre eigenen typischen Tastaturkürzel für Aktionen wie z.B. Kopieren, Ausschneiden und Einfügen. Sonic Pi nutzt diese Standards wo immer möglich. Jedoch *liegt die Priorität auf plattformübergreifender Konsistenz* innerhalb von Sonic Pi, nicht auf dem Versuch, die Standards der jeweiligen Plattform vollumfänglich zu erfüllen. Das bedeutet, dass die in Sonic Pi auf dem Raspberry Pi gelernten Tastaturkürzel ebenso auf einem Mac oder PC mit Sonic Pi funktionieren.

en: Control and Meta
de: Control und Meta

en: Part of the notion of consistency is the naming of shortcuts. In Sonic Pi we use the names *Control* and *Meta* to refer to the two main combination keys. On all platforms *Control* is the same. However, on Linux and Windows, *Meta* is actually the *Alt* key while on Mac *Meta* is the *Command* key. For consistency we'll use the term *Meta* - just remember to map that to the appropriate key on your operating system.
de: Für diese Konsistenz müssen wir auch die Namen der Tastaturkürzel entsprechend auswählen. In Sonic Pi verwenden wir die Namen *Control* und *Meta* für die beiden wichtigsten Kombinationstasten. *Control* (*Ctrl* - oder *Strg* für "Steuerung" auf deutschen Tastaturen) ist auf allen Plattformen gleich. Auf Linux und Windows ist *Meta* die *Alt*-Taste, während *Meta* auf dem Mac die *Command*-Taste ist. Um konsistent zu bleiben, nutzen wir den Begriff *Meta* - diesem musst Du mental die passende Taste Deines Betriebssystems zuordnen.

en: Abbreviations
de: Abkürzungen

en: To help keep things simple and readable, we'll use the abbreviations *C-* for *Control* plus another key and *M-* for *Meta* plus another key. For example, if a shortcut requires you to hold down both *Meta* and *r* we'll write that as `M-r`. The *-* just means "at the same time as."
de: Um die Dinge einfach und lesbar zu halten, werden wir die Abkürzungen *C-* für *Control* und eine weitere Taste sowie *M-* für *Meta* und eine weitere Taste verwenden. Wenn ein Tastaturkürzel beispielsweise erfordert, dass Du *Meta* und *r* gleichzeitig drückst, werden wir die Abkürzung `M-r` verwenden. Der Bindestrich in der Mitte (*-*) bedeutet nur "zur gleichen Zeit."

en: The following are some of the shortcuts I find most useful.
de: Hier sind ein paar der Tastaturkürzel, die ich am nützlichsten finde.

en: Stopping and starting
de: Starten und Stoppen

en: Instead of always reaching for the mouse to run your code, you can simply press `M-r`. Similarly, to stop running code you can press `M-s`.
de: Du musst nicht immer zur Maus greifen, um Deinen Code auszuführen. Drücke stattdessen einfach `M-r` zum Abspielen. Mit `M-s` stoppst Du die Musik.

en: I'm really lost without the navigation shortcuts. I therefore highly recommend you spend the time to learn them. These shortcuts also work extremely well when you've learned to touch type as they use the standard letters rather than requiring you to move your hand to the mouse or the arrow keys on your keyboard.
de: Ohne die Tastenkürzel zur Navigation bin ich verloren. Deshalb empfehle ich Dir dringend, diese Kürzel zu lernen. Sie funktionieren besonders gut, wenn Du das Zehnfingersystem schon halbwegs beherrschst, da sie normale Buchstaben verwenden - so musst Du Deine Hand nicht zur Maus oder zu den Pfeiltasten bewegen.

en: You can move to the beginning of the line with `C-a`, the end of the line with `C-e`, up a line with `C-p`, down a line with `C-n`, forward a character with `C-f`, and back a character with `C-b`. You can even delete all the characters from the cursor to the end of the line with `C-k`.
de: Mit `C-a` springst Du an den Anfang, mit `C-e` ans Ende einer Zeile. Eine Zeile nach oben geht es mit `C-p`, eine nach unten mit `C-n`, ein Zeichen vorwärts mit `C-f` und eines nach hinten mit `C-b`. Du kannst auch alle Zeichen von der aktuellen Cursorposition bis zum Ende der Zeile mit `C-k` löschen.

en: Tidy Code
de: Code aufräumen

en: To auto-align your code simply press `M-m`.
de: Um Deinen Code sauber einzurücken, drücke `M-m`.

en: Help System
de: Hilfesystem

en: To toggle the help system you can press `M-i`. However, a much more useful shortcut to know is `C-i` which will look up the word underneath the cursor and display the docs if it finds anything. Instant help!
de: Zum Hilfesystem kommst Du mit `M-i`. Noch hilfreicher ist allerdings `C-i`, damit wird Dir für das Wort, auf dem der Cursor gerade steht, sofort die passende Stelle in der Dokumentation gezeigt. Sofortige Hilfe!

en: Shortcut Cheatsheet
de: Cheatsheet für Tastaturkürzel

en: Conventions
de: Konventionen

en: In this list, we use the following conventions (where *Meta* is one of *Alt* on Windows/Linux or *Cmd* on Mac):
de: Wir verwenden die folgenden Konventionen (*Meta* ist *Alt* auf Windows und Linux und *Cmd* auf dem Mac wie in 10.1 beschrieben):

en: `C-a` means hold the *Control* key then press the *a* key whilst holding them both at the same time, then releasing.
de: `C-a` bedeutet, die *Control* (*Strg* auf deutschen Tastaturen) zu drücken und zu halten, dabei *a* zu drücken und danach beide Tasten wieder los zu lassen.

en: `M-r` means hold the *Meta* key and then press the *r* key whilst holding them both at the same time, then releasing.
de: `M-r` bedeutet, *Meta* zu drücken und zu halten, dabei die *r*-Taste zu drücken und danach beide wieder los zu lassen.

en: `S-M-z` means hold the *Shift* key, then the *Meta* key, then finally the *z* key all at the same time, then releasing.
de: `S-M-z` bedeutet, die *Meta*-Taste zu drücken und zu halten, dann *Shift* zu drücken und zu halten und schließlich die *z*-Taste und alle drei Tasten gleichzeitig wieder los zu lassen.

en: `C-M-f` means hold the *Control* key, then press *Meta* key, finally the *f* key all at the same time, then releasing.
de: `C-M-f` bedeutet, *Control* zu drücken und zu halten, dann *Meta* zu drücken und zu halten, dann *f* zu drücken und alle drei Tasten gleichzeitig wieder los zu lassen.

en: Main Application Manipulation
de: Steuerung der Hauptanwendung

en: `M-r` - Run code
de: `M-r` - Code ausführen

en: `M-s` - Stop code
de: `M-s` - Code-Ausführung stoppen

en: `M-i` - Toggle Help System
de: `M-i` - Hilfesystem ein-/ausschalten

en: `M-p` - Toggle Preferences
de: `M-p` - Einstellungen ein-/ausschalten

en: `M-{` - Switch buffer to the left
de: `M-<` - Zum Puffer links wechseln

en: `M-}` - Switch buffer to the right
de: `M->` - Zum Puffer rechts wechseln

en: `M-+` - Increase text size of current buffer
de: `M-+` - Schrift des Puffers vergrößern

en: `M--` - Decrease text size of current buffer
de: `M--` - Schrift des Puffers verkleinern

en: Selection/Copy/Paste
de: Auswahl/Kopieren/Einfügen

en: `M-a` - Select all
de: `M-a` - Alles auswählen

en: `M-c` - Copy selection to paste buffer
de: `M-c` - Auswahl in den Zwischenspeicher kopieren

en: `M-]` - Copy selection to paste buffer
de: `M-]` - Auswahl in den Zwischenspeicher kopieren

en: `M-x` - Cut selection to paste buffer
de: `M-x` - Auswahl ausschneiden und im Zwischenspeicher ablegen

en: `C-]` - Cut selection to paste buffer
de: `C-]` - Auswahl ausschneiden und im Zwischenspeicher ablegen

en: `C-k` - Cut to the end of the line
de: `C-k` - Text ab Cursor bis zum Ende der Zeile ausschneiden

en: `M-v` - Paste from paste buffer to editor
de: `M-v` - Inhalt des Zwischenspeichers in den Editor kopieren

en: `C-y` - Paste from paste buffer to editor
de: `C-y` - Inhalt des Zwischenspeichers in den Editor kopieren

en: `C-SPACE` - Set mark. Navigation will now manipulate highlighted region. Use `C-g` to escape.
de: `C-SPACE` - Markierung setzen. Textauswahl ab jetzt von hier bis zum Cursor. `C-g` löscht die Markierung.

en: Text Manipulation
de: Text-Manipulation

en: `M-m` - Align all text
de: `M-m` - Gesamten Code ausrichten

en: `Tab` - Align current line or selection (or select autocompletion)
de: `Tab` - Aktuelle Codezeile oder Auswahl ausrichten

en: `C-l` - Centre editor
de: `C-l` - Editor zentrieren

en: `M-/` - Comment/Uncomment current line or selection
de: `M-/` - Aktuelle Codezeile auskommentieren

en: `C-t` - Transpose/swap characters
de: `C-t` - Zeichen vertauschen

en: `M-u` - Convert next word (or selection) to upper case.
de: `M-u` - Das nächste Wort oder Auswahl in Großbuchstaben wandeln.

en: `M-l` - Convert next word (or selection) to lower case.
de: `M-l` - Das nächste Wort oder Auswahl in Kleinbuchstaben wandeln.

en: `C-a` - Move to beginning of line
de: `C-a` - An den Anfang der Zeile springen

en: `C-e` - Move to end of line
de: `C-e` - Ans Ende der Zeile springen

en: `C-p` - Move to previous line
de: `C-p` - Zur vorherigen Zeile springen

en: `C-n` - Move to next line
de: `C-n` - Zur nächsten Zeile springen

en: `C-f` - Move forward one character
de: `C-f` - Ein Zeichen vorwärts

en: `C-b` - Move backward one character
de: `C-b` - Ein Zeichen zurück

en: `M-f` - Move forward one word
de: `M-f` - Ein Wort nach vorne

en: `M-b` - Move backward one word
de: `M-b` - Ein Wort zurück

en: `C-M-n` - Move line or selection down
de: `C-M-n` - Zeile oder Auswahl nach unten schieben

en: `C-M-p` - Move line or selection up
de: `C-M-p` - Zeile oder Auswahl nach unten schieben

en: `S-M-u` - Move up 10 lines
de: `S-M-u` - 10 Zeilen nach oben springen

en: `S-M-d` - Move down 10 lines
de: `S-M-d` - 10 Zeilen nach unten springen

en: `M-<` - Move to beginning of buffer
de: `M-<` - Zum Anfang des Puffers gehen

en: `M->` - Move to end of buffer
de: `M->` - Zum Ende des Puffers gehen

en: Deletion
de: Löschen

en: `C-h` - Delete previous character
de: `C-h` - Vorangegangenes Zeichen löschen

en: `C-d` - Delete next character
de: `C-d` - Nächstes Zeichen löschen

en: Advanced Editor Features
de: Fortgeschrittene Funktionen des Editors

en: `C-i` - Show docs for word under cursor
de: `C-i` - Dokumentation für das Wort unter dem Cursor anzeigen

en: `M-z` - Undo
de: `M-z` - Rückgängig ("Undo")

en: `S-M-z` - Redo
de: `S-M-z` - Wiederholen ("Redo")

en: `S-M-f` - Toggle fullscreen mode
de: `S-M-f` - Vollbildmodus ein-/ausschalten

en: `S-M-b` - Toggle visibility of buttons
de: `S-M-b` - Buttons ein-/ausschalten

en: `S-M-l` - Toggle visibility of log
de: `S-M-l` - Anzeige Protokoll-Fenster ein-/aus

en: `S-M-m` - Toggle between light/dark modes
de: `S-M-m` - Dunkle Benutzeroberfläche ein-/ausschalten

en: `S-M-s` - Save contents of buffer to a file
de: `S-M-s` - Inhalt des Puffers in Datei speichern

en: `S-M-o` - Load contents of buffer from a file
de: `S-M-o` - Datei in einen Puffer laden

en: Sharing
de: Teilen

en: Sonic Pi is all about sharing and learning with each other.
de: In Sonic Pi geht es vor allen Dingen um das Teilen und gemeinsame Lernen.

en: Once you've learned how to code music, sharing your compositions is as simple as sending an email containing your code. Please do *share* your code with others so they can *learn* from your work and even use parts in a new *mash-up*.
de: Sobald Du gelernt hast, Musik zu programmieren, kannst Du Deine Kompositionen ganz leicht mit anderen teilen: Schicke Deinen Code einfach mit einer E-Mail an Deine Freunde. Ich möchte Dich ermuntern, Deinen Code mit anderen zu *teilen*, so dass sie von Deiner Arbeit *lernen* und Teile davon in neuen *Mash-Ups* verwenden können.

en: If you're unsure of the best way to share your work with others I recommend putting your code on [GitHub](https://github.com) and your music on [SoundCloud](https://soundcloud.com). That way you'll be able to easily reach a large audience.
de: Du hast keine Ahnung, wo Du Deine Werke am besten mit anderen teilen kannst? Ich empfehle Dir für Deinen Code [GitHub](https://github.com) und für Deine Musik [SoundCloud](https://soundcloud.com). So erreichst Du schnell ein großes Publikum.

en: [GitHub](https://github.com) is a site for sharing and working with code. It's used by professional developers as well as artists for sharing and collaborating with code. The simplest way to share a new piece of code (or even an unfinished piece) is to create a [Gist](https://gist.github.com). A [Gist](https://gist.github.com) is a simple way of uploading your code in a simple way that others can see, copy and share.
de: [GitHub](https://github.com) wird von professionellen Entwicklern und auch Künstlern verwendet, um Code zu teilen und zusammenzuarbeiten. Auf GitHub gibt es einen eigenen Bereich namens [Gist](https://gist.github.com), damit kann man besonders einfach ein neues Stück Code (egal ob fertig oder nicht) veröffentlichen. Mit einem [Gist](https://gist.github.com) können dann auch andere Deinen Code übernehmen, kommentieren und verbessern.

en: Another important way of sharing your work is to record the audio and upload it to [SoundCloud](https://soundcloud.com). Once you've uploaded your piece, other users can comment and discuss your work. I also recommend placing a link to a [Gist](https://gist.github.com) of your code in the track description.
de: Statt Code kannst Du auch eine Musikaufnahme veröffentlichen und dafür eine Audiodatei zu [SoundCloud](https://soundcloud.com) hochladen. Dort können andere Nutzer Kommentare dazu abgeben und die Musik diskutieren. Es ist empfehlenswert, bei einer Veröffentlichung auf Soundcloud zusätzlich einen Link zu einem [Gist](https://gist.github.com) mit Deinen Code in die Beschreibung aufzunehmen.

en: To record your work, hit the `Rec` button in the toolbar, and recording starts immediately. Hit `Run` to start your code if it isn't already in progress. When you're done recording, press the flashing `Rec` button again, and you'll be prompted to enter a filename. The recording will be saved as a WAV file, which can be edited and converted to MP3 by any number of free programs (try Audacity for instance).
de: Um Dein Stück aufzunehmen, drücke den `Aufnehmen`-Knopf in der Werkzeugleiste, die Aufnahme startet dann sofort. Drücke `Ausführen`, um Deinen Code zu starten, wenn er nicht bereits läuft. Wenn Du fertig bist, drücke den blinkenden `Aufnehmen`-Knopf erneut. Du wirst dann nach einem Dateinamen gefragt, unter dem die Aufnahme als WAV-Datei gespeichert wird. Es gibt viele Werkzeuge, um eine WAV-Datei in ein MP3 zu wandeln, z.B. das Programm *Audacity*.

en: Hope
de: Hoffnung

en: I encourage you to share your work and really hope that we'll all teach each other new tricks and moves with Sonic Pi. I'm really excited by what you'll have to show me.
de: Ich möchte Dich ermuntern, Deine Arbeiten zu teilen, und hoffe sehr, dass wir uns gegenseitig neue Sonic-Pi-Tipps und -Tricks beibringen werden. Ich bin schon sehr gespannt darauf, was Du mir zeigen wirst.

en: Performing
de: Auftritte

en: One of the most exciting aspects of Sonic Pi is that it enables you to use code as a *musical instrument*. This means that writing code live can now be seen as a new way of performing music.
de: Einer der aufregendsten Aspekte von Sonic Pi ist, dass Du von nun an Code als *Musikinstrument* verwenden kannst. Vor Publikum zu programmieren wird damit ein neuer Weg, um Musik aufzuführen.

en: We call this *Live Coding*.
de: Das nennen wir *Live-Coding*.

en: Show Your Screen
de: Zeig Deinen Bildschirm

en: When you live code I recommend you *show your screen* to your audience. Otherwise it's like playing a guitar but hiding your fingers and the strings. When I practice at home I use a Raspberry Pi and a little mini projector on my living room wall. You could use your TV or one of your school/work projectors to give a show. Try it, it's a lot of fun.
de: Wenn Du live programmierst, empfehle ich Dir, Deinem Publikum Deinen *Bildschirm zu zeigen*. Beim Gitarrespielen versteckst Du ja auch nicht Deine Finger und die Saiten Deines Instruments. Wenn ich zu Hause übe, verwende ich einen Raspberry Pi und projiziere den Bildschirm mit einem kleinen Beamer an meine Wohnzimmerwand. Du könntest auch Deinen Fernseher oder einen Projektor in der Schule/Arbeit verwenden und eine kleine Show geben. Versuch es, das macht eine Menge Spaß.

en: Form a Band
de: Gründe eine Band

en: Live coding isn't completely new - a small number of people have been doing it for a few years now, typically using bespoke systems they've built for themselves. A great place to go and find out more about other live coders and systems is [TOPLAP](http://toplap.org).
de: Live-Coding ist nicht wirklich neu - eine kleine Gruppe von Enthusiasten macht das schon seit Jahren, typischerweise mit selbstgebauten, individuellen Systemen. Bei [TOPLAP](http://toplap.org) erfährst Du mehr über diese anderen Live-Coder und ihre Geräte.

en: Another great resource for exploring the live coding world is [Algorave](http://algorave.com). Here you can find all about a specific strand of live coding for making music in nightclubs.
de: Einige Live-Coder spielen auch in Nightclubs. Mehr über dieses spezielle Genre erfährst Du auf [Algorave](http://algorave.com).
