Sonic Pi - en to de translation catalogue (1219 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 crazy 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 gespannt darauf, zu lernen, wie man mit Sonic Pi verrückte Sounds machen kann, genauso wie ich gespannt darauf bin, Dir zu zeigen, wie es geht. Es wird ein *Riesenspaß* bei dem Du etwas über Musik, Synthese, Programmieren, Komposition, Aufführung und viele andere Dinge 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: Moment, wie unhöflich von mir! Ich sollte mich erst einmal vorstellen. Ich bin [Sam Aaron](http://twitter.com/samaaron) der Typ, der Sonic Pi gebaut hat. Du kannst mich unter [@samaaron](http://twitter.com/samaaron) auf Twitter finden. Schau doch mal vorbei. Vielleicht interessierst Du Dich auch für meine [Live Coding Performances](https://youtube.com/samaaron), wo ich den Sonic Pi Code für meine Musik 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: Bitte schreibe mir, wenn Du irgendwelche Vorschläge oder Ideen zur Verbesserung von Sonic Pi hast – Feedback ist sehr hilfreich. Man kann ja nie wissen, vielleicht ist Deine Idee das nächste große Feature!

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 Kapitel aufgeteilt, die nach Themen gruppiert sind. Auch wenn ich es so geschrieben habe, dass man damit von Anfang bis zum Ende einfach lernen kann, kannst Du an jeder Stelle einsteigen, ganz wie es Dir gefällt. Wenn Du etwas im Tutorial vermisst, lass es mich wissen, und ich überlege, 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: Besonders gut lernt man Live-Coding, wenn man anderen dabei zuschaut. Ich streame meine Musik regelmäßig auf [http://youtube.com/samaaron](http://youtube.com/samaaron). Schau gerne mal vorbei, sag Hallo und frag mich dort ein wenig aus. :-)

en: OK, let's get started...
de: Ok, dann 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: Mit Sonic Pi kannst Du etwas sehr aufregendes tun: Du kannst Musik aus Code live schreiben und *verändern, während sie spielt*. Fast so wie mit einer Gitarre. Mit anderen Worten: Du kannst Sonic Pi mit auf die Bühne nehmen und jammen.

en: Free your mind
de: Mach mal kurz 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: Wir werden in diesem Tutorial in die Details von Sonic Pi eintauchen. Jetzt möchte ich Dir aber erst einmal zeigen, wie das ist, live Musik zu programmieren. Keine Sorge, Du wirst vielleicht nicht sofort alles verstehen. Aber das macht nichts. Genieße kurz diesen Einblick.

en: A live loop
de: Eine Live-Loop

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 drücke den `Ausführen`-Button und Du wirst eine schöne Bass-Drum hören, die schnell vor sich hin hämmert. Mit einem Druck auf den `Stopp`-Button hört die Musik wieder auf. Aber drücke bitte noch nicht darauf ... sondern probiere die folgenden Veränderungen aus:

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

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

en: Press the `Run` button again
de: Drücke wieder den `Ausführen`-Button

en: Notice how the drum speed has changed.
de: Gemerkt? Die Geschwindigkeit der Bass-Drum hat sich verändert.

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: *Merke Dir diesen Moment.* Du hast mit Sonic Pi zum ersten Mal live Code geschrieben. Wahrscheinlich wird es nicht das letzte Mal sein …

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. Verändern wir also die Zutaten ein wenig. Vor `sample :bd_haus` kannst Du die Zeile `sample :ambi_choir, rate: 0.3` einfügen. Dein Code müsste 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, kleine oder negative Zahlen einträgst? Hast Du gemerkt, wie sich eine sehr kleine Änderung des `rate:`-Wertes für das `:ambi_choir`-Sample auswirkt (z. B. 0.29)? Was passiert bei einem wirklich kleinen `sleep`-Wert? Kannst Du eine Fehlermeldung Deines Computers auslösen, wenn Du den Wert immer kleiner werden lässt? (Wenn das geschieht, nimm einfach wieder einen größeren Wert für `sleep` und drücke auf `Ausführen`).

en: Try commenting one of the `sample` lines out by adding a `#` to the beginning:
de: Kommentiere eine Code-Zeile aus, 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: Siehst Du? Jetzt ignoriert der Computer diese Zeile und wir hören den Befehl nicht mehr. Was hinter einem `#` steht ist ein Kommentar. Wir können dieses Zeichen benutzen, um Code schnell zu entfernen und später wieder einzufü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: Zum Abschluss möchte ich Dir etwas zum Spielen geben. Nimm den Code unten und kopiere ihn in einen freien Puffer. Macht nix, Du musst noch nicht alles davon durchschauen, aber Du siehst, dass da zwei Loops sind – zwei Schleifen, die gleichzeitig laufen und sich endlos wiederholen. Jetzt tue, was Du am besten kannst: Experimentiere und spiele herum. Hier sind 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 höre zu, 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 Zeitwerte von `sleep` und beobachte, wie die beiden Schleifen in unterschiedlicher Weise aneinander vorbei laufen.

en: Try uncommenting the sample line (remove the `#`) and enjoy the sound of the guitar played backwards.
de: Hole die auskommentierte Sample-Zeile wieder hervor und genieße den Sound 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 von `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: Vergiss nicht, `Ausführen` zu drücken, dann hörst Du sofort beim nächsten Durchlauf der Loops Deine Änderungen. Wenn irgendwas schiefgeht – macht nichts! Drücke `Stopp`, lösche den kaputten Code und fang mit dem ursprünglichen Code noch einmal von vorn an. Denn am besten lernt man beim Fehlermachen …

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 also 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. Jetzt bist Du 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 zum 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: 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: Mit diesen pinkfarbenen Buttons kannst Du Klänge abspielen und stoppen. Der *Ausführen*-Button startet den Code im Editor, *Stopp* hält den ablaufenden Code an, *Speichern* schreibt den Code in eine Datei und *Aufnehmen* nimmt den gerade laufenden Sound (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 orangen Knöpfe erlauben es Dir, den Code-Editor zu manipulieren. Mit den *Size +* und *Size -* Knöpfen kannst du den Text vergrössern 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 Buttons bieten Dir den Zugriff auf Informationen, die Hilfe und die Voreinstellungen. Der *Info*-Button öffnet ein Fenster mit Informationen über Sonic Pi selbst und wo Du mehr Informationen und Hilfe von anderen findest. Der *Help*-Button zeigt/verbirgt das eingebaute Hilfesystem (*F*) und *Prefs* zeigt/verbirgt das Fenster, wo Du einige grundsätzliche Einstellungen regeln 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, komponierst Du Deine Musik und führst sie später auf. Es ist ein einfacher Texteditor, in dem Du Code eingibst und bearbeitest; so eine Art sehr einfache Textverarbeitung wie Word oder Google Docs. Der Editor färbt bestimmte Begriffe automatisch ein, je nachdem, welche Bedeutung sie innerhalb des Codes haben. Am Anfang ist das vielleicht ein wenig merkwürdig, aber Du wirst es bald nützlich finden. Zum Beispiel erkennst Du Zahlen sofort daran, dass sie blau eingefärbt 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: Du kannst verschiedene Einstellungen von Sonic Pi verändern, wenn Du den *Prefs*-Button drückst. Einige davon sind z.B.: Die Ausgabe von Mono-Ton, der Tausch der Stereokanäle, die Ausführlichkeit des Protokolls. Auf dem Raspberry Pi kannst Du hier auch noch die Lautstärke und den Ausgabekanal 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 Dein Code abläuft, 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 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: Das Hilfe-System im unteren Bereich des Programmfensters ist einer der wichtigsten Teile von Sonic Pi. Du kannst es ein- und ausblenden, wenn Du den blauen`Hilfe`-Button klickst. Es zeigt Hilfe und Informationen über alle Aspekte von Sonic Pi, einschließlich dieses Tutorials, einer Liste der mitgelieferten Synths, Samples, Beispiele, Effekte (Im Englischen wird der Begriff *Effekte* manchmal lautmalerisch mit *FX* ("ef-eks") abgekürzt; *FX* bezeichnet also die Klangeffekte in Sonic Pi.) sowie eine komplette Liste aller Funktionen, 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-Kurve. Du kannst auch den Unterschied zwischen lauten und leisen Tönen anhand der Größe der Linien erkennen. Es gibt drei Felder, mit denen Du spielen kannst. Standardmäßig ist es ein kombiniertes aus dem linken und rechten Kanal, es gibt ein Stereo-Oszilloskop das für jeden Kanal einen eigenen Bereich anzeigt. Zu guter Letzt gibt es die Lissajous-Figur, sie zeigt Dir die Phasen-Beziehung zwischen dem linken und rechten Kanal. Damit kann man schöne Bilder aus Klängen malen (https://de.wikipedia.org/wiki/Lissajous-Figur).

en: 1.3 Learning through Play
de: 1.3 Spielend lernen

en: Learning through Play
de: Spielend lernen

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: Mit Sonic Pi kannst Du etwas über Computer und Musik zu lernen - und zwar auf eine spielerische und experimentelle Weise. Das allerwichtigste ist, dass Du Spaß hast. Und bevor Du es überhaupt bemerkt hast, wirst Du zufällig gelernt haben, Code zu schreiben, zu komponieren und Musik aufzuführen.

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

en: Start Simple
de: Fang einfach an

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 man lernt, will man die tollen Sachen am liebsten *sofort* machen. Vergiss das nicht, aber sieh es als ein Ziel an, welches Du erst etwas *später* erreichen kannst. Denke lieber erst einmal an *einfachste* Sache, die Dir Spaß machen wird und die lohnend erscheint; diese Sache ist ein kleiner Schritt auf dem Weg zu dem faszinierenden Ding, das Dir im Kopf herum geht. Wenn Dir dieser einfache Schritt klar ist, versuche ihn umzusetzen, spiele damit herum und finde heraus, auf was für neue Ideen Du kommst. Du wirst bald viel Spaß haben und schnell Fortschritte machen.

en: Just make sure to share your work with others!
de: Und: Sorg dafür, dass Du Deine Werke mit anderen teilst!

en: OK, enough of the intros - let's get into some sound.
de: Ok, genug der Einführung - jetzt wollen wir 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 besprechen wir, wie man Synths ansteuert und manipuliert. Synth ist die Kurzform von Synthesizer - ein hochtrabendes Wort für ein Ding, das einen Klang erzeugt. Typischerweise sind Synths ziemlich kompliziert im Gebrauch, vor allem analoge Synths mit ihren vielen Kabeln und Modulen. Sonic Pi stellt Dir aber vieles davon auf eine einfache und gut zugängliche Art zur Verfügung.

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: Die Programmoberfläche von Sonic Pi mag simpel erscheinen, doch wenn Du willst, kannst Du damit sehr tief in ausgeklügelte Klangmanipulationen eintauchen. Also festhalten...

en: 2.1 Your First Beeps
de: 2.1 Deine ersten Klänge

en: Your First Beeps
de: Deine ersten Klänge

en: Take a look at the following code:
de: Sieh Dir mal 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 dem Ausführen-Button). Nun klicke auf Ausführen...

en: Intense. Press it again. And again. *And again...*
de: Stark. Klicke den Button nochmal. Und nochmal. *Und nochmal...*

en: Woah, crazy, 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, dass könntest Du den ganzen Tag lang machen. Aber halt, bevor Du Dich in einem endlosen Strom von Piepstönen verliert, 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, kleinere Zahlen machen tiefere Töne und größere Zahlen höhere Töne. Es ist wie bei einem Klavier, die Tasten weiter links erzeugen tiefere Töne als die 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 stellt sich heraus, 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 auf der Klaviatur zu spielen, musst du 1 zu 60 addieren, also `play 61` schreiben. Das wird dann ein Cis (oder C# in englischer Schreibweise) sein. Um ein D, den Ton noch eins weiter, zu spielen, musst du `play 62` schreiben.

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 zu Beginn auch so. Für den Anfang reicht es zu wissen: *Kleinere Zahlen bedeuten tiefere Klänge* und *größere 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: Wow! Wenn Du also mehrere `play`s hinschreibst, spielen sie alle zur selben Zeit. Versuche es selbst - welche Nummern klingen gut zusammen? Was klingt fürchterlich? Experimentiere, erforsche und erkunde selbst.

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 geht 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 mit `0.5`:

en: Notice how it plays faster. Now, try for yourself, change the times - use different times and notes.
de: Achte darauf, dass die Melodie nun schneller spielt. Probiere das 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`. (Warum `52.2` und nicht `52,3`? Im deutschsprachigen Raum schreibt man solche Zahlen normalerweise mit Komma, der Computer verwendet in seiner Programmiersprache aber die englische Schreibweise. Deshalb verwenden wir für Zahlen mit Nachkommastellen einen Punkt - also `52.3`.) Es gibt überhaupt keinen Grund, nur ganze Zahlen zu verwenden. Spiel damit herum und hab Spaß dabei.

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: Für die unter Euch, die das Notenschreiben schon ein bisschen 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. Beachte dabei nur, dass es die englische Namensgebung für Notennamen verwendet, dort heißt Fis "F sharp" oder auch "F#" und Fes "F flat" bzw. "Fb". Weiterhin heißt die Note H im englischen Sprachraum "B". 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, vor den Notennamen einen Doppelpunkt `:` zu stellen, sodass dieser sich Pink einfärbt. Die jeweilige Oktave kannst Du als Zahl dahinter schreiben:

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 die Note um einen Halbton verringern möchtest, füge ein `b` an, also `play :Eb3`.

en: Now go *crazy* and have fun making your own tunes.
de: Jetzt mach was *Verrücktes* und baue Deine eigenen Melodien.

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: Mit Sonic Pi kannst Du nicht nur Noten und Samples abspielen, Du kannst die Klänge mit Optionen gestalten und beeinflussen. Wir werden viele davon in diesem Tutorial behandeln, für jede Option gibt es ausführliche Informationen in der Hilfe. Zwei der nützlichsten sehen wir uns gleich mal an: *Amplitude* und *Pan*. Aber vorher lass mich 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 `play` oder `sample` übergeben werden; sie verändern und steuern die Art, wie sich die Klänge anhören. Jeder Synth hat seine eigenen Opts, um den Klang fein einzustellen. Es gibt auch Opts, die für viele Klänge gleich sind, z.B. `amp:` und Hüllkurven-Opts (die wir an anderer Stelle besprechen).

en: Opts have two major parts, their name (the name of the control) and their value (the value you want to set the control at). For example, you might have a opt called `cheese:` and want to set it with a value of `1`.
de: Opts bestehen aus zwei Teilen: Ihrem Namen (der Name des Reglers) und ihrem Wert (den Wert, auf den Du den Regler setzten möchtest). Zum Beispiel könntest Du eine Option mit dem Namen `cheese:` haben, der Du den Wert `1` geben möchtest.

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` mit einem Komma `,` übergeben, dem der Name der Opt folgt, etwa `amp:` (vergiss den Doppelpunkt `:` nicht), dann eine Leerstelle und schließlich der Wert der Opt. Zum Beispiel:

en: (Note that `cheese:` isn't a valid opt, we're just using it as an example).
de: (Die `cheese:`-Opt gibt es in Wirklichkeit gar nicht, 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 mit weiteren Kommata 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 dasselbe tun würde wie die vorherige:

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, lässt er einfach links liegen und ignoriert sie. (So wie `cheese` und `beans`, die ja wirklich lachhafte Namen für Optionen wären!)

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 lassen sich über Optionen steuern; nimm Dir ein bisschen Zeit zu lernen, wie Du sie einsetzen kannst, und Du bist startklar. Jetzt 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 die Weise, wie sich der Computer die Lautstärke eines Klangs vorstellt. Eine *hohe Amplitude ergibt einen lauteren Klang* und eine *niedrige Amplitude ergibt einen leiseren Klang*. So wie Sonic Pi Zahlen dazu benutzt, um Zeit und Töne darzustellen, bildet es auch die Lautstärke mit 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 sogenannten Kompressor ein, damit die Klänge nicht zu laut für Dein Ohr werden. Oft klingt das dann matschig und schräg. Verwende also lieber niedrigere Amplituden, das heißt zwischen 0 und 0.5, um die Kompression zu verhindern.

en: Amp it up
de: Amp verwenden

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. Mit 0.5 lässt Du zum Beispiel den Klang mit halber Amplitude spielen:

en: To play at double amplitude pass 2:
de: Und für die doppelte Amplitude:

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. Der Wert -1 schiebt den Klang ganz nach links, 0 steht für die Mitte und 1 lässt den Klang nur aus dem rechten Lautsprecher kommen. Natürlich kannst Du jeden Wert zwischen -1 und 1 verwenden, um Deine Klänge im Stereofeld zu positionieren.

en: Let's play a beep out of the left speaker:
de: Spiel einen Klang, der nur aus linken Lautsprecher kommt:

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 lass den Klang aus der Mitte herauskommen (die Standardposition):

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

en: 2.3 Switching Synths
de: 2.3 Synths wechseln

en: Switching Synths
de: Synths wechseln

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 bringt eine Palette an Instrumenten mit, die Synths heißen, eine Kurzform für Synthesizer (Klangerzeuger). Samples sind vorher aufgenommene Klänge; demgegenüber erzeugen Synths neue Klänge, je nachdem, wie Du sie anlegst (wie das geht, werden wir später sehen). Die Synths von Sonic Pi sind sehr wirkungsvoll und ausdrucksstark und man kann damit tolle Sachen machen. Als erstes lernen wir, wie man einen Synth auswählt, den man benutzen möchte.

en: Buzzy saws and prophets
de: Brilliante Sägen und Prophets

en: A fun sound is the *saw wave* - let's give it a try:
de: Einen spaßigen Sound ergibt 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 damit, beide Sounds zu verbinden? Zuerst nacheinander:

en: Now multiple sounds at the same time (by not sleeping between successive calls to `play`):
de: Jetzt machen wir mehrere Töne gleichzeitig, indem wir keine Pausen mit `sleep` zwischen Aufrufen von `play` einfügen:

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: Hast Du bemerkt, dass das `use_synth`-Kommando nur die nachfolgenden `play`-Kommandos beeinflusst? Stell Dir das als 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: 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: Spiel mal ein bisschen herum, indem Du *in Deinem Stück die Synths wechselst*. Kombiniere unterschiedliche Synths oder setze sie für unterschiedliche Stellen in Deinem Stück ein.

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

en: Duration with Envelopes
de: Dauer und 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: Wie wir schon vorher gesehen haben, können wir mit dem `sleep`-Kommando steuern, wann ein Klang zu spielen anfängt. Bislang konnten wir aber noch nicht die Dauer eines Klangs 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: Um die *Dauer von Klängen* auf einfache, aber tiefgehende Weise zu beeinflussen, bietet Sonic Pi das Prinzip der *ADSR-Hüllkurve*. (Der englische Begriff für *Hüllkurve* heißt *Envelope*, wir werden später sehen, was ADSR genau bedeutet). Eine Hüllkurve hat zwei praktische Eigenschaften:

en: control over the duration of a sound
de: Kontrolle über die Dauer eines Klangs

en: control over the amplitude of a sound
de: Kontrolle über die Amplitude (Lautstärke) eines Klangs

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 bestimmt, wie lange ein Klang klingt. Eine längere Dauer bedeutet, dass Du den Klang länger hören kannst. Alle Klänge in Sonic Pi haben eine Hüllkurve, die beeinflusst werden kann, und die gesamte Dauer dieser Hüllkurve bestimmt die Dauer des Klangs. Deshalb kann man über die Kontrolle der Hüllkurve die Dauer des Klangs beeinflussen.

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 kontrolliert nicht nur die Dauer, sondern ermöglicht Dir auch die *genaue Kontrolle über die Amplitude eines Klangs*. Alle Klänge beginnen und enden mit Stille; dazwischen ist irgendetwas hörbar. Hüllkurven erlauben Dir, die Amplitude der hörbaren Anteile des Klanges zu verschieben, zu verlängern und zu verkürzen. Es ist so, als würdest Du jemanden sagen, wie er die Lautstärke einer Musik lauter und leiser drehen soll. Du könntest denjenigen z.B. bitten: "Fang bitte mit einer Stille an, dreh dann die Lautstärke langsam bis zum Anschlag hoch, lass es eine Weile so und blende dann schnell runter, bis man nichts mehr hört". Genau dafür sind in Sonic Pi die Hüllkurven da.

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 vorher schon gesehen haben, bedeutet eine Amplitude von 0 Stille und eine Amplitude von 1 entspricht der normalen Lautstärke.

en: Now, let us look at each of the parts of the envelopes in turn.
de: Jetzt wollen wir uns alle Teile einer Hüllkurve einmal ansehen.

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: Wenn man Sonic Pi nichts anderes sagt, verwendet jeder Synth eine sehr einfache Hüllkurve mit einer Release-Zeit von 1. Solange dauert es, bis der Synth ausklingt - eine Schlagzeit (was beim BPM-Wert 60 genau 1 Sekunde entspricht):

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. Los, stopp die Zeit. :-) Es bedeutet das gleiche für diese etwas längere, ausführliche 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: Du hast gemerkt, dass dieser Ton genau gleich klang (der Klang war eine Sekunden lang zu hören). Aber jetzt kannst Du sehr einfach die Dauer über die `release:`-Opt verändern:

en: We can make the synth sound for a very short amount of time by using a very small release time:
de: Mit einer sehr kurzen Release-Zeit wird der Synth-Klang sehr kurz:

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 nennt sich *Release-Phase*. Normalerweise ist das ein lineares Ausklingen (also eine gerade Linie), wie das folgende Diagramm zeigt:

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: Deshalb kannst Du mit der Release-Zeit die Länge eines Klangs ändern. Spiele einmal mit unterschiedlichen Release-Zeiten herum.

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: Normalerweise ist die Attack-Phase für alle Synths 0, die Amplitude geht also sofort von 0 auf 1 hoch. Dies gibt dem Synth einen perkussiven Klang. Vielleicht möchtest Du den Klang jedoch einblenden. Dies kannst Du mit der `attack`-Opt erreichen. Blende einige Klänge ein:

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 selben Zeit anwenden. Zum Beispiel für eine kurze Attack- und eine lange Release-Zeit:

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

en: Of course, you may switch things around. Try a long attack and a short release:
de: Oder mal andersherum: Versuche einen langen Attack und einen kurzen Release:

en: Finally, you can also have both short attack and release times for shorter sounds.
de: Schließlich kannst Du auch einen kurzen Attack und Release für kürzere Klänge verwenden.

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 den Attack- und Release-Zeiten kannst Du auch die Sustain-Zeit bestimmen. Das ist die Zeitdauer, die der Klang anhält, wenn er die eingestellte Lautstärke erreicht hat, also zwischen dem Attack- und dem Release-Stadium.

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: Mit der Sustain-Zeit kannst Du wichtige Klänge in einem Mix hervorheben, bevor möglicherweise der Release einsetzt. Natürlich kann man ohne weiteres sowohl den `attack:` als auch den `release:` auf 0 setzen und nur den Sustain gebrauchen. Damit bekommt man einen Klang ohne Ein- und Ausblendung. Aber Vorsicht, ein Release von 0 kann Klickgeräusche in der Aufnahme verursachen. Meist ist ein geringer Wert wie z.B. 0.2 besser.

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: Und falls Du alles ganz genau beeinflussen möchtest, kannst Du noch die Decay-Zeit festlegen. Das ist die Phase der Hüllkurve, die zwischen die Attack- und die Release-Phase passt; sie gibt die Zeit an, wo die Amplitude hinunterfällt vom `attack_level:` zum `decay_level:` (welche den gleichen Wert wie `sustain_level:` erhält, wenn Du es nicht anders vorgibst). Normalerweise steht die Opt `decay:` auf 0, während sowohl das Attack- als auch das Sustain-Level auf 1 stehen. Damit die Decay-Zeit einen hörbaren Effekt hat, müssen Attack und Sustain also auch angegeben werden:

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: Normalerweise hat die Option `decay_level:` den selben Wert wie `sustain_level:`, aber Du kannst sie auch bewusst einen anderen Wert setzen. So hast Du volle Kontrolle über die Hüllkurve und kannst zum Beispiel eine wie diese vorgeben:

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

en: ADSR Envelopes
de: ADSR-Hüllkurven

en: So to summarise, Sonic Pi's ADSR envelopes have the following phases:
de: Fassen wir noch einmal 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, welche die Amplitude von 0 bis zum `attack_level` benötigt,

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

en: *sustain* - time to move the amplitude from `decay_level` to `sustain_level`,
de: *Sustain* - die Zeit, in der sich die Amplitude auf dem `sustain_level` hält,

en: *release* - time to move amplitude from `sustain_level` to 0
de: *Release* - die Zeit, welche die Amplitude vom `sustain_level` auf 0 bringt

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: Eins ist wichtig: der Klang dauert so lange wie die Summe aller Zeiten der unterschiedlichen Phasen. Deshalb hat der folgende Klang eine Dauer von 0.5 + 1 + 2 + 0.5 = 4 Schlägen:

en: Now go and have a play adding envelopes to your sounds...
de: Jetzt weißt Du, wie Du Deine Klänge mit Hüllkurven verändern kannst...

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: Du kannst auch aufgenommene Sounds in Deiner Musik verwenden. In der großen Tradition des Hip-Hop nennen wir diese aufgenommenen Sounds auch *Samples*. Wenn Du ein Mikrophon mit nach draußen nimmst und den zarten Klang der Regentropfen auf einem Zeltdach aufnimmst, dann ist das Ergebnis ein Sample.

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 kann man in Sonic Pi viele tolle Sachen machen. Es sind über 130 freie Samples zum sofortigen Gebrauch dabei und Du kannst auch Deine eigenen Samples einbauen und verändern. Legen wir 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: Pieptöne zu spielen ist erst der Anfang. Mit aufgenommenen Samples hat man noch viel mehr Spaß. Probier 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 ebenso wie das `play`-Kommando benutzen. 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 nacheinander spielen willst, füge einen `sleep`-Befehl ein:

en: Discovering Samples
de: Samples entdecken

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: Zweitens hilft Dir das *Auto-Completion System*. Tipp einfach den Anfang eines Gruppennamens von Samples ein, also: `sample :ambi_`. Nun klappt ein Menü mit allen dazu passenden Samples auf. Versuche einen der folgenden Anfänge von Gruppennamen:

en: Now start mixing samples into your compositions!
de: Jetzt leg los und mische Samples in Deine Komposition!

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 mit den Synths können wir auch unsere Sounds mit Parametern steuern. Der selbe Parameter-Mechanismus funktioniert auch mit Samples. Besuchen wir unsere Freunde `amp:` and `pan:` noch einmal.

en: Amping samples
de: Die Amplitude von Samples verändern

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 so steuern, wie Du es schon von den Synths kennst:

en: Panning samples
de: Das Stereo-Feld von Samples verändern

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 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: Samples berücksichtigen nicht die Grundeinstellungen für einen Synth, die Du mit `use_synth_defaults` setzen kannst (aber dazu kommen wir später noch).

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 ganze Menge Synths und Samples spielen und damit Musik machen. Es wird Zeit zu lernen, wie wir diese Synths und Samples verändern können. Das macht unsere Musik einzigartiger und spannender. Als erstes sehen wir uns an, wie wir Samples *strecken* und *stauchen*.

en: Sample Representation
de: Wie Samples Klänge darstellen

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 und werden als eine Zahlenreihe von Messwerten (deshalb "Sample") gespeichert. Diese Zahlen sagen der Lautsprechermembran, wie sie 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 soll. Um einen Klang als Aufnahme wirklichkeitsgetreu wiederzugeben, muss das Sample je Sekunde viele tausend Zahlen speichern. Sonic Pi nimmt diese Zahlenreihe und gibt sie in der richtigen Samplerate (bzw. Samplingrate oder Abtastrate) an den Lautsprecher in Deinem Computer, so dass der Klang richtig wiedergegeben wird. Es macht aber auch Spaß, die Samplerate zu beeinflussen, denn das verändert den Klang.

en: Changing Rate
de: Die Samplerate ä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`. Beim Befehl `sample` kannst Du mit der Opt `rate` die Samplerate verändern:

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 normalen Samplerate (1) abgespielt, also nichts Besonderes. Aber wir können die Zahl jederzeit verändern. Was passiert bei `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 mal 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 Zusammenstauchen besonders viel Spass. Mit der normalen Samplerate passt das Sample gut in einen *Drum 'n' Bass*-Track:

en: However by changing the rate we can switch up genres. Try half speed for *old school hip-hop*:
de: Mit einer anderen Samplerate passt es zu einer ganz anderen Stilrichtung. Versuche es mal mit halber Samplerate für *Hip-Hop der alten Schule*:

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

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

en: Woah! It plays it *backwards*! Now try playing with lots of different samples at different rates. Try very fast rates. Try crazy slow rates. See what interesting sounds you can produce.
de: Boah! Das Sample spielt *rückwärts*! Jetzt probiere mit vielen unterschiedlichen Samples und unterschiedlichen Sampleraten herum. Versuch es mit sehr hohen oder mit verrückt langsamen. Finde heraus, welche spannenden Klänge Du damit produzieren kannst.

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: Man kann sich Samples gut als Sprungfedern vorstellen. Wenn man die Samplerate verändert, ist das so, als ob man die Feder zusammendrückt oder auseinanderzieht. Wenn Du ein Sample mit der doppelten Samplerate abspielst, dann drückst Du die Feder zusammen, bis sie nur noch die Hälfte ihrer normalen Länge hat. Das Sample braucht also auch nur die Hälfte der Abspielzeit. Wenn Du das Sample mit halber Samplerate spielst, dann ziehst Du die Feder auf ihre doppelte Länge auseinander. Das Sample dauert also nun doppelt so lange. Je mehr Du zusammendrückst (höhere Rate), desto kürzer das Sample, je mehr Du auseinanderziehst (geringere Rate), desto länger dauert 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 man eine Feder zusammendrückt, dann erhöht man ihre Dichtheit (die Anzahl der Windungen je Zentimeter) - das ist so ähnlich wie bei einem Sample, der *höher klingt*. Wenn man die Feder auseinanderzieht, dann verringert sich ihre Dichtheit, vergleichbar einem Klang, der 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 noch etwas mehr in die Tiefe gehen möchten. 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 Liste von Zahlen dargestellt, die der Lautsprechermembran sagen, wo sie zu welchem Zeitpunkt sein soll. Wir können diese Zahlenliste nehmen und eine Kurve zeichnen, die ungefähr so aussieht:

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 *Kurvenform* eines Sample. Es ist bloß eine Kurve aus Zahlenwerten. Typischerweise entsteht eine solche Kurve 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 Datenrate von 44100 Datenpunkten pro Sekunde senden. Natürlich könnten wir es mit der doppelten Datenrate senden, also 88200 Datenpunkten pro Sekunde. Dann würde das Sample nur eine Sekunde lang dauern. Wir können es auch mit der halben Datenrate 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 Sample-Dauer ist also abhängig von der Datenrate:

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 sich die Abspielzeit,

en: Using a playback rate of one fourth quadruples the playback time,
de: Verwendest Du eine Abtastrate von einem Viertel, dann vervierfachst Du die Abspielzeit.

en: Using a playback rate of 1/10 makes playback last 10 times longer.
de: Verwendest Du eine Abtastrate von 1/10, dann dauert die Abspielzeit 10mal länger.

en: We can represent this with the formula:
de: Es gibt eine Formel dafür:

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öhen des Samples. Die Frequenz oder Tonhöhe einer Kurve wird dadurch bestimmt, wie schnell sie hoch und runter geht. Unsere Gehirne machen aus schnellen Bewegungen einer Lautsprechermembran hohe Töne und aus langsamen tiefe. Deshalb kannst Du manchmal sogar sehen, wie sich ein großer Basslautsprecher bewegt, wenn ein sehr tiefer Ton rauskommt. Er bewegt 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 Kurve nimmst und sie zusammendrückst, wird sie je Sekunde öfter hoch und runter gehen als vorher. Der Ton wird dann auch höher sein. Wenn man die Auf- und Abbewegungen je Sekunde verdoppelt (Oszillationen), dann wird die Frequenz, die Tonhöhe, verdoppelt. Also, *wenn Du Dein Sample mit doppelter Samplerate abspielst, wird es auch doppelt so hoch klingen*; andererseits: *eine Halbierung der Samplerate wird auch die Frequenz halbieren*. Andere Sampleraten werden dementsprechend die Tonhöhe beinflussen.

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 Sample mit einer ADSR-Hüllkurve zu verändern. Das funktioniert jedoch ein wenig anders als die ADSR-Hüllkurven bei den Synths. Mit Sample-Hüllkurven kannst Du 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 das Sample begrenzt - je nachdem welche kürzer ist. Mit einem sehr langen `release:` kannst Du ein Sample also nicht über seine normale Laufzeit hinaus 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 alten 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. Mit der `attack:`-Opt können wir das Sample einblenden lassen:

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: Beim *Sustain*-Wert unterscheidet sich das Verhalten einer ADSR-Hüllkurve. Bei der Hüllkurve für Standard-Synths steht der Sustain normalerweise auf 0 - außer Du setzt den Wert ausdrücklich. Bei Samples wird der Sustain-Wert auf einen *automagical* Wert gesetzt - nämlich die Zeit, die es braucht, bis das gesamte Sample 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 0 wären, würden wir keinen Pieps hören. Deshalb berechnet Sonic Pi zunächst, wie lange das Sample von sich aus dauert, zieht etwaige Dauern für Attack, Decay und Release davon ab und setzt die restliche Zeit als Sustain-Wert. Wenn die Werte von Attack, Decay und Release zusammengenommen 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 genauer an. Wir fragen Sonic Pi, 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: Es wird `1.753310657596372` ausgeben; das ist die Länge des Sample in Sekunden. Wir runden das einmal bequemerweise 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. Wenn unser Sample 10.75 Sekunden lang wäre, würden die ersten 10 Sekunden in voller Lautstärke gespielt bevor dann eine Ausblende über 0.75 Sekunden erfolgt.

en: Remember: by default, `release:` fades out at the end of a sample.
de: Zur Erinnerung: 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 `attack:` und `release:` zusammen mit Auto-Sustain nutzen, um über die Laufzeit 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 der Sustain automatisch die Länge 0.25s. So ist es ganz einfach, das Sample ein- und auszublenden.

en: Explicit sustain
de: Ausdrücklich angegebener 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 das normales 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 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: Man kann hören, wie das Becken eine Zeit lang ausklingt. Mit einer leicht veränderten Hüllkurve klingt es perkussiver:

en: You can then emulate hitting the cymbal and then dampening it by increasing the sustain period:
de: Mit einer längeren Sustain-Dauer kannst Du es so klingen lassen, als ob das Becken erst angeschlagen und dann abgedämpft würde:

en: Now go and have fun putting envelopes over the samples. Try changing the rate too for really interesting results.
de: Jetzt versuch einmal, Hüllkurven über Samples zu legen. Verändere auch die Samplerate; damit kannst Du sehr 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: Dieses Kapitel 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 lassen (hier zum Beispiel 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 ein Sample am Anfang perkussiver klingen lassen können, indem wir `sustain:` ausdrücklich einen Wert zuweisen, und sowohl der Attack als auch der Release kurze Werte bekommen:

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 prima, wenn das Ende des klingenden Sample nicht immer seinem wirklichen Ende entsprechen müsste?

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: Man kann auch einen beliebigen Startpunkt eines Sample als Wert zwischen 0 und 1 auswählen. Dabei ist 0 der Anfang, 1 das Ende und 0.5 die Mitte des Samples. Spielen wir also jetzt die zweite Hälfte des Amen Break:

en: How about the last quarter of the sample:
de: Oder vielleicht das letzte Viertel des Sample:

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: Ebenso 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 das auch kombinieren und so einen beliebigen Abschnitt des Sample abspielen. Wie wäre es mit einem kurzen Abschnitt aus der Mitte:

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

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

en: Combining with rate
de: In Kombination mit der 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: Diese neue Fähigkeit, beliebige Abschnitte eines Klangs zu spielen, lässt sich mit unserem Freund `rate:` kombinieren. Zum Beispiel können wir einen sehr kurzen Abschnitt des Amen-Breaks sehr langsam spielen:

en: Combining with envelopes
de: In Kombination mit Hüllkurven

en: Finally, we can combine all of this with our ADSR envelopes to produce interesting results:
de: Wenn wir all dies mit unseren ADSR-Hüllkurven kombinieren, kriegen wir interessante Ergebnisse:

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

en: 3.6 External Samples
de: 3.6 Samples aus externen Quellen

en: External Samples
de: Samples aus externen Quellen

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: Mit den mitgelieferten Samples kannst Du schnell einsteigen, aber vielleicht möchtest Du 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 mit Hilfe der eingebauten Synths und Samples komponierst, braucht man nur den Code, um Deine Musik so abzuspielen, wie Du sie geschrieben hast. Denk darüber einen Augenblick nach - das ist erstaunlich! Ein bisschen Text, den Du per Email verschicken oder auf [Gist](https://gist.github.com) ablegen kannst, reicht vollkommen aus, um Deine Klänge wieder abzuspielen. So wird es sehr einfach, Deine Kompositionen mit Deinen Freunden zu teilen. Sie brauchen nur ein wenig 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: Wenn Du nun selbst aufgenommene Samples verwendest, verlierst Du diese Übertragbarkeit. Denn jetzt braucht man zum Abspielen auf einem anderen Rechner nicht nur den Code, sondern auch Deine Samples.

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. Alle anderen Standard-Parameter, die Du schon kennengelernt hast, kannst Du jetzt auch für Dein eigenes Sample einsetzen:

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 den fortgeschrittenen Umgang mit großen Verzeichnissen Deiner eigenen Samples. Das wird nützlich, wenn Du eigene 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: **Du kannst diesen Abschnitt überspringen, wenn Dir die mitgelieferten Samples ausreichen und Du keine eigenen brauchst.**

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 externer 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 den Ordner schauen, finden wir folgende 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 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 nur schnell die einzelnen Samples nacheinander hö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 zum Sample und den Index 0 eingeben. Das geht so:

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 Vernküpfung zu unserem Verzeichnis 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 den Index 1 anfü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 benötigen nur das Verzeichnis (oder haben eine Verknüpfung zu diesem). Wenn wir nach einem Index fragen, der größer als die Anzahl der Samples ist, fängt die Liste einfach von vorne an - wie bei Ringen. Also egal welche Nummer wir nutzen, es ist garantiert, dass  wir ein Sample 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 mehr Möglichkeiten beim Organisieren unserer Samples. Glücklicherweise ergänzen viele Sample-Packs nützliche Informationen in ihre Dateinamen. Lass uns noch einmal einen Blick auf die Dateinamen 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: In diesen Dateinamen sind einige Informationen enthalten. Zuerst haben wir die BPM ("beats per minute") des Samples. D.h. das Piano Sample hat 120 BPM und unsere ersten drei Melodien haben 100 BPM. Außerdem steht in den Samplenamen die Tonart. Das Gitarren-Sample ist in Bb und die Melodien sind in A#. Diese Information ist für das Mixen der Samples in 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 herauszufiltern, was 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 das erste passende Sample abspielen. Wenn wir das zweite passende Sample abspielen wollen, müssen wir nur einen Index nutzen:

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

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 beim Abspielen des Samples 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` fn will first gather all sources and use them to create a large list of candidates. This list is constructed by first adding all valid paths and then by adding all the valid `.flac`, `.aif`, `.aiff`, `.wav`, `.wave` files contained within the directories.
de: Der `sample`-Befehl sammelt alle Quellen und erzeugt daraus eine lange Liste von Kandidaten. Für diese Liste durchsucht er zunächst alle gültigen Verzeichnispfade und fügt dann alle darin enthaltenen Dateien in den Formaten `.flac`, `.aif`, `.aiff`, `.wav`, `.wave` hinzu.

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 sammeln wir alle Samples aus zwei Verzeichnissen und fügen noch einen einzelnen 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: Normalerweise werden nur die Sample-Dateien des angegebenen Verzeichnisses in der Kandidatenliste versammelt. 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 stellst:

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: Sei aber vorsichtig, weil eine Suche über viele Verzeichnisse hinweg lange dauern kann. Allerdings wird der Inhalt aller Ordner, die Du als Quellen angegeben hast, zwischengespeichert; die Suche wird also nur beim ersten Mal langsam sein.

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 Du keine Quelle angibst, werden die mitgelieferten Samples für die Standardliste ausgewählt, mit der 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 einmal die Kandidatenliste hast, kannst du die folgenden Filtertypen zur weiteren Auswahl benutzen:

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 (ohne den Verzeichnispfad und die 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 (ohne den Verzeichnispfad und die 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, wo dieses Kennwort genau dem Dateinamen entspricht (ohne den Verzeichnispfad und die 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 Index 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 dazu den Hilfeeintrag zu `sample` mit vielen Anwendungsbeispielen an. Achte darauf, dass die Sortierung der Filter eine Rolle spielt.

en: Composites
de: Zusammengesetzte Ausdrücke

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: Schließlich: Du kannst eine Liste verwenden, wo immer Du eine Quelle oder einen Filter anwendest. Die Liste wird automatisch aufgelöst und ihr Inhalt so behandelt, als wäre er eine normale Quellen- oder Filterangabe. Deshalb bedeuten die folgenden Aufrufe von `sample` alle dasselbe:

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 komplizierter Abschnitt für alle, die tiefer in Sample-Pakete einsteigen möchten. Mach' Dir keine Sorgen, wenn vieles von dem, was hier steht, für Dich im Moment noch wenig Sinn macht. Es ist gut möglich, dass Du davon vieles noch nicht brauchst. Dennoch, Du wirst schon merken, wenn Du es brauchst, und dann kannst Du zurückkommen und den Abschnitt noch einmal lesen, wenn Du einmal mit umfangreichen Sample-Sammlungen hantieren möchtest.

en: 4 Randomisation
de: 4 Randomisierung

en: Randomisation
de: Randomisierung

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: Zufallszahlen sind eine tolle Möglichkeit, Deine Musik interessant zu gestalten. In Sonic Pi sind einige Funktionen enthalten, um Zufallsfaktoren in Deine Musik einzubauen. Aber bevor wir starten, müssen wir noch einer schockierenden Wahrheit ins Gesicht sehen: In Sonic Pi bedeutet *zufällig nicht wirklich zufällig*. Was zum Teufel soll das bedeuten? Nun, das verrate ich Dir jetzt.

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 das englische *ranged random*, also eine Zufallszahl in einem bestimmten Wertebereich.) Hier eine zufällig ausgewählte Note:

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, eine zufällige Note wird gespielt. Es war die Note `83.7527`. Eine nette Note zwischen 50 und 100. Aber hallo, habe ich gerade diese angeblich zufällige Note exakt vorhergesagt? Da ist doch etwas nicht ganz astrein. Lasse den Code noch einmal ablaufen. Wieder `83.7527`, oder? Das kann doch 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, sondern pseudo-zufällig. Sonic Pi liefert Dir Reihenfolgen von Zufallszahlen, die wiederholbar sind. Das ist sehr nützlich, denn so ist sichergestellt, dass die Musik von Deinem Rechner auf anderen Rechnern identisch klingt - sogar dann, wenn Du den Zufallsgenerator einbaust.

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 in einem bestimmten Musikstück jedesmal die `83.7527` als 'zufällige' Zahl gewählt würde, dann wäre das nicht besonders interessant. Aber so ist es auch nicht. Versuch 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: Jawohl! Nun klingt es zufällig. Innerhalb eines bestimmten Code-Durchgangs liefern Aufrufe von Zufallsfunktionen auch zufällige Werte. Der nächste Durchgang wird jedoch genau die selbe Folge von Zufallswerten liefern und also auch genau gleich klingen. Es ist, als ob der Code immer zu demselben Zeitpunkt zurückspringt, wenn der Ausführen-Button geklickt wird. Es ist der Murmeltier-Tag der musikalischen Synthese!

en: Haunted Bells
de: Ruhelose Glocken

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 großartiges Beispiel von Zufall in Aktion bietet der "Haunted Bells"-Code. Die "ruhelosen Glocken" spielen das Sample `:perc_bell` mit einer zufälligen Samplerate und Pausenzeit in einer Endlosschleife ab:

en: Random cutoff
de: Zufällig abschneiden (random cutoff)

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 spannendes Beispiel für die Randomisierung ist das zufällige Ausfiltern bzw. Abschneiden hoher Töne eines Synth-Klangs. Der `:tb303`-Emulator ist ein guter Synth, um das auszuprobieren:

en: Random seeds
de: Startpunkt der Zufallsfolge (random seed)

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 aber, wenn Du die Abfolge von Zufallszahlen, die Sonic Pi Dir liefert, nicht magst? Nun, mit `use_random_seed` kannst Du unterschiedliche Startpunkte für diese Folge angeben. Der Standard-Startpunkt ist die 0. Wähle also einfach einen anderen Startpunkt und mache eine andere Zufallserfahrung!

en: Consider the following:
de: Sieh Dir den 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 den Code ablaufen lässt, hörst Du dieselbe Folge von 5 Tönen. Um eine andere Folge zu bekommen, setze einfach 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 von 5 Tönen. Indem Du den Startpunkt wechselst und Dir die Ergebnisse anhörst, kannst Du eine Folge finden, die Dir gefällt - und wenn Du den Code dann 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 eine andere nützliche Zufallsfunktion an.

en: choose
de: Auswählen (choose)

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: Häufig kommt es vor, dass man aus einer Liste von Dingen eines zufällig auswählen möchte. Zum Beispiel möchte ich einen Ton aus der folgenden Liste auswählen: 60, 65 oder 72. Dafür ist `choose` da. Zuerst musst Du Deine Zahlen in eine Liste packen. Dafür schreibst Du sie jeweils durch Kommata getrennt in eckige Klammern. Dann übergibst Du diese Liste dem Kommando `choose`:

en: Let's hear what that sounds like:
de: Hören wir uns das 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: `rrand` haben wir schon kennengelernt, aber sehen wir uns das noch einmal genauer an. Es liefert eine zufällige Zahl zwischen zwei Werten, aber ohne diese Werte selbst; man sagt auch *exklusiv* dieser beiden Werte. Das bedeutet, dass sowohl der minimale als auch der maximale Wert niemals ausgegeben werden, immer nur eine Zahl *zwischen* diesen beiden Werten. Die Zahl wird immer eine Gleitkommazahl sein, also keine ganze Zahl, sondern eine mit einem Komma. (Ok, wir schreiben sie mit einem Komma, aber im englischen Sprachraum heißen sie *Floating Point* - oder kurz: *Float* - und man schreibt sie mit einem Punkt.) Einige Beispiele für Gleitkommazahlen, die der wiederholte Aufruf von `rrand(20, 110)` ausgeben könnte:

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: Manchmal braucht man eine zufällige, aber ganze Zahl, eben keine Gleitkommazahl. Hier rettet einen `rrand_i`. (Das "i" steht hier für das englische Wort *Integer*, also ganze Zahl.) Es funktioniert ähnlich `rrand`, kann jedoch auch den minimalen oder maximalen Wert, den man übergeben hat, als mögliche Zufallszahl auswählen (man kann auch sagen: es ist *inklusiv*, also nicht exklusive der Werte, mit denen man den Bereich für die Auswahl festgelegt hat). `rrand_i(20,  110)` könnte zum Beispiel die folgenden Werte ausgeben:

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: `rand` gibt eine zufällige Gleitkommazahl zwischen 0 (inklusiv) und einem übergebenen Maximalwert (exklusiv) zurück. Standardmäßig - wenn also kein Maximalwert angegeben wird - wird ein Wert zwischen 0 und 1 geliefert. Deshalb kann man `rand` gut dafür gebrauchen, zufällige Werte für `amp:` (also die Lautstärke) auszuwählen:

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 bei `rrand_i` und `rrand`, wählt `rand_i` eine zufällige ganze Zahl zwischen 0 und dem angegebenen Maximalwert aus.

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 möchte man so tun, als würde man würfeln (engl. *to dice*) - das ist ein Sonderfall von `rrand_i`, wobei der kleinste Wert immer die 1 ist. Wenn man `dice` verwendet, muss man dabei immer bestimmen, wie viele Seiten der Würfel hat. Ein normaler Würfel hat 6 Seiten, also wird `dice(6)` entsprechend funktionieren und den Wert 1, 2, 3, 4, 5 oder 6 zurückgeben. Aber - angenommen wir befänden uns in einen Fantasy-Rollenspiel - ist es Dir vielleicht lieber, wenn der Würfel 4 oder 12, 20 oder sogar 120 Seiten hat?

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 sein, dass Du so tun willst, als ob Du beim Würfeln eine 6 hast - also den höchten Wert erreichst. `one_in` gibt - mit einer Wahrscheinlichkeit 1 im Verhältnis zur Menge der Würfelseiten - den Wert *wahr* (engl. *true*) zurück, falls die höchste Zahl gewürfelt wurde. `one_in(6)` wird also mit einer Wahrscheinlichkeit von 1 zu 6 wahr, ansonsten *falsch* (engl. *false*). Wahr- und Falsch-Werte sind sehr nützlich, wenn es um `if`-Anweisungen geht, die wir in einem späteren Kapitel dieses Tutorials besprechen.

en: Now, go and jumble up your code with some randomness!
de: Jetzt los, bring Deinen Code mit ein paar Zufälligkeiten 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 kennst Du schon die wichtigsten Grundlagen. Du weißt, wie man Klänge mit `play` und `sample` erzeugt, und kannst einfache Melodien und Rhythmen bauen, indem Du `sleep` zwischen die Klänge setzt. Du fragst Dich nun vielleicht, was Dir die Welt des Codes noch alles 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: Ich denke, da kommen noch einige tolle Sachen auf Dich zu! Du wirst sehen, dass grundlegende Programmstrukturen wie Schleifen, Bedingungen, Funktionen und Threads großartige Werkzeuge sind, wenn Du Deine musikalischen Ideen ausdrücken willst.

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

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, die man häufig in Sonic Pi sieht, ist der Block. Blocks erlauben uns, nützliche Dinge mit größeren Codeabschnitten zu tun. Mit Synth- oder Sample-Parametern konnten wir etwas ändern, was in einer Codezeile geschah. Manchmal aber möchten wir etwas mit einer ganzen Reihe von Codezeilen anstellen. Zum Beispiel möchten wir diese in einer Schleife ablaufen lassen, Hall hinzufügen, bei vorgegebenen Wiederholungen nur eine von fünf ablaufen lassen etc. Schau Dir den 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 mit einem mehrzeiligen Codestück zu tun, müssen wir Sonic Pi sagen, wo der Code-Block *anfängt*, und wo er *aufhört*. Dazu verwenden wir `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 alles und wird so nicht funktionieren (versuche es und Du wirst einen Fehler erhalten), weil wir Sonic Pi noch nicht gesagt haben, was wir mit diesem *do/end-Block* machen wollen. Dafür setzen wir noch einen speziellen Ausdruck vor das `do`. Solche Ausdrücke werden wir in diesem Tutorial gleich kennenlernen. Zunächst einmal ist wichtig, dass wir mehrere Codezeilen mit `do` und `end` zusammenfassen und Sonic Pi sagen können, dass wir mit diesem Codestück etwas Bestimmtes machen wollen.

en: 5.2 Iteration and Loops
de: 5.2 Iteration 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 einige Zeit damit verbracht, uns unterschiedliche Klänge anzusehen, die Du mit `play` und `sample` erzeugen kannst. Wir haben auch gelernt, wie Du den Ablauf dieser Klänge mit `sleep` steuern kannst.

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 schon entdeckt, dass man mit diesen Grundbausteinen schon *vieles* bauen kann. Eine ganz neue Dimension eröffnet sich jedoch, wenn wir beginnen, die Musik und die Kompositionen über den Code weitergehend zu strukturieren. In den nächsten Abschnitten schauen wir einige wirkungsvolle neue Werkzeuge dafür an. Als erstes kommen die Iteration und die Schleife (engl. *Loop*) 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. ungefähr 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 Mal wiederholen wolltest? Naja, die Lösung ist einfach! Du kannst den Code kopieren und drei Mal 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: Das ist natürlich eine Menge Code! Was wäre, wenn Du das Sample in `:elec_plip` umändern wolltest? Du müsstest alle Stellen mit `:elec_blub` finden und ändern. Und weiter: Was, wenn Du das ursprüngliche Codestück 50 oder 1000 Mal wiederholen wolltest? Das wäre noch mehr Code, und Du müsstest eine Menge Zeilen bearbeiten, 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: Wenn man Code wiederholt ablaufen lassen wollte, müsste man eigentlich nur sagen: *Mach das drei Mal*. Und so ist es auch in etwa. Erinnerst Du 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. Dann benutzen wir den speziellen Ausdruck `3.times`. Wir schreiben zwar nicht *mach das drei Mal*, wir schreiben `3.times do` - also nicht besonders schwierig. Denk aber daran, ans Ende des zu wiederholenden Code-Blocks gehört ein `end`:

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 kopieren und einfügen? Wir können bei vielen sich wiederholenden Strukturen gut gebrauchen:

en: Nesting Iterations
de: Verschachtelte Iterationen

en: We can put iterations inside other iterations to create interesting patterns. For example:
de: Wenn wir Iterationen in andere Iterationen hinein packen, entstehen interessante Muster. Zum Beispiel:

en: Looping
de: Schleifen

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 macht es mehr Sinn, Sonic Pi dazu zu bringen, den Code in einer Endlos-Schleife zu wiederholen (zumindest, bis Du den Stopp-Button klickst!). Wiederholen wir den Amen-Break unendlich oft:

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 Endlos-Schleifen ist, dass sie für den Code wie schwarze Löcher sind. Wenn der Code einmal in einer Endlos-Schleife läuft, kann er sie nicht mehr verlassen, bis Du auf Stopp klickst - ansonsten wird er für immer weiterlaufen. Das bedeutet, wenn hinter Deiner Endlos-Schleife noch weiterer Code steht, wirst Du diesen *nie* hören. Zum Beispiel wird das Becken hinter dieser Schleife nie spielen:

en: Now, get structuring your code with iteration and loops!
de: Jetzt fang an und strukturiere Deinen Code mit Wiederholungen 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: Wahrscheinlich willst Du häufig nicht nur einen einen zufälligen Ton abspielen (siehe das Kapitel über Zufallszahlen), sondern auch eine zufällige Entscheidung treffen: je nachdem wie diese ausfällt, möchtest Du dann den einen oder anderen Code ausführen. Zum Beispiel könnte es sein, dass Du zufällig entweder eine Trommel oder ein Becken anschlagen möchtest. Das können wir mit einem `if`-Ausdruck erreichen.

en: Flipping a Coin
de: Wirf eine Münze

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 der `one_in`-Funktion nachbilden (eingeführt im Kapitel über Randomisierung), indem wir eine Wahrscheinlichkeit von 1 aus 2 angeben: `one_in(2)`. Das Ergebnis dieser Berechnung benutzen wir, um zwischen zwei Codestücken auszuwählen, entweder den Code für die Trommel oder den für das Becken:

en: Notice that `if` statements have three parts:
de: Denke daran, 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 erste Wahl des Codes, der ablaufen 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 Wahl des Codes, der ablaufen 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: Für Programmiersprachen typisch steht für das Ja der Ausdruck `true` (wahr) und für das Nein der Ausdruck `false` (falsch). Also müssen wir eine Frage finden, die uns eine Antwort gibt, die entweder wahr oder falsch ist; genau das erledigt hier im Beispiel `one_in`.

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, dass die erste Wahl zwischen `if` und `else` und die zweite Wahl zwischen `else` und `end` eingeschlossen wird. So wie bei den do/end-Blöcken kannst Du beliebig viele Codezeilen an beide Stellen schreiben. Zum Beispiel:

en: This time we're sleeping for a different amount of time depending on which choice we make.
de: Dieses Mal schläft der Code unterschiedlich lange, 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 Codezeile ausführen. Dafür hängst Du ein `if` und die Frage an das Ende der Codezeile, zum Beispiel:

en: This will play chords of different numbers with the chance of each note playing having a different probability.
de: Dieses Beispiel setzt einen Akkord aus verschiedenen Noten zusammen, wobei die einzelnen Noten jeweils eine unterschiedliche Wahrscheinlichkeit haben.

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: Mal angenommen, Du hast eine Killer-Basslinie und einen krassen Beat gebaut. Wie kannst Du beides zur selben Zeit spielen lassen? Eine Möglichkeit ist es, beide Sounds per Hand ineinander zu weben - erst spielt der Bass ein bisschen, dann das Schlagzeug, dann der Bass etwas mehr... Beides aufeinander zeitlich abzustimmen wird jedoch immer schwieriger, vor allem, wenn noch mehr Sounds dazukommen sollen.

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 Sounds automatisch für Dich ineinander flechten könnte? Kann es auch, und zwar mit einem besonderen Ding, welches *Thread* heißt.

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 das nächste 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, Endlos-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 den `Stopp`-Button klickst. Wie also können wir beide Schleifen zur selben Zeit abspielen? Wir müssen Sonic Pi sagen, dass wir einen bestimmten Abschnitt gleichzeitig mit dem Rest des Codes starten möchten. Hierbei helfen uns Threads.

en: Threads to the Rescue
de: Threads kommen zur Hilfe

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: Wenn 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 die nachfolgende Anweisung ausführen. Und das ist in diesem Fall die zweite Schleife. Probier es aus, und Du wirst den Beat zusammen mit der Basslinie hören!

en: Now, what if we wanted to add a synth on top. Something like:
de: Angenommen, dass wir obendrauf noch einen Synth legen wollten. 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: Ablauf in Threads

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 den Ausführen-Button klickst, erzeugst Du tatsächlich einen neuen Thread, innerhalb dessen der Code abläuft. Deshalb entstehen immer neue Soundschichten, wenn Du den Ausführen-Button wiederholt klickst. Weil die Abläufe Threads sind, werden sie automatisch die Sounds verflechten.

en: Scope
de: Geltungsbereich (Scope)

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: Wenn Du Dich besser mit Sonic Pi auskennst, wirst Du herausfinden, dass Threads die wichtigsten Bausteine für Deine Musik sind. Threads können die *aktuellen Einstellungen*, die für einen Thread gelten, von anderen Threads isolieren. Was genau bedeutet das? Wenn Du etwa einen Synths mit `use_synth` durch einen anderen austauschst, dann veränderst Du den Synth lediglich für den *aktuellen Thread* - kein anderer der laufenden Threads bekommt den neuen Synth. 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: Hast Du gehört, dass 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 Haupt-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 dieser vom vorherigen alle Einstellungen automatisch 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: Hast Du bemerkt, dass der zweite Ton mit dem `:tb303`-Synth gespielt wird, obwohl er in einem anderen Thread läuft? Jede der Einstellungen, die mit den unterschiedlichen `use_*`-Ausdrücken vorgenommen wird, verhält sich genauso.

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 starten, erben sie alle Einstellungen von ihren Eltern. Wenn Du aber Einstellungen innerhalb dieser neuen Threads änderst, haben diese keine Einfluss auf die Eltern-Threads.

en: Naming Threads
de: Threads benennen

en: Finally, we can give our threads names:
de: Schließlich kannst Du Deinen Threads 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: Sieh Dir das Protokoll-Fenster an, wenn Du diesen Code laufen lässt. Siehst Du, wie die Namen der Threads ausgeben werden?

en: Only One Thread per Name Allowed
de: Nur ein Name pro Thread 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 Anmerkungen zu Threads mit Namen: Es können nicht zwei gleichzeitig laufende Threads den gleichen Namen haben. Probieren wir das aus. Sieh Dir den 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 den `Ausführen`-Button. Klick in noch ein paar mal. Hör Dir diese Kakophonie mehrerer Amen-Breaks an, die rhythmisch nicht unbedingt passend zueinander ablaufen. Ok, jetzt kannst Du auf `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 konnten wir schon woanders sehen - wenn Du den `Ausführen`-Button klickst, legen sich die neuen Klänge über die schon laufenden. Wenn eine Schleife abläuft, und Du den `Ausführen`-Button dreimal klickst, bekommst Du drei Ebenen mit Schleifen, die gleichzeitig ablaufen.

en: However, with named threads it is different:
de: Mit benannten Threads ist das jedoch 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 mit diesem Code den `Ausführen`-Button mehrmals zu klicken. Du wirst immer nur eine Amen-Break-Schleife hören. Das kannst Du auch im 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 sagt Dir, dass ein Thread mit dem Namen `:amen` bereits läuft und es deshalb keinen weiteren startet.

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 sinnvoll - 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, mehr Code zu schreiben, dann wirst Du nach Wegen suchen, wie Du die Dinge organisieren und strukturieren kannst. Damit wird alles ordentlicher und einfacher zu verstehen. Funktionen sind dafür sehr praktisch. Sie geben uns die Möglichkeit, einem Bündel von Codezeilen 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 `erste_strophe` oder `hintergrund_akkorde`.

en: Remember to prepend a colon `:` to the name of your function when you define it.
de: Denk daran, bei der Definition einer Funktion einen Doppelpunkt `:` vor ihren Namen zu stellen.

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 einfach über ihren Namen 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 Iterations-Blocks aufrufen und überall da, wo wir auch `play` oder `sample` hätten benutzen können. Das gibt uns eine große Ausdrucksfreiheit und wir können sinnvolle Worte bilden, die wir in unseren Kompositionen verwenden.

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 bislang den `Ausführen`-Button geklickt hast, startete Sonic Pi jedes mal aufs Neue ohne irgendwelche Vorgaben. Es berücksichtigt nichts, außer dem, was im jeweiligen Puffer steht. Du kannst Dich nicht auf irgendwelchen Code beziehen, der in einem anderen Puffer oder einem anderen Thread steht. Funktionen ändern das jedoch. Wenn Du eine Funktion definierst, dann erinnert sich Sonic Pi daran. Probieren wir das aus. Ersetze den gesamten Code in Deinem Puffer 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: Klick den `Ausführen`-Button und höre, wie Deine Funktion spielt. Wo wurde dieser Code gespeichert? Woher weiß Sonic Pi, was es zu spielen hat? Sonic Pi hat sich Deine Funktion einfach gemerkt. Also sogar, nachdem Du den 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`) definiert 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: Du kannst Deinen Funktionen beibringen, Argumente zu übernehmen, genau so, wie Du z.B. `rrand` einen Minimal- und einen Maximalwert übergeben kannst. Sehen wir uns das an:

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 jetzt 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 nach dem `do` stehen, welches zum `define` des do/end-Blocks gehört; sie werden von senkrechten Strichen umgeben und durch Kommata getrennt. Du kannst beliebige Worte 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 Zauberei findet innerhalb des `define`-do/end-Blocks statt. Du kannst die Parameternamen so benutzen, als wären sie wirkliche Werte. In diesem Beispiel spiele ich den Ton `n`. Du kannst die Parameter als eine Art Versprechen ansehen, dass sie durch wirkliche Werte ersetzt werden, wenn der Code läuft. Das machst Du, indem Du der Funktion beim Aufruf einen Parameter mitgibst. Ich tue das hier mit `my_player 80`, um den Ton 80 zu spielen. Innerhalb der Funktionsdefinition wird `n` nun durch 80 ersetzt, sodass `play n` sich in `play 80` verwandelt. Wenn ich die Funktion erneut mit `my_player  90` aufrufe, wird `n` durch 90 ersetzt, sodass sich `play n` in `play  90` verwandelt.

en: Let's see a more interesting example:
de: Sehen wir uns interessantere Beispiele 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 im Aufruf `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: Siehst Du? Unser Code wird sehr aussagekräftig und leichter lesbar, wenn wir eine Menge der 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 Coden ist es sehr nützlich, Namen für Dinge zu vergeben. Sonic Pi macht es Dir hier sehr leicht: Schreib einfach den Namen, den Du gerne 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 Variable `sample_name` *gemerkt*. Wir können nun `sample_name` überall da benutzen, wo wir auch `loop_amen` benutzen könnten. 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 Hauptgründe, Variablen in Sonic Pi zu nutzen: Bedeutung vermitteln, Wiederholung steuern und Ergebnisse 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 Code schreibst, könntest Du denken, dass Du einfach nur dem Computer sagst, was er tun soll - solange der Computer das versteht, ist es okay. Vergiss aber nicht, dass nicht nur ein Computer Deinen Code lesen will. Andere Leute könnten den Code auch lesen und wollen verstehen, was da vor sich geht. Wahrscheinlich wirst Du den Code auch später selbst wieder lesen und möchtest verstehen, was er bedeutet. Obwohl Dir jetzt vielleicht alles offensichtlich erscheint - wahrscheinlich ist es für andere nicht ganz so offensichtlich und vielleicht nicht einmal 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: Mit Kommentaren hilfst Du anderen, Deinen Code zu verstehen. Und Du kannst 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: Aha, jetzt ist viel klarer, was `1.7533` bedeutet: Es ist die Dauer des Sample `:loop_amen`! Natürlich kannst Du jetzt sagen, warum nicht einfach schreiben:

en: Which, of course, is a very nice way of communicating the intent of the code.
de: Das ist natürlich auch ein sehr guter Weg, 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: In Deinem Code wirst Du oft Dinge wiederholen, und wenn Du irgendwo etwas ändern willst, musst Du das an vielen Stellen tun. Schau Dir mal 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: Hier machen wir eine ganze Menge mit dem `:loop_amen`! Was wäre, wenn Du das Ganze mit einem anderen Loop-Sample wie zum Beispiel `:loop_garzul` hören wollten? 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 einer Bühne stehst? Manchmal hast Du nicht den Luxus, Zeit zu haben - 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 (probier es aus). Außerdem bekommen wir die Möglichkeit, durch die Änderung der einen Zeile `sample_name = :loop_amen` in `sample_name = :loop_garzul` die vielen anderen Stellen durch die Magie der Variablen zu verändern.

en: Capturing Results
de: Ergebnisse von Dingen 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: Wenn man schließlich die Ergebnisse von irgendwelchen Dingen speichern möchte, dann ist das ebenfalls ein guter Grund dafür, Variablen zu verwenden. Du möchtest vielleicht irgendetwas mit der Dauer eines Sample anstellen:

en: We can now use `sd` anywhere we need the duration of the `:loop_amen` sample.
de: Wir können nun `sd` überall da 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: Noch wichtiger vielleicht: Eine Variable erlaubt es uns, 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 eingefangen und gemerkt. Und 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: Das nur als kleine Vorschau, wie man Synths steuert. Das schauen wir uns später noch genauer an.

en: Warning: Variables and Threads
de: Warnung: Variablen und Threads (Prozessreihenfolge)

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, so sollten sie aber typischerweise nur im lokalen Kontext eines Threads verwendet werden. Das Folgende sollte man daher *nicht tun*:

en: 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: 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: 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 einem "Ring" aus Zahlen einer Variable 'a' zu und verwenden sie dann in zwei separaten `live_loop`s. Innerhalb der ersten live-loop sortieren wir alle 5 Sekunden den Ring (to `(ring 1, 2, 3, 4, 5, 6)`) und geben in es dann im log aus. Wenn du nun den Code startest, wirst du bemerken, dass die ausgegebene Liste *nicht immer sortiert ist!*. Das könnte dich verwundern - insbesondere, da manchmal die Liste sortiert ist und manchmal eben nicht. Das bezeichnet man als nicht-deterministisches Verhalten (nicht vorhersagbar) und ist das Ergebnis eines eher üblen Problems, das man als 'Race-Condition' bezeichnet. Das Problem resultiert aus der Tatsache, dass die zweite live-loop parallel zur ersten live-loop die Liste verändert (sie mischt sie durch) und zum Zeitpunkt der Ausgabe die Liste manchmal sortiert und manchmal nicht sortiert ist. Da beide live-loops im Wettlauf miteinander sind, die Variable zu verändern, 'gewinnt' eben manchmal die eine live-loop oder 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: *Verwende nie die gleiche Variable in verschiedenen live-loops oder threads*. Beispielsweise gibt der folgende Code die Liste immer richtig sortiert aus, da jede live-loop ihre 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 möchte man manchmal Werte zwischen verschiedene Threads teilen: zum Beispiel die aktuelle Tonart, das aktuelle oder den aktuellen Synth. In einem solchen Fall verwendet man in Sonic Pi spezielle System-Kommandos mit Hilfe der Funktionen `get` und `set, die wir später in Kapitel besprechen.

en: 5.7 Thread Synchronisation
de: 5.7 Thread Synchronisierung

en: Thread Synchronisation
de: Synchronisation von Threads

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: Bald wirst Du ausreichend vertraut damit sein, live mit einer Anzahl von gleichzeitig ablaufenden Funktionen und Threads zu coden. Dann wirst Du bemerken, dass es ziemlich leicht ist, einen einzelnen Thread mit einem Fehler zum Abbruch zu bringen. Das ist nicht weiter schlimm, da Du den Thread mit einem Klick auf `Ausführen` ja einfach neu starten kannst. Wenn Du den Thread aber neu startest, dann läuft er nicht mehr zusammen mit den anderen so wie vorher, er ist nun *aus dem Takt* mit den ursprünglichen 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: Wir haben zuvor erwähnt, dass neue Threads beim Start mit `in_thread` alle ihre Einstellungen vom Eltern-Thread erben. Das schließt auch die aktuelle Zeit mit ein. Das bedeutet, dass Threads bei gleichzeitigem Start immer miteinander im Takt sind.

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 alleine startest, spielt er in seinem eigenen Takt, der höchstwahrscheinlich nicht mit irgendeinem der anderen laufenden Threads zusammenpasst.

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 hat 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, regelmäßige Signale an alle anderen Threads mit einem Taktgeber zu versenden. Normalerweise sind die anderen Threads an solchen Signale nicht interessiert und werden sie ignorieren. Mit der `sync`-Funktion kann man jedoch erreichen, dass ein anderer Thread auf diesen Taktgeber hört.

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: Eine wichtige Sache, derer man sich bewusst sein sollte: `sync` ist so ähnlich `sleep`, weil es den aktuellen Thread für eine bestimmte Zeit anhält und dieser so lange nichts tut. Allerdings sagt man mit `sleep`, wie lange man warten möchte, während man bei `sync` nicht weiß, wie lange gewartet wird - denn `sync` wartet auf das nächste `cue` eines anderen Threads; das kann kürzer oder länger dauern.

en: Let's explore this in a little more detail:
de: Sehen wir uns das etwas genauer 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 davon arbeitet wie ein Metronom; er spielt nichts, aber sendet bei jedem Schlag ein `:tick`-Taktgebersignal. Der zweite Thread synchronisiert sich mit den `tick`-Signalen, und wenn er eins davon erhält, übernimmt er die Zeit 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: Als Ergebnis hören wir den `:drum_heavy_kick` Sample genau dann, wenn der andere Thread ein `:tick`-Signal sendet, auch dann, wenn beide Threads gar nicht zur selben Zeit gestartet sind:

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: Dieser freche (zweite) Aufruf von `sleep` würde eigentlich den zweiten Thread gegenüber dem ersten aus dem Takt bringen. Weil wir aber `cue` und `sync` verwenden, synchronisieren wir beide Threads automatisch und umgehen dabei, dass beide in der Zeit auseinanderfallen.

en: Cue Names
de: Cue benennen

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 `cue`-Signale benennen, wie Du willst - nicht nur mit `:tick`. Du musst nur sicherstellen, dass irgendein anderer Thread sich mit eben diesem Namen synchronisiert - ansonsten wartet der zweite Thread endlos (oder jedenfalls bis Du den `Stopp`-Button klickst).

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

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 `cue`-Hauptschleife, die auf Zufallsbasis einen von drei Namen des Taktgebers `:foo`, `:bar` oder `:baz` aussendet. Wir haben auch drei Schleifen-Threads, die jeder für sich mit einem der Namen synchronisiert werden und dann jeweils ein anderes Sample spielen. Im Endeffekt hören wir bei jedem halben Schlag einen Klang, da jeder der `sync`-Threads auf Zufallsbasis mit dem `cue`-Thread synchronisiert ist, und sein Sample spielt, wenn er dran ist.

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: Die `sync`-Threads sitzen einfach da und warten auf ihren nächsten `cue`.

en: 6 FX
de: 6 Effekte

en: Studio FX
de: Studio-Klangeffekte

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: Es lohnt sich, mit Sonic Pi Deine Klänge mit Studio-Effekten zu verändern - Du wirst sehen, wie spannend das ist und wieviel Spaß das macht. Zum Beispiel kannst Du zu Teilen Deiner Komposition Hall-Effekte ("Reverb") hinzufügen. Oder etwas Echo ("Echo"). Oder vielleicht möchtest Du Deine Bassmelodien verzerren ("Distortion") oder schwabbeln 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: Mit Sonic Pi kannst Du sehr mächtige Klangeffekte auf ganz einfache Art einfügen. Du kannst sie sogar miteinander verketten oder sie ineinander verschachteln (zum Beispiel könntest Du einen Ton zuerst verzerren, dann Echo hinzufügen und zum Schluss noch etwas Hall). Jeder einzelne Effekt lässt sich mit Parametern steuern (ganz ähnlich wie auch Synths und Samples). Du kannst sogar die Parameter eines Klangeffektes ändern, während der Effekt läuft. Zum Beispiel könntest Du den Halleffekt Deiner Bassmelodie während des Stückes langsam anheben...

en: Guitar Pedals
de: Gitarreneffekte

en: If all of this sounds a bit complicated, don't worry. Once you play around with it a little, it will all become quite clear. Before you do though, a simple analogy is that of guitar FX pedals. There are many kinds of FX pedals you can buy. Some add reverb, others distort etc. A guitarist will plug his or her guitar into one FX pedal - i.e. distortion -, then take another cable and connect (chain) a reverb pedal. The output of the reverb pedal can then be plugged into the amplifier:
de: Wenn sich das alles etwas kompliziert anhören sollte, keine Sorge! Spiel ein bisschen mit den Effekten herum und es wird Dir ganz schnell alles viel einfacher vorkommen. Bevor Du loslegst, könnte dieser kleine Vergleich nützlich sein: Die Effekte in Sonic Pi funktionieren so ähnlich wie Gitarreneffektpedale. Es gibt eine Vielzahl von solchen Effektpedalen zu kaufen. Manche Gitarristen benutzen gerne Hall-Effekte ("Reverb"), andere bevorzugen ein Verzerrerpedal ("Distortion"), etc. Als Gitarrist kann man einfach seine Gitarre an ein Effektpedal anstecken - z.B. "Distortion" - und dann mit einem weiteren Kabel noch ein Hallpedal anhängen. So entsteht eine Kette von Effekten. Das Ausgangssignal des Hall-Effektpedals am Ende der Kette kann man dann in einen Verstärker leiten:

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

en: This is called FX chaining. Sonic Pi supports exactly this. Additionally, each pedal often has dials and sliders to allow you to control how much distortion, reverb, echo etc. to apply. Sonic Pi also supports this kind of control. Finally, you can imagine a guitarist playing whilst someone plays with the FX controls whilst they're playing. Sonic Pi also supports this - but instead of needing someone else to control things for you, that's where the computer steps in.
de: Dies nennt man "Effektverkettung". Und genau das kannst Du mit Sonic Pi machen. Jedes Effektpedal hat normalerweise einige Drehknöpfe und Schalter, mit denen man exakt steuern kann, wieviel Verzerrung, Hall, oder Echo erzeugt werden soll. Und eines noch zum Schluss: Du kannst Dir sicher vorstellen, dass ein Gitarrist mit Gitarrespielen beschäftigt sein könnte, während jemand anderes die Effekte steuert. Das ist auch bei Sonic Pi möglich - aber anstatt auf jemand anderen dafür angewiesen zu sein, steht für Dich Dein Computer am Effektmischer und hilft Dir.

en: Let's explore FX!
de: Aber jetzt ist es höchste Zeit, die Effektfunktionen auszuprobieren!

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

en: Adding FX
de: FX 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 genauer an: Hall und Echo. Wir werden lernen, wie diese Effekte zu benutzen sind, wie man ihre Parameter steuern kann, und wie man sie verketten kann.

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 FX-System von Sonic Pi benutzt sogenannte Code-Blocks. Falls Du Abschnitt 5.1 des Tutorials noch nicht gelesen hast, sieh es Dir doch kurz an und kehre dann hierher zurück.

en: Reverb
de: Hall ("Reverb")

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, fügen wir `with_fx :reverb` als Spezialcode zu unserem bestehenden Code-Block hinzu. 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: Wenn Du nun diesen Code-Block abspielst, wirst Du ihn mit Hall hören. Hört sich gut an, nicht wahr! Mit Hall-Effekt hört sich alles immer ziemlich gut an.

en: Now let's look what happens if we have code outside the do/end block:
de: Aber was passiert, wenn wir den Code außerhalb des do/end-Code-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: Wie Du sicher bemerkt hast, wird nun die letzte Note (55) nicht mehr mit Hall-Effekt abgespielt. Der Grund dafür ist, dass sich die Note *außerhalb* des do/end Code-Blocks befindet und deshalb unsere Anweisung zum Hall-Effekt für sie nicht mehr gültig ist.

en: Similarly, if you make sounds before the do/end block, they also won't be captured:
de: Wenn Du Noten vor dem do/end-Code-Block einfügst, verhält es sich ganz ähnlich, und sie werden ebenfalls ohne Hall-Effekt abgespielt:

en: There are many FX to choose from. How about some echo?
de: Es stehen noch viele weitere Effekte zur Auswahl. Wie wäre es zum Beispiel 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: Die FX-Blocks von Sonic Pi sind besonders vielfältig einsetzbar, denn sie lassen sich über Parameter steuern. Genauso wie die Befehle `play` und `sample`, die wir ja schon kennen. Ein spannender Echo-Parameter ist zum Beispiel `phase:`. Dieser Parameter stellt die Dauer des Echos in Schlägen dar. Versuchen wir, das Echo etwas langsamer zu machen:

en: Let's also make the echo faster:
de: Und jetzt lass uns das Echo wieder schneller machen:

en: Let's make the echo take longer to fade away by setting the `decay:` time to 8 beats:
de: Wie wäre es nun mit einem langsam ausschwingenden Echo? Wir können dafür einfach den `decay:`-Wert auf 8 Schläge verlängern:

en: Nesting FX
de: FX 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: Interessant wird es, wenn wir die FX-Blocks ineinander verschachteln. So kannst Du ganz unterschiedliche FX leicht verketten. Wie wäre es zum Beispiel damit, einen Code-Block zuerst mit Echo und dann mit Hall zu versehen? Das geht ganz einfach, Du musst nur die beiden Code-Blocks ineinander verschachteln:

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 so vor, als ob die erzeugten Klänge von innen nach außen fließen würden. Der erzeugte Klang des innersten do/end-Code-Blocks (zum Beispiel `play 50`) wird zuerst durch den Echo-FX-Block gesendet, und danach noch durch den Hall-FX-Block.

en: We may use very deep nestings for crazy results. However, be warned, the FX can use a lot of resources and when you nest them you're effectively running multiple FX simultaneously. So be sparing with your use of FX especially on low powered platforms such as the Raspberry Pi.
de: Mit vielschichtigen Verschachtelungen kannst Du verrückte Ergebnisse ganz einfach erzielen. Aber sei vorsichtig, weil FX viel Rechenkraft des Computers verbraucht, besonders dann, wenn Du mehrere FX zugleich benutzt. Sei also etwas sparsam mit Deinen FX, wenn Du mit eher rechenschwachen Geräten wie dem Raspberry Pi arbeitest.

en: Discovering FX
de: Weitere FX 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 FX mit, die Du ausprobieren kannst. Eine komplette Liste findest Du im Hilfe-Fenster, wenn Du dort links auf 'FX' klickst. Hier sind einige meiner Favoriten:

en: Now go crazy and add FX everywhere for some amazing new sounds!
de: Nun drehe so richtig auf und füge überall in deinem Code Audioeffekte hinzu. Du wirst fantastische Sounds erschaffen!

en: 6.2 FX in Practice
de: 6.2 Anwenden von Soundeffekten

en: FX in Practice
de: Anwenden von Soundeffekten

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: Auf den ersten Blick mögen die Effekte von Sonic Pi sehr einfach aussehen, aber in Wirklichkeit sind sie höchst komplexe Gebilde. Ihre scheinbare Einfachheit verleitet manche dazu, zu viele FX in ihre Projekte einzubauen. Das kann durchaus Spaß machen, wenn Du über einen sehr starken Computer hast. Aber falls Du - so wie ich - einen einfachen Raspberry Pi zum Musikmachen benutzt, musst Du darauf achten, die Maschine nicht zu überlasten. Nur so kannst Du sicher gehen, dass Sonic Pi ordentlich funktioniert und im Takt bleibt.

en: Consider this code:
de: Betrachte den folgenden Code:

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: Hier spielen wir die Note 60 mit sehr kurzem Ausklang ("release"), und erzeugen somit einen kurzen Ton. Wir wollen außerdem einen Hall-Effekt, also haben wir den nötigen "reverb"-Block darum herum geschrieben. Bisher 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: Sehen wir uns genauer an, was der Code hier macht. Zuerst einmal haben wir einen Loop, und wie wir ja schon wissen wird alles, was innerhalb der Endlosschleife geschrieben ist, für immer und ewig wiederholt. Außerdem haben wir einen `with_fx:`-do/end-Block. Das bedeutet, dass bei jeder Wiederholung des Loops ein neuer Hall-Effekt erzeugt wird. Das ist so, als ob wir jedes Mal, wenn wir eine Gitarrenseite zupfen, ein neues Pedal an die Effektkette hängen würden. Es ist ja ganz nett, das wir das machen können, aber es ist möglicherweise nicht das, was wir eigentlich wollen. Ein kleiner Raspberry Pi wird an diesem Code schwer zu arbeiten haben. Die `with_fx:`-Funktion erledigt die ganze Arbeit, bei jeder Wiederholung des Loops den Hall-Effekt zu erzeugen, dann zu warten, und dann den Effekt wieder zu entfernen, aber insgesamt werden dabei wertvolle CPU Ressourcen verbraucht.

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 ähnlichen Code-Block schreiben, bei dem unser Gitarrist nur ein einzelnes Hall-Effektpedal zur Klangerzeugung benutzt? Ganz 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: Nun haben wir unseren Loop ins Innere des `with_fx:`-Blocks gesetzt. So wird nur noch ein einziger Hall-Effekt erzeugt und auf alle Noten im Loop angewandt. Dieser Code-Block ist viel effizienter und wird auf jedem Raspberry Pi gut funktionieren.

en: A compromise is to use `with_fx` over an iteration within a loop:
de: Als Kompromiss könnten wir `with_fx:` auch als Iteration innerhalb eines Loops schreiben:

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 des Loops geholt, und der Code erzeugt jetzt nur noch einen Hall-Effekt alle 16 Noten.

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 Ausdruck taucht so häufig auf, dass `with_fx` dafür eine Option bereitstellt; Du musst also nicht den Block `16.times` hinschreiben:

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, `reps: 16` und `16.times do` verhalten sich indentisch. `reps: 16` wiederholt den Code im `do/end`-Block 16-mal, sodass Du beide Ausdrücke untereinander austauschen kannst; nimm' einfach den, der Dir am besten gefällt.

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: Denk daran, man kann nichts falsch machen, dafür aber unendlich viel ausprobieren! Jedes Mal wird es sich ein bisschen anders anhören, und jeweils mehr oder weniger gut funktionieren. Experimentiere also so viel wie möglich, bis Du gefunden hast, was am besten funktioniert und den Einschränkungen Deines Computers am besten gerecht wird.

en: 7 Control
de: 7 Steuerung

en: Controlling running sounds
de: Laufende Sounds steuern

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 angeschaut, wie man Synths und Samples starten und ihre Standard-Einstellungen wie Lautstärke, Position im Stereofeld, Hüllkurven und so weiter anpassen kann. Jeder abgespielte Ton ist im Grunde genommen ein eigener Klang mit seinen eigenen Optionen für seine Abspieldauer.

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 cool, wenn man diese Opts verändern könnte - während der Ton noch abgespielt wird? Etwa so, wie Du beim Gitarrespielen an einer noch schwingende Saite ziehen kannst?

en: You're in luck - this section will show you how to do exactly this.
de: Glück gehabt - dieses Kapitel wird Dir genau das zeigen.

en: 7.1 Controlling Running Synths
de: 7.1 Laufende Synths steuern

en: Controlling Running Synths
de: Laufende Synths steuern

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 Sounds und Effekte zu starten. Mit Sonic Pi kannst Du aber auch laufende Klänge steuern und verändern. Um das zu tun, speichern wir die 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 run-local Variable `s`. Sie repräsentiert einen Synth, der die Note 60 spielt. Beachte, dass diese Variable eine *lokale* ist - Du kannst nicht von anderen Runs, wie beispielsweise Funktionen, auf sie zugreifen.

en: Once we have `s`, we can start controlling it via the `control` function:
de: Sobald wir die Referenz in der Variable `s` haben, können wir den Synth mit Hilfe 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 ist hier, dass wir nicht vier verschiedene Synths starten - wir starten einen einzigen und ändern danach dreimal die Tonhöhe, 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. Das erlaubt Dir, Dinge wie `amp:`, `cutoff:` oder `pan:` zu kontrollieren.

en: Non-controllable Options
de: Nicht-kontrollierbare 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 Opts lassen sich nach dem Start des Synths nicht mehr verändern. Das trifft auf alle ADSR-Hüllkurven-Parameter zu. Welche Opts kontrollierbar sind, kannst Du in der Dokumentation im Hilfe-System herausfinden. Parameter, die mit *Can not be changed once set* markiert sind, lassen sich nach dem Synth-Start nicht mehr verändern.

en: 7.2 Controlling FX
de: 7.2 Effekte steuern

en: Controlling FX
de: Effekte steuern

en: It is also possible to control FX, although this is achieved in a slightly different way:
de: Man kann auch Effekte steuern, allerdings geht 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: Statt eine Variable zu verwenden, nutzen wir die senkrechten Striche des do/end-Blocks. Innerhalb der Striche `|`, 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 Optionen

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: Vielleicht ist Dir beim Erforschen der Synth- und FX-Opts aufgefallen, dass manche davon mit `_slide` enden. Vielleicht hast Du sie sogar ausprobiert und keine Auswirkung bemerkt. Das liegt daran, dass dies keine normalen Opts sind. Diese besonderen Opts funktionieren nur dann, wenn Du Synths wie im letzten Kapitel beschrieben steuerst.

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 unmittelbar bei jedem Aufruf von `control` ändert. Vielleicht möchtest Du aber, dass die Tonhöhe sich gleitend zwischen den Aufrufen verändert. Um dort, wo wir die Opt `note:` verwenden, gleitende Übergänge hinzuzufügen, nutzen wir die `note_slide:`-Opt des Synths:

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: Jetzt 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 angegeben hast, bleibt er bestehen und wird jedesmal genutzt, wenn Du den entsprechenden Parameter steuerst. Um das Gleiten auszuschalten, 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: Genauso ist es möglich, Effekt-Opts gleiten zu lassen:

en: Now have fun sliding things around for smooth transitions and flowing control...
de: Und jetzt lass die Dinge ein wenig gleiten. Viel Spaß mit den weichen Übergängen...

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 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 eine Sache darstellen oder verwenden. Es könnte beispielsweise nützlich sein, sich eine Reihe von Noten zu merken und sie dann nacheinander abzuspielen. In Programmiersprachen sind Datenstrukturen genau für diesen Zweck da.

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 sind viele aufregende und exotische Datenstrukturen für Programmierer verfügbar - und es werden immer noch neue erfunden. Für unsere Zwecke benötigen wir vorerst jedoch 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 gleich im Detail anschauen. 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 anschauen - die Liste. Wir hatten schon einmal in dem Abschnitt über Randomisierung kurz mit ihr zu tun, als wir die zu spielenden Noten zufällig aus einer Liste auswählten:

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 man Akkorde und Skalen mit Listen darstellen kann. Rufen wir uns wieder in Erinnerung, wie wir einen Akkord spielen könnten. Ohne `sleep` werden alle Töne zur gleichen Zeit abgespielt:

en: Let's look at other ways to represent this code.
de: Wir können diesen Code aber auch anders schreiben.

en: Playing a List
de: Eine Liste abspielen

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 es, alle Noten aus einer Liste zu spielen: `[52, 55, 59]`. Unsere freundliche Funktion `play` ist schlau genug, um zu wissen, wie man eine Liste von Noten abspielt. Versuche es einmal:

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: Prima, das kann man schon viel besser lesen. Das Abspielen einer Liste hindert uns aber nicht daran, die gewohnten Parameter zu verwenden:

en: Of course, you can also use the traditional note names instead of the MIDI numbers:
de: Natürlich kannst Du auch die traditionellen Namen der Noten 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 bisschen Musiktheorie gelernt haben, erkannten den Akkord vielleicht: Es ist *E-Moll* in der dritten Oktave.

en: Accessing a List
de: Listenzugriffe

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: Sehr nützlich an Listen ist, dass man auf die enthaltenen Informationen zugreifen kann. Das klingt vielleicht seltsam, aber es ist nicht komplizierter als beispielsweise das Öffnen eines Buches auf der Seite 23. Eine Liste fragt man einfach "Was ist das Element am Index 23?". Du musst Dir nur eine Merkwürdigkeit merken: Beim Programmieren beginnt man beim Zählen der Listenelemente normalerweise mit 0 statt mit 1.

en: With list indexes we don't count 1, 2, 3... Instead we count 0, 1, 2...
de: Listenindizes 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: Wir schauen uns das etwas genauer an. Nehmen wir diese Liste:

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: Nicht besonders beängstigend. Was ist das zweite Element dieser Liste? Natürlich, das ist `55`. Das war einfach. Jetzt versuchen wir, ob wir nicht 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: Falls Du so etwas noch nie gesehen hast, mag das ein bisschen seltsam wirken. Aber vertrau mir, das ist nicht schwierig zu durchschauen. Die Zeile oben besteht aus drei Teilen: Dem Wort `puts`, unserer Liste `52, 55, 59` und unserem Index `[1]`. Zunächst sagen wir `puts`, damit Sonic Pi die Antwort für uns ins Protokoll schreibt. Danach übergeben wir unsere Liste und am Ende den Index, mit dem wir nach dem zweiten Element der Liste fragen. Den Index müssen wir mit eckigen Klammern umschließen, und da wir bei `0` zu zählen beginnen, ist der Index des zweiten Elements `1`. Wie hier unten:

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 Code `puts [52, 55, 59][1]` auszuführen, dann wirst Du sehen, dass `55` im Protokoll erscheint. Ändere den Index `1` in einen anderen, probiere längere Listen aus und denke darüber nach, wie Du Listen in Deinem nächsten Code-Jam verwenden könntest. Überlege dir zum Beispiel, welche Strukturen aus der Musik man als eine Reihe von Zahlen interpretieren könnte...

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 kann Dir den Namen eines Akkords in eine Liste seiner Töne übersetzen. Versuche es selbst:

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: Jetzt tut sich was. Das sieht doch schon viel schöner aus als einfache Listen (und ist für andere viel einfacher lesbar). Welche Akkorde kennt Sonic Pi noch? Naja, *viele*. Probier mal ein paar von diesen aus:

en: We can easily turn chords into arpeggios with the function `play_pattern`:
de: Um Akkorde einfach in Arpeggios umzuwandeln, können wir die Funktion `play_pattern` verwenden:

en: Ok, that's not so fun - it played it really slowly. `play_pattern` will play each note in the list separated with a call to `sleep 1` between each call to `play`. We can use another function `play_pattern_timed` to specify our own timings and speed things up:
de: Ok, das war nichts besonderes - das ging wirklich langsam. `play_pattern` spielt jede Note in der Liste hintereinander, getrennt durch Aufrufe von `sleep 1` ab. Wir können die Funktion `play_pattern_timed` verwenden, um unsere eigenen Zeitdauern zu verwenden und das Ganze zu beschleunigen:

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 Dauern übergeben; Sonic Pi verwendet diese nacheinander und wiederholt sie solange wie notwendig:

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: 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 kennt alle möglichen Tonleitern. Wie wäre es mit einer C3-Dur-Skala?

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

en: How about all the notes in a pentatonic scale?
de: Und wie wär's mit allen Noten einer pentatonischen Tonleiter?

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, eine zufällige Auswahl auf etwas von Bedeutung einzugrenzen. Spiele einmal mit diesem Beispiel, das zufällige 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 den `Lang`-Button ganz auf der linke Seite dieses Tutorials und wähle entweder `chord` oder `scale` aus der API-Liste. Scrolle im Hauptfenster herunter, bist Du eine lange Liste von Akkorden oder Skalen findest.

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 interessante Spielart von normalen Listen sind Ringe. Wenn Du ein bisschen Programmiererfahrung hast, könntest Du Ringspeicher (engl. „Ring Buffer“) oder Ring-Arrays kennen. Wir nennen die hier nur Ring – das ist kurz und einfach.

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, dass wir Elemente aus einer Liste über den Index 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? Offensichtlich gibt es kein Element mit dem Index 100, da die Liste nur drei Elemente enthält. Also gibt Sonic Pi `nil` zurück, was "nichts" bedeutet.

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 vor, einen Zähler wie den aktuellen Takt zu haben, der kontinuierlich wächst. Lass uns so einen Zähler und unsere Liste anlegen:

en: We can now use our counter to access a note in our list:
de: Jetzt können wir mit unserem Zähler auf eine Note in unserer Liste zugreifen:

en: Great, we got `52`. Now, let's increment our counter and get another note:
de: Super, da kam `52` heraus. Jetzt erhöhen wir den Zähler (`inc`, die Abkürzung für englisch "to increment" = erhöhen) und bekommen damit eine neue Note:

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: Ok, jetzt kommen `55` und beim nächsten Mal `59` heraus. Wenn wir das jedoch jetzt noch einmal machen, werden wir aber nicht mehr genug Zahlen in unserer Liste haben und werden stattdessen `nil` zurück bekommen. Was wäre, wenn wir dann einfach wieder vom Anfang der Liste anfangen 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: Es gibt zwei Möglichkeiten, Ringe zu erzeugen. Die erste ist, die `ring` Funktion mit den gewünschten Elementen des Rings als Parameter zu verwenden:

en: Or we can take a normal list and convert it to a ring by sending it the `.ring` message:
de: Die zweite Möglichkeit ist es, eine normale Liste mit der Nachricht `.ring` zu einem Ring umzuwandeln:

en: Indexing Rings
de: Auf Ringelemente zugreifen

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 wir einen Ring haben, können wir ihn auf die gleiche Art wie eine Liste verwenden. Die einzige Ausnahme ist, dass Du Indizes verwenden kannst, die negativ oder größer als der Ringinhalt sind. Diese fangen dann wieder am Anfang an, um immer auf ein Element des Rings zu zeigen:

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: Angenommen, wir bilden die Nummer des aktuellen Takts in einer Variable ab. Diese Nummer können wir als Zugriffsindex für unseren Ring verwenden, um abzuspielende Note, Release-Zeiten oder andere sinnvolle Dinge, die wir in unserem Ring abgelegt haben, abzurufen.

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: Gut zu wissen: Die Listen, die von `scale` und `chord` zurückgegeben werden, sind Ringe. Du kannst also mit beliebigen Indizes auf sie zuzugreifen.

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 noch 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 ein, einen Startpunkt, einen Endpunkt und eine Schrittgröße zu definieren.

en: `bools` allows you to use `1`s and `0`s to succinctly represent booleans.
de: `bools` erlaubt Dir `1`er und `0`er als prägnante Darstellung boolscher Werte zu nutzen.

en: `knit` allows you to knit a sequence of repeated values.
de: `knit` erlaubt Dir, eine Abfolge wiederholter Werte zu "stricken" (engl. "to knit").

en: `spread` creates a ring of bools with a Euclidean distribution.
de: `spread` verteilt boolschen Werte mit dem Euklidischen Algorithmus in einem Ring.

en: Take a look at their respective documentation for more information.
de: Mehr Informationen zu diesen Funktionen findest Du in der entsprechenden Dokumentation.

en: 8.5 Ring Chains
de: 8.5 Ring-Ketten

en: Ring Chains
de: Ringe mit verketteten Kommandos

en: In addition to the constructors such as `range` and `spread` another way of creating new rings is to manipulate existing rings.
de: Zusätzlich zu den Konstruktoren wie `range` und `spread` können neue Ringe auch erzeugt werden, indem schon existierende manipuliert werden.

en: Chain Commands
de: Verkettete Kommandos

en: To explore this, take a simple ring:
de: Nimm' einen einfachen Ring, um das auszuprobieren:

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 die Reihenfolge umkehren wollen? Dann verwenden wir das verkettete Kommando `.reverse`, um den Ring umzudrehen:

en: Now, what if we wanted the first three values from the ring?
de: Was nun, wenn wir die ersten 3 Werte aus dem Ring haben möchten?

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

en: Multiple Chains
de: Mehrteilige 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: So haben wir schon viele Möglichkeiten neue Ringe zu erzeugen. Noch besser wird es, wenn Du diese Kommandos miteinander verkettest.

en: How about shuffling the ring, dropping 1 element and then taking the next 3?
de: Wie wäre es z. B. wenn Du den Ring mischst, das erste Element weglässt, und dann die nächsten 3 Elemente nimmst?

en: Let's take this in stages:
de: Gehen wir das Schritt für Schritt durch:

en: `(ring 10, 20, 30, 40, 50)` - our initial ring
de: `(ring 10, 20, 30, 40, 50)` - Dein Ring am Anfang

en: `(ring 10, 20, 30, 40, 50).shuffle` - shuffles - `(ring 40, 30, 10, 50, 20)`
de: `(ring 10, 20, 30, 40, 50).shuffle` - mischt - `(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)` - das erste Element weglassen - `(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)` - 3 Elemente nehmen - `(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: Siehst Du, wie wir eine lange Kette dieser Methoden einfach dadurch erzeugen können, dass wir sie *aneinander hängen*? Wir können das in jeder beliebigen Reihenfolge tun; damit haben wir viele unterschiedliche Möglichkeiten, neue Ringe aus schon 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 leistungsstarke und wichtige Eigenschaft. Sie sind unveränderlich (engl. immutable). Das heisst, dass die Verkettung von Methoden, von der wir hier sprechen, *die Ringe nicht verändert* sondern *neue Ringe erzeugt*. Du kannst also Ringe in verschiedenen Threads verwenden und sie mit verketteten Kommandos verändern, ohne dass derselbe Ring in einem anderen Thread verändert wird.

en: Available Chain Methods
de: Methoden, die verkettet werden können

en: Here's a list of the available chain methods for you to play with:
de: Hier kommt eine Liste der Methoden, die miteinander verkettet werden können:

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

en: `.sort` - creates a sorted version of the ring
de: `.sort` - stellt eine sortierte Version des Rings her

en: `.shuffle` - creates a shuffled version of the ring
de: `.shuffle` - liefert eine neu gemischte Version des Rings

en: `.pick(3)` - returns a ring with the results of calling `.choose` 3 times
de: `.pick(3)` - liefert einen Ring nachdem 3-mal `.choose` angewendet wurde

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

en: `.drop(3)` - returns a new ring with everything but the first 3 elements
de: `.drop(3)` - liefert einen neuen 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 neuen 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 neuen 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 neuen 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 ganzen Ring 3-mal

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

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

en: `.scale(2)` - returns a new ring with all elements multiplied by 2 (assumes ring contains numbers only)
de: `.scale(2)` - gibt einen neuen Ring zurück, der alle Elemente des ursprünglichen Rings mit 2 multipliziert enthält (Voraussetzung: Ring enthält nur Zahlen)

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: Die Verkettungsfunktionen mit Zahlenparametern können natürlich auch mit anderen Werten aufgerufen werden. Anstelle von `.drop(3)` kann man zum Beispiel `.drop(5)` aufrufen, um die ersten fünf Elemente wegfallen zulassen.

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: So, und jetzt wird es aufregend! Mit Sonic Pi kannst Du den Code für Deine Musik live schreiben und verändern. Du kannst also während eines Auftritts mit Sonic Pi live Musik machen - wie mit einer Gitarre. Das Großartige daran ist, dass Du noch während des Komponierens sofort die Rückmeldung vom Publikum erhältst. Starte einen einfachen Loop und spiele daran herum, bis er genau richtig klingt. Der größte Vorteil ist aber, dass Du Sonic Pi bei einem Gig mit auf die Bühne nehmen 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, mit denen Du Deine Kompositionen von statischem Code in rasante 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, nun können wir wirklich Spaß haben. In diesem Abschnitt nutzen wir alles, was wir bisher in diesem Tutorial gelernt haben und zeigen Dir, wie Du Deine Kompositionen live aufführen und in Performances verwandeln kannst. Dazu benötigen wir vor allem drei Zutaten:

en: An ability to write code that makes sounds - CHECK!
de: Die Fähigkeit, Code zu schreiben, der Töne 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, (named) Threads 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, es kann also los gehen. Lass uns unsere ersten Sounds live coden. Zuerst brauchen wir eine Funktion, die den abzuspielenden Code enthält. Wir fangen ganz einfach an. Außerdem wollen wir diese Funktion in einer Schleife in einem Thread aufrufen:

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 aussieht, lies bitte noch einmal die Abschnitte über Funktionen und Threads durch. Wenn Du diese Dinge verstanden hast, wird es Dir nicht mehr sehr kompliziert vorkommen.

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: 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: Jetzt geht es richtig los. Während der Code *noch läuft*, ändere die 50 in eine andere Zahl, zum Beispiel 55, und drücke den `Ausführen`-Button erneut. Woah! Es hat sich verändert! Live!

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 Funktion noch einmal, ändere die Note und die Pausenzeit. Wie wäre es damit, ein `use_synth`-Statement einzufügen? Ändere die Funktion zum Beispiel in folgenden Code:

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 aufpeppen. Anstatt immer wieder die gleiche Note zu spielen, versuche es einmal mit einem Akkord:

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 zum Schluss noch ein Schlagzeug dazu:

en: Now things are getting exciting!
de: So langsam wird das hier alles viel spannender!

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: Bevor Du jetzt aufspringst und mit Funktionen und Threads live codest, solltest Du lieber erst einmal eine Pause machen und das nächste Kapitel über den `live_loop` lesen. Denn dieser wird für immer verändern, wie Du in Sonic Pi programmierst...

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, dieses Kapitel des Tutorials ist ein Juwel. Wenn Du nur einen Abschnitt lesen würdest, sollte es dieser sein. Mit `live_loop` kannst Du genau das, was Du im letzten Abschnitt gelernt hast, viel einfacher und mit weniger Code tun.

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, mit Sonic Pi zu jammen.

en: Let's play. Write the following in a new buffer:
de: Also los. 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 den `Ausführen`-Button. Du hörst zu jeder Schlagzeit ein einfaches Piepen. Kein besonderer Spaß. Drücke aber noch nicht den `Stopp`-Button. Ändere die `60` in `65` und drücke wieder `Ausführen`.

en: Woah! It changed *automatically* without missing a beat. This is live coding.
de: Whoa! Es hat sich *automatisch* verändert, ohne einen Takt 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 jetzt nicht ein wenig bassiger machen? Verändere Deinen Code, während er abläuft:

en: Then hit Run.
de: Dann drücke `Ausführen`.

en: Let's make the cutoff move around:
de: Lass uns den Cut-Off ein wenig bewegen:

en: Hit Run again.
de: Drücke wieder `Ausführen`.

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

en: Change the note from `e1` to `c1`:
de: Ändere den Ton von `e1` nach `c1`:

en: Now stop listening to me and play around yourself! Have fun!
de: Und jetzt höre auf, mir zuzuhören. 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: Schau 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 sicherstellt, 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 können nie zwei Live-Loops mit dem selben Namen gleichzeitig laufen*.

en: This means that if we want multiple concurrently running live loops, we just need to give them different names:
de: Wir müssen also unterschiedliche Namen vergeben, damit wir mehrere gleichzeitig laufende Live-Loops spielen können:

en: You can now update and change each live loop independently and it all just works.
de: Jetzt kannst Du 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 im Abschnitt über Thread-Synchronisation bereits angeschaut haben. In jedem Durchlauf des Live-Loops generiert er ein neues `cue`-Event mit dem Namen des Loops. Anhand dieser Cues können wir für unsere Loops mit `sync` sicherstellen, dass sie zueinander synchron laufen, ohne dass wir das Abspielen zwischendurch stoppen 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: Jetzt versuchen wir, das Timing zu korrigieren ohne den Loop zu stoppen. Zuerst reparieren wir den Loop `:foo`, indem wir die Sleep-Dauer zu einem Faktor von 1 machen - dafür funktioniert zum Beispiel `0.5`:

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 hörst schon, dass die Beats nicht so recht zusammenpassen. Der Grund dafür ist, dass diese Loops *out of phase* sind. Das können wir reparieren, indem wir einen Loop mit dem anderen synchronisieren:

en: Wow, everything is now perfectly in time - all without stopping.
de: Wow, jetzt passt alles genau zusammen - und das, ohne dass wir die Loops anhalten mussten.

en: Now, go forth and live code with live loops!
de: Jetzt fangt an und coded live in Live-Loops!

en: 9.4 Ticking
de: 9.4 Ticks

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: Beim Live-Coding wirst Du in Deinen Loops sehr oft Ringe verwenden. Aus einem Ring wirst Du Noten für Melodien, Pausen für Rhythmen, Akkordfolgen, Klangvariatonen und ähnliches entnehmen.

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: Das Tick-System ist ein *sehr* praktisches Werkzeug, um in einem `live_loop` mit Ringen zu hantieren. Du kannst damit einen *Ring durchticken*. Hier ein Beispiel:

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: In diesem Beispiel tickt der Code einmal jede Note der pentatonischen E3-Moll-Tonleiter durch. Dafür fügst Du einfach ein `.tick` hinter der Tonleiter-Deklaration an. Dieser Tick gilt nur für diese Live-Loop und jede Live-Loop kann seinen eigenen, unabhängigen Tick haben:

en: You can also call `tick` as a standard fn and use the value as an index:
de: Du kannst auch den aktuellen Tick mit der Standard-Funktion `tick` 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 kannst Du benutzen, wenn Du aufwändigere Dinge machen möchtest; oder wenn du Ticks für andere Dinge verwenden möchtest als Werte aus einem Ring anzusteuern.

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: Die Magie des Ticks ist, dass er sich nach jedem Aufruf erhöht, so dass Du bei der nächsten Verwendung auch den nächsten Tick bekommst. In den Beispielen findest Du einige Sonic-Pi-Codes, die `.tick` verwenden, schau sie Dir mal näher an. Manchmal willst Du aber den aktuellen Tick benutzen, *ohne dass er gleich um einen Wert weiter tickt*. Dafür gibt es die `look`-Funktion. Du kannst sie wie zuvor mit `look` als Funktion aufrufen oder mit `.look` an einen Ring anfügen.

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: Gelegentlich wirst Du auch mal mehr als einen Tick pro Live-Loop brauchen. Gib den Ticks dafür Namen:

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 markiert ein Tick die Position in der Tonleiter, ein zweiter Tick wählt die Pausenwerte. Beide Ticks befinden sich im gleichen Live-Loop, also geben wir ihnen zur Unterscheidung eindeutige Namen. Du kennst das Prinzip schon von den Live-Loops - einfach ein `:` gefolgt vom Namen. Im Beispiel heißt der eine Tick `:foo` und der andere `:bar`. Willst Du die Tick-Werte mit `look` nur abfragen, musst Du ebenso den Namen nennen.

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: Mit Ticks kannst Du viele großartige Dinge machen, aber versuche nicht, gleich alles in diesem Kapitel zu lernen und anzuwenden. Für den Anfang reicht es völlig, wenn Du nur durch einen Ring durchtickst und das Prinzip kennenlernst. Damit kannst Du in Deinen `live_loop`s schon eine Menge anfangen.

en: Take a look at the documentation for `tick` where there are many useful examples and happy ticking!
de: Schau Dir die Dokumentation an, Du wirst dort viele praktische Beispiele entdecken. Viel Spaß beim Durchticken!

en: 10 Time State
de: 10 Zeitzustand (Time State)

en: Time State
de: Zeitzustand (Time State)

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 man *in verschiedenen threads or live-loops teilen möchte*. Beispielsweise möchte man die aktuelle Tonart, die Geschwindigkeit (BPM) oder sogar allerlei andere abstrakte Konzepte wie die aktuelle 'Komplexität'  teilen (die wiederum unterschiedlich in den verschiedenen Threads interpretiert werden könnte). Dabei möchten wir aber auch nicht auf die deterministischen Garantien von Sonic Pi verzichten. In anderen Worten: Wir möchten Code mit anderen teilen, aber sicherstellen, dass genau das abgespielt wird, was wir uns dabei gedacht haben. Am Ende des Kapitels 5.6. dieses Tutorials gingen wir kurz darauf ein, warum wir *Variablen nicht zwischen verschiedenen Threads teilen sollten", um nicht die Vorhersagbarkeit zu verlieren (aufgrund von Race Conditions).

en: Sonic Pi's solution to the problem of easily working with global variables in a deterministic way is through a novel system it calls Time State. This might sound complex and difficult (in fact, in the UK, programming with multiple threads and shared memory is typically a university level subject). However, as you'll see, just like playing your first note, *Sonic Pi makes it incredibly simple to share state across threads* whilst still keeping your programs *thread-safe and deterministic.*.
de: Sonic Pi's Lösung, um auf einfache Art mit globalen Variablen in einer verhersagbaren Weise zu arbeiten, ist das neuartige System, das wir "Time State" (Zeitzustand) genannt haben. Dies klingt erstmal komplex und schwierig (solche Themen werden normalerweise erst in der Universität gelehrt), allerdings wirst du erkennen, dass es Sonic Pi *unglaublich einfach macht, einen Zustand zwischen verschiedenen Threads zu teilen*, und dabei dennoch Programme zu schreiben, die *thread-safe und vorhersagbar" sind.

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 hat einen global Speicherbereich, der "Time State" genannt wird. Die beiden wesentliche Dinge, die man auf ihn an anwendet sind das Setzen von Informationen (Set) und das Holen von Information (Get).

en: To store information into the Time State we need two things:
de: Um Informationen innerhalb des Time States zu speichern, benötigen wir zwei Dinge:

en: the information we want to store,
de: die Information, die wir speichern möchten,

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: Wir möchten beispielsweise die Zahl `3000` unter dem Schlüsselnamen `:intensity` speichern. Dies können wir mit der `set` function erreichen:

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: Für den Schlüssel können wir jeden Namen verwenden, den wir möchten. Haben wir einmal einen Wert unter diesem Schlüsselnamen gespeichert, wird ein neuer `set` -Befehl diesen ü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üssel abgespeichert. Der letzte Befehl 'gewinnt', so dass die Zahl, die mit `:intensity` assoziert ist, die `3000` sein wird und somit die erste (1000) damit überschrieben wurde.

en: Get
de: Get (Abfragen des Werts)

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 wieder zu holen, benötigen wir nun unseren Schlüssel, den wir bei `set` verwendet haben, also in diesem Fall `:intensity`. We müssen jetzt einfach `get[:intensity]` aufrufen und bekommen dies im log angezeigt:

en: print get[:intensity] #=> prints 3000
de: print get[:intensity]  #=> prints 3000

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: Achte darauf, dass Aufrufe von `get` Informationen zurückgeben kann, die bei einem vorherigem Programm-Lauf gesetzt wurden. Wurde eine Information einmal mit Hilfe von `set` gespeichert, ist sie solange verfügbar bis sie entweder überschrieben wird (wie oben die  `1000` mit `3000`) 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 man auf sichere Art und Weise Informationen zwischen Threads und live-loops austauschen kann. Beispielsweise könnte eine live-loop Informationen bereitstellen, die die andere live-loop ausliest:

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 `get` und `set` bei Threads ist, dass sie immer das gleiche Ergebnis produzieren, wenn das Programm erneut gestartet wird. Versuch's einfach mal selbst und prüfe nach, ob die folgende Ausgabe im Log erscheint:

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 mal mehrere Male - du wirst sehen, dass das Ergebnis immer das Gleiche ist. Das bezeichnen wir als "deterministisches" Verhalten und das ist sehr wichtig, wenn wir unsere Musik an andere weitergeben möchten und sicher sein wollen, dass die Person, die die Musik anhört, genau das gleiche Ergebnis hören wird wie wir, die es erstellt haben (ähnlich wie das Spielen einer MP3 oder das Streamen von Musik).

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 gezeigt, wie die Nutzung von Variablen in verschiedenen Threads zu zufälligen Resultaten führen kann. Das verhindert wiederum die sichere Reproduktion von bestimmten Code wie diesem:

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 auf 
    ## gleiche Variable zugreifen).
    ##  
    ## Wenn Du den Code startest, siehst Du,
    ## dass die Liste 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: Schauen wir mal, wie wir `get` und `set` einsetzen können:

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 ein deterministisches Verhalten
    ## (trotz des gleichzeitigen Zugriff auf einen gemeinsamen Zustand) 
    ## mit Hilfe des Sonic Pi Time State Systems
    ##
    ## Wenn dieser Code gestartet wird,
    ## 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 zu dem Code ist, der die Variable zum Teilen der Information verwendet hat. Allerdings verhält er sich so, wie man es sich bei einem typischen Sonic Pi Code erwartet - *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 immer `get` und `set`, wenn Du Daten zwischen live-loops und Threads teilen möchtest anstatt Variablen zu verwenden.

en: 10.2 Sync
de: 10.2 Synchronisation (Sync)

en: Sync
de: Sync(hronisation)

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 Kapitel 5.7 beschäftigten wir uns mit den Funktionen `cue` und `sync, um Threads zu synchronisieren. Dort wurde allerdings nicht erklärt, was es mit dem Time State System auf sich hat, das diese Funktionalität zur Verfügung stellt. Tatsächlich ist `set` eine Variation von `cue` und baut auf die gleiche Kernfunktionalität auf, Informationen im Time State System zu hinterlegen. Zusätzlich ist `sync`so gestaltet, dass es einfach mit dem Time State funktioniert - es kann auf jegliche Information, die im Time State gespeichert ist, kann auch synchronisiert werden. Mit anderen Worten: wir synchronisieren auf Ereignisse, die im Time State gespeichert werden.

en: Waiting for Events
de: Warten auf Ereignisse (Events)

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 anschauen, wie man `sync`verwendet, 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 ':foo' event zum Time State hinzugefügt wird. Nach dieser Threaderstellung (Deklaration) schlafen wir für 2 beats und dann setzen wir mit 'set'-Befehl den ':foo'-Wert auf '1'. Diese Aktion 'releases' (beendet) den 'sync' und geht weiter zur nächsten Zeile, wo 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 and den Thread genau an dieser Stelle so lange blockiert, bis das Ereignis eingetreten ist. Zusätzlich erbt der (gesyncte) Thread die logische Zeite des anderen Threads, der ihn mit Hilfe von `set` oder `cue` getriggert (angestossen) hat. Das heißt, dass man durch dieses Verfahren auch die Zeit von zwei Threads synchronisieren kann.

en: Passing values into the Future
de: Übergabe von Werten in 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 den Wert '1', mit dem wir dann nichts gemacht haben. Diesen Wert können wir im Thread auch wieder abfragen ('get'), in dem wir den Befehl '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. Das bedeutet, dass nur Werte übergeben werden dürfen, die sich in der Zukunft nicht verändern können wie zum Beispiel "unveränderliche Zeichenketten" (immutable strings), Zahlen, Symbole oder eingefrorene Zeichenketten (frozen strings). Sonic Pi wirft einen Fehler, falls ein Wert verwendet wird, der nicht dieser Vorgabe entspricht.

en: 10.3 Pattern Matching
de: 10.3 Muster-Erkennung

en: Pattern Matching
de: Muster-Erkennung

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 Einlesen und Setzen von Informationen in den Zeitstatus ist es möglich, komplexere Tasten als einfache Symbole wie `:foo` und `:bar` zu verwenden. Sie können auch URL-Style-Strings wie `"/foo/bar/baz"` verwenden. Sobald wir mit Pfaden arbeiten, können wir die Vorteile von Sonic Pi's ausgeklügeltem Pattern-Matching-System nutzen, um `Get` und `Sync` mit `ähnlichen' statt `identischen' Pfaden zu nutzen. Schauen wir uns das mal an.

en: Match any path segment
de: Erkennen von Pfad-Segmenten

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

en: sync "/*/*/*"
de: sync  "/*/*/*"

en: This will match any Time State event with exactly three path segments, regardless of their names. For example:
de: Hiermit kann man auf jegliches Time State Ereignis syncen, dass aus exakt drei Pfadsegmenten besteht, unabhängig davon, was genau der Inhalt der Segmente ist. Schauen wir uns das an einem Beispiel an:

en: `cue "/eggs/beans/toast"`
de: `cue  "/eggs/beans/toast"`

en: `cue "/moog/synths/rule"`
de: `cue  "/moog/synths/rule"`

en: However, it will *not* match paths with fewer or more path segments. The following will not match:
de: Allerdings wird es nicht auf Ereignisse "matchen", die weniger oder mehr Pfad-Segmente hätten. Die folgenden würden nicht erkannt und damit kein Ereignis triggern:

en: `cue "/eggs"`
de: `cue  "/eggs"`

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

en: Matching partial segments
de: Erkennen von 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 zusätzlich zu einem Teilsegmentnamen ein `*` verwenden. Zum Beispiel: `"/foo/b*/baz"`passt auf jeden Pfad, der drei Segmente hat, von denen das erste `foo`, das letzte `baz` und das mittlere Segment alles sein können, was mit `b` beginnt. Also, es würde passen:

en: However, it wouldn't match the following:
de: Allerdings erkennt es nicht das Folgende:

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"`, das jedem 3-Segment `cue` oder `set` entspricht, wobei das erste Segment `foo` ist, das letzte `baz` ist und das mittlere Segment mit `zz` endet, wie `"cue "/foo/whizz/baz"`.

en: Matching Nested Path Segments
de: Erkennen von 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ß man nicht, wie viele Pfadsegmente man zuordnen möchte. In diesen Fällen kannst Du den mächtigen Doppelstern: `**` wie `"/foo/**/**/baz"` verwenden, der übereinstimmt:

en: Matching Single Letters
de: Erkennen von einzelnen Buchstaben

en: You can use the `?` character to match against a single char such as `"/?oo/bar/baz"` which will match:
de: Du kann das `?` verwenden, um auf ein bestimmtes einzelnes Zeichen zu erkennen. `"/?oo/bar/baz"` passt auf:

en: `cue "/goo/bar/baz"`
de: `cue  "/goo/bar/baz"`

en: `cue "/too/bar/baz"`
de: `cue  "/too/bar/baz"`

en: `cue "/woo/bar/baz"`
de: `cue  "/woo/bar/baz"`

en: Matching Multiple Words
de: Erkennen von mehrfachen Wörtern

en: Matching Multiple Letters
de: Erkennen von mehrfachen Zeichen

en: Combining Matchers
de: Kombinieren von Mustererkennungen

en: When calling `sync` or `get` you are free to combine matchers in any order you see fit to powerfully match any Time State event created by `cue` or `set`. Let's look at a crazy example:
de: Wenn du `sync` oder `get` aufrufst, kannst du Mustererkenner in beliebiger Reihenfolge kombinieren um jedes beliebige Time State Event, das durch `cue` oder `set` erzeugt wurde zu erkennen. Lass uns ein verrücktes Beispiel anschauen:

en: OSC Pattern Matching
de: OSC Mustererkennung

en: For those curious, these matching rules are based on the Open Sound Control pattern matching specification which is explained in detail here: http://opensoundcontrol.org/spec-1_0
de: Für die Neugierigen, diese Regeln zur Mustererkennung basieren auf der Open Sound Control Spezifikation zur Mustererkennung, die hier im Detail erklärt ist: http://opensoundcontrol.org/spec-1_0

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: Nachdem du es gemeistert hast Code in Musik umzuwandeln, fragst du dich vielleicht - was kommt als nächstes? Manchmal sind die Einschränkungen nur mit Sonic Pis Syntax und Soundsystem zu arbeiten aufregend und versetzen dich in eine neue kreative Lage. Manchmal jedoch ist es notwendig aus dem Programmcode in die echte Welt auszubrechen. 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 echten Welt in Sonic Pi Events 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 Zeitmodell und Semantik nutzen zu können um Objekte in der echten Welt zu kontrollieren und zu beeinflussen

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 stellt komplette Unterstützung für das MIDI Protokoll bereit, was es dir erlaubt deinen Live Code mit der echten Welt zu verbinden. Lass uns das weiter 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, wie man einen MIDI Controller verbindet, sodass er Ereignisse an Sonic Pi sendet, um unsere Synths und Töne zu kontrollieren. Nimm dir einen MIDI Controller, wie beispielsweise ein Keyboard oder eine Control Oberfläche und lass uns loslegen!

en: Connecting a MIDI Controller
de: Verbinde einen MIDI Controller

en: Receiving MIDI Events
de: Erhalte MIDI Ereignisse

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: Nachdem dein Gerät verbunden ist, empfängt Sonic Pi automatisch Events. Du kannst das selbst nachprüfen indem du dein MIDI Gerät bedienst und auf den Cue Logger unten rechts im Anwendungsfenster unterhalb des Logs schaust (wenn das nicht sichtbar ist gehe zu Einstellungen->Editor->Ein-/Ausblenden und aktiviere die 'Zeige cue Log' checkbox). Du wirst einen Datenstrom an Events 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 Datenstrom an Nachrichten wie diesen sehen kannst, hast du dein MIDI Gerät erfolgreich verbunden. Glückwunsch, lass uns schauen, was wir damit machen können!

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 Events sind in zwei Abschnitte unterteilt. Erstens gibt es den Namen des Events, wie `/midi:nanokey2_keyboard:0:1/note_on`  und zweitens gibt es die Werte des Events wie `[18, 62]`. Interessanter Weise sind das die zwei Dinge, die wir brauchen, um Informationen in Time State zu speichern. *Sonic Pi fügt eingegangene MIDI Events automatisch in Time State ein*. Das bedeutet du kannst auf den neuesten MIDI Wert mit `get` zugreifen und auch mit `sync` auf den nächsten MIDI Wert warten indem du alles was du in Abschnitt 10 dieses Tutorials gelernt hast nutzt.

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: Jetzt nachdem wir ein MIDI Gerät verbunden, seine Events im cue Log gesehen und entdeckt haben, dass unser Wissen über Time State alles ist, was wir zum Arbeiten mit Events brauchen, können wir anfangen Spaß zu haben. Lass uns ein einfaches MIDI Klavier 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, auch einiges Problematisches. Zuerst haben wir einfach einen `live_loop`, der für immer den Code zwischen dem `do`/`end` Block wiederholt. Das wurde in Abschnitt 9.2 eingeführt. Danach rufen wir `sync` auf, um auf das nächste Time State Event zu warten. Wir benutzen einen String, der die MIDI Nachricht repräsentiert, nach der wir suchen (welcher der selbe ist, wie der, der im cue Logger angezeigt wurde). Bemerke, dass dieser lange String von Sonic Pis Autovervollständigung vervollständigt wird, sodass du ihn nicht komplett von Hand eintippen musst. Im Log haben wir gesehen, dass es zwei Werte für jedes MIDI "note on" Event  gibt, also weisen wir das Ergebnis an zwei separate Variablen `note` und `velocity` zu. Schlussendlich lösen wir den `:piano` Synth aus 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 Code ein und ersetzte den sync Schlüssel mit einer Zeichenkette die deinem spezifischen MIDI Gerät entspricht und drücke Ausführen. Hey presto, du hast ein funktionierendes Klavier! Du bemerkt jedoch wahrscheinlich ein paar Probleme: Erstens sind alle Noten gleich laut, unabhängig davon, wie stark du das Klavier anschlägst. Das kann einfach behoben werden indem wir den velocity MIDI Wert nutzen und in eine Amplitude umwandeln. Nachdem MIDI einen Wertebereich von 0-127 hat müssen wir, um diese Zahl in einen Wert zwischen 0->1 zu konvertieren, nur 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 den Code und drücke erneut auf Ausführen. Jetzt wird der Anschlag des Klaviers berücksichtigt. Als nächstes lass uns diese ärgerliche 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 erfahren, warum sie da ist. Um alle Synths und FX auf einer Vielzahl an verschiedenen unterschiedlich starken CPUs gut getaktet zu halten, setzt Sonic Pi das Audio standardmäßig 0,5s *im voraus* an. (Beachte, dass diese zusätzliche Latenz über die fns `set_sched_ahead_time!` und `use_sched_ahead_time` konfiguriert werden kann). Diese 0,5s Latenz wird zu unseren `:piano` Synth Auslösern hinzugefügt, wie es bei allen Synths, die von Sonic Pi ausgelöst werden, passiert. Normalerweise möchten wir diese Latenz wirklich, weil sie bedeutet, dass alle Synths gut getaktet werden. Das ergibt jedoch nur Sinn bei Synths, die von Code durch `play` und `sleep` ausgelöst werden. In diesem Fall lösen wir den `:piano` Synth mit unserem externen MIDI Gerät aus und möchten daher nicht, dass Sonic Pi das Timing für uns kontrolliert. Wir können diese Latenz mit dem Befehl `use_real_time` ausschalten, welches die Latenz für den aktuellen Thread abschaltet. Das bedeutet, dass du den Echtzeitmodus für Live-Loops benutzen kannst, die ihr Timing durch `sync`en mit externen Geräten kontrollieren, und die normale Latenz für alle anderen Live-Loops behalten kannst. Schauen wir mal:

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 an, sodass er dem obigen Code entspricht und drücke erneut auf Ausführen. Jetzt haben wir ein Klavier mit niedriger Latenz und variablem Anschlag in nur 5 Zeilen programmiert. War das nicht einfach!

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, nachdem unsere MIDI Events direkt in den Time State gehen, können wir die `get` fn benutzen um den letzten gesehenen Wert zu erhalten. Das blockiert nicht den aktuellen Thread und gibt `nil` zurück, wenn es keinen Wert gibt (was du überschreiben kannst, indem du einen Standardwert übergibst - schaue in die Dokumentation für `get`). Erinnere dich, dass du `get` in jedem Thread zu jeder Zeit aufrufen kannst, um den letzten zutreffenden Time State Wert zu sehen. Du kannst sogar `time_warp` benutzen um in der Zeit zurück zu reisen und  `get` aufrufen um vergangene Events zu sehen...

en: Now You are in Control
de: Du hast jetzt 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 spannende ist jetzt, dass du jetzt die gleichen Code Strukturen benutzen kannst um MIDI Informationen von irgendeinem MIDI Gerät zu `sync`en und `get`en und mit den Werten tun kannst was auch immer du möchtest. Du kannst jetzt 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: Neben dem Empfang von MIDI-Events können wir auch MIDI-Events 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-Nachrichten wie z.B:

en: Pitch bend - `midi_pitch_bend`
de: Tonhöhenverä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 auch noch viele weitere MIDI-Meldungen – schau in der API-Dokumentation nach all den anderen Funktionen, die mit `midi_`anfangen.

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

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 verschiedenen `midi_*` Funktionen verhalten sich genauso wie `play` :

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 jede MIDI Nachricht an alle verbundenen Geräte auf allen MIDI Kanälen senden, sodass es einfacher ist, mit einem einzelnen verbundenen Gerät zu arbeiten, ohne etwas einstellen zu müssen. Allerdings kann es sein, dass ein MIDI Gerät Nachrichten auf verschiedenen Kanälen unterschiedlich handhabt (zum Beispiel könnte jede Note einen eigenen Kanal haben), oder Du möchtest mehr als ein MIDI Gerät anschließen. Bei etwas umfangreicheren Setups, möchtest du wahrscheinlich genauer bestimmen können, welches Gerät welche Nachricht auf welchem Kanal erhält.

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 das Gerät, welches angesprochen werden soll mit der `port:` Option angeben, indem wir den Gerätenamen verwenden, der 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 auch angeben, an welchen Kanal gesendet werden soll, in dem 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 zur gleichen Zeit 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: Schlussendlich ist es auch sehr spannend, den Audio-Ausgang deines MIDI Synthesizers mit einem deiner Audio-Eingänge deiner Soundkarte zu verbinden. Dann kannst du deinen Synthesizer mit den `midi_*`Funktionen steuern und auch die erzeugten Sounds 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 Funktion `midi` ist eine handliche Vereinfachung um `note on ` und `note off` Events mit einem einzigen Befehl zu senden. Für weitere Informationen schaue einfach in die 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: Ein (zu MIDI) zusätzlicher Weg, um Information aus Sonic Pi hinaus und hinein zu bekommen, ist OSC - Open Sound Control, ein einfaches Netzwerkprotokoll. Es lässt dich Nachrichten an externe Programme senden und empfangen (jeweils auf dem gleichen oder verschiedenen Computern) und eröffnet somit neue Steuerungsmöglichkeiten weit über MIDI hinaus, welches durch sein 1980er Design Einschränkungen hat.

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 wie Python oder sclang schreiben, das OSC Nachrichten sendet oder empfängt und direkt mit Sonic Pi zusammenarbeitet. Es gibt OSC Bibliotheken für die allermeisten gebräuchlichen Programmiersprachen. Was Du damit tun kannst, ist nur durch deine Vorstellungskraft begrenzt.

en: Let's build a basic OSC listener:
de: Lass uns einen einfachen OSC listener (Code der auf OSC Nachrichten hört) 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 haben wir als OSC Pfad, auf dem wir auf Nachrichten lauschen, `"/osc*/trigger/prophet"` festgelegt. Dafür können wir jeden beliebigen validen OSC Pfad verwenden (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 Nachrichten angefügt, also müssen wir eine OSC Nachricht mit dem Pfad `/trigger/prophet` senden, sodass der `sync` Befehl beendet und der prophet Synth gespielt wird.

en: Sending OSC to Sonic Pi
de: OSC Nachrichten 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 Nachrichten von jeder beliebigen Programmiersprache an Sonic Pi senden, die Unterstützung (eine Bibliothek) für OSC bietet. Wenn wir zum Beispiel eine OSC Nachricht aus Python schicken wollen, 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 eine OSC Nachricht aus Clojure senden, sieht das vielleicht so aus:

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 anderen Computern empfangen

en: For security reasons, by default Sonic Pi does not let remote machines send it OSC messages. However, you can enable support for remote machines in Preferences->IO->Network->Receive Remote OSC Messages. Once you've enabled this, you can receive OSC messages from any computer on your network. Typically the sending machine will need to know your IP address (a unique identifier for your computer on your network - kind of like a phone number or an email address). You can discover the IP address of your computer by looking at the IO section of the preferences pane. (If your machine happens to have more than one IP address, hovering the mouse over the listed address will pop up with a list of all known addresses).
de: Aus Sicherheitsgründen empfängt Sonic Pi standardmäßig keine OSC Nachrichten von anderen Computern. Trotzdem kann man das unter Einstellungen->IO->Netzwerk->Empfange OSC von entfernten Computern aktivieren. Sobald du dieses Feature aktiviert hast, kannst du OSC Nachrichten von beliebigen Computern in deinem Netzwerk empfangen. Dafür muss der Sender deine IP-Adresse (ein eindeutiger Bezeichner für deinen Computer in deinem Netzwerk - wie eine Telefonnummer oder E-Mail-Adresse) kennen. Du kannst diese herausfinden, indem Du in den Einstellungen den IO-Reiter aufrufst. (Falls dein Computer mehrere IP-Adressen haben sollte, kannst du alle sehen, wenn du den Mauszeiger über der angezeigten ruhen lässt).

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: Manche Programme, wie TouchOSC für iPhone und Android, unterstützen das Senden von OSC Nachrichten von Haus aus. Also kannst du direkt, wenn du auf OSC Nachrichten von entfernten Computer hörst und deine IP-Adresse kennst, damit beginnen von Apps wie TouchOSC OSC Nachrichten zu senden und deine eigenen Steuerungen mit Slidern, Knöpfen, Drehknöpfen usw. zu bauen. Dies bietet Dir eine enorme Bandbreite an Eingabemöglichkeiten.

en: Sending OSC
de: OSC Nachrichten senden

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, die wir anstelle von `"localhost"`verwenden:

en: 13 Multichannel Audio
de: 13 Multikanal-Audio

en: Multichannel Audio
de: Multikanal-Audio

en: Increasing the Duration
de: Die Dauer erhöhen

en: Potential Issues
de: Mögliche Probleme

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 verhält sich ähnlich zu `synth :sound_in`, mit einigen wesentlichen Unterschieden: er läuft ununterbrochen (bis Du ihn ausdrücklich stoppst) und Du kannst ihn dynamisch in neue FX-Inhalte *schieben*.

en: Working with FX
de: Mit FX arbeiten

en: Now, whilst you're still hearing the audio live from the sound card with reverb, change the code to the following:
de: Jetzt, während Du noch den Ton live von der Soundkarte mit Reverb hörst, ändere den Code so um:

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: Und nun, drück Run, und sofort wirst Du den Sound mit dem Echo-FX hören und nicht mehr mit Reverb. Wenn Du beides möchtest, ändere einfach wieder den Code und drück Run:

en: Stereo input
de: Stereo-Eingang

en: 13.3 Sound Out
de: 13.3 Soundausgabe

en: Sound Out
de: Soundausgabe

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

en: Conclusions
de: Abschluss

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: Damit bist Du am Ende des Tutorials von Sonic Pi angekommen. Hoffentlich hast Du etwas dabei gelernt. Falls Du das Gefühl hast, nicht alles verstanden zu haben - keine Angst, spiele einfach weiter und hab Spaß dabei. Dann wird immer mehr hängen bleiben. Und greife einfach auf das Tutorial zurück, wenn Du eine Frage hast, die vielleicht in einem der vorherigen Kapitel behandelt wurde.

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: Du bist auch eingeladen, Dir den Rest der Dokumentation im Hilfe-System genauer anzuschauen. Es gibt noch eine Reihe von Features, die in dieser Einführung 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 herum, hab Spaß, teile Deinen Code, tritt vor Freunden auf, zeige was Du auf dem Monitor hast und nicht vergessen:

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

en: A Appendix A - MagPi Articles
de: A Appendix 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: Appendix A sammelt Artikel über Sonic Pi, die für das MagPi-Magazin geschrieben wurden.

en: Dive into Topics
de: Steig' in die Themen ein

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 bestimmter Reihenfolge gelesen werden und wiederholen einiges aus dem Tutorial. Es geht weniger um einen Gesamtüberblick von Sonic Pi, sondern eher darum, einen Aspekt genauer anzusehen und diesen leicht verständlich darzustellen.

en: Read the MagPi
de: MagPi lesen

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 sie in wunderbar gesetzter Form in der Rubrik freie PDF-Downloads des MagPi sehen: 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 Dich ein Thema interessiert, welches noch nicht behandelt wurde - warum nicht eines vorschlagen? Der einfachste Weg ist ein Tweet mit deinem Vorschlag an [@Sonic_Pi](http://twitter.com/sonic_pi). Man kann 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 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 einfach furchtbar klingen und auch richtige Edelsteine, die einfach toll klingen. Was Dir nicht gefällt, lässt Du einfach beiseite, und was Dir gefällt, das behältst Du. Je mehr 'Fehler' Du Dir erlaubst, desto schneller lernst Du und entdeckst dabei Deinen persönlichen Coding Sound.

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

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: Now, try increasing that feedback to 1 to hear some crazy sounds! Read the docs for full details on all the many opts available to you.
de: Jetzt setze das feedback auf 1 und hör' Dir die verrückten Sounds an! Einzelheiten zu den vielen Opts, die Dir zur Verfügung stehen, findest Du in der Dokumentation.

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: The laser beams sliced through the wafts of smoke as the subwoofer pumped bass deep into the bodies of the crowd. The atmosphere was ripe with a heady mix of synths and dancing. However something wasn't quite right in this nightclub. Projected in bright colours above the DJ booth was futuristic text, moving, dancing, flashing. This wasn't fancy visuals, it was merely a projection of Sonic Pi running on a Raspberry Pi. The occupant of the DJ booth wasn't spinning disks, he was writing, editing and evaluating code. Live. This is Live Coding.
de: Die Laserstrahlen schnitten durch die Rauschwaden als der Subwoofer den Bass tief in die Körper der Menge pumpte. Die Atmosphäre war erfüllt von einem berauschenden Mix aus Synthesizern und Tanzen. Aber irgendetwas stimmte nicht in diesem Nachtklub. Über der DJ-Kabine leuchtete in bunten Farben futuristischer Text; bewegte sich, tanzte, blinkte. Dies war keine abgefahrene Lichtshow, sondern einfach eine Projektion von Sonic Pi, das auf einem Raspberry Pi lief. Der Insasse der DJ-Kabine drehte keine Platten, nein, er schrieb und bearbeitete Programmcode. Live. Das ist Live-Coding.

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: There are 4 core ingredients to a `live_loop`. The first is its name. Our `live_loop` above is called `:beats`. You're free to call your `live_loop` anything you want. Go crazy. Be creative. I often use names that communicate something about the music they're making to the audience. The second ingredient is the `do` word which marks where the `live_loop` starts. The third is the `end` word which marks where the `live_loop` finishes, and finally there is the body of the `live_loop` which describes what the loop is going to repeat - that's the bit between the `do` and `end`. In this case we're repeatedly playing a bass drum sample and waiting for half a beat. This produces a nice regular bass beat. Go ahead, copy it into an empty Sonic Pi buffer and hit run. Boom, Boom, Boom!.
de: Ein Live-Loop hat 4 Hauptbestandteile. Der erste ist sein Name. Unser `live_loop` oben heißt `live_loop`. Du kannst frei entscheiden, wie Du Deinen `live_loop` nennen möchtest. Sei kreativ. Ich benutze oft Namen, die dem Publikum etwas über die Musik mitteilen, die ich mache. Der zweite Bestandteil ist das Wort `do`, welches anzeigt, wo der `live_loop` beginnt. Der dritte ist das Wort `end`, das markiert, wo der `live_loop` endet. Schließlich gibt es noch den Block innerhalb des `live_loop`, der beschreibt, was die Schleife wiederholen soll – das ist der Teil zwischen `do` und `end`. In unsrem Fall spielen wir ein Bass-Drum-Sample und warten einen halben Takt. Dies führt zu einem schönen regelmäßigen Bass Beat. Auf gehts, kopiere den `live_loop` in einem leeren Sonic Pi-Puffer und drücke auf Ausführen. Boom, Boom, Boom!.

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: 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: Here, we have two `live_loop`s, one looping quickly making beats and another looping slowly making a crazy bass sound.
de: Hier haben wir zwei `live_loop`s. Der eine wiederholt schnell Beats, während der andere durch langsames Wiederholen einen verrückten Bass Sound kreiert.

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: Interessant beim Einsatz mehrerer `live_loop`s ist, dass jeder seine eigene Zeit verwaltet. Das bedeutet, dass man interessante polyrhythmische Strukturen erzeugen kann und sogar mit Phasenverschiebungen á la Steve Reich spielen kann. 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 des Drum Break aufgeführt. Doch erst die Wiederentdeckung durch frühe Hip-hop Musiker der 80er und der Einsatz in Samplern bewirkte den Einzug des Samples in einer 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: Die Sonic Pi Funktionen `sample` und `synth` bieten uns über optionale Parameter wie `amp:`, `cutoff:` und `release:` viele zusätzliche Kontrollmöglichkeiten. Da die Bezeichnung optimale Parameter allerdings ganz schön lang ist, werden wir der Einfachheit halber ab jetzt von *opts* sprechen.

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: Now, here's the fun part. Whilst the loop is still live, change the `30` in the `use_bpm 30` line to `50`. Woah, everything just got faster yet *kept in time*! Try going faster - up to 80, to 120, now go crazy and punch in 200!
de: Jetzt kommen wir zum spannenden Teil. Während der Loop läuft, verändere den Wert `30` in der `use_bpm 30` Zeile zu `50`. Wuhuu, auf einmal ist alles *ohne aus dem Einklang zu geraten* schneller geworden! Versuch das Tempo noch etwas mehr zu erhöhen - 80, 120 und um es wirklich verrückt klingen zu lassen, trage 200 ein!

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: Jetzt können wir damit beginnen Samples in unseren Live-Loop zu integrieren. Lass uns einige der lustigsten Optionen des `sample` Synths anschauen. Zunächst hätten wir `cutoff:`, das den Cut-Off-Filter des Samplers kontrolliert. Per default ist dieser ausgestellt. Aber du kannst ihn ganz einfach frei geben:

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 jedes Synth Riffs ist das Verändern und Experimentieren mit der Klangfarbe. Sonic Pi bietet uns zwei Möglichkeiten, die Klangfarbe zu kontrollieren - für dramatische Änderungen können wir verschiedene Synths verwenden, für dezente Umwandlungen reicht es die Optionen eines Synths einzustellen. Wir könnten auch FX verwenden, aber das heben wir uns für ein anderes Tutorial auf…

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: Pseudo Randomisation
de: Pseudo-Randomisierung

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: Interestingly, Roland never intended for the TB-303 to be used in dance music. It was originally created as a practice aid for guitarists. They imagined that people would program them to play bass lines to jam along to. Unfortunately there were a number of problems: they were a little fiddly to program, didn't sound particularly good as a bass-guitar replacement and were pretty expensive to buy. Deciding to cut their losses, Roland stopped making them after 10,000 units were sold and after a number of years sitting on guitarist's shelves, they soon could be found in the windows of second hand shops. These lonely discarded TB-303s were waiting to be discovered by a new generation of experimenters who started using them in ways that Roland didn't imagine to create new crazy sounds. Acid House was born.
de: Interessanterweise hatte Roland nicht vorgesehen, dass der TB-303 für Tanzmusik zum Einsatz kommt. Er wurde ursprünglich als eine Übungshilfe für Gitarristen entwickelt. Die Firma hatte sich überlegt, dass Leute mit Hilfe des Synthesizers Basslinien programmieren würden zu denen sie jammen könnten. Leider gab es damit mehrere Probleme: die Programmierung war etwas zu kompliziert, der Klang glich nicht wirklich einer Bassgitarre und sie waren teuer in der Anschaffung. Um ihre Verluste zu minimieren, brach Roland die Produktion nach dem Verkauf von 10.000 Exemplaren ab. Nach ein paar Jahren des Daseins als Staubfänger in den Regalen der Gitarristen wanderten die meisten TB-303s in die Schaufenster von Second-Hand-Läden. Dort warteten sie auf ihre Wiederentdeckung durch eine neue Generation von Experimentierfreudigen, die anfingen sie auf eine Art und Weise zu nutzten, die Roland nie vorgesehen hatte, um abgefahrene Klänge zu erzeugen. Das war die Geburtsstunde des Acid House.

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: 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: For each standard envelope opt, there's a `cutoff_` equivalent opt in the `:tb303` synth. So, to change the cutoff attack time we can use the `cutoff_attack:` opt. Copy the code above into an empty buffer and hit Run. You'll hear a crazy sound warble in and out. Now start to play. Try changing the `cutoff_attack:` time to `1` and then `0.5`. Now try `8`.
de: Für jede Standard-Hüllkurvenoption gibt es eine entsprechende `cutoff_`-Option im `:tb303`-Synthesizer. Um die cutoff-Anschlagszeit zu ändern, können wir die Option `cutoff_attack:` verwenden. Kopiere den Code unten in einen leeren Puffer und drücke *Run*. Du wirst einen verrrückten Sound hören, der ein- und auswobbelt. Nun spiel ein bisschen herum. Versuche, die `cutoff_attack:`-Zeit auf `1` zu ändern, dann auf `0.5`. Und jetzt probiere `8`.

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: Finally, here's a piece I composed using the ideas in this tutorial. Copy it into an empty buffer, listen for a while and then start live coding your own changes. See what crazy sounds you can make with it! See you next time...
de: Zum Schluss gibt es ein Beispiel, das ich mit Hilfe der Konzepte aus diesem Tutorial komponiert habe. Kopiere den Code in einen leeren Puffer, höre es Dir ein Weile lang an und dann versuche Deine eigenen Änderungen live zu coden. Überzeuge Dich davon, was für verrückte Klänge Du erzeugen kannst! Bis zum nächste Mal …

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, die ich Dir zeigen kann (was ich in zukünftigen Tutorialeinheiten auch machen werden). In diesem Monat werfen wir allerdings einen Blick auf etwas, das Du von Sonic Pi wahrscheinlich nicht erwartet hast: Minecraft kontrollieren.

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: Sonic Teleporter
de: Schall-Teleporter

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: Magic Blocks
de: Magische Blöcke

en: Decoding the Habanera
de: Die Habanera dekodieren

en: Notes
de: Anmerkungen

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: `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: 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: Probabilities
de: Wahrscheinlichkeiten

en: Changing tempo
de: Tempo ändern

en: 4. Use the Master Mixer
de: 4. Verwende den Hauptmischer

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: 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, die Du am häufigsten brauchst. Später kannst Du Dein Repertoire nach und nach erweitern.

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: For a full list take a look at section 10.2 Shortcut Cheatsheet.
de: Eine Liste aller Tastaturkürzel ist in Kapitel 10.2 "Cheatsheet für Tastenkürzel" enthalten.

en: Shortcut Cheatsheet
de: Cheatsheet für Tastaturkürzel

en: The following is a summary of the main shortcuts available within Sonic Pi. Please see Section 10.1 for motivation and background.
de: In diesem Abschnitt findest Du eine Zusammenfassung der wichtigsten Tastenkürzel von Sonic Pi. In Abschnitt 10.1 erklärte ich Dir bereits, warum diese so nützlich sind.

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` - Protokollfenster ein-/ausschalten

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 Email 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 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).

en: Sonic Pi now supports a simple API for interacting with Minecraft Pi - the special edition of Minecraft which is installed by default on the Raspberry Pi's Raspbian Linux-based operating system.
de: Raspbian, das Linux-Betriebssystem für Raspberry Pi, bringt eine spezielle Version von Minecraft als Teil der Vorinstallation mit. Und mit Sonic Pi kannst Du über eine einfache API jetzt auch Minecraft Pi steuern.

en: No need to import libraries
de: Keine Bibliotheken notwendig

en: The Minecraft Pi integration has been designed to be insanely easy to use. All you need to do is to launch Minecraft Pi and create a world. You're then free to use the `mc_*` fns just like you might use `play` and `synth`. There's no need to import anything or install any libraries - it's all ready to go and works out of the box.
de: Die Verbindung zwischen Minecraft Pi und Sonic Pi ist so einfach zu nutzen, dass Du nichts dafür vorbereiten musst. Starte einfach Minecraft Pi und baue eine Welt. Du kannst sofort die `mc_*`-Funktionen in Deinem Code genau wie `play` oder `synth` einsetzen. Es gibt nichts zu installieren und keine Bibliotheken zu importieren - alles ist fix und fertig und sofort startklar für Dich.

en: Automatic Connection
de: Automatische Verbindung

en: The Minecraft Pi API takes care of managing your connection to the Minecraft Pi application. This means you don't need to worry about a thing. If you try and use the Minecraft Pi API when Minecraft Pi isn't open, Sonic Pi will politely tell you. Similarly, if you close Minecraft Pi whilst you're still running a `live_loop` that uses the API, the live loop will stop and politely tell you that it can't connect. To reconnect, just launch Minecraft Pi again and Sonic Pi will automatically detect and re-create the connection for you.
de: Die Minecraft-Pi-API kümmert sich automatisch um die Verbindung zur laufenden Minecraft-Pi-Applikation. Du musst also nichts dafür tun. Sonic Pi wird sich allerdings freundlich beschweren, wenn Du die API benutzen möchtest und Minecraft Pi nicht gleichzeitig läuft. Und falls Du die Minecraft-Pi-Applikation beendest, während Dein Code die API in einem `live_loop` ansprechen will, wird der Loop beendet und Du erhältst eine entsprechende Fehlermeldung. Starte dann Minecraft Pi wieder neu, die API wird sich von selbst damit verbinden und Dein Code funktioniert wieder.

en: Designed to be Live Coded
de: Gemacht für Live-Coding

en: The Minecraft Pi API has been designed to work seamlessly within `live_loop`s. This means it's possible to synchronise modifications in your Minecraft Pi worlds with modifications in your Sonic Pi sounds. Instant Minecraft-based music videos! Note however that Minecraft Pi is alpha software and is known to be slightly buggy. If you encounter any problems simply restart Minecraft Pi and carry on as before. Sonic Pi's automatic connection functionality will take care of things for you.
de: Die Minecraft-Pi-API ist dazu da, dass sie problemlos in in einem `live_loop` funktioniert. Du kannst damit also Veränderungen in Deiner Minecraft-Welt mit Veränderungen in Deinen Sonic-Pi-Sounds synchronisieren. Zack, Minecraft-basierte Musik-Videos! Bedenke aber, dass Minecraft Pi eine Alpha-Version ist und die Software ein paar kleinere Bugs hat. Wenn ein solches Problem mit Minecraft Pi auftritt, starte es einfach neu. Sonic Pi nimmt dann automatisch eine neue Verbindung über seine API auf.

en: Requires a Raspberry Pi 2.0
de: Raspberry Pi 2 empfohlen

en: It is highly recommended that you use a Raspberry Pi 2 if you wish to run both Sonic Pi and Minecraft at the same time - especially if you want to use Sonic Pi's sound capabilities.
de: Minecraft Pi und Sonic Pi mit seinen Sound-Möglichkeiten sind beides sehr rechenintensive Programme. Der alte Raspberry ist davon schnell überfordert und ein Raspberry Pi 2 mit seinem schnelleren Prozessor deshalb sehr zu empfehlen.

en: API Support
de: API-Support

en: At this stage, Sonic Pi supports basic block and player manipulations which are detailed in Section 11.1. Support for event callbacks triggered by player interactions in the world is planned for a future release.
de: Zur Zeit kann Sonic Pi einige Grundfunktionen zur Manipulation von Minecraft-Blöcken und dem Spieler ausführen. Details dazu findest Du im nächsten Abschnitt 11.1. Für ein späteres Release plane ich, auch Event-Callbacks aus Minecraft Pi zu unterstützen, so dass der Code in Sonic Pi von Ereignissen erfahren kann, die der Spieler in Minecraft Pi ausgelöst hat.

en: Basic Minecraft Pi API
de: Grundfunktionen der Minecraft-Pi-API

en: Sonic Pi currently supports the following basic interactions with Minecraft Pi:
de: Folgende Aktionen kannst Du mit der API von Sonic Pi aus in Minecraft Pi auslösen:

en: Displaying chat messages
de: Anzeige von Chat-Nachrichten

en: Setting the position of the user
de: die Spielerposition setzen

en: Getting the position of the user
de: die Spielerposition auslesen

en: Setting the block type at a given coordinate
de: den Typ eines Minecraft-Blocks an einer Koordinate setzen

en: Getting the block type at a given coordinate
de: den Typ eines Minecraft-Blocks an einer Koordinate auslesen

en: Let's look at each of these in turn.
de: Schauen wir uns diese der Reihe nach an.

en: Let's see just how easy it is to control Minecraft Pi from Sonic Pi. First, make sure you have both Minecraft Pi and Sonic Pi open at the same time and also make sure you've entered a Minecraft world and can walk around.
de: Ich zeige Dir mal, wie einfach es ist, von Sonic Pi aus die Kontrolle über Minecraft Pi zu übernehmen. Starte also zunächst Sonic Pi und Minecraft Pi und betrete eine Minecraft-Welt, in der Du herumlaufen kannst.

en: In a fresh Sonic Pi buffer simply enter the following code:
de: Jetzt schreibe folgenden Code in einem leeren Puffer von Sonic Pi :

en: mc_message "Hello from Sonic Pi"
de: mc_message "Hallo, hier ist Sonic Pi"

en: When you hit the *Run* button, you'll see your message flash up on the Minecraft window. Congratulations, you've written your first Minecraft code! That was easy wasn't it.
de: Führe den Code aus und Du wirst die Nachricht im Minecraft-Fenster aufblitzen sehen. Gratuliere, das ist Dein erster Minecraft-Code! War doch gar nicht schwer, oder?

en: Now, let's try a little magic. Let's teleport ourselves somewhere! Try the following:
de: Und jetzt zaubern wir ein wenig. Teleportiere Dich einfach, wohin Du willst! Probiere das hier aus:

en: When you hit *Run* - boom! You're instantantly transported to a new place. Most likely it was somewhere in the sky and you fell down either to dry land or into water. Now, what are those numbers: `50, 50, 50`? They're the coordinates of the location you're trying to teleport to. Let's take a brief moment to explore what coordinates are and how they work because they're really, really important for programming Minecraft.
de: Nach Klick auf *Ausführen* - Paff! - bist Du sofort an einem anderen Ort in Deiner Minecraft-Welt. Vermutlich irgendwie hoch oben in der Luft und Du bist aufs Land oder Wasser herunter gefallen. Was bedeuten diese Zahlen: `50, 50, 50`? Das sind die Koordinaten der Zielposition für den Teleport. Probiere jetzt in Deinem Code ein paar Koordinaten aus, damit Du weißt, wie sie funktionieren. Koordinaten sind für Minecraft-Programme sehr sehr wichtig.

en: Coordinates
de: Koordinaten

en: Imagine a pirate's map with a big `X` marking the location of some treasure. The exact location of the `X` can be described with two numbers - how far along the map from left to right and how far along the map from bottom to top. For example `10cm` across and `8cm` up. These two numbers `10` and `8` are coordinates. You could easily imagine describing the locations of other stashes of treasure with other pairs of numbers. Perhaps there's a big chest of gold at `2` across and `9` up...
de: Stelle Dir eine alte Piraten-Schatzkarte vor - beim großen `X` ist der Schatz vergraben. Die genaue Position des `X` lässt sich mit zwei Zahlen beschreiben - wie weit ist das Kreuz horizontal vom Papierrand entfernt und wie weit vertikal. Angenommen, es ist `10cm` vom linken Rand und `8cm` vom unteren Rand entfernt. Diese beiden Zahlen `10` und `8` sind Koordinaten. Auch andere vergrabene Schätze auf der Karte lassen sich mit ihrem jeweiligen Koordinaten-Zahlenpaar genau beschreiben. Etwa die große Goldkiste bei `2` von links und `9` von unten...

en: Now, in Minecraft two numbers isn't quite enough. We also need to know how high we are. We therefore need three numbers:
de: In Minecraft Pi reichen zwei Zahlen nicht mehr aus. Wir brauchen auch eine Höhenangabe und damit besteht eine Koordinate in Minecraft aus drei Zahlen:

en: How far from right to left in the world - `x`
de: Wie weit von rechts nach links innerhalb der Welt - `x`

en: How far from front to back in the world - `z`
de: Wie weit von vorn nach hinten innerhalb der Welt - `z`

en: How high up we are in the world - `y`
de: Wie hoch vom Boden aus innerhalb der Welt - `y`

en: One more thing - we typically describe these coordinates in this order `x`, `y`, `z`.
de: Diese Minecraft-Koordinaten schreiben wir dann in der Reihenfolge `x`, `y`, `z` auf.

en: Finding your current coordinates
de: Finde deine aktuellen Koordinaten

en: Let's have a play with coordinates. Navigate to a nice place in the Minecraft map and then switch over to Sonic Pi. Now enter the following:
de: Spielen wir also ein wenig mit den Koordinaten herum. Bewege Dich in Minecraft Pi an einen schönen Ort und wechsele dann zu Sonic Pi. Nun führe folgenden Code aus:

en: When you hit the *Run* button you'll see the coordinates of your current position displayed in the log window. Take a note of them, then move forward in the world and try again. Notice how the coordinates changed! Now, I recommend you spend some time repeating exactly this - move a bit in the world, take a look at the coordinates and repeat. Do this until you start to get a feel for how the coordinates change when you move. Once you've understood how coordinates work, programming with the Minecraft API will be a complete breeze.
de: Drücke *Ausführen* und im Log erscheinen die Koordinaten, an denen Du Dich in Minecraft befindest. Merke sie Dir, bewege Dich in Minecraft ein wenig weiter und führe den Code noch einmal aus. Hast Du gesehen, wie sich die Koordinaten geändert haben? Probiere das noch ein bisschen aus, damit Du ein Gefühl dafür bekommst, wie sich die Koordinaten mit Deiner Bewegung in der Minecraft-Welt verändern. Wenn Du erst einmal verstanden hast, wie Koordinaten funktionieren, wird das Programmieren mit der Minecraft-Pi-API ganz einfach.

en: Let's Build!
de: Lass uns etwas bauen!

en: Now that you know how to find the current position and to teleport using coordinates, you have all the tools you need to start building things in Minecraft with code. Let's say you want to make the block with coordinates `40`, `50`, `60` to be glass. That's super easy:
de: Jetzt weißt Du, wie Du Deine Position auslesen und Dich an beliebige Stellen teleportieren kannst. Als nächstes können wir mit Code Dinge in Minecraft bauen. Zum Beispiel ein Block aus Glas an Koordinate `40, 50, 60`, das geht ganz einfach:

en: Haha, it really was that easy. To see your handywork just teleport nearby and take a look:
de: Haha, das war ja wirklich ganz einfach. Nach getaner Arbeit springst Du schnell in die Nähe und schaust Dir das Ergebnis an:

en: Now turn around and you should see your glass block! Try changing it to diamond:
de: Dreh Dich ein wenig und Du wirst Deinen Glasblock sehen! Ändern wir kurz das Material und machen einen Block aus Diamant daraus:

en: If you were looking in the right direction you might have even seen it change in front of your eyes! This is the start of something exciting...
de: Wenn Du in die richtige Richtung schaust, konntest Du eben sogar dabei zusehen, wie sich der Block verändert. Hier geschieht etwas aufregendes...

en: Looking at blocks
de: Blöcke ansehen

en: Let's look at one last thing before we move onto something a bit more involved. Given a set of coordinates we can ask Minecraft what the type of a specific block is. Let's try it with the diamond block you just created:
de: Du kannst Minecraft Pi auch fragen, welcher Typ Block sich an einer Koordinate befindet. Der folgende Code tut dies für den Diamantblock, den Du gerade gebaut hast:

en: Yey! It's `:diamond`. Try changing it back to glass and asking again - does it now say `:glass`? I'm sure it does :-)
de: Yay! Es ist `:diamond`. Ändere das Material des Blocks wieder zu Glas und lese den Typ noch einmal aus - meldet der Code jetzt `:glass` zurück? Ich bin sicher, dass er das tut. :-)

en: Available block types
de: Mögliche Materialtypen in Minecraft

en: Before you go on a Minecraft Pi coding rampage, you might find this list of available block types useful:
de: Bevor Du jetzt mit Code durch Minecraft Pi tobst, hier noch eine praktische Liste aller Material-Typen für Minecraft-Blöcke:
