Sonic Pi - en to nl translation catalogue (1423 entries)

en: 1 Welcome to Sonic Pi
nl: 1 Welkom bij Sonic Pi

en: Welcome friend :-)
nl: Welkom vriend :-)

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.
nl: Welkom bij Sonic Pi. Hopelijk ben je net zo enthousiast als ik om te gekke klanken te gaan maken. Het zal een *leuk* avontuur worden, waarin je alles over muziek, synthese, programmeren, compositie en ook live spelen gaat leren en nog veel meer...

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.
nl: Maar wacht,dat was onbeleefd van mij! Ik moet mij nog voorstellen.
    Ik ben [Sam Aaron] ( http://twitter.com/samaaron ) de kerel die Sonic Pi creëerde.
    Je vind mij als [@samaaron](http://twitter.com/samaaron) op Twitter en ik zal heel blij zijn om je daar te kunnen begroeten. Misschien ben je ook geïnteresseerd om meer te weten te komen over mijn [Live Coding Performances] (https://youtube.com/samaaron) waar ik, voor publiek, live codeer met Sonic Pi.

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!
nl: Mocht je gedachten of ideeën hebben om Sonic Pi te verbeteren, aarzel dan niet om deze door te geven; terugkoppeling is zo nuttig. En, je weet het nooit, jouw idee zou de volgende grote nieuwe functie kunnen zijn!

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.
nl: Deze handleiding is verdeeld in secties en gegroepeerd per categorie. Hoewel ik deze in een volgorde geschreven heb met een eenvoudige leercurve voor ogen, wees vrij, om in afzonderlijke secties te duiken zoals jij dat wil. Als je het gevoel hebt dat er iets ontbreekt, laat dit gerust aan mij weten, ik zal jouw bedenking in overweging nemen voor een toekomstige versie.

en: OK, let's get started...
nl: OK, laten we beginnen...

en: 1.1 Live Coding
nl: 1.1 Live Coderen (Live Coding)

en: Live Coding
nl: Live Coderen

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.
nl: Een van de meest opwindende aspecten van Sonic Pi is, dat het je in staat stelt, code te gaan schrijven en *de code, ook live te wijzigen* om muziek te spelen, net zoals je live gitaar zou spelen. Dit betekent dat je, mits wat oefening, met Sonic Pi het podium op kan en hiermee kan optreden.

en: Free your mind
nl: Maak je hoofd leeg

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...
nl: Voor we in detail gaan over hoe Sonic Pi werkt, verderop in deze handleiding, wil ik je even de ervaring meegeven, hoe het voelt om live te coderen. Maak je geen zorgen als je hier niet veel (of niets) van begrijpt. Blijf gewoon even zitten en geniet ...

en: A live loop
nl: Een loop "live" brengen

en: live_loop :flibble do
      sample :bd_haus, rate: 1
      sleep 0.5
    end
nl: live_loop :typmaarlustig do
      sample :bd_haus, rate: 1
      sleep 0.5
    end

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:
nl: Klik nu op de `afspeel` knop en je zal een lekkere snelle basdrum horen vertrekken. Je kan nu, wanneer jij dat wenst, het geluid stoppen door op de `Stop`' knop te klikken. Maar doe dat nog even niet... neem in plaats daarvan de volgende stappen:

en: Make sure the bass drum sound is still running
nl: Zorg ervoor dat deze basdrum klank nog steeds loopt

en: Change the `sleep` value from `0.5` to something higher like `1`.
nl: Verander de waarde van 'sleep' van '0.5' naar een ietwat hoger getal,zoals bv. `1`.

en: Press the `Run` button again
nl: Klik opnieuw op de `afspeelknop`

en: Notice how the drum speed has changed.
nl: Merk op dat de snelheid van de drum hierbij veranderd is.

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...
nl: En *onthou dit moment*, dit is de eerste keer dat je een Live Code met Sonic Pi hebt gedaan en het is waarschijnlijk niet je laatste keer...

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:
nl: Ok, dat was eenvoudig. We gaan er nog iets aan de mix toevoegen. Boven `sample :bd_haus` voeg je deze lijn toe  `sample :ambi_choir, rate: 0.3`. Jouw code moet er nu als volgt uitzien:

en: live_loop :flibble do
      sample :ambi_choir, rate: 0.3
      sample :bd_haus, rate: 1
      sleep 1
    end
nl: live_loop :typmaarlustig do
      sample :ambi_choir, rate: 0.3
      sample :bd_haus, rate: 1
      sleep 1
    end

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).
nl: Speel hiermee. Verander de `rate:` (snelheid) waardes - wat gebeurd er, als je hoge waarden gebruikt,of kleine waarden of negatieve waarden? Kijk wat er gebeurd wanneer je de `rate:` waarde van het `:ambi_choir` sample maar een tikkeltje veranderd (bv. 0.29). Wat gebeurd er als je een héél kleine `sleep` (rust) waarde kiest? Kijk nu of je het zo snel kan laten gaan dat je computer stopt en een foutmelding geeft omdat hij het niet meer kan verwerken (wanneer dit gebeurd, kun je gewoon een grotere `sleep` tijd instellen en op `afspelen` klikken).

en: Try commenting one of the `sample` lines out by adding a `#` to the beginning:
nl: Probeer één van de `sample` lijnen van een commentaar te voorzien door er een `#` voor te zetten:

en: live_loop :flibble do
      sample :ambi_choir, rate: 0.3
    #  sample :bd_haus, rate: 1
      sleep 1
    end
nl: live_loop :typmaarlustig do
      sample :ambi_choir, rate: 0.3
    #  sample :bd_haus, rate: 1
      sleep 1
    end

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.
nl: Merk op hoe het de computer opdraagt deze lijn te negeren, zodat we deze niet horen. Dit heet een comment (commentaarlijn). In Sonic Pi kunnen we een commentaarlijn gebruiken om klanken uit de mix te verwijderen of toe te voegen.

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:
nl: Ik laat je nu even met het volgende spelen. Neem de onderstaande code, en kopieer deze in een lege buffer. Probeer er nu nog niet al te veel van te begrijpen, maar wel in te zien dat er twee loops zijn - dus twee klanken die op het zelfde moment spelen. Het beste wat je kan doen nu is, experimenteren en er, gewoon op los, mee te gaan spelen. Hier zijn enkele suggesties:

en: Try changing the blue `rate:` values to hear the sample sound change.
nl: Wijzig de blauwe `rate:` waarden, om het geluid van de sample-klank te horen veranderen.

en: Try changing the `sleep` times and hear that both loops can spin round at different rates.
nl: Wijzig de `sleep` tijd en hoor nu, dat je beide loops kunt afspelen met verschillende rusttijden.

en: Try uncommenting the sample line (remove the `#`) and enjoy the sound of the guitar played backwards.
nl: Probeer de commentaarlijn te wissen (verwijder het `#`) uit onze voorbeeldlijn en geniet van de gitaarklank, die nu achterwaarts afspeelt.

en: Try changing any of the blue `mix:` values to numbers between `0` (not in the mix) and `1` (fully in the mix).
nl: Probeer de blauwe `mix:` waarden te veranderen naar cijfers tussen `0` (niet in de mix) en `1` (voluit in de mix).

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...
nl: Denk er ook aan, te klikken op 'afspelen' om deze veranderingen te kunnen horen, bij de volgende loop die vertrekt. Maak je geen zorgen als het hierbij soms in de soep draait, klik dan op `Stop`, wis de code in de buffer en plak er een nieuwe kopie in, zo je bent weer gereed om opnieuw te gaan improviseren. Van je fouten kan je nu eenmaal het beste leren.

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.
nl: Blijf nu spelen en experimenteren tot je de nieuwsgierigheid begint te voelen en je je begint af te vragen wat je hier nog allemaal mee kan doen. Dan ben je nu klaar om de rest van de handleiding te lezen.

en: So what are you waiting for...
nl: Dus,waar wacht je nog op . . .

en: 1.2 Exploring the Interface
nl: 1.2 De Interface Verkennen

en: The Sonic Pi Interface
nl: De Interface van Sonic Pi

en: Sonic Pi has a very simple interface for coding music. Let's spend a little time exploring it.
nl: Sonic Pi heeft een zeer eenvoudige interface om muziek te coderen. Laten we hier eens wat tijd aan besteden om deze te verkennen.

en: *A* - Play Controls
nl: *A* - Afspeel knoppen

en: *B* - Editor Controls
nl: *B* - Editor aanpassen

en: *C* - Info and Help
nl: *C* - Info en Hulp

en: *E* - Prefs Panel
nl: *E* - Paneel Voorkeursinstellingen

en: *F* - Log Viewer
nl: *F* - Log Venster

en: *G* - Help System
nl: *G* - Hulp-Systeem

en: *H* - Scope Viewer
nl: *H* - Scope Venster

en: A. Play Controls
nl: A. Afspeel knoppen

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.
nl: Deze roze knoppen zijn de belangrijkste bedieningselementen voor het starten en stoppen van het geluid. Er is de *Afspelen* knop om de code in de editor af te spelen, *Stop* om alle actieve code te stoppen, *opslaan* om de code naar een extern bestand op te slaan en *Opnemen* om een opname (WAV-bestand) te maken van het afgespeelde geluid.

en: B. Editor Controls
nl: B.  Controle over de Editor

en: C. Info and Help
nl: C. Info and Hulp

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.
nl: Deze blauwe knoppen geven je toegang tot hulp-, informatie- en voorkeursinstellingen. De *Info* knop opent het venster die informatie over Sonic Pi zelf bevat - het kernteam, de geschiedenis, de medewerkers en ook de Sonic Pi "gemeenschap". De *Hulp* knop schakelt naar het hulp-systeem (*G*) en de *Voorkeuren* knop schakelt naar het voorkeur-venster waarmee u een aantal fundamentele systeemparameters kan bijsturen.

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.
nl: Dit is het gebied waarin je jouw code schrijft en muziek componeert/uitvoert. Het is een eenvoudige tekst-editor, waarin je code kan schrijven, verwijderen, knippen en plakken, enz. Denk aan een zeer eenvoudige versie van Word of Google Docs. De editor zal de kleur van woorden automatisch aanpassen op basis van hun betekenis in de code. Dit lijkt misschien eerst wat vreemd, maar je zal dit snel heel nuttig vinden. Bijvoorbeeld als het het blauw ziet, dan weet je dat het om een getal gaat.

en: E. Prefs Panel
nl: E. Paneel Voorkeursinstellingen

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.
nl: Sonic Pi ondersteunt een aantal instellingen die toegankelijk zijn door het in-/uitschakelen van de knop *Voorkeuren* in de Info en Hulp knoppen-set. Dit zal de zichtbaarheid van het Paneel Voorkeursinstellingen, met daarin een aantal regelbare opties, in- of uitschakelen. Voorbeelden zijn: het brengen van stereo naar mono, stereo omkeren, de detaillering van het log en ook een volumeregelaar en audio keuze voor de Raspberry Pi.

en: F. Log Viewer
nl: F. Log Venster

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.
nl: Wanneer je je code uitvoert,zal informatie over wat het programma doet, getoond worden in een soort logboek. Standaard zal je een berichtje zien, voor elk geluid dat je maakt, met de exacte tijd dat het geluid werd geactiveerd. Dit is zeer handig om fouten in je code op te kunnen sporen en om te kunnen begrijpen wat je code doet.

en: G. Help System
nl: G. Hulp Systeem

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.
nl: Eén van de belangrijkste onderdelen van de Sonic Pi-interface is het hulp-systeem dat wordt weergegeven aan de onderkant van het venster. Dit kan worden in- en uitgeschakeld door op de blauwe knop *Hulp* te klikken. Het hulp-systeem bevat hulp en informatie over alle aspecten van Sonic Pi, inclusief deze handleiding, een lijst van beschikbare synths, samples, voorbeelden, effecten en een volledige lijst van alle functies die Sonic Pi biedt voor het coderen van muziek.

en: H. Scope Viewer
nl: H. Scope Venster

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).
nl: Met het scope venster zie je het geluid. Je ziet hier dat een zaagtand-golf er ook uitziet als een zaag en dat onze basis biep-toon een mooie golvende sinus-golf is. Je ziet ook duidelijk het verschil tussen luide en zachte klanken door hun grootte. Er zijn 3 verschillende scopes beschikbaar- de standaard (default) is een gecombineerde scope voor het linker en rechter kanaal, een stereo die voor elk kanaal een aparte scope laat zien. En tenslotte is er een Lissajousfiguur scope die de relatie in fase tussen het linker- en rechter-kanaal weergeven en die je in staat stelt, mooie figuren te tekenen  met geluid (https://nl.wikipedia.org/wiki/Lissajousfiguur).

en: 1.3 Learning through Play
nl: 1.3 Spelenderwijs Leren

en: Learning through Play
nl: Spelenderwijs Leren

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.
nl: Sonic Pi moedigt je aan om meer te gaan leren over zowel de computer als over muziek door middel van spel en experimenteren. Het belangrijkste is dat je hierin plezier hebt, en voor je het beseft, heb je hierdoor geleerd, hoe te coderen, te componeren en live te spelen.

en: There are no mistakes
nl: Er bestaan geen fouten

en: Start Simple
nl: Start Eenvoudig

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.
nl: Wanneer je aan het leren bent, is het verleidelijk om *nu al* verbazingwekkende dingen te gaan doen. Maar het is beter om die wens vast te houden en als een toekomstig doel voor ogen te houden om later te bereiken. Probeer kleine, eenvoudige stappen te zetten en te zien hoe dit jou plezier geeft en je dichter tot je doel brengen. Eens je de kleine stappen onder de knie hebt, kan je deze als bouwstenen gebruiken en hiermee spelen, en je zal zien dat deze nieuwe inzichten, jou ook verse ideeën zullen geven. Snel genoeg ben je fijn bezig én maak je vooruitgang.

en: Just make sure to share your work with others!
nl: Zorg ervoor dat je je werk deelt met anderen!

en: 2 Synths
nl: 2 Synthesizers (Synths)

en: Synths
nl: Synthesizers

en: OK, enough of the intros - let's get into some sound.
nl: OK, genoeg intro's - laat ons in enkele klanken duiken.

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.
nl: In deze sectie zullen we de basisprincipes van het triggeren en het manipuleren van synth's behandelen. Synth is kort voor synthesizer, wat een chique woord is voor een ding dat geluiden kan creëren. Synth's zijn doorgaans vrij ingewikkeld om te gebruiken - met name analoge synth's met vele patch kabels en modules. Sonic Pi biedt je  een zelfde kracht op een eenvoudige en toegankelijke wijze.

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...
nl: Laat je niet misleiden door de directe eenvoud van de Sonic Pi interface. Je kunt hier diepgaand, in zeer geavanceerde geluidsmanipulatie gaan als dat je ding mocht zijn. Hou je maar vast...

en: 2.1 Your First Beeps
nl: 2.1 Je Eerste Bliepjes

en: Your First Beeps
nl: Je Eerste Bliepjes

en: Take a look at the following code:
nl: Bestudeer de volgende code:

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...
nl: Dit is waar het allemaal begint. Ga je gang, kopieer en plak deze in het codevenster aan de bovenzijde van de app (de grote witte ruimte onder de Afspeel knop). Nu, klik op Afspelen...

en: Beep!
nl: Bliep!

en: Intense. Press it again. And again. *And again...*
nl: Heftig. Klik opnieuw. En opnieuw. *En opnieuw…*

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:
nl: Woah, te gek, ik weet zeker dat je dit een hele dag kan blijven doen. Maar wacht, voordat je jezelf verliest in een oneindige stroom van bliepjes, probeer het cijfer te wijzigen:

en: Can you hear the difference? Try a lower number:
nl: Hoor je het verschil? Probeer een lager cijfer:

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*.
nl: *Maak je geen zorgen* wanneer dit niets voor jou betekent, mij betekende het ook niets toen ik er eerst aan begon. Het belangrijkste is dat je weet dat *lage getallen, lagere tonen maken* en *hoge getallen, hogere tonen*.

en: Chords
nl: Akkoorden

en: Playing a note is quite fun, but playing many at the same time can be even better. Try it:
nl: Een noot spelen kan leuk zijn, maar veel noten op het zelfde moment spelen kan het beter maken. Probeer dit:

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.
nl: Jazzy! Dus, als je meerdere „play”s typt, spelen ze allemaal op hetzelfde moment. Probeer het voor jezelf - welke cijfers klinken goed samen? En welke verschrikkelijk samen? Experimenteer, verken en ontdek dit voor jezelf.

en: Melody
nl: 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:
nl: Zo, het spelen van noten en akkoorden is leuk, maar hoe zit dat met een melodie? Wat als je noten achter elkaar wil spelen en niet op dezelfde moment? Wel dat is eenvoudig, je moet enkel een rust („sleep") zetten tussen de 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`:
nl: Hoe mooi, zo een beetje arpeggio. Dus wat betekent de '1' in 'sleep 1'? Nou het betekent de *duur van de rust*. Het betekent eigenlijk slaap voor één tel , voor 1 seconde rusten. Dus, wat als we onze arpeggio een beetje sneller willen? Nou, dan moeten we kortere slaap waarde gebruiken. Wat denk je van de helft? D.w.z. '0.5':

en: play 72
    sleep 0.5
    play 75
    sleep 0.5
    play 79
nl: lay 72
    sleep 0.5
    play 75
    sleep 0.5
    play 79

en: Notice how it plays faster. Now, try for yourself, change the times - use different times and notes.
nl: Merk op hoe het sneller speelt. Probeer dit nu voor jezelf, verander de rusttijd- gebruik verschillende tijden en 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.
nl: Wat je zeker ook kan proberen is om "tussen” noten te spelen zoals `play 52.3` and `play 52.63`. Het is absoluut niet noodzakelijk om te blijven vasthouden aan standaard „hele” noten. Speel erop los en amuseer je.

en: Traditional Note Names
nl: Traditionele 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:
nl: Als je al kennis hebt van muzieknotatie (maak je geen zorgen als dit niet het geval is, zonder deze kennis blijft het even leuk), dan wil je  bij het schrijven van een melodie, misschien liever de nootnamen gebruiken zoals: C en F# in plaats van cijfers. In Sonic Pi kan je dat.
    Je kan dan het volgende doen:

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:
nl: Denk eraan, een dubbelpunt voor de nootnaam te plaatsen, zodat deze in roze wordt. Je kan hierbij ook het octaaf aangeven door achter de nootnaam een cijfer te plaatsen:

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`.
nl: Als je een verhoogde alteratie (bv. F#) zet je een 's' achter de nootnaam, bv. `play :Fs3`. Als je een verlaagde alteratie wil maken (bv. E mol), zet dan een 'b' achter de nootnaam bv. `play :Eb3`.

en: Now go *crazy* and have fun making your own tunes.
nl: Ga nu maar lekker loos bij het maken van je eigen melodietjes, veel plezier ermee.

en: 2.2 Synth Options
nl: 2.2 Synthesizer Opties

en: Synth Options: Amp and Pan
nl: Synthesizer Opties: Amp en 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.
nl: Zoals je kan bepalen welke noot er gespeeld wordt of welke sample er wordt getriggert, zo biedt Sonic Pi een hele waaier aan mogelijkheden om geluiden te bewerken en manipuleren. We gaan velen daarvan in deze handleiding bekijken en in het hulp systeem is een uitgebreide documentatie voorzien van deze 'opties'. De belangrijkste op dit moment zijn: 'amplitude' en 'pan'. Laat ons eerst even bekijken wat opties eigenlijk zijn.

en: Options
nl: Opties

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).
nl: Sonic Pi ondersteunt het noteren van opties (afgekort: opts) voor haar synths. Opts zijn controle-elementen  die je samen met het commando 'play' doorgeeft die wijzigingen en manipulaties van het afgespeelde geluid. Elke synth heeft zijn eigen unieke set van opts om haar geluid fijn af te stemmen. Er zijn echter opts die bij elke synth, of bij elk geluid gebruikt kunnen worden zoals 'amp:' en 'envelope' (= geluidsverloop) opties (In een andere sectie gaan we dieper op die 'envelopes' in).

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`.
nl: Opts bestaan uit twee belangrijke delen (de naam van het element waar je controle over wil hebben) en de waarde hiervan (de mate van controle over dit element). Een voorbeeld, je hebt een opt genaamd 'kaas' en je wilt deze instellen op een waarde van '1'.

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:
nl: Opts worden samen met 'play' commando's doorgegeven, dor gebruik te maken van een komma ',' gevolgd door de naam van de optie, we kiezen hier 'amp:' (vergeet de dubbelpunt niet ':' ) gevolgd door een spatie en de waarde van de optie. Bijvoorbeeld:

en: play 50, cheese: 1
nl: play 50, kaas: 1

en: (Note that `cheese:` isn't a valid opt, we're just using it as an example).
nl: (Merk op dat ' kaas: "geen geldige opt is, we gebruiken deze gewoon als voorbeeld).

en: You can pass multiple opts by separating them with a comma:
nl: Je kan meerdere opts tegelijk doorgeven door deze te scheiden met een komma:

en: play 50, cheese: 1, beans: 0.5
nl: play 50, kaas: 1, eieren: 0.5

en: The order of the opts doesn't matter, so the following is identical:
nl: De volgorde van de opts maakt niet uit, dus het volgende is identiek:

en: play 50, beans: 0.5, cheese: 1
nl: play 50, eieren: 0.5, kaas: 1

en: Opts that aren't recognised by the synth are just ignored (like `cheese` and `beans` which are clearly ridiculous opt names!)
nl: Opts die door de synth niet worden herkent zullen gewoon genegeerd worden (zoals 'kaas' en 'eieren' duidelijk zeer ridicule opt namen!)

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:
nl: Mocht je per ongeluk twee keer dezelfde opt hebben ingevoerd maar met verschillende waarden, dan zal de laatste waarde winnen. Bijvoorbeeld, 'eieren' zal de waarde 2 hebben in plaats van 0.5:

en: play 50, beans: 0.5, cheese: 3, eggs: 0.1, beans: 2
nl: play 50, eieren: 0.5, kaas: 3, tomaat: 0.1, eieren: 2

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:`.
nl: Opts worden door veel items in Sonic Pi geaccepteerd, dus probeer deze onder de knie te krijgen, het loont echt! Laten we wat spelen met onze eerste 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.
nl: Amplitude is de representatie van het geluidsvolume op een computer. Een hoge amplitude produceert het geluid op een luid volume en een lage amplitude op een zacht volume. Net zoals Sonic Pi cijfers gebruikt om noten en tijden aan te geven, gebruikt het cijfers om amplitude te bepalen. Een amplitude van '0' is stil (je zal niets horen) en een amplitude van '1' is een normaal volume. Je kan het volume zelfs nog opdrijven en verhogen tot 2, 10, 100. Maar u moet er wel rekening mee houden dat wanneer het globale volume te hoog wordt, zal Sonic Pi een compressie inschakelen en het geluid onderdrukken om ervoor te zorgen dat je oren gespaard blijven. Dit kan het geluid dan weer dof en vreemd doen laten klinken. Dus is het beter lage amplitudes te gebruiken, dwz. tussen 0 tot0.5 om compressie te vermijden.

en: Amp it up
nl: Amp 't op

en: To change the amplitude of a sound, you can use the `amp:` opt. For example, to play at half amplitude pass 0.5:
nl: Om de amplitude van een geluid te veranderen, kan je de 'amp:' optie gebruiken. Bijvoorbeeld, op gemiddelde amplitude afspelen, gebruik dan 0.5:

en: To play at double amplitude pass 2:
nl: Afspelen op dubbel zo hoge amplitude gebruik 2:

en: The `amp:` opt only modifies the call to `play` it's associated with. So, in this example, the first call to play is at half volume and the second is back to the default (1):
nl: De amp opt verandert enkel de 'play' oproep waarmee deze wordt geassocieerd. In dit voorbeeld zal de eerste oproep dus aan de helft van het volume spelen en de tweede op standaard-instelling (1):

en: Of course, you can use different `amp:` values for each call to play:
nl: Natuurlijk kunnen verschillende 'amp:' waarden per 'play' oproep worden gebruikt:

en: Panning
nl: Pannen

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.
nl: Een ander leuke opt om te gebruiken is 'pan:' die bepaalt de panning van een geluid in stereo. Naar links pannen betekent dat je het geluid door de linker-luidspreker hoort,  naar rechts pannen betekent dat je het geluid door de rechter-luidspreker hoort. Onze cijferwaarde -1 betekend helemaal links, 0 geeft het midden weer en 1 geeft helemaal rechts van ons stereobeeld. Natuurlijk zijn we vrij om elke waarde tussen -1 en 1 te gebruiken om de exacte positie van ons geluid te bepalen.

en: Let's play a beep out of the left speaker:
nl: Laten we eens een bliepje uit de linkerluidspreker doen klinken:

en: Now, let's play it out of the right speaker:
nl: En nu uit de rechter luidspreker:

en: Finally let's play it back out of the center of both (the default position):
nl: En nu terug vanuit beiden samen (standaard positie):

en: Now, go and have fun changing the amplitude and panning of your sounds!
nl: Doe nu maar, en veel plezier met het veranderen van de amplitude en het pannen van uw geluiden!

en: 2.3 Switching Synths
nl: 2.3 Synths Veranderen

en: Switching Synths
nl: Synths Veranderen

en: Buzzy saws and prophets
nl: Drukke Zaagtand-golven en "Prophets"

en: A fun sound is the *saw wave* - let's give it a try:
nl: Een leuke klank is de *zaagtand-golf*, laten we deze uitproberen:

en: Let's try another sound - the *prophet*:
nl: Laten we nog een andere klank proberen, de *prophet*:

en: How about combining two sounds. First one after another:
nl: Hoe zit het dan met het combineren van twee verschillende klanken? Eerst de ene na de andere:

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`.
nl: Merk hierbij op dat het `use_synth` commando, alleen invloed heeft op de daarop volgende oproepen van 'play'. Stel je deze even voor,als een grote schakelaar, die bij nieuwe 'play' opvragingen, eender welke synth laat afspelen waar momenteel naar verwezen wordt. Je kan die dan omschakelen naar andere synth door het gebruik van `use_synth`.

en: Discovering Synths
nl: Synths Ontdekken

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.
nl: Speel nu een beetje met dit schakelen van synths terwijl je muziekstuk afspeelt. Veel plezier met het combineren van synths om nieuwe klanken te maken of om verschillende secties in uw muziekstuk van verschillende synths te voorzien.

en: 2.4 Duration with Envelopes
nl: 2.4 Geluidsduur met "Envelopes"

en: Duration with Envelopes
nl: Geluidsduur met "Envelopes"

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.
nl: In een eerdere sectie, hebben we gezien hoe we de opdracht 'sleep' gebruiken om te bepalen wanneer we onze geluiden activeren . We zijn echter nog in staat geweest om te bepalen hoe lang onze klank duurt.

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:
nl: Om ons een eenvoudig maar krachtig middel te geven waar we de controle hebben over de tijdsduur van onze klank, biedt Sonic Pi ons een zekere manier van notering van een zogenaamde *ADSR amplitude envelope* (we bespreken later in deze sectie wat dat betekent). Een amplitude "envelope" biedt twee manieren van controle:

en: control over the duration of a sound
nl: controle over de duurtijd van een klank

en: control over the amplitude of a sound
nl: controle over de amplitude van een klank

en: Duration
nl: Duurtijd

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.
nl: De duurtijd is de lengte dat een klank aanhoud . Een langere duur betekent dat u de klank langer hoort. De klanken van Sonic Pi hebben allen een instelbare amplitude envelop, de totale duur van die envelop is dan de totale duurtijd van die klank. Daarom kan je, door het instellen van de envelop,  de duurtijd bepalen.

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.
nl: De ADSR envelop regelt niet alleen de duurtijd, het geeft je ook een *fijnregeling van de geluidssterkte van de klank*. Alle hoorbare klanken starten en eindigen van en naar onhoorbaarheid en bevatten, tussendoor, luidere en minder luide delen. De ASDR envelop staat je toe de geluidssterkte van de hoorbare gedeelten van een klank te verschuiven en vast te houden. Zoals je iemand instructies zou geven aan het volume van een gitaarversterker en deze van stil, naar langzaam omhoog tot het hoogste volume en deze even aan te laten houden, om deze dan, snel of traag, terug naar stil te brengen. Door de envelop kan je dit gedrag in Sonic Pi programmeren.

en: Just to recap, as we have seen before, an amplitude of 0 is silence and an amplitude of 1 is normal volume.
nl: Even recapituleren, zoals we eerder hebben gezien, is een amplitude van 0 is stilte en een amplitude van 1 is het normale volume.

en: Now, let us look at each of the parts of the envelopes in turn.
nl: Laten we nu kijken naar elk onderdeel van de envelop.

en: Release Phase
nl: Release fase

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):
nl: Het enige deel van de envelop die standaard wordt gebruikt is de release tijd. Dit is de tijd die nodig is om het geluid van een synth uit te vervagen. Alle synthesizers hebben een release tijd van 1, wat betekent dat ze standaard een duur van 1 beat hebben (en dus op onze standaard 60 BPM, 1 seconde lang is):

en: The note will be audible for 1 second. Go ahead and time it :-) This is short hand for the longer more explicit version:
nl: De noot zal 1 seconde lang hoorbaar zijn. Chronometreer maar :-) Dit is de verkorting van de langere, meer uitgesproken versie:

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:
nl: Merk op dat deze exact hetzelfde klinkt (de klank duurt één seconde). Het is dus heel makkelijk om de duurtijd in te stellen door de waarde te veranderen van de  `release:` optie:

en: We can make the synth sound for a very short amount of time by using a very small release time:
nl: We kunnen de synth voor een heel korte tijd laten klinken door een heel korte release tijd te gebruiken:

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:
nl: De duur van het “vrijlaten" van het geluid noemen we de *release fase* en staat standaard op een lineaire overgang ingesteld (dwz rechtlijnig).Het volgende diagram illustreert deze overgang:

en: You can therefore change the duration of your sound by changing the release time. Have a play adding release times to your music.
nl: Je kan dus de duurtijd van je klank veranderen aan de hand van de release tijd. Speel hier even mee, door deze release tijden toe te voegen aan je klanken.

en: Attack Phase
nl: Aanslag fase (de Attack)

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:
nl: De aanslag fase is voor alle synths standaard ingesteld op 0, wat betekend dat deze onmiddellijk van 0 naar 1 gaat. Dit geeft aan de synth een korte hevige klank zoals bij een percussie-instrument. Maar misschien wil je je geluid zachtjes luider laten worden. Dit kunnen we met de `attack:` optie. Probeer nu eens van klanken te laten aanzwellen:

en: You may use multiple opts at the same time. For example for a short attack and a long release try:
nl: Je kan meerdere opties tegelijk kiezen. Probeer deze bijvoorbeeld voor een kortere aanslag en een langere uitloop:

en: This short attack and long release envelope is illustrated in the following diagram:
nl: Deze korte attack en lange release envelop wordt geïllustreerd in het volgende diagram:

en: Of course, you may switch things around. Try a long attack and a short release:
nl: Natuurlijk, kan je de dingen omdraaien. Probeer een lange attack en een korte release:

en: Finally, you can also have both short attack and release times for shorter sounds.
nl: Voorts kan je ook korte Attack en release tijden hebben voor korte klanken.

en: Sustain Phase
nl: SustainFase

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.
nl: Naast het opgeven van attack en release tijden, u kunt ook een sustain-tijd opgeven om de *sustain fase* in te stellen. Dit is de tijd dat het geluid bij een volledige amplitude tussen de attack en de release fase wordt gehandhaafd.

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.
nl: De sustain-tijd is nuttig voor de klanken die je een volledige tegenwoordigheid in de mix wil geven voordat deze een release fase doorlopen. Natuurlijk, is het volkomen geldig om zowel de `attack:` als de  `release:` optie in te stellen op 0, om gewoon geen fade in- of fade out aan het geluid toe te voegen. Maar hier moet je mee opletten, een release van 0 kan klikjes in de audio produceren en het is vaak beter om een zeer kleine waarde te gebruiken zoals 0,2.

en: Decay Phase
nl: Verval fase (Decay Phase)

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:
nl: Voor een extra controle niveau kunt u ook de verval tijd instellen. Dit is de fase van de envelop die past tussen de attack en sustain fasen en geeft u een tijdwaarde waarbij de amplitude zal dalen het  `attack_niveau:` naar het `decay_niveau:` (die, tenzij u die expliciet instelt, op het ' sustain_niveau:' gebracht zal worden). Standaard, is de `decay:` optie 0 en hebben zowel attack en sustain niveaus zijn 1, deze zal je dus moeten opgeven voor de verval  tijd effect heeft:

en: Decay Level
nl: Verval niveau

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:
nl: Eén laatste truc is dat, hoewel de `decay_level:` optie standaard dezelfde waarde heeft ingesteld als `sustain_level:`, je deze wel expliciet kan instellen op verschillende waarden voor de volledige controle over de envelop. Hierdoor kan je een envelop maken zoals deze:

en: It's also possible to set the `decay_level:` to be higher than `sustain_level:`:
nl: Het is ook mogelijk om het  `decay_niveau:` hoger te zetten dan het `sustain_niveau:`:

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

en: ADSR Envelopes
nl: ADSR Enveloppen

en: So to summarise, Sonic Pi's ADSR envelopes have the following phases:
nl: Dus samengevat , hebben Sonic Pi's ADSR enveloppen de volgende fasen:

en: *attack* - time from 0 amplitude to the `attack_level`,
nl: *attack* - tijd vanaf 0 amplitude naar `attack_niveau`,

en: *decay* - time to move amplitude from `attack_level` to `decay_level`,
nl: *decay* - tijd om de amplitude van `attack_niveau` naar `decay_niveau` te brengen,

en: *sustain* - time to move the amplitude from `decay_level` to `sustain_level`,
nl: *sustain* - tijd om de amplitude van `decay_niveau` naar `sustain_niveau` te brengen,

en: *release* - time to move amplitude from `sustain_level` to 0
nl: *release* - tijd om de amplitude van `sustain_niveau` naar 0 te brengen

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:
nl: Het is belangrijk op te merken dat de duur van een geluid de som is van van de tijd van elk van deze fasen. Daarom zal het volgende geluid een duur van 0,5 + 1 + 2 + 0,5 = 4 hebben:

en: Now go and have a play adding envelopes to your sounds...
nl: Nu gaan we hiermee spelen, door deze envelop aan jouw klanken toe te voegen…

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.
nl: Een andere goede manier om je muziek op te bouwen is het gebruik van vooraf opgenomen geluiden. In de traditie van de hip-hop, noemen we deze vooraf opgenomen geluiden *samples*. Dus, als je met een microfoon buiten gaat en je neemt het geluid van de regen op, dat zachtjes tegen een zeil tikt, heb je een sample gemaakt.

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...
nl: Sonic Pi laat je allerlei prettige dingen doen door gebruik te maken van samples. En niet alleen omdat deze over de 90 samples aan boord heeft waar je mee aan de slag kan gaan, ook laat het je toe om jouw eigen samples te gebruiken en deze te manipuleren. We vertrekken...

en: 3.1 Triggering Samples
nl: 3.1 Samples Triggeren

en: Triggering Samples
nl: Samples Triggeren

en: Playing beeps is only the beginning. Something that's a lot of fun is triggering pre-recorded samples. Try it:
nl: Bliepjes spelen was slechts het begin. Vooraf opgenomen samples triggeren is ook echt fijn . Probeer het:

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:
nl: Sonic Pi bevat vele samples waarmee je aan de slag kunt gaan. Je kan ze gebruiken met het `play` commando, net zoals de bliepjes. Als je meerder samples en noten wil gebruiken kan je ze dus achter elkaar schrijven:

en: If you want to space them out in time, use the `sleep` command:
nl: Als je ze in tijd wil verspreiden, maak dan gebruik van het `sleep` commando:

en: Discovering Samples
nl: Samples Ontdekken

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:
nl: Alternatief kan je het *auto-vervollediging systeem* gebruiken.  Typ enkel het begin van de groep waartoe de sample behoort zoals `sample :ambi_`  en je zal een menu zien openklappen waarin de samples weergegeven worden die je kan selecteren. Probeer de volgende categorie-voorvoegsels:

en: Now start mixing samples into your compositions!
nl: Begin nu de samples in je composities te mixen!

en: Sample Parameters: Amp and Pan
nl: Sample Parameters: Amp en 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:`.
nl: Zoals we met synths zagen, kunnen we gemakkelijk onze geluiden met parameters regelen. Samples steunen op precies hetzelfde parameter mechanisme. Laten we opnieuw onze vrienden `amp:` en `pan:` erbij halen.

en: Amping samples
nl: Samples amp-en

en: You can change the amplitude of samples with exactly the same approach you used for synths:
nl: Je kan de amplitude van de samples met precies dezelfde aanpak instellen die je voor synthesizers gebruikt:

en: Panning samples
nl: Samples Pannen

en: We're also able to use the `pan:` parameter on samples. For example, here's how we'd play the amen break in the left ear and then half way through play it again through the right ear:
nl: We kunnen ook gebruik maken van de `pan:` parameter op samples. Bijvoorbeeld, hier zouden we de amen break met het linker oor en halverwege met het rechter oor horen:

en: Note that 0.877 is half the duration of the `:loop_amen` sample in seconds.
nl: Merk op dat 0.877 de helft van de lengte is, van de ': loop_amen' sample in seconden uitgedrukt.

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`.
nl: Hou er tenslotte ook rekening mee dat als je sommige synths van het commando `use_synth_defaults` voorziet (welke we later zullen bespreken), deze door `sample` zullen genegeerd worden.

en: 3.3 Stretching Samples
nl: 3.3  Samples Stretchen

en: Stretching Samples
nl: Samples Stretchen

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.
nl: Nu  we  met verschillende synths en samples muziek kunnen gaan spelen, is het tijd om te leren hoe je zowel de synths als de samples in kan stellen om de muziek nog meer uniek en interessant te maken. Ten eerste, laten we  de mogelijkheid onderzoeken om te samples te *stretchen* of te *krimpen*.

en: Sample Representation
nl: Sample Representatie

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.
nl: Samples zijn eigenlijk vooraf opgenomen geluiden die opgeslagen zijn als getallen die het verplaatsen van de conus van de luidspreker veroorzaken, om het geluid te kunnen representeren. De conus van de luidspreker kan zich naar voor en naar achter verplaatsen , en dus hoeven de nummers alleen maar weer te geven, hoe ver in en uit de kegel op elk moment in de tijd moet bewegen. Om een getrouwe afspiegeling van een opgenomen geluid te kunnen zijn moet de sample meestal vele duizenden nummers per seconde opslaan! Sonic Pi neemt deze lijst van nummers en voedt hen met de juiste snelheid, om de luidspreker van uw computer op de juiste manier in en uit te verplaatsen om het geluid te kunnen weergeven. Het is echter ook leuk om  de snelheid waarmee de nummers worden gevoed aan de luidspreker te veranderen, om het geluid te veranderen .

en: Changing Rate
nl: Koers wijzigen (rate)

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`:
nl: Laten we even spelen met één van de  ambient sounds: `:ambi_choir`. Om deze af te spelen op de standaard ingestelde koers, kan je een `rate:` optie aan `sample` doorgeven:

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`:
nl: Deze speelt de normale koers (1), nog niets bijzonders dus. We zijn echter vrij om dat cijfer te veranderen naar iets anders. Hoe zit het met '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.
nl: Woah! Wat gebeurt hier? Nou, twee dingen. Ten eerste, de sample duurt twee keer zo lang in deze weergave, ten tweede is het geluid een octaaf lager. Laten we deze dingen meer in detail gaan bekijken.

en: Let's stretch
nl: Laten we 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:
nl: Een sample die is leuk om te stretchen en te comprimeren is de Amen Break. Op normale koers, kunnen we het ons voorstellen deze in een *drum 'n' bass* track te gooien:

en: However by changing the rate we can switch up genres. Try half speed for *old school hip-hop*:
nl: Door de koerssnelheid te veranderen kunnen we van genre schakelen. Probeer eens halve snelheid voor *old school hiphop*:

en: If we speed it up, we enter *jungle* territory:
nl: Als we het versnellen, komen we op het grondgebied van *jungle*:

en: Now for our final party trick - let's see what happens if we use a negative rate:
nl: En nog een laatste truc - laten we eens kijken wat er gebeurt als we gebruik maken van een negatieve koers:

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.
nl: Woah! Nu speelt het *achteruit*! Proberen nu met een heleboel verschillende samples aan verschillende koerssnelheden te spelen. Probeer zeer snelle rates. Probeer gek trage rates. Zie welke interessante geluiden je zo kan produceren.

en: A Simple Explanation of Sample Rate
nl: Een eenvoudige uitleg over de Sample Rate

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.
nl: Een handige manier van denken is om samples te zien als een veer. Afspeel snelheid is als het stretchen en indrukken van de veer. Als je de sample aan snelheid (rate) 2 afspeelt, ben je de *veer aan het indrukken* met de helft daarvan, heb je de veer in rust. Het neemt de sample dus de helft van de tijd om te spelen, aangezien deze nu korter is. Als je de sample aan half tempo speelt, *stretch je de veer* tot het dubbele van zijn lengte. De sample neemt daarom tweemaal zolang tijd om te spelen, aangezien deze nu langer is. Hoe meer u indrukt (hogere snelheid), hoe korter deze wordt, hoe meer je stretcht (lagere snelheid), hoe langer deze wordt.

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*.
nl: Het comprimeren van een veer verhoogt de dichtheid (het aantal windingen per cm) - deze is vergelijkbaar met de sample die dan *hoger gepitcht* klinkt. De veer rekken neemt de dichtheid af en is dan vergelijkbaar met het geluid met een *lagere toonhoogte*.

en: The Maths Behind Sample Rate
nl: De wiskunde achter Sample Rate

en: (This section is provided for those that are interested in the details. Please feel free to skip it...)
nl: (Deze sectie is bedoeld voor degenen die geïnteresseerd zijn in de details. Je kan deze gerust overslaan...)

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:
nl: Zoals we hierboven zagen, wordt een sample vertegenwoordigd door een grote lange lijst nummers, die de luidspreker vertelt waar deze zou moeten zijn doorheen een zekere tijd. We kunnen deze lijst van getallen gebruiken om bv. deze grafiek te tekenen:

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.
nl: Misschien hebt u al wel eens afbeeldingen gezien zoals deze. Het is een *geluidsgolf* van een sample.Het is gewoon een grafiek van getallen. Meestal zal een golfvorm 44100 punten per seconde bevatten over de gegevens (dit is te wijten aan de Nyquist-Shannon sample-theoriën). Dus, als de sample 2 seconden duurt, za de golfvorm vertegenwoordigd worden door 88200 nummers die we aan de luidspreker met een snelheid van 44100 punten per seconde zouden voeden. Natuurlijk, kunnen we deze aan dubbele snelheid voeden, dat zou dan 88200 punten per seconde zijn. Dit zou dus slechts 1 seconde in beslag nemen om af te spelen. We kunnen ook aan halve snelheid afspelen, dat zou 22050 punten per seconde zijn waarbij deze 4 seconden nodig heeft om af te spelen.

en: The duration of the sample is affected by the playback rate:
nl: De duur van de sample wordt beïnvloed door de afspeelsnelheid (rate):

en: Doubling the playback rate halves the playback time,
nl: De afspeelsnelheid verdubbelen, halveert de afspeeltijd,

en: Halving the playback rate doubles the playback time,
nl: Halvering van de afspeelsnelheid, verdubbelt de afspeeltijd,

en: Using a playback rate of one fourth quadruples the playback time,
nl: Een kwart van de afspeelsnelheid, verviervoudigt de speeltijd,

en: Using a playback rate of 1/10 makes playback last 10 times longer.
nl: 1/10 van de afspeelsnelheid, maakt het afspelen 10 keer langer.

en: We can represent this with the formula:
nl: Wij kunnen deze representeren met de formule:

en: new_sample_duration = (1 / rate) * sample_duration
nl: new_sample_duur = (1 / rate) * sample_duur

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.
nl: De afspeelsnelheid zal ook de toonhoogte van de sample wijzigen. De frequentie of toonhoogte van een golfvorm wordt bepaald door hoe snel deze op en neer beweegt. Onze hersenen vormen  de snelle beweging van luidsprekers om tot hoge noten en de trage beweging tot lage noten. Daarom kan je soms zelfs zien hoe uit een grote bas luidspreker de super lage tonen worden gepompt, en in feite gaan deze veel trager dan een luidspreker die hoge noten reproduceert.

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.
nl: Als je een golfvorm neemt van een geluid en deze over de lengte samendruk,t zal deze per seconde vaker op en neer gaan. Dit zal het geluid hoger laten klinken.Het blijkt dat een verdubbeling van het aantal op en neer bewegingen (trillingen) de frequentie verdubbelt . Ook zal *bij het afspelen van je sample aan dubbele rate, de frequentie verdubbelen die je hoort*. Dus ook zal *een halvering van de rate waarde, de frequentie halveren*. Andere waarden zullen de frequenties dan naargelang beïnvloeden.

en: 3.4 Enveloped Samples
nl: 3.4 Envelop op Samples

en: Enveloped Samples
nl: Envelop op Samples

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.
nl: Het is ook mogelijk om  de *duur* en *amplitude* te wijzigen van een samples met behulp van een ADSR-envelop. Nochtans, werkt dit enigszins anders dan de ADSR envelop voor synths. Sample enveloppen kunnen alleen de amplitude en de duur van een sample verminderen  - en nooit om deze te verhogen. De sample wordt gestopt wanneer de sample is afgespeeld of de envelop heeft voltooid - welke van deze het eerst is. Dus, bij een erg lange release:`, het zal de sample niet verlengen.

en: Amen Envelopes
nl: Amen Envelop

en: Let's return to our trusty friend the Amen Break:
nl: Laten we terugkeren naar onze trouwe vriend de 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:
nl: Zonder opties zullen we de volledige sample horen aan normale volle amplitude. Als we deze met behulp van het volume in willen mixen over een tijd van 1 seconde kunnen we de `attack:` parameter gebruiken:

en: For a shorter fade in, choose a shorter attack value:
nl: Voor een kortere fade in, kies een kleinere waarde voor de attack:

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.
nl: Waar de ADSR envelop zeker van gedrag verschilt met de standaard synth-envelop is in de *sustain* waarde. In de standaard synth envelop, is de sustain waarde, standaard op 0 ingesteld, tenzij u deze handmatig instelt. Met samples, is de sustain waarde, standaard  een *automagische* waarde - namelijk de speelduur die de sample rest . Dit is de reden waarom we de totale sample horen als we geen waarden instellen. Als de attack, decay, sustain en release waarden allen 0 waren zouden we  niks horen . Sonic Pi berekent dus hoe lang de sample is, trekt elke attack, decay en release tijden af en wordt het resultaat, de sustain tijd. Als de som van de attack, decay en release waarden meer dan de duur van de sample zijn, is de sustain gewoon ingesteld op 0.

en: To explore this, let's consider our Amen break in more detail. If we ask Sonic Pi how long the sample is:
nl: Om deze te ontdekken, laten we dan onze Amen break in meer detail bekijken. Als wij Sonic Pi nu eens vragen hoe lang de sample is:

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:
nl: Het zal `1.753310657596372` uitprinten wat de de lengte is  van de sample in seconden uitgedrukt. Laten we dit gewoon even afronden naar '1,75' voor het gemak hier. Nu, als we de release naar '0,75' instellen zal er iets verrassend gebeuren:

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.
nl: Het zal de eerste seconde van de sample met volledige amplitude afspelen voordat deze dan uit-fade over een periode van 0.75 seconden. Dit is de *auto sustain* in actie. Standaard werkt de release altijd vanaf het einde van de sample. Als onze sample 10.75 seconden lang was, zou het de eerste 10 seconden spelen met volledige amplitude vooraleer deze met 0.75s uit te fade-en .

en: Remember: by default, `release:` fades out at the end of a sample.
nl: Dus onthoud: standaard geeft de release, aan het einde van de sample, een fade-out .

en: Fade In and Out
nl: Fade In en Uit

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:
nl: We kunnen `attack:` een `release:` samen met het gedrag van de auto sustain gebruiken om in de duurtijd van de sample  in en uit te fade-en:

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.
nl: Als de totale duurtijd van de sample 1.75s is en onze attack en release fase opgeteld 1.5 is, wordt de sustain fase automatisch op 0.25 ingesteld. Dit staat ons toe van makkelijk in en uit te fade-en.

en: Explicit sustain
nl: Expliciete sustain

en: We can easily get back to our normal synth ADSR behaviour by manually setting `sustain:` to a value such as 0:
nl: We kunnen makkelijk naar ons normale synth ADSR gedrag terugkeren door de `sustain:` manueel naar een waarde te brengen zoals bv. 0:

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.
nl: Nu zal onze sample in totaal 0.75s spelen. Met de standaard waarden voor `attack:` en`decay:` van 0, springt de sample recht naar volle amplitude, zal 0s sustain-en maakt een neerwaardse release tot amplitude 0 over een periode van 0.75s.

en: Percussive cymbals
nl: Percussieve cymbalen

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`:
nl: We kunnen dit gedrag goed gebruiken om langer klinkende geluiden om te zetten naar korte, meer percussieve geluiden. We overwegen dit even met de sample `:drum_cymbal_open`:

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:
nl: Je hoort het cimbaal over een zekere periode uitzingen. We kunnen nu de envelop gebruiken om deze meer percussief te maken:

en: You can then emulate hitting the cymbal and then dampening it by increasing the sustain period:
nl: Je kan het slaan op de cymbaal, en het dempen ervan veranderen, door de sustain fase te vergroten:

en: Now go and have fun putting envelopes over the samples. Try changing the rate too for really interesting results.
nl: Leef je uit door aan samples een envelop toe te voegen. Probeer ook de rate te veranderen voor echt interessante resultaten.

en: 3.5 Partial Samples
nl: 3.5 gedeeltelijke Samples

en: Partial Samples
nl: gedeeltelijke 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:
nl: Deze sectie zal onze verkenning afsluiten van Sonic Pi's sample player. Laten we een snelle samenvatting maken. Tot nu toe hebben we gekeken hoe we samples kunnen triggeren:

en: We then looked at how we can change the rate of samples such as playing them at half speed:
nl: Vervolgens hebben we gekeken hoe we de rate kunnen wijzigen naar bv. het afspelen op halve snelheid:

en: Next, we looked at how we could fade a sample in (let's do it at half speed):
nl: Verder hebben we gekeken hoe we deze sample konden in fade-en (we doen deze op halve snelheid):

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:
nl: We hebben ook gekeken hoe we de start van een sample meer percussief kunne maken door aan de `sustain:` een expliciete waarde te geven en aan zowel de attack als de release korte waarden te geven:

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?
nl: Zou het niet leuk zijn, als we deze niet altijd hoeven te laten starten vanaf het begin van de sample? Zou het niet leuk zijn, als we deze niet altijd hoeven te laten stoppen tot het einde van de sample?

en: Choosing a starting point
nl: Startpunt kiezen

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:
nl: Het is mogelijk om een willekeurige startpunt in de sample te kiezen als een waarde tussen 0 en 1, waarbij 0 is het begin van de sample 1 is het einde en 0,5 is halverwege sample. Laten we proberen om alleen de laatste helft van de amen break te spelen:

en: How about the last quarter of the sample:
nl: Of het laatste kwart van de sample:

en: Choosing a finish point
nl: Eindpunt kiezen

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:
nl: Ook is het mogelijk om een willekeurig eindpunt te bepalen in de sample met een waarde tussen 0 en 1. Laat ons de Amen Break halverwege doen stoppen:

en: Specifying start and finish
nl: Specifieke begin- en eindpunten opgeven

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:
nl: Natuurlijk kunnen we deze alle twee gebruiken om elk willekeurig segment van het audiobestand af te laten spelen. Hoe zit dat met een heel kleine sectie ergens in het midden:

en: What happens if we choose a start position after the finish position?
nl: Wat gebeurd er als we een startpunt achter het eind punt kiezen?

en: Cool! It plays it backwards!
nl: Cool! Het speelt achterstevoren!

en: Combining with rate
nl: Combineren met rate

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:
nl: We kunnen deze nieuwe mogelijkheid combineren om een willekeurige selectie in ons audiofragment met onze oude vriend `rate:`. We kunnen bijvoorbeeld een heel klein stukje in het midden van onze amen break sample traag laten afspelen:

en: Combining with envelopes
nl: Combineren met de envelop

en: Finally, we can combine all of this with our ADSR envelopes to produce interesting results:
nl: Tot slot kunnen we dit alles combineren met onze ADSR envelop om tot interessante resultaten te komen:

en: Now go and have a play mashing up samples with all of this fun stuff...
nl: Experimenteer er nu maar even op los en maak leuke mash-ups van samples met deze toffe nieuwigheden...

en: 3.6 External Samples
nl: 3.6 Externe Samples

en: External Samples
nl: Externe Sample

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.
nl: Terwijl de ingebouwde samples je direct lanceren om mee aan de slag te laten gaan, wil je misschien experimenteren met ander vooraf opgenomen materiaal om jouw muziek mee te maken. Sonic Pi ondersteund dit ook. Vooraleerst, gaan we eerst even snel iets anders bespreken nl. de portabiliteit van jouw muziekstuk.

en: Portability
nl: Portabiliteit

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.
nl: Wanneer je je muziekstuk louter met de ingebouwde synth's en samples componeert, is de code het enige wat je nodig hebt om een getrouwe weergave van jou muziek te horen. Fantastisch toch,als je hier even over nadenkt! Een simpel stukje tekst dat je rond kan e-mailen  of in een [Gist](https://gist.github.com) kan steken, vertegenwoordigd alles wat je nodig hebt om jouw klanken te laten horen. Dit maakt het *echt makkelijk om te delen* met jouw vrienden, daar zij alleen over jouw stukje code moeten beschikken.

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.
nl: Als je echter met je eigen voor-opgenomen samples begint te werken verlies je deze portabiliteit. Dit komt  omdat je nu  niet alleen de code nodig hebt, maar ook de samples om je muziek getrouw af te spelen. Dit beperkt  de mogelijkheid voor anderen om met jouw werk te gaan experimenteren, te manipuleren of een mash up van te  maken. Natuurlijk mag dit jou niet tegenhouden om je eigen samples te gaan gebruiken, gewoon om even bij stil te staan.

en: Local Samples
nl: 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`:
nl: Sonic Pi zal deze samples automatisch laden en afspelen. Je kan ook alle standaard parameters toewijzen aan deze doorgegeven `sample`:

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.**
nl: **Opmerking dit gedeelte van de handleiding behandeld een meer geavanceerd thema, nl. over het werken met grote bestanden van eigen samples. Dit zal bijvoorbeeld het geval zijn als je sample packs kocht of hebt gedownload en deze in Sonic Pi wenst te gebruiken.**

en: **Feel free to skip this if you're happy working with the built-in samples.**
nl: **U mag dit gedeelte gerust overslaan wanneer je tevreden bent met de ingebouwde samples.**

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.
nl: Wanneer je werkt met grote mappen van externe samples kan het erg onhandig zijn om telkens het hele pad te typen die jouw eigen samples triggeren.

en: For example, say you have the following folder on your machine:
nl: Bijvoorbeeld, stel dat je de volgende map hebt op je computer:

en: When we look inside that folder we find the following samples:
nl: Als we in die map kijken vinden we de volgende voorbeelden:

en: Typically in order to play the piano sample we can use the full path:
nl: Om de piano sample te spelen gebruiken we dan normaal gezien het volledige pad:

en: sample "/path/to/my/samples/120_Bb_piano1.wav"
nl: sample "/pad/naar/mijn/samples/120_Bb_piano1.wav"

en: If we want to then play the guitar sample we can use its full path too:
nl: Om vervolgens de gitaar sample te willen gebruiken we ook het volledige pad:

en: sample "/path/to/my/samples/120_Bb_guit.wav"
nl: sample "/pad/naar/mijn/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?
nl: Echter, om beide samples op te roepen zijn we genoodzaakt te weten welke de naam is van deze samples in onze map. Wat als we  snel door onze samples willen gaan om deze even te beluisteren?

en: Indexing Sample Packs
nl: Sample Packs Indexeren

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:
nl: Als we de eerste sample binnen een map willen spelen moeten we alleen de naam van de map doorgeven aan `sample` en de index `0` als volgt:

en: sample "/path/to/my/samples/", 0
nl: sample "/pad/naar/mijn/samples/", 0

en: We can even make a shortcut to our directory path using a variable:
nl: We kunnen zelfs een binnenweg maken naar ons pad van de map met behulp van een variabele:

en: samps = "/path/to/my/samples/"
    sample samps, 0
nl: samps = "/pad/naar/mijn/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:
nl: Als we dan de tweede sample in onze folder willen afspelen, moeten we gewoon 1 aan onze index toevoegen:

en: samps = "/path/to/my/samples/"
    sample samps, 1
nl: samps = "/pad/naar/mijn/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.
nl: Merk op dat we hierbij niet meer de naam van de sample in de map hoeven op te geven,  alleen de map zelf (of de snelkoppeling). Als we nu een indexnummer zouden gebruiken dat hoger is dan het aantal samples, gaan de eerste samples in de map terug aan de beurt komen, als in een kring werpt deze er zich rond. Welk nummer we ook gaan gebruiken, we komen gegarandeerd één van onze samples tegen in deze map.

en: Filtering Sample Packs
nl: Sample Packs Filteren

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:
nl: Meestal is indexeren genoeg, maar soms moeten we wat meer "power" hebben om onze samples te sorteren en te organiseren. Gelukkig voegen veel sample packs nuttige informatie in de bestandsnamen toe. Laten we nog eens kijken naar de sample-bestandsnamen in onze folder:

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.
nl: Merk op dat we in deze bestandsnamen vrij veel informatie hebben. Ten eerste hebben we de BPM van de sample (beats per minute) aan het begin. Dus, de piano sample bedraagt 120 BPM en onze eerste drie melodieën hebben 100 BPM. Ook bevatten onze samples,de toonhoogte (key). Dus de sample van de gitaar is in Bb en de melodieën zijn in A #. Deze informatie is zeer nuttig bij het mengen van deze samples, samen met onze andere code. Bijvoorbeeld, nu weten we dat de piano sample enkel in een code past die 120 BPM heeft met toonhoogte van Bb.

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:
nl: Het komt wel goed uit dat we deze bijzondere naamgeving van onze sample sets ook in de code kunnen gebruiken om onze samples uit te filteren naar degene die we willen. Bijvoorbeeld, als we op 120 BPM werken, kunnen we als volgt, alle samples uitfilteren die de tekenreeks `"120"` bevatten:

en: samps = "/path/to/my/samples/"
    sample samps, "120"
nl: samps = "/pad/naar/mijn/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:
nl: Deze zal ons een eerste filtering opleveren. Als we verder willen gaan zoeken naar een sample die goed past, kunnen we de index gebruiken:

en: samps = "/path/to/my/samples/"
    sample samps, "120", 1
nl: samps = “/pad/naar/mijn/samples/"
    sample samps, "120", 1

en: samps = "/path/to/my/samples/"
    sample samps, "120", "A#"
nl: samps = "/pad/naar/mijn/samples/"
    sample samps, "120", "A#"

en: Finally, we're still free to add our usual opts to the call to `sample`:
nl: Voorts zijn we nog altijd vrij om onze gebruikelijke opties voor de weergave van onze `sample` toe te voegen:

en: samps = "/path/to/my/samples/"
    sample samps, "120", "Bb", 1, lpf: 70, amp: 2
nl: samps = "/pad/naar/mijn/samples/"
    sample samps, "120", "Bb", 1, lpf: 70, amp: 2

en: Sources
nl: Bronnen

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.
nl: De `sample` functie zal eerst alle bronnen verzamelen en deze gebruiken om een lange lijst van kandidaten te maken.Deze lijst wordt gevormd door eerst alle geldige paden toe te voegen en daarna alle geldige  `.flac`, `.aif`, `.aiff`, `.wav`, `.wave` bestanden die deze mappen bevatten.

en: For example, take a look at the following code:
nl: Kijk bijvoorbeeld even naar deze code:

en: samps = "/path/to/my/samples/"
    samps2 = "/path/to/my/samples2/"
    path = "/path/to/my/samples3/foo.wav"
    sample samps, samps2, path, 0
nl: samps = "/pad/naar/mijn/samples/"
    samps2 = "/pad/naar/mijn/samples2/"
    path = "/pad/naar/mijn/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).
nl: Hier combineren we de inhoud van de samples binnen twee mappen en het toevoegen van een specifieke sample. Als `"/pad/naar/mijn/samples/"` 3 samples bevat en  `"/pad/naar/mijn/samples/"` bevat er 12, zouden we 16 potentiële samples om te indexeren en te filteren hebben (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:
nl: Standaard worden alleen de voorbeeldbestanden binnen een map in de lijst met kandidaten verzameld. Soms heb je misschien een aantal geneste mappen van samples die je lokaal wil gaan zoeken en filteren. Je kan daarom een recursieve zoekopdracht voor alle samples in alle sub-mappen van een bepaalde map doen door toevoeging van `**` aan het einde van het pad:

en: samps = "/path/to/nested/samples/**"
    sample samps, 0
nl: samps = "/pad/naar/geneste/samples/**"
    sample samps, 0

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.
nl: Hou er wel rekening mee dat als je door een groot aantal folders gaat zoeken,dit veel tijd in beslag kan nemen. Maar de inhoud van alle folderbronnen worden ge-cached, dus de vertraging zal maar één keer optreden.

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.
nl: Ten slotte, merk op dat de bronnen *eerst moeten gaan*. Als er geen bron is opgegeven, zal de set van ingebouwde samples geselecteerd worden als de standaardlijst van kandidaten om mee te werken.

en: Once you have a list of candidates you may use the following filtering types to further reduce the selection:
nl: Als u eenmaal een lijst van kandidaten hebt mag u het volgende filter typen om de selectie verder te reduceren:

en: `"foo"` Strings will filter on substring occurrence within file name (minus directory path and extension).
nl: `"foo"` Tekenreeksen zullen filteren op sub-tekenreeksen gebeurtenissen binnen de bestandsnaam (min het pad van de map en de extensie).

en: `/fo[oO]/` Regular Expressions will filter on pattern matching of file name (minus directory path and extension).
nl: `/fo[oO]/` Reguliere expressies zullen filteren op patroonherkenning van bestandsnamen (min het pad van de map en de extensie).

en: `:foo` - Keywords will filter candidates on whether the keyword is a direct match of the filename (minus directory path and extension).
nl: `:foo` -trefwoorden zullen naar kandidaten filteren op basis van hun gelijkenis met de bestandsnaam (min het pad van de map en extentie).

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).
nl: `lambda{|a| ... }` - Procedures met één argument zullen als een kandidaat-filter gezien worden of als een genereer-functie. 
    Het zal worden doorgegeven aan de lijst van de huidige kandidaten en moet een nieuwe lijst van kandidaten oproepen ( een lijst met geldige paden naar sample bestanden).

en: `1` - Numbers will select the candidate with that index (wrapping round like a ring if necessary).
nl: `1` - Nummers zullen de kandidaat met dit index selecteren (en als een kring rond gaan als dit nodig is).

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:
nl: We kunnen bijvoorbeeld alle samples filteren in een map die bevat de tekenreeks `"foo"` bevat en de eerste overeenkomende sample spelen op halve snelheid:

en: sample "/path/to/samples", "foo", rate: 0.5
nl: sample "/pad/naar/samples", "foo", rate: 0.5

en: See the help for `sample` for many detailed usage examples. Note that the ordering of the filters is honoured.
nl: Zie hulp voor `sample` voor vele gedetailleerde gebruiksvoorbeelden. Merk op dat de volgorde van de filters geëerd wordt.

en: Composites
nl: Mengsels

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:
nl: En tot slot, je mag lijsten gebruiken waar ook je een bron of filter kan plaatsen. De lijst zal automatisch afgevlakt worden en hun inhoud zal als reguliere bronnen en filters behandeld worden. Daarom zijn de volgende aanroepen naar `sample`, semantisch equivalent:

en: sample "/path/to/dir", "100", "C#"
    sample ["/path/to/dir", "100", "C#"]
    sample "/path/to/dir", ["100", "C#"]
    sample ["/path/to/dir", ["100", ["C#"]]]
nl: sample "/pad/naar/map", "100", "C#"
    sample ["/pad/naar/map", "100", "C#"]
    sample "/pad/naar/map", ["100", "C#"]
    sample ["/pad/naar/map", ["100", ["C#"]]]

en: Wrapping Up
nl: Rond Wikkelen

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.
nl: Dit was een geavanceerd gedeelte voor mensen die veel kracht om sample packs te manipuleren en gebruiken nodig hebben. Moest het meeste van dit deel vraagtekens oproepen, geen nood. Waarschijnlijk hebt u dan deze functionaliteit nu nog niet echt nodig. Je zal wel merken wanneer je er aan toe bent om dan terug te keren naar dit gedeelte om met grote sample bestanden te gaan werken.

en: 4 Randomisation
nl: 4 Randomiseren

en: Randomisation
nl: Randomiseren

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.
nl: Een geweldige manier om jouw muziek interessant te maken is het gebruik van willekeurige getallen. Sonic Pi heeft een goede functionaliteit om willekeurigheid in jouw muziek toe te voegen, maar eerst moeten we naakte waarheid onder ogen zien: in Sonic Pi is *random geen echte random*. Wat heeft dit nu weer te betekenen? Laat ons eens kijken.

en: Repeatability
nl: Herhaalbaarheid

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:
nl: Een heel nuttige willekeurige functie is 'rrand', welke je een willekeurige waarde tussen twee nummers geeft - een *min* en *max*. ('rrand' is kort voor ranged random (willekeurigen binnen een bepaald bereik)). Laten we proberen een willekeurige opmerking te spelen:

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!
nl: Ooh het speelt een willekeurige noot. Het speelde de noot `83.7527`. Een mooie willekeurige noot tussen 50 en 95. Hu, heb ik nu net de willekeurige noot die jij ook had exact voorspeld? Hier is iets verdacht gaande. Probeer de code nu nog eens opnieuw uit te voeren. Wat?? Het koos `83.7527` opnieuw? Niet echt random dus!

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.
nl: Het antwoord is, dat deze niet echt random is, maar pseudo-random. Sonic Pi zal jou random-achtige cijfers geven op een repetitieve manier. Dit is heel nuttig om ervoor te zorgen dat jouw muziek,gemaakt op jou toestel, hetzelfde klinkt op iemand anders toestel, ook al heb je de functie van randomiseren gebruikt in je compositie.

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:
nl: Natuurlijk, bij een zeker stukje muziek, moest het elke keer 'random' `83.7527` kiezen, dan zou het niet interessant meer zijn. Maar dat doet het niet. Probeer het volgende:

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!
nl: Ja, Eindelijk klinkt het random. Binnen een gegeven doorloop gaan de volgende opvragingen naar random functies randum waarden weergeven. Bij de daar opvolgende doorloop gaan zij echter exact dezelfde sequentie van deze random waarden spelen en dus net hetzelfde klinken. Alsof Sonic Pi terug in de tijd ging naar exact hetselfde punt elke keer de afspeelknop werd ingedrukt. De "Groundhog Day" in de wereld van muziek synthese!

en: Haunted Bells
nl: "Haunted Bells"

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:
nl: Een mooie illustratie van randomiseren in actie is het voorbeeld "haunted bell's" die de `:perc_bell`' sample laat "loop-en" met een willekeurige rate en sleep tijd tussen de klokkengeluiden:

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:
nl: Een ander leuk voorbeeld van randomiseren is het willekeurig wijzigen van de cutoff van een synth. Een geweldige synth om dit op uit te proberen is de ': tb303' emulator:

en: Random seeds
nl: Random "seeds"

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!
nl: Dus, wat als deze bijzondere reeks willekeurige getallen die  Sonic Pi biedt  je niet bevalt ? Nou is het volledig mogelijk om een ander uitgangspunt  te kiezen via 'use_random_seed'. De standaard seed instelling is 0, kies dus een andere seed voor een andere  ervaring in randomisering!

en: Consider the following:
nl: Houd rekening met het volgende:

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:
nl: Telkens wanneer u deze code uitvoert, zult u dezelfde sequentie van 5 noten horen. Voor een andere volgorde verander gewoon de seed:

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.
nl: Dit zal een andere sequentie van 5 noten produceren. Door het veranderen van de seed en door het beluisteren van de resultaten vindt u  wel iets dat u goed vind - en wanneer u deze met anderen deelt, horen zij precies wat u ook hebt gehoord.

en: Let's have a look at some other useful random functions.
nl: Laten we eens kijken naar enkele andere nuttige randomisering functies.

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`:
nl: Een zeer gebruikelijk actie zou zijn, random te kiezen uit een lijst van gekende items. Bijvoorbeeld, ik zou één van de volgende noten willen spelen: 60, 65 of 72. Ik kan dit bewerkstelligen met `choose` die mij een item uit een lijst laat kiezen. Eerst moet ik mijn getallen in een lijst zetten, hetgeen ik kan doen door deze in rechthoekige haakjes te plaatsen en door middel van komma's te scheiden: : `[60, 65, 72]. Vervolgens moet ik deze doorgeven aan  `choose`:

en: Let's hear what that sounds like:
nl: Laten we eens horen hoe dat klinkt:

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)`:
nl: We hebben `rrand` al gezien, maar laat ons deze nog even overlopen. Deze reproduceert een willekeurig getal tussen twee getallen die hierbij exclusief zijn. Dit wil zeggen dat deze getallen,noch het onderste, noch het bovenrste zal weergeven worden, maar altijd een getal tussen die twee. Het getal zal altijd een niet-geheel getal zijn- wat betekend dat dit nooit een geheel getal zal zijn, maar een breuk van een getal. Voorbeelden van niet-gehele getallen die worden gereproduceerd door `rrand(20, 110)`:

en: Occasionally you'll want a whole random number, not a float. This is where `rrand_i` comes to the rescue. It works similarly to `rrand` except it may return the min and max values as potential random values (which means it's inclusive rather than exclusive of the range). Examples of numbers returned by `rrand_i(20, 110)` are:
nl: Soms zal je een geheel getal, willen doen uitkomen in plaats van een niet-geheel getal in de ranomisering. Hier komt  `rrand_i` redding brengen. Dit werk het zelfde als `rrand` behalve dat deze hier de min en max waarden als potentiële random waarden laat uitkomen (inclusief ipv. exclusief bereik). Voorbeelden van getallen die gereproduceerd kunnen worden door `rrand` zijn:

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:
nl: Dit geeft een willekeurig niet-geheel getal tussen 0 (inbegrepen) en de max waarde die u opgeeft (exclusieve). Standaard wordt een waarde tussen 0 en 1 geretourneerd. Daarom is deze nuttig voor het kiezen van willekeurige ' amp:' waarden:

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.
nl: Vergelijkbaar met de relatie tussen 'rrand_i' en 'rrand', 'rand_i' geeft een willekeurig geheel getal tussen 0 en de max waarde die u opgeeft.

en: dice
nl: dice (teerling)

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!
nl: Soms wil je een gooi van een dobbelstenen nabootsen - dit is een speciaal geval van 'rrand_i' waar de laagste waarde altijd 1 is . Een oproep naar de 'dobbelstenen' moet je het aantal zijden op de dobbelsteen opgeven. Een standaard dobbelsteen heeft 6 zijden, en zal 'dice(6)' zich ook zo gaan gedragen - en waarden van ofwel 1, 2, 3, 4, 5 of 6 reproduceren.Maar misschien wil je wel, net zoals in een fantasy rollenspel , een 4-zijdige dobbelstenen, of een 12 zijdige dobbelstenen, of een 20 zijdige dobbelsteen - misschien zelfs een 120 zijdige dobbelsteen!

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.
nl: Tot slot wil je ook de gooi naar het hoogste getal nabootsen, zoals onze 6 op een normale dobbelsteen. `one_in` zal daarom de waarde true met een kans van één op het aantal zijden op de dobbelsteen reproduceren. Daarom geeft `one_in(6)` true met een waarschijnlijkheid van 1 in 6 terug, en  anders false . True en False waarden zijn zeer nuttig voor `if` verklaringen die wij in een latere sectie van dit leerprogramma zullen behandelen.

en: Now, go and jumble up your code with some randomness!
nl: Maak maar even een wirwar aan Random-heid!

en: 5 Programming Structures
nl: 5 Programmeerstructuren

en: Programming Structures
nl: Programmeerstructuren

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...
nl: Nu dat je de basis hebt geleerd om geluiden met 'play' en 'sample' te creëren , en eenvoudige melodieën en ritmes, door tussen de klanken  `sleep`  te gebruiken, kan je je nu gaan afvragen wat de wereld van code je nog heeft te bieden...

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.
nl: Nou, sta je voor een spannende traktatie! Het blijkt dat fundamentele programmeerstructuren zoals loops, conditionals, functies en threads jou  ongelooflijk krachtige tools geven om jou muzikale ideeën uit te drukken.

en: Let's get stuck in with the basics...
nl: We bijten ons vast in de basisbeginselen hiervan...

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:
nl: Een structuur die je vaak zal terugvinden in Sonic Pi is de blok-structuur. Deze "Blocks" kunnen ervoor zorgen dat we heel handig met grote happen code gaan kunnen omspringen. Met de Synth en sample parameters konden we deze al op een enkele lijn gaan veranderen. Soms willen we echter op een slimme manier verschillende lijnen kunnen aanspreken om hun parameters te gaan veranderen. Bijvoorbeeld, als we die willen loop-en, een reverb toe willen voegen, deze 1 van de vijf keer willen laten afspelen etc... Kijk dan even naar deze code:

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:
nl: Om iets met een stuk code-reeksen te laten gebeuren, moeten we Sonic Pi vertellen waar die blok van code moet *starten* en waar deze *eindigt*. Hiervoor gebruiken we `do` om te starten en `end` om te eindigen. Bijvoorbeeld:

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.
nl: Maar... we zijn er nog niet helemaal (als je dit zou uitproberen krijg je een foutmelding) want we hebben Sonic Pi nog niet verteld wat we willen doen met deze *do/end block*. Door een speciale code vóór de `do` te zetten kunnen we dit duidelijk maken aan Sonic Pi. We zullen deze speciale stukjes code later in deze handleiding bekijken. Het belangrijkste om weten nu, is dat als je je code inpakt met deze `do` en `end` je hiermee iets speciaal kan aanvangen.

en: 5.2 Iteration and Loops
nl: 5.2 Herhaling en Loops

en: Iteration and Loops
nl: Herhaling en Loops

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`.
nl: Tot nu toe hebben we al een heleboel tijd besteed aan de verschillende klanken die we kunnen maken met de `play` en `sample` lijnen. We hebben ook geleerd deze met een zekere regelmaat te triggeren met behulp van `sleep`.

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.
nl: Zoals je waarschijnlijk hebt ontdekt, je kan *veel* plezier beleven met deze basis bouwstenen. Er zal echter een nieuwe wereld voor je opengaan wanneer je de kracht van code gaat gebruiken om structuur te geven aan jouw muziek en composities. In de volgende secties gaan we enkele van deze krachtige hulpmiddelen verkennen. Vooraleerst zijn herhaling en loop aan de beurt.

en: Repetition
nl: Repetitieve herhaling

en: Have you written some code you'd like to repeat a few times? For example, you might have something like this:
nl: Heb je wat code geschreven dat je graag een paar keer wil herhalen? Bijvoorbeeld, zoiets als deze::

en: What if we wished to repeat this 3 times? Well, we could do something simple and just copy and paste it three times:
nl: Wat als wij deze 3 keer willen herhalen? Nou simpel, we kunnen deze drie keer kopiëren en plakken:

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.
nl: Dat is wel een heleboel code! Wat als je nu de sample `:elec_plip` wil veranderen? Dan moet je de code helemaal afgaan en overal waar deze voorkomt vervangen door de nieuwe sample. En, nog belangrijker, wat als ik de code 50 of 1000 keer wil herhalen? Dat zou een heleboel code zijn, en heel wat regels wijzigen om een verandering te maken.

en: Iteration
nl: Iteratie

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:
nl: In feite zou het herhalen van code zo eenvoudig moeten zijn als zeggen *doe dit drie keer*. Zo is het ook wel een beetje. Herinner je je onze oude vriend de code block nog? We kunnen hem gebruiken om het start- en eindpunt, van de code die we willen herhalen, aan te duiden. We gebruiken dan onze speciale code `3.times`. In plaats van *doe dit drie keer*, schrijven we `3.times do`, eenvoudig niet? Vergeet ook niet `end`op het einde van het te herhalen block te schrijven:

en: Now isn't that much neater than cutting and pasting! We can use this to create lots of nice repeating structures:
nl: Nu is dat niet veel netter dan knippen en plakken! We kunnen dit gebruiken om allerlei leuke herhalende structuren te maken:

en: Nesting Iterations
nl: Geneste Iteraties

en: We can put iterations inside other iterations to create interesting patterns. For example:
nl: We kunnen iteraties binnen andere iteraties plaatsen om interessante patronen te creëren. Bijvoorbeeld:

en: Looping
nl: Loop-en

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:
nl: Als je iets lang wil laten herhalen, ga je je misschien op betrappen van grote getallen te gebruiken zoals bv. `1000.times do`. In dat geval kan je Sonic Pi misschien beter opdragen van deze oneindig veel keer te herhalen ( als je tenminste niet op de stop-knop drukt,natuurlijk!) Laat ons de Amen Break eindeloos herhalen:

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:
nl: Belangrijk om weten is dat loops zich kunnen gedragen als zwarte gaten in je code. Eens de code in loop gaat, geraakt hij er niet meer uit tenzij je op stop drukt - de code blijft in deze loop doordraaien. Dit betekent dan, als je code hebt geschreven na de loop, je deze code *nooit* zal horen. In dit voorbeeld, zal de cymbaal na de loop nooit spelen:

en: Now, get structuring your code with iteration and loops!
nl: Nu gaan we de code structureren met iteratie en loops!

en: 5.3 Conditionals
nl: 5.3 Conditionelen

en: Conditionals
nl: Conditionelen

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.
nl: Eén van de dingen die je op een zeker moment zeker wil gaan doen is,dat je niet alleen willekeurige noten wil spelen (zie de voorgaande sectie hierover)  maar ook een willekeurige (random) beslissing kunnen maken en gebaseerd op de uitkomst van andere uitgevoerde code of andere code. Zo wil je bijvoorbeeld een drum of cimbaal willekeurig bespelen.  Dit kunnen we bereiken met de instructie 'als'.

en: Flipping a Coin
nl: Een muntje opgooien

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:
nl: Laten we een muntje opgooien: Als het kop is, speel je een trommel, als het munt is, speel je een cimbaal. Makkelijk. We kunnen kop of munt nabootsen met onze  `one_in` functie (voorgesteld in onze sectie over willekeurigheid) door een waarschijnlijkheid in te bouwen van 1 op 2: 'one_in(2)'.  We kunnen het resultaat,vervolgens gebruiken om te kunnen kiezen tussen twee stukken van de code, de code om de trommel te spelen en de code om de cimbaal  te spelen :

en: Notice that `if` statements have three parts:
nl: Merk op dat 'if' verklaringen drie delen hebben:

en: The question to ask
nl: De vraagstelling

en: The first choice of code to run (if the answer to the question is yes)
nl: De eerste keuze van de uit te voeren code (als het antwoord op de vraag ja is)

en: The second choice of code to run (if the answer to the question is no)
nl: De tweede keuze van de uit te voeren code (als het antwoord op de vraag neen is)

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.
nl: Typisch in programmeertalen, wordt ja aangeduid door de term 'true' en neen door de term 'false'. Dus moeten we een vraag vinden die ons een `true` of `false` antwoord geeft, dat is precies wat `one_in´ doet.

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:
nl: Merk op hoe de eerste keuze verpakt  is tussen `if` en `else` en de tweede keus verpakt tussen `else` en `end`. Net zoals bij een do/end blok kun je meerdere coderegels in beide plaatsen zetten. Bijvoorbeeld:

en: This time we're sleeping for a different amount of time depending on which choice we make.
nl: Dit keer hebben we verschillende rustijden afhankelijk van de keuze die wordt gemaakt.

en: Simple if
nl: Gewoon 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:
nl: Soms wilt je optioneel slechts één regel code uitvoeren. Dit is mogelijk door het plaatsen van `if` en vervolgens de vraag aan het einde. Bijvoorbeeld:

en: This will play chords of different numbers with the chance of each note playing having a different probability.
nl: Dit zal akoorden met andere getallen, bij iedere gespeelde noot, de kans op een verschillende mogelijkheid spelen.

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.
nl: Dus je hebt je fatale baslijn en een vette beat. Hoe speel je ze op hetzelfde moment? Een oplossing is deze handmatig verweven- een beetje bas , dan wat drums, wat meer bas... Lang gaat het niet duren eer je je de timing moeilijk kan voorstellen, zeker als je nog meer elementen hierin wil verweven.

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*.
nl: Wat als Sonic Pi deze automatisch kan verweven voor jou? Nou, het kan, en je het doet dat met wat heet een *thread*.

en: Infinite Loops
nl: Oneindige Loops

en: To keep this example simple, you'll have to imagine that this is a phat beat and a killer bassline:
nl: Om het voorbeeld eenvoudig te houden, moet je je voorstellen dat dit een waanzinnige baslijn is en een vette beat:

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.
nl: Zoals we reeds eerder bespraken, zijn loops zoals *zwarte gaten* voor het programma. Zodra je in loop bent geraakt, kan je deze niet verlaten totdat u op stop hebt gedrukt. Hoe spelen we dan deze beide loops op hetzelfde moment? We moeten Sonic Pi vertellen dat we iets op hetzelfde moment als de rest van de code willen beginnen. Dit is waar de threads ons redding brengen.

en: Threads to the Rescue
nl: Threads bieden redding

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!
nl: Door de eerste loop in een `in_thread` do/end block te plaatsen, vertellen we Sonic Pi de inhoud van de do/end block uit te voeren op *exact* hetzelfde moment als de volgende instructie na de do/end block (toevallig ook onze tweede lus). Probeer het en je zal de baslijn en de drums samen horen spelen!

en: Now, what if we wanted to add a synth on top. Something like:
nl: Wat als we hieraan nog een synth willen toevoegen? Zoiets als:

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:
nl: Nu hebben we hetzelfde probleem als hiervoor. De eerste loop wordt gespeeld op hetzelfde moment als de tweede loop, door onze 'in_thread'. *De derde loop wordt weer nooit bereikt*. Daarom hebben we een andere thread nodig:

en: Runs as threads
nl: Voert uit als 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.
nl: Wat je mischien zal verbazen is dat iedere keer je op de afspeel-knop drukt je eigenlijk een nieuwe thread aanmaakt voor de uitvoerende code. Vandaar dat, wanneer je meerdere keren op afspelen drukt, de klanken op elkaar hoort opstapelen. Vermits deze een thread op zich is, verweeft hij deze code voor jou automatisch.

en: Scope
nl: Toepassingsgebied

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:
nl: Als je Sonic Pi leert beheersen, ga je zien dat threads de belangrijkste bouwstenen voor jouw muziek zullen zijn. Eén van de belangrijkste taak die zij hebben is het isoleren van *de huidige staat* van andere threads. Wat betekend dit? Wel, wanneer je van synth overschakeld door het gebruik van `use_synth` schakel je van synth in *de huidige thread* - geen enkele andere thread zal van synth veranderen. Laten we dit in actie zien:

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.
nl: Merk je op dat de middelste klank anders is dan de andere? De `use_synth` declaratie zal enkel invloed hebben op de thread waarin deze zich bevind en niet op de threads daarbuiten.

en: Inheritance
nl: Erfenis

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:
nl: Wanneer je een nieuwe thread met `in_thread` creëert, zal de nieuwe thread de instellingen van de huidige thread overnemen. Laten we dit even bekijken :

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.
nl: Merk je op hoe de tweede noot met de ': tb303' synth wordt gespeeld, hoewel het door een aparte thread werd aangestuurd? Elk van de met verschillende `use_*`  functies gewijzigde instellingen, zullen zich op dezelfde manier gaan gedragen.

en: When threads are created, they inherit all the settings from their parent but they don't share any changes back.
nl: Wannneer threads worden gecreëerd, erven zij alle instellingen over van bovenliggende (parent) maar zij delen geen veranderingen aan hen terug.

en: Naming Threads
nl: Naamgeving aan Threads

en: Finally, we can give our threads names:
nl: Ook nog kunnen wij namen geven aan threads:

en: Look at the log pane when you run this code. See how the log reports the name of the thread with the message?
nl: Kijk naar het log venster wanneer u deze code uitvoert. Zie je hoe het logboek de naam rapporteert van de thread met een bericht?

en: Only One Thread per Name Allowed
nl: Slechts één thread per naam toegestaan

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:
nl: Wat je nog moet weten over benoemde threads is dat slechts één thread met een bepaalde naam tegelijkertijd kan worden uitgevoerd. Laten we dit onderzoeken met de volgende code:

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.
nl: Ga je gang en plak deze in een buffer en druk op de knop afspelen. Druk er opnieuw een paar keer. Luister naar de kakofonie van meerdere amen breaks in loop, uit de maat afspelen . OK, je mag nu op Stop drukken.

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.
nl: Dit soort gedrag hebben we al keer op keer gezien - dat als je de afspeelknop aanklikt, geluidslagen op bestaande klanken gaan stapelen. Dus als je een loop hebt en je klikt drie keer op afspelen zal je drie lagen loops tegelijkertijd horen afspelen.

en: However, with named threads it is different:
nl: Met benoemde threads is dat echter 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:
nl: Probeer de afspeel-knop meerdere malen met deze code. Je zal nu één enkele amen break loop horen. Ook zie je dit in het logboek:

en: Sonic Pi is telling you that a thread with the name `:amen` is already playing, so it's not creating another.
nl: Sonic Pi vertelt je hier dat een thread met de naam `:amen` al aan het spelen is , en gaat geen andere creëren.

en: This behaviour may not seem immediately useful to you now - but it will be very handy when we start to live code...
nl: Dit gedrag lijkt misschien niet onmiddellijk bruikbaar voor je nu - maar het zal erg handig worden wanneer we beginnen met het spelen van code live...

en: 5.5 Functions
nl: 5.5 functies

en: Functions
nl: Functies

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.
nl: Zodra u veel code begint te schrijven, kan je als je wil, een manier vinden om dingen te gaan organiseren en structureren, om deze netter te maken en gemakkelijker te begrijpen. Functies zijn een zeer krachtige manier om dit te doen. Ze brengen ons de mogelijkheid om een naam te geven aan een bundel code. Laten we een kijkje nemen.

en: Defining functions
nl: Functies definiëren

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`.
nl: Hier hebben we een nieuwe functie genaamd `foo` gedefinieerd. We doen dit met onze oude vriend het do/end blok en het magische woord `define`  gevolgd door de naam die wij willen geven aan onze functie. We hoefde deze niet `foo` te noemen, we konden deze om het even wat noemen zoals `fiets`, `bal`  of een ideale beschrijving  zoals `refrein_stuk` of `lead_riff`.

en: Remember to prepend a colon `:` to the name of your function when you define it.
nl: Vergeet niet van een dubbele punt `:` bij de naam van je functie te voegen wanneer je deze definieert.

en: Calling functions
nl: Functies aanroepen

en: Once we have defined our function we can call it by just writing its name:
nl: Eens we een functie hebben gedefinieerd kunnen we deze oproepen door gewoon zijn naam te schrijven:

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.
nl: We kunnen zelfs gebruik maken van 'foo' binnen iteratie blokken of overal waar we `spelen` of `samplen` hebben geschreven. Dit schenkt ons een geweldige manier om onszelf te uiten en nieuwe zinvolle woorden te gebruiken in onze composities.

en: Functions are remembered across runs
nl: Functies worden onthouden langsheen het uitvoer commando

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:
nl: Tot nu toe was het zo, dat telkens als u de Afspeel-knop ingedrukte, Sonic Pi met een schone lei startte. Het weet weet van niets tenzij van wat er in de buffer zit. Je kan niet verwijzen naar code die in een andere buffer of een andere thread zit. Met functies veranderd dat. Wanneer je een functie definieert zal Sonic Pi zich deze *herinneren*. Laten we dit eens proberen. Verwijder alle code uit uw buffer en vervang het met:

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`).
nl: Druk op de Afspeel-knop - en hoor je functie nu spelen. Zo zonder code? Hoe wist Sonic Pi wat het moest spelen? Sonic Pi herinnerde zich jouw functie - dus zelfs nadat je deze hebt gewist uit de buffer, het herinnerde zich wat jij had getypt. Dit gedrag werkt alleen met functies die zijn gemaakt met `define` (en `defonce`).

en: Parameterised functions
nl: geparametreerde functies

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:
nl: Interessant om weten ook is dat je net zoals je min als max waarden kan geven aan `rrand`, kan je ook jouw functies argumenten laten accepteren. Laat ons dat even bekijken:

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.
nl: Dit is niet erg spannend, maar het illustreert wel de zaak. We hebben onze eigen versie van `play` genaamd 'my_player' die is geparametriseerd.

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.
nl: De parameters moeten na de `do` van het `define` do/end blok komen te staan, omringd door een sluisteken `|`en gescheiden door komma's `,`. Om deze parameters te benoemen mag je elk woord gebruiken dat je maar wil.

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`.
nl: Het zit 'h allemaal in de `define` do/end blok. Je kan de parameternamen gebruiken zoals echte waarden. In dit voorbeeld speel ik de noot `n. Je kan deze beschouwen als een soort toezegging, dat wanneer de code loopt, deze door de werkelijke waarden vervangen wordt wanneer je deze benoemd. Ik doe dit met `my_player 80`. om noot 80 te spelen. Binnen de definitie van deze functie, is `n`nu vervangen door 80, dus `play n` verandert in `play 80`. Wanneer ik deze vernoem met `my_player 90´, is `n` nu vervangen met 90, play `n`is veranderd in play `90`.

en: Let's see a more interesting example:
nl: Laten we eens kijken naar een interessanter voorbeeld:

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`.
nl: Hier gebruikte ik `repeats` als een cijfer in de regel `repeats.times do`.Ik gebruikte `root` ook als naam van een noot in mijn `play` oproep.

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!
nl: Hierbij zien we dat we in staat zijn om iets zeer expressief, maar makkelijk leesbaar te schrijven door onze logica in een functie te steken!

en: 5.6 Variables
nl: 5.6 Variabelen

en: Variables
nl: Variabelen

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:
nl: Het is handig om in jouw code is namen voor dingen te creëren. Sonic Pi maakt jou dit zeer eenvoudig, je schrijft de naam die je wenst te gebruiken, een gelijkteken ('='), en dan wat je wilt onthouden:

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:
nl: Hier, we hebben  het symbool `:loop_amen` 'onthouden' in de variabele `sample_name` . Nu kunnen we `sample_name` gebruiken, overal waar we `:loop_amen` hebben gebruikt. Bijvoorbeeld:

en: There are three main reasons for using variables in Sonic Pi: communicating meaning, managing repetition and capturing the results of things.
nl: Er zijn drie belangrijke redenen voor het gebruik van variabelen in Sonic Pi: in het communiceren, het beheer van herhaling en het vastleggen van de resultaten van zaken.

en: Communicating Meaning
nl: In de zin van Communicatie

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!
nl: Als je code schrijft, denk ,je snel dat je je computer verteld wat hij moet doen, en zolang de computer deze kan verstaan, alles OK is. 
    Maar het is ook belangrijk om er op te letten dat niet alleen de computer jouw code leest. Andere mensen kunnen deze ook lezen en proberen te begrijpen wat er gaande is. Ook, wil je waarschijnlijk jouw eigen code in de toekomst lezen en proberen te begrijpen hoe die werkt. Hoewel deze code voor jou nu vanzelfsprekend lijkt - is het misschien niet zo duidelijk voor anderen of zelfs je toekomstige zelf!

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:
nl: Een manier om andere jouw code te laten begrijpen is deze van een commentaar-lijn voorzien (zoals we in een voorgaande sectie hebben gezien). Een ander is zinvolle variabele namen gebruiken. Kijk naar deze code:

en: Why does it use the number `1.7533`? Where did this number come from? What does it mean? However, look at this code:
nl: Waarom maakt men hier gebruik van het cijfer `1.7533`? Waar komt dit getal vandaan? Wat betekent het? En kijk nu eens naar deze code:

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:
nl: Het is nu veel duidelijker wat '1.7533' betekent: het is de duur van de sample `:loop_amen`! Natuurlijk, zou je kunnen zeggen, waarom schrijf je gewoon niet:

en: Which, of course, is a very nice way of communicating the intent of the code.
nl: Wat natuurlijk een zeer mooie manier is om de intentie van de code te communiceren .

en: Managing Repetition
nl: Herhaling Beheren

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:
nl: Vaak zie je een heleboel herhaling in je code en als je dingen wil veranderen, moet je deze op een heleboel plaatsen veranderen. Kijk even naar deze code:

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.
nl: We doen hier heel wat met ': loop_amen'! Maar als we nu willen horen hoe dit klinkt met een andere sample loop, zoals `:loop_garzul`? Dan zouden we deze moeten gaan zoeken en alle `:loop_amen`s met `:loop_garzul` vervangen'. Dat zou fijn zijn als je veel tijd hebt- maar wat als je dit uitvoert op het podium? Soms heb je de luxe van de tijd niet - vooral niet als je de mensen aan het dansen wil houden.

en: What if you'd written your code like this:
nl: Wat als je je code als het volgt zou schrijven:

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.
nl: Nu dat doet net het zelfde als deze hierboven (probeer maar). Het geeft ons ook de mogelijkheid om één enkele lijn te moeten gaan veranderen: `sample_naam = :loop_amen` naar `sample_naam = :loop_garzul, en we veranderen deze op vele plaatsen binnen onze code door de magie van variabelen.

en: Capturing Results
nl: Vastleggen van de resultaten

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:
nl: Tot slot, een goede motivatie om variabelen te gaan gebruiken is om resultaten van zaken vast te leggen. Misschien wilt u bijvoorbeeld iets doen met de duur van een sample:

en: We can now use `sd` anywhere we need the duration of the `:loop_amen` sample.
nl: We kunnen nu  'sd' overal gebruiken waar we de duur van de sample `:loop_amen` nodig hebben.

en: Perhaps more importantly, a variable allows us to capture the result of a call to `play` or `sample`:
nl: Wat misschien nog belangrijker is, een variabele stelt ons in staat het resultaat te capteren van een oproep naar `play` of `sample`:

en: Now we have caught and remembered `s` as a variable, which allows us to control the synth as it is running:
nl: Nu hebben we  `s` gevangen en onthouden als een variabele, hetgeen ons toelaat de synth te controleren wanneer deze speelt:

en: We'll look into controlling synths in more detail in a later section.
nl: We zullen het manipuleren van synth's in een later sectie meer in detail bekijken.

en: Warning: Variables and Threads
nl: Waarschuwing: Variabelen en threads

en: Whilst variables are great for giving things names and capturing the results of things, it is important to know that they should typically only be used locally within a thread. For example, *don't do this*:
nl: Alhoewel variabelen goed zijn voor het geven van namen aan dingen en het opslaan van de resultaten van dingen, is het belangrijk om te weten dat ze typisch alleen lokaal gebruikt dienen te worden binnen een thread. Bijvoorbeeld, *doe dit niet*:

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
nl: a = (ring 6, 5, 4, 3, 2, 1)
    live_loop :geschud do
      a = a.shuffle
      sleep 0.5
    end
    live_loop :gesorteerd do
      a = a.sort
      sleep 0.5
      puts "gesorteerd: ", 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'.
nl: In het bovenstaande voorbeeld kenden we een ring van getallen toe aan variabele `a` en werd deze gebruikt in twee `live_loop`'s. In de eerste lus sorteren we de ring elke 0,5s (naar `(ring 1, 2, 3, 4, 5, 6)`) en drukken deze af naar het log. Wanneer je de code draait kom je erachter dat de afgedrukte lijst *niet altijd gesorteerd is!*. Dit kan je verrassen, zeker omdat de lijst soms gesorteerd is afgedrukt en soms niet. Dit wordt niet deterministisch gedrag genoemd en is het resultaat van een behoorlijk naar probleem genaamd race conditie. Het probleem komt doordat de tweede lus de lijst ook manipuleert (in dit geval door elkaar schudden). Tegen de tijd dat de lijst wordt afgedrukt is deze soms net gesorteerd en soms net geschud. Beide lussen 'racen' om iets anders te doen met dezelfde variabele en elke keer 'wint' er een andere lus.

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:
nl: Er zijn hiervoor twee oplossingen. Ten eerste, *gebruik dezelfde variabele niet in meerdere live lussen of threads*. Bijvoorbeeld: de volgende code drukt altijd een gesorteerde lijst omdat iedere live lus een aparte eigen variabele heeft:

en: live_loop :shuffled do
      a = (ring 6, 5, 4, 3, 2, 1)
      a = a.shuffle
      sleep 0.5
    end
    live_loop :sorted do
      a = (ring 6, 5, 4, 3, 2, 1)
      a = a.sort
      sleep 0.5
      puts "sorted: ", a
    end
nl: live_loop :geschud do
      a = (ring 6, 5, 4, 3, 2, 1)
      a = a.shuffle
      sleep 0.5
    end
    live_loop :gesorteerd do
      a = (ring 6, 5, 4, 3, 2, 1)
      a = a.sort
      sleep 0.5
      puts "gesorteerd: ", a
    end

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.
nl: Soms willen we echter dingen delen tussen threads. Bijvoorbeeld de huidige toonsoort, BPM, synth, etc. In deze gevallen is de oplossing om gebruik te maken van de speciale thread-safe state systemen in Sonic Pi via de functies `get` en `set`. Dit wordt verder beproken in sectie 10.

en: 5.7 Thread Synchronisation
nl: 5.7 Het Synchroniseren van Threads

en: Thread Synchronisation
nl: Het Synchroniseren van 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.
nl: Eens je het live coderen voldoende onder de knie hebt met een aantal functies en threads tezelfdertijd, dan heb je misschien opgemerkt dat het niet moeilijk is om een fout te maken in één van de threads die dodelijk kan zijn. Niet heel erg, want je kan makkelijk de thread terug herstarten door op afspelen te klikken. Maar als je de thread herstart is deze *uit de maat* met de originele threads.

en: Inherited Time
nl: Overgenomen Tijd

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.
nl: Zoals we eerder hebben besproken, erven nieuwe threads gemaakt met `in_thread` alle instellingen van de bovenliggende thread. Dus ook de huidige tijd. Dit betekent dat de threads altijd synchroon met elkaar zijn als zij tegelijkertijd zijn gestart.

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.
nl: Wanneer je een thread op zich start, begint het met zijn eigen klok die waarschijnlijk niet in sync is met een van de andere actieve threads.

en: Cue and Sync
nl: Cue en Sync

en: Sonic Pi provides a solution to this problem with the functions `cue` and `sync`.
nl: Sonic Pi biedt een oplossing voor dit probleem met de functies 'cue' en 'sync'.

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.
nl: 'cue' laat ons toe, hartslag-berichten te sturen aan alle andere threads. Standaard zijn de andere threads niet geïnteresseerd in deze, en negeren deze hartslag-berichten. Je kan hun aandacht wel vragen met de functie 'sync'.

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.
nl: Het belangrijkst om weten is dat 'sync' vergelijkbaar is met `sleep` in die zin dat het de huidige thread stopt  voor een periode van tijd om om actief te zijn. Met `sleep` geef je echter aan hoe lang je wilt wachten terwijl je met 'sync' niet weet hoe lang je zal wachten -  als 'sync' op de volgende 'cue' van een andere thread wacht die lang of kort kan wegblijven.

en: Let's explore this in a little more detail:
nl: Laten we dit in detail bekijken:

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.
nl: Hier hebben we twee threads - één gedraagt zich als metronoom, zonder geluid te maken en zend elke maat enkel `:tick` hartslag-berichten uit. De tweede thread synchroniseerd op `tick` berichten en wanneer deze er één ontvangt, erft hij de `cue` tijd thread en blijft lopen.

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:
nl: Als gevolg zullen wij de ': drum_heavy_kick' sample horen, precies op het moment dat de andere thread het `:tick` bericht uitzend, zelfs als de twee threads niet met de uitvoering ervan op hetzelfde moment beginnen:

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.
nl: Die ondeugende `sleep` aanroep zou doorgaans de tweede thread uit fase laten lopen met de éérste. Als we echter `cue` en `sync` gebruiken, synchroniseren we automatisch alle lopende threads die toevallige verschuivingen in timing omzeilen.

en: Cue Names
nl: Cue Namen

en: You are free to use whatever name you'd like for your `cue` messages - not just `:tick`. You just need to ensure that any other threads are `sync`ing on the correct name - otherwise they'll be waiting for ever (or at least until you press the Stop button).
nl: Je mag eender welke naam gebruiken voor jouw `cue` berichten, niet enkel `:tick`. Je hoeft er alleen voor de zorgen dat alle threads op de correcte naam `sync`-en, anders gaan ze voor eeuwig wachten (of tot je op de stopknopstop klikt tenminste).

en: Let's play with a few `cue` names:
nl: Laten we met en paar `cue` namen spelen:

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.
nl: Hier hebben we een hoofd  `cue` loop die random de heartbeat namen `:foo`, `:bar` or `:baz`uitzend. We hebben ook drie loop threads die elk onafhankelijk op één van die namen synct en daarbij een verschillende sample afspeeld. Het netto effect is dat we elke 0.5 beat een klank horen als wordt elk van deze 0.5 `sync` threads random ge-synct wordt met de `cue` thread en zijn sample speelt.

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`.
nl: Dit werkt natuurlijk ook als jen de threads omgekeerd ordend omdat de`sync` threads gewoon op de volgende `cue` zitten wachten.

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.
nl: Een van de meest lonende en leuke aspecten van Sonic Pi is de mogelijkheid om gemakkelijk  studio-effecten aan uw geluiden toe te voegen . Bijvoorbeeld, op sommige delen van je muziekstuk een reverb toevoegen, of wat echo of misschien zelfs distortion op je  wobbelende basslijnen.

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...
nl: Sonic Pi biedt een erg simpele, doch krachtige manier om effecten toe te voegen. Je kan deze zelfs in een ketting aan elkaar schakelen (dus kan je je klanken doogeven via distortion, dan echo-delay en dan reverb) en de effect-modules apart besturen (op een vergelijkbare manier dat je dat met de parameters van een synth of sampler zou doen). Je kan zelfs de opties modifiëren terwijl deze nog steeds loopt. Dus, bijvoorbeeld, je zou de reverb op je bas kunnen verhogen terwijl de track loopt...

en: Guitar Pedals
nl: Gitaar Pedalen

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:
nl: Als dit allemaal een beetje ingewikkeld klinkt, maak je geen zorgen. Eens je hiermee een beetje speelt, zal het allemaal duidelijk worden. Maar voor je eraan begint, moet je weten dat het een werkt zoals bij gitaar effecten pedalen. Er zijn verschillende effect-pedalen te koop. Sommigen voegen een reverb-klank toe, andere distortion enz. Een gitarist zal zij of haar gitaar in één van de effect-pedalen pluggen, bv. distortion, en zal dan bvb een reverb effect in de uitgang van de eerste pedaal pluggen om het geluid door te schakelen (chain=ketting). De uitgang van de reverb-pedaal kan dan in de versterker geplugt worden:

en: Guitar -> Distortion -> Reverb -> Amplifier
nl: Gitaar -> Distortion -> Reverb -> Amplifier (Versterker)

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.
nl: Dit heet FX chaining. Sonic Pi ondersteunt precies dit. Bovendien heeft elke pedaal vaak wijzerplaten en schuifregelaars zodat je kan bepalen hoeveel distortion, reverb, echo enz je kan toepassen. Sonic Pi ondersteunt ook dit soort controle. Tot slot kan je je bvb gitaristen voorstellen en dat iemand anders  met de FX-besturingselementen speelt, terwijl zij aan het spelen zijn. Sonic Pi ondersteunt dit ook- maar in plaats van dat iemand anders  dingen voor jou controleert, doet de computer dit.

en: Let's explore FX!
nl: Laten we FX verkennen!

en: 6.1 Adding FX
nl: 6.1 FX  Toevoegen

en: Adding FX
nl: FX  Toevoegen

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.
nl: In deze sectie zullen we naar een paar Effecten kijken : reverb en echo. We zullen zien hoe ze te gebruiken, hoe hun opts te besturen en hoe ze te chainen.

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.
nl: Sonic Pi's FX systeem maakt gebruik van blokken. Dus als je die niet hebt gelezen in sectie 5.1 Kan je hier snel naar kijken en kom dan naar hier terug.

en: If we want to use reverb we write `with_fx :reverb` as the special code to our block like this:
nl: Als we reverb willen gebruiken schrijven we `with_fx :reverb` als speciale code naar ons blok als volgt:

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.
nl: Speel deze code nu en hoor dat deze met reverb wordt gespeeld. Dat klinkt goed, niet?Alles klinkt vrij aardig met een reverb.

en: Now let's look what happens if we have code outside the do/end block:
nl: Laten we nu kijken wat er gebeurt als we buiten het do/end blok code hebben:

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.
nl: Merk op hoe de laatste `play 55` niet met reverb gespeeld wordt. Dit is omdat het *buiten* het do/end blok staat, en dus niet door de reverb FX gecapteerd kan worden.

en: Similarly, if you make sounds before the do/end block, they also won't be captured:
nl: Op dezelfde manier zullen klanken vòòr het do/end blok ook niet gecapteerd worden:

en: There are many FX to choose from. How about some echo?
nl: Er zijn veel effecten te kiezen. Wat dacht je van wat 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:
nl: Één van de sterke punten van Sonic Pi's FX blokken is dat je er opties aan kunt meegeven, vergelijkbaar met de opts die we al met `play` en `sample` hebben gezien. Een plezante echo opt om mee te spelen is `phase:` die de duurtijd van een echo in tellen (Beats) weergeeft. Laat ons even de echo vertragen:

en: Let's also make the echo faster:
nl: Laten we de echo sneller maken:

en: Let's make the echo take longer to fade away by setting the `decay:` time to 8 beats:
nl: Laat ons de echo over een langere tijd uitfaden door de `decay:` tijd in te stellen naar 8 beats:

en: Nesting FX
nl: Effecten nesten

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:
nl: Een van de krachtigste aspecten van de FX-blokken is dat u hen kunt nesten. Hierdoor kan je heel gemakkelijk een FX keten samenstellen. Bijvoorbeeld, wat als je wat code met echo  wilde spelen en vervolgens met een reverb? Gemakkelijk, zet de één gewoon in de andere:

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.
nl: Denk aan de audio als zou deze van binnenuit stromen. Het geluid van alle code binnen het binnenste do/end blok zoals 'play 50' wordt eerst verzonden naar de echo FX en het geluid van de echo FX wordt op zijn beurt verstuurd naar de reverb FX.

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.
nl: We kunnen heel diep nesten en deze gebruiken voor maffe resultaten. Maar wees hierbij gewaarschuwd, want de FX kunnen veel cpu gebruiken wanneer u effectief meerdere effecten nest die gelijktijdig worden uitgevoerd. Wees dus spaarzaam op uw gebruik van effecten zeker op laag aangedreven platforms zoals  Raspberry Pi.

en: Discovering FX
nl: Effecten ontdekken

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:
nl: Sonic Pi wordt  met een groot aantal effecten geleverd om mee te spelen. Als j wil weten welke er beschikbaar zijn, klik op FX in het linkeruiteinde van het help-systeem en je zal een lijst van beschikbare opties zien. Hier is een lijst van enkele van mijn favorieten:

en: Now go crazy and add FX everywhere for some amazing new sounds!
nl: Doe nu maar eens goed gek en zet overal effecten op voor wat verbazingwekkende nieuwe geluiden!

en: 6.2 FX in Practice
nl: 6.2 FX in de praktijk

en: FX in Practice
nl: FX in de praktijk

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.
nl: Hoewel ze eenvoudig aan de buitenkant lijken, zijn effecten best complexe beesten intern. Hun eenvoud verleid mensen ertoe ze te gaan overgebruiken. Dit kan goed gaan op een krachtige machine, maar als je zoals ik een Raspberry Pi gebruikt om mee te jammen, met je voorzichtig zijn met de gevraagde werkkracht als je zeker wil zijn van een goede flow van jouw beats.

en: Consider this code:
nl: Bekijk even deze 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...
nl: In deze code spelen we noot 60 met een zeer korte release tijd, dus een korte noot. We willen ook reverb, dus hebben we die in een reverb blok gewikkeld. Dat gaat goed. Behalve...

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.
nl: Laten we eens kijken wat de code doet. Vooraleerst hebben we een `loop` wat betekent dat al wat hierin zit voor eeuwig wordt herhaald. Vervolgens hebben we een `with_fx` blok. Dit betekent dat we een nieuwe reverb FX zullen creëren *elke keer de loop opnieuw aan zijn beginpositie komt *. Dit is alsof we een extra FX reverb pedaal zouden bijkrijgen, elke keer dat je aan een snaar van een gitaar plukt. Het is wel cool dat je dit kunt doen, maar het is niet altijd wat je wilt. Deze code zal bijvoorbeeld moeite hebben mooi te draaien op een Raspberry Pi. Want al het werk om de reverb te vormen, en het wachten naar het moment dat deze moet stoppen en weer weggedaan moet worden wordt allemaal voor jou gedaan door de `with_fx`, maar dat vraagt CPU kracht die kostbaar kan zijn.

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:
nl: Hoe maken we deze meer vergelijkbaar met een traditionele opstelling waar onze gitarist slechts *één* reverb-pedaal heeft waardoor alle klanken passeren? Eenvoudig:

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.
nl: We zetten onze loop *binnen* het blok 'with_fx'. Op deze manier maken wij slechts een enkele reverb voor alle noten die gespeeld worden in onze loop. Deze code is een stuk efficiënter en zou prima werken op een Raspberry Pi.

en: A compromise is to use `with_fx` over an iteration within a loop:
nl: Een compromis is het gebruik van 'with_fx' buiten van de herhaling binnen een loop:

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.
nl: Op deze manier hebben we de 'with_fx'  uit het binnenste deel van de `loop` gehaald en nu creëren we  een nieuwe reverb elke 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:
nl: Deze situatie gaat in ons werk zo dikwijls terugkeren dat `with_fx` deze met een opt ondersteunt die dat zelf doet zonder de `16.times` blok te hoeven schrijven:

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.
nl: In de voorbeelden van `reps 16` en `16.times do` zullen zich beiden identiek gedragen. De `reps: 16` herhalen in wezen de code in het `do/end` blok 16 keer zodat u hen beide door elkaar kunt gebruiken en je kies gewoon de manier die voor jou het beste voelt.

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.
nl: Onthou, er zijn geen misstappen, enkel mogelijkheden. Echter, sommige benaderingen zullen een andere klank of een ander performant karakter hebben. Dus speel een beetje met deze verschillende benaderingen en gebruik diegene het best bij jou past en die het best samengaan met de beperkingen van de prestaties van het platform dat je gebruikt.

en: 7 Control
nl: 7 Controle

en: Controlling running sounds
nl: De controle over lopende klank

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.
nl: Tot nu toe hebben we gekeken hoe je synths en samples kunt activeren, en ook hun standaard opties zoals amplitude, pan, envelop-instellingen en meer te wijzigen. Elk geactiveerd geluid is wezenlijk haar eigen geluid, met een eigen lijst van opties ingesteld voor de duur van de klank.

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?
nl: Zou het ook niet gaaf zijn dat als je dit geluid zou kunnen veranderen terwijl het nog steeds speelt, zoals je misschien een snaar van een gitaar zou buigen terwijl deze nog trilt?

en: You're in luck - this section will show you how to do exactly this.
nl: Je hebt geluk- deze sectie gaat precies daarover.

en: 7.1 Controlling Running Synths
nl: 7.1 De controle over lopende Synths

en: Controlling Running Synths
nl: Lopende Synths Contoleren

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:
nl: Tot nu toe hebben we onszelf alleen bezig gehouden met de triggering van nieuwe drumklanken en FX. Sonic Pi geeft ons echter de mogelijkheid op het manipuleren en controleren van de momenteel lopende klanken. We doen dit door middel van een variabele die een verwijzing naar een synthesizer opvangt:

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.
nl: Hier hebben we de variabele van een run-local waarmee de synth noot 60 speelt. Merk op dat dit een *run-local* is - je kan geen toegang   hebben tot deze vanaf een andere uitvoering zoals bij functies.

en: Once we have `s`, we can start controlling it via the `control` function:
nl: Eens we  `s` hebben, kunnen we deze beginnen tweaken via de `control` functie:

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.
nl: Wat je bij deze moet opmerken is dat wij hier geen 4 verschillende synths triggeren - maar slechts één synth triggeren om dan de toonhoogte 3 keer te wijzigen achteraf, terwijl deze wordt afgespeeld.

en: We can pass any of the standard opts to `control`, so you can control things like `amp:`, `cutoff:` or `pan:`.
nl: We kunnen iedere standaard opt doorgeven om `controle` over te hebben, zodat je `amp:`, `cutoff:` or `pan:´ kan controllen.

en: Non-controllable Options
nl: Niet-Control-bare Opties

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.
nl: Sommige opts kunnen niet gecontrold worden eens de synth gestart is. Dis is het geval voor alle ADSR envelop parameters. Je kan uitzoeken welke opts gecontrold kunnen worden door naar hun documentie te kijken in het hulp systeem. Als de de documentatie zegt *Can not be changed once set*, dan weet je dat het niet mogelijk is om de opt te controllen als de synth al loopt.

en: 7.2 Controlling FX
nl: 7.2 FX Controllen

en: Controlling FX
nl: FX Controllen

en: It is also possible to control FX, although this is achieved in a slightly different way:
nl: Het is ook mogelijk om FX te controllen, hoewel dit op een iets andere manier wordt bereikt:

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.
nl: In plaats van een variabele, gebruiken we de sluisteken parameters van het do/end blok. Binnen de  `|` staafjes , moeten we een unieke naam voor onze lopende FX opgeven die we vervolgens verwijzen vanuit het  do/end blok. Dit gedrag is identiek aan het gebruik van geparametriseerde functies.

en: Now go and control some synths and FX!
nl: Ga nu enkele synths en FX Controllen !

en: 7.3 Sliding Options
nl: 7.3 Glijdende Opties

en: Sliding Opts
nl: Glijdende Opties

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.
nl: Tijdens het verkennen van de synth en FX opties is het je misschien opgevallen dat er een aantal opts zijn die eindigen op `_slide`. Je hebt deze misschien ook proberen oproepen en daarmee opgemerkt dat zij geen effect hebben. Dat is omdat zij geen normale parameters zijn, het zijn speciale opts die enkel werken wanneer je synths controlt zoals beschreven in de voorgaande sectie.

en: Consider the following example:
nl: Beschouw het volgende voorbeeld:

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:
nl: Hier hoor je de toonhoogte van de synth onmiddellijk wijzigen op elke `control` appèl  . Wij willen echter dat de toonhoogte slide (glijdt) tussen de veranderingen. Vermits we de `note:` parameter controllen, om slide toe te voegen, moeten we de parameter 'note_slide' van de synth instellen:

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.
nl: Nu horen we de de noten buigen tussen de `control`aanroep. Dat klinkt lekker, niet? Je kan de slide versnellen door een kortere tijd te gebruiken zoals `note_slide: 0.2` of vertragen door een langere slide time in te stellen.

en: Every parameter that can be controlled has a corresponding `_slide` parameter for you to play with.
nl: Elke parameter die controlt kan worden heeft een identieke parameter '_slide' voor jou om mee te spelen.

en: Sliding is sticky
nl: Slide-en blijft plakken

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.
nl: Zodra u hebt een parameter '_slide' ingesteld op een lopende synth, zal het worden onthoudenen telkens wanneer u de bijbehorende parameter slide gebruikt . Als je de slide wilt stoppen moet je de waarde '_slide' op 0 instellen voor de volgende oproep van `control`.

en: It is also possible to slide FX opts:
nl: Het is ook mogelijk FX opts te slide-en:

en: Now have fun sliding things around for smooth transitions and flowing control...
nl: Veel plezier met het rond slide-en van zaken voor een vloeiende overgang en een vlotte control...

en: 8 Data Structures
nl: 8 Datastructuren

en: Data Structures
nl: Datastructuren

en: A very useful tool in a programmer's toolkit is a data structure.
nl: Een zeer nuttig hulpmiddel in de gereedschapskist van een programmeur is een datastructuur.

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.
nl: Soms wil je meer dan één ding kunnen representeren en gebruiken. Zo kan je het bijvoorbeeld op en moment nodig vinden om een serie noten achter elkaar te spelen,de één na de andere. Programmeertalen hebben datastructuren die jou dit toelaten.

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.
nl: Er zijn vele spannende en exotische gegevensstructuren beschikbaar voor programmeurs - en veel mensen zijn nog altijd bezig met het uitvinden van nieuwe. Maar momenteel gaan we enkel een zeer eenvoudige gegevensstructuur beschouwen- de lijst.

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.
nl: Laten we dit eens in detail bekijken. We zullen zijn basisvorm behandelen en ook hoe lijsten kunnen worden gebruikt voor toonladders en akkoorden.

en: 8.1 Lists
nl: 8.1 Lijsten

en: Lists
nl: Lijsten

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:
nl: In deze sectie zullen we een kijkje nemen naar een datastructuur die zeer nuttig kan zijn - de lijst. We hebben dit al kort gezien in het gedeelte over randomiseren, wanneer we willekeurig uit een lijst van noten kiezen om te spelen:

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:
nl: In deze sectie verkennen we om ook akkoorden en toonladders door lijsten te laten vertegenwoordigen. Eerste recapituleren we even hoe we een snaar kunnen bespelen. Denk eraan dat als we geen gebruik maken van `sleep` we alle klanken tezelfdertijd horen :

en: Let's look at other ways to represent this code.
nl: Laten we eens kijken naar andere manieren om deze code weer te geven.

en: Playing a List
nl: Afspelen van een lijst

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:
nl: Een optie zou kunnen zijn om alle noten in een lijst te zeten `[52, 55, 59]`. Onze vriendschappelijke `play` functie is slim genoeg om een lijst van noten te kunnen spelen. Probeer maar:

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:
nl: Ooh, dat is al aangenamer om lezen. Een lijst met noten afspelen weerhoud je niet om de gewoonlijke parameters te gaan gebruiken:

en: Of course, you can also use the traditional note names instead of the MIDI numbers:
nl: Natuurlijk kan je ook de traditionele benaming van de noten gebruiken ipv. de MIDI nummers:

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.
nl: De gelukkigen onder jullie die wat muziektheorie hebben geleerd, hebben het akkoord *E Mineur* in het 3de octaaf herkend.

en: Accessing a List
nl: Toegang tot een lijst

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.
nl: Een andere zeer nuttige functie van een lijst is de mogelijkheid om er informatie uit te krijgen. Dit klinkt misschien een beetje vreemd, maar het is niet ingewikkelder dan iemand die jou vraagt een boek op pagina 23 open te slaan. Bij een lijst, zou je kunnen zeggen: wat is het element op index 23? Het vreemde alleen is dat programmeer indexen meestal bij 0 beginnen en niet 1.

en: With list indexes we don't count 1, 2, 3... Instead we count 0, 1, 2...
nl: Met lijst indexen tellen we niet 1,2,3... maar 0,1,2...

en: Let's look at this in a little more detail. Take a look at this list:
nl: Laten we dit een beetje meer in detail bekijken. Neem een kijkje naar deze lijst:

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:
nl: Dit is niet onoverkomelijk. Wat is nu het tweede element in de lijst? Dat is `55` natuurlijk ja. Dat was makkelijk. Laten we eens kijken of de computer zover kunnen krijgen om dit voor ons te doen:

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:
nl: OK, dat ziet er misschien een beetje raar als je nog nooit zoiets gezien hebt. Geloof me maar, het is niet te moeilijk. Er zijn drie onderdelen naar de regel erboven: het woord `puts`, onze lijst ' 52, 55, 59' en onze index '[1]'. Ten eerste: we zeggen `puts` omdat we willen dat Sonic Pi het antwoord voor ons in het logboek afdrukt . Vervolgens geven we het onze lijst, en tenslotte vraagt onze index naarr het tweede element. We moeten onze index omringen met vierkante haken en omdat tellen bij '0' begint, is de index voor het tweede element `1`. Kijk:

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...
nl: Probeer de code uit te voeren ´puts [52, 55, 59] [1]` en je ziet `55´ in het logboek opduiken. Zet de index ´1´ om in andere indexen, probeer langere lijsten en denk na over hoe u een lijst in uw volgende code jam kunt gebruiken. Welke muzikale structuren kunnen bijvoorbeeld worden weergegeven als een reeks getallen...

en: 8.2 Chords
nl: 8.2 Akkoorden

en: Sonic Pi has built-in support for chord names which will return lists. Try it for yourself:
nl: Sonic Pi heeft ingebouwde ondersteuning voor akkoordnamen die lijsten zullen weergeven. Probeer dit voor jezelf:

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:
nl: Nu komen we er. Dit ziet er veel beter uit dan de rauwe lijst (en is makkelijker te lezen voor andere mensen). Welke andere akkoorden ondersteund Sonic Pi nog? Wel, een *hoop*. Probeer wat van deze:

en: Arpeggios
nl: Arpeggio 's

en: We can easily turn chords into arpeggios with the function `play_pattern`:
nl: We kunnen gemakkelijk akkoorden in arpeggio's omzetten met de functie 'play_pattern':

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:
nl: Ok, dit is niet zo fijn- het speelde het echt te traag. `play_pattern` zal elke noot van de lijst apart afspelen met een rust van `sleep 1` tussen elke oproep naar `play`. We kunnen de functie  `play_pattern_timed` gebruiken om een eigen timing aan te geven en het wat sneller te laten gaan:

en: We can even pass a list of times which it will treat as a circle of times:
nl: We kunnen zelfs een lijst met tijden doorgeven, welke als een tijdscirkel zullen worden behandeld:

en: This is the equivalent to:
nl: Dit is gelijk aan:

en: Which would you prefer to write?
nl: Welke wil je liever schrijven?

en: 8.3 Scales
nl: 8.3 Toonladders

en: Scales
nl: Toonladders

en: Sonic Pi has support for a wide range of scales. How about playing a C3 major scale?
nl: Sonic Pi geeft ondersteuning aan een breed scala van toonladders. Wat dacht je van de toonladder C3 majeur?

en: We can even ask for more octaves:
nl: We kunnen zelfs meer octaven vragen:

en: How about all the notes in a pentatonic scale?
nl: Wat dacht je van deze noten  in een pentatonische toonladder?

en: Random notes
nl: Random 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:
nl: Akkoorden en toonladders zijn een goede manieren om een willekeurige keuze tot iets zinvols te beperken. Speel met dit voorbeeld dat willekeurige noten uitkiest van het akkoord E3 mineur:

en: Try switching in different chord names and cutoff ranges.
nl: Probeer verschillende akkoordnamen en cutoff in te geven.

en: Discovering Chords and Scales
nl: Akkoorden en toonladders ontdekken

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).
nl: Om erachter te komen welke toonladders en akkoorden worden ondersteund door Sonic Pi klikt u de knop Lang op het linkeruiteinde van deze tutorial en kies vervolgens chord of scale in de lijst van de API. Scroll In de informatie van het hoofdpaneel naar beneden totdat u een lange lijst van akkoorden of schalen ziet (afhankelijk van welke u zoekt).

en: Have fun and remember: there are no mistakes, only opportunities.
nl: Veel plezier en vergeet niet: er zijn geen fouten, alleen kansen.

en: 8.4 Rings
nl: 8.4 Ringen

en: Rings
nl: Ringen

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.
nl: Een interessante draai aan standaard lijsten zijn ringen. Als u wat programmeren weet, ben je misschien al ring buffers of ring array's tegengekomen. Hier gaan we gewoon voor ring - het is kort en simpel.

en: In the previous section on lists we saw how we could fetch elements out of them by using the indexing mechanism:
nl: In de vorige sectie over lijsten zagen we al hoe we elementen door het indexeer mechanisme uit hen konden halen:

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.
nl: War gebeurd er nu als je `100` wil indexeren? Wel er is duidelijk geen element bij index 100 daar de lijst enkel drie elementen bevat. Dus Sonic Pi zal `nil` weergeven, wat niets betekent.

en: However, consider you have a counter such as the current beat which continually increases. Let's create our counter and our list:
nl: Stel nu even dat je een teller hebt en dat deze jouw huidige beat is die in snelheid toeneemt. Lat ons deze teller en lijst aanmaken:

en: We can now use our counter to access a note in our list:
nl: We kunnen nu onze teller gebruiken om toegang te krijgen tot een noot in onze lijst:

en: Great, we got `52`. Now, let's increment our counter and get another note:
nl: Geweldig, we hebben `52`. Nu, laten we onze teller verhogen en krijg een andere noot:

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.
nl: Super, we krijgen nu `55` en als wij het opnieuw doen krijgen we `59`. Als wij het nogmaals doen, raken onze cijfer op in onze lijst en krijgen we `nil`. Wat als we bij het begin van de lijst weer willen beginnen? Dit is wat waar ringen voor zijn.

en: Creating Rings
nl: Ringen maken

en: We can create rings one of two ways. Either we use the `ring` function with the elements of the ring as parameters:
nl: We kunnen ringen op twee manieren maken. We kunnen de `ring` functie gebruiken met de elementen van de ring als parameters:

en: Or we can take a normal list and convert it to a ring by sending it the `.ring` message:
nl: Of we kunnen een normale lijst nemen en deze naar een ring omzetten door naar deze een `.ring` bericht te zenden :

en: Indexing Rings
nl: Ringen Indexeren

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:
nl: Eens we een ring hebben, kan je deze op exact de zelfde manier als gewone lijsten gebruiken met uitzondering dat je indexen kunt gebruiken die negatief zijn of groter dan de grootte van de ring, en altijd naar één van de elementen van de ring zullen omslaan:

en: Using Rings
nl: Ringen Gebruiken

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.
nl: Laten we zeggen dat we een variabele gebruiken om het nummer van de huidige beat te vertegenwoordigen. We kunnen dit als een index in onze ring  gebruiken om noten te halen om te spelen of release tijden of alles wat nuttig zou kunnen zijn en we hebben opgeslagen in onze ring ongeacht het beat nummer dat we momenteel hebben.

en: Scales and Chords are Rings
nl: Toonladders en Akkoorden zijn ringen

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.
nl: Handig om weten is dat de lijsten door `scale` en de `chord` opgeroepen, ook ringen zijn en jou toelaten willekeurige indexen te openen.

en: Ring Constructors
nl: Ring Bouwers

en: In addition to `ring` there are a number of other functions which will construct a ring for us.
nl: Naast de `ring` zijn er een aantal andere functies die een ring voor ons zullen bouwen.

en: `range` invites you specify a starting point, end point and step size.
nl: `range`nodigt je uit om een start en een eindpositie op te geven en de grootte van de stappen.

en: `bools` allows you to use `1`s and `0`s to succinctly represent booleans.
nl: `bools` laten het gebruik van `1`s en `0`s om beknopte booleaans te vertegenwoordigen.

en: `knit` allows you to knit a sequence of repeated values.
nl: `knit` laat jou een sequentie met repeterende waarden breien.

en: `spread` creates a ring of bools with a Euclidean distribution.
nl: `spread` creëert een ring van een boleaanse met een Euclidische distributie.

en: Take a look at their respective documentation for more information.
nl: Neem een kijkje naar hun respectievelijke documentatie voor meer informatie hierover.

en: 8.5 Ring Chains
nl: 8.5 Ring Kettingen

en: Ring Chains
nl: Ring Kettingen

en: In addition to the constructors such as `range` and `spread` another way of creating new rings is to manipulate existing rings.
nl: Als toevoeging tot de bouwers zoals `range`en `spread`is het manipuleren van bestaande ringen, een andere manier om nieuwe ringen te maken.

en: Chain Commands
nl: Ketting Commando's

en: To explore this, take a simple ring:
nl: Neem deze eenvoudige ring om dit te verkennen:

en: What if we wanted it backwards? Well we'd use the chain command `.reverse` to take the ring and turn it around:
nl: Wat als we deze andersom willen? Dan kunnen we het chain commando `.reverse nemen om de ring om te draaien:

en: Now, what if we wanted the first three values from the ring?
nl: En wat als we de eerste drie waarden van de ring willen nemen?

en: Finally, what if we wanted to shuffle the ring?
nl: En wat als we de ring willen verschuiven?

en: Multiple Chains
nl: Meerdere Kettingen

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.
nl: Dit is al een krachtige manier om nieuwe ringen te creëren. De *echte* kracht komt wanneer je een paar van deze opdrachten samen chaint.

en: How about shuffling the ring, dropping 1 element and then taking the next 3?
nl: Wat denk je ervan de ring te shuffelen, 1 element te laten vallen en vervolgens de volgende 3 te nemen?

en: Let's take this in stages:
nl: Laten we dit in fasen doen:

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.
nl: Kan je nu zien dat we een lange ketting van deze methoden kunnen gebruiken door deze *bij elkaar te plakken*. We kunnen deze in eender welke volgorde combineren en ontwikkellen hierbij een uiterst rijke en krachtige manier om nieuwe ringen van bestaande ringen te creëren.

en: Immutability
nl: Onveranderbaarheid

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.
nl: Deze ringen hebben een krachtige en belangrijke eigenschap. Ze zijn onveranderlijk wat betekent dat je ze niet kunt veranderen. Dit betekent dat de chaining methode die in deze sectie beschreven word *ringen niet veranderd* maar eerder *nieuwe ringen maakt*. Dit betekent dat u vrij bent om te ringen te delen met threads en je hen kan beginnen chainen binnen een thread met de wetenschap dat je geen andere thread zal beïnvloeden die gebruik maakt van dezelfde ring.

en: Available Chain Methods
nl: Beschikbare Chain Methoden

en: Here's a list of the available chain methods for you to play with:
nl: Hier is een lijst van de beschikbare chain methoden voor jou om mee te spelen:

en: `.reverse` - returns a reversed version of the ring
nl: '.reverse' - geeft een omgekeerde versie van de ring

en: `.sort` - creates a sorted version of the ring
nl: '.sort' - creëert een gesorteerde versie van de ring

en: `.shuffle` - creates a shuffled version of the ring
nl: '.shuffle' - creëert een geshuffelde versie van de ring

en: `.pick(3)` - returns a ring with the results of calling `.choose` 3 times
nl: '.pick(3)' - geeft een ring met de resultaten van de aanroep `.choose` 3 keer

en: `.take(5)` - returns a new ring containing only the first 5 elements
nl: '.take(5)' - geeft als resultaat een nieuwe ring die alleen eerste 5 elementen bevat

en: `.drop(3)` - returns a new ring with everything but the first 3 elements
nl: '.drop(3)' - geeft als resultaat een nieuwe ring met alles behalve de eerste 3 elementen

en: `.butlast` - returns a new ring with the last element missing
nl: '.butlast' - geeft als resultaat een nieuwe ring maar ontbreekt het laatste element

en: `.drop_last(3)` - returns a new ring with the last 3 elements missing
nl: '.drop_last(3)' - geeft als resultaat een nieuwe ring maar de laatste 3 elementen ontbreken

en: `.take_last(6)`- returns a new ring with only the last 6 elements
nl: '.take_last(6)'-geeft als resultaat een nieuwe ring met alleen de laatste 6 elementen

en: `.stretch(2)` - repeats each element in the ring twice
nl: '.stretch(2)' - herhaald tweemaal elk element in de ring

en: `.repeat(3)` - repeats the entire ring 3 times
nl: '.repeat(3)' - herhaalt de hele ring 3 keer

en: `.mirror` - adds the ring to a reversed version of itself
nl: '.mirror' - voegt de ring naar een omgekeerde versie van zichzelf toe

en: `.reflect` - same as mirror but doesn't duplicate middle value
nl: '.reflect' - hetzelfde als spiegel maar middelste waarde wordt niet gedupliceerd

en: `.scale(2)` - returns a new ring with all elements multiplied by 2 (assumes ring contains numbers only)
nl: `.scale(2)`- geeft een nieuwe ring met alle elementen, maal 2 (van uitgegaan dat ring alleen cijfers bevat)

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.
nl: Natuurlijk, kan je in deze chain methoden ook andere cijfers gebruiken! Dus voel je vrij om `.drop(5)` in plaats van `.drop(3)` als je de eerste 5 elementen wilt laten vallen.

en: 9 Live Coding
nl: 9 Live Codering

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.
nl: Éen van de meest opwindende aspecten van Sonic Pi is dat je live code kan schrijven en deze veranderd om muziek te spelen, net zoals je zou optreden met je gitaar. Een voordeel van deze aanpak is dat je meer feedback krijgt terwijl je componeert (je kaan een simpele code loop laten lopen en deze tweaken tot deze perfect klinkt).  Het belangrijkste voordeel is echter dat u Sonic Pi op het podium mee kunt nemen en kan optreden.

en: In this section we'll cover the fundamentals of turning your static code compositions into dynamic performances.
nl: In deze sectie zullen we de fundamenten bespreken hoe je je statische code kan omvormen tot een dynamische voorstelling.

en: Hold on to your seats...
nl: Zit je goed? ...

en: 9.1 Live Coding Fundamentals
nl: 9.1 De Grondslagen van Live Codering

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:
nl: Nu hebben we genoeg geleerd en kan het echte plezier beginnen. In deze sectie trekken we uit alle vorige secties zaken die jou laten zien hoe je je composities tot live muziek kan maken en ze in een voorstelling kan omtoveren. Daarvoor hebben we 3 hoofd ingrediënten nodig:

en: An ability to write code that makes sounds - CHECK!
nl: Code kunnen schrijven dat geluiden kan voortbrengen - CHECK!

en: An ability to write functions - CHECK!
nl: Functies kunnen schrijven - CHECK!

en: An ability to use (named) threads - CHECK!
nl: (benoemde) Threads kunnen gebruiken - 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:
nl: We gaan aan de slag. We coderen onze eerste geluiden. We moeten eerst een functie hebben met de code die we willen spelen. Laten we eenvoudig beginnen. Wij willen ook loops oproepen die in een thread functioneren:

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.
nl: Als dat een beetje te ingewikkeld voor je lijkt, ga dan even terug en herlees de passages over functies en threads. Het is niet al te ingewikkeld nu je je al in deze zaken verdiept hebt.

en: If you run this code, you'll hear note 50 repeating again and again...
nl: Als u deze code uitvoert, zult je noot 50 altijd opnieuw en opnieuw horen spelen...

en: Changing it up
nl: Veranderingen aanbrengen

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!
nl: Nu, hier is waar de pret begint. Terwijl de code *nog loopt* wijzigen 50 naar een ander nummer, zeg 55, druk nogmaals op de knop afspelen. Woah! Het veranderd! 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:
nl: Probeer het opnieuw te wijzigen, verander de noot, de rusttijd. Hoe zit het met het toevoegen van het `use_synth` statement? Verander het bijvoorbeeld naar:

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:
nl: Nu het klinkt erg interessant, maar we kunnen het verder verlevendigen. In plaats van dezelfde noot opnieuw en opnieuw te spelen, speel een akkoord:

en: How about playing random notes from the chord:
nl: Wat denk je van random noten van het akkoord te spelen:

en: Or using a random cutoff value:
nl: Of met behulp van een willekeurige cutoff waarde:

en: Finally, add some drums:
nl: Ten slotte, voeg enkele drums toe:

en: Now things are getting exciting!
nl: Nu word het steeds 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...
nl: Maar voor je recht springt en je begint te live coden met functies en threads, stop met wat je doet en lees de volgende sectie over `live_loop` wat de manier van coderen in Sonic Pi voor eeuwig zal veranderen...

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.
nl: OK, dus dit gedeelte van de handleiding is de echte parel. Als je maar één gedeelte zou kunnen lezen, zou het deze moeten zijn. Als je de vorige sectie van Live codering grondbeginselen leest, is 'live_loop' een eenvoudige manier om precies dat te bereiken, maar zonder zo veel code te hoeven schrijven.

en: If you didn't read the previous section, `live_loop` is the best way to jam with Sonic Pi.
nl: Als je de vorige sectie niet gelezen hebt,  `live_loop` is de beste manier om  met Sonic Pi te jammen.

en: Let's play. Write the following in a new buffer:
nl: Laten we hiermee even spelen. Schrijf het volgende in een nieuwe buffer:

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.
nl: Druk op de afspeel knop. Je hoort elke tel een zelfde basis bliep. Niks opwindend aan. Maar druk nog niet op Stop. Verander de `60` naar `65` en druk terug op Afspelen.

en: Woah! It changed *automatically* without missing a beat. This is live coding.
nl: Woeha! Het veranderde *automatisch* zonder een tel te missen. Dit is Live Coding.

en: Why not change it to be more bass like? Just update your code whilst it's playing:
nl: Waarom deze niet veranderen aar iets meer Bass-achtig? Gewoon je code updaten terwijl het speelt:

en: Then hit Run.
nl: Sla Afspelen aan.

en: Let's make the cutoff move around:
nl: Laten we de cutoff wat rond-bewegen:

en: Hit Run again.
nl: Sla Afspelen opnieuw aan.

en: Add some drums:
nl: Voeg wat drums toe:

en: Change the note from `e1` to `c1`:
nl: Verander de noot van `e1` naar `c1`:

en: Now stop listening to me and play around yourself! Have fun!
nl: Stop nu met naar mij te luisteren en ga zelf aan de slag! Veel plezier!

en: 9.3 Multiple Live Loops
nl: 9.3 Meerdere Live Loops

en: Multiple Live Loops
nl: Meerdere Live Loops

en: Consider the following live loop:
nl: Beschouw even de volgende code:

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.
nl: Je kan je al afgevraagd hebben waarom het de naam `: foo` moet zijn. Deze naam is belangrijk, omdat het betekent dat deze live loop van de andere live loops verschilt.

en: *There can never be two live loops running with the same name*.
nl: *Er kunnen nooit twee live loops met de zelfde naam afspelen*.

en: This means that if we want multiple concurrently running live loops, we just need to give them different names:
nl: Dit betekent dat als we willen dat meerdere live loops gelijktijdig willen uit voeren, moeten we ze gewoon een andere naam geven:

en: You can now update and change each live loop independently and it all just works.
nl: Je kan nu  elke live loop onafhankelijk van elkaar wijzigen en updaten en het werkt gewoon allemaal.

en: Syncing Live Loops
nl: Synchroniseren van Live Loops

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.
nl: Wat je misschien al opgevallen is is dat live loops automatisch met het thread cue mechanisme werkt dat we al verkend hebben. Elke keer een live loop afspeelt genereert deze een nieuw cue gebeuren met de live loop's naam. We kunnen daarom op deze cue's sync-en om ons ervan te verzekeren dat onze loops in sync lopen zonder we daarvoor iets moeten gaan stoppen.

en: Consider this badly synced code:
nl: Beschouw even deze slecht gesyncte code:

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:
nl: Laten we eens kijken als we de timing en synchronisatie kunnen verhelpen zonder deze te stoppen. Laten we eerst de `:foo` loop fixen en de sleep factor 1 veranderen naar `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:
nl: We zijn nog niet helemaal klaar -je zult merken dat de beats niet helemaal correct samenlopen. Dit komt omdat de loops *uit fase* spelen. Laten we dat verhelpen door de ene aan de andere te synchroniseren:

en: Wow, everything is now perfectly in time - all without stopping.
nl: Wow,  nu is alles perfect in tijd - allemaal zonder te stoppen.

en: Now, go forth and live code with live loops!
nl: Ga nu door met je live code en live loops!

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.
nl: Soms heb je best veel werk, zo lijkt het, wanneer er veel code door een ring loopt. Je zal noten in rings steken voor melodieën, rusttijden (sleep) bij ritmes, akkoordenschema's, variaties op het timbre, enz. enz.

en: Ticking Rings
nl: Tick Ringen

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:
nl: Sonic Pi biedt een *zeer* handig hulpmiddel voor het werken met ringen binnen `live_loop`s. Het heet het tick systeem. In de sectie over de ringen spraken we over de teller die constant verhoogt, zoals een weergave van de huidige tel . Tick voert het zelfde idee uit. Het biedt u de mogelijkheid om te *doorheen ringen te tikken*. Laten we eens kijken naar een voorbeeld:

en: This is equivalent to:
nl: Dit is gelijk aan:

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:
nl: Hier nemen we de pentatonische toonladder E3 mineur en ticking doorheen elk element. Dit wordt gedaan door `.tick` toe te voegen aan het einde van de verklaring van de toonladder. De tick is lokaal voor de live loop, dus elke live loop kan zijn eigen onafhankelijke tick hebben:

en: You can also call `tick` as a standard fn and use the value as an index:
nl: U kunt ook `tick` als een standaard fn aanroepen en de waarde gebruiken als een index:

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.
nl: Het is veel leuker om `.tick` op het einde aan te roepen. de `.tick` fn is als je je dingen wil verbeelden met de tick waarde en voor wanneer je ticks wil gebruiken voor andere dingen dan in ringen te indexeren.

en: Look
nl: Kijk

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.
nl: De magische van tick is dat niet alleen het resultaat geeft van een nieuwe index (of de waarde van de ring op die index) ook zorgt het ervoor dat de volgende keer dat u tick aanroept, dit de volgende waarde zal zijn. Neem een kijkje naar de voorbeelden in de docs `tick` voor de vele manieren om hiermee te werken. Nu is het echter belangrijk erop te wijzen dat je soms gewoon wil kijken naar de huidige waarde van de `tick` maar deze *niet te verhogen*. Deze optie is beschikbaar via de `look` fn. U kunt `look` oproepen zoals een standaard fn of door toevoeging van `look`  aan het einde van een ring.

en: Naming Ticks
nl: Ticks Benoemen

en: Finally, sometimes you'll need more than one tick per live loop. This is achieved by giving your tick a name:
nl: En nog dit, soms heb je meer dan één tick per live loop nodig. Dat kan je door je tick een naam te geven:

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`.
nl: Hier gebruiken we twee ticks: één voor de te spelen noten en een andere voor de rusttijd (sleep). Vermits deze alle twee in dezelfde live loop zitten, moeten we ze een unieke naam geven om hen te kunnen onderscheiden. Hier gaat het net zoals een `live_loop` benoemen, we geven een symbool door, voorafgegaan door een `:`. In het voorgaande voorbeeld noemden we één tick `:foo`en een andere `:bar`. Als we naar dezen willen kijken ( `look`), moeten we ook de naam van de tick doorgeven aan `look`.

en: Don't make it too complicated
nl: Maak het niet te ingewikkeld

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.
nl: De grote kracht van het tick systeem is niet behulpzaam als beginner. Probeer niet alles uit deze sectie. Focus op een tick in één enkele ring. Dit geeft de grootste voldoening en is het minst gekunsteld tick-en door ringen in jouw `live_loop`s.

en: Take a look at the documentation for `tick` where there are many useful examples and happy ticking!
nl: Neem een kijkje naar de documentatie 'Tick' waar nuttige voorbeelden te vinden zijn. Nog een leuke tick verder!

en: 10 Time State
nl: 10 Tijd toestand

en: Time State
nl: Tijd toestand

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).
nl: Vaak is het nuttig om informatie te *delen over meerder threads of live lussen*. Je zou bijvoorbeeld de huidige toonsoort, BPM of meer abstracte concepten zoals de huidige 'complexiteit' (wat je potentieel op verschillende manieren interpreteerd in verschillende threads). We willen ook niet iets van ons bestaande garanties voor determinisme verliezen wanneer we dit doen. In andere woorden, we willen nog steeds code met andere kunnen delen en exact weten wat ze horen wanneer het wordt uitgevoerd. Aan het einde van sectie 5.6 van deze tutorial wordt kort besproken waarom we *geen variabelen zouden moeten gebruiken om informatie te delen tussen threads* vanwege het verlies van determinisme (op hun beurt veroorzaakt door race condities).

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.*.
nl: De oplossing in Sonic Pi voor het probleem van een makkelijk model met globale variabelen op een deterministische wijze is door een vernieuwend systeem dat tijd toestand wordt genoemd. Dit kan complex en moeilijk klinken (in feite is programmeren met meerdere threads en een gedeeld geheugenmodel tipisch een onderwerp op universitair niveau). Echter, zoals je zult zien, net als het spelen van de eerste noot, * Sonic Pi maakt het onzetten eenvoudig om toestand te delen tussen threads* terwijl je programma's nog steeds *thread safe en deterministisch blijven*.

en: Meet `get` and `set`...
nl: Maak kennis met `get` en `set`...

en: 10.1 Set and Get
nl: 10.1 Set en get

en: Set and Get
nl: Set en 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...
nl: Sonic Pi heeft een globaal memory model genaamd tijd toestand. De twee belangrijkste dingen die je ermee doet is informattie `zetten` (set) en `ophalen` (get). Laten we erin duiken...

en: To store information into the Time State we need two things:
nl: Om informatie op te slaan in de tijd toestand  hebben we twee dingen nodig:

en: the information we want to store,
nl: de informatie die we willen opslaan,

en: a unique name (key) for the information.
nl: een unieke naam (sleutel) voor de informatie.

en: For example, we might want to store the number `3000` with the key `:intensity`. This is possible using the `set` function:
nl: We willen bijvoorbeeld het getal `3000` opslaan met de sleutel `:intensiteit`. Dit is mogelijk door de `set` functie te gebruiken:

en: set :intensity, 3000
nl: set :intensiteit, 3000

en: We can use any name for our key. If information has already been stored with that key, our new `set` will override it:
nl: We kunnen elke naam gebruiken voor onze sleutel. Wanneer informatie al was opgeslagen voor die sleutel, dan overschrijft de nieuwe `set` die:

en: set :intensity, 1000
    set :intensity, 3000
nl: set :intensiteit, 1000
    set :intensiteit, 3000

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.
nl: In het bovenstaande voorbeeld hebben we beide getallen opgeslagen onder dezelfde sleutel. De laatste aanroep van `set` 'wint'. Het getal dat gekoppeld is aan `:intensiteit` zal `3000` zijn omdat de eerste aanroep van `set` effectief wordt overschreven.

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:
nl: Om informatie op te halen uit de tijd toestand hebben we allen de sleuten nodig die werd gebruikt om voor `set`. In ons geval is dat `:intensiteit`. We hoeven alleen `get[:intensiteit]` aan te roepen wat we kunnen zien door het resultaat naar het log af te drukken:

en: print get[:intensity] #=> prints 3000
nl: print get[:intensiteit] #=> print 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.
nl: Merk op dat aanroepen van `get` informatie kunnen teruggeven die was ge`set` in de vorige uitvoering.  Wanneer een stuk informatie is ge`set` is het beschikbaar totdat of de informatie is overschreven (net als de aanpassing van `:intensiteit` van de waarde `1000` naar `3000` hierboven) of Sonic Pi is afgesloten.

en: Multiple Threads
nl: Meerdere 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:
nl: Het belangrijkste voordeel van het tijd toestand systeem is dat het veilig gebruikt kan worden tussen meerdere threads of live lussen. Je kunt bijvoorbeeld een live lus hebben voor het zetten van informatie en een andere voor het ophalen:

en: live_loop :setter do
      set :foo, rrand(70, 130)
      sleep 1
    end
    live_loop :getter do
      puts get[:foo]
      sleep 0.5
    end
nl: live_loop :opslaan do
      set :foo, rrand(70, 130)
      sleep 1
    end
    live_loop :ophalen do
      puts get[:foo]
      sleep 0.5
    end

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:
nl: Het leuke aan het gebruik van `get` en `set` tussen meerdere threads zoals hier is dat het altijd hetzelfde resultaat oplevert iedere keer dat je op uitvoeren drukt. Vooruit, probeer het. Kijk op je het volgende in je log krijgt:

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
nl: {run: 0, time: 0.0}##run: draai
     └─ 125.72265625
    {run: 0, time: 0.5}##run: draai
     └─ 125.72265625
    {run: 0, time: 1.0}##run: draai
     └─ 76.26220703125
    {run: 0, time: 1.5}##run: draai
     └─ 76.26220703125
    {run: 0, time: 2.0}##run: draai
     └─ 114.93408203125
    {run: 0, time: 2.5}##run: draai
     └─ 114.93408203125
    {run: 0, time: 3.0}##run: draai
     └─ 75.6048583984375
    {run: 0, time: 3.5}##run: draai
     └─ 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).
nl: Probeer het een paar keer uit te voeren, zie je wel, het is steeds hetzelfde. Dit is wat we deterministisch gerag noemen en het is werkelijk heel belangrijk wanneer we onze muziek als code willen delen en zeker willen weten dat de persoon die code afspeelt exact hetzelfde hoort als wat we wilden dat ze hoorden (net als een MP3 afpselen of een internet stream voor alle luisteraars hezelfde klinkt).

en: A Simple Deterministic State System
nl: Een simple deterministisch toestandssysteem

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:
nl: Eerder, in sectie 5.6, bespraken we waarom variabelen gebruiken over meerdere threads voor willekeurig gedrag kan zorgen. Daardoor is het betrouwbaar reproduceren zoals de volgende code niet mogelijk:

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
nl: ## Een voorbeeld van niet deterministisch gedrag
    ## (veroorzaakt door race condities veroorzaakt door meerdere
    ## live lussen die dezelfde variable manipuleren
    ## op hetzelfde moment).
    ##  
    ## Wanneer je deze code uitvoert zul je opmerken
    ## dat de lijst die wordt afgedrukt 
    ## niet altijd gesorteerd is
    a = (ring 6, 5, 4, 3, 2, 1)
    live_loop :geschud do
      a = a.shuffle
      sleep 0.5
    end
    live_loop :gesorteerd do
      a = a.sort
      sleep 0.5
      puts "gesorteerd: ", a
    end

en: Let's take a look at how this might look using `get` and `set`:
nl: Laten we kijken hoe dit eruit ziet wanneer we `get` en `set` gebruiken:

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
nl: ## Een voorbeeld van deterministisch gedrag
    ## (ondanks gelijktijdige toegang tot gedeelde toestand)
    ## door het gebruik van het tijd toestand systeem van Sonic Pi.
    ##
    ## Wanneer deze code wordt uitgevoerd is de lijst
    ## die wordt afgedrukt altijd gesorteerd!
    set :a, (ring 6, 5, 4, 3, 2, 1)
    live_loop :geschud do
      set :a, get[:a].shuffle
      sleep 0.5
    end
    live_loop :gesorteerd do
      set :a, get[:a].sort
      sleep 0.5
      puts "gesorteerd: ", 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.
nl: Merk op dat de code bijna identiek is aan de versie die de variabele gebruikt hiervoor. Echter wanneer je de code uitvoert gedraagt het zich zoals je zou verwachten met elk typisch stuk Sonic Pi code: *het doet elke keer hetzelfde* in dit geval dankzij het tijd toestand systeem.

en: Therefore, when sharing information across live loops and threads, use `get` and `set` instead of variables for deterministic, reproducible behaviour.
nl: Gebruik daarom wanneer je informatie deelt tussen live lussen en threads `get` en `set` in plaat van variabelen voor deterministisch en reproduceerbaar gedrag.

en: 10.2 Sync
nl: 10.2 Sync ("synchroniseer")

en: Sync
nl: Sync (synchroniseren)

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*.
nl: Sectie 5.7 introduceerde de functies `cue` en `sync` om het synchroniseren van threads af te handelen. Wat niet werd uitgelegd is dat het het tijd toestand systeem is dat deze functionaliteit beschikbaar stelt. Eigenlijk is `set` een variatie op `cue` en bouwt voort op dezelfde kernfunctionaliteit: het toevoegen van informatie aan het tijd toestand systeem. Bovendien is `sync` ook zo ontworpen dat het naadloos samenwerkt met de tijd toestand - alle informatie die we van plan zijn op te slaan in de tijd toestand waarop we kunnen synchroniseren. Met andere woorden - * we `sync`-en op gebeurtenissen die nog moeten worden ingevoegd in de tijd toestand *.

en: Waiting for Events
nl: Wachten op gebeurtenissen

en: Let's take a quick look at how to use `sync` to wait for new events to be added to Time State:
nl: Laten we kort kijken naar hoe `sync` gebruikt wordt om op nieuwe gebeurtenissen te wachten die worden toegevoegd aan tijd toestand:

en: in_thread do
      sync :foo
      sample :ambi_lunar_land
    end
    sleep 2
    set :foo, 1
nl: in_thread do
      sync :bla
      sample :ambi_lunar_land
    end
    sleep 2
    set :bla, 1

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.
nl: In dit voorbeeld maken we eerst een draad die wacht op een ':foo'-gebeurtenis die toegevoegd wordt aan de Time State. Nadat we deze draad aangekondigd hebben, slapen we twee slagen en dan zetten we ('set') 'foo' op '1'. Dat zorgt er vervolgens voor dat de 'sync' vrijgegeven wordt zodat op de volgende regel het ':ambi_lunar_land'-stukje geactiveerd wordt.

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.
nl: Let erop, dat 'sync' altijd wacht op *toekomstige* gebeurtenissen, en dat het de huidige draad blokkeert zolang die gebeurtenis nog niet opgetreden is. Bovendien erft het de logische tijd van de draad die hem geactiveerd heeft via de 'set' of 'cue', zodat het gebruikt kan worden om de tijd te synchroniseren.

en: Passing values into the Future
nl: Doorgeven van waarde aan de toekomst

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`:
nl: In het bovenstaande voorbeeld is ':bla' op '1' gezet om er vervolgens niets mee te doen. We kunnen de waarde ophalen van de thread door 'sync' aan te roepen:

en: in_thread do
      amp = sync :foo
      sample :ambi_lunar_land, amp: amp
    end
    sleep 2
    set :foo, 0.5
nl: in_thread do
      amp = sync :bla
      sample :ambi_lunar_land, amp: amp
    end
    sleep 2
    set :bla, 0.5

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.
nl: Let erop, dat waarde die via 'set' en 'cue' doorgegeven worden 'thread safe' moeten zijn. Dat wil zeggen dat de waarden niet opeens gewijzigd mogen kunnen worden. Voorbeelden van toegestane waardetypes zijn onveranderlijke tekenreeksen ('immutable strings'), getallen, symbolen of bevroren tekenreeksen ('frozen strings'). Sonic Pi geeft een foutmelding als je een waarde gebruikt die niet aan die voorwaarde voldoet.

en: 10.3 Pattern Matching
nl: 10.3 Patroonherkenning

en: Pattern Matching
nl: Patroonherkenning

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.
nl: Wanneer je informatie haalt ('get') van de Time State of gegevens in de Time State vastlegd ('set'), kun je ook complexere waarden gebruiken dan de basissymbolen zoals ':foo' en ':bar'. Je kan bijvoorbeeld paden in een URL-stijl gebruiken zoals '/foo/bar/baz'. Zodra we zulke paden gaan gebruiken, kunnen we voordeel halen uit de slimme patroonherkenning van Sonic Pi, zodat we met vergelijkbare ('similar') in plaats van precies gelijke ('identical') paden kunnen halen ('get') en synchroniseren ('sync'). Laten we eens kijken.

en: `cue "/foo/bar/baz"`
nl: `cue "/bla/bar/baz"`

en: `cue "/foo/baz/quux"`
nl: `cue "/bla/baz/quux"`

en: `cue "/foo/bar"`
nl: `cue "/bla/bar"`

en: `cue "/foo/baz/quux/quaax"`
nl: `cue "/bla/baz/quux/quaax"`

en: `cue "/foo/baz/baz"`
nl: `cue "/bla/baz/baz"`

en: `cue "/foo/beans/baz"`
nl: `cue "/bla/beans/baz"`

en: `cue "/foo/flibble/baz"`
nl: `cue "/bla/flibble/baz"`

en: `cue "/foo/abaz/baz"`
nl: `cue "/bla/abaz/baz"`

en: `cue "/foo/beans/baz/eggs"`
nl: `cue "/bla/beans/baz/eggs"`

en: `cue "/foo/bar/beans/baz"`
nl: `cue "/bla/bar/beans/baz"`

en: `cue "/foo/baz"`
nl: `cue "/bla/baz"`

en: `cue "/foo/a/b/c/d/e/f/baz"`
nl: `cue "/bla/a/b/c/d/e/f/baz"`

en: `cue "/foo/bar/quux"`
nl: `cue "/bla/bar/quux"`

en: `cue "/foo/beans/quux"`
nl: `cue "/bla/beans/quux"`

en: `cue "/foo/eggs/quux"`
nl: `cue "/bla/eggs/quux"`

en: `cue "/foo/aux/baz"`
nl: `cue "/bla/aux/baz"`

en: `cue "/foo/bux/baz"`
nl: `cue "/bla/bux/baz"`

en: `cue "/foo/cux/baz"`
nl: `cue "/bla/cux/baz"`

en: `cue "/foo/dux/baz"`
nl: `cue "/bla/dux/baz"`

en: `cue "/foo/eux/baz"`
nl: `cue "/bla/eux/baz"`

en: Controlling Code
nl: Besturingscode

en: Getting Values
nl: Waarden ophalen

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

en: Increasing the Duration
nl: Duurtijd vergroten

en: Multiple Inputs
nl: Meerdere inputs

en: Live Audio
nl: Live audio

en: live_audio :foo
nl: live_audio :bla

en: with_fx :reverb do
      live_audio :foo
    end
nl: with_fx :reverb do
      live_audio :bla
    end

en: Now, whilst you're still hearing the audio live from the sound card with reverb, change the code to the following:
nl: Wijzig, terwijl je de live audio van de geluidskaart nog met reverb hoort, nu de code naar het volgende:

en: with_fx :echo do
      live_audio :foo
    end
nl: with_fx :echo do
      live_audio :bla
    end

en: with_fx :reverb do
      with_fx :echo do
        live_audio :foo
      end
    end
nl: with_fx :reverb do
      with_fx :echo do
        live_audio :bla
      end
    end

en: live_audio :foo, :stop
nl: live_audio :bla, :stop

en: live_audio :foo, stereo: true, input: 2
nl: live_audio :bla, stereo: true, input: 2

en: In the above example, the `:loop_amen` sample is sent to its outer context, the `:sound_out` FX. This then sends a mono mix to audio card output 3 and then multiplies the audio by 0 which essentially silences it. It is this silenced signal which is then sent out to the `:sound_out`'s outer context which is the standard output. Therefore with this code, the default output channels will not receive any audio, and channel 3 will receive a mono mix of the amen drum break.
nl: In het bovenstaande voorbeeld is de `:loop_amen` sample verstuurd naar zijn buitenste context, de `:sound_out` FX. Dit stuurt dan een mono mix naar audiokaart output 3 en vermenigvuldigd de audio vervolgens met 0 wat het feitelijk verstomt. Het is dit verstomde signaal dat wordt uitgestuurd naar de buitenste context van `:sound_out` wat de standaard output is. Daarom ontvangen de default outputkanalen geen audio met deze code en kanaal drie zal een mono mix van de amen drum rust ontvangen.

en: 14 Conclusions
nl: 14 conclusies

en: Conclusions
nl: Conclusies

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.
nl: Dit rond Sonic Pi's handleiding af. Hopelijk heb je terloops iets bijgeleerd. Maak je geen zorgen als het voelt alsof je niet alles begrepen hebt - speel er gewoon mee en heb plezier in wat je doet, zo zal je op je eigen tempo nieuwe leerstof tot je opnemen. Duik gerust terug in een sectie waarover je nog vragen hebt.

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.
nl: Ten slotte, nodigen ik je ook uit om je wat nader tot de rest van de documentatie in dit help-systeem te wenden. Er zijn een heleboel functies die nog niet behandeld zijn in deze handleiding en die jij nog kan ontdekken.

en: So play, have fun, share your code, perform for your friends, show your screens and remember:
nl: Dus speel, heb veel plezier, deel jouw code, treed op voor vrienden, toon jouw scherm en vergeet niet:

en: *There are no mistakes, only opportunities.*
nl: *Er zijn geen fouten, alleen maar kansen*

en: A Appendix A - MagPi Articles
nl: A Appendix A - MagPi artikelen

en: MagPi Articles
nl: MagPi artikelen

en: Appendix A collects all the Sonic Pi articles written for the MagPi magazine.
nl: Bijlage A verzamelt alle de Sonic Pi artikelen geschreven voor het tijdschrift MagPi.

en: Dive into Topics
nl: Duik in Onderwerpen

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.
nl: Deze artikelen zijn niet bedoeld om in een strikte volgorde  te worden gelezen en bevatten veel cross-over materiaal uit de tutorial zelf. In plaats van te proberen je alles van Sonic Pi te leren, zijn ze elk gericht op een specifiek aspect van Sonic Pi en dit op een leuke en toegankelijke manier.

en: Read the MagPi
nl: Lees de MagPi

en: You can see them in their glorious professionally typeset form in the free PDF downloads of The MagPi here: https://www.raspberrypi.org/magpi/
nl: Je kan ze in hun glorieuze professioneel ✓ vorm zien in de gratis PDF-downloads van de MagPi : https://www.raspberrypi.org/magpi/

en: Suggest a Topic
nl: Een onderwerp suggereren

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!
nl: Mocht het zijn dart er een onderwerp ontbreekt dat jou interesseert - waarom zou je daar dan geen suggestie over kunnen maken? De makkelijkste manier om dit te doen is jouw suggestie tweeten naar [@Sonic_Pi](http://twitter.com/sonic_pi). Jouw suggestie kan wel eens het onderwerp van het volgende artikel zijn!

en: A.1 Tips for Sonic Pi
nl: A.1 Tips voor Sonic Pi

en: Five Top Tips
nl: Vijf Top Tips

en: 1. There are no mistakes
nl: 1. Er bestaan geen fouten

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.
nl: De belangrijkste les om leren in Sonic Pi is dat er geen echte fouten bestaan. De beste manier van leren is om gewoon te  proberen en te proberen en te proberen. Probeer verschillende dingen uit, stop ermee je zorgen te maken of je code nu goed klinkt of niet en begin te experimenteren met zoveel mogelijk verschillende synths, noten, FX als mogelijk is. Je zal ontdekken dat je een heleboel dingen maakt die je aan het lachen brengen omdat het gewoon verschrikkelijk klinkt en soms zullen er echte juweeltjes tussen zitten, die echt geweldig klinken. Laat gewoon de dingen vallen die u niet graag doet en hou van wat je doet. Hoe meer `fouten` je jezelf toelaat te maken hoe sneller je zaken zal leren en jouw persoonlijke geluids codering zal ontdekken.

en: 2. Use the FX
nl: 2. FX gebruiken

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:
nl: Laat ons aan nemen dat je de basis om klanken te maken in Sonic Pi met `sample`, `play`. Wat nu? Wist je dat Sonic Pi over de 27 studio ondersteunt om de sound van je code te veranderen. Effecten zijn zoals beeldfilters in tekenprogramma's maar in plaats van zaken te vervagen of zwart-wit te maken, kan je zaken aan jouw geluid toevoegen zoals reverb, distortion, en echo. Het concept isq zoals je een geluidskabel vanuit je gitaar in de effectenpedaal van jou keuze te steken en vervolgens de versterker in. Gelukkig maakt Sonic Pi je het heel makkelijk om FX te gebruiken en dit zonder kabels! Het enige wat je moet doen is het fragment in jouw code selecteren waar je FX wil op gebruiken en deze met de FX code omhullen. Laten we naar een voorbeeld kijken. Stel dat je deze code hebt:

en: If you wanted to add FX to the `:loop_garzul` sample, you'd just tuck it inside a `with_fx` block like this:
nl: Als je een FX aan de  `:loop_garzul` sample wil toevoegen, moet je deze gewoon in een `with_fx` blok steken zoals hier:

en: Now, if you wanted to add FX to the bass drum, go and wrap that with `with_fx` too:
nl: Als je nu ook een FX aan de bass drum wil voegen, omhul deze dan ook met een  `with_fx`:

en: Remember, you can wrap *any* code within `with_fx` and any sounds created will pass through that FX.
nl: Denk eraan , je kan *elke* code omhullen met  `with_fx` en elke klank hierin gecreëerd zal door deze FX passeren.

en: 3. Parameterise your synths
nl: 3. Het parametreren van jouw 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:
nl: Om je eigen geluid te gaan ontwikkelen, zal je snel willen leren, hoe je synths en Fx kan veranderen en controllen. Zo wil je bijvoorbeeld de lengte van een noot veranderen, of wil je wat meer reverb toevoegen, of de tijdsinstellingen van een echo aanpassen. Gelukkig geeft Sonic Pi de mogelijkheid om dit op een hoog niveau te gaan doen met behulp van optionele parameters of in het kort: opts. Laten we dit even bekijken. Kopieer de volgende code in een werkveld en klik afspelen:

en: Ooh, a lovely guitar sound! Now, let's start playing with it. How about changing its rate?
nl: Ooh, een mooie gitaarklank! Nu gaan we hiermee spelen. Wat dacht je van zijn koers te veranderen?

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:
nl: Hé, wat is dat stukje `rate: 0.5`, dat daar op het einde staat? Dat is een opt! Alle synths en FX van Sonic Pi ondersteunen deze en er zijn er tal van beschikbaar om mee te spelen. Probeer deze eens:

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.
nl: Probeer nu de feedback te verhogen naar 1 om maffe klanken te horen. Lees de documentatie voor details over de beschikbare opts.

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:
nl: De beste manier om zaken snel te ontdekken in Sonic Pi is experimenteren en live te coderen. Dit laat jou toe om stukjes code op te starten en deze voortduren te veranderen en te controllen terwijl je speelt. Bijvoorbeeld, als je niet weet wat de cutoff parameter doet met een sample, speel er gewoon mee, probeer het. Kopieer deze code in één van je werkvelden:

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`...
nl: Klik nu op afspelen en hoor hierbij een licht gedempte drum break. Verander de cutoff waarde nu naar `80` en klik opnieuw op afspelen. Hoor je het verschil? Probeer  `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.
nl: Eens je het gewoon bent  `live_loop`s te gebruiken zal je nooit meer zonder deze kunnen. Wanneer ik een live coding doe reken ik hier zwaar op, zoals een drummer zijn drumsticks nodig heeft. Voor meer informatie over live coding, kijk naar Sectie 9 van de ingebouwde handleiding.

en: 5. Surf the random streams
nl: 5. Surfen op random golven

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:
nl: Tot slot nog deze, ik hou ervan om een beetje vals te spelen door Sonic Pi in mijn plaats te laten componeren. Een goede manier om dit te verwezenlijken is gebruik te maken van het randomiseren. Misschien lijkt dit een beetje ingewikkeld maar dat is het helemaal niet. Laat ons hiernaar naar kijken. Kopieer deze in een lege buffer:

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`:
nl: Wanneer je deze afspeelt zal je een constante stroom van random noten horen spelen in de toonladder `:e2 :minor_pentatonisch` gespeeld met de synth `:dsaw`." Maar wacht! Dat is geen melodie" hoor ik jou roepen! Wel, dit is ook het eerste deel van onze tovertruc. Elke keer we rond  gaan in de `live_loop`, kunnen we Sonic Pi vertellen om de random toeloop naar een gegeven punt te resetten. Dit is een beetje zoals in de tijd teruggaan met de dokter in de TARDIS naar een bepaald punt in tijd en ruimte. We proberen de lijn `use_random_seed 1` toe te voegen aan de  `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.
nl: Nu, elke keer de `live_loop` rond gaat , wordt de random stream gereset. Dit betekend dat iedere keer dezelfde 16 noten gekozen worden. En presto! Instant melodie. Nu komt het spannende deel. Verander de seed waarde van `1` naar een ander getal. Neem `4923`. Wauw! Een andere melodie! Dus door gewoon één cijfer te veranderen (de random seed), je kan je zoveel melodische combinaties gaan verkennen als je je kan voorstellen ! Nu, dat is de magie van code.

en: A.2 Live Coding
nl: A.2 Live codering

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.
nl: De laserstralen sneden door de slierten rook, terwijl de subwoofer de bassen diep in de lichamen van de menigte pompten. De sfeer  was rijp met een onstuimige mix van synths en dansbewegingen. Maar tegelijkertijd klopte er iets niet in deze discotheek.  In felle kleuren boven de DJ booth was een futuristische tekst geprojecteerd die knipperde en heen en weer bewoog. Het waren geen hype visuals, maar een projectie van Sonic Pi op een Raspberry Pi. De aanwezige in de DJ booth draaide geen plaatjes, hij was code aan het schrijven, aanpassen en redigeren. Live. Dit is 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.
nl: Dit klinkt misschien als een vergezocht verhaal van een futuristische nachtclub maar codering van muziek zoals deze is een groeiende trend en wordt vaak omschreven als Live codering (http://toplap.org). Een van de recente benadering van muziek spelen  is de Algorave (http://algorave.com) - evenementen waar artiesten zoals ik code schrijven voor mensen om op muziek te dansen . Echter, je hoeft niet naar een nachtclub te trekken voor een Live Code - met Sonic Pi v2.6 + kan je het overal waar je je Raspberry Pi  kunt meenemen met een paar hoofdtelefoons of luidsprekers. Voor je het einde van dit artikel kan lezen, zal je je eigen beats programmeren en  hen live wijzigen. Waar je enkel beperkt wordt door uw verbeelding.

en: The key to live coding with Sonic Pi is mastering the `live_loop`. Let's look at one:
nl: De hoofdzaak bij het live coderen ligt bij het beheersen van de  `live_loop`. Hier kijken we naar zo ééntje:

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!.
nl: Er zitten 4 basisingrediënten in een  `live_loop`. De eerst is de naam. Onze `live_loop`heet `:beats`. Je kan jouw `live_loop`benoemen zoals jij dat wil. Doe dwaas. Wees creatief. Ikzelf gebruik benamingen die een uitleg geven over welke klank zij naar het publiek brengen. Het volgende ingrediënt is het `do` woord die markeert waar de `live_loop` start. het derde is het `end`woord dat het einde van onze`live_loop markeert, en tenslotte heb je de inhoud van de `live_loop` waarin beschreven wordt wat de loop gat herhalen- dat is het stukje tussen `do` en `end`. In dit geval gaan we de bass drum sample met een halve tel rusttijd spelen . Dit produceert een aangenaam regelmatige bass beat. Ga je gang, kopieer deze in een lege buffer en klik op afspelen. Boem, boem, boem!.

en: Redefining On-the-fly
nl: Ter plekke herdefiniëren

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:
nl: OK, dus wat is er nu zo speciaal aan de 'live_loop'? Tot nu toe lijkt het gewoon een veredelde 'loop'! Nou, de schoonheid van ' de live_loop is dat u hen ter plekke kan herdefiniëren. Dit betekent dat terwijl deze nog steeds speelt, kan je veranderen wat ze doen. Dit is het geheim van het live coderen met Sonic Pi. Laten we eens spelen:

en: Sleeping is important
nl: Slapen is belangrijk

en: One of the most important lessons about `live_loop`s is that they need rest. Consider the following `live_loop`:
nl: Een van de belangrijkste lessen over `live_loop`s is dat ze rust nodig hebben. Beschouw deze volgende '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`.
nl: Wanneer je deze code probeert te laten lopen, zie je onmiddellijk dat Sonic Pi klaagt dat de `live_loop` geen `sleep` toebedeeld heeft gekregen. Dit is het veiligheidssysteem dat in werking treedt! Nemen even de tijd om erover na te denken wat je aan de computer vraagt met deze code. Juist, het vraagt de computer een oneindig aantal koorsamples te af te spelen op nul tijd. Zonder het veiligheidssysteem zou de arme computer crashen tijdens dit proces. Dus onthou dat jouw `live_loop` een `sleep` moet bevatten.

en: Combining Sounds
nl: Geluiden combineren

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`!
nl: In muziek gebeuren veel dingen tezelfdertijd. Drums spelen op het zelfde moment als de bass en op het zelfde moment als zang en gitaar... In Computing noemen we dit samenwerking en Sonic Pi biedt ons een ongelofelijk eenvoudige manier om zaken samen te laten spelen. Gewoon gebruik maken van verschillende `live_loop`s!

en: Here, we have two `live_loop`s, one looping quickly making beats and another looping slowly making a crazy bass sound.
nl: Hier hebben we twee `live_loops` de ene speelt snel en maakt beats, de andere speelt snel en maakt maffe bas geluiden.

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:
nl: Eén van de interessante zaken aan het gebruik van meerdere `live_loop`s is dat deze hun eigen onafhankelijke tijd kunnen hebben. Dit betekend dat je makkelijk interessante poly-ritmische structuren kan maken en zelfs kan spelen met fase-verschuivingen in de stijl van Steve Reich. Check deze:

en: Bringing it all together
nl: Waardoor het allemaal samen valt

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...
nl: In elk van deze tutorials eindigen we met een muzikaal voorbeeld waarin alle ideeën die werden voorgesteld samen worden gebracht. Bekijk de code en probeer je voor te stellen wat deze zou gaan doen. Plak deze dan in een lege buffer in Sonic Pi en druk op afspelen, en luister nu hoe dit klinkt. Verander tenslotte één van de getallen en schakel commentaarlijnen in om lijnen in en uit te schakelen. Bekijk of je dit ook niet kan gaan gebruiken in een live optreden, en boven alles,beleef hier plezier aan! Tot volgende keer...

en: A.3 Coded Beats
nl: A.3 Gecodeerd Beats

en: Coded Beats
nl: Gecodeerd 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.
nl: Een van de meest revolutionaire en vernieuwende ontwikkeling op technisch gebied was de uitvinding van de sampler.Dit waren kisten die jou toelieten eender welke klank op te nemen, te manipuleren en terug af te spelen, op vele interessante manieren. Bijvoorbeeld kon je van een oude plaat een drumsolo (of een break) nemen, deze opnemen op jouw sampler en deze dan op repeat aan halve snelheid afspelen om de basis te leggen van je nieuwe beats. Dit is hoe old school hip-hop werd geboren en vandaag is het haast onmogelijk om Elektronische muziek te vinden die geen gebruik maken van één of andere sample. Het gebruik van samples is een geweldige manier om makkelijk nieuwe en interessante elementen aan jouw live code toe te voegen.

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!
nl: Dus waar kan je zo'n sampler krijgen? Wel je hebt er al één- het is jouw Raspberry Pi! The ingebouwde codeer app Sonic Pi  heeft een uiterst krachtige sampler ingebouwd in zijn core. Laten we ermee gaan spelen!

en: The Amen Break
nl: De 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.
nl: Een van de meest klassiek en herkenbare drum break samples is de Amen Break. Het werd voor het eerst uitgevoerd in 1969 in het nummer "Amen Brother" door de Winstons als een gedeelte in een drumbreak. Het was echter wanneer het werd ontdekt door de vroege hip-hop muzikanten in de jaren 80 en werd gebruikt in samplers dat de start werd gegeven deze sample  in vele stijlen te gaan gebruiken zoals drum& bass, breakbeat, hardcore techno en 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:
nl: Ik ben er zeker van dat je blij bent dat deze standaard ingebouwd zit in Sonic Pi. Ruim even een buffer leeg en gooi er de volgende code in:

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.
nl: Klik op *Afspelen* en Boem. Je luistert nu naar één van de meest invloedrijke drumbreaks in de geschiedenis van dance music. Als one-shot was deze niet populair natuurlijk wel als loop.

en: Let's loop the Amen Break by using our old friend the `live_loop` introduced in this tutorial last month:
nl: Laat ons de Amen Break loopen in onze goede vriend `live_loop`, geïntroduceerd in deze tutorial van vorige maand:

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.
nl: OK, deze loopt nu, maar er is wel een vervelende pauze elke keer dat hij zijn cyclus heeft volbracht. Dat komt omdat we het een `sleep`-tijd van`2`tellen hebben gegeven en met de standaard 60 BPM duurt de `:loop_amen` sample  `1.753` tellen. Hierdoor hebben we een stilte van `2 - 1.753 = 0.247` tellen. Ook al is deze kort, het is wel merkbaar.

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.
nl: Om dit probleem op te lossen kunnen we de `beat_stretch`opt gebruiken om Sonic Pi op te dragen deze sample uit te rekken (of te doen inkrimpen) om met het opgegeven aantal tellen overeen te laten komen.

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.
nl: De `sample`en `synth` fns van Sonic Pi geven jou veel controle over de optionele parameters zoals `amp:`, `cutoff:`en `release:` . Maar de term optionele parameter is wel een mond vol, dus noemen we deze *opts* om de zaken eenvoudig te houden.

en: Now we're dancing! Although, perhaps we want to speed it up or slow it down to suit the mood.
nl: Nu zijn we aan het dansen! Maar misschien willen we het wat sneller of wat trager om de juiste stemming te pakken te krijgen.

en: Playing with Time
nl: Spelen met Tijd

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:
nl: Ok, en als we de stijl willen aanpassen naar old school hip hop of breakcore? Een eenvoudige manier om dit te gaan doen is te spelen met tijd -of in andere woorden: aan het tempo klooien. Dit is makkelijk te doen in Sonic Pi, gooi gewoon `use_bpm` in je live loop:

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.
nl: Terwijl je over deze trage beats heen rapt merk je dat we nog steeds voor 2 `sleep`hebben en dat onze BPM 30 is, maar alles is wel in maat. De `beat_stretch`opt werkt met de huidige BPM om ervoor te zorgen dat alles werkt.

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!
nl: Nu komt het leuke! Terwijl de loop nog altijd speelt, verander de`30`in de `use_bpm 30`regel naar `50`. Woeha, Alles gaat nu sneller, en *in maat* gehouden! Probeer sneller te gaan - omhoog naar 80, naar 120, doe nu eens goed zot en gebruik 200!

en: Filtering
nl: Filteren

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:
nl: Nu we samples kunnen live lopen, laat ons eens kijken naar de leukste opts die bij de `sample`synth geleverd zijn. Eerst komt `cutoff`aan beurt, welke de cutoff op de filter van de sampler regelt. Standaard is deze uitgeschakeld, maar je kan deze makkelijk aanzetten:

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.
nl: Ga je gang en verander de `cutoff:` opt. Verhoog deze bijvoorbeeld naar 100, klik op *Afspelen* en wacht een cyclus van de loop af om de verandering van het geluid waar te nemen. Merk op dat lage waarden zoals 50 zacht klinken en laag en hoger waarden zoals 100 en 120 voller klinken en rasperig. Dit is omdat de `cutoff:`opt de hoge geluidsfrequentie afsnijdt zoals een grasmaaier de grasuiteinden afknipt. De `cutoff:` opt is zoals de lengte instelling, en bepaald hoeveel gras overblijft.

en: Slicing
nl: Slicing (Snijden)

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:
nl: Nog een fantastisch hulpmiddel om mee aan de slag te gaan is de slicer FX. Deze zal het geluid uiteen hakken (snijden). Omhul de `sample`regel met de FX code als volgt:

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).
nl: Merk op hoe de klank op en neer stuitert, elke keer meer. (Je kan de originele klank, zonder FX, beluisteren door de `mix` opt naar `0`te veranderen) Speel nu met de `phase:` opt. Dit is de snelheid (in slagen) van het slicing effect. Een kleinere waarde zoals `0.125` zal sneller hakken en grotere waarden zoals `0.5` zullen trager snijden. Merk hierbij op dat het opeenvolgend halveren of verdubbelen van de `phase:`opt waarde altijd goed schijnt te klinken. Verander tenslotte de `wave:` opt naar 0,1 of 2 en hoor hoe dit de klank veranderd. Dit zijn de verschillende golfvormen. 0 is een zaagtand-golf, (harde aanslag, fade-out) 1 is een blokgolf (harde aanslag, geen fade-out) en 2 is een driehoeksgolf (fade-in, fade 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...
nl: Laten we tenslotte terug in de tijd gaan en de vroege drum&bass scene van Bristol bezoeken, met het voorbeeld van de maand. Maak je geen zorgen als je echt niet weet over wat dit gaat, type deze even, klik op Afspelen, begin te live code-en, door de getallen van de opt te veranderen en kijk wat je dit oplevert. Deel alsjeblieft wat je hebt gemaakt! Tot Volgende keer...

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.
nl: Of het nu spokende onstuimige, grommende oscillatoren zijn of de ontstemde aanslag van zaagtand-golven die door de mix klieven, de lead synth zal altijd een essentiële rol spelen in een elektronisch nummer. In de editie van vorige maand in deze serie zelf-studies   zagen we hoe je je beats code maakt. In deze tutorial gaan we zien hoe we de code doen van drie hoofd componenten van een synth riff: het timbre, de melodie en het ritme.

en: OK, so power up your Raspberry Pi, crack open Sonic Pi v2.6+ and let's make some noise!
nl: Ok, zet je Raspberry Pi op, maak Sonic Pi v2.6+ open en maak wat lawaai!

en: Timbral Possibilities
nl: Timbrale mogelijkheden

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...
nl: Een essentieel onderdeel van zowat elke synth riff ligt in het veranderen en bespelen van het timbre. We kunnen het timbre in Sonic Pi op twee verschillende manieren controllen: veranderen van synth voor een drastische verandering en de verschillende synth opts gebruiken voor een meer subtiele aanpak. We kunnen ook FX gebruiken, maar dat is voor een andere tutorial...

en: Let's create a simple live loop where we continually change the current synth:
nl: We creëren een eenvoudige loop waar we de huidige synth voortdurend gaan veranderen:

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.
nl: Kijk even naar de code. We tikken gewoon door een ring van synth namen (deze zal de lijst helemaal doorlopen en aan het einde opnieuw beginnen). We geven deze synth naam door aan de `use_synth` fn (functie) die de `live_loop`'s huidige synth verandert. We spelen ook de noot `:e2` (E van het tweede octaaf), met een release tijd van 0.5 tel (een halve seconde aan de standaard BPM van 60) en met een `cutoff:`opt naar 100 gezet.

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.
nl: Hoor hoe de verschillende synths zeer grote verschillen vertonen hoewel ze dezelfde noot spelen. Experimenteer nu en speel hiermee. Verander de release tijden naar grotere en kleinere waarden. Verander bijvoorbeeld de `attack:` en `release:` opts om te zien hoe verschillende cutoff waarden een invloed hebben op het timbre (waarden tussen 60 en 130 zijn goed) Kijk hoeveel verschillende klanken je kan creëren door simpelweg enkele waarden aan te passen. Eens je dit onder de knie hebt, ga dan naar de  synths tab in het hulpsysteem voor de lijst van alle synths en de voor iedere individuele synth beschikbare opts, om te zien hoeveel kracht je hiermee onder je codende vingers hebt.

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.
nl: Timbre of klankkleur is enkel een moeilijk woord om de klank van een geluid te beschrijven. Als je dezelfde noot speelt met verschillende instrumenten zoals viool, gitaar of piano zal de toonhoogte altijd dezelfde zijn, maar de klankeigenschap zal anders zijn. Deze eigenschap die het mogelijk maakt om het verschil tussen een piano en een gitaar waar te nemen is het timbre.

en: Melodic Composition
nl: Melodische Compositie

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:
nl: Een ander belangrijk aspect dat onze lead synth is de keuze van de noten die wij willen spelen. Als je al een goed idee hebt, dan kan je gewoon een ring met jouw noten :

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.
nl: Hier hebben de melodie gedefinieerd met een ring die beide noten `:e3` en de rust ´:r bevat. We gebruiken dan `.tick` om door elke noot te lopen, om zo een herhalende riff te krijgen.

en: Auto Melody
nl: Auto 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:
nl: Het is niet altijd gemakkelijk om met een mooie riff voor de dag te komen. In plaats daarvan is het vaak makkelijker Sonic Pi  te vragen naar een selectie van willekeurig riff's en waaruit je dan kan kiezen ,welke jou het beste bevalt. Om dit te kunnen gaan doen, moeten we drie zaken combineren: ringen, randomiseren en random seeds. Laten we eens kijken naar een voorbeeld:

en: There's a few things going on - let's look at them in turn. First, we specify that we're using random seed 3. What does this mean? Well, the useful thing is that when we set the seed, we can predict what the next random value is going to be - it's the same as it was last time we set the seed to 3! Another useful thing to know is that shuffling a ring of notes works in the same way. In the example above we're essentially asking for the 'third shuffle' in the standard list of shuffles - which is also the same every time as we're always setting the random seed to the same value right before the shuffle. Finally we're just ticking through our shuffled notes to play the riff.
nl: Een aantal zaken gebeuren hier, laat ons deze even afzonderlijk bekijken. Eerst specifiëren we dat we random seed 3 gebruiken. Wat betekent dit? Wel het nuttige hieraan is dat wanneer we de seed instellen, we ook kunnen voorspellen wat de volgende willekeurige waarde zal zijn, namelijk dezelfde als de laatste keer dat we de seed op 3 hadden ingesteld! Goed om weten is ook, dat een shuffle van kring van noten, op dezelfde manier werkt. In het bovenstaande voorbeeld vragen we eigenlijk de 'derde shuffle' in de standaard lijst van shuffles op, die steeds ook dezelfde is, gezien we de random seed  instellen op de zelfde waarde vlak voor de shuffle. Ten slotte tikken we met `.tick` door de ge-shuffle-de noten, om onze riff af te spelen.

en: Now, here's where the fun starts. If we change the random seed value to another number, say 3000, we get an entirely different shuffling of the notes. So now it's extremely easy to explore new melodies. Simply choose the list of notes we want to shuffle (scales are a great starting point) and then choose the seed we want to shuffle with. If we don't like the melody, just change one of those two things and try again. Repeat until you like what you hear!
nl: En nu wordt het leuk. Als we de waarde van de random seed veranderen  naar bvb. 3000, krijgen we een geheel nieuwe shuffle van noten. Het is nu wel extreem makkelijk om nieuwe melodieën te gaan ontdekken. Kies simpelweg de lijst van de noten die je wil verschuiven met shuffle ( toonladders zijn hierbij een mooi uitgangspunt) en kies dan de seed waarmee je de shuffle wil doen. Als de melodie jou niet bevalt, verander dan één van deze twee dingen en probeer opnieuw. Herhaal dit tot je iets tegenkomt dat je wel graag hoort!

en: Pseudo Randomisation
nl: Pseudo randomiseren

en: Sonic Pi's randomisation is not actually random it's what's called pseudo random. Imagine if you were to roll a dice 100 times and write down the result of each roll onto a piece of paper. Sonic Pi has the equivalent of this list of results which it uses when you ask for a random value. Instead of rolling an actual dice, it just picks the next value from the list. Setting the random seed is just jumping to a specific point in that list.
nl: Sonic Pi's randomiseren is niet echt willekeurig (random) en is daarom pseudo random. Stel je voor je een dobbelsteen 100 keer zou opgooien en het resultaat van elke opgooi op een stuk papier zou moeten noteren. Sonic Pi heeft het equivalent van deze resultatenlijst, die zij dan gebruikt, wanneer je om een willekeurige waarde vraagt. In plaats van werkelijke dobbelstenen, pakt het gewoon de volgende waarde uit de lijst. Het instellen van random seed, is gewoon het springen naar een bepaald punt in die lijst.

en: Finding your Rhythm
nl: Jouw Ritme Vinden

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:
nl: Nog een belangrijk element van onze riff is het ritme, wanneer een noot spelen en wanneer niet. Zoals we hierboven al zagen, kunnen we `:r` in onze ringen gebruiken, om een rusttijd in te zetten. Nog een andere, krachtige, manier is het gebruik maken van spreads, wat we in een toekomstige leeroefening gaan bekijken. Vandaag zullen we gebruik maken van randomiseren, om ons te helpen, ons ritme te vinden. In plaats van elke noot te spelen kunnen we een voorwaardelijke gebruiken, om een noot te spelen met een gegeven waarschijnlijkheid. Laat ons eens een kijkje nemen:

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.
nl: Een heel nuttige functie om te onthouden is `one_in`, welke ons een `true` of `false` waarde geeft met een bepaalde waarschijnlijkheid. Hier gebruiken we een waarde van 2, die gemiddeld één keer per twee oproepen naar `one_in`, `true zal weergeven. Door hogere waarden te gebruiken kunnen we `false` meer weergegeven laten worden, waardoor we meer ruimte in de riff kunnen creëren.

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.
nl: Merk op dat we hier een iteratie  met `16.times` hebben toegevoegd. Dit doen we alleen omdat we onze random seed waarde om de 16 noten willen resetten, zodat ons ritme elke 16 keer herhaalt. Dit beïnvloed de shuffle niet, vermits deze direct achter de seed staat. We kunnen de grootte van de iteratie wijzigen om, om de lengte van de riff te veranderen. Probeer 16 naar 8 te veranderen of zelfs aar 4 of 3 en zie hoe dit de lengte van de riff beïnvloed.

en: OK, so let's combine everything we've learned together into one final example. See you next time!
nl: Ok, laat ons nu alles wat we geleerd hebben in een laatste voorbeeld combineren. Tot volgende keer!

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.
nl: Als we naar de geschiedenis van  elektronische dansmuziek kijken, kunnen we niet naast de enorme impact van de kleine Roland TB-303 synthesizer kijken Het is het geheime recept van het originele acid bass geluid.

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.
nl: Interessant om weten is ook dat Roland de TB-303 niet voor dancemuziek heeft ontwikkeld. Het werd oorspronkelijk gemaakt als ondersteuning voor gitaristen bij het oefenen. Ze stelden zich voor dat men bas-lijnen ging programmeren om dan samen met de gitaar te gaan jammen.  Helaas waren er een aantal problemen: ze waren een beetje onhandig om te programmeren, niet bijzonder goed als vervanging van een bas-gitaar geluid en vrij duur om te kopen. Het sloeg niet aan en om verlies te vermijden werd er beslist met de productie te stoppen na 10.000 exemplaren. Al snel vonden ze hun weg naar de etalage van de tweedehands winkels. De afgedankte TB-303's lagen nu te wachten om ontdekt  te worden door een nieuwe generatie die hen op een manier zou gaan gebruiken die Roland niet voor ogen had. Acid house was geboren.

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:
nl: Vermits het in handen krijgen van een originele TB-303 niet eenvoudig is, zal u blij zijn te horen dat je jouw Raspberry Pi makkelijk kan omtoveren tot een TB-303 met de kracht van Sonic Pi. Ziehier, start Sonic Pi,  gooi de code in een lege buffer, en druk op afspelen:

en: Instant acid bass! Let's play around...
nl: Acid Bass in een oogwenk! We gaan hier mee spelen...

en: Squelch that Bass
nl: Smak die Bas

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:
nl: Laten we eerst een arpeggiator maken om de zaken leuk te houden. In de laatste tutorial hebben gezien hoe riffs gewoonweg een ring van noten kunnen zijn waar we, de ene na de andere doorheen "tikken", en zich gaan herhalen eens ze aan het einde van de cyclus zijn gekomen. Laten we een live loop maken die dat doet:

en: Take a look at each line.
nl: Laten we naar elke regel een kijkje nemen.

en: On the first line we set the default synth to be `tb303` with the `use_synth` fn.
nl: Op de eerste regel zetten we de standaard synth als 'tb303' met de 'use_synth' fn.

en: On line two we create a live loop called `:squelch` which will just loop round and round.
nl: Op regel twee creëren we een live loop genaamd ': squelch' die in een lus loopt.

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.
nl: In regel drie creëren we onze riff, een ring van noten (E in de octaven 1, 2 en 3) die we simpelweg met `.tick` gaan "tikken". We definiëren `n` om de huidige noot in de riff te vertegenwoordigen. Het gelijkheidsteken betekent dat de waarde rechts, aan de naam links wordt verwezen. Deze zal in elke loop cyclus anders zijn. In de eerste loop zal `n` naar `:e1` gezet worden. In de tweede loop cyclus zal dit `:e3`zijn gevolgd door `:e3`, en dan terug naar `:e1`, om zo voor altijd zijn cyclus te herhalen.

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.
nl: Regel vier is waar we onze `:tb303` synth activeren. En we passeren aan deze een aantal interessante opts:  `release:`, `cutoff:`, `res:` and `wave:` dewelke we hieronder gaan bespreken.

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.
nl: Regel vijf is onze ´sleep´' - we vragen de live loop elke ' 0,125` of 8 keer per seconde op de standaard BPM van 60 te gaan loop-en.

en: Line six is the `end` to the live loop. This just tells Sonic Pi where the end of the live loop is.
nl: Regel 6 is het einde van de live loop. Deze vertelt aan Sonic Pi waar het einde van de live loop is.

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.
nl: Terwijl je nog steeds uitzoekt wat er gaande is, typt u de bovenstaande code in en druk op de knop afspelen. Je zou nu de `:tb303` in actie moeten horen schieten. Nu, hier begint de pret: laten we beginnen live-coderen.

en: Whilst the loop is still live, change the `cutoff:` opt to `110`. Now hit the Run button again. You should hear the sound become a little harsher and more squelchy. Dial in `120` and hit run. Now `130`. Listen how higher cutoff values make it sound more piercing and intense. Finally, drop it down to `80` when you feel like a rest. Then repeat as many times as you want. Don't worry, I'll still be here...
nl: Terwijl de loop afspeelt, verander je de `cutoff:` opt naar `110`. Klik nu opnieuw op de Afspeel knop. Je zou het geluid nu harder en rauwer moeten horen afspelen. Verander deze nu op `120` en klik op Afspelen. Nu `130`en hoor het geluid intenser en meer snijdend worden. Ga tenslotte terug naar `80` wanneer het jou  ter druk wordt. Herhaal dit zoveel je wil. Geen nood, ik zal hier nog wel zijn :) ...

en: Another opt worth playing with is `res:`. This controls the level of resonance of the filter. A high resonance is characteristic of acid bass sounds. We currently have our `res:` set to `0.8`. Try cranking it up to `0.85`, then `0.9`, and finally `0.95`. You might find that a cutoff such as `110` or higher will make the differences easier to hear. Finally go crazy and dial in `0.999` for some insane sounds. At a `res` this high, you're hearing the cutoff filter resonate so much it starts to make sounds of its own!
nl: Een andere opt die de moeite waard is, is `res`. Deze bedient het niveau van de resonantie van de filter. Een hoge resonantie is een typisch kenmerk van de Acid Bass geluiden. Ons huidig niveau is `0.8`. Draai deze omhoog naar `0.85`, dan `0.9` en tenslotte naar `0.95`. Je zult hierdoor merken dat met een cutoff van `110`, de verschillen makkelijker hoorbaar zullen zijn. Doe tenslotte maar eens goed gek, door ´0999´ te gebruiken, voor een krankzinnig geluid. Aan zo een hoge `res` zal de cutoff filter zo hard resoneren dat deze zelf gaat oscilleren, en zo zelf een geluidsbron wordt!

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.
nl: Tenslotte veranderen we de golfvorm met de ´wave:´ opt naar `1`. Dit is de keuzeschakelaar van de oscillator. Standaard is deze `0`, deze is de zaagtand geluidsgolf (sawtooth wave).`1`is de pulsgolf (pulse wave) en `2`is de triangelgolf (triangle wave).

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.
nl: Je kan natuurlijk ook andere riffs gebruiken door de noten te veranderen in de ringen of zelfs noten te plukken uit toonladders en akkoorden. Veel plezier met je eerste Acid Bass synth.

en: Deconstructing the TB-303
nl: De TB-303 deconstrueren

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.
nl: Het ontwerp van de oorspronkelijke TB-303 is eigenlijk vrij eenvoudig. Zoals je in het volgende diagram ziet, zijn er maar 4 belangrijke kerndelen.

en: First is the oscillator wave - the raw ingredients of the sound. In this case we have a square wave. Next there's the oscillator's amplitude envelope which controls the amp of the square wave through time. These are accessed in Sonic Pi by the `attack:`, `decay:`, `sustain:` and `release:` opts along with their level counterparts. For more information read Section 2.4 'Duration with Envelopes' in the built-in tutorial. We then pass our enveloped square wave through a resonant low pass filter. This chops off the higher frequencies as well as having that nice resonance effect. Now this is where the fun starts. The cutoff value of this filter is also controlled by its own envelope! This means we have amazing control over the timbre of the sound by playing with both of these envelopes. Let's take a look:
nl: Ten eerste is de wave oscillator - de grondstoffen van het geluid. In dit geval hebben we een blokgolf. Vervolgens is er de amplitude envelop van de oscillator, die de amplitude van de blokgolf door de tijd bedient. Deze zijn toegankelijk in Sonic Pi door de `attack:`, `decay:`, `sustain:` and `release:` opts  vergezeld door het niveau hiervan. Lees voor meer informatie de sectie 2.4 'Duurtijd met enveloppen' in de ingebouwde handleiding. Vervolgens sturen we deze blokgolf met zijn envelop door een resonant low-pass filter. Dit dit snijdt in de hogere frequenties en heeft dat mooi resonantie-effect. Hier begint de pret. De grenswaarde van deze filter wordt ook gecontroleerd door eigen envelop! Dit betekent dat we een geweldige controle hebben over de klankkleur van het geluid door te spelen met beide van deze enveloppen. Laten we dit eens bekijken:

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`.
nl: Voor elke standaard envelop opt, is er een 'cutoff_' gelijkwaardige opt-in de ': tb303' synth. Dus, om het tijdsverloop van de attack van de cutoff kunnen we de ' cutoff_attack:' opt gebruiken . Kopieer de code hierboven in een lege buffer en druk op Afspelen. Je hoort een gek geluidje  in en uit kwelen. Begin hiermee te spelen te spelen. Probeer de ' cutoff_attack:' tijd naar te `1` te brengen en vervolgens naar `0.5`.  Probeer daarna `8`.

en: Notice that I've passed everything through a `:reverb` FX for extra atmosphere - try other FX to see what works!
nl: Merk ook op dat ik alles door een   `:reverb` FX heb gestuurd voor een extra sfeer, probeer zeker een ander FX uit en zie of dit werkt!

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...
nl: Tenslotte nog een stuk dat ik gecomponeerd heb met de ideeën van deze tutorial. kopieer deze in een lege buffer, luister er even naar en   verander de parameters in een live coding. Kijk welke krankzinnige geluiden je ermee kan maken! Tot volgende keer...

en: A.6 Musical Minecraft
nl: A.6 Muzikale Minecraft

en: Musical Minecraft
nl: Muzikale 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:
nl: Hallo en welkom terug! In de vorige tutorials heb we gericht puur op de mogelijkheden rond muziek in Sonic Pi - ( Je  Raspberry Pi in een  muziekinstrument veranderen). Tot nu toe hebben we geleerd geleerd hoe te:

en: Live Code - changing the sounds on-the-fly,
nl: Live Code - ter plekke wijzigen van het geluid,

en: Code some huge beats,
nl: Geweldige Beats coderen,

en: Generate powerful synth leads,
nl: Krachtige synth leads, genereren

en: Re-create the famous TB-303 acid-bass sound.
nl: De bekende TB-303 recreëren.

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.
nl: Er is zoveel meer om te laten zien (die we in toekomstige versies zullen onderzoeken). Echter, deze maand, gaan we eens kijken wat je met Sonic Pi kunt doen en je waarschijnlijk niet weet: controle hebben  over Minecraft.

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.
nl: We gaan aan de slag. Start je  Raspberry Pi, alsook Minecraft Pi en creëer een nieuwe wereld. Start Sonic Pi nu op en schik de vensters van deze programma's, zodat je zowel Sonic Pi als Minecraft Pi gelijkertijd kan zien.

en: In a fresh buffer type the following:
nl: In een nieuwe buffer typ je dan het volgende:

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!
nl: Klik nu op afspelen. En Bam! Jouw bericht verschijnt nu in Minecraft! Was dat niet makkelijk? Speel hier nu mee met je eigen berichten. Veel plezier ermee!

en: Now let's do some exploring. The standard option is to reach for the mouse and keyboard and start walking around. That works, but it's pretty slow and boring. It would be far better if we had some sort of teleport machine. Well, thanks to Sonic Pi, we have one. Try this:
nl: Nu gaan we op verkenning. De standaard optie is werken met de muis en het klavier en beginnen rondlopen. Dat werkt wel, maar het is behoorlijk traag en saai. Het zou veel beter zijn moesten we een soort teleportatie machine hebben. Wel, dankzij Sonic Pi, hebben we  dat ook. Probeer deze:

en: Crikey! That was a long way up. If you weren't in flying-mode then you would have fallen back down all the way to the ground. If you double-tap space to enter flying-mode and teleport again, you'll stay hovering at the location you zap to.
nl: Jeetje! Dat duurde even.  Als je niet in de vliegende-modus zou zijn, was je die afstand helemaal naar beneden gevallen. Als je space twee keer aanslaat om in vliegmodus te gaan en opnieuw te teleporteren, blijf je zweven op de plaats waar je naartoe zapte.

en: Now, what do those numbers mean? We have three numbers which describe the coordinates of where in the world we want to go. We give each number a name - x, y and z:
nl: Nu, wat betekenen deze cijfers ? We hebben drie getallen die de coördinaten beschrijven, waar in de wereld we willen naartoe gaan . We geven elk nummer een naam - x-, y- en z:

en: x - how far left and right (80 in our example)
nl: x - hoe ver links en rechts (80 in ons voorbeeld)

en: y - how high we want to be (40 in our example)
nl: y - hoe hoog we willen zijn (40 in ons voorbeeld)

en: z - how far forward and back (100 in our example)
nl: z - hoe ver voorwaarts of achterwaarts (100 in ons voorbeeld)

en: By choosing different values for x, y and z we can teleport *anywhere* in our world. Try it! Choose different numbers and see where you can end up. If the screen goes black it's because you've teleported yourself under the ground or into a mountain. Just choose a higher y value to get back out above land. Keep on exploring until you find somewhere you like...
nl: Door verschillende waarden te kiezen voor x, y en z kunnen we "overal" in de onze wereld teleporteren. Probeer maar! Kies hierbij verschillende getallen en kijk waar je terechtkomt. Wanneer je scherm zwart wordt betekent dit dat je jezelf onder de grond of in een berg hebt geteleporteerd. Kies dan gewoon een een hoger getal voor y om terug op land te komen. Ga door tot je op een leuke plek terecht gekomen bent...

en: Using the ideas so far, let's build a Sonic Teleporter which makes a fun teleport sound whilst it whizzes us across the Minecraft world:
nl: Met behulp van de tot nu toe aangereikte ideeën, gaan we nu een Sonic Teleporter die een leuk teleportatie geluid maakt als door de Minecraft wereld zoeven:

en: Magic Blocks
nl: Magische blokken

en: Now you've found a nice spot, let's start building. You could do what you're used to and start clicking the mouse furiously to place blocks under the cursor. Or you could use the magic of Sonic Pi. Try this:
nl: Nu je een leuke plek gevonden hebt, gaan we beginnen bouwen. Je kan nu zoals je gewoonlijk doet verwoed gaan klikken om blokken onder de cursor te plaatsen. Of je kan de magie van Sonic Pi gebruiken. Probeer dit:

en: Now look up! There's a melon in the sky! Take a moment to look at the code. What did we do? On line one we grabbed the current location of Steve as the variables x, y and z. These correspond to our coordinates described above. We use these coordinates in the fn `mc_set_block` which will place the block of your choosing at the specified coordinates. In order to make something higher up in the sky we just need to increase the y value which is why we add 5 to it. Let's make a long trail of them:
nl: Kijk omhoog! Er hangt een meloen in de lucht! Neem even de tijd om naar de code te kijken. Wat hebben we hier gedaan? Op lijn één namen we de huidige locatie van Steve als de variabelen x, y en z. Deze komen overeen met onze coördinaten hierboven beschreven. Wij gebruik deze coördinaten in de fn 'mc_set_block', die de blok van uw keuze zal plaatsen op de opgegeven coördinaten.Als we deze nu omhoog willen plaatsen, moeten we de waarde van y verhogen,dat is ook de reden waarom we er 5 aan hebben toegevoegd. Laten we hiervan een lang spoor maken:

en: Now, jump over to Minecraft, make sure you're in flying-mode (double tap space if not) and fly all around the world. Look behind you to see a pretty trail of melon blocks! See what kind of twisty patterns you can make in the sky.
nl: Nu, spring nu naar Minecraft, zorg ervoor dat je in de vliegende-modus bent (2 keer spatie indien niet) en vlieg over de hele wereld. Kijk achter je om  een mooi parcours van meloen blokken te zien! Kijk wat voor gedraaide patronen je in de lucht kan maken.

en: Live Coding Minecraft
nl: Minecraft Live Coderen

en: Those of you that have been following this tutorial over the last few months will probably have your minds blown at this point. The trail of melons is pretty cool, but the most exciting part of the previous example is that you can use `live_loop` with Minecraft! For those that don't know, `live_loop` is Sonic Pi's special magic ability that no other programming language has. It lets you run multiple loops at the same time and allows you to change them whilst they run. They are incredibly powerful and amazing fun. I use `live_loop`s to perform music in nightclubs with Sonic Pi - DJs use discs and I use `live_loop`s :-) However, today we're going to live code both music and Minecraft.
nl: Wie in de laatste maanden de zelfstudie (tutorials) heeft gevolgd zal nu wel behoorlijk onder de indruk zijn. Het spoor van meloenen is dan ook cool, maar het strafste deel van het voorgaande voorbeeld is dat je `live_loop` kan gebruiken met Minecraft! Als je `live_loop` niet kent, het is Sonic Pi's magische eigenschap die geen enkele andere programmeertaal heeft. Het staat je toe verschillende "loops" tezelfdertijd af te spelen, en deze tezelfdertijd ook aan te passen terwijl zij afspelen. Ze zijn heel krachtig en leuk. Ik gebruik `live_loop` om live muziek te spelen in nachtclubs met Sonic Pi. Dj's gebruiken disc's en ik gebruik  `live_loop`s :-) Maar vandaag gaan we zowel muziek als Minecraft live coderen.

en: Let's get started. Run the code above and start making your melon trail again. Now, without stopping the code, just simply change `:melon` to `:brick` and hit run. Hey presto, you're now making a brick trail. How simple was that! Fancy some music to go with it? Easy. Try this:
nl: Laten we beginnen. Voer de bovenstaande code in en begin weer met het maken van uw meloen parcours . Nu, zonderde code  te stoppen , wijzigen `:melon` naar `:brick en klik afspelen. En hupsaké, je maakt nu een parcours van baksteen. Hoe eenvoudig was dat! Zetten we er wat muziek bij? Ook gemakkelijk. Probeer dit:

en: Now, whilst that's playing start changing the code. Change the block types - try `:water`, `:grass` or your favourite block type. Also, try changing the cutoff value from `70` to `80` and then up to `100`. Isn't this fun?
nl: Nu, verander de code terwijl dit afspeelt. Verander de blok type's - probeer `:water`, `:grass` of jouw favoriete blok type uit. Probeer ook de waarde van de cutoff te wijzigen van `70`naar `80`en nog hoger tot `100`. Leuk niet?

en: Let's combine everything we've seen so far with a little extra magic. Let's combine our teleportation ability with block placing and music to make a Minecraft Music Video. Don't worry if you don't understand it all, just type it in and have a play by changing some of the values whilst it's running live. Have fun and see you next time...
nl: Laten ons nu alles wat we tot hiertoe hebben gezien combineren, met nog een extra vleugje magie. En we combineren onze teleportatie met het blok plaatsen en met de muziek om tot een Minecraft Muziek Videoclip te komen. Wees niet bezorgd dat je niet alles begrijpt, typ het in en speel ermee door sommige waarden te veranderen terwijl het live afspeelt. Veel plezier en tot een volgende keer...

en: After our brief excursion to the fantastic world of coding Minecraft with Sonic Pi last month, let's get musical again. Today we're going to bring a classical operatic dance piece straight into the 21st century using the awesome power of code.
nl: Na onze korte excursie vorige maand, naar de fantastische wereld van het coderen van Minecraft met Sonic Pi , gaan we opnieuw de muzikale toer op. Vandaag gaan we een klassieke opera dansstuk rechtstreeks naar de 21ste eeuw katapulteren met behulp van de ongelofelijke krachtt van code.

en: Outrageous and Disruptive
nl: Schandalig en Disruptief

en: Let's jump into a time machine back to the year 1875. A composer called Bizet had just finished his latest opera Carmen. Unfortunately like many exciting and disruptive new pieces of music people initially didn't like it at all because it was too outrageous and different. Sadly Bizet died ten years before the opera gained huge international success and became one of the most famous and frequently performed operas of all time. In sympathy with this tragedy let's take one of the main themes from Carmen and convert it to a modern format of music that is also too outrageous and different for most people in our time - live coded music!
nl: Laten we door de teletijdmachine terugkeren naar het jaar 1875. Een componist Bizet genaamd heeft net zijn laatste opera Carmen afgewerkt. Zoals het helaas dikwijls gaat met vernieuwende muziek ,sloeg het bij het publiek niet aan wegens te verschillend en te uitbundig. Helaas stierf Bizet 10 jaar voordat deze opera een internationaal succes werd en één van de meest beroemde en gespeelde opera's aller tijden werd. Uit sympathie voor deze tragedie gaan we één van de hoofdthema's van Carmen in een moderne muziekstijl gieten die voor de meeste mensen in deze tijd ook te "anders" is: live gecodeerde muziek!

en: Decoding the Habanera
nl: De Habanera decoderen

en: Trying to live code the whole opera would be a bit of a challenge for this tutorial, so let's focus on one of the most famous parts - the bass line to the Habanera:
nl: Om deze volledige opera zou in deze oefening een te grote uitdaging zijn, laten we daarom ons op één van de meest beroemde delen focussen- de baslijn van de Habanera:

en: This may look extremely unreadable to you if you haven't yet studied music notation. However, as programmers we see music notation as just another form of code - only it represents instructions to a musician instead of a computer. We therefore need to figure out a way of decoding it.
nl: Dit kan uiterst onleesbaar lijken als je geen muziek hebt gestudeerd .Als programmeurs kunnen wij muzieknotatie zien als gewoon een andere vorm van code.Hiermee geeft u instructies aan een musicus in plaats van een computer. Daarom moeten wij een manier bedenken om het te decoderen.

en: Notes
nl: Noten

en: The notes are arranged from left to right like the words in this magazine but also have different heights. *The height on the score represents the pitch of the note.* The higher the note on the score, the higher the pitch of the note.
nl: De noten zijn van links naar rechts gerangschikt zoals de woorden op uw scherm,maar hebben ook verschillende plaatsing  in hoogte.* De hoogte in de partituur geeft de toonhoogte weer.* Hoe hoger de noot in de partituur staat, hoe hoger de noot klinkt.

en: In Sonic Pi we already know how to change the pitch of a note - we either use high or low numbers such as `play 75` and `play 80` or we use the note names: `play :E` and `play :F`. Luckily each of the vertical positions of the musical score represents a specific note name. Take a look at this handy look up table:
nl: Hoe we in Sonic Pi de toonhoogte van noten moeten veranderen, weten we al - ofwel gebruiken we getallen zoals `play 75` en `play 80` of we gebruiken de naam van de noot: `play :E` en`play :F`. Gelukkig vertegenwoordigt elk van de verticale posities van de partituur de naam van een specifieke noot. Neem een kijkje naar deze handige opzoek tabel:

en: Rests
nl: Rusttijden

en: Music scores are an extremely rich and expressive kind of code capable of communicating many things. It therefore shouldn't come as much of a surprise that musical scores can not only tell you what notes to play but also when *not* to play notes. In programming this is pretty much equivalent to the idea of `nil` or `null` - the absence of a value. In other words not playing a note is like the absence of a note.
nl: Partituren zijn een zeer rijke en expressieve soort code waarmee je verschillende uiteenlopende zaken kan communiceren.Het zal dan ook niet verbazen dat partituren jou niet alleen vertellen welke noten je moet spelen, maar ook waar je *geen* noten mag spelen. In het programmeren is dat te vertalen naar het idee van `nil` of `null` - de afwezigheid van een waarde. Met andere woorden, een noot niet spelen is zoals een noot die afwezig is.

en: If you look closely at the score you'll see that it's actually a combination of black dots with lines which represent notes to play and squiggly things which represent the rests. Luckily Sonic Pi has a very handy representation for a rest: `:r`, so if we run: `play :r` it actually plays silence! We could also write `play :rest`, `play nil` or `play false` which are all equivalent ways of representing rests.
nl: Als je de partituur aandachtig bekijkt zal je zien dat  deze een combinatie van zwarte punten met lijnen bevat de de te spelen noten vertegenwoordigen, en kronkelende dingen die de rusttijden vertegenwoordigen. Gelukkig heeft Sonic Pi een handige manier om een rusttijd aan te geven: `:r`, dus als we `play :r` afspelen, speelt deze eigenlijk stilte af! We kunnen ook `play :rest` schrijven, `play nil` of `play false` die allemaal evengoed een rusttijd vertegenwoordigen.

en: Rhythm
nl: Ritme

en: Finally, there's one last thing to learn how to decode in the notation - the timings of the notes. In the original notation you'll see that the notes are connected with thick lines called beams. The second note has two of these beams which means it lasts for a 16th of a beat. The other notes have a single beam which means they last for an 8th of a beat. The rest has two squiggly beams which means it also represents a 16th of the beat.
nl: Tenslotte nog een laatste manier om de noten te ontcijferen: de timing van de noten. In de originele partituur zal je zien dat de noten verbonden zijn met dikke lijnen die men waardestrepen noemt. De tweede noot heeft twee lijnen in deze waardestreep wat betekent dat deze noot een zestiende van een tel aanhoudt.De andere noten hebben een enkel waardestreepje, wat wil zeggen dat deze een 8-ste van een tel aanhouden. De rest heeft twee krullige lijnen, vlagjes, die willen zeggen dat deze ook een 16-de van een tel zijn.

en: When we attempt to decode and explore new things a very handy trick is to make everything as similar as possible to try and see any relationships or patterns. For example, when we re-write our notation purely in 16ths you can see that our notation just turns into a nice sequence of notes and rests.
nl: Als we trachten nieuwe zaken te ontcijferen, is het handig om alles eenvormig te maken om zo patronen en verbanden te kunnen zien. Bijvoorbeeld, als we onze notenschrift in louter zestiende noten zouden herschrijven, kan je zien dat ons notenschrift verandert in een opeenvolging van noten en rusttijden.

en: Re-coding the Habanera
nl: De Habanera Hercoderen

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:
nl: We staan nu op het punt om te beginnen met het vertalen van deze baslijn naar Sonic Pi. Laten we deze noten en rusttijden in een ring coderen:

en: Let's see what this sounds like. Throw it in a live loop and tick through it:
nl: Laten we eens kijken hoe dit klinkt. Gooi het in een live loop en "tick" erdoor heen:

en: Fabulous, that instantly recognisable riff springs to life through your speakers. It took a lot of effort to get here, but it was worth it - high five!
nl: Fantastisch, die herkenbare riff komt door jouw luidsprekers meteen  tot leven. Het kostte veel moeite om hier te komen, maar het was het waard - high five!

en: Now we have the bass line, let's re-create some of the ambience of the operatic scene. One synth to try out is `:blade` which is a moody 80s style synth lead. Let's try it with the starting note `:d` passed through a slicer and reverb:
nl: Nu we de baslijn hebben, gaan we de sfeer van de opera recreëren. Een synth om uit te proberen is `:blade` welke een stemmige, jaren 80 stijl, synth lead is. We proberen deze met de beginnoot `:d`en laten deze door een slicer en een reverb passeren:

en: Now, try the other notes in the bass line: `:a` and `:f5`. Remember, you don't need to hit stop, just modify the code whilst the music is playing and hit run again. Also, try different values for the slicer's `phase:` opt such as `0.5`, `0.75` and `1`.
nl: Probeer nu de andere noten in de baslijn: `:a`en `:f5`. Denk eraan, je hoeft niet op stop te drukken, je hoeft enkel de code te veranderen terwijl de muziek afspeelt en op afspelen de drukken. Probeer ook verschillende waarden uit voor de  `phase:` opt van de slicer uit zoals `0.5`, `0.75`en  `1`.

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.
nl: Ten slotte combineren we alle ideeën die we tot dusver hebben gezien in een nieuwe remix van De Habanera. Je zal opmerken dat ik een ander deel van de baslijn in een commentaarlijn heb gestoken. Eens je alles in een nieuwe buffer hebt getypt, druk je op afspelen om de compositie te horen. Nu, zonder op stop te drukken ga je de tweede regel *uitcommentariëren*  door de # te verwijderen en opnieuw op afspelen te drukken, - hoe prachtig is dat!. Probeer zelf nog het een en ander en veel plezier ermee.

en: A.8 Become a Minecraft VJ
nl: A.8 Word een Minecraft VJ

en: Become a Minecraft VJ
nl: Word een Minecraft VJ

en: Everyone has played Minecraft. You will all have built amazing structures, designed cunning traps and even created elaborate cart lines controlled by redstone switches. How many of you have performed with Minecraft? We bet you didn't know that you could use Minecraft to create amazing visuals just like a professional VJ.
nl: Iedereen heeft ooit Minecraft gespeeld. Je zal allemaal verbazingwekkende structuren gebouwd hebben, sluwe vallen ontworpen hebben en zelfs cart lines hebben uitgewerkt met hun bijbehorende redstone schakelaars. Hoeveel van jullie hebben al een optreden gedaan met Minecraft? Wedden dat je niet wist dat je Minecraft kunt gebruiken om ongelofelijke beelden af te spelen net zoals een professionele VJ dat doet.

en: If your only way of modifying Minecraft was with the mouse, you'd have a tough time changing things fast enough. Luckily for you your Raspberry Pi comes with a version of Minecraft that can be controlled with code. It also comes with an app called Sonic Pi which makes coding Minecraft not only easy but also incredibly fun.
nl: Als de muis de enige manier was om Minecraft te modificeren, had je het waarschijnlijk moeilijk om de dingen vlug genoeg veranderd te krijgen. Gelukkig komt jouw Raspberry Pi met een versie van Minecraft dat met behulp van code kan gecontrolt worden. Er is ook een app bij die Sonic Pi heet, die Het coderen van Minecraft niet alleen makkelijk, maar ook plezierig maakt.

en: In today's article we'll be showing you some of the tips and tricks that we've used to create performances in night clubs and music venues around the world.
nl: In het artikel van vandaag gaan we jou enkele van de tips en trucjes tonen, die we hebben gebruikt bij optredens in nachtclubs en podia over de hele wereld.

en: Let's get started...
nl: Laten we starten...

en: Getting Started
nl: Starten

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:
nl: Laten we eerst een opwarmertje doen, en even terug keren naar de basis. Vooraleerst, doe je Raspberry Pi open en start zowel Minecraft als Sonic Pi op, creëer een nieuwe wereld, en kies in Sonic Pi een verse buffer en schrijf deze 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......
nl: Sla de afspelen toets aan om het bericht te zien in het Minecraft-venster.  Ok, we zijn klaar om te starten. We gaan wat pret maken...

en: Sand Storms
nl: Zandstormen

en: When we're using Minecraft to create visuals we try and think about what will both look interesting and also be easy to generate from code. One nice trick is to create a sand storm by dropping sand blocks from the sky. For that all we need are a few basic fns:
nl: Wanneer we Minecraft gebruiken om visuals mee te maken, houden we in gedachte dat we iets leuk om naar te kijken maken als zowel makkelijk uit code kunnen genereren. Een leuke truc is een zandstorm creëren door zandblokken uit de lucht te laten vallen. Daarvoor hebben we een aantal basis fns nodig:

en: `sleep` - for inserting a delay between actions
nl: `sleep` - voor het invoegen van een vertraging tussen acties

en: `mc_location` - to find our current location
nl: `mc_location` - om onze huidige lokatie te vinden

en: `mc_set_block`- to place sand blocks at a specific location
nl: `mc_set_block`- om de zandblokken op een bepaalde plaats te zetten

en: `rrand` - to allow us to generate random values within a range
nl: `rrand` - om ons toe te laten random waarden binnen een bepaald bereik te genereren

en: `live_loop` - to allow us to continually make it rain sand
nl: `live_loop` - om ons toe te laten een constante stroom aan regen te maken

en: If you're unfamiliar with any of the built-in fns such as `rrand`, just type the word into your buffer, click on it and then hit the keyboard combo `Control-i` to bring up the built-in documentation. Alternatively you can navigate to the *lang* tab in the Help system and then look up the fns directly along with all the other exciting things you can do.
nl: Als je niet vertrouwd bent met een van de ingebouwde fns zoals `rrand`, typ het woord in je buffer, klik erin en gebruik de combinatie `control-i` op je toetsenbord om de ingebouwde documentatie op te roepen. Alternatief kan je ook navigeren naar de *lang* tab in het hulpsysteem en zoek fns op, tussen al de andere leuke dingen die je kan doen.

en: Let's make it rain a little first before unleashing the full power of the storm. Grab your current location and use it to create a few sand blocks up in the sky nearby:
nl: Laat het een beetje regenen vooraleer je de zandstorm op volle kracht zet. Pluk je huidige locatie en gebruik deze om in de buurt een paar zandblokken in de lucht te plaatsen:

en: When you hit Run, you might have to look around a little as the blocks may start falling down behind you depending on which direction you're currently facing. Don't worry, if you missed them just hit Run again for another batch of sand rain - just make sure you're looking the right way!
nl: Wanneer je Afspelen aanslaat, moet je misschien een beetje rondkijken om zicht te hebben op de vallende blokken vermits hun zichtbaarheid afhangt van jouw kijkrichting. Geen nood als je hun val net gemist hebt, klik gewoon terug op Afspelen voor een nieuwe partij zandregen- zorg er gewoon voor dat je in de juiste richting kijkt!

en: Let's quickly review what's going on here. On the first line we grabbed Steve's location as coordinates with the fn `mc_location` and placed them into the vars `x`, `y`, and `z`. Then on the next lines we used the `mc_set_block` fn to place some sand at the same coordinates as Steve but with some modifications. We chose the same x coordinate, a y coordinate 20 blocks higher and then successively larger z coordinates so the sand dropped in a line away from Steve.
nl: Laten we even kijken wat hier gaan de is. In de eerste regel bemachtigde we de coördinaten van de huidige locatie van Steve via de  `mc_location` en plaatsten we deze in de variabelen `x`, `y`, en `z`. Op de volgende regels gebruikten we  `mc_set_block` fn om wat zand te plaatsen op de zelfde coördinaten als die van Steve, met wat aanpassingen. We kozen dezelfde x coördinaat , een y coördinaat 20 blokken hoger en achtereenvolgens een groter z coördinaat zodat het zand niet ver van Steve naar beneden valt.

en: Why don't you take that code and start playing around with it yourself? Try adding more lines, changing the sleep times, try mixing `:sand` with `:gravel` and choose different coordinates. Just experiment and have fun!
nl: Waarom nemen we deze code niet over om hier wat mee te gaan spelen? Probeer meer lijnregels, verander de rusttijden (sleep), probeer `:sand` met `:gravel` te mengen en gebruik verschillende coördinaten? Experimenteer maar en veel plezier ermee!

en: Live Loops Unleashed
nl: Live Loops ontketend

en: OK, it's time to get the storm raging by unleashing the full power of the `live_loop` - Sonic Pi's magical ability which unleashes the full power of live coding - changing code on-the-fly whilst it's running!
nl: Ok, tijd om een storm te laten woeden door de kracht van de `live_loop` te laten ontketenen - Sonic Pi's wonderlijke eigenschap die de kracht van het live code-en laat zien- namelijk de code wijzigen terwijl deze loopt!

en: What fun! We're looping round pretty quickly (8 times a second) and during each loop we're finding Steve's location like before but then generating 3 random values:
nl: Hoe leuk! We gaan behoorlijk snel door deze Loop (8 keer per seconde) en bij elke doorloop vinden we opnieuw de locatie van Steve om er dan 3 random waarden bij te genereren:

en: `xd` - the difference for x which will be between -10 and 10
nl: `xd` - het verschil bij x welke tussen -10 en 10 liggen

en: `zd` - the difference for z also between -10 and 10
nl: `zd` - het verschil bij z ook tussen -10 en 10

en: `co` - a cutoff value for the low pass filter between 70 and 130
nl: `co` - een cutoff waarde voor de low pass filter tussen 70 en 130

en: We then use those random values in the fns `synth` and `mc_set_block` giving us sand falling in random locations around Steve along with a percussive rain-like sound from the `:cnoise` synth.
nl: We gebruiken dan deze random waarden in de fns `synth` en `mc_set_block` die ons vallend zand geven op willekeurige plaatsen rond Steve samen met een regen-achtig geluid van de `:cnoise` synth.

en: For those of you new to live loops - this is where the fun really starts with Sonic Pi. Whilst the code is running and the sand is pouring down, try changing one of the values, perhaps the sleep time to `0.25` or the `:sand` block type to `:gravel`. Now hit run *again*. Hey Presto! Things changed without the code stopping. This is your gateway to performing like a real VJ. Keep practising and changing things around. How different can you make the visuals without stopping the code?
nl: Voor diegene voor wie  live loops nieuw zijn - hier begint de pret pas met Sonic Pi. Terwijl de code loopt en het zand naar beneden wordt uitgestrooid, tracht je één van de waarden te veranderen, misschien de rusttijd (sleep) naar `0.25` of de `:sand` block type naar `:gravel. Druk nu *opnieuw* Afspelen in. En presto veranderde de zaken die je had aangepast zonder de code te hoeven stoppen. Dit is jouw toegangspoort om als een echte VJ aan de slag te gaan. Blijf oefenen en verander hier en daar wat. Hoe verschillend kan jij de visuals maken zonder de code te stoppen?

en: Epic Block Patterns
nl: Epische blok patronen

en: ![Screensman 1](../../../etc/doc/images/tutorial/articles/A.08-minecraft-vj/minecraft-vj-1-small.png)
nl: ![Screen 1](../../../etc/doc/images/tutorial/articles/A.08-minecraft-vj/minecraft-vj-1-small.png)

en: Finally, another great way of generating interesting visuals is to generate huge patterned walls to fly towards and close by. For this effect we'll need to move from placing the blocks randomly to placing them in an ordered manner. We can do this by nesting two sets of iteration (hit the Help button and navigate to section 5.2 of the tutorial "Iteration and Loops" for more background on iteration). The funny `|xd|` after the do means that `xd` will be set for each value of the iteration. So the first time it will be 0, then 1, then 2... etc. By nesting two lots of iteration together like this we can generate all the coordinates for a square. We can then randomly choose block types from a ring of blocks for an interesting effect:
nl: Wat tenslotte ook een fantastische manier is om interessante visuals te maken is van een grote muur van een patroon te genereren om naartoe en langsheen te vliegen. Om dit effect te bereiken moeten moeten we ons van het idee van het willekeurig plaatsen van blokken verplaatsen naar deze geordend te plaatsen. We kunnen dit doen door twee sets van iteratie (druk op de hulp-knop om naar sectie 5.2 van de zelfstudie "Iteratie en loops" te navigeren voor meer achtergrondinformatie over iteraties). De gekke `|xd|` achter do betekend dat `xd` achter elke waarde van de iteratie zal worden gezet. De eerste keer zal deze 0 zijn, dan1, dan 2.....enz. Door twee delen iteratie te gaan nesten, kunnen we op deze manier de coördinaten voor een vierkant genereren. We kunnen dan willekeurig blok-types kiezen van een ring van blokken om een interessant effect te bekomen:

en: Pretty neat. Whilst we're having fun here, try changing `bs.choose` to `bs.tick` to move from a random pattern to a more regular one. Try changing the block types and the more adventurous of you might want to try sticking this within a `live_loop` so that the patterns keep changing automatically.
nl: Behoorlijk gaaf. Terwijl we hiermee plezier beleven, probeer je `bs.choose` te veranderen naar `bs.tick om van een willekeurig patroon een meer regelmatig patroon te bekomen. Probeer ook de blok-type's te veranderen en de waaghalzen onder ons willen deze misschien ook in een `live_loop` plakken om de patronen automatisch te laten veranderen.

en: Now, for the VJ finale - change the two `10.times` to `100.times` and hit Run. Kaboom! A Huge gigantic wall of randomly placed bricks. Imagine how long it would take you to build that manually with your mouse! Double-tap space to enter fly-mode and start swooping by for some great visual effects. Don't stop here though - use your imagination to conjure up some cool ideas and then use the coding power of Sonic Pi to make it real. When you've practised enough dim the lights and put on a VJ show for your friends!
nl: Nu, voor de VJ finale: verander de twee `10.times` naar `100.times` en klik op Afspelen. Kaboom! Een reusachtig en gigantische muur van willekeurig geplaatste bakstenen. Beeld je in hoe lang je daarmee bezig zou zijn geweest indien je dit met de muis zou gedaan hebben! Sla twee keer de spacebar om naar vlieg-modus over te gaan en begin aan een duikvlucht voor geweldige visuele effecten. Maar stop op dit punt nog niet, gebruik je verbeeldingsvermogen voor coole ideeën en gebruik in Sonic Pi de kracht van het coderen om deze werkelijk te maken. Wanneer je voldoende geoefend hebt, dim je de lichten en zet een VJ show voor je vrienden op!

en: A.9 Randomisation
nl: A.9 Randomiseren

en: Surfing Random Streams
nl: Surfen op  Random Streams

en: Back in episode 4 of this tutorial series we took a brief look at randomisation whilst coding up some sizzling synth riffs. Given that randomisation is such an important part of my live coding DJ sets I thought it would be useful to cover the fundamentals in much greater detail. So, get your lucky hat on and let's surf some random streams!
nl: In deel 4 van deze zelfstudie serie keken we even naar randomiseren terwijl we een aantal broeierige synth-riffs codeerden. Daar randomiseren zo'n belangrijk onderdeel van mijn live-coding DJ-sets is, dacht ik dat het zinvol was om de grondbeginselen ervan in detail te gaan bekijken. Laat ons beginnen surfen op Random Streams!

en: There is no random
nl: Er is geen random

en: The first thing to learn which might really surprise you when playing with Sonic Pi's randomisation functions is that they're not actually really random. What does this actually mean? Well, let's try a couple of tests. First, imagine a number in your head between 0 and 1. Keep it there and don't tell me. Now let me guess... was it `0.321567`? No? Bah, I'm clearly no good at this. Let me have another go, but let's ask Sonic Pi to choose a number this time. Fire up Sonic Pi v2.7+ and ask it for a random number but again don't tell me:
nl: Het eerste wat je moet weten, en wat jou misschien ook verrast, wanneer je met de randomisering functies van Sonic Pi speelt, is dat deze niet écht random zijn. Wat betekent dit? Wel laat ons een paar tests doen. Verbeeld je eerst een getal tussen 0 en1. Onthou deze en verklap deze niet aan mij. Nu laat me raden... was het `0.321567`? Nee? Goh ik ben er blijkbaar toch niet zo goed in. Geef me nog een kans maar vraag deze keer Sonic Pi een nummer te kiezen. Start Sonic Pi v2.7+ en vraag deze een random nummer te genereren, maar ook nu verklap je deze niet aan mij:

en: Now for the reveal... was it `0.75006103515625`? Yes! Ha, I can see you're a little sceptical. Perhaps it was just a lucky guess. Let's try again. Press the Run button again and see what we get... What? `0.75006103515625` again? This clearly can't be random! You're right, it's not.
nl: En dan nu de onthulling... was het `0.75006103515625`? Yes! Ha maar ik merk dat je hier een beetje sceptisch tegenover staat. Misschien was het wel een gelukstreffer. We proberen nog een keer. Druk opnieuw op Afspelen en we zien wel wat we krijgen... Wat? Opnieuw  `0.75006103515625`? Dit kan duidelijk geen random zijn! Je hebt gelijk, het is ook geen random.

en: What's going on here? The fancy computer science word here is determinism. This just means that nothing is by chance and everything is destined to be. Your version of Sonic Pi is destined to always return `0.75006103515625` in the program above. This might sound pretty useless, but let me assure you that it's one of the most powerful parts of Sonic Pi. If you stick at it you'll learn how to rely on the deterministic nature of Sonic Pi's randomisation as a fundamental building block for your compositions and live coded DJ sets.
nl: Wat gebeurt hier? Determinisme is de dure computerwetenschappelijke term die hier kan  opgaan.Het betekent gewoon dat het toeval niet bestaat en alles voorbestemd is om te worden. Uw versie van Sonic Pi is voorbestemd om altijd  `0.75006103515625` terug te geven. Dit klink misschien helemaal niet nuttig, maar ik verzeker je dat dit één van de meest krachtige delen van Sonic Pi is. Als je hier aan vasthoud zal je leren vertrouwen te schenken aan de deterministische manier van randomisering in Sonic Pi als fundamentele bouwsteen voor jouw composities en live gecodeerde DJ sets.

en: A Random Melody
nl: Een Random Melodie

en: When Sonic Pi boots it actually loads into memory a sequence of 441,000 pre-generated random values. When you call a random function such as `rand` or `rrand`, this random stream is used to generate your result. Each call to a random function consumes a value from this stream. Therefore the 10th call to a random function will use the 10th value from the stream. Also, every time you press the Run button, the stream is reset for that run. This is why I could predict the result to `rand` and why the 'random' melody was the same every time. Everybody's version of Sonic Pi uses the exact same random stream which is very important when we start sharing our pieces with each other.
nl: Wanneer Sonic Pi opstart, laad het eigenlijk een opeenvolging van 441.000 pre-geregenereerde waarden in het geheugen op. Wanneer je een random functie zoals `rand` of `rrand` oproept, wordt deze stroom van random waarden gebruikt om jouw resultaat te regenereren. Elke oproep naar een random functie verbruikt een waarde van deze stroom. Daarom zal de 10-de oproep naar zo'n random functie, de 10-de waarde van de stroom gebruiken. Iedere keer je op de Afspelen toets drukt zal de stroom voor die doorloop gereset worden. Daarom ook kon ik het resultaat van `rand` voorspellen en was de 'random' melodie ook elke keer dezelfde. Ieders versie van Sonic Pi gebruikt dezelfde random stream, wat ook belangrijk is als we elkaars code onderling gaan delen.

en: Let's use this knowledge to generate a repeatable random melody:
nl: Laten we deze kennis te gebruiken om een herhalende willekeurige melodie te genereren:

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.
nl: Typ deze in een lege buffer en klik Afspelen? Je hoort een melodie die bestaat uit 'random' noten tussen 50 en 95. Wanneer deze uitgespeeld is, klik je opnieuw op Afspelen opnieuw om exact dezelfde melodie te hoeren spelen.

en: Handy Randomisation Functions
nl: Handige randomisering Functies

en: Sonic Pi comes with a number of useful functions for working with the random stream. Here's a list of some of the most useful:
nl: Sonic Pi wordt geleverd met een aantal handige functies voor het werken met de random stream. Hier is een lijst met enkele van de meest nuttige:

en: `rand` - Simply returns the next value in the random stream
nl: `rand` - geeft gewoon de volgende waarde van de stream weer

en: `rrand` - Returns a random value within a range
nl: `rrand` - geeft een random waarde binnen een bereik weer

en: `rrand_i` - Returns a random whole number within a range
nl: `rrand_i` - Geeft een random geheel getal binnen een bereik weer

en: `one_in` - Returns true or false with the given probability
nl: `one_in` - Geeft true of false weer met de gegeven probabiliteit

en: `dice` - Imitates rolling a dice and returns a value between 1 and 6
nl: `dice` - Immiteerd het rollen van een dobbelsteen en geeft waarden tussen 1 en 6 weer

en: `choose` - Chooses a random value from a list
nl: `choose` - Kiest een willekeurige waarde uit een lijst

en: Check out their documentation in the Help system for detailed information and examples.
nl: Bekijk hun documentatie in het Help-systeem voor meer informatie en voorbeelden.

en: Resetting the Stream
nl: Resetten van de Stream

en: Whilst the ability to repeat a sequence of chosen notes is essential to allow you to replay a riff on the dance floor, it might not be exactly the riff you want. Wouldn't it be great if we could try a number of different riffs and choose the one we liked best? This is where the real magic starts.
nl: Terwijl de mogelijkheid om het  herhalen van een fragment met gekozen noten essentieel is om jouw riff te kunnen spelen op de dansvloer, is het misschien niet de riff die je wou. Zou het niet geweldig zijn moesten we een aantal verschillende riffs kunnen uitproberen om dan de beste ervan te kunnen uitkiezen? Hier gaat de toverdoos open.

en: We can manually set the stream with the fn `use_random_seed`. In Computer Science, a random seed is the starting point from which a new stream of random values can sprout out and blossom. Let's try it:
nl: We kunnen de stream met de fn 'use_random_seed' handmatig instellen. In Computerwetenschap, is random seed een startpunt waaruit een nieuwe stream van random waarden kunnen beginnen kiemen en bloeien. We proberen dit:

en: Great, we get the first three notes of our random melody above: `84`, `83` and `71`. However, we can now change the seed to something else. How about this:
nl: Geweldig, we krijgen de eerste drie noten van onze random melodie hierboven: '84', '83' en ' 71'. We kunnen de seed naar ierts anders veranderen. Laat ons zeggen deze:

en: Interesting, we get `83`, `71` and `61` . You might notice that the first two numbers here are the same as the last two numbers before - this isn't a coincidence.
nl: Interessant, we  krijgen '83', '71' en ' 61'. Je merkt hierbij misschien ook op dat de eerste twee cijfers hier, dezelfde zijn als de laatste twee in het vorige voorbeeld - dit is geen toeval.

en: Remember that the random stream is just a giant list of 'pre-rolled' values. Using a random seed simply jumps us to a point in that list. Another way of thinking about it is to imagine a huge deck of pre-shuffled cards. Using a random seed is cutting the deck at a particular point. The fabulous part of this is that it's precisely this ability to jump around the random stream which gives us huge power when making music.
nl: Vergeer niet dat de random stream gewoon een gigantisch lijst is van vooraf op een rol gezette waarden is. Random seed gebruiken is gewoon een verspringen naar een plaats in de lijst. Een andere manier om ons dit voor te stellen is te denken aan een gigantische deck van door elkaar geschudde speelkaarten. Gebruik maken van random seed is als het openklappen van deze deck op een nauwkeurig punt. Het fabuleuze gedeelte hier is dat precies de mogelijkheid om rond te springen in de random stream, dit ons een krachtig instrument geeft wanneer we muziek maken.

en: Let's revisit our random melody of 8 notes with this new stream resetting power, but let's also throw in a live loop so we can experiment live whilst it's playing:
nl: Laten we onze random melodie van 8 noten nog eens opzoeken met de kracht van die nieuwe stream resetting, maar laten we er ook een live loop in gooien zodat we ermee kunnen experimenteren terwijl de code loopt:

en: Now, whilst it's still playing, change the seed value from `0` to something else. Try `100`, what about `999`. Try your own values, experiment and play around - see which seed generates the riff you like best.
nl: Nu, terwijl deze nog speelt, verander je de seed waarde van `0`naar iets anders. Probeer `100`, en wat dacht je van `999`. Probeer ook je eigen waarden, experimenteer en speel er wat mee - en kijk welke seed  de riff regenereerde die jij het leukst vindt.

en: This month's tutorial has been quite a technical dive into the workings of Sonic Pi's randomisation functionality. Hopefully it has given you some insight into how it works and how you can start using randomisation in a reliable way to create repeatable patterns within your music. It's important to stress that you can use repeatable randomisation *anywhere* you want. For example, you can randomise the amplitude of notes, the timing of the rhythm, the amount of reverb, the current synth, the mix of an FX, etc. etc. In the future we'll take a close look at some of these applications, but for now let me leave you with a short example.
nl: De tutorial van deze maand was een behoorlijk technische duik in hoe de functionaliteit van de randomisatie in Sonic Pi werkt.Hopelijk gaf het jou wat inzicht hoe dit in z'n werk  gaat en hoe je deze op een vertrouwde manier kan gaan gebruiken om repeteerbare patronen in jouw muziekstukken te creëren. Het is belangrijk je erop te wijzen dat je repeteerbare randomisatie *overal* je maar wil kan gebruiken. Je kan bijvoorbeeld de amplitude van noten randomiseren, de maat van het ritme, de hoeveelheid galm (reverb), de synth die je gebruikt, de mix van de FX, enz. enz. In de toekomst gaan we uitgebreid kijken naar sommige van die toepassingen, maar momenteel geef jou nog even dit voorbeeld.

en: Type the following into a spare buffer, hit Run, and then start changing the seeds around, hit Run again (whilst it's still playing) and explore the different sounds, rhythms and melodies you can make. When you find a nice one, remember the seed number so you can get back to it. Finally, when you've found a few seeds you like, put on a live coded performance for your friends by simply switching between your favourite seeds to create a full piece.
nl: Typ het volgende in een lege buffer, toets Afspelen, en begin dan links en rechts de seeds te veranderen, duw opnieuw op Afspelen (terwijl het nog speelt) en onderzoek welke verschillende geluiden, ritmes en melodieën die je kan maken. Wanneer je iets lekkers gevonden hebt, probeer dan het seed getal te onthouden, zodat je die later opnieuw kan gebruiken. Als je tenslotte een aantal leuke seeds gevonden hebt, nu kan je voor je vrienden een live coded optreden geven door gewoon te switchen tussen jouw favoriete seeds om een compleet muziekstuk te creëren.

en: Controlling Your Sound
nl: Jouw Geluid Controllen

en: So far during this series we've focussed on triggering sounds. We've discovered that we can trigger the many synths built into Sonic Pi with `play` or `synth` and how to trigger pre-recorded samples with `sample`. We've also looked at how we can wrap these triggered sounds within studio FX such as reverb and distortion using the `with_fx` command. Combine this with Sonic Pi's incredibly accurate timing system and you can produce a vast array of sounds, beats and riffs. However, once you've carefully selected a particular sound's options and triggered it, there's no ability to mess with it whilst it's playing right? Wrong! Today you're going to learn something very powerful - how to control running synths.
nl: Tot zover hebben we in deze serie de focus gelegd op het triggeren van geluiden. We hebben geleerd dat we de, in Sonic Pi, ingebouwde synth's met `play` of `synth` kunnen triggeren en vooraf opgenomen samples triggeren met `sample`. We hebben ook geleerd hoe we deze getriggerde klanken in een studio FX kunnen steken door middel van het `with_fx` commando. Combineer deze met het ongelofelijk nauwkeurige timing systeem van Sonic Pi en je kan een breed scala klanken,beats en riff's produceren. Maar zodra je een zorgvuldig geselecteerde klank opties hebt uitgekozen en deze hebt getriggerd, is er geen mogelijkheid om deze klank te veranderen terwijl deze speelt, juist? Neen hoor! Vandaag gaan we iets machtig leren, hoe een lopende synth controllen.

en: A Basic Sound
nl: Een Basis Klank

en: Let's create a nice simple sound. Fire up Sonic Pi and in a fresh buffer type the following:
nl: Laat ons even een leuke eenvoudige klank maken. Start Sonic Pi en typ in een nieuwe buffer het volgende:

en: Now press the Run button at the top left to hear a lovely rumbling synth sound. Go ahead, press it again a few times to get a feel for it. OK, done? Let's start controlling it!
nl: Druk nu op de Afspeel-knop bovenaan links om dan een een mooie rommelend synth-geluid te mogen horen. Doe dit nog maar een paar keer om het in de vingers te krijgen en druk op Afspelen. Ok, klaar? Nu beginnen we het te controllen!

en: A little known feature in Sonic Pi is that the fns `play`, `synth` and `sample`, return something called a `SynthNode` which represents a running sound. You can capture one of these `SynthNode`s using a standard variable and then **control** it at a later point in time. For example, let's change the value of the `cutoff:` opt after 1 beat:
nl: Een weinig bekende functie in Sonic Pi is dat de fns `play`, `synth` en `sample`, een zogenaamde `SynthNode` opgeven, die een lopende klank vertegenwoordigd. Je kan zo'n `SynthNode` vastleggen door een standaard variabele te gebruiken en deze later te gaan **controllen**. We kunnen bijvoorbeeld de waarde van de `cutoff:` opt na 1 tel veranderen:

en: Let's look at each line in turn:
nl: Laten we de verschillende regels op zijn beurt even bekijken:

en: Firstly we trigger the `:prophet` synth using the `synth` fn as normal. However we also capture the result in a variable called `sn`. We could have called this variable something completely different such as `synth_node` or `jane` - the name doesn't matter. However, it's important to choose a name that's meaningful to you for your performances and for people reading your code. I chose `sn` as it's a nice short mnemonic for synth node.
nl: Ten eerste triggeren we de `:prophet` synth door de `synth` fn zoals gewoonlijk te gebruiken. We spelen het resultaat aan een variabele door genaamd `sn`. We zouden deze variabele ook een totaal andere naam hebben kunnen geven zoals `synth_node` of `kevin` , de naam speelt geen rol. Het is wel belangrijk dat deze voor jou een betekenis heeft als je een performance geeft en voor de mensen die jouw code lezen. Ik koos nu voor `sn` omdat dit een mooi geheugensteuntje is naar synth node.

en: On line 2 we have a standard `sleep` command. This does nothing special - it just asks the computer to wait for 1 beat before moving onto the next line.
nl: Op regel 2 hebben we het standaard `sleep` commando. Het doet niks bijzonders, het vraagt de computer enkel om één tel te wachten alvorens verder te gaan naar de volgende regel.

en: Line 3 is where the control fun starts. Here, we use the `control` fn to tell our running `SynthNode` to change the cutoff value to `130`. If you hit the **Run** button, you'll hear the `:prophet` synth start playing as before, but after 1 beat it will shift to sound a lot brighter.
nl: Op regel 3 begint de pret met control. Hier gebruiken we de `control` fn, om onze lopende `synth_node` te vertellen, de cutoff waarde naar `130` te veranderen. Als je **Afspelen** klikt, hoor je de`:prophet` synth zoals daarvoor, maar na 1 tel zal deze verschuiven naar een meer heldere klank .

en: Modulatable Options
nl: Moduleerbare Opties

en: Most of Sonic Pi's synths and FX opts may be changed after being triggered. However, this isn't the case for all of them. For example, the envelope opts `attack:`, `decay:`, `sustain:` and `release:` can only be set when triggering the synth. Figuring out which opts can and can't be changed is simple - just head to the documentation for a given synth or FX and then scroll down to the individual option documentation and look for the phrases "May be changed whilst playing" or "Can not be changed once set". For example, the documentation for the `:beep` synth's `attack:` opt makes it clear that it's not possible to change it:
nl: De meeste van Sonic Pi's synths en FX opts kunnen veranderd worden nadat ze getriggerd zijn. Dit is echter niet voor allen het geval. Bijvoorbeeld, de envelop opts  `attack:`, `decay:`, `sustain:` and `release:` kunnen alleen ingestelt worden bij bij het triggeren van de synth. Uitzoeken welke opts wel en welke niet kunnen veranderd worden is heel makkelijk, ga gewoon naar de documentatie voor de gegeven synth of FX en scroll naar beneden naar de afzonderlijke beschrijving van de opties.In de onderste regel vind je dan “Kan veranderd worden tijdens het afspelen” of “Kan niet veranderd worden eens ingesteld”. De documentatie voor de `:beep` synth maakt duidelijk dat het niet mogelijk is de `attack:` opt te veranderen eens ingesteld:

en: Default: 0
nl: Standaard instelling: 0

en: Must be zero or greater
nl: Moet nul of groter dan nul zijn

en: Can not be changed once set
nl: Kan niet worden aangepast eens ingesteld

en: Scaled with current BPM value
nl: Geschaald met huidige BPM waarde

en: Multiple Changes
nl: Meerdere veranderingen

en: Whilst a synth is running you're not limited to changing it only once - you're free to change it as many times as you like. For example, we can turn our `:prophet` into a mini arpeggiator with the following:
nl: Als een synth eenmaal loopt ben je niet beperkt tot slechts 1 verandering - je kunt veranderingen blijven doen zoveel je wilt. bijvoorbeeld, we kunnen onze ':prophet' veranderen in een generator van een reeks accoordtonen (dat is een arpeggio, arpeggio generator =arpeggiator) door het volgende te doen:

en: In this snippet of code we just added a couple of extra things. First we defined a new variable called `notes` which contains the notes we'd like to cycle through (an arpeggiator is just a fancy name for something that cycles through a list of notes in order). Secondly we replaced our single call to `control` with an iteration calling it 16 times. In each call to `control` we `.tick` through our ring of `notes` which will automatically repeat once we get to the end (thanks to the fabulous power of Sonic Pi's rings). For a bit of variety try replacing `.tick` with `.choose` and see if you can hear the difference.
nl: In dit stukje code kunnen we een aantal extra zaken toevoegen. Ten eerste hebben we een nieuwe variabele, genaamd `notes`, gedefinieerd, die de noten bevat die we graag willen doorlopen (een arpeggiator is gewoon een chique naam voor datgene waarin een lijst van noten in een volgorde wordt doorlopen) Ten tweede hebben we onze éénmalige oproep naar `control`, vervangen door een iteratie om deze 16 keer aan te roepen. In elke oproep naar `control`, hebben we een `:tick` -en we door onze ring van `notes`, die automatisch herhaald worden eens we aan het einde ervan gekomen zijn (dankzij de sublieme kracht van Sonic Pi's rings) Voor wat variatie probeer je `.tick` door `.choose` te vervangen, en bekijk of je hier een verschil kan horen.

en: Note that we can change multiple opts simultaneously. Try changing the control line to the following and listen for the difference:
nl: Merk op dat we meerdere opts tegelijk kunnen veranderen. Probeer de control regel naar het volgende te wijzigen en hoor nu het verschil:

en: Sliding
nl: Sliden

en: When we control a `SynthNode`, it responds exactly on time and instantly changes the value of the opt to the new one as if you'd pressed a button or flicked a switch requesting the change. This can sound rhythmical and percussive - especially if the opt controls an aspect of the timbre such as `cutoff:`. However, sometimes you don't want the change to happen instantaneously. Instead, you might want to smoothly move from the current value to the new one as if you'd moved a slider or dial. Of course, Sonic Pi can also do this too using the `_slide:` opts.
nl: Wanneer we een `SynthNode` controllen, reageert die precies op tijd vanuit de waarde van de opt naar de nieuwe waarde, alsof je een knop indrukte, of een schakelaar aanzette om de verandering aan te brengen. Dit kan ritmisch en percussief klinken, zeker als de opt een aspect van de klankkleur bepaalt zoals de `cutoff:`. Maar soms wil je helemaal niet dat de verandering in een knip gebeurd, maar dat deze langzaam aan overgaat van de huidige waarde naar de nieuwe waarde, alsof je langzaam een schuifregelaar bewoog. Natuurlijk kan Sonic Pi dit ook, door gebruik te maken van de  `_slide:` opts.

en: Each opt that can be modified also has a special corresponding `_slide:` opt that allows you to specify a slide time. For example, `amp:` has `amp_slide:` and `cutoff:` has `cutoff_slide:`. These slide opts work slightly differently than all the other opts in that they tell the synth note how to behave **next time they are controlled**. Let's take a look:
nl: Elke opt die gewijzigd kan worden heeft een overeenkomstige `_slide:` opt  waarmee je de slide tijd mee kan instellen. Bijvoorbeeld, `amp:` heeft `amp_slide:` en `cutoff:` heeft `cutoff_slide:`. Deze slide opts werken een beetje anders dan de andere opts, doordat zij de synth noot opdraagt, hoe deze zich moeten gaan gedragen **de volgende keer dat ze gecontrold wordt**. Laten we hier even naar kijken:

en: Notice how this example is exactly the same as before except with the addition of `cutoff_slide:`. This is saying that next time this synth has its `cutoff:` opt controlled, it will take 2 beats to slide from the current value to the new one. Therefore, when we use `control` you can hear the cutoff slide from 70 to 130. It creates an interesting dynamic feel to the sound. Now, try changing the `cutoff_slide:` time to a shorter value such as 0.5 or a longer value such as 4 to see how it changes the sound. Remember, you can slide any of the modifiable opts in exactly this way and each `_slide:` value can be totally different so you can have the cutoff sliding slowly, the amp sliding fast and the pan sliding somewhere in between if that's what you're looking to create...
nl: Merk hierbij op dat we hetzelfde voorbeeld genomen hebben, maar hier hebben we `cutoff_slide:` toegevoegd. Dit betekent dat de volgende keer; de `cutoff:` opt wordt gecontrolt. Het neemt 2 beats (tellen) in beslag om te sliden vanuit de huidige waarde naar de nieuwe waarde. Daardoor hoor je, wanneer we `control` gebruiken, de cutoff sliden van 70 naar 130. Het creëert een interessante dynamiek in het geluid. Probeer nu de `cutoff_slide:` tiid  te veranderen naar een kortere waarde zoals 0.5 en door een langere waarde zoals 4 om te zien hoe dit de klank verandert. Denk eraan, je kan elke modificeerbare opt op deze manier sliden, en elke `_slide:` waarde mag helemaal anders zijn. Zo kan de cutoff langzaam sliden, de amp snel sliden en de pan daar ergens tussenin sliden, zoals jij dit wil …

en: Let's look at a short example which demonstrates the power of controlling synths after they've been triggered. Notice that you can also slide FX just like synths although with a slightly different syntax. Check out section 7.2 of the built-in tutorial for more information on controlling FX.
nl: Laat ons naar een korter voorbeeld kijken dat ons de kracht toont van het controllen van synths nadat ze getriggerd zijn. Merk hierbij op dat ook FX zoals synths kan sliden maar met een iets andere syntax. Bekijk hoofdstuk 7.2 van de ingebouwde handleiding voor meer informatie omtrent het controllen van FX .

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!
nl: Kopieer de code naar een overgebleven buffer en luister hier naar. Stop niet en speel een beetje met de code. Verander de slide tijd, verander de noten, de synth, de rusttijd (sleep) en zorg dat je deze kan veranderen tot iets compleet anders!

en: A.11 Tick Tock
nl: A.11 Tik Tok

en: Tracking the Beat
nl: De maat houden

en: Last month in this series we took a deep technical dive into the randomisation system underpinning Sonic Pi. We explored how we can use it to deterministically add new levels of dynamic control over our code. This month we're going to continue our technical dive and turn our attention to Sonic Pi's unique tick system. By the end of this article you'll be ticking your way through rhythms and riffs on your way to being a live coding DJ.
nl: Vorige maand hebben we in deze serie een diepe duik genomen in het randomiseer systeem dat Sonic Pi ondersteund. We gingen na hoe we dit kunnen gebruiken om op deterministische wijze, nieuwe lagen van dynamische controle op onze code, uit te oefenen.

en: Beat Counting
nl: De beat tellen

en: When making music we often want to do a different thing depending on which beat it is. Sonic Pi has a special beat counting system called `tick` to give you precise control over when a beat actually occurs and even supports multiple beats with their own tempos.
nl: Wanneer we muziek maken willen we soms dingen gaan doen die afhangen van het tempo en de beat. Sonic Pi heeft een speciaal systeem dat de beat telt, genaamd  `tick`, om je de precieze controle te geven  over wanneer een beat daadwerkelijk optreedt en zelfs meerdere beats met hun eigen tempo ondersteunt.

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:
nl: We spelen hier nu even mee, om de beats te laten toenemen hoeven we gewoon `tick` aan te roepen. Open een lege buffer, typ het volgende en druk op Afspelen:

en: This will return the current beat: `0`. Notice that even if you press the Run button a few times it will always return `0`. This is because each run starts a fresh beat counting from 0. However, whilst the run is still active, we can advance the beat as many times as we want:
nl: Dit geeft je de huidige beat: `0`. Merk op dat zelfs wanneer je de Afspeel-knop herhaaldelijk indrukt, altijd `0` zal weergegeven worden. Dat komt omdat bij elke afspeel-commando het tellen van de beat van 0 start. We kunnen echter wanneer het afspelen nog actief is, de beat omhoog laten gaan, zoveel maal we zelf willen:

en: Whenever you see the symbol `#=>` at the end of a line of code it means that that line will log the text on the right-hand-side. For example, `puts foo #=> 0` means the code `puts foo` prints `0` to the log at that point in the program.
nl: Telkens je het symbool `l#=>`  aan het einde van een regel code ziet, betekend dit dat deze regel de tekst logt in het logvenster rechts. Bijvoorbeeld `puts eenderwat #=> 0 betekent dat de code `puts eenderwat `0`zal uitprinten naar het log op het moment dat dit in het programma voorkomt.

en: Checking the Beat
nl: De beat nagaan

en: We've seen that `tick` does two things. It increments (adds one) and returns the current beat. Sometimes we just want to look at the current beat without having to increment it which we can do via `look`:
nl: We hebben gezien dat `tick` twee dingen doet. Het verhoogt (voegt toe) en geeft als resultaat de huidige beat. Soms willen we gewoon kijken naar de huidige beat zonder deze te verhogen. Dat kunnen we doen met `look`:

en: In this code we tick the beat up twice and then call `look` twice. We'll see the following values in the log: `0`, `1`, `1`, `1`. The first two `tick`s returned `0`, then `1` as expected, then the two `look`s just returned the last beat value twice which was `1`.
nl: In deze code tick-en we de beat twee keer en roepen we `look` twee maal op. We zien de volgende waarden het log verschijnen: `0`, `1`, `1`, `1`. De eerste twee `tick`s gaven `0`en `1` zoals verwacht weer. daarna gaven de twee `look`s de laatste waarde van de beat weer, die `1`was.

en: So now we can advance the beat with `tick` and check the beat with `look`. What next? We need something to tick over. Sonic Pi uses rings for representing riffs, melodies and rhythms and the tick system has been specifically designed to work very closely with them. In fact, rings have their own dot version of `tick` which does two things. Firstly, it acts like a regular tick and increments the beat. Secondly it looks up the ring value using the beat as the index. Let's take a look:
nl: Nu kunnen we dus de beat verhogen door middel van `tick`en deze nagaan door `look`. Maar wat nu? We hebben nog iets nodig om te laten tick-en. Sonic Pi gebruikt ringen om riffs, melodieën en ritmes te vertegenwoordigen, en het tick systeem is speciaal ontwikkeld om nauw met hen samen te werken. In feite hebben ringen hun eigen dot versie van `tick`,die  twee dingen doet. Ten eerste functioneert deze als een gewone tick en verhoogt ook de beat.Ten tweede zoekt die de waarde van de ring op waarbij de beat als index wordt gebruikt. Laten we hier even naar kijken:

en: `.tick` is a special dot version of `tick` which will return the first value of the ring `:a`. We can grab each of the values in the ring by calling `.tick` multiple times:
nl: `.tick` 'is een speciale dot versie van 'tik', die de eerste waarde van de ring geeft `:a`. We kunnen elke waarden in de ring oppikken door `.tick` meerdere keren op te roepen:

en: Take a look at the log and you'll see `:a`, `:b`, `:c` and then `:a` again. Notice that `look` returns `3`. Calls to `.tick` act just like they are regular calls to `tick` - they increment the local beat.
nl: Neem nu een kijkje in het log en je zal `:a`, `:b`, `:c` zien en dan `:a` opnieuw. Merk op dat `look` `3` weergeeft. Een oproep naar `.tick` zal handelen als een gewone oproep naar `tick`, zij verhogen de beat hier.

en: A Live Loop Arpeggiator
nl: Een Live Loop Arpeggiator

en: The real power comes when you mix `tick` with rings and `live_loop`s. When combined we have all the tools we need to both build and understand a simple arpegiator. We need just four things:
nl: De sterke kant hiervan komt naar boven als je `tick` mixt met `ring` en `live_loops`s. Wanneer zij gecombineerd worden, hebben we ons gereedschap om een eenvoudige arpegiator te bouwen,en om deze te begrijpen. We hebben maar vier dingen nodig:

en: A ring containing the notes we want to loop over.
nl: Een ring die de te doorlopen noten bevat.

en: A means of incrementing and obtaining the beat.
nl: Een middel om de beat te verkrijgen en te verhogen.

en: The ability to play a note based on the current beat.
nl: De mogelijkheid om een noot te spelen volgens de huidige beat.

en: A loop structure to keep the arpegiator repeating.
nl: Een loop structuur waarin de arpegiator zich herhaalt.

en: These concepts can all be found in the following code:
nl: Deze concepten vind je in de volgende code terug:

en: Let's look at each of these lines. First we define our ring of notes which we'll continually play. We then create a `live_loop` called `:arp` which loops round for us. Each time round the `live_loop` we set our synth to `:dpulse` and then play the next note in our ring using `.tick`. Remember that this will increment our beat counter and use the latest beat value as an index into our notes ring. Finally, we wait for an eighth of a beat before looping round again.
nl: Laten we een kijkje nemen naar elke regels. Ten eerste definiëren we onze ring noten, die we continue laten afspelen. Dan maken we onze `live_loop` die `arp` heet, en die voor ons de loop doet. Elke cyclus van de `live_loop` stellen we onze synth in op `:dpulse´, om vervolgens de volgende noot in onze ring te spelen met behulp van `;tick`. Denk eraan dat dit onze beat-teller zal verhogen en onze laatste beat waarde zal gaan gebruiken als index in onze noten ring. Tenslotte, wachten we één achtste van een tel alvorens opnieuw te gaan  loop-en.

en: Multiple Simultaneous Beats
nl: Meerdere simultane beats

en: A really important thing to know is that `tick`s are local to the `live_loop`. This means that each `live_loop` has its own independent beat counter. This is much more powerful than having a global metronome and beat. Let's take a look at this in action:
nl: Belangrijk om weten is, is dat `tick` lokaal werkt tegenover `live_loop`. Dit betekent dat elke `live_loop` z'n eigen individuele beat-teller heeft. Dit is krachtiger dan het hebben van een globale metronoom en beat. Laten we dit in actie zien:

en: Clashing Beats
nl: Botsende Beats

en: A big cause of confusion with Sonic Pi's tick system is when people want to tick over multiple rings in the same `live_loop`:
nl: Een grote oorzaak van verwarring met het tick systeem van Sonic Pi is wanneer men meerdere ringen willen tick-en in de zelfde `live_loop`:

en: Even though each `live_loop` has its own independent beat counter, we're calling `.tick` twice within the same `live_loop`. This means that the beat will be incremented twice every time round. This can produce some interesting polyrhythms but is often not what you want. There are two solutions to this problem. One option is to manually call `tick` at the start of the `live_loop` and then use `.look` to look up the current beat in each `live_loop`. The second solution is to pass a unique name to each call to `.tick` such as `.tick(:foo)`. Sonic Pi will then create and track a separate beat counter for each named tick you use. That way you can work with as many beats as you need! See the section on named ticks in 9.4 of the built-in tutorial for more information.
nl: Hoewel elke 'live_loop' zijn eigen onafhankelijke beat teller heeft, roepen we `.tick` twee keer op binnen dezelfde `live_loop`.  Dit betekent dat de beat twee keer wordt verhoogd bij elke cyclus die doorlopen wordt. Op die manier kunnen interessante poly-ritmes ontstaan, maar dikwijls wil je dit ook helemaal niet. Je kan dit op twee manieren oplossen. De ene oplossing is een manuele oproep naar `tick` aan de start van de `live_loop` om dan `.look` te gebruiken om de huidige beat in in elk van de `live_loop`'s op te zoeken. De tweede oplossing is elke  `.tick` een unieke naam te geven zoals bvb `.tick(:naam1)`. Sonic Pi zal dan een aparte beat-teller maken en gebruiken voor elke, door jou benoemde `.tick`. Hiermee kan je zoveel verschillende beats werken als je maar wil! Zie sectie 9.4 over benoemde tick's in de ingebouwde handleiding voor meer informatie.

en: Let's bring all this knowledge of `tick`s, `ring`s and `live_loop`s together for a final fun example. As usual, don't treat this as a finished piece. Start changing things and play around with it and see what you can turn it into. See you next time...
nl: Laat ons de opgestoken kennis over  `tick`s, `ring`s en `live_loop`s samenvoegen in een leuk voorbeeld. En ook deze keer mag je dit voorbeeld ook niet als een afgewerkt stuk zien. Verander hier en daar de waarden, en ontdek zo wat je er kan uitkrijgen. Tot volgende keer…

en: A.12 Sample Slicing
nl: A.12 Sample Snijden

en: Sample Slicing
nl: Het snijden van een sample

en: Way back in episode 3 of this Sonic Pi series we looked at how to loop, stretch and filter one of the most famous drum breaks of all time - the Amen Break. In this tutorial we're going to take this one step further and learn how to slice it up, shuffle the slices and glue it back together in a completely new order. If that sounds a bit crazy to you, don't worry, it will all become clear and you'll soon master a powerful new tool for your live coded sets.
nl: Een hele tijd terug in aflevering 3 van deze Sonic Pi serie, keken we hoe we één van de meest bekende drum breaks aller tijden  konden loop-en, stretchen en filteren: de Amen Break. In deze tutorial gaan we nog een stapje verder en gaan we zien hoe we de sample kunnen opknippen, de stukken door elkaar te schudden en deze in een andere volgorde weer aan elkaar te lijmen. Misschien klinkt dit allemaal wat raar nu, maar maak je geen zorgen, het zal je snel allemaal duidelijk worden, en je zal deze techniek snel meester zijn en deze in de toekomst gebruiken in je live gecode set .

en: Sound as Data
nl: Geluid als data

en: Before we get started let's just take a brief moment to understand how to work with samples. By now, you've all hopefully played with Sonic Pi's powerful sampler. If not, there's no time like the present! Boot up your Raspberry Pi, launch Sonic Pi from the Programming menu, type the following into a fresh buffer and then hit the Run button to hear a pre-recorded drum beat:
nl: Voor we eraan beginnen, kijken we even hoe we het gebruik van sample's beter kunnen begrijpen. Ondertussen hebben jullie hopelijk al gespeeld met de krachtige sampler van Sonic Pi. Indien niet, start Raspberry Pi, laad Sonic Pi op, en typ het volgende in een lege buffer om de drum-sample te kunnen horen:

en: A recording of a sound is simply represented as data - lots of numbers between -1 and 1 which represent the peaks and troughs of the sound wave. If we play those numbers back in order, we get the original sound. However, what's to stop us from playing them back in a different order and creating a new sound?
nl: Een opgenomen geluid wordt simpelweg uitgedrukt in data, veel nummers tussen -1 en 1 zijn dat die de pieken en dalen van een geluidsgolf vertegenwoordigen. Als we deze cijfers in volgorde kunnen reproduceren, krijgen we het originele geluid terug. Maar wat houdt ons tegen om deze in een andere volgorde te gaan afspelen en hierbij een nieuw geluid te creëren?

en: How are samples actually recorded? It's actually pretty simple once you understand the basic physics of sound. When you make a sound - for example by hitting a drum, the noise travels through the air in a similar fashion to how the surface of a lake ripples when you throw a pebble into it. When those ripples reach your ears, your eardrum moves sympathetically and converts those movements into the sound you hear. If we wish to record and play back the sound, we therefore need a way of capturing, storing and reproducing those ripples. One way is to use a microphone which acts like an eardrum and moves back and forth as the sound ripples hit it. The microphone then converts its position into a tiny electric signal which is then measured many times a second. These measurements are then represented as a series of numbers between -1 and 1.
nl: Hoe zijn samples eigenlijk opgenomen? Dat  is eigenlijk vrij eenvoudig als u eenmaal de fundamentele fysica van geluid begrijpt. Bij het produceren van een klank,bijvoorbeeld door op een trommel te slaan, reist het geluid door de lucht,op een zelfde manier het wateroppervlak rimpels maakt als je er een steentje in gooit. Als deze golven jouw oren bereiken, zal jouw trommelvlies hierop reageren en zullen deze bewegingen omgezet worden naar de klank die jij dan hoort. Als we een geluid willen opnemen en terug willen afspelen moeten we deze geluidsgolven capteren, opslaan en reproduceren. We kunnen dit bijvoorbeeld met een microfoon, die net als een trommelvlies reageert en heen en weer zal bewegen zodra een geluidsgolf het membraan raakt. De microfoon registreert deze beweging en zet deze om tot een minuscuul elektrisch signaal dat op zijn beurt vele malen per seconde wordt gemeten.Deze metingen worden dan weergegeven als een reeks getallen tussen -1 en 1.

en: If we were to plot a visualisation of the sound it would be a simple graph of data with time on the x axis and microphone/speaker position as a value between -1 and 1 on the y axis. You can see an example of such a graph at the top of the diagram.
nl: Als we geluid zouden visualiseren zou deze een simpele grafiek zijn van datagegevens met tijdsverloop op de x-as en de bewegingen van de microfoon/luidspreker met waarden tussen -1 en 1 op de y-as. Je kan, bovenaan het diagram, een voorbeeld van zo'n grafiek zien.

en: Playing Part of a Sample
nl: Een deel van een sample afspelen

en: So, how do we code Sonic Pi to play a sample back in a different order? To answer this question we need to take a look at the `start:` and `finish:` opts for `sample`. These let us control the start and finish positions of our playback of the numbers which represent the sound. The values for both of these opts are represented as a number between `0` and `1` where `0` represents the start of the sample and `1` is the end. So, to play the first half of the Amen Break, we just need to specify a `finish:` of `0.5`:
nl: Dus, hoe kunnen we dan Sonic Pi zo coderen dat deze een sample in een andere volgorde afspeelt? Om een antwoord op deze vraag te kunnen geven moeten we een kijkje nemen naar de `start:` en`finish:` opts voor `sample`. Deze laten ons toe de start en eindposities voor de weergave van een sample te bepalen. De waarden voor deze opts liggen tussen  `0` en`1` waarbij `0` staat voor de de start van de sample en `1` het einde ervan is. Dus als we de eerste helft van de Amen Break willen spelen moeten we de  `finish:` zetten op `0.5`:

en: We can add in a `start:` value to play an even smaller section of the sample:
nl: We kunnen ook een `start:` toevoegen om een nog kleiner stukje van de sample te kunnen spelen:

en: For fun, you can even have the `finish:` opt's value be *before* `start:` and it will play the section backwards:
nl: Voor de lol kunnen we de waarde van `finish:` laten vallen *vòòr* de waarde van `start:` om de selectie achterstevoren te laten afspelen:

en: Re-ordering Sample Playback
nl: Het afspelen van een sample herordenen

en: Now that we know that a sample is simply a list of numbers that can be played back in any order and also how to play a specific part of a sample we can now start having fun playing a sample back in the 'wrong' order.
nl: Nu we weten dat een sample een simpele lijst is van getallen, die we in eender welke volgorde kunnen laten afspelen en we ook weten hoe we een bepaald deel van de sample kunnen afspelen, kunnen we na aan de slag gaan en een sample in de verkeerde volgorde gooien en afspelen.

en: Let's take our Amen Break and chop it up into 8 equally-sized slices and then shuffle the pieces around. Take a look at the diagram: at the top A) represents the graph of our original sample data. Chopping it into 8 slices gives us B) - notice that we've given each slice a different colour to help distinguish them. You can see each slice's start and finish values at the top. Finally C) is one possible re-ordering of the slices. We can then play this back to create a new beat. Take a look at the code to do this:
nl: Laten we onze Amen break nemen en deze in 8 gelijke stukken verdelen en de stukken verschuiven. Kijk even op het diagram: bovenaan A) geeft de grafiek van onze originele sample weer. In 8 stukjes geknipt geeft ons B) , merk op dat we elk stukje een andere kleur hebben gegeven om deze te kunnen onderscheiden. Je ziet bovenaan de waarde van start en einde ,van elk stukje. En tenslotte is  C) een mogelijke herordening van de stukjes. Deze kunnen we als een nieuwe beat afspelen. Laten we even deze code bekijken om dit te gaan doen:

en: we choose a random slice to play which should be a random number between 0 and 7 (remember that we start counting at 0). Sonic Pi has a handy function for exactly this: `rand_i(8)`. We then store this random slice index in the variable `slice_idx`.
nl: We kiezen een willekeurige segment om af te spelen welke een willekeurig getal tussen 0 en 7 is (voor de 8 stukken, we tellen vanaf 0!) Hiervoor heeft Sonic Pi een handige functie: `rand_i(8)`. Vervolgens bewaren we deze willekeurige segment-index in de variabele `slice_idx`.

en: We define our `slice_size` which is 1/8 or 0.125. The `slice_size` is necessary for us to convert our `slice_idx` into a value between 0 and 1 so we can use it as our `start:` opt.
nl: Definiëren we onze `slice_size` die 1/8 is of 0,125 is. De `slice_size` is noodzakelijk om  onze 'slice_idx' te converteren naar een waarde tussen 0 en 1 zodat we deze kunnen gebruiken als onze `start:` opt.

en: We calculate the start position `s` by multiplying the `slice_idx` by the `slice_size`.
nl: We berekenen de beginpositie ' door de 'slice_idx' met 'slice_size' te vermenigvuldigen .

en: We calculate the finish position `f` by adding the `slice_size` to the start position `s`.
nl: We berekenen de eind-positie `f` door de ´slice_size` aan de startpositie `s` toe te voegen.

en: We can now play the sample slice by plugging in the `s` and `f` values into the `start:` and `finish:` opts for `sample`.
nl: We kunnen nu deze sample-slice afspelen door de waarden van `s`en `f`, in de `start:` en `finish:` opts voor `sample` te steken.

en: Before we play the next slice we need to know how long to `sleep` which should be the duration of the sample slice. Luckily, Sonic Pi has us covered with `sample_duration` which accepts all the same opts as `sample` and simply returns the duration. Therefore, by passing `sample_duration` our `start:` and `finish:` opts, we can find out the duration of a single slice.
nl: Voordat we het volgende segment spelen moeten we weten hoe lang de `sleep` is welke de duurtijd is van ons sample segment. Gelukkig heeft  Sonic Pi ons voorzien van `sample_duration` welke dezelfde opts heeft als `sample`en ons zijn duurtijd kan weergeven. Dus, door het passeren van `sample_duration` aan onze `start:` en  `finish:`  kennen we de duur van elke slice.

en: We wrap all of this code in a `live_loop` so that we continue to pick new random slices to play.
nl: We steken deze code in een `live_loop` zodat we verder nieuwe random slices kunnen uitpikken.

en: Let's combine everything we've seen so far into a final example which demonstrates how we can take a similar approach to combine randomly sliced beats with some bass to create the start of an interesting track. Now it's your turn - take the code below as a starting point and see if you can take it in your own direction and create something new...
nl: Laten we alles wat we tot nu toe hebben gezien, met de zelfde aanpak in een laatste voorbeeld combineren, dat demonstreert hoe opgeknipte beats met wat bass het begin van een interessante track kunnen maken . Nu is het jouw beurt - om de onderstaande code als uitgangspunt te nemen en te zien of je deze een eigen twist kan geven om er weer iets helemaal anders van te maken...

en: A.13 Code a Probabilistic Sequencer
nl: A.13 Codeer een probabilistische Sequencer

en: Code a Probabilistic Sequencer
nl: Codeer een probabilistische Sequencer

en: In a previous episode of this Sonic Pi series we explored the power of randomisation to introduce variety, surprise and change into our live coded tracks and performances. For example, we randomly picked notes from a scale to create never-ending melodies. Today we're going to learn a new technique which uses randomisation for rhythm - probabilistic beats!
nl: In een vorige aflevering van deze Sonic Pi serie, verkenden we de kracht van randomiseren om verscheidenheid,variatie en verassing te kunnen introduceren in onze live gecodeerde nummers en optredens. We plukten bijvoorbeeld willekeurig noten van een bepaalde toonladder, om nooit-eindigende melodieën te creëren. Vandaag gaan we een nieuwe techniek leren, die gebruik maakt van het randomiseren van ritme - probabilistische beats!

en: Probability
nl: Probabiliteit

en: Before we can start making new beats and synth rhythms we need to take a quick dive into the basics of probability. This might sound daunting and complicated, but really it's just as simple as rolling a dice - honestly! When you take a regular 6 sided board game dice and roll it what's actually happening? Well, firstly you'll roll either a 1, 2, 3, 4, 5 or 6 with exactly the same chance of getting any of the numbers. In fact, given that it's a 6 sided dice, on average (if you roll lots and lots of times) you'll throw a 1 every 6 throws. This means you have a 1 in 6 chance of throwing a 1. We can emulate dice rolls in Sonic Pi with the fn `dice`. Let's roll one 8 times:
nl: Voor we nieuwe beats en synth ritmes beginnen maken, moeten we even kijken naar de basisprincipes van probabiliteit. Het lijkt misschien ingewikkeld, maar het is echt net zo eenvoudig als een dobbelstenen werpen - echt waar! Als je een 6 zijdige dobbelsteen gooit, wat gebeurt er dan? Wel misschien gooi je een 1, 2, 3, 4, 5 of 6 met precies dezelfde kansen.
    Hierdoor heb je een kans van 1 in 6 van het gooien van een 1. We kunnen ook het gooien van dobbelstenen in Sonic Pi emuleren met de fn 'dice' . Laten we eens 8 keer gooien:

en: Notice how the log prints values between 1 and 6 just as if we'd rolled a real dice ourselves.
nl: Kijk hoe in het logboek waarden tussen 1 en 6 wordt afgedrukt, alsof we een echte dobbelsteen geworpen zouden hebben.

en: Now imagine you had a drum and every time you were about to hit it you rolled a dice. If you rolled a 1, you hit the drum and if you rolled any other number you didn't. You now have a probabilistic drum machine working with a probability of 1/6! Let's hear what that sounds like:
nl: Beeld je even in dat je een trommel hebt en dat je elke keer je deze zou slaan, je een teerling zou werpen. Als je één gooit zou je hem slaan en elke worp met een ander getal niet. Je hebt nu een probalistische drummachine met een probabiliteit van 1/6! Laten we eens horen hoe dat klinkt:

en: Let's quickly go over each line to make sure everything is very clear. First we create a new `live_loop` called `:random_beat` which will continually repeat the two lines between `do` and `end`. The first of these lines is a call to `sample` which will play a pre-recorded sound (the `:drum_snare_hard` sound in this case). However, this line has a special conditional `if` ending. This means that the line will only be executed if the statement on the right hand side of the `if` is `true`. The statement in this case is `dice == 1`. This calls our `dice` function which, as we have seen, returns a value between 1 and 6. We then use the equality operator `==` to check to see if this value is `1`. If it is `1`, then the statement resolves to `true` and our snare drum sounds, if it isn't `1` then the statement resolves to `false` and the snare is skipped. The second line simply waits for `0.125` seconds before rolling the dice again.
nl: Laat ons even snel elke regel overlopen om er zeker van te zijn dat alles duidelijk is. Eerst creëren we een nieuwe `live_loop` die `:random_beat`heet , en de twee regels tussen `do` en `end`, herhaalt. De eerste regel roept een `sample` aan die een vooraf opgenomen geluidsbestand afspeelt ( `:drum_snare_hard` in dit geval ).Deze lijn heeft echter een special voorwaardelijk einde met de `if` functie. Deze betekent dat de regel enkel wordt uitgevoerd als de declaratie, rechts van de `if` (als), `true`(waar) is. Deze geeft in dit geval `dice == 1` aan. Die roept onze `dice`functie aan dewelke, zoals we reeds zagen, een waarde tussen 1 en 6 zal teruggeven.

en: Changing Probabilities
nl: Probabiliteit veranderen

en: Those of you that have played role play games will be familiar with lots of strangely shaped dice with different ranges. For example there is the tetrahedron shaped dice which has 4 sides and even a 20 sided dice in the shape of a icosahedron. The number of sides on the dice changes the chance, or probability of rolling a 1. The fewer sides, the more likely you are to roll a 1 and the more sides the less likely. For example, with a 4 sided dice, there's a one in 4 chance of rolling a 1 and with a 20 sided dice there's a one in 20 chance. Luckily, Sonic Pi has the handy `one_in` fn for describing exactly this. Let's play:
nl: Wie al een rollenspel heeft gespeeld zal al wel vertrouwd zijn met vreemd gevormde dobbelstenen die verschillende reeksen getallen kunnen hebben. Er is bijvoorbeeld de tetraëder-vormige dobbelsteen die 4 zijden heeft en zelfs een 20 zijdige dobbelsteen in de vorm van een icosaëder. Het aantal zijden op de dobbelsteen verandert de kans of waarschijnlijkheid van het rollen van een 1. Hoe minder kanten, hoe meer kans je hebt om 1 te gooien en hoe meer zijden hoe minder waarschijnlijk. Met een 4-zijdige dobbelstenen bijvoorbeeld, is er  een kans van één op 4 om een 1 te gooien en met een 20 zijdige dobbelsteen er is één kans op de 20. Gelukkig heeft Sonic Pi de handige 'one_in' fn om precies dit te bepalen. Laten we gaan gooien:

en: Start the live loop above and you'll hear the familiar random rhythm. However, don't stop the code running. Instead, change the `6` to a different value such as `2` or `20` and hit the `Run` button again. Notice that lower numbers mean the snare drum sounds more frequently and higher numbers mean the snare triggers fewer times. You're making music with probabilities!
nl: Start de bovenstaande live-loop en je hoort het bekende random ritme. Stop deze nog even niet maar wijzig de `6` naar een andere waarde, zoals `2` of `20` en druk op de `Afspeel` - knop. Merk op dat een lager getal betekent dat je de snare drum vaker hoort en dat hogere cijfers de snare minder zullen triggeren. Je maakt nu muziek met kansberekening!

en: Combining Probabilities
nl: Probabiliteit combineren

en: Things get really exciting when you combine multiple samples being triggered with different probabilities. For example:
nl: Echt spannend wordt het wanneer je meerdere samples combineert, die worden geactiveerd met verschillende kansen. Bijvoorbeeld:

en: Again, run the code above and then start changing the probabilities to modify the rhythm. Also, try changing the samples to create an entirely new feel. For example try changing `:drum_cymbal_closed` to `:bass_hit_c` for extra bass!
nl: Opnieuw, laat de bovenstaande code lopen, en wijzig de probabiliteit, om het ritme te modificeren. Probeer het ook de samples te veranderen om een geheel nieuw gevoel te creëren. Probeer bijvoorbeeld `:drum_cymbal_closed` naar `:bass_hit_c` te veranderen voor extra bass!

en: Repeatable Rhythms
nl: Herhaalbare ritmes

en: Next, we can use our old friend `use_random_seed` to reset the random stream after 8 iterations to create a regular beat. Type the following code to hear a much more regular and repeating rhythm. Once you hear the beat, try changing the seed value from `1000` to another number. Notice how different numbers generate different beats.
nl: Vervolgens kunnen we gebruik maken van onze oude vriend `use_random_seed` om de willekeurige stroom, na 8 herhalingen opnieuw in te stellen om een regelmatige beat te maken. Typ de volgende code om een meer regelmatig en herhalend ritme te horen. Zodra je de beat hoort, probeer de seed waarde van `1000` naar een ander nummer te wijzigen. Merk op hoe verschillende cijfers, verschillende beats genereren.

en: One thing I tend to do with this kind of structure is to remember which seeds sound good and make a note of them. That way I can easily re-create my rhythms in future practice sessions or performances.
nl: Wat ik met dit soort structuren ook graag doe is, de seeds, welke goed klinken,te onthouden en deze te noteren. Op die manier kan ik makkelijk mijn favoriete ritmes opnieuw maken in toekomstige trainingen of voorstellingen.

en: Finally, we can throw in some random bass to give it some nice melodic content. Notice that we can also use our newly discovered probabilistic sequencing method on synths just as well as samples. Don't leave it at that though - tweak the numbers and make your own track with the power of probabilities!
nl: Tot slot kunnen we er een random baslijn aan toevoegen om er een mooie melodische inhoud aan te geven. Merk ook op dat we onze pas aangeleerde probabilistische sequentie methode, kunnen gebruiken op synths en samples. Laat het daar zeker ook niet bij, pas de getallen aan, en maak je eigen nummer met de kracht van waarschijnlijkheden!

en: A.14 Amplitude Modulation
nl: A.14 Amplitude Modulatie

en: Amplitude Modulation
nl: Amplitude Modulatie

en: This month we're going to take a deep dive into one of Sonic Pi's most powerful and flexible audio FX - the `:slicer`. By the end of this article you will have learned how to manipulate the overall volume of parts of our live coded sound in powerful new ways. This will allow you to create new rhythmic and timbral structures and broaden your sonic possibilities.
nl: Deze maand gaan we een diepe duik nemen in een van Sonic Pi ' s meest krachtige en flexibele audio effecten: de `: slicer`. Aan het eind van dit artikel heb je geleerd hoe je de totale omvang van de onderdelen van ons live gecodeerd geluid op een krachtige, nieuwe manieren kan manipuleren. Dit zal je toelaten, nieuwe ritmische en timbrale structuren te creëren en je klankspectrum te verruimen.

en: Slice that Amp
nl: Snij de Amp

en: So, what does the `:slicer` FX actually do? One way to think about it is that it's just like having someone play around with the volume control on your TV or home hi-fi. Let's take a look but first, listen to the deep growl of the following code which triggers the `:prophet` synth:
nl: Dus, wat doet deze:slicer` FX eigenlijk? Een manier om er naar te kijken is ,dat het net iemand is, die speelt met de volumeknop op de stereoinstallatie of de TV. Laten we eens een kijkje nemen, maar zeker eerst luisteren naar het diepe gegrom van de volgende code die de `:prophet` synth triggeren:

en: Now, let's pipe it through the `:slicer` FX:
nl: Laat ons dit nu door het `:slicer`FX leiden:

en: Hear how the slicer acts like it's muting and unmuting the audio with a regular beat. Also, notice how the `:slicer` affects all the audio generated between the `do`/`end` blocks. You can control the speed at which it turns the audio on and off with the `phase:` opt which is short for phase duration. Its default value is `0.25` which means 4 times a second at the default BPM of 60. Let's make it faster:
nl: Hoor hier, hoe de Slicer, het geluid met een een regelmatige tel, lijkt op en aan te zetten.Merk hierbij op dat de `:slicer` het geluid, gegenereerd tussen de `do`/`end` blocks, beïnvloed. Je kan de snelheid waarmee het geluid wordt af- en aangezet bepalen met de `phase:` opt ( duurtijd fase). Zijn standaard instelling is `0.25`, dat is 4 keer per minuut aan de standaard 60 BPM. Dit maken we sneller:

en: Now, play with different `phase:` durations yourself. Try longer and shorter values. See what happens when you choose a really short value. Also, try different synths such as `:beep` or `:dsaw` and different notes. Take a look at the following diagram to see how different `phase:` values change the number of amplitude changes per beat.
nl: Speel nu zelf met de verschillende `phase:` tijden. Probeer langere en kortere waarden. Zie wat er gebeurt wanneer je kiest voor een heel korte-waarde. Probeer ook verschillende synths zoals `:beep` of `:dsaw` en probeer ook andere noten. Bekijk het volgende diagram om te zien hoe verschillende `phase:` waarden, het aantal veranderingen op de amplitude per beat wijzigt.

en: Phase duration is the length of time for one on/off cycle. Therefore smaller values will make the FX switch on and off much faster than larger values. Good values to start playing with are `0.125`, `0.25`, `0.5` and `1`.
nl: De duur van een fase is de lengte van een aan/uit cyclus. Daarom zullen kleinere waarden, de FX schakelaar veel sneller aan-/ uitschakelen, dan grotere waarden. Leuke waarden om mee te beginnen spelen zijn `0.125`, `0.25`, `0.5` en `1`.

en: Control Waves
nl: Golfsoort Instellen

en: By default, the `:slicer` FX uses a square wave to manipulate the amplitude through time. This is why we hear the amplitude on for a period, then immediately off for a period, then back on again. It turns out that the square wave is just one of 4 different control waves that are supported by `:slicer`. The others are saw, triangle and (co)sine. Take a look at the diagram below to see what these look like. We can also hear what they sound like. For example, the following code uses (co)sine as the control wave. Hear how the sound doesn't turn on and off abruptly but instead smoothly fades in and out:
nl: Standaard gebruikt het `:slicer` FX een blokgolf om de amplitude in een bepaalde tijdsduur te manipuleren.  Daarom horen we amplitude voor een tijdje, en dan voor een tijdje helemaal niet, om dan weer met een zelfde cyclus te beginnen. Het is zo dat de blokgolf  één van de vier golfvormen is die we kunnen instellen in deze  `:slicer`. De andere golfsoorten zijn: zaagtand, driehoeksgolf, en (co)sinus. Kijk ook eens naar de onderstaande afbeelding om te zien hoe deze eruit zien. We kunnen ook horen hoe deze klinken. De volgende code gebruikt een sinusgolf als controlegolf. Hoor nu dat het geluid niet abrupt aan en uit gaat, maar zacht in- en uit-fade:

en: Have a play with the different wave forms by changing the `wave:` opt to `0` for saw, `1` for square, `2` for triangle and `3` for sine. See how different waves sound with different `phase:` opts too.
nl: Speel met verschillende golftypes door de `wave:` opt naar `0` te veranderen voor saw (zaagtandgolf) , `1` voor square (blokgolf), `2` voor triangle (driehoeksgolf) en `3` voor sine (sinusgolf). Bekijk ook hoe deze verschillende golftypes klinken met verschillende `phase:` opts.

en: Each of these waves can be inverted with the `invert_wave:` opt which flips it on the y axis. For example, in a single phase the saw wave typically starts high, and slowly goes down before jumping back to the top. With `invert_wave: 1` it will start low and slowly go up before jumping back down again. Additionally, the control wave can be started at different points with the `phase_offset:` opt which should be a value between `0` and `1`. By playing around with `phase:`, `wave:`, `invert_wave:` and `phase_offset` opts you can dramatically change how the amplitude is modified through time.
nl: Elk van deze golven kan worden omgekeerd met de `invert_wave:` optie, en spiegelt deze tegenover de Y-as. Bijvoorbeeld, in een enkele fase, zal een zaagtand-golf normaal gezien op zijn hoogste punt beginnen en langzaam naar beneden te gaan, om dan terug naar zin hoogste punt te springen. Met `invert_wave: 1` zal deze nu op het laagste punt beginnen en langzaam naar boven gaan, om dan naar beneden te vallen. Bijkomend, kan je de  golf ook instellen dat deze op andere punten start met de `phase_offset:` optie. Deze kan een getal bevatten tussen `0` en`1`. Door te gaan spelen met de `phase:`, `wave:`, `invert_wave:` en`phase_offset` opties kan je de amplitude binnen een tijdsverloop dramatisch veranderen.

en: Setting your levels
nl: Het instellen van je niveaus

en: By default, `:slicer` switches between amplitude values `1` (fully loud) and `0` (silent). This can be changed with the `amp_min:` and `amp_max:` opts. You can use this alongside the sine wave setting to create a simple tremolo effect:
nl: Standaard schakelt `:slicer` tussen de amplitude-waarden `1` (luid) en `0` (stil). Dit kan je veranderen met de `amp_min:` en `amp_max:` opties. Je kan deze gebruiken naast de sinusgolf instelling om een eenvoudige tremolo-effect te bekomen:

en: This is just like grabbing the volume knob on your hi-fi and moving it up and down just a little so the sound 'wobbles' in and out.
nl: Dit is zoals je de volumeknop van je hi-fi op en neer zou bewegen, zodat het geluid een beetje aan en uit 'wiebelt'.

en: Probabilities
nl: Probabiliteit

en: One of `:slicer`'s powerful features is its ability to use probability to choose whether or not to turn the slicer on or off. Before the `:slicer` FX starts a new phase it rolls a dice and based on the result either uses the selected control wave or keeps the amplitude off. Let's take a listen:
nl: Een van de krachtigste functies van ': slicer' , is de mogelijkheid of u de slicer aan of uit wil schakelen. Vooraleer het `:slicer` FX een nieuwe fase start, zal deze een teerling werpen, en gebaseerd op de uitkomst hiervan , de geselecteerde controle golf gebruiken, of de amplitude niet aanzetten. Laten we even gaan luisteren:

en: Hear how we now have an interesting rhythm of pulses. Try changing the `probability:` opt to a different value between `0` and `1`. Values closer to `0` will have more space between each sound due to the likelihood of the sound being triggered being much lower.
nl: Hoor hoe we nu een interessant ritme van pulsen hebben bekomen. Probeer de `probability:` optie naar een andere waarde tussen `0` en `1` te veranderen.  Waarden dichter bij `0` zullen meer ruimte tussen elk geluid hebben, doordat de waarschijnlijkheid dat het geluid wordt getriggerd veel lager ligt.

en: Another thing to notice is that the probability system in the FX is just like the randomisation system accessible via fns such as `rand` and `shuffle`. They are both completely deterministic. This means that each time you hit Run you'll hear exactly the same rhythm of pulses for a given probability. If you would like to change things around you can use the `seed:` opt to select a different starting seed. This works exactly the same as `use_random_seed` but only affects that particular FX.
nl: Wat je zeker ook nog moet weten is, dat het probabiliteitssysteem in FX, net zoals het randomisatie-systeem toegankelijk is via functies zoals `rand` en`shuffle`. Ze zijn beide volledig deterministisch. Dit betekent dat elke keer je op afspelen klikt, je precies hetzelfde ritme van pulsen zal horen binnen een bepaalde probabiliteit. Wil je toch nog dingen veranderen, gebruik dan de `seed:` opt om een verschillend start seed te kiezen. Dit werkt precies hetzelfde als `use_random_seed` maar zal enkel invloed hebben op dat bepaalde FX.

en: Finally, you can change the 'resting' position of the control wave when the probability test fails from `0` to any other position with the `prob_pos:` opt:
nl: Tenslotte kan je ook nog de 'rust' positie van de controle-Golf als de probabiliteit-test mislukt, van `0` naar eender welke positie brengen met de `prob_pos:` opt:

en: Slicing Beats
nl: Beats Slicen (Opknippen)

en: One really fun thing to do is to use `:slicer` to chop a drum beat in and out:
nl: Wat ook heel leuk is om te doen is het gebruik van `:slicer` om een drum beat aan en uit te knipperen:

en: This allows us to take any sample and create new rhythmical possibilites which is a lot of fun. However, one thing to be careful about is to make sure that the tempo of the sample matches the current BPM in Sonic Pi otherwise the slicing will sound totally off. For example, try swapping `:loop_mika` with the `loop_amen` sample to hear how bad this can sound when the tempos don't align.
nl: Hiermee kunnen we met eender welke sample nieuwe ritmische mogelijkheden creëren, heel leuk om mee te spelen. Waar je wel op moet letten is dat het tempo van de sample past in het huidige BPM van Sonic Pi, anders knipt hij naast het ritme. Probeer bijvoorbeeld de `:loop_mika` met de `loop_amen` sample te verwisselen, om te horen hoe slecht dit kan klinken als het tempo niet uitlijnt.

en: Changing tempo
nl: Tempo Veranderen

en: As we have already seen, changing the default BPM with `use_bpm` will make all the sleep times and synth envelope durations grow or shrink to match the beat. The `:slicer` FX honours this too, as the `phase:` opt is actually measured in beats not seconds. We can therefore fix the issue with `loop_amen` above by changing the BPM to match the sample:
nl: Zoals we reeds gezien hebben, als het standaard BPM met `use_bpm` wordt veranderd, zal dit ervoor zorgen dat de rusttijden (sleep) en de enveloppe van de synths gaan groeien of krimpen, om gelijk met de tel te kunnen lopen. De `:slicer` FX houdt hier ook rekening mee, vermits de `phase:` optie in de maat wordt berekend en niet in seconden. We kunnen dus bovenstaand probleem oplossen door de BPM te veranderen om deze met de sample te laten passen:

en: Let's apply all these ideas into a final example that only uses the `:slicer` FX to create an interesting combination. Go ahead, start changing it and make it into your own piece!
nl: Laten we deze ideeën nu even toepassen in een laatste voorbeeld waar enkel het `:slicer` FX wordt gebruikt om een interessante combinatie te maken. Ga je gang, begin dingen te veranderen en maak er je eigen nummer van!

en: A.15 Five Live Coding Techniques
nl: A.15 Vijf Live codering technieken

en: Five Live Coding Techniques
nl: Vijf Live-Coding Technieken

en: In this month's Sonic Pi tutorial we're going to take a look at how you can start treating Sonic Pi like a real instrument. We therefore need to start thinking of code in a completely different way. Live coders think of code in a similar way to how violinists think of their bow. In fact, just like a violinist can apply various bowing techniques to create different sounds (long slow motions vs short fast hits) we will explore five of the basic live coding techniques that Sonic Pi enables. By the end of this article you'll be able to start practicing for your own live coded performances.
nl: In de Sonic Pi zelfstudie van deze maand gaan we eens kijken hoe je Sonic Pi als een echt muziekinstrument kan gaan hanteren. We moeten daarvoor met een andere blik naar de code beginnen kijken. Live Coders bekijken hun code zoals een violist naar zijn strijkstok kijkt. Zoals een violist in feite verschillende strijktechnieken gebruikt om andere klanken te creëren (lange trage bewegingen of korte snelle aanslagen), zullen wij vijf van de basistechnieken onderzoeken die Sonic Pi mogelijk maakt. Aan het eind van het artikel, kan je je eigen live coding optreden beginnen oefenen.

en: 1. Memorise the Shortcuts
nl: 1. Het onthouden van de Sneltoetsen

en: The first tip to live coding with Sonic Pi is to start using the shortcuts. For example, instead of wasting valuable time reaching for the mouse, moving it over to the Run button and clicking, you can simply press `alt` and `r` at the same time which is much faster and keeps your fingers at the keyboard ready for the next edit. You can find out the shortcuts for the main buttons at the top by hovering the mouse over them. See section 10.2 of the built-in tutorial for the full list of shortcuts.
nl: De eerste tip om met Sonic Pi live coding te gaan doen is beginnen gebruik maken van de sneltoetsen. Bijvoorbeeld, in plaats van kostbare tijd te verliezen door de muis te moeten gaan nemen om op de afspeeltoets te klikken kan je simpelweg tegelijk de `alt` en`r` toets typen, dat werkt niet alleen sneller, je vingers staan zo ook al klaar op het klavier voor de volgende bewerking. Je kan de sneltoetsen voor de belangrijkste knoppen bovenaan makkelijk uitzoeken door met de muis eroverheen te zweven. Zie sectie 10.2 voor de ingebouwde handleiding voor de volledige lijst met sneltoetsen.

en: When performing, one fun thing to do is to add a bit of flair with your arm motion when hitting shortcuts. For example, it's often good to communicate to the audience when you're about to make a change - so embellish your movement when hitting `alt-r` just like a guitarist would do when hitting a big power chord.
nl: Wanneer je een voorstelling doet is het ook prettig om je armbewegingen met wat flair te doen als je een sneltoets aanslaat. Zo is het bijvoorbeeld heel goed met het publiek fysiek te communiceren als je op het punt staat een verandering te maken, dus maak een mooie beweging als je `alt-r` typt, net zoals een gitarist zou doen wanneer hij een power chord aanslaat.

en: 2. Manually Layer your Sounds
nl: 2. Handmatig je geluid van lagen voorzien

en: Now you can trigger code instantly with the keyboard, you can instantly apply this skill for our second technique which is to layer your sounds manually. Instead of 'composing' using lots of calls to `play`, and `sample` separated by calls to `sleep` we will have one call to `play` which we will manually trigger using `alt-r`. Let's try it. Type the following code into a fresh buffer:
nl: Nu je de code direct kunt activeren met het computerklavier, kan je deze vaardigheid voor onze tweede techniek gaan gebruiken, en dat is handmatig je geluid van lagen voorzien. In plaats van te componeren door meermaals een `play`, en een `sample` op te roepen, gescheiden door oproepen van `sleep`, hebben we één oproep naar `play` welk we manueel activeren met `alt-r`. Typ de volgende code in een nieuwe buffer:

en: Now, hit `Run` and whilst the sound is playing, modify the code in order to drop down four notes by changing it to the following:
nl: Klik nu op de  `Afspeel` knop wanneer de klank loopt, verander de code om vier tonen te zakken door het volgende te doen:

en: Now, hit `Run` again, to hear both sounds playing at the same time. This is because Sonic Pi's `Run` button doesn't wait for any previous code to finish, but instead starts the code running at the same time. This means you can easily layer lots of sounds manually with minor or major modifications between each trigger. For example, try changing both the `note:` and the `cutoff:` opts and then re-trigger.
nl: Klik nu terug op `Afspelen`, om beide klanken, tegelijk te horen spelen. Dit komt omdat de `Afspelen`knop van Sonic Pi niet wacht tot een voorgaande code is afgelopen, maar in plaats daarvan de code tegelijkertijd start. Dit betekent dat je makkelijk veel lagen van je geluid van kleinere of grotere veranderingen kan voorzien tussen elke trigger. Verander bijvoorbeeld zowel de `note:` als de  `cutoff:` opties en herstart dan.

en: You can also try this technique with long abstract samples. For example:
nl: Je kan deze techniek ook gebruiken met lange abstracte samples. Bijvoorbeeld:

en: Try starting the sample off, and then progressively halving the `rate:` opt between hitting `Run` from `1` to `0.5` to `0.25` to `0.125` and then even try some negative values such as `-0.5`. Layer the sounds together and see where you can take it. Finally, try adding some FX.
nl: Probeer de sample op te starten en dan geleidelijk de `rate:` waarde te halveren tussen de afspeelcommando's door en gebruik getallen tussen `1` tot `0.5` tot `0.25` tot `0.125` en probeer zelfs negatieve waarden zoals `-0.5`. Voeg lagen toe en kijk waar je uitkomt. Voeg er tenslotte nog een snuifje FX aan toe.

en: When performing, working with simple lines of code in this way means that an audience new to Sonic Pi has a good chance to follow what you're doing and relate the code that they can read to the sounds they are hearing.
nl: Werken met eenvoudige regels code tijdens een uitvoering, betekent hier dat een publiek dat niet vertrouwd is met Sonic Pi, een goede kans maakt, te begrijpen wat jij aan het doen bent, en de code kunnen koppelen en lezen aan de klank die ze horen.

en: 3. Master Live Loops
nl: 3.Live Loops Masteren

en: When working with more rhythmic music, it can often be hard to manually trigger everything and keep good time. Instead, it is often better to use a `live_loop`. This provides repetition for your code whilst also giving the ability to edit the code for the next time round the loop. They also will run at the same time as other `live_loop`s which means you can layer them together both with each other and manual code triggers. Take a look at section 9.2 of the built-in tutorial for more information about working with live loops.
nl: Als je eerder met ritmische muziek werkt, kan het dikwijls moeilijk zijn om alles manueel te activeren en hierin een goeie timing te houden. In plaats daarvan is het dikwijls beter om een `live_loop`te gebruiken. Het geeft herhaling aan je code en geeft je ook de mogelijkheid de code te bewerken voor de volgende cyclus van een loop. Deze lopen samen met andere `live_loop`s, wat betekent dat je deze kan lagen met elkaar en manueel triggers codeert. Bekijk sectie 9.2 van de ingebouwde handleiding om meer over live loops te weten te komen.

en: When performing, remember to make use of `live_loop`'s `sync:` opt to allow you to recover from accidental runtime mistakes which stop the live loop running due to an error. If you already have the `sync:` opt pointing to another valid `live_loop`, then you can quickly fix the error and re-run the code to re-start things without missing a beat.
nl: Denk eraan om, bij een uitvoering, gebruikt te maken van de  `sync:` optie van `live_loop`om te kunnen herstellen van een accidentele doorloop die de live loop stopt door een fout. Als je de `sync:` optie laat verwijzen naar een andere geldige `live_loop`, kan je snel de fout herstellen en de code te herstarten zonder een tel te missen.

en: 4. Use the Master Mixer
nl: 4. De Master Mixer Gebruiken

en: One of Sonic Pi's best kept secrets is that it has a master mixer through which all sound flows. This mixer has both a low pass filter and a high pass filter built-in, so you can easily perform global modifications to the sound. The master mixer's functionality can be accessed via the fn `set_mixer_control!`. For example, whilst some code is running and making sound, enter this into a spare buffer and hit `Run`:
nl: Een van Sonic Pi's best bewaarde geheimen, is dat deze een master mixer heeft, waar het geluid doorgaat. Deze mixer heeft zowel een low pass- als een high pass filter ingebouwd, zodat je makkelijk het globale geluid kan modificeren. De functies van de master mixer is toegankelijk via de fn `set_mixer_control!`. Gebruik bijvoorbeeld het volgende, terwijl je de code loopt en hoort, in een vrije buffer, en druk op `Afspelen`:

en: After you run this code, all existing and new sounds will have a low pass filter applied to them and will therefore sound more muffled. Note that this means that the new mixer values stick until they are changed again. However, if you want, you can always reset the mixer back to its default state with `reset_mixer!`. Some of the currently supported opts are: `pre_amp:`, `lpf:` `hpf:`, and `amp:`. For the full list, see the built-in docs for `set_mixer_control!`.
nl: Nadat je deze code uitvoert, worden alle bestaande en nieuwe geluiden van een low pass filter voorzien en daarom zal het geluid nu meer gedempt zijn. Merk op, dat dit betekent, dat de waarden van nieuwe mixer blijvend zijn, totdat ze weer veranderd worden. Je kan echter, als je wil, altijd opnieuw de mixer terug naar de standaard instelling zetten met `reset_mixer!`. Een aantal van de huidige ondersteunde opts zijn: `pre_amp:`, `lpf:` op hpf:` en `amp:`. Voor de volledige lijst, zie de ingebouwde handleiding voor `set_mixer_control!`.

en: Use the mixer's `*_slide` opts to slide one or many opts values over time. For example, to slowly slide the mixer's low pass filter down from the current value to 30, use the following:
nl: Gebruik de `*_slide` opts van de mixer om tussen een of meerdere opt waarden te schuiven. Om bijvoorbeeld langzaam de waarde van de mixer's low pass filter van de huidige waarde naar 30 te brengen, gebruik het volgende:

en: You can then slide quickly back to a high value with:
nl: Je kan dan snel terug naar boven schuiven voor een hogere waarde met:

en: When performing, it's often useful to keep a buffer free for working with the mixer like this.
nl: Als u optreed is het nuttig om een lege buffer vrij te houden om zoals hier met de mixer te werken.

en: 5. Practice
nl: 5. Oefening

en: The most important technique for live coding is practice. The most common attribute across professional musicians of all kinds is that they practice playing with their instruments - often for many hours a day. Practice is just as important for a live coder as a guitarist. Practice allows your fingers to memorise certain patterns and common edits so you can type and work with them more fluently. Practice also gives you opportunities to explore new sounds and code constructs.
nl: De meest belangrijke techniek voor live coding is oefening. Het meest gezamenlijke kenmerk van professionele muzikanten  is dat ze het bespelen van hun instrumenten - vaak vele uren per dag, oefenen. Oefening is net zo belangrijk voor een live-coder als voor een gitarist. Oefening laten uw vingers bepaalde patronen  en veel voorkomende bewerkingen onthouden, zodat je deze kan typen, en je meer vloeiend met hen kan werken . Het oefenen geeft je ook de mogelijkheid nieuwe klanken en constructies te kunnen gaan verkennen .

en: When performing, you'll find the more practice you do, the easier it will be for you to relax into the gig. Practice will also give you a wealth of experience to draw from. This can help you understand which kinds of modifications will be interesting and also work well with the current sounds.
nl: Bij het uitvoeren, zal je zien dat hoe meer oefening je doet, hoe makkelijker het voor je zal zijn om te ontspannen bij het optreden. Oefening zal je ook een schat aan ervaring geven, om uit te putten. Dit kan je helpen te begrijpen welke soorten wijzigingen interessant zullen zijn en goed werken met de huidige "sound".

en: This month, instead of giving you a final example that combines all the things discussed, let's part by setting down a challenge. See if you can spend a week practicing one of these ideas every day. For example, one day practice manual triggers, the next do some basic `live_loop` work and the following day play around with the master mixer. Then repeat. Don't worry if things feel slow and clunky at first - just keep practicing and before you know it you'll be live coding for a real audience.
nl: In plaats van je een laatste Voorbeeld te geven, waarin alle aangeleerde dingen worden gecombineerd, laten we deze maand afscheid nemen door je een uitdaging te laten aangaan. Kijk of je een week lang al deze ideeën kan oefenen. Bijvoorbeeld, de ene dag oefen je alle manuele triggers, de volgende dag wat `live_loop` basiswerk en de volgende dag speel je met de master mixer. Dan herhaal je dit. Maak je geen zorgen dat dit eest met horten en stoten gaat, blijf oefenen en voor je het weet ben je echt voor een publiek aan het live coden.

en: A.16 How to Practice Live Coding
nl: A. 16 Hoe Live Coding te oefenen

en: 8 Tips for Live Coding Practice
nl: 8 Tips om Live-Coding te oefenen

en: Last month we took a look at five important techniques for mastering live coding - in other words, we explored how we could use Sonic Pi to approach code in the same way we would approach a musical instrument. One of the important concepts that we discussed was practice. This month we're going to take a deeper dive into understanding why live coding practice is important and how you might start.
nl: Vorige maand namen we een kijkje naar vijf belangrijke technieken om live-coding te beheersen  - in andere woorden, we onderzocht hoe we gebruik kunnen maken van Sonic Pi en de code te benaderen op eenzelfde manier als een muziekinstrument. Een van de belangrijkste concepten die we besproken hebben, is deze van oefening. Deze maand gaan we hier dieper op in, om te begrijpen waarom het oefenen van live coding zo belangrijk is en hoe je eraan zou kunnen beginnen.

en: Practice regularly
nl: Regelmatig oefenen

en: The most important piece of advice is to make sure you practice regularly. As a rule I typically practice for 1-2 hours a day, but 20 mins is just fine when you're starting out. Little but often is what you're aiming for - so if you can only manage 10 minutes, that's a great start.
nl: Het belangrijkste advies is om ervoor te zorgen dat je regelmatig oefent. Als regel oefen ik meestal  1-2 uur per dag, maar 20 minuten is prima wanneer je begint. Kleine beetjes maar wel vaak is waar je naar zou willen streven - dus als het je lukt slechts 10 minuten, is al een goede start.

en: Practice tip #1 - start to develop a practice routine. Find a nice time in the day that works for you and try and practice at that time as many days of the week as you can. Before long you'll be looking forward to your regular session.
nl: Oefening tip #1 Begin een routine om te oefenen op te bouwen. Bepaal een leuk tijdstip, dat jou het beste uitkomt, om zoveel mogelijk dagen in de week te kunnen oefenen. Het zal niet lang duren eer je naar je dagelijkse sessie uitkijkt.

en: Learn to Touch Type
nl: Leer blind typen

en: If you watch a professional musician performing on stage you'll likely notice a few things. Firstly, when they play they don't stare at their instrument. Their fingers, arms and bodies know which keys to press, strings to pluck or drums to hit without them having to think about it too much. This is known as "muscle memory" and although it might sound like something only professionals can do - it's just the same as when you first learned to walk or ride a bike - practicing through repetition. Live coders use muscle memory to free their minds from having to think about where to move their fingers so they can focus on the music. This is called touch-typing - typing without having to look at the keyboard.
nl: Als je een professionele muzikant op het podium ziet ,zal je waarschijnlijk een paar dingen merken. Ten eerste, als ze spelen staren ze niet zo overduidelijk op hun instrument. Hun vingers, armen en lichamen weten welke toetsen, snaren te plukken of drums te raken zonder hier veel over  na te denken. Dit is bekend als "muscle memory" (spier geheugen) en hoewel dit misschien klinkt als iets dat alleen professionals kunnen doen - het is net hetzelfde als wanneer je voor het eerst geleerd hebt om te lopen of om fiets te rijden- oefenen door middel van herhaling. Live programmeurs gebruiken spier geheugen om niet na te moeten denken over waar hun vingers te zetten, zodat ze zich kunnen concentreren op de muziek. Dit is de zogenaamde touch-typen - typen zonder te kijken naar het toetsenbord.

en: Practice tip #2 - learn how to touch type. There are many apps, websites and even games which can help you achieve this. Find one you like the look of and stick at it until you can code without looking down.
nl: Oefening tip #2 - leer blind typen. Er zijn vele apps, websites en zelfs games die jou daarbij kunnen helpen. Kies er een die er voor jou goed uitziet en blijf deze gebruiken tot je code kan typen en niet meer hoeft te kijken.

en: Code whilst standing
nl: Codeer terwijl je rechtstaat

en: The body of a musician is conditioned for playing their instrument. For example, a trumpet player needs to be able to blow hard, a guitar player needs to be able to grip the fretboard with strength and a drummer needs to be able to continually hit the drums for long periods of time. So, what's physical about live coding? Just like DJs, live coders typically perform whilst standing up and some even dance whilst they code! If you practice live coding whilst sitting at a desk and then have to get up and stand at a gig, you'll likely find the difference very difficult and frustrating.
nl: Het lichaam van een muzikant is geconditioneerd naar het spelen van hun instrument. Zo moet bijvoorbeeld een trompettist hard kunnen blazen, een gitarist zijn greep krachtig kunnen zijn op het fretboard  en een drummer de drums voor langere tijd kunnen slaan. Dus, wat is het fysieke aan live coding? Net als DJs, zullen live coders doorgaans rechtstaan bij een optreden, en sommige zullen zelfs dansen terwijl ze coden! Als je  live coden oefent terwijl je zittend achter een bureau zit en dan moet rechtstaan op een optreden, zal je het verschil zeer moeilijk en frustrerend vinden.

en: Practice tip #3 - stand whilst you practice. The easiest way to do this is to use a standing height desk. However, if like me you don't have one at home, there's a couple of low-fi options. The approach I take is to use an ironing board which happens to work rather well. Another is to stack some boxes or large books on a normal desk and place your keyboard on top of that. Also, make sure you stretch before you start practicing and try and dance a little during the session. Remember, nobody is watching you, so have fun and you'll feel much more natural on stage.
nl: Oefening tip #4 - Sta recht als je oefent.  De eenvoudigste manier om dit te doen is gebruik te maken van een bureau op stahoogte . Maar als je net zoals ik er thuis geen hebt, zijn er wel een paar low-fi opties. Ik gebruik bijvoorbeeld een strijkplank en dat werkt bijzonder goed voor me. Een andere optie is, wat dozen op elkaar stapelen, of een stapel boeken op een gewone tafel te schikken, en je keyboard hierboven op te zetten. Vergeet niet te stretchen voor je begint en probeer ook een beetje te dansen tijdens de sessie. Denk eraan, niemand kijkt, amuseer je, op het podium zal het later veel meer naturel aanvoelen.

en: Practice setting up
nl: Oefen het opstellen

en: Most instruments require some assembly and tuning before they can be played. Unless you're a rockstar with a bus full of roadies, you'll have to set up your own instrument before your gig. This is often a stressful time and it is easy for problems to occur. One way to help with this is to incorporate the setup process into your practice sessions.
nl: De meeste instrumenten vereisen enige montage en moeten gestemd, voordat ze afgespeeld kunnen worden. Tenzij je een rockstar met een bus vol roadies hebt, moet je je eigen instrument voor je optreden  klaarmaken. Dit is vaak een stressvol moment en problemen kunnen hier ook makkelijk de kop opsteken. Een manier om dit te verhelpen is het setup-proces in uw oefen sessies in te bouwen.

en: Practice tip #4 - treat setting up as an important part of your practice. For example, have a box or bag that you can keep your Raspberry Pi and keyboard in etc. Before each practice session, take out all the parts, connect everything, and work through the boot process until you have Sonic Pi running and can make sounds. Once you've finished practicing, take the time to carefully pack everything away afterwards. This may take some time at first, but before long you'll be able to setup and pack everything away incredibly quickly without having to think about it.
nl: Oefen tip #4 - Behandel het opstellen als een belangrijk onderdeel van je oefening. Hou je Raspberry Pi en je toetsenbord enz... in een een doos of tas. Pak deze dan voor elke oefening uit en stel ze op en start de computer en Sonic Pi op en je geluid hebt. Als je oefening gedaan is, neem je de tijd om alles weer zorgvuldig in te pakken. In het begin zal dit traag gaan, maar je zal zien, dat je na een tijdje alles snel kan inpakken, zonder hier zelfs maar over na te hoeven denken.

en: Experiment Musically
nl: Experimenteer op muzikaal vlak

en: Once you've set up and are ready to start making music, you might find yourself struggling to know where to start. One problem many people face is that they might have a good idea of the kinds of sounds they want to make, but are frustrated that they can't produce them. Some people don't even know what kind of sounds they want to make! The first thing to do is not to worry - this is very common and happens to every musician - even if they've been practicing for a long time. It is much more important to be making sounds you don't like than not making any sounds at all.
nl: Eens je bent opgesteld en klaar om muziek te maken, kan je misschien worstelen met waar te beginnen. Een probleem dat veel mensen hebben is dat ze wel goed weten welke klanken ze willen maken, maar gefrustreerd raken omdat ze niet goed weten hoe ze deze moeten maken. Sommige mensen weten zelfs niet welke klanken te gaan maken! Maak je hier vooral geen zorgen over, dit komt heel vaak voor en het gebeurt bij elke , zelfs doorwinterde muzikant. Het is belangrijker om klanken te maken die je niet mooi vind, dan helemaal niets te maken.

en: Practice tip #5 - spend time making sounds and music you don't like. Try to make time to explore new sounds and ideas. Don't worry that it might sound terrible if it's not the style you're looking for. When you're experimenting like this you increase the chance of stumbling over a sound or combination of sounds which you love! Even if 99% of the sounds you make are bad, that 1% might be the riff or intro to your new track. Forget the things you don't like and remember the parts you do. This is even easier when you're making music with code - just hit save!
nl: Oefening tip #5 - Besteed tijd aan het maken van klanken en muziek die je niet aanstaan. Maak tijd om nieuwe klanken en ideeën te ondekken. Maak je geen zorgen als het afschuwelijk klinkt en het zelfs de stijl niet is waar je naar zoekt. Door te experimenteren vergroot je de kans om op iets te stuiten op een klank of klankcombinatie die je wel graag hoort! Zelfs als 99% van de geluiden die je maakt slecht zijn, die 1% is misschien de riff of intro van jouw nieuwe track. Vergeet de delen die je niet goed vind en denk aan de delen die je wel mooi vindt. Dat is zelfs makkelijker bij het maken van muziek met code- druk gewoon op bewaren!

en: Hear the Code
nl: Hoor de code

en: Practice tip #6 - write some code into Sonic Pi but don't hit the Run button. Instead, try to imagine what sound it is going to produce. Then, hit Run, listen, and think about what you got right and what you didn't. Keep repeating this until it become a natural part of your coding process. When I practice I normally have a good idea of what the code will sound like. However, I still am occasionally surprised, and then I'll stop and spend some time thinking about why I was wrong. Each time this happens, I learn new tricks which allow me to express myself in new ways.
nl: Oefen tip #6 - Schrijf wat code in Sonic Pi, maar druk niet op afspelen. Probeer je in plaats daarvan, voor te stellen, welke klank deze gaat produceren. Klik dan op Afspelen, luister, en bekijk dan wat je goed had en wat je niet goed had. Herhaal dit tot dit een tweede natuur word tijdens je coding sessies. Als ik oefen heb ik er normaal gezien altijd een goed idee van, hoe de code gaat klinken. Af en toe ben ik echter ook verrast, en besteed ik er even aandacht aan, waarom ik verkeerd was. Elke keer als dit gebeurt, leer ik een nieuw trucje waardoor ik mij op een nieuwe manier kan uiten.

en: Remove all distractions
nl: Verwijder alle afleiding

en: A common problem when practicing is to become distracted with other things. Practicing is hard and requires real discipline regardless of the kind of music you're making - from jazz to classical to EDM. If you're struggling to get started or make progress, it's often too easy to hop on social media, or look something up on the internet etc. If you've set yourself a target of 20 minutes of practice, it's important to try and spend all that time being as productive as possible.
nl: Een veel voorkomend probleem tijdens het oefenen is dat je makkelijk door andere dingen word afgeleid. Oefenen is moeilijk en vergt een echte discipline,  ongeacht het soort muziek dat je maakt - van jazz tot klassiek, EDM. Als je ermee worstelt om aan de slag te gaan of vooruitgang te boeken, is het dikwijls veel makkelijker om even een kijkje te gaan nemen op sociale media of iets op te gaan zoeken op het internet enz... Als je jezelf een oefentijd van 20 minuten voorhoud, is het belangrijk om deze zo productief mogelijk proberen te maken.

en: Practice tip #7 - before you start practicing remove as many distractions as possible. For example, disconnect from the internet, put your phone in another room and try to practice in a quiet place where you're unlikely to be disturbed. Try to focus on coding music and you can return to your distractions when you've finished.
nl: Oefen tip #7 - Voor je je oefening begint, doe je zoveel mogelijke afleidingen weg. Zet bijvoorbeeld je wi-fi uit, leg je gsm in een andere kamer, en probeer te oefenen op een rustige plaats, waar je niet gestoord kan worden. Probeer je op het coden van muziek te focussen, je kan later, wanneer je klaar bent, naar je afleidingen terugkeren .

en: Keep a practice diary
nl: Hou een oefenboek bij

en: When you are practicing, you'll often find your mind is full of new exciting ideas - new musical directions, new sounds to try out, new functions to write, etc. These ideas are often so interesting that you might stop what you're doing and start working on the idea. This is another form of distraction!
nl: Wanneer je oefent, zult je vaak merken dat je geest vol zit met spannende nieuwe ideeën - nieuwe muzikale richtingen, nieuwe geluiden om uit te proberen, nieuwe functies om te schrijven, enz. Deze ideeën zijn vaak zo interessant dat je zou willen stoppen met wat je aan het doen bent en begint te werken aan dat idee. Dit is een andere vorm van afleiding!

en: Practice tip #8 - keep a practice diary by your keyboard. When you get an exciting new idea, temporarily pause your practice session, quickly jot the idea down, then forget about it and carry on practicing. You can then spend some quality time thinking about and working on your ideas after you've finished practicing.
nl: Oefen tip #8 - Hou een oefendagboek bij naast je keyboard. Wanneer je een gaaf idee krijgt, pauzeer de oefening even en schrijf je idee op, vergeet deze dan en oefen verder. Je kan er dan extra tijd besteden aan je ideeën en deze uitwerken na je oefening.

en: Try to establish a practice routine which incorporates as many of these ideas as possible. Try to keep the sessions as fun as possible but be aware that some practice sessions will be hard and feel a little like work. However, it will all be worth it once you've created your first piece or given your first performance. Remember, practice is the key to success!
nl: Probeer ook zoveel mogelijk routine te krijgen in het oefenen van deze nieuwe ideeën. Probeer de oefensessies zo leuk mogelijk te houden, maar wees er wel van bewust dat sommige sessies zwaar zullen zijn en als hard werken aanvoelen. Het zal het allemaal waard zijn als je je eerste stuk hebt gemaakt en je eerste optreden hebt gegeven. Den eraan, oefening is de sleutel naar succes!

en: A.17 Sample Stretching
nl: A.12 Sample Stretching

en: When people discover Sonic Pi, one of the first things they learn is how simple it is to play pre-recorded sounds using the `sample` function. For example, you can play an industrial drum loop, hear the sound of a choir or even listen to a vinyl scratch all via a single line of code. However, many people don't realise that you can actually vary the speed that the sample is played back at for some powerful effects and a whole new level of control over your recorded sounds. So, fire up a copy of Sonic Pi and let's get started stretching some samples!
nl: Wanneer mensen Sonic Pi ontdekken, een van de eerste dingen die ze leren, hoe eenvoudig het is om vooraf opgenomen geluiden af te spelen met behulp van de `sample` functie. Je kan bijvoorbeeld een industriële drumloop afspelen, het geluid van een koor horen of zelfs naar een kras op vinyl luisteren, allemaal via een enkele regel code. Veel mensen beseffen echter niet dat je eigenlijk de snelheid waarmee de sample wordt afgespeeld kan variëren wat voor een krachtige effect kan zorgen en de controle over je opgenomen geluiden naar een nieuw niveau kan tillen . Dus, start een kopie van Sonic Pi en laten ons aan de slag gaan met wat sample stretching!

en: Slowing Samples Down
nl: Samples vertragen

en: To modify the playback rate of a sample we need to use the `rate:` opt:
nl: Om de afspeelsnelheid van de sample te wijzigen moeten we de `rate:` optie gebruiken:

en: If we specify a `rate:` of `1` then the sample is played back at the normal rate. If we want to play it back at half speed we simply use a `rate:` of `0.5`:
nl: Als we een `rate:` waarde van `1` toekennen wordt de sample op de normale snelheid afgespeeld. Als we deze op halve snelheid willen afspelen gebruiken we simpelweg een `rate:` van`0.5`:

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.
nl: Merk op dat dit twee gevolgen voor de audio heeft. Ten eerste zullen de samples lager in toonhoogte klinken en ten tweede duurt twee keer zo lang om ze af te spelen (Zie de zijbalk voor de uitleg  waarom dit het geval is). We kunnen zelfs nog lager kiezen en lagere snelheden, naar '0' toe, een `rate:` van '0,25' is de kwart snelheid, '0.1' is voor een tiende van de snelheid, enz. Probeer af te spelen met enkele lage snelheden en zie of je het geluid naar een laag gerommel kan omzetten.

en: Speeding Samples Up
nl: Samples versnellen

en: In addition to making the sound longer and lower using a small rate, we can use higher rates to make the sound shorter and higher. Let's play with a drum loop this time. First, take a listen to how it sounds at the default rate of `1`:
nl: Naast het maken van langere, lager klinkende samples door een kleiner waarde voor de snelheid te gebruiken, kunnen we hogere waarde ingeven om kortere en hoger klinkende geluiden te maken. Laten we dit nu even met een drumloop doen. Hoor even hoe dit klinkt met de standaard snelheid van `1`:

en: sample :loop_amen, rate: 1
nl: sample :loop_amen, rate: -1

en: Now, let's speed it up a little:
nl: Nu versnellen we deze een beetje:

en: Ha! We just moved musical genres from old-skool techno to jungle. Notice how the pitch of each drum hit is higher as well as how the whole rhythm speeds up. Now, try even higher rates and see how high and short you can make the drum loop. For example, if you use a rate of `100`, the drum loop turns into a click!
nl: Ha! Nu verhuisden we naar een ander muzikaal genre, van old-skool techno naar jungle. Merk hierbij op dat zowel elke drumslag hoger klinkt als het gehele ritme versnelt. Probeer nu nog hogere waarden uit en zie hoe hoog en hoe kort je de drumloop kan maken. Als je bijvoorbeeld een snelheid van `100`gebruikt, verandert de drumloop naar een enkele klik!

en: Reverse Gear
nl: In achteruit versnelling

en: Now, I'm sure many of you are thinking the same thing right now... "what if you use a negative number for the rate?". Great question! Let's think about this for a moment. If our `rate:` opt signifies the speed with which the sample is played back, `1` being normal speed, `2` being double speed, `0.5` being half speed, `-1` must mean backwards! Let's try it on a snare. First, play it back at the normal rate:
nl: Ik weet zeker dat velen nu gaan denken... "wat als we nu eens een negatieve waarde gebruiken voor de `rate:`?" Goeie vraag! Als `1`de normale snelheid is en ´2´dubbele snelheid en waarbij `0,5` de halve snelheid is, dan moet `-1`achterwaarts  zijn! Laten we dit met een snare uitproberen. Laten we deze eerst op normale snelheid afspelen:

en: Now, play it backwards:
nl: Cool! Het speelt achterstevoren:

en: Of course, you can play it backwards twice as fast with a rate of `-2` or backwards at half speed with a rate of `-0.5`. Now, play around with different negative rates and have fun. It's particularly amusing with the `:misc_burp` sample!
nl: Natuurlijk kan je ook achterwaarts dubbel zo snel met een waarde van `-2` of achterwaarts op halve snelheid met `-0,5`. Speel nu even met verschillende negatieve waarden en amuseer je hiermee. Het is bijzonder grappig met de `:misc_burp` sample!

en: One of the effects of rate modification on samples is that faster rates result in the sample sounding higher in pitch and slower rates result in the sample sounding lower in pitch. Another place you may have heard this effect in every day life is when you're cycling or driving past a beeping pedestrian crossing - as you're heading towards the sound source the pitch is higher than when you're moving away from the sound - the so-called Doppler effect. Why is this?
nl: Een van de effecten van het modificeren van de snelheid van samples, is dat bij hogere snelheden de klank hoger klinkt en bij trage snelheid lager. In het alledaagse leven hebt je misschien ook al eens opgemerkt dat wanneer een ziekenwagen voorbij rijd, als deze aankmt gereden zal de sirene hoger klinken dan wanneer deze voorbij is gereden- het zogenaamde Doppler effect. Waarom gebeurd dit?

en: Let's consider a simple beep which is represented by a sine wave. If we use an oscilloscope to plot a beep, we'll see something like Figure A. If we plot a beep an octave higher, we'll see Figure B and an octave lower will look like Figure C. Notice that the waves of higher notes are more compact and the waves of lower notes are more spread out.
nl: Laten we even een simpele biep nemen die wordt vertegenwoordigd door een sinusgolf. Als we een oscilloscoop gebruiken om de grafische weergave van deze biep te kunnen zien krijgen we zoiets als Figuur B en bij een octaaf lager zien we zoiets als Figuur C. Merk op dat de golven van hogere noten compacter zijn en dat de golven van lagere noten meer uitgespreid zijn.

en: A sample of a beep is nothing more than a lot of numbers (x, y, coordinates) which when plotted onto a graph will re-draw the original curves. See figure D where each circle represents a coordinate. To turn the coordinates back into audio, the computer works through each x value and sends the corresponding y value to the speakers. The trick here is that the rate at which the computer works through the x numbers does not have to be the same as the rate with which they were recorded. In other words, the space (representing an amount of time) between each circle can be stretched or compressed. So, if the computer walks through the x values faster than the original rate, it will have the effect of squashing the circles closer together which will result in a higher sounding beep. It will also make the beep shorter as we will work through all the circles faster. This is shown in Figure E.
nl: Een sample van een pieptoon is niets meer dan een heleboel cijfers (x, y, coördinaten) die wanneer ze uitgezet worden op een grafiek hun oorspronkelijke curven laten zien. Zie figuur D waarbij elke cirkel een coördinaat vertegenwoordigd. Om de coördinaten terug om te zetten in geluid, zet de computer elke x-waarde en de bijbehorende waarde van y naar de luidsprekers om. De truc hier is dat de afspeelsnelheid waarmee de computer zich door de x-nummers werkt niet dezelfde moet zijn als de snelheid waarmee zij werden geregistreerd. Met andere woorden, kan de ruimte (die de tijd vertegenwoordigen) tussen elke cirkel worden uitgerekt of samengedrukt. Dus, als de computer de x-waarden sneller dan het oorspronkelijke snelheid doorloopt, zal het het effect van het samendrukken van de cirkels in een hogere klinkende pieptoon resulteren. Het maakt ook de pieptoon korter maken gezien we sneller door de cirkels lopen. Dit wordt getoond in figuur E.

en: Finally, one last thing to know is that a mathematician called Fourier proved that any sound is actually lots and lots of sine waves all combined together. Therefore, when we compress and stretch any recorded sound we're actually stretching and compressing many sine waves all at the same time in exactly this manner.
nl: Tot slot, interessant om weten is dat, een wiskundige genaamd Fourier bewees dat elk geluid eigenlijk bestaat uit heel veel sinusgolven. Daarom, als we een opgenomen geluid comprimeren , rekken we vele sinusgolven allemaal op hetzelfde moment op precies deze manier uit.

en: As we've seen, using a faster rate will make the sound higher in pitch and a slower rate will make the sound lower in pitch. A very simple and useful trick is to know that doubling the rate actually results in the pitch being an octave higher and inversely halving the rate results in the pitch being an octave lower. This means that for melodic samples, playing it alongside itself at double/half rates actually sounds rather nice:
nl: Zoals we hebben gezien, zal met een sneller tempo het geluid hoger in toonhoogte, en een trager tempo zal het geluid lager in toonhoogte zijn. Een zeer eenvoudige en nuttige truc is om te weten dat een verdubbeling van de rate waarde, eigenlijk resulteert in een toonhoogte van een octaaf hoger wordt en omgekeerd de halvering van de rate waarde resulteren in een toonhoogte van een octaaf lager. Dit betekent dat voor melodische samples, het naast elkaar afspelen op het dubbel/helft van de rate waarde, deze eigenlijk vrij mooi klinken:

en: However, what if we just want to alter the rate such that the pitch goes up one semitone (one note up on a piano)? Sonic Pi makes this very easy via the `rpitch:` opt:
nl: Maar, wat als we gewoon het tempo willen veranderen zodat de toonhoogte stijgt met een halve toon (één noot hoger op een piano)? Sonic Pi maakt dit zeer eenvoudig via de ' rpitch:' optie:

en: If you take a look at the log on the right, you'll notice that an `rpitch:` of `3` actually corresponds to a rate of `1.1892` and a `rpitch:` of `7` corresponds to a rate of `1.4983`. Finally, we can even combine `rate:` and `rpitch:` opts:
nl: Als je een kijkje neemt op het log aan de rechterkant, zal je merken dat een ' rpitch:' van '3' overeenkomt met een snelheid van '1.1892' en een ' rpitch:' van '7' overeenkomt met een snelheid van '1.4983'. Tot slot kunnen we zelfs de ' rate:' en ' rpitch:' optie combineren:

en: Let's take a look at a simple piece which combines these ideas. Copy it into an empty Sonic Pi buffer, hit play, listen to it for a while and then use it as a starting point for your own piece. See how much fun it is to manipulate the playback rate of samples. As an added exercise try recording your own sounds and play around with the rate to see what crazy sounds you can make.
nl: Laat ons even kijken naar een eenvoudig stukje waarbij deze ideeën gecombineerd worden  . Kopieer deze naar een lege Sonic Pi buffer en klik op afspelen, luister even en gebruik deze dan als uitgangspunt voor je eigen stuk muziek. Merk hoe leuk het is om de snelheid van het afspelen van samples te manipuleren. Als extra oefening probeer je je eigen geluiden op te nemen en speel met de rate waarden om te zien wat voor gekke geluiden je hiermee kan maken.

en: A.18 Sound Design - Additive Synthesis
nl: A.18 Sound Design - Additieve Synthese

en: Additive Synthesis
nl: Additieve Synthese

en: Simple Combinations
nl: Eenvoudige combinaties

en: Let's start with the most basic sound there is - the humble pure-toned sine wave:
nl: Laten we beginnen met het meest elementaire geluid dat er is - de eenvoudige zuiver gestemde sinus golf:

en: Now, let's see how this sounds combined with a square wave:
nl: Laten we eens kijken hoe dit klinkt gecombineerd met een blokgolf:

en: Notice how the two sounds combine to form a new, richer sound. Of course, we don't have to stop there, we can add as many sounds as we need. However, we need to be careful with how many sounds we add together. Just like when we mix paints to create new colours, adding too many colours will result in a messy brown, similarly - adding too many sounds together will result in a muddy sound.
nl: Merk op hoe deze twee geluiden combineren tot een nieuwe, rijker geluid. Natuurlijk, hoeven we hier nog niet te stoppen, we kunnen zoveel geluiden we willen toevoegen. We moeten echter wel voorzichtig zijn hoe veel geluiden we bij elkaar gaan optellen. Net zoals wanneer we verf maken om  nieuwe kleuren te mengen, het toevoegen van dat beetje teveel kleur zal resulteren in bijvoorbeeld een rommelig bruin, evenzo - zal het toevoegen van te veel geluiden resulteren in een modderig geluid.

en: Blending
nl: Mengen

en: Let's add something to make it sound a little brighter. We could use a triangle wave at an octave higher (for that high bright sound) yet only play it at amp `0.4` so it adds something extra to the sound rather than taking it over:
nl: Laten we iets toevoegen om het geluid een beetje helderder te maken. We zouden een driehoeksgolf kunnen gebruiken van een octaaf hoger (voor dat hoge heldere geluid) voorlopig op amp '0.4' afgesteld om iets extra's toe te voegen aan het geluid, zo dat dit geluid het niet overheerst:

en: Now, try creating your own sounds by combining 2 or more synths at different octaves and amplitudes. Also, note that you can play around with each synth's opts to modify each source sound before it is mixed in for even more combinations of sounds.
nl: Nu, probeer je eigen geluid te creëren door een combinatie van 2 of meer synths op verschillende octaven en amplitudes. Merk ook op dat je met elke synth kunt spelen en elk brongeluid afzonderlijk kan worden gewijzigd voordat het wordt gemengd in nog meer combinaties van geluiden.

en: Detuning
nl: Detuning (Ontstemmen)

en: So far, when combining our different synths we've used either the same pitch or switched octave. How might it sound if we didn't stick to octaves but instead chose a slightly higher or lower note? Let's try it:
nl: Tot nu toe hebben we bij het combineren van onze verschillende synthesizers dezelfde toonhoogte gebruikt of zijn we naar een andere octave overgestapt. Hoe zou het misschien klinken als wij ons niet aan octaven vasthouden, maar in plaats daarvan voor een iets hogere of lagere noot zouden kiezen? Laten we dit proberen:

en: If we detune our square waves by 0.7 notes we hear something that perhaps doesn't sound in tune or correct - a 'bad' note. However, as we move closer to 0 it will sound less and less out of tune as the pitches of the two waves get closer and more similar. Try it for yourself! Change the `detune:` opt value from `0.7` to `0.5` and listen to the new sound. Try `0.2`, `0.1`, `0.05`, `0`. Each time you change the value, take a listen and see if you can hear how the sound is changing. Notice that low detune values such as `0.1` produce a really nice 'thick' sound, with both slightly different pitches interacting with each other in interesting, often surprising, ways.
nl: Als we onze blokgolf met een 0.7 noot ontstemmen, klinkt dit misschien vals of niet in harmonie. Hoe dichter bij de 0 plaats je het geluid minder uit toon gezien de toon van de golven meer en meer met elkaar gaan samenvallen. Probeer dit zelf maar eens uit! Verander de waarde van de `detune:` opt van `0.7` naar `0.5`en luister hoe het geluid hierbij veranderen kan. Merk op dat lage ontstemde noten zoals bij `0.1`een heel fijn 'vet' geluid produceren en waarbij de lichtjes verschillende toonhoogten op een interessante wijze met elkaar een wisselwerking aangaan, dikwijls op zeer verrassende wijze .

en: Amplitude shaping
nl: Amplitude vormgeven

en: Another way we can finely craft our sound is to use a different envelope and options for each synth trigger. For example this will allow you to make some aspects of the sound percussive and other aspects ring out for a period of time.
nl: We kunnen ons geluid ook nog op een andere manier bijschaven door voor elke synth een andere envelope te gebruiken. Deze laten jou toe om sommige elementen van het geluid percussief te laten klinken terwijl we andere elementen langer kunnen laten naklinken.

en: In the example above I have mixed in a noisy percussive element to the sound along with some more persistent background rumbling. This was achieved firstly by using two noise synths with middling cutoff values (`90` and `100`) using short release times along with a noise with a longer release time but with a low cutoff value (which makes the noise less crisp and more rumbly.)
nl: In het bovenstaande voorbeeld heb ik lawaaierige percussieve elementen gemixt met een meer aanhoudend achtergrond gerommel. Dit werd bereikt door twee noise synth's met een middelmatige cutoff waarde (`90`en `100`) door gebruik te maken van korte release-tijd waarden, samen met een ruis die een langere release-tijd heeft, met een lagere cutoff waarde (om het geluid minder scherp en meer rommelend te maken.)

en: Let's combine all these techniques to see if we can use additive synthesis to re-create a basic bell sound. I've broken this example into four sections. Firstly we have the 'hit' section which is the initial onset part of the bell sound - so uses a short envelope (e.g. a `release:` of around `0.1`). Next we have the long ringing section in which I'm using the pure sound of the sine wave. Notice that I'm often increasing the note by roughly `12` and `24` which are the number of notes in one and two octaves. I have also thrown in a couple of low sine waves to give the sound some bass and depth. Finally, I used `define` to wrap my code in a function which I can then use to play a melody. Try playing your own melody and also messing around with the contents of the `:bell` function until you create your own crazy sound to play with!
nl: Laten we deze technieken combineren om te zien of we gebruik kunnen  maken van additieve synthese om een elementair bel geluid te re-creëren . Ik heb dit voorbeeld opgedeeld in vier secties. Als eerste hebben we het 'aanslag'-gedeelte, die het begin uitmaakt van onze bel klank - en dus gebruik maakt van een korte envelop (bijv. een `release:` van rondom `0.1`). Vervolgens hebben we het lange ring gedeelte waarin ik het pure  geluid van de sinusgolf gebruik . Merk op dat ik vaak het verhogen van een noot toepas, met ongeveer `12` en `24`, dat het aantal noten met één a twee octaven verhoogd. Ik heb er ook een paar lage sinus golven aan toegevoegd die het geluid wat bas en diepte geeft. Tot slot, gebruik ik `define` om mijn code in een functie te wikkelen, die ik dan kan gebruiken om een melodie af te spelen. Probeer je eigen melodie uit en speel ook met de inhoud van de `:bell` functie totdat je je eigen leuk geluid hebt om mee te spelen!

en: A.19 Sound Design - Subtractive Synthesis
nl: A. 19 Sound Design - Subtractieve Synthese

en: Subtractive Synthesis
nl: Subtractieve synthese

en: This is the second in a series of articles on how to use Sonic Pi for sound design. Last month we looked at additive synthesis which we discovered was the simple act of playing multiple sounds at the same time to make a new combined sound. For example we could combine different sounding synths or even the same synth at different pitches to build a new complex sound from simple ingredients. This month we'll look at a new technique commonly called *subtractive synthesis* which is simply the act of taking an existing complex sound and removing parts of it to create something new. This is a technique which is commonly associated with the sound of analog synthesisers of the 1960s and 1970s but also with the recent renaissance of modular analog synths through popular standards such as Eurorack.
nl: Dit is het tweede in een serie artikelen over het gebruik van Sonic Pi in sound design. Vorige maand hebben we gekeken naar additieve synthese waar we met eenvoudige handelingen, met het tegelijkertijd afspelen van meerdere geluiden, kunnen zorgen voor een nieuw gecombineerde geluid. We kunnen bijvoorbeeld verschillend klinkende synths of zelfs dezelfde synth op verschillende toonhoogten gebruiken om een nieuw complex geluid op te bouwen met eenvoudige ingrediënten. Deze maand nemen we een kijkje naar een nieuwe techniek die in de volksmond *subtractieve synthese* wordt genoemd, wat gewoon het nemen van een bestaand complex geluid is en deze ontdoen van bepaalde onderdelen, om er iets nieuws van te maken . Dit is een techniek die meestal wordt geassocieerd met het geluid van analoge synthesizers uit de jaren 1960 en 1970, maar ook bekend is door de recente opleving van modulaire analoge synths via populaire nieuwe standaarden zoals bijvoorbeeld Eurorack.

en: Despite this sounding like a particularly complicated and advanced technique, Sonic Pi makes it surprisingly simple and easy - so let's dive right in.
nl: Ondanks dat dit klinkt als een bijzonder ingewikkelde en geavanceerde techniek, maakt Sonic Pi het je verrassend simpel en eenvoudig, we beginnen er gelijk mee.

en: Complex Source Signal
nl: Complex Bron Signaal

en: For a sound to work well with subtractive synthesis, it typically needs to be fairly rich and interesting. This doesn't mean we need something hugely complex - in fact, just a standard `:square` or `:saw` wave will do:
nl: Om een geluid goed met subtractieve synthese te laten werken, moet deze meestal vrij rijk en interessant op zich klinken. Dat betekent niet dat deze ongelofelijk complex hoeft te zijn, in feite zullen een typische `:square` of`:saw`golf volstaan:

en: Notice that this sound is already pretty interesting and contains many different frequencies above `:e2` (the second E on a piano) which add to create the timbre. If that didn't make much sense to you, try comparing it with the `:beep`:
nl: Merk hier op dat dit geluid al vrij interessant is en veel verschillende frequenties boven `:e2` (de tweede E op een piano) bevat, die aan toevoeging doen aan het maken van de klankkleur. Als dat nog niet veel duidelijk maakt, probeer dit te vergelijken met de `:beep`toon:

en: As the `:beep` synth is just a sine wave, you'll hear a much purer tone and only at `:e2` and none of the high crispy/buzzy sounds which you heard in the `:saw`. It's this buzziness and variation from a pure sine wave that we can play with when we use subtractive synthesis.
nl: Vermits de `:beep` synth een eenvoudige sinusgolf is, zal je een meer zuivere toon horen op `:e2` en geen van de meer knapperige/zoemende geluiden die je met `:saw`hoorde. Het is dit bezige, variërende geluid van de sinus golf, die we kunnen gaan gebruiken voor subtractieve synthese.

en: Once we have our raw source signal, the next step is to pass it through a filter of some kind which will modify the sound by removing or reducing parts of it. One of the most common filters used for subtractive synthesis is something called a low pass filter. This will allow all the low parts of the sound through but will reduce or remove the higher parts. Sonic Pi has a powerful yet simple to use FX system that includes a low pass filter, called `:lpf`. Let's play with it:
nl: Eens we ons eerste rauwe geluid hebben gevonden, is onze volgende stap deze door een filter te sturen, die delen van het geluid wegneemt of vermindert. Een van de meest gebruikte filters bij subtractieve synthese is de zogenaamde low pass filter. Deze laat alle lage tonen van het geluid door, maar zal de hogere frequenties reduceren of weglaten. Sonic Pi heeft een krachtig maar makkelijk te gebruiken FX systeem waar een low pass filter inzit, namelijk de `:lpf`. Laten we hiermee even spelen:

en: If you listen carefully you'll hear how some of that buzziness and crispiness has been removed. In fact, all the frequencies in the sound above note `100` have been reduced or removed and only the ones below are still present in the sound. Try changing that `cutoff:` point to lower notes, say `70` and then `50` and compare the sounds.
nl: Als je goed luistert zal je horen dat wat geroezemoes en knapperigheid verwijderd is. In feite zijn alle frequenties in het geluid boven `100`gereduceerd of weggenomen en zijn enkel de frequenties daaronder aanwezig in het geluid. Probeer een `cutoff:` te vinden om noten te verlagen met bijvoorbeeld `70` en dan naar `50` en vergelijk dan deze klank.

en: Of course, the `:lpf` isn't the only filter you can use to manipulate the source signal. Another important FX is the high pass filter referred to as `:hpf` in Sonic Pi. This does the opposite to `:lpf` in that it lets the high parts of the sound through and cuts off the low parts.
nl: Uiteraard is de `:lpf` niet de enige filter die je kan gebruiken om een inkomend signaal te bewerken. Een andere belangrijke FX is de high pass filter aangeduid als `:hpf` in Sonic Pi.  Dit doet het tegenovergestelde  van`:lpf` waar die de hoge delen van het geluid doorlaat en/of  afsnijdt, doet deze dat voor de lage delen.

en: Notice how this sounds much more buzzy and raspy now that all the low frequency sounds have been removed. Play around with the cutoff value - notice how lower values let more of the original bass parts of the source signal through and higher values sound increasingly tinny and quiet.
nl: Merk op dat het geluid nu drukker en rasperig is nu alle lage frequenties weggenomen zijn. Speel maar even met de cutoff waarden en merk op dat lagere waarden meer van de originele basstonen doorlaten en bij hogere waarden, het geluid dunner en stiller wordt.

en: The low pass filter is such an important part of every subtractive synthesis toolkit that it's worth taking a deeper look at how it works. This diagram shows the same sound wave (the `:prophet` synth) with varying amounts of filtering. At the top, section A shows the audio wave with no filtering. Notice how the wave form is very pointy and contains lots of sharp edges. It is these hard, sharp angles that produce the high crispy/buzzy parts of the sound. Section B shows the low pass filter in action - notice how it is less pointy and more rounded than the wave form above. This means that the sound will have fewer high frequencies giving it a more mellow rounded feel. Section C shows the low pass filter with a fairly low cutoff value - this means that even more of the high frequencies have been removed from the signal resulting in an even softer, rounder wave form. Finally, notice how the size of the wave form, which represents the amplitude, decreases as we move from A to C. Subtractive synthesis works by removing parts of the signal which means that the overall amplitude is reduced as the amount of filtering that is taking place increases.
nl: Het low-pass filter is zo'n belangrijk onderdeel in elke gereedschapskist van de subtractieve synthese, dat het moeite waard is iets dieper in te gaan op hoe het werkt. Dit diagram toont dezelfde geluidsgolf (de ': prophet ' synth) met verscheidene filter hoeveelheden . Aan de top toont deel A de audiogolf zonder filtering. Merk op hoe de golfvorm erg puntig is en veel scherpe randen bevat. Het zijn deze harde, scherpe hoeken die de hoge scherpe delen van het geluid produceren. Sectie B toont het low-pass filter in actie - merk hoe deze minder puntige en meer afgerond heeft, dan de golfvorm hierboven. Dit betekent dat het geluid minder hoge frequenties heeft, waardoor het een meer zacht afgerond aanvoelt . Sectie C toont de low-pass filter met een vrij lage grenswaarde - dit betekent dat zelfs nog meer van de hoge frequenties zijn verwijderd uit het signaal wat resulteert in een nog zachtere, ronder golfvorm. Tot slot merk je hoe de vorm van de golf, die de amplitude vertegenwoordigt, afneemt als we van A naar C gaan. Subtractieve synthese werkt door het verwijderen van delen van het signaal en betekent dus dat de totale amplitude wordt verminderd door de waarde van de filter die verhoogt.

en: Filter Modulation
nl: Filter Modulatie

en: So far we've just produced fairly static sounds. In other words, the sound doesn't change in any way for the entirety of its duration. Often you might want some movement in the sound to give the timbre some life. One way to achieve this is via filter modulation - changing the filter's options through time. Luckily Sonic Pi gives you powerful tools to manipulate an FX's opts through time. For example, you can set a slide time to each modulatable opt to specify how long it should take for the current value to linearly slide to the target value:
nl: Tot nu toe klonk ons geluid vrij statisch. Met andere woorden, het geluid verandert op geen enkele manier gedurende zijn gehele duurtijd. Vaak zal je wat beweging in je geluid willen, om wat leven in het timbre te brengen. Een van de manieren om dit te bewerkstelligen is met filtermodulatie, d.w.z. het veranderen van de filter opties gedurende een bepaalde tijd. Sonic Pi heeft gelukkig een krachtig instrument om de FX opt's, tijdsgebonden te manipuleren. Je kan bijvoorbeeld voor elke moduleerbare opt een bepaalde tijd opgeven, hoe traag of hoe snel deze van een bepaalde waarde, naar de vooropgestelde waarde verschuift:

en: Let's take a quick look at what's going on here. Firstly we start an `:lpf` FX block as normal with an initial `cutoff:` of a very low `20`. However, the first line also finishes with the strange `|fx|` at the end. This is an optional part of the `with_fx` syntax which allows you to directly name and control the running FX synth. Line 2 does exactly this and controls the FX to set the `cutoff_slide:` opt to 4 and the new target `cutoff:` to be `130`. The FX will now start sliding the `cutoff:` opt's value from `50` to `130` over a period of 3 beats. Finally we also trigger a source signal synth so we can hear the effect of the modulated low pass filter.
nl: Laat ons even kijken naar wat hier gebeurt. Eerst starten we een `:lpf` FX blok met een initiële `cutoff:` zeer laag op`20`. De eerste regel heeft evenwel een mysterieuze `|fx|` op het einde.  Dit is een optioneel onderdeel van de  `with_fx` syntax wat ons in staat stelt om een naam te geven aan de lopende FX synth, en deze te manipuleren. Dat is precies wat regel 2 doet, namelijk de `cutoff_slide:` opt naar 4 zetten, en de uiteindelijke `cutoff:` naar `130` te brengen. Het FX zal de `cutoff:` opt's waarde van `50` naar `130` schuiven, over een periode van 3 tellen. Ten slotte triggeren we een synth, die als bron door deze low pass filter wordt gestuurd.

en: This is just a very basic taster of what's possible when you use filters to modify and change a source sound. Try playing with Sonic Pi's many built-in FX to see what crazy sounds you can design. If your sound feels too static, remember you can start modulating the options to create some movement.
nl: Dit is slechts een zeer basic voorproefje van wat mogelijk is als je filters gebruikt om een geluidsbron te wijzigen. Probeer in Sonic Pi met de vele ingebouwde FX te spelen, om te zien wat een gekke geluiden je hiermee kan ontwerpen. Als je geluid te statisch aanvoelt , vergeet niet dat je  de opties kan moduleren om bewegingen aan te brengen.

en: Let's finish by designing a function which will play a new sound created with subtractive synthesis. See if you can figure out what's going on here - and for the advanced Sonic Pi readers out there - see if you can work out why I wrapped everything inside a call to `at` (please send answers to @samaaron on Twitter).
nl: Laten we eindigen, met het ontwerpen van een functie die een nieuw geluid maakt met subtractieve synthese. Zie of je kan achterhalen wat hier aan de hand is - en voor de gevorderde Sonic Pi lezers: - kijk of je kunt vinden waarom ik alles in de oproep verpak naar `at` (stuur de antwoorden naar @samaaron op Twitter).

en: B Essential Knowledge
nl: B Essentiële kennis

en: Essential Knowledge
nl: Essentiële Kennis

en: This section will cover some very useful - in fact *essential* - knowledge for getting the most out of your Sonic Pi experience.
nl: Deze sectie gaat over nuttige - in feite *essentiële* - kennis om het meeste uit Sonic Pi te halen.

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.
nl: We gaan het hebben over, hoe profijt te halen uit de vele beschikbare sneltoetsen, hoe jouw werk te delen en wat tips hoe met Sonic Pi op te treden.

en: B.1 Using Shortcuts
nl: B.1 Sneltoetsen gebruiken

en: Using Shortcuts
nl: Sneltoetsen gebruiken

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.
nl: Sonic Pi is evengoed een instrument als een coderingsomgeving. Sneltoetsen kunen daarom het bespelen van Sonic Pi *efficienter en natuurijker* maken- zeker als je live voor publijk speelt.

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!
nl: Veel van Sonic Pi kan worden bestuurd via het toetsenbord. Als je meer vertrouwd raakt met Sonic Pi, zult je de sneltoetsen waarschijnlijk meer en meer beginnen gebruiken. *Ik persoonlijk touch-type* (ik adviseer je te overwegen om dit te leren) ik vind het frustrerend wanneer ik het nodig vind de muis te gebruiken. Ik gebruik deze shortcuts dus zeer regelmatig!

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.
nl: Daarom, als je de shortcuts leert, leer je je toetsenbord efficienter te gebruiken en je zal in geen tijd live coderen als een pro.

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.
nl: Maar probeer ze niet allemaal tegelijkertijd uit te proberen te leren, enkel die je het meest gebruikt en ze langzaam meer en meer in de praktijk toe te voegen.

en: Consistency across Platforms
nl: Samenhang tussen Platforms

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.
nl: Stel dat je een klarinet leert bespelen. Je verwachten dan toch dat alle klarinetten van de verschillende merken vergelijkbare controles en vingergrepen  zouden hebben. Als dat niet zo was, zou je een moeilijke tijd hebben om tussen de verschillende klarinetten te kunnen schakelen en je zou vasthangen aan het gebruik van slechts één merk.

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.
nl: Helaas zijn de drie belangrijkste besturingssystemen (Linux, Mac OS X en Windows) zijn voorzien van hun eigen standaardwaarden voor acties zoals het knippen en plakken enz. Sonic Pi zal proberen deze normen te respecteren. Deze is echter *de prioriteit is geplaatst op de consistentie tussen de platformen* binnen Sonic Pi, in plaats te proberen om te voldoen aan de norm van een bepaald platform. Dit betekent dat als je Sonic pi's shortcuts leert spelen op je Raspberry Pi, je naar Mac of PC kan overschakelen en je thuis voelen.

en: Control and Meta
nl: Controle en 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.
nl: Het concept van consistentie zit ook in de benaming van de shortcuts. In Sonic Pi gebruiken we de namen *Control* en *Meta*  om te verwijzen naar de twee belangrijkste combinatie toetsen. Bij alle platformen is *Control* hetzelfde.Maar op Linux en Windows is *Meta* eigenlijk de *Alt* toets is, terwijl *Meta* op Mac de *Command* toets is. Voor de samenhang zullen we de term *Meta* gebruiken - vergeet dit niet naar je besturingsysteem over te zetten.

en: Abbreviations
nl: Afkortingen

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."
nl: Om de zaken eenvoudig en leesbaar te houden, gebruiken we de afkorting *C-* voor *Control* plus andere toets en *M-* voor *Meta* plus andere toets.
    Een voorbeeld: als je bij een shortcut zowel *Meta* als *r* moet indrukken schrijven we dit als `M-r`. En de *-* betekent dan "tegelijk."

en: The following are some of the shortcuts I find most useful.
nl: Enkele van de sneltoetsen die ik het meest nuttig vind.

en: Stopping and starting
nl: Stoppen en starten

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`.
nl: In plaats van altijd de muis te gebruiken je code te gaan uit voeren, kan je simpelweg op `M-r` drukken. Om het uitvoeren van je code te stoppen kan je `M-s` gebruiken.

en: Navigation
nl: Navigatie

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.
nl: Zonder de navigatie sneltoetsen ben ik echt verloren. Daarom adviseer ik je hieraan wat tijd te besteden. Deze sneltoetsen werken ook extreem goed wanneer je blind hebt leren typen vermits zij ook gebruik maken van de standaard letters in plaats van waarvoor u uw hand naar de muis of naar de pijltoetsen op uw toetsenbord moet gaan 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`.
nl: Je kan naar het begin van een lijn gaan met`C-a`, naar het einde van de lijn met `C-e`, een lijn omhoog met `C-p`, een lijn naar beneden met `C-n`, een karakter naar voor met `C-f, een karakter teruggaan is `C-b`. Je kan zelfs alle karakters wissen vanaf de cursor tot het einde van de zin met `C-k`.

en: Tidy Code
nl: Nette Code

en: To auto-align your code simply press `M-m`.
nl: Voor het automatisch uitlijnen van jouw code druk `M-m`.

en: Help System
nl: Help-systeem

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!
nl: Om het help-systeem in te schakelen kan je `M-i` indrukken. Een nog veel nuttiger sneltoets om te kennen is `C-i`die het woor dat zich onder de cursor bevindt opzoekt en alle docs die hierover gevonden wordt zal tonen. Instant hulp!

en: For a full list take a look at section 10.2 Shortcut Cheatsheet.
nl: Voor een volledige lijst kijk je naar punt 10.2 Shortcut Cheatsheet.

en: B.2 Shortcut Cheatsheet
nl: B.2 Sneltoetsen spiekbrief

en: The following is a summary of the main shortcuts available within Sonic Pi. Please see Section 10.1 for motivation and background.
nl: Het volgende is een samenvatting van de belangrijkste sneltoetsen die beschikbaar zijn in Sonic Pi. Zie sectie 10.1 voor motivatie en achtergrond.

en: Conventions
nl: Conventies

en: In this list, we use the following conventions (where *Meta* is one of *Alt* on Windows/Linux or *Cmd* on Mac):
nl: In deze lijst, gebruiken we de volgende conventies (waar *Meta* staat is dit  *Alt* op Windows/Linux en *Cmd* op Mac):

en: `C-a` means hold the *Control* key then press the *a* key whilst holding them both at the same time, then releasing.
nl: `C-a` betekend hou de *Control* toets en de *a* toets tegelijkertijd in, laat dan los.

en: `M-r` means hold the *Meta* key and then press the *r* key whilst holding them both at the same time, then releasing.
nl: `M-r`betekent hou de *Meta* toets en druk dan de *r* toets tegelijkertijd in, laat dan los.

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.
nl: `S-M-z` betekent hou de *Shift* toets, dan de *Meta* toets, en tenslotte de *z* toets tegelijkertijd allemaal in en laat dan los.

en: `C-M-f` means hold the *Control* key, then press *Meta* key, finally the *f* key all at the same time, then releasing.
nl: `C-M-f` betekent hou de *Control* toets, dan de *Meta* en tenslotte de *f* toets allemaal tegelijkertijd in, en dan los deze dan.

en: Main Application Manipulation
nl: Belangrijkste Applicatie Manipulatie

en: `M-r` - Run code
nl: `M-r` - code afspelen

en: `M-i` - Toggle Help System
nl: `M-i` - Help Systeem Schakelaar

en: `M-p` - Toggle Preferences
nl: `M-p` - Voorkeursinstellingen Aan/Uit

en: `M-{` - Switch buffer to the left
nl: `M-{` - Buffer naar links omwisselen

en: `M-}` - Switch buffer to the right
nl: `M-}` - Buffer naar links omwisselen

en: `M-+` - Increase text size of current buffer
nl: `M-+` - Vergroot de tekstgrootte van de huidige buffer

en: `M--` - Decrease text size of current buffer
nl: `M--` - Verkleint de tekstgrootte van de huidige buffer

en: Selection/Copy/Paste
nl: Selectie/Kopiëren/Plakken

en: `M-a` - Select all
nl: `M-a` - Selecteer alles

en: `M-c` - Copy selection to paste buffer
nl: `M-c` - kopieer selectie om buffer te plakken

en: `M-]` - Copy selection to paste buffer
nl: `M-]` - Kopieer selectie om buffer te plakken

en: `M-x` - Cut selection to paste buffer
nl: `M-x` - Knip selectie om buffer te plakken

en: `C-]` - Cut selection to paste buffer
nl: `C-]` - Knip selectie om buffer te plakken

en: `C-k` - Cut to the end of the line
nl: `C-k` - Knip tot het einde van de lijn

en: `M-v` - Paste from paste buffer to editor
nl: `M-v` - Plak naar editor vanaf plak buffer

en: `C-y` - Paste from paste buffer to editor
nl: `C-y` - Plak naar editor vanaf plak buffer

en: `C-SPACE` - Set mark. Navigation will now manipulate highlighted region. Use `C-g` to escape.
nl: `C-SPACE` - Zet markering. Navigatie zal nu gemarkeerd gebied manipuleren. Gebruik `C-g` om te verlaten.

en: Text Manipulation
nl: Bewerken van tekst

en: `M-m` - Align all text
nl: `M-m` - Alle tekst uitlijnen

en: `Tab` - Align current line or selection (or select autocompletion)
nl: `Tab` - Huidige lijn uitlijnen of selectie (of selecteer automatisch aanvullen)

en: `C-l` - Centre editor
nl: `C-l` - Editor Centreren

en: `M-/` - Comment/Uncomment current line or selection
nl: `M-/` - Comment/Uncomment huidige lijn of selectie

en: `C-t` - Transpose/swap characters
nl: `C-t` - Karakters omzetten/ruilen

en: `M-u` - Convert next word (or selection) to upper case.
nl: `M-u` - Volgende woord (of selectie) omzetten in hoofdletters.

en: `M-l` - Convert next word (or selection) to lower case.
nl: `M-l` - -Volgende woord (of selectie) omzetten in kleine letters.

en: `C-a` - Move to beginning of line
nl: `C-a` - Naar het begin van de lijn

en: `C-e` - Move to end of line
nl: `C-e` -Verplaats naar einde van regel

en: `C-p` - Move to previous line
nl: `C-p` -Verplaatsen naar vorige regel

en: `C-n` - Move to next line
nl: `C-n` - Verplaatsen naar volgende regel

en: `C-f` - Move forward one character
nl: `C-f` -Eén teken naar rechts verplaatsen

en: `C-b` - Move backward one character
nl: `C-b` - Eén teken naar achter verplaatsen

en: `M-f` - Move forward one word
nl: `M-f` - Eén woord naar voor springen

en: `M-b` - Move backward one word
nl: `M-b` -  Eén woord naar achter springen

en: `C-M-n` - Move line or selection down
nl: `C-M-n` -Zet lijn of selectie naar beneden

en: `C-M-p` - Move line or selection up
nl: `C-M-p` - Zet lijn of selectie naar boven

en: `S-M-u` - Move up 10 lines
nl: `S-M-u` - 10 lijnen naar boven gaan

en: `S-M-d` - Move down 10 lines
nl: `S-M-d` - 10 lijnen naar beneden gaan

en: `M-<` - Move to beginning of buffer
nl: `M-<` - Naar het begin van de buffer gaan

en: `M->` - Move to end of buffer
nl: `M->` - Naar het eind van de buffer gaan

en: Deletion
nl: Verwijdering

en: `C-h` - Delete previous character
nl: `C-h` - Vorige teken verwijderen

en: `C-d` - Delete next character
nl: `C-d` - Volgend teken verwijderen

en: Advanced Editor Features
nl: Geavanceerde Editor Functies

en: `C-i` - Show docs for word under cursor
nl: `C-i` - Toon docs voor het woord onder de cursor

en: `M-z` - Undo
nl: `M-z` - Ongedaan maken

en: `S-M-z` - Redo
nl: `S-M-z` - Opnieuw maken

en: `C-g` - Escape
nl: `C-g` - Verlaten

en: `S-M-f` - Toggle fullscreen mode
nl: `S-M-f` - Tussen Fullscreen modus schakelen

en: `S-M-b` - Toggle visibility of buttons
nl: `S-M-b`- Zichtbaarheid van knoppen in-/uitschakelen

en: `S-M-l` - Toggle visibility of log
nl: `S-M-l` - Zichtbaarheid van log in-/uitschakelen

en: `S-M-m` - Toggle between light/dark modes
nl: `S-M-m` - Tussen licht/donker modus schakelen

en: `S-M-s` - Save contents of buffer to a file
nl: `S-M-s` - Inhoud van de buffer als een bestand opslaan

en: `S-M-o` - Load contents of buffer from a file
nl: `S-M-o` - Inhoud van buffer vanuit een bestand laden

en: B.3 Sharing
nl: B.3 Delen

en: Sharing
nl: Delen

en: Sonic Pi is all about sharing and learning with each other.
nl: Sonic Pi gaat helemaal over het delen en leren met elkaar.

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*.
nl: Zodra je geleerd hebt hoe je muziek codeert, is het delen van uw composities zo eenvoudig als het verzenden van een e-mail met jouw code.Deel alsjeblief je code met anderen zodat zij kunnen *leren* van jouw werk en misschien onderdelen te gebruiken in een nieuwe *mash-up*.

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.
nl: Als u niet zeker bent van de manier om je werk met anderen te delen, adviseer ik om je code op [GitHub] (https://github.com) en uw muziek op [SoundCloud] (https://soundcloud.com) te zetten. Op die manier kun je gemakkelijk een groot publiek bereiken .

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.
nl: [GitHub] (https://github.com) is een site om met codete werken en deze te delen. Het wordt gebruikt door professionele ontwikkelaars, maar ook artiesten delen en werken samen aan code. De eenvoudigste manier om een nieuw stuk code te delen (zelfs een onvoltooide stukje) is het creëren van een [Gist] (https://gist.github.com). Een [Gist] (https://gist.github.com) is een eenvoudige manier om  uw code te uploaden van op een zodat anderen deze kunnen zien, kopiëren en delen.

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.
nl: Een andere belangrijke manier om je werk te delen is de audio opnemen en te uploaden naar [SoundCloud] (https://soundcloud.com). Zodra je je stuk geüpload hebt, kunnen andere gebruikers commentaar geven en je werk bespreken . Ik adviseer ook een link te plaatsen van naar een [Gist] (https://gist.github.com) met uw code en daarbij de beschrijving van deze track.

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).
nl: Om je werk op te nemen, sla de`Opname` toets aan in de gereedschapsbalk, en de opname start onmiddellijk. Klik op `Afspelen` om de code te starten als deze nog niet bezig mocht zijn. Als je klaar bent, druk je opnieuw op de knipperende `Opname` knop, en dan kan je een bestandsnaam kiezen. De opname wordt opgeslagen als een WAV-bestand, dat kan worden bewerkt en geconverteerd naar MP3 met eender welk gratis programma (probeer Audacity bijvoorbeeld).

en: Hope
nl: Hoop

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.
nl: Ik moedig je aan om je werk te delen en ik hoop echt dat we van elkaar nieuwe trukjes kunnen leren en met Sonic Pi  verder kunnen evolueren. Ik ben er echt enthousiast om wat jij mij gaat laten zien.

en: B.4 Performing
nl: B.4 Optreden

en: Performing
nl: Optreden

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.
nl: Een van de meest boeiende aspecten van Sonic Pi is dat je code kunt gebruiken als een *muzikaal instrument*. Dit betekent dat het schrijven van live code kan worden gezien als een nieuwe manier om muziek uit te voeren.

en: We call this *Live Coding*.
nl: We noemen dit *Live coderen*.

en: Show Your Screen
nl: Laat je scherm zien

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.
nl: Wanneer je live codeert rad ik je aan om *je scherm te tonen* aan je publiek. Anders ben je je als een gitarist die zijn handen niet laat zien. Wanneer ik thuis oefen gebruik ik een Raspberry Pi en een kleine mini projector gericht op de muur van mijn living. Je zou je TV kunnen gebruiken of een projector van het werk of jouw school om een show te geven. Probeer dit, het is erg leuk.

en: Form a Band
nl: Vorm een 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).
nl: Live coderen is niet nieuw - een kleine groep mensen doen dit al gedurende enkele jaren meestal met behulp van op maat gemaakte systemen die ze voor zichzelf hebben gebouwd. Een goeie plek om meer over deze live coders en hun systemen te weten te komen is  [TOPLAP](http://toplap.org).

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.
nl: Een andere interessante bron om de wereld van live coding te leren kennen is [Algorave](http://algorave.com). Hier kan je alles vinden over de verschillende onderdelen om live te spelen in een nachtclub.

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.
nl: Sonic Pi ondersteunt nu een eenvoudige API voor interactie met Minecraft Pi - de speciale editie van Minecraft is standaard op de Raspberry Pi's (Raspbian's Linux-gebaseerd OS) geïnstalleerd.

en: No need to import libraries
nl: Libraries importeren onnodig

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.
nl: De Minecraft Pi-integratie is ontwikkeld om makkelijk te gebruiken. Al wat je moet te doen is te Minecraft Pi lanceren en een wereld creëren. Dan bent je vrij om `mc_*` fns te gebruiken, net zoals `play` and `synth` . Er is geen behoefte om te bibliotheken te gaan importeren -alles is klaar om te gaan gebruiken.

en: Automatic Connection
nl: Automatische Verbinding

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.
nl: De Minecraft Pi API zorgt voor het beheren van uw verbinding met de Minecraft Pi-toepassing.Geen zorgen dus. Als u probeert  Minecraft Pi API te  gebruiken wanneer Minecraft Pi niet geopend is, zal Sonic Pi je dat vriendelijk vertellen.Ook als u Minecraft Pi sluit terwij ler nog steeds een 'live_loop' speelt, die gebruik maakt van de API, zal de live loop stoppen en je vertellen dat deze geen verbinding kan maken. Als je wil verbinden, lanceer gewoon opnieuw de Minecraft Pi en Sonic Pi zal dan automatisch detecteren en de verbinding voor u opnieuw  maken.

en: Designed to be Live Coded
nl: Ontworpen om Live gecodeerd te worden

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.
nl: De Minecraft Pi API is ontworpen om naadloos te werken binnen ' live_loop. Hierdoor is het mogelijk om wijzigingen in uw Minecraft Pi werelden te synchroniseren met wijzigingen in uw Sonic Pi klanken. Instant Minecraft gebaseerde muziek video's! Merk wel op dat het gaat om Minecraft Pi Alfa software is endus enigszins buggy. Als u problemen hebt, start Minecraft Pi gewoon terug op. Sonic Pi's automatische verbinding functionaliteit zal voor de rest zorgen.

en: Requires a Raspberry Pi 2.0
nl: Een Raspberry Pi 2.0 vereist

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.
nl: Het is sterk aanbevolen een Raspberry Pi 2 te gebruiken als u Sonic Pi en Minecraft samen gebruikt - vooral als je gebruik wilt maken van Sonic Pi's geluids mogelijkheden.

en: API Support
nl: API-ondersteuning

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.
nl: In dit stadium ondersteunt Sonic Pi fundamentele blok en manipulaties van de speler die zijn beschreven in de sectie 11.1. Ondersteuning voor event callbacks getriggerd door interacties met de speler en de rest van de wereld is gepland voor een toekomstige versie.

en: Basic Minecraft Pi API
nl: Basis Minecraft Pi API

en: Sonic Pi currently supports the following basic interactions with Minecraft Pi:
nl: Sonic Pi ondersteunt momenteel de volgende fundamentele interacties met Minecraft Pi:

en: Displaying chat messages
nl: Chatberichten weergeven

en: Setting the position of the user
nl: De plaats van de gebruiker instellen

en: Getting the position of the user
nl: De positie van de gebruiker verkrijgen

en: Setting the block type at a given coordinate
nl: Het bloktype instellen op een bepaalde coördinaat

en: Getting the block type at a given coordinate
nl: Het krijgen van het bloktype bij een bepaalde coördinaat

en: Let's look at each of these in turn.
nl: Laten we deze op hun beurt eens bekijken .

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.
nl: Laten we eens kijken hoe makkelijk het is om Minecraft Pi vanuit  Sonic Pi te controllen. Controleer eerst of u zowel Minecraft Pi en Sonic Pi open hebt staan en ook zorg ervoor dat u een Minecraft wereld hebt ingevoerd en je hier kan in rondlopen.

en: In a fresh Sonic Pi buffer simply enter the following code:
nl: Voer de volgende code in een verse Sonic Pi-buffer:

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.
nl: Wanneer je de *Afspeel* knop indrukt zal je je berichtje openspringen op het Minecraft-scherm. Gefeliciteerd, hebt u uw eerste Minecraft code geschreven! Dat was niet moeilijk.

en: Now, let's try a little magic. Let's teleport ourselves somewhere! Try the following:
nl: Nu gaan we  wat magie gebruiken. Laten we onszelf naar ergens anders teleporteren. Probeer het volgende:

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.
nl: Wanneer je de * afspeel* knop indrukt - bam! Je bent inmiddelijk op een nieuwe plek. Waarschijnlijk ergens in de lucht en dat je op de grond of in het water viel. Nu, wat zijn die nummers : '50, 50, 50'? Dat zijn de coördinaten van de plaats waarnaartoe je probeerde te teleporteren. Neem de tijd om  coördinaten te verkennen en wat deze  zijn en hoe ze werken.Dit is echt belangrijk om Minecraft te kunnen programmeren.

en: Coordinates
nl: Coördinaten

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...
nl: Stel je een piraten kaart voor met een grote `X`om de locatie van één of andere schat te markeren. De exacte locatie van de `X` kan beschreven worden met twee cijfers- hoe ver van links naar rechts op de kaart en hoe ver op de kaart van beneden naar boven in de kaart. Bijvoorbeeld  `10cm` over en `8cm`  naar omhoog. Deze twee nummers `10`en `8` zijn coördinaten. Je kan je goed voorstellen hoe andere locaties van schatten met andere cijfercombinaties worden beschreven. Misschien is er een grote kist met goud aan `2` en `9` omhoog...

en: Now, in Minecraft two numbers isn't quite enough. We also need to know how high we are. We therefore need three numbers:
nl: Nu, twee getallen zijn in Minecraft niet genoeg. We willen ook weten hoe hoog we zitten. Daarvoor hebben we drie getallen nodig:

en: How far from right to left in the world - `x`
nl: Hoe ver van rechts naar links in de wereld - 'x'

en: How far from front to back in the world - `z`
nl: Hoe ver van voor naar achter in de wereld - 'z'

en: How high up we are in the world - `y`
nl: Hoe hoog, we in de wereld zijn - 'y'

en: One more thing - we typically describe these coordinates in this order `x`, `y`, `z`.
nl: Nog even dit - meestal schrijven we deze coördinaten in deze volgorde`x`, `y`, `z`.

en: Finding your current coordinates
nl: Je huidige coördinaten vinden

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:
nl: Laten we een spelletje doen met de coördinaten. Navigeer naar een mooie plek in de Minecraft kaart en schakel om naar Sonic Pi. Voer nu de volgende gegevens in:

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.
nl: Wanneer je op de*Afspeel* knop drukt zie je de coördinaten van uw huidige positie weergegeven worden in het logboekvenster. Neem hier nota van, ga vooruit in de wereld en probeer het dan nog eens. Merk op hoe de coördinaten veranderen! Nu, adviseer ik je om dit even te herhalen - beweeg een beetje in de wereld, neem een kijkje naar de coördinaten en herhaal opnieuw. Doe dit tot je er een zeker gevoel voor begint te krijgen, hoe deze coördinaten veranderen wanneer je je verplaatst. Zodra je hebt begrepen hoe deze coördinaten werken, zal het programmeren met de Minecraft-API peanuts worden.

en: Let's Build!
nl: Laten we gaan bouwen!

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:
nl: Nu je de huidige positie weet te vinden en je kan teleporteren met behulp van coördinaten, heb je alle hulpmiddelen die die je nodig hebt om met code te gaan beginnen bouwen in Minecraft. Stel dat je het blok met coördinaten `40`, `50`, `60` van glas wordt. Dat is nu super eenvoudig:

en: Haha, it really was that easy. To see your handywork just teleport nearby and take a look:
nl: Haha, het was echt zo makkelijk. Om je werkstuk te zien, teleporteer je je in de buurt en bekijk deze nu:

en: Now turn around and you should see your glass block! Try changing it to diamond:
nl: Draai nu even rond en je zou je glazen blok moeten zien staan! Probeer deze nu in diamant te veranderen:

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...
nl: Als je goed keek, zag je het met jij eigen ogen veranderen! Dit is het begin van iets groots...

en: Looking at blocks
nl: Blokken bekijken

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:
nl: Nog een laatste, voor we ons in iets anders engageren. Met een set van coördinaten kunnen we Minecraft vragen, welk type een bepaalde blok is. Laat ons dit proberen met onze zopas aangemaakte blok:

en: Yey! It's `:diamond`. Try changing it back to glass and asking again - does it now say `:glass`? I'm sure it does :-)
nl: Jeuj! Het is `:diamond`.Probeer deze nu terug te veranderen naar glas en vraag het dan opnieuw. Zegt het nu `:glass`? Ik ben zeker van wel :-)

en: Available block types
nl: De beschikbare bloktypes

en: Before you go on a Minecraft Pi coding rampage, you might find this list of available block types useful:
nl: Voor je helemaal loos gaat met het coderen van Minecraft Pi, moet je misschien deze lijst met beschikbare bloktypes even bekijken:
