# 1 - Welkom vriend :-)

Welkom bij Sonic Pi. Hopelijk ben je net zo enthousiast als ik om te gekke geluiden 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…

Maar wacht, dat was onbeleefd van me! Ik moet mij nog voorstellen. Ik ben Sam Aaron de kerel die Sonic Pi heeft gemaakt. Je vind mij als @samaaron op Twitter en ik zal heel blij zijn je daar te begroeten. Misschien ben je ook geïnteresseerd om meer te weten te komen over mijn Live Coding Performances waar ik, voor publiek, live codeer met Sonic Pi.

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!

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, dan zal ik jouw suggesties in overweging nemen voor een toekomstige versie.

Tenslotte, andermans live code bekijken is een geweldige manier om te leren. Regelmatig stream ik live op http://youtube.com/samaaron ga daar eens kijken, zeg hallo en stel me veel vragen :-)

OK, laten we beginnen…

# 1.1 - Live Coderen

Een van de meest opwindende aspecten van Sonic Pi is, dat het je in staat stelt, code te schrijven en de code, ook live te wijzigen om muziek te maken, net zoals je live gitaar zou spelen. Dit betekent dat je, na wat oefening, met Sonic Pi het podium op kan en een kan optreden geven.

## Maak je hoofd leeg

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 …

## Een loop “live” brengen

Om te beginnen, kopieer de volgende code in een lege buffer:

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

Klik nu op de `Afspeel`-knop en je zal een lekkere snelle basdrum horen. Je kan nu, als je dat wenst, het geluid stoppen door op de `Stop`-knop te klikken. Maar doe dat nog even niet… volg in plaats daarvan de volgende stappen:

1. Zorg ervoor dat dit basdrum geluid nog steeds loopt
2. Verander de waarde van `sleep` van `0.5` naar een ietwat hoger getal, zoals bv. `1`.
3. Klik opnieuw op de `Afspeel`-knop
4. Merk op dat de snelheid van de drum is veranderd.
5. En onthoud dit moment, dit is de eerste keer dat je een “Live Code” met Sonic Pi hebt gedaan en het is waarschijnlijk niet je laatste…

Ok, dat was eenvoudig. Laten we iets aan de mix toevoegen. Boven `sample :bd_haus` voeg je deze regel toe `sample :ambi_choir, rate: 0.3`. Jouw code moet er nu als volgt uitzien:

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

En nu, aanpassen maar. Verander de `rate:` (snelheid) waardes - wat gebeurt er, als je hoge waarden gebruikt, of kleine waarden of negatieve waarden? Kijk wat er gebeurt wanneer je de `rate:` waarde van het `:ambi_choir` sample maar een tikkeltje verandert (bv. `0.29`). Wat gebeurt 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 gebeurt, kun je gewoon een grotere `sleep` tijd instellen en op `afspelen` klikken).

Probeer eens één van de `sample` regels te laten beginnen met `#`:

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

Merk op hoe het de computer vertelt deze regel te negeren, zodat we deze niet horen. Dit heet een “comment” (commentaar-regel). In Sonic Pi kunnen we een commentaar-regel gebruiken om klanken uit de mix te verwijderen of weer toe te voegen.

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 hetzelfde moment spelen. Het beste wat je nu kan doen is er gewoon lekker op los experimenteren. Hier zijn enkele suggesties:

- Wijzig de blauwe `rate:` waarden, om het geluid van de sample te horen veranderen.
- Wijzig de `sleep` waarden en hoor, dat je beide loops kunt afspelen met verschillende rusttijden.
- Probeer de commentaar-regel te activeren (verwijder de `#`) uit onze “sample”-regel en geniet van het gitaargeluid, dat zich nu achterwaarts afspeelt.
- Probeer de blauwe `mix:` waarden te veranderen naar getallen tussen `0` (niet in de mix) en `1` (voluit in de mix).

Denk er aan, om op `Afspelen` te klikken om deze veranderingen te kunnen horen zodra de volgende loop begint. 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 ben je weer klaar om opnieuw te gaan improviseren. Van je fouten kan je nu eenmaal het beste leren.

    live_loop :guit do
      with_fx :echo, mix: 0.3, phase: 0.25 do
        sample :guit_em9, rate: 0.5
      end
    #  sample :guit_em9, rate: -0.5
      sleep 8
    end
    live_loop :boom do
      with_fx :reverb, room: 1 do
        sample :bd_boom, amp: 10, rate: 1
      end
      sleep 8
    end

Blijf nu spelen en experimenteren tot je een beetje begint te begrijpen hoe het allemaal werkt en je begint af te vragen wat je hier allemaal nog meer mee kan doen. Dan ben je klaar om de rest van de handleiding te lezen.

Dus, waar wacht je nog op…

# 1.2 - De Interface van Sonic Pi

Sonic Pi heeft een zeer eenvoudige interface om muziek te coderen. Laten we even de tijd nemen deze te verkennen.

- A - Afspeel knoppen
- B - Editor aanpassen
- C - Info en Hulp
- D - Code Editor
- E - Paneel Voorkeursinstellingen
- F - Log Venster
- G - Hulp-Systeem
- H - Scope Venster
- I - Indicatie Venster

## A. Afspeel knoppen

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 afspelende geluid.

## B. Werking van de Editor

Deze oranje knoppen maken het mogelijk om de code editor aan te passen. De Schaal + and Schaal - knoppen vergroten of verkleinen de tekst.

## C. Info en Hulp

Deze blauwe knoppen geven je toegang tot hulp-, informatie- en voorkeursinstellingen. De Info knop opent het venster dat 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 je een aantal fundamentele systeemparameters kan instellen.

## D. Code Editor

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 woord blauw is, dan weet je dat het om een getal gaat.

## E. Voorkeursinstellingen Paneel

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 het Paneel Voorkeursinstellingen, met daarin een aantal regelbare opties, tonen of verbergen. 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.

## F. Log Venster

Wanneer je je code uitvoert, zal informatie over wat het programma doet, getoond worden in een soort logboek. Je zult gewoonlijk 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.

## G. Hulp Systeem

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 getoond of verborgen 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.

## H. Scope Venster

In het scope venster zie je het geluid dat je hoort. Bijvoorbeeld dat een zaagtand-golf er ook uit ziet als een zaag en dat onze basis “beep”-toon een mooie golvende sinus-golf is. Je ziet ook duidelijk het verschil tussen luide en zachte geluiden door hun grootte. Er zijn 3 verschillende scopes beschikbaar, de standaard (default) is een gecombineerde scope voor het linker en rechter kanaal, een stereo variant die voor elk kanaal een aparte scope laat zien. En tenslotte is er een Lissajousfiguur scope die de fase relatie tussen het linker- en rechter-kanaal weergeven en je in staat stelt, mooie figuren te tekenen met geluid (https://nl.wikipedia.org/wiki/Lissajousfiguur).

## I. Indicatie Venster

Alle interne en externe events (`cues` in Sonic Pi) worden automatisch gelogd in het Indicatie Venster (`Cue` Viewer). Indien bijvoorbeeld een MIDI controller is aangesloten en een knop is ingedrukt, zal een new event zichtbaar zijn met de naam van de controller en de ingedrukte knop. Zodra je de basis van het produceren van geluiden beheerst, kun je secties van geluiden afspelen gebaseerd op dit soort events. Een `Cue`-event is een indicatie dat er iets gebeurd is. Wanneer er bijvoorbeeld een live loop loopt gaat, zal een `Cue`-event zichtbaar zijn in het Indicatie Venster. Externe events zoals MIDI berichten van verbonden apparatuur en OSC berichten van andere computers en programma’s worden hier eveneens weergegeven. Het is ook mogelijk om direct `Cue` events te genereren middels de `cue` functie. Alles wat zichtbaar is in het Indicatie Venster kan gebruikt worden om een verandering te signaleren (trigger). Meer details hierover vind je in sectie 10 en 12 van deze handleiding.

# 1.3 - Spelenderwijs Leren

Sonic Pi moedigt je aan om spelenderwijs te leren over computers en 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.

## Er bestaan geen fouten

Nu we er toch over bezig zijn, geef ik je graag een raad mee, wat ik heb geleerd in de jaren van live muziek coderen is - er bestaan geen fouten, alleen kansen. Dit is iets wat ik vaak heb horen zeggen over jazz, maar het werkt even goed met live codering. Ongeacht hoe ervaren je bent - van een complete beginner tot een doorgewinterde Algoraver, je zal soms code uitvoeren met een geheel onverwacht resultaat. Het kan waanzinnig cool klinken - in dat geval komen we er mee weg. Het kan ook compleet dwaas en ontoepasselijk klinken. Maar het maakt niet uit dat het gebeurd is - waar het om gaat is, wat je er vervolgens mee doet. Pak dat geluid, manipuleer en morph het naar iets ongelooflijks. Je publiek zal uit zijn dak gaan.

## Start Eenvoudig

Wanneer je aan het leren bent, is het verleidelijk om nu al verbazingwekkende dingen te willen doen. Maar het is beter om die wens nog even vast te houden en als doel voor ogen te houden om later te bereiken. Probeer eerst kleine, eenvoudige stappen te zetten en te zien hoe dit jou plezier geeft en je dichter tot je doel brengt. Wanneer je de kleine stappen onder de knie hebt, kan je deze als bouwstenen gebruiken en ermee spelen, en je zal zien dat deze nieuwe inzichten, jou ook verse ideeën zullen geven. Voor je het weet ga je op in je plezier én maak je echte vooruitgang.

Zorg ervoor dat je je werk deelt met anderen!

# 2 - Synthesizers

OK, genoeg intro’s - laten we in enkele geluiden duiken.

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 eenzelfde kracht op een eenvoudige en toegankelijke wijze.

Laat je niet misleiden door de ogenschijnlijke eenvoud van de Sonic Pi interface. Je kunt ermee diep, in zeer geavanceerde geluidsmanipulatie duiken als dat je ding mocht zijn. Hou je vast…

# 2.1 - Je Eerste Bliepjes

Bestudeer de volgende code:

    play 70

Dit is waar het allemaal begint. Ga je gang, kopieer en plak dit in het code venster aan de bovenzijde van de app (de grote witte ruimte onder de Afspeel knop). En, klik op Afspelen…

## Bliep!

Heftig. Klik opnieuw. En opnieuw. En opnieuw…

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 getal te veranderen:

    play 75

Hoor je het verschil? Probeer een lager getal:

    play 60

Dus, Lagere en hogere getallen maken respectievelijk lagere en hogere tonen. Net zo als op een piano worden de lagere toetsen (linkerhand) gebruikt om lagere noten te spelen, terwijl de hogere toetsen ingezet worden om hogere noten (rechterhand) te spelen.

Het komt erop neer dat de C noot van het 4de octaaf (C in engelse notatie) of centrale do word aangeduid met het getal 60. `play 60` speelt hierdoor de C noot van het 4de octaaf. Om de eerstvolgende piano toets rechts hiervan te spelen, tel je 1 bij 60 op en zet `play 61` in de code, welke in dit geval de zwarte toets van de Cis. Om de D te spelen, de volgende toets naar rechts, `play 62`.

Maak je geen zorgen wanneer dit nog niets zegt, mij zei het ook niets toen ik er voor het eerst aan begon. Het belangrijkste is dat je weet dat lage getallen, lagere tonen maken en hoge getallen, hogere tonen.

## Akkoorden

Eén noot spelen kan leuk zijn, maar vele noten tegelijk spelen kan het nog beter maken. Probeer dit:

    play 72
    play 75
    play 79

Jazzy! Dus, als je meerdere `play`s typt, spelen ze allemaal op hetzelfde moment. Probeer het zelf maar - welke getallen klinken goed samen? En welke klinken absoluut niet samen? Experimenteer, verken en ontdek dit voor jezelf.

## Melodie

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? Nou, dat is eenvoudig, je moet enkel wat rusten (`sleep`) tussen de noten:

    play 72
    sleep 1
    play 75
    sleep 1
    play 79

Hoe mooi, zo een korte arpeggio. Maar wat betekent toch die `1` in `sleep 1`? Nou, het staat voor de duur van de rust. Het betekent eigenlijk “slaap voor één tel”, rust voor 1 seconde. Dus, wat als we onze arpeggio een beetje sneller willen maken? Nou, dan zullen we een kortere slaap duur gebruiken. Wat denk je van de helft? D.w.z. `0.5`:

    play 72
    sleep 0.5
    play 75
    sleep 0.5
    play 79

Hoor je dat het sneller speelt. Probeer het nu zelf, verander de rusttijd - gebruik verschillende tijden en noten.

Wat je zeker ook kan proberen is om “tussen” noten te spelen zoals `play 52.3` en `play 52.63`. Het is absoluut niet nodig vast te blijven houden aan de standaard “hele” noten. Speel er maar op los en amuseer je.

## Traditionele Notennamen

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:

    play :C
    sleep 0.5
    play :D
    sleep 0.5
    play :E

Denk eraan, een dubbele punt vòòr de nootnaam te plaatsen, zodat deze roze wordt. Je kan hierbij ook het octaaf aangeven door achter de nootnaam een cijfer te plaatsen:

    play :C3
    sleep 0.5
    play :D3
    sleep 0.5
    play :E4

Als je een verhoogde alteratie (bv. F# of Fis) wilt maken, 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`.

Er is ook een handige notatie voor een “rust” (een muzikale manier om aan geven even niets te spelen in plaats van een note) gebruik hiervoor `:r`, `:rest` of `nil`.

Ga nu maar lekker los bij het maken van je eigen melodietjes, veel plezier ermee.

# 2.2 - Synthesizer Opties: Amp en Pan

Naast dat je kan bepalen welke noot er gespeeld wordt of welke sample er wordt getriggert, biedt Sonic Pi een heel scala aan mogelijkheden om geluiden te bewerken en manipuleren. We gaan vele daarvan in deze handleiding bekijken en in het hulp systeem zijn deze “opties” voorzien van uitgebreide documentatie. De belangrijkste op dit moment zijn: amplitude (sterkte) en pan (balans). Laten we eerst even bekijken wat opties nu eigenlijk zijn.

## Opties

Sonic Pi ondersteunt het concept van opties (afgekort: opts) voor haar synths. Opts zijn controle-elementen die je samen met het commando `play` doorgeeft. Ze wijzigingen en manipuleren het afgespeelde geluid. Elke synth heeft zijn eigen unieke set opts om haar geluid haarfijn af te kunnen stemmen. Er zijn ook opts die bij elke synth, of bij elk geluid gebruikt kunnen worden. Zoals `amp:` en “envelope” (geluidsverloop) opties (Waar we in een andere sectie dieper op ingaan).

Opts bestaan uit twee belangrijke delen, een naam (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`.

Opts worden samen met het `play` commando’s doorgegeven, gescheiden door een komma `,` gevolgd door de naam van de optie, we kiezen hier `amp:` (vergeet de dubbele punt niet `:`) gevolgd door een spatie en de waarde van de optie. Bijvoorbeeld:

    play 50, kaas: 1

(Let op dat `kaas:` geen geldige opt is, we gebruiken deze alleen als voorbeeld).

Je kunt meerdere opts tegelijk doorgeven door deze te scheiden door een komma:

    play 50, kaas: 1, eieren: 0.5

De volgorde van de opts maakt niet uit, dus het volgende is identiek:

    play 50, eieren: 0.5, kaas: 1

Opts die door de synth niet worden herkent zullen gewoon genegeerd worden (zoals `kaas` en `eieren` duidelijk nergens op slaan qua opt namen!)

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`:

    play 50, eieren: 0.5, kaas: 3, tomaat: 0.1, eieren: 2

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:`.

## Amplitude

Amplitude is de representatie van het geluidsvolume door een computer. Een hoge amplitude produceert het geluid met een luid volume en een lage amplitude met een zacht volume. Net zoals Sonic Pi getallen gebruikt om noten en tijden aan te geven, gebruikt het getallen om de amplitude te bepalen. Een amplitude van `0` is stil (je zult 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 je moet er dan wel rekening mee houden dat, wanneer het globale volume te hoog wordt, Sonic Pi een zogenaamde compressor inschakelt die het geluid zal 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 om lage amplitudes te gebruiken, dwz. tussen 0 en 0.5 om compressie te vermijden.

## Amp ‘t op

Om de amplitude van een geluid te veranderen, kan je de `amp:` optie gebruiken. Bijvoorbeeld, om op een gemiddelde amplitude af te spelen, gebruik je 0.5:

    play 60, amp: 0.5

Afspelen op een dubbel zo hoge amplitude gebruik dan 2:

    play 60, amp: 2

De `amp:` opt verandert enkel de `play` oproep waarmee deze wordt geassocieerd. In dit voorbeeld zal de eerste oproep dus op de helft van het volume spelen en de tweede op de standaard-instelling (1):

    play 60, amp: 0.5
    sleep 0.5
    play 65

Natuurlijk kun je verschillende `amp:` waarden per `play` oproep gebruiken:

    play 50, amp: 0.1
    sleep 0.25
    play 55, amp: 0.2
    sleep 0.25
    play 57, amp: 0.4
    sleep 0.25
    play 62, amp: 1

## Pannen

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. Een waarde van -1 betekend helemaal links, 0 betekend in het midden en 1 betekend weer 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.

Laten we eens een bliepje uit de linker-luidspreker laten horen:

    play 60, pan: -1

En nu uit de rechter-luidspreker:

    play 60, pan: 1

En nu terug vanuit het midden (standaard positie):

    play 60, pan: 0

Doe nu maar, en veel plezier met het veranderen van de amplitude en het pannen van je geluiden!

# 2.3 - Synths Veranderen

Tot nu hebben we al heel wat plezier beleeft met onze biepjes. Dit standaard biepje zal ons echter na een tijdje gaan vervelen. Is dit alles wat Sonic Pi ons te bieden heeft? Er moet toch meer kunnen dan alleen maar wat biepjes maken met dit hele gedoe van live-coderen? O ja zeker! In deze sectie gaan we een serie spannende klanken die Sonic Pi te bieden heeft verkennen.

## Synthesizers

Sonic Pi heeft een scala aan instrumenten, synths genaamd (dat is kort voor synthesizers). Waar samples reeds opgenomen klanken vertegenwoordigen, zijn synths in staat om nieuwe klanken te genereren, afhankelijk van hoe je deze instelt (dat gaan we later in deze handleiding ontdekken). Sonic Pi’s synths zijn heel krachtig en expressief en je zal er veel plezier aan beleven om deze te leren kennen en te gebruiken. Maar eerst gaan we leren hoe we er een kunnen selecteren.

## Drukke Zaagtanden en “Prophets”

Een leuk geluid is de zaagtand-golf, laten we deze eens uitproberen:

    use_synth :saw
    play 38
    sleep 0.25
    play 50
    sleep 0.25
    play 62

Laten we nog een ander geluid proberen, de prophet:

    use_synth :prophet
    play 38
    sleep 0.25
    play 50
    sleep 0.25
    play 62

Hoe zit het dan met het combineren van twee verschillende klanken? De ene na de andere:

    use_synth :saw
    play 38
    sleep 0.25
    play 50
    sleep 0.25
    use_synth :prophet
    play 57

Nu klinken er meerdere tonen tegelijk (omdat er geen pauze (`sleep`) meer zit tussen de opeenvolgende aanroepen van `play`):

    use_synth :tb303
    play 38
    use_synth :dsaw
    play 50
    use_synth :prophet
    play 57

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` oproepen, de synth laat afspelen waar momenteel naar verwezen wordt. Je kan die dan omschakelen naar een andere synth door het gebruik van `use_synth`.

## Synths Ontdekken

Om te zien welke synths Sonic Pi voor je heeft om mee te spelen kun je een kijkje nemen bij de Synths, het menu helemaal links-onder (tussen Voorbeelden en Effecten). Er zijn er meer dan 20 om uit te kiezen. Hier zijn een paar van mijn favorieten:

- `:prophet`
- `:dsaw`
- `:fm`
- `:tb303`
- `:pulse`

Speel nu een beetje met dit schakelen van synths terwijl je muziekstuk afspeelt. Veel plezier met het combineren van synths om nieuwe geluiden te maken of om verschillende secties in je muziekstuk van verschillende synths te voorzien.

# 2.4 - Geluidsduur met “Envelopes”

In een eerdere sectie, hebben we gezien hoe we de opdracht `sleep` konden gebruiken om te bepalen wanneer we onze geluiden activeren. We zijn echter nog niet in staat geweest om te bepalen hoe lang ons geluid duurt.

Om ons een eenvoudig maar krachtig middel te geven waarmee we de controle hebben over de tijdsduur van onze geluiden, biedt Sonic Pi ons een manier om een zogenaamde ADSR amplitude envelope (we bespreken later in deze sectie wat dat betekent) te beschrijven. Een amplitude “envelope” biedt twee manieren van controle:

- controle over de duurtijd van een geluid
- controle over de amplitude van een geluid

## Duurtijd

De duurtijd is de lengte dat een klank aanhoud. Een langere duur betekent dat je de klank langer hoort. De geluiden van Sonic Pi hebben allen een instelbare amplitude envelop, de totale duur van die envelop is dan de totale duurtijd van dat geluid. Zodoende kun je, door het instellen van de envelop, de duurtijd bepalen.

## Amplitude

De ADSR envelop regelt niet alleen de duurtijd, het geeft je ook een fijnregeling van de geluidssterkte van het geluid. Alle hoorbare geluiden beginnen en eindigen onhoorbaar met daartussen luidere en minder luide stukken. De ASDR envelop staat je toe om de geluidssterkte van de hoorbare gedeelten van een geluid 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.

Even herhalen, zoals we eerder hebben gezien, staat een amplitude van 0 voor stilte en een amplitude van 1 voor het normale volume.

Laten we nu eens kijken naar elk afzonderlijk onderdeel van de envelop.

## Release fase

Het enige deel van de envelop dat standaard wordt gebruikt is de release tijd. Dit is de tijd die nodig is om het geluid van een synth te reduceren tot stilte. Alle synths 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):

    play 70

De noot zal 1 seconde lang hoorbaar zijn. Controleer het maar met je stopwatch :-) Dit is de verkorting voor het langere, meer expliciete:

    play 70, release: 1

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 van de `release:` optie te veranderen:

    play 60, release: 2

We kunnen de synth een heel kort laten klinken door een heel kleine release tijd te gebruiken:

    play 60, release: 0.2

De duur van het “vrijlaten” van het geluid noemen we de release fase en staat standaard ingesteld op een “lineair” verloop ingesteld (d.w.z. in een rechte lijn). Het volgende diagram illustreert deze overgang:

De verticale lijn aan de linkerkant van het diagram toont ons dat het geluid bij geluidssterkte 0 begint en onmiddellijk naar volledige sterkte klimt (dit is de aanslag fase, die gaan we hierna bespreken). Zodra het geluid op volle sterkte is zal de sterkte in een rechte lijn naar nul zakken. In de tijdsduur die is aangegeven met `release:`. Langere release tijden leveren een langer verloop, waarmee het geluid van de synth uitvaagt, op.

Je kan dus de duurtijd van je klank veranderen aan de hand van de `release:` tijd. Speel hier even mee, door `release:` tijden toe te voegen aan je geluiden.

## Aanslag fase (de Attack)

De aanslag fase is voor alle synths standaard ingesteld op 0, wat betekend dat deze qua sterkte 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 bereiken met de `attack:` optie. Probeer nu eens je geluiden te laten aanzwellen:

    play 60, attack: 2
    sleep 3
    play 65, attack: 0.5

Je kan meerdere opties tegelijk gebruiken. Probeer deze bijvoorbeeld eens voor een kortere aanslag met een langere uitloop:

    play 60, attack: 0.7, release: 4

Deze korte `attack:` en lange `release:` envelop zie je in het volgende diagram afgebeeld:

Natuurlijk, kan je de dingen omdraaien. Probeer eens een lange attack en een korte release:

    play 60, attack: 4, release: 0.7

Als laastste, kan je natuurlijk ook korte attack en release tijden instellen voor korte geluiden.

    play 60, attack: 0.5, release: 0.5

## Sustain fase

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 aangehouden.

    play 60, attack: 0.3, sustain: 1, release: 1

De sustain-tijd is nuttig voor de geluiden die je een volledige aanwezigheid in de mix wil geven voordat deze een optionele release fase ingaan. Natuurlijk, is het volkomen correct 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 dan ook beter om dan een zeer kleine waarde te gebruiken zoals 0,2.

## Verval fase (Decay Phase)

Voor een nog beetje extra controle kun je ook de verval tijd instellen. Dit is de fase van de envelop die past tussen de attack en sustain fasen en de tijd aangeeft waarin de amplitude zal dalen van het `attack_level:` naar het `decay_level:` (die, tenzij u die expliciet instelt, op het `sustain_level:` gebracht zal worden). Standaard, is de `decay:` optie 0 en hebben zowel attack en sustain niveaus een waarde van 1, deze zal je dus moeten opgeven wil je dat de verval tijd effect heeft:

    play 60, attack: 0.1, attack_level: 1, decay: 0.2, sustain_level: 0.4, sustain: 1, release: 0.5

## Verval niveau (Decay level)

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 een volledige controle over de envelop. Hierdoor kan je een envelop als deze maken:

    play 60, attack: 0.1, attack_level: 1, decay: 0.2, decay_level: 0.3, sustain: 1, sustain_level: 0.4, release: 0.5

Het is ook mogelijk om het `decay_level:` hoger in te stellen dan het `sustain_level:`:

    play 60, attack: 0.1, attack_level: 0.1, decay: 0.2, decay_level: 1, sustain: 0.5, sustain_level: 0.8, release: 1.5

## ADSR Enveloppen

Dus samengevat , hebben Sonic Pi’s ADSR enveloppen de volgende fasen:

1. attack - tijd vanaf 0 amplitude naar `attack_level`,
2. decay - tijd om de amplitude van `attack_level` naar `decay_level` te brengen,
3. sustain - tijd om de amplitude van `decay_level` naar `sustain_level` te brengen,
4. release - tijd om de amplitude van `sustain_level` naar 0 te brengen

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 beats hebben:

    play 60, attack: 0.5, attack_level: 1, decay: 1, sustain_level: 0.4, sustain: 2, release: 0.5

Ga hier nu maar mee spelen en voeg je eigen envelop aan jouw geluiden toe…

# 3 - Samples

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.

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…

# 3.1 - Samples Triggeren

Bliepjes spelen was slechts het begin. Vooraf opgenomen samples triggeren is ook echt fijn . Probeer het:

    sample :ambi_lunar_land

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:

    play 36
    play 48
    sample :ambi_lunar_land
    sample :ambi_drone

Als je ze in tijd wil verspreiden, maak dan gebruik van het `sleep` commando:

    sample :ambi_lunar_land
    sleep 1
    play 48
    sleep 0.5
    play 36
    sample :ambi_drone
    sleep 1
    play 36

Merk op hoe Sonic Pi niet zal wachten om een geluid te voltooien voordat het volgende geluid begint. De opdracht `sleep` beschrijft alleen de scheiding tussen het activeren van de geluiden. Hierdoor kan je makkelijk verschillende lagen van klanken creëren die een interessant effect kunnen hebben door overlapping. Verderop in deze handleiding zullen we een kijkje nemen hoe je de duur van geluiden met enveloppen in te stellen.

## Samples Ontdekken

Er zijn twee manieren om de samples in Sonic Pi te verkennen. Allereerst, kun je dit hulp-systeem gebruiken. Klik op Samples in het menu onderaan het dit hulp venster, kies een categorie en vervolgens zie je een lijst met beschikbare geluiden.

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:

- `:ambi_`
- `:bass_`
- `:elec_`
- `:perc_`
- `:guit_`
- `:drum_`
- `:misc_`
- `:bd_`

Begin nu de samples in je composities te mixen!

# 3.2 - Sample Parameters: Amp en Pan

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.

## Samples amp-en

Je kan de amplitude van de samples met precies dezelfde aanpak instellen die je voor synthesizers gebruikt:

    sample :ambi_lunar_land, amp: 0.5

## Samples Pannen

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:

    sample :loop_amen, pan: -1
    sleep 0.877
    sample :loop_amen, pan: 1

Merk op dat 0.877 de helft van de lengte is, van de ‘: loop_amen’ sample in seconden uitgedrukt.

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.

# 3.3 - Samples Stretchen

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.

## Sample Representatie

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 .

## Koers wijzigen (rate)

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:

    sample :ambi_choir, rate: 1

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’:

    sample :ambi_choir, rate: 0.5

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.

## Laten we stretchen

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:

    sample :loop_amen

Door de koerssnelheid te veranderen kunnen we van genre schakelen. Probeer eens halve snelheid voor old school hiphop:

    sample :loop_amen, rate: 0.5

Als we het versnellen, komen we op het grondgebied van jungle:

    sample :loop_amen, rate: 1.5

En nog een laatste truc - laten we eens kijken wat er gebeurt als we gebruik maken van een negatieve koers:

    sample :loop_amen, rate: -1

Woah! Nu speelt het achteruit! Proberen nu eens met een heleboel verschillende samples op verschillende snelheden te spelen. Probeer maar eens zeer hoge snelheden. Probeer hele lage snelheden. Kijk maar welke interessante geluiden je zo kan produceren.

## Een eenvoudige uitleg over de Sample Rate

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.

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.

## De wiskunde achter Sample Rate

(Deze sectie is bedoeld voor degenen die geïnteresseerd zijn in de details. Je kan deze gerust overslaan…)

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:

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.

De duur van de sample wordt beïnvloed door de afspeelsnelheid (rate):

- De afspeelsnelheid verdubbelen, halveert de afspeeltijd,
- Halvering van de afspeelsnelheid, verdubbelt de afspeeltijd,
- Een kwart van de afspeelsnelheid, verviervoudigt de speeltijd,
- 1/10 van de afspeelsnelheid, maakt het afspelen 10 keer langer.

Wij kunnen deze representeren met de formule:

    new_sample_duur = (1 / rate) * sample_duur

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.

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.

# 3.4 - Envelop op Samples

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.

## Amen Envelop

Laten we terugkeren naar onze trouwe vriend de Amen Break:

    sample :loop_amen

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:

    sample :loop_amen, attack: 1

Voor een kortere fade in, kies een kleinere waarde voor de attack:

    sample :loop_amen, attack: 0.3

## Auto Sustain

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.

## Fade Outs

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:

    print sample_duration :loop_amen

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:

    sample :loop_amen, release: 0.75

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 .

Dus onthoud: standaard geeft de release, aan het einde van de sample, een fade-out .

## Fade In en Uit

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:

    sample :loop_amen, attack: 0.75, release: 0.75

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.

## Expliciete sustain

We kunnen makkelijk naar ons normale synth ADSR gedrag terugkeren door de `sustain:` manueel naar een waarde te brengen zoals bv. 0:

    sample :loop_amen, sustain: 0, release: 0.75

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.

## Percussieve cymbalen

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`:

    sample :drum_cymbal_open

Je hoort het cimbaal over een zekere periode uitzingen. We kunnen nu de envelop gebruiken om deze meer percussief te maken:

    sample :drum_cymbal_open, attack: 0.01, sustain: 0, release: 0.1

Je kan het slaan op de cymbaal, en het dempen ervan veranderen, door de sustain fase te vergroten:

    sample :drum_cymbal_open, attack: 0.01, sustain: 0.3, release: 0.1

Leef je uit door aan samples een envelop toe te voegen. Probeer ook de rate te veranderen voor echt interessante resultaten.

# 3.5 - Gedeeltelijke Samples

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:

    sample :loop_amen

Vervolgens hebben we gekeken hoe we de rate kunnen wijzigen naar bv. het afspelen op halve snelheid:

    sample :loop_amen, rate: 0.5

Verder hebben we gekeken hoe we deze sample konden in fade-en (we doen deze op halve snelheid):

    sample :loop_amen, rate: 0.5, attack: 1

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:

    sample :loop_amen, rate: 2, attack: 0.01, sustain: 0, release: 0.35

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?

## Startpunt kiezen

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:

    sample :loop_amen, start: 0.5

Of het laatste kwart van de sample:

    sample :loop_amen, start: 0.75

## Eindpunt kiezen

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:

    sample :loop_amen, finish: 0.5

## Specifieke begin- en eindpunten opgeven

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:

    sample :loop_amen, start: 0.4, finish: 0.6

Wat gebeurd er als we een startpunt achter het eind punt kiezen?

    sample :loop_amen, start: 0.6, finish: 0.4

Cool! Het speelt achterstevoren!

## Combineren met rate

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:

    sample :loop_amen, start: 0.5, finish: 0.7, rate: 0.2

## Combineren met de envelop

Tot slot kunnen we dit alles combineren met onze ADSR envelop om tot interessante resultaten te komen:

    sample :loop_amen, start: 0.5, finish: 0.8, rate: -0.2, attack: 0.3, release: 1

Experimenteer er nu maar even op los en maak leuke mash-ups van samples met deze toffe nieuwigheden…

# 3.6 - Externe Sample

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.

## Portabiliteit

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

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.

## Lokale Samples

Maar hoe speel je nou een willekeurig WAV-, AIFF-, OGG-, OGA- of FLAC-bestand van je computer? Het enige wat je hoeft te doen is het pad naar het bestand mee te geven aan `sample`:

    # Raspberry Pi, Mac, Linux
    sample "/Users/sam/Desktop/my-sound.wav"
    # Windows
    sample "C:/Users/sam/Desktop/my-sound.wav"

Sonic Pi zal deze samples automatisch laden en afspelen. Je kan ook alle standaard parameters toewijzen aan deze doorgegeven `sample`:

    # Raspberry Pi, Mac, Linux
    sample "/Users/sam/Desktop/my-sound.wav", rate: 0.5, amp: 0.3
    # Windows
    sample "C:/Users/sam/Desktop/my-sound.wav", rate: 0.5, amp: 0.3

# 3.7 - Sample Packs

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.

U mag dit gedeelte gerust overslaan wanneer je tevreden bent met de ingebouwde samples.

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.

Bijvoorbeeld, stel dat je de volgende map hebt op je computer:

    /path/to/my/samples/

Als we in die map kijken vinden we de volgende voorbeelden:

- `100_A#_melody1.wav`
- `100_A#_melody2.wav`
- `100_A#_melody3.wav`
- `120_A#_melody4.wav`
- `120_Bb_guit1.wav`
- `120_Bb_piano1.wav`

Om de piano sample te spelen gebruiken we dan normaal gezien het volledige pad:

    sample "/pad/naar/mijn/samples/120_Bb_piano1.wav"

Om vervolgens de gitaar sample te willen gebruiken we ook het volledige pad:

    sample "/pad/naar/mijn/samples/120_Bb_guit.wav"

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?

## Sample Packs Indexeren

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:

    sample "/pad/naar/mijn/samples/", 0

We kunnen zelfs een binnenweg maken naar ons pad van de map met behulp van een variabele:

    samps = "/pad/naar/mijn/samples/"
    sample samps, 0

Als we dan de tweede sample in onze folder willen afspelen, moeten we gewoon 1 aan onze index toevoegen:

    samps = "/pad/naar/mijn/samples/"
    sample samps, 1

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.

## Sample Packs Filteren

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:

- `100_A#_melody1.wav`
- `100_A#_melody2.wav`
- `100_A#_melody3.wav`
- `120_A#_melody4.wav`
- `120_Bb_guit1.wav`
- `120_Bb_piano1.wav`

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.

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:

    samps = "/pad/naar/mijn/samples/"
    sample samps, "120"

Deze zal ons een eerste filtering opleveren. Als we verder willen gaan zoeken naar een sample die goed past, kunnen we de index gebruiken:

    samps = “/pad/naar/mijn/samples/"
    sample samps, "120", 1

We kunnen zelfs meerdere filters tegelijk gebruiken. Bijvoorbeeld, als we willen dat een sample waarvan de bestandsnaam zowel `"120"` en `"A#"` bevat, kunnen we die met de volgende code gemakkelijk terugvinden:

    samps = "/pad/naar/mijn/samples/"
    sample samps, "120", "A#"

Voorts zijn we nog altijd vrij om onze gebruikelijke opties voor de weergave van onze `sample` toe te voegen:

    samps = "/pad/naar/mijn/samples/"
    sample samps, "120", "Bb", 1, lpf: 70, amp: 2

## Bronnen

De pre-arg(umenten) van het sample filtersysteem herkennen twee soorten informatie: bronnen en filters. Bronnen worden gebruikt om een lijst van potentiële kandidaten te maken. Een bron kan twee vormen aannemen:

1. `"/pad/naar/samples"` - een tekenreeks dat een geldig pad naar een map weergeeft
2. `"/pad/naar/samples/blabla.wav"` - een tekenreeks dat een geldig pad naar een sample bestand weergeeft

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.

Kijk bijvoorbeeld even naar deze code:

    samps = "/pad/naar/mijn/samples/"
    samps2 = "/pad/naar/mijn/samples2/"
    path = "/pad/naar/mijn/samples3/foo.wav"
    sample samps, samps2, path, 0

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

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:

    samps = "/pad/naar/geneste/samples/**"
    sample samps, 0

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.

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.

## Filters

Als u eenmaal een lijst van kandidaten hebt mag u het volgende filter typen om de selectie verder te reduceren:

- `"foo"` Tekenreeksen zullen filteren op sub-tekenreeksen gebeurtenissen binnen de bestandsnaam (min het pad van de map en de extensie).
- `/fo[oO]/` Reguliere expressies zullen filteren op patroonherkenning van bestandsnamen (min het pad van de map en de extensie).
- `:foo` -trefwoorden zullen naar kandidaten filteren op basis van hun gelijkenis met de bestandsnaam (min het pad van de map en extentie).
- `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).
- `1` - Nummers zullen de kandidaat met dit index selecteren (en als een kring rond gaan als dit nodig is).

We kunnen bijvoorbeeld alle samples filteren in een map die bevat de tekenreeks `"foo"` bevat en de eerste overeenkomende sample spelen op halve snelheid:

    sample "/pad/naar/samples", "foo", rate: 0.5

Zie hulp voor `sample` voor vele gedetailleerde gebruiksvoorbeelden. Merk op dat de volgorde van de filters geëerd wordt.

## Mengsels

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:

    sample "/pad/naar/map", "100", "C#"
    sample ["/pad/naar/map", "100", "C#"]
    sample "/pad/naar/map", ["100", "C#"]
    sample ["/pad/naar/map", ["100", ["C#"]]]

## Rond Wikkelen

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.

# 4 - Randomiseren

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.

## Herhaalbaarheid

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:

    play rrand(50, 95)

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!

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.

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:

    loop do
      play rrand(50, 95)
      sleep 0.5
    end

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!

## “Haunted Bells”

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:

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

## Random cutoff

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:

    use_synth :tb303
    loop do
      play 50, release: 0.1, cutoff: rrand(60, 120)
      sleep 0.125
    end

## Random “seeds”

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!

Houd rekening met het volgende:

    5.times do
      play rrand(50, 100)
      sleep 0.5
    end

Telkens wanneer u deze code uitvoert, zult u dezelfde sequentie van 5 noten horen. Voor een andere volgorde verander gewoon de seed:

    use_random_seed 40
    5.times do
      play rrand(50, 100)
      sleep 0.5
    end

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.

Laten we eens kijken naar enkele andere nuttige randomisering functies.

## choose

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`:

    choose([60, 65, 72])

Laten we eens horen hoe dat klinkt:

    loop do
      play choose([60, 65, 72])
      sleep 1
    end

## rrand

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)`:

- 87.5054931640625
- 86.05255126953125
- 61.77825927734375

## rrand_i

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:

- 88
- 86
- 62

## rand

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:

    loop do
      play 60, amp: rand
      sleep 0.25
    end

## rand_i

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.

## dice (teerling)

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!

## one_in

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.

Maak maar even een wirwar aan Random-heid!

# 5 - Programmeerstructuren

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…

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.

We bijten ons vast in de basisbeginselen hiervan…

# 5.1 - Blocks

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:

    play 50
    sleep 0.5
    sample :elec_plip
    sleep 0.5
    play 62

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:

    do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

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.

# 5.2 - Herhaling en Loops

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`.

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.

## Repetitieve herhaling

Heb je wat code geschreven dat je graag een paar keer wil herhalen? Bijvoorbeeld, zoiets als deze::

    play 50
    sleep 0.5
    sample :elec_blup
    sleep 0.5
    play 62
    sleep 0.25

Wat als wij deze 3 keer willen herhalen? Nou simpel, we kunnen deze drie keer kopiëren en plakken:

    play 50
    sleep 0.5
    sample :elec_blup
    sleep 0.5
    play 62
    sleep 0.25
    play 50
    sleep 0.5
    sample :elec_blup
    sleep 0.5
    play 62
    sleep 0.25
    play 50
    sleep 0.5
    sample :elec_blup
    sleep 0.5
    play 62
    sleep 0.25

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.

## Iteratie

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:

    3.times do
      play 50
      sleep 0.5
      sample :elec_blup
      sleep 0.5
      play 62
      sleep 0.25
    end

Nu is dat niet veel netter dan knippen en plakken! We kunnen dit gebruiken om allerlei leuke herhalende structuren te maken:

    4.times do
      play 50
      sleep 0.5
    end
    8.times do
      play 55, release: 0.2
      sleep 0.25
    end
    4.times do
      play 50
      sleep 0.5
    end

## Geneste Iteraties

We kunnen iteraties binnen andere iteraties plaatsen om interessante patronen te creëren. Bijvoorbeeld:

    4.times do
      sample :drum_heavy_kick
      2.times do
        sample :elec_blip2, rate: 2
        sleep 0.25
      end
      sample :elec_snare
      4.times do
        sample :drum_tom_mid_soft
        sleep 0.125
      end
    end

## Loop-en

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:

    loop do
      sample :loop_amen
      sleep sample_duration :loop_amen
    end

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:

    loop do
      play 50
      sleep 1
    end
    sample :drum_cymbal_open

Nu gaan we de code structureren met iteratie en loops!

# 5.3 - Conditionelen

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’.

## Een muntje opgooien

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 :

    loop do
      if one_in(2)
        sample :drum_heavy_kick
      else
        sample :drum_cymbal_closed
      end

      sleep 0.5

    end

Merk op dat ‘if’ verklaringen drie delen hebben:

- De vraagstelling
- De eerste keuze van de uit te voeren code (als het antwoord op de vraag ja is)
- De tweede keuze van de uit te voeren code (als het antwoord op de vraag neen is)

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.

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:

    loop do
      if one_in(2)
        sample :drum_heavy_kick
        sleep 0.5
      else
        sample :drum_cymbal_closed
        sleep 0.25
      end

    end

Dit keer hebben we verschillende rustijden afhankelijk van de keuze die wordt gemaakt.

## Gewoon if

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:

    use_synth :dsaw
    loop do
      play 50, amp: 0.3, release: 2
      play 53, amp: 0.3, release: 2 if one_in(2)
      play 57, amp: 0.3, release: 2 if one_in(3)
      play 60, amp: 0.3, release: 2 if one_in(4)
      sleep 1.5
    end

Dit zal akoorden met andere getallen, bij iedere gespeelde noot, de kans op een verschillende mogelijkheid spelen.

# 5.4 - Threads

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.

Wat als Sonic Pi deze automatisch kan verweven voor jou? Nou, het kan, en je het doet dat met wat heet een thread.

## Oneindige Loops

Om het voorbeeld eenvoudig te houden, moet je je voorstellen dat dit een waanzinnige baslijn is en een vette beat:

    loop do
      sample :drum_heavy_kick
      sleep 1
    end
    loop do
      use_synth :fm
      play 40, release: 0.2
      sleep 0.5
    end

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.

## Threads bieden redding

    in_thread do
      loop do
        sample :drum_heavy_kick
        sleep 1
      end
    end
    loop do
      use_synth :fm
      play 40, release: 0.2
      sleep 0.5
    end

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!

Wat als we hieraan nog een synth willen toevoegen? Zoiets als:

    in_thread do
      loop do
        sample :drum_heavy_kick
        sleep 1
      end
    end
    loop do
      use_synth :fm
      play 40, release: 0.2
      sleep 0.5
    end
    loop do
      use_synth :zawa
      play 52, release: 2.5, phase: 2, amp: 0.5
      sleep 2
    end

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:

    in_thread do
      loop do
        sample :drum_heavy_kick
        sleep 1
      end
    end
    in_thread do
      loop do
        use_synth :fm
        play 40, release: 0.2
        sleep 0.5
      end
    end
    loop do
      use_synth :zawa
      play 52, release: 2.5, phase: 2, amp: 0.5
      sleep 2
    end

## Voert uit als threads

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.

## Toepassingsgebied

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:

    play 50
    sleep 1
    in_thread do
      use_synth :tb303
      play 50
    end
    sleep 1
    play 50

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.

## Erfenis

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 :

    use_synth :tb303
    play 50
    sleep 1
    in_thread do
      play 55
    end

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.

Wannneer threads worden gecreëerd, erven zij alle instellingen over van bovenliggende (parent) maar zij delen geen veranderingen aan hen terug.

## Naamgeving aan Threads

Ook nog kunnen wij namen geven aan threads:

    in_thread(name: :bass) do
      loop do
        use_synth :prophet
        play chord(:e2, :m7).choose, release: 0.6
        sleep 0.5
      end
    end
    in_thread(name: :drums) do
      loop do
        sample :elec_snare
        sleep 1
      end
    end

Kijk naar het log venster wanneer u deze code uitvoert. Zie je hoe het logboek de naam rapporteert van de thread met een bericht?

    [Run 36, Time 4.0, Thread :bass]
     |- synth :prophet, {release: 0.6, note: 47}

## Slechts één thread per naam toegestaan

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:

    in_thread do
      loop do
        sample :loop_amen
        sleep sample_duration :loop_amen
      end
    end

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.

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.

Met benoemde threads is dat echter anders:

    in_thread(name: :amen) do
      loop do
        sample :loop_amen
        sleep sample_duration :loop_amen
      end
    end

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:

    ==> Skipping thread creation: thread with name :amen already exists.

Sonic Pi vertelt je hier dat een thread met de naam `:amen` al aan het spelen is , en gaat geen andere creëren.

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…

# 5.5 - Functies

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.

## Functies definiëren

    define :foo do
      play 50
      sleep 1
      play 55
      sleep 2
    end

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`.

Vergeet niet van een dubbele punt `:` voor de naam van je functie te zetten wanneer je deze definieert. Functie namen moeten beginnen met een kleine letter, gebruik dus `:bla` in plaats van `:Bla`.

## Functies aanroepen

Eens we een functie hebben gedefinieerd kunnen we deze oproepen door gewoon zijn naam te schrijven:

    define :foo do
      play 50
      sleep 1
      play 55
      sleep 0.5
    end
    foo
    sleep 1
    2.times do
      foo
    end

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.

## Functies worden onthouden langsheen het uitvoer commando

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:

    foo

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

## geparametreerde functies

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:

    define :my_player do |n|
      play n
    end
    my_player 80
    sleep 0.5
    my_player 90

Dit is niet erg spannend, maar het illustreert wel de zaak. We hebben onze eigen versie van `play` genaamd ‘my_player’ die is geparametriseerd.

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.

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`.

Laten we eens kijken naar een interessanter voorbeeld:

    define :chord_player do |root, repeats|
      repeats.times do
        play chord(root, :minor), release: 0.3
        sleep 0.5
      end
    end
    chord_player :e3, 2
    sleep 0.5
    chord_player :a3, 3
    chord_player :g3, 4
    sleep 0.5
    chord_player :e3, 3

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.

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!

# 5.6 - Variabelen

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:

    sample_name = :loop_amen

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:

    sample_name = :loop_amen
    sample sample_name

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.

## In de zin van Communicatie

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!

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:

    sleep 1.7533

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:

    loop_amen_duration = 1.7533
    sleep loop_amen_duration

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:

    sleep sample_duration(:loop_amen)

Wat natuurlijk een zeer mooie manier is om de intentie van de code te communiceren .

## Herhaling Beheren

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:

    sample :loop_amen
    sleep sample_duration(:loop_amen)
    sample :loop_amen, rate: 0.5
    sleep sample_duration(:loop_amen, rate: 0.5)
    sample :loop_amen
    sleep sample_duration(:loop_amen)

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.

Wat als je je code als het volgt zou schrijven:

    sample_name = :loop_amen
    sample sample_name
    sleep sample_duration(sample_name)
    sample sample_name, rate: 0.5
    sleep sample_duration(sample_name, rate: 0.5)
    sample sample_name
    sleep sample_duration(sample_name)

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.

## Vastleggen van de resultaten

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:

    sd = sample_duration(:loop_amen)

We kunnen nu ‘sd’ overal gebruiken waar we de duur van de sample `:loop_amen` nodig hebben.

Wat misschien nog belangrijker is, een variabele stelt ons in staat het resultaat te capteren van een oproep naar `play` of `sample`:

    s = play 50, release: 8

Nu hebben we `s` gevangen en onthouden als een variabele, hetgeen ons toelaat de synth te controleren wanneer deze speelt:

    s = play 50, release: 8
    sleep 2
    control s, note: 62

We zullen het manipuleren van synth’s in een later sectie meer in detail bekijken.

## Waarschuwing: Variabelen en threads

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:

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

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.

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:

    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

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.

# 5.7 - Het Synchroniseren van Threads

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.

## Overgenomen Tijd

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.

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.

## Cue en Sync

Sonic Pi biedt een oplossing voor dit probleem met de functies ‘cue’ en ‘sync’.

‘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’.

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

Laten we dit in detail bekijken:

    in_thread do
      loop do
        cue :tick
        sleep 1
      end
    end
    in_thread do
      loop do
        sync :tick
        sample :drum_heavy_kick
      end
    end

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.

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:

    in_thread do
      loop do
        cue :tick
        sleep 1
      end
    end
    sleep(0.3)
    in_thread do
      loop do
        sync :tick
        sample :drum_heavy_kick
      end
    end

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.

## Cue Namen

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

Laten we met en paar `cue` namen spelen:

    in_thread do
      loop do
        cue [:foo, :bar, :baz].choose
        sleep 0.5
      end
    end
    in_thread do
      loop do
        sync :foo
        sample :elec_beep
      end
    end
    in_thread do
      loop do
        sync :bar
        sample :elec_flip
      end
    end
    in_thread do
      loop do
        sync :baz
        sample :elec_blup
      end
    end

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.

Dit werkt natuurlijk ook als jen de threads omgekeerd ordend omdat de`sync` threads gewoon op de volgende `cue` zitten wachten.

# 6 - Studio FX

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.

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…

## Gitaar Pedalen

Als dit je allemaal een beetje ingewikkeld klinkt, maak je dan geen zorgen. Zodra je hier een beetje mee speelt word het allemaal duidelijk. Maar voor je zover bent, het is vergelijkbaar met hoe gitaar effect-pedalen werken. Er zijn verschillende effect-pedalen te koop. Sommigen voegen een nagalm toe, andere verstoring enz. Een gitarist zal zijn of haar gitaar in één van de effect-pedalen pluggen, bv. verstoring, en zal de uitgang hiervan deze met een kabel verbinden met de ingang van een nagalm-pedaal om het geluid door te schakelen (chain). De uitgang van de nagalm-pedaal kan dan in de versterker geplugd worden:

    Gitaar -> Distortion -> Reverb -> Amplifier (Versterker)

Het aan elkaar knopen van effecten heet effecten ketten (“FX chaining”). Sonic Pi ondersteunt precies dit. Bovendien heeft elke pedaal vaak draaiknoppen en schuifregelaars zodat je kan bepalen hoeveel verstoring, nagalm, echo enz je wilt toepassen. Sonic Pi ondersteunt ook dit soort controle. Tot slot kan je je een gitarist voorstellen die lekker aan het spelen en dat iemand anders, terwijl hij aan het spelen is, met de effect-knoppen van de pedalen speelt. Sonic Pi ondersteunt dit ook - maar in plaats van dat iemand anders dingen voor jou regelt, doet de computer dit.

Laten we FX verkennen!

# 6.1 - FX Toevoegen

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.

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.

## Reverb

Als we reverb willen gebruiken schrijven we `with_fx :reverb` als speciale code naar ons blok als volgt:

    with_fx :reverb do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

Speel deze code nu en hoor dat deze met reverb wordt gespeeld. Dat klinkt goed, niet?Alles klinkt vrij aardig met een reverb.

Laten we nu kijken wat er gebeurt als we buiten het do/end blok code hebben:

    with_fx :reverb do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end
    sleep 1
    play 55

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.

Op dezelfde manier zullen klanken vòòr het do/end blok ook niet gecapteerd worden:

    play 55
    sleep 1
    with_fx :reverb do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end
    sleep 1
    play 55

## Echo

Er zijn veel effecten te kiezen. Wat dacht je van wat echo?

    with_fx :echo do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

Éé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:

    with_fx :echo, phase: 0.5 do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

Laten we de echo sneller maken:

    with_fx :echo, phase: 0.125 do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

Laat ons de echo over een langere tijd uitfaden door de `decay:` tijd in te stellen naar 8 beats:

    with_fx :echo, phase: 0.5, decay: 8 do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

## Effecten nesten

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:

    with_fx :reverb do
      with_fx :echo, phase: 0.5, decay: 8 do
        play 50
        sleep 0.5
        sample :elec_blup
        sleep 0.5
        play 62
      end
    end

Stel je voor dat het geluid binnen naar buiten stroomt. Het geluid van alle code binnen het binnenste do/end blok zoals `play 50` wordt eerst verzonden naar het echo effect en het geluid van het echo effect wordt op zijn beurt doorgestuurd naar het nagalm (reverb) effect.

We kunnen heel diep nesten en zo voor maffe resultaten zorgen. Maar wees gewaarschuwd, want de effecten kunnen veel vragen van je computers rekenkracht, zeker wanneer je meerdere effecten nest die gelijktijdig worden uitgevoerd. Wees dus spaarzaam met uw gebruik van effecten zeker op minder krachtige computers zoals een Raspberry Pi.

## Effecten ontdekken

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:

- wobble,
- reverb,
- echo,
- distortion,
- slicer

Doe nu maar eens gek en zet overal effecten op voor verbazingwekkende nieuwe geluiden!

# 6.2 - FX in de praktijk

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.

Bekijk even deze code:

    loop do
      with_fx :reverb do
        play 60, release: 0.1
        sleep 0.125
      end
    end

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…

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.

Hoe maken we deze meer vergelijkbaar met een traditionele opstelling waar onze gitarist slechts één reverb-pedaal heeft waardoor alle klanken passeren? Eenvoudig:

    with_fx :reverb do
      loop do
        play 60, release: 0.1
        sleep 0.125
      end
    end

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.

Een compromis is het gebruik van ‘with_fx’ buiten van de herhaling binnen een loop:

    loop do
      with_fx :reverb do
        16.times do
          play 60, release: 0.1
          sleep 0.125
        end
      end
    end

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.

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:

    loop do
      with_fx :reverb, reps: 16 do
        play 60, release: 0.1
        sleep 0.125
      end
    end

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.

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.

# 7 - De controle over lopende klank

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.

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?

Je hebt geluk- deze sectie gaat precies daarover.

# 7.1 - Lopende Synths Contoleren

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:

    s = play 60, release: 5

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.

Eens we `s` hebben, kunnen we deze beginnen tweaken via de `control` functie:

    s = play 60, release: 5
    sleep 0.5
    control s, note: 65
    sleep 0.5
    control s, note: 67
    sleep 3
    control s, note: 72

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.

We kunnen iedere standaard opt doorgeven om `controle` over te hebben, zodat je `amp:`, `cutoff:` or `pan:´ kan controllen.

## Niet-Control-bare Opties

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.

# 7.2 - FX Controllen

Het is ook mogelijk om FX te controllen, hoewel dit op een iets andere manier wordt bereikt:

    with_fx :reverb do |r|
      play 50
      sleep 0.5
      control r, mix: 0.7
      play 55
      sleep 1
      control r, mix: 0.9
      sleep 1
      play 62
    end

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.

Ga nu enkele synths en FX Controllen !

# 7.3 - Glijdende Opties

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.

Beschouw het volgende voorbeeld:

    s = play 60, release: 5
    sleep 0.5
    control s, note: 65
    sleep 0.5
    control s, note: 67
    sleep 3
    control s, note: 72

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:

    s = play 60, release: 5, note_slide: 1
    sleep 0.5
    control s, note: 65
    sleep 0.5
    control s, note: 67
    sleep 3
    control s, note: 72

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.

Elke parameter die controlt kan worden heeft een identieke parameter ‘_slide’ voor jou om mee te spelen.

## Slide-en blijft plakken

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`.

## Sliding FX Opts

Het is ook mogelijk FX opts te slide-en:

    with_fx :wobble, phase: 1, phase_slide: 5 do |e|
      use_synth :dsaw
      play 50, release: 5
      control e, phase: 0.025
    end

Veel plezier met het rond slide-en van zaken voor een vloeiende overgang en een vlotte control…

# 8 - Datastructuren

Een zeer nuttig hulpmiddel in de gereedschapskist van een programmeur is een datastructuur.

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.

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.

Laten we dit eens in detail bekijken. We zullen zijn basisvorm behandelen en ook hoe lijsten kunnen worden gebruikt voor toonladders en akkoorden.

# 8.1 - Lijsten

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:

    play choose([50, 55, 62])

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 :

    play 52
    play 55
    play 59

Laten we eens kijken naar andere manieren om deze code weer te geven.

## Afspelen van een lijst

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:

    play [52, 55, 59]

Ooh, dat is al aangenamer om lezen. Een lijst met noten afspelen weerhoud je niet om de gewoonlijke parameters te gaan gebruiken:

    play [52, 55, 59], amp: 0.3

Natuurlijk kan je ook de traditionele benaming van de noten gebruiken ipv. de MIDI nummers:

    play [:E3, :G3, :B3]

De gelukkigen onder jullie die wat muziektheorie hebben geleerd, hebben het akkoord E Mineur in het 3de octaaf herkend.

## Toegang tot een lijst

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.

Met lijst indexen tellen we niet 1,2,3… maar 0,1,2…

Laten we dit een beetje meer in detail bekijken. Neem een kijkje naar deze lijst:

    [52, 55, 59]

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:

    puts [52, 55, 59][1]

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:

    # indexes:  0   1   2
               [52, 55, 59]

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…

# 8.2 - Akkoorden

Sonic Pi heeft ingebouwde ondersteuning voor akkoordnamen die lijsten zullen weergeven. Probeer dit voor jezelf:

    play chord(:E3, :minor)

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:

- `chord(:E3, :m7)`
- `chord(:E3, :minor)`
- `chord(:E3, :dim7)`
- `chord(:E3, :dom7)`

## Arpeggio ‘s

We kunnen gemakkelijk akkoorden in arpeggio’s omzetten met de functie ‘play_pattern’:

    play_pattern chord(:E3, :m7)

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:

    play_pattern_timed chord(:E3, :m7), 0.25

We kunnen zelfs een lijst met tijden doorgeven, welke als een tijdscirkel zullen worden behandeld:

    play_pattern_timed chord(:E3, :m13), [0.25, 0.5]

Dit is gelijk aan:

    play 52, sustain: 0.25
    sleep 0.25
    play 55, sustain: 0.5
    sleep 0.5
    play 59, sustain: 0.25
    sleep 0.25
    play 62, sustain: 0.5
    sleep 0.5
    play 66, sustain: 0.25
    sleep 0.25
    play 69, sustain: 0.5
    sleep 0.5
    play 73, sustain: 0.25
    sleep 0.25

Welke wil je liever schrijven?

Note that `play_pattern` and `play_pattern_timed` alter the sustain of the notes to fill the times. You can remove this behavior by setting the `sustain:` opt to `0`:

    play_pattern_timed chord(:E3, :m13), [0.25, 0.5]

# 8.3 - Toonladders

Sonic Pi geeft ondersteuning aan een breed scala van toonladders. Wat dacht je van de toonladder C3 majeur?

    play_pattern_timed scale(:c3, :major), 0.125, release: 0.1

We kunnen zelfs meer octaven vragen:

    play_pattern_timed scale(:c3, :major, num_octaves: 3), 0.125, release: 0.1

Wat dacht je van deze noten in een pentatonische toonladder?

    play_pattern_timed scale(:c3, :major_pentatonic, num_octaves: 3), 0.125, release: 0.1

## Random noten

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:

    use_synth :tb303
    loop do
      play choose(chord(:E3, :minor)), release: 0.3, cutoff: rrand(60, 120)
      sleep 0.25
    end

Probeer verschillende akkoordnamen en cutoff in te geven.

## Akkoorden en toonladders ontdekken

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

Veel plezier en vergeet niet: er zijn geen fouten, alleen kansen.

# 8.4 - Ringen

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.

In de vorige sectie over lijsten zagen we al hoe we elementen door het indexeer mechanisme uit hen konden halen:

    puts [52, 55, 59][1]

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.

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:

    counter = 0
    notes = [52, 55, 59]

We kunnen nu onze teller gebruiken om toegang te krijgen tot een noot in onze lijst:

    puts notes[counter]

Geweldig, we hebben `52`. Nu, laten we onze teller verhogen en krijg een andere noot:

    counter = (inc counter)
    puts notes[counter]

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.

## Ringen maken

We kunnen ringen op twee manieren maken. We kunnen de `ring` functie gebruiken met de elementen van de ring als parameters:

    (ring 52, 55, 59)

Of we kunnen een normale lijst nemen en deze naar een ring omzetten door naar deze een `.ring` bericht te zenden :

    [52, 55, 59].ring

## Ringen Indexeren

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:

    (ring 52, 55, 59)[0] #=> 52
    (ring 52, 55, 59)[1] #=> 55
    (ring 52, 55, 59)[2] #=> 59
    (ring 52, 55, 59)[3] #=> 52
    (ring 52, 55, 59)[-1] #=> 59

## Ringen Gebruiken

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.

## Toonladders en Akkoorden zijn ringen

Handig om weten is dat de lijsten door `scale` en de `chord` opgeroepen, ook ringen zijn en jou toelaten willekeurige indexen te openen.

## Ring Bouwers

Naast de `ring` zijn er een aantal andere functies die een ring voor ons zullen bouwen.

- `range`nodigt je uit om een start en een eindpositie op te geven en de grootte van de stappen.
- `bools` laten het gebruik van `1`s en `0`s om beknopte booleaans te vertegenwoordigen.
- `knit` laat jou een sequentie met repeterende waarden breien.
- `spread` creëert een ring van een boleaanse met een Euclidische distributie.

Neem een kijkje naar hun respectievelijke documentatie voor meer informatie hierover.

# 8.5 - Ring Kettingen

Als toevoeging tot de bouwers zoals `range`en `spread`is het manipuleren van bestaande ringen, een andere manier om nieuwe ringen te maken.

## Ketting Commando’s

Neem deze eenvoudige ring om dit te verkennen:

    (ring 10, 20, 30, 40, 50)

Wat als we deze andersom willen? Dan kunnen we het chain commando `.reverse nemen om de ring om te draaien:

    (ring 10, 20, 30, 40, 50).reverse  #=> (ring 50, 40, 30, 20, 10)

En wat als we de eerste drie waarden van de ring willen nemen?

    (ring 10, 20, 30, 40, 50).take(3)  #=> (ring 10, 20, 30)

En wat als we de ring willen verschuiven?

    (ring 10, 20, 30, 40, 50).shuffle  #=> (ring 40, 30, 10, 50, 20)

## Meerdere Kettingen

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.

Wat denk je ervan de ring te shuffelen, 1 element te laten vallen en vervolgens de volgende 3 te nemen?

Laten we dit in fasen doen:

1. `(ring 10, 20, 30, 40, 50)` - our initial ring
2. `(ring 10, 20, 30, 40, 50).shuffle` - shuffles - `(ring 40, 30, 10, 50, 20)`
3. `(ring 10, 20, 30, 40, 50).shuffle.drop(1)` - drop 1 - `(ring 30, 10, 50, 20)`
4. `(ring 10, 20, 30, 40, 50).shuffle.drop(1).take(3)` - take 3 - `(ring 30, 10, 50)`

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.

## Onveranderbaarheid

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.

## Beschikbare Chain Methoden

Hier is een lijst van de beschikbare chain methoden voor jou om mee te spelen:

- ‘.reverse’ - geeft een omgekeerde versie van de ring
- ‘.sort’ - creëert een gesorteerde versie van de ring
- ‘.shuffle’ - creëert een geshuffelde versie van de ring
- `.pick` - geeft een ring met de resultaten van de aanroep `.choose` 1 keer
- ‘.pick(3)’ - geeft een ring met de resultaten van de aanroep `.choose` 3 keer
- ‘.take(5)’ - geeft als resultaat een nieuwe ring die alleen eerste 5 elementen bevat
- ‘.drop(3)’ - geeft als resultaat een nieuwe ring met alles behalve de eerste 3 elementen
- ‘.butlast’ - geeft als resultaat een nieuwe ring maar ontbreekt het laatste element
- ‘.drop_last(3)’ - geeft als resultaat een nieuwe ring maar de laatste 3 elementen ontbreken
- ‘.take_last(6)’-geeft als resultaat een nieuwe ring met alleen de laatste 6 elementen
- ‘.stretch(2)’ - herhaald tweemaal elk element in de ring
- ‘.repeat(3)’ - herhaalt de hele ring 3 keer
- ‘.mirror’ - voegt de ring naar een omgekeerde versie van zichzelf toe
- ‘.reflect’ - hetzelfde als spiegel maar middelste waarde wordt niet gedupliceerd
- `.scale(2)`- geeft een nieuwe ring met alle elementen, maal 2 (van uitgegaan dat ring alleen cijfers bevat)

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.

# 9 - Live Coderen

É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.

In deze sectie zullen we de fundamenten bespreken hoe je je statische code kan omvormen tot een dynamische voorstelling.

Zit je goed? …

# 9.1 - Live Coderen

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:

- Code kunnen schrijven dat geluiden kan voortbrengen - CHECK!
- Functies kunnen schrijven - CHECK!
- (benoemde) Threads kunnen gebruiken - CHECK!

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:

    define :my_sound do
      play 50
      sleep 1
    end
    in_thread(name: :looper) do
      loop do
        my_sound
      end
    end

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.

Wat we hier hebben is een functie-definitie die noot 50 speelt en één beat slaapt. Vervolgens definiëren we een thread genaamd `:looper` die herhaaldelijk rond `my_loop` loopt.

Als u deze code uitvoert, zult je noot 50 altijd opnieuw en opnieuw horen spelen…

## Veranderingen aanbrengen

Nu, Dit is waar de pret begint. Terwijl de code nog loopt verander de 50 in een ander nummer, bijvoorbeeld 55, en druk nogmaals op de Afspelen-knop. Woah! Het veranderd! Live!

Het heeft geen nieuwe laag toegevoegd omdat we threads met een naam gebruiken, voor elke naam is maar één thread toegestaan. Het geluid veranderde omdat we de functie hebben geherdefinieerd. We gaven `:my_loop` een nieuwe definitie. Toen de `:looper` thread opnieuw wilde beginnen riep deze de nieuwe definitie op.

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:

    define :my_loop do
      use_synth :tb303
      play 50, release: 0.3
      sleep 0.25
    end

Nu het klinkt erg interessant, maar we kunnen het verder verlevendigen. In plaats van dezelfde noot opnieuw en opnieuw te spelen, speel een akkoord:

    define :my_loop do
      use_synth :tb303
      play chord(:e3, :minor), release: 0.3
      sleep 0.5
    end

Wat denk je van random noten van het akkoord te spelen:

    define :my_loop do
      use_synth :tb303
      play choose(chord(:e3, :minor)), release: 0.3
      sleep 0.25
    end

Of met behulp van een willekeurige cutoff waarde:

    define :my_loop do
      use_synth :tb303
      play choose(chord(:e3, :minor)), release: 0.2, cutoff: rrand(60, 130)
      sleep 0.25
    end

Ten slotte, voeg enkele drums toe:

    define :my_loop do
      use_synth :tb303
      sample :drum_bass_hard, rate: rrand(0.5, 2)
      play choose(chord(:e3, :minor)), release: 0.2, cutoff: rrand(60, 130)
      sleep 0.25
    end

Nu word het steeds spannender!

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…

# 9.2 - Live Loops

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.

Als je de vorige sectie niet gelezen hebt, `live_loop` is de beste manier om met Sonic Pi te jammen.

Laten we hiermee even spelen. Schrijf het volgende in een nieuwe buffer:

    live_loop :foo do
      play 60
      sleep 1
    end

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.

Woeha! Het veranderde automatisch zonder een tel te missen. Dit is Live Coding.

Waarom deze niet veranderen aar iets meer Bass-achtig? Gewoon je code updaten terwijl het speelt:

    live_loop :foo do
      use_synth :prophet
      play :e1, release: 8
      sleep 8
    end

Sla Afspelen aan.

Laten we de cutoff wat rond-bewegen:

    live_loop :foo do
      use_synth :prophet
      play :e1, release: 8, cutoff: rrand(70, 130)
      sleep 8
    end

Sla Afspelen opnieuw aan.

Voeg wat drums toe:

    live_loop :foo do
      sample :loop_garzul
      use_synth :prophet
      play :e1, release: 8, cutoff: rrand(70, 130)
      sleep 8
    end

Verander de noot van `e1` naar `c1`:

    live_loop :foo do
      sample :loop_garzul
      use_synth :prophet
      play :c1, release: 8, cutoff: rrand(70, 130)
      sleep 8
    end

Stop nu met naar mij te luisteren en ga zelf aan de slag! Veel plezier!

# 9.3 - Meerdere Live Loops

Beschouw even de volgende code:

    live_loop :foo do
      play 50
      sleep 1
    end

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.

Er kunnen nooit twee live loops met de zelfde naam afspelen.

Dit betekent dat als we willen dat meerdere live loops gelijktijdig willen uit voeren, moeten we ze gewoon een andere naam geven:

    live_loop :foo do
      use_synth :prophet
      play :c1, release: 8, cutoff: rrand(70, 130)
      sleep 8
    end
    live_loop :bar do
      sample :bd_haus
      sleep 0.5
    end

Je kan nu elke live loop onafhankelijk van elkaar wijzigen en updaten en het werkt gewoon allemaal.

## Synchroniseren van Live Loops

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.

Beschouw even deze slecht gesyncte code:

    live_loop :foo do
      play :e4, release: 0.5
      sleep 0.4
    end
    live_loop :bar do
      sample :bd_haus
      sleep 1
    end

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` :

    live_loop :foo do
      play :e4, release: 0.5
      sleep 0.5
    end
    live_loop :bar do
      sample :bd_haus
      sleep 1
    end

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:

    live_loop :foo do
      play :e4, release: 0.5
      sleep 0.5
    end
    live_loop :bar do
      sync :foo
      sample :bd_haus
      sleep 1
    end

Wow, nu is alles perfect in tijd - allemaal zonder te stoppen.

Ga nu door met je live code en live loops!

# 9.4 - Ticking

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.

## Tick Ringen

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:

    counter = 0
    live_loop :arp do
      play (scale :e3, :minor_pentatonic)[counter], release: 0.1
      counter += 1
      sleep 0.125
    end

Dit is gelijk aan:

    live_loop :arp do
      play (scale :e3, :minor_pentatonic).tick, release: 0.1
      sleep 0.125
    end

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:

    live_loop :arp do
      play (scale :e3, :minor_pentatonic).tick, release: 0.1
      sleep 0.125
    end
    live_loop :arp2 do
      use_synth :dsaw
      play (scale :e2, :minor_pentatonic, num_octaves: 3).tick, release: 0.25
      sleep 0.25
    end

## Tick

U kunt ook `tick` als een standaard fn aanroepen en de waarde gebruiken als een index:

    live_loop :arp do
      idx = tick
      play (scale :e3, :minor_pentatonic)[idx], release: 0.1
      sleep 0.125
    end

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.

## Kijk

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.

## Ticks Benoemen

En nog dit, soms heb je meer dan één tick per live loop nodig. Dat kan je door je tick een naam te geven:

    live_loop :arp do
      play (scale :e3, :minor_pentatonic).tick(:foo), release: 0.1
      sleep (ring 0.125, 0.25).tick(:bar)
    end

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`.

## Maak het niet te ingewikkeld

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.

Neem een kijkje naar de documentatie ‘Tick’ waar nuttige voorbeelden te vinden zijn. Nog een leuke tick verder!

# 10 - Tijd toestand

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

Sonic Pi’s oplossing voor het probleem van “makkelijk werken met globale variabelen op een deterministische wijze” is door een vernieuwend systeem dat “Time State” heet. Dit kan ingewikkeld en moeilijk klinken (in feite is programmeren met meerdere threads en een gedeeld geheugenmodel typisch een onderwerp op universitair niveau). Echter, zoals je zult zien, is het net als het spelen van de eerste noot. Sonic Pi maakt het ontzettend eenvoudig om toestand te delen tussen threads terwijl je programma’s nog steeds thread safe en deterministisch blijven.

Maak kennis met `get` en `set`…

# 10.1 - Set en get

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…

## Set

Om informatie op te slaan in de tijd toestand hebben we twee dingen nodig:

1. de informatie die we willen opslaan,
2. een unieke naam (sleutel) voor de informatie.

We willen bijvoorbeeld het getal `3000` opslaan met de sleutel `:intensiteit`. Dit is mogelijk door de `set` functie te gebruiken:

    set :intensiteit, 3000

We kunnen elke naam gebruiken voor onze sleutel. Wanneer informatie al was opgeslagen voor die sleutel, dan overschrijft de nieuwe `set` die:

    set :intensiteit, 1000
    set :intensiteit, 3000

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.

## Get

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:

    print get[:intensiteit] #=> print 3000

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.

## Meerdere threads

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:

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

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:

    {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

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

## Een simple deterministisch toestandssysteem

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:

    ## 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

Laten we kijken hoe dit eruit ziet wanneer we `get` en `set` gebruiken:

    ## 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

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.

Gebruik daarom wanneer je informatie deelt tussen live lussen en threads `get` en `set` in plaat van variabelen voor deterministisch en reproduceerbaar gedrag.

# 10.2 - Sync (synchroniseren)

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 *.

## Wachten op gebeurtenissen

Laten we kort kijken naar hoe `sync` gebruikt wordt om op nieuwe gebeurtenissen te wachten die worden toegevoegd aan tijd toestand:

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

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.

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.

## Doorgeven van waarde aan de toekomst

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:

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

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.

# 10.3 - Patroonherkenning

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.

## Komt overeen met ieder pad segment

Laten we aannemen dat wij willen wachten op een volgend event dat beschikt over drie pad segmenten:

    sync "/*/*/*"

Dit zal overeenkomen met ieder ‘Time State’ event met exact drie pad segmenten, ongeacht hun namen. Bijvoorbeeld:

- `cue "/bla/bar/baz"`
- `cue "/bla/baz/quux"`
- `cue "/eggs/beans/toast"`
- `cue "/moog/synths/rule"`

Het zal echter niet matchen voor paden met minder of meer pad segmenten. Het volgende zal niet matchen:

- `cue "/bla/bar"`
- `cue "/bla/baz/quux/quaax"`
- `cue "/eggs"`

Iedere `*` betekent elke inhoud. We kunnen paden matchen met slechts één segment met `/*` of paden met vijf segmenten middels `/*/*/*/*/*`

## Matcht gedeeltelijke segmenten

Als we weten waar een segment mee zal beginnen of eindigen kunnen dat deel segment samen met `*` gebruiken. Bijvoorbeeld: `"/bla/b*/baz"` zal elk pad matchen dat drie segmenten heeft waarbij het eerste `bla` en het laatste `baz` is, het middelste segment kan alles zijn dat begint met een `b`. Dus het volgende zal matchen:

- `cue "/bla/bar/baz"`
- `cue "/bla/baz/baz"`
- `cue "/bla/beans/baz"`

Het zou echter niet matchen met het volgende:

- `cue "/bla/flibble/baz"`
- `cue "/bla/abaz/baz"`
- `cue "/bla/beans/baz/eggs"`

Je kunt ook een `*` aan het begin van een segment zetten om te matchen met laatste tekens van het segment: `"/bla/*ux/baz"` welke matcht met een `cue` of `set` van 3 segmenten, waarbij het eerste `bla` en het laatste `baz` is, het middelste segment eindigd met `ux`. Zoals bijvoorbeeld:

## Matcht Geneste Pad Segmenten

Soms weet je niet uit hoeveel segmenten een pad dat je wilt matchen bestaat. In dat geval kun je gebruik maken van de krachtige dubbele asterix: `**`. Zo zal `"/bla/**/baz"` met het volgende matchen:

- `cue "/bla/bar/baz"`
- `cue "/bla/bar/beans/baz"`
- `cue "/bla/baz"`
- `cue "/bla/a/b/c/d/e/f/baz"`

## Matcht Alleenstaande Letters

Je kunt het `?` karakter gebruiken om te matchen met een single karakter zoals `"/?oo/bar/baz"` wat zal matchen met:

- `cue "/bla/bar/baz"`
- `cue "/goo/bar/baz"`
- `cue "/too/bar/baz"`
- `cue "/woo/bar/baz"`

## Matcht Met Meerdere Woorden

Als je weet dat een segment een van een select aantal woorden moet matchen kun je `{` en `}` haken gebruiken om een lijst van keuzes te geven. Zo zal `"/bla/{bar,beans,eggs}/quux"` alleen met het volgende matchen:

- `cue "/bla/bar/quux"`
- `cue "/bla/beans/quux"`
- `cue "/bla/eggs/quux"`

## Matcht Met Meedere Letters

Als laatste kun je ook matchen op een selectie van letters door de `[` en `]` haken te gebruiken om een lijst van keuzes aan te geven. Zo al `"/bla/[abc]ux/baz"` alleen met het volgende matchen:

- `cue "/bla/aux/baz"`
- `cue "/bla/bux/baz"`
- `cue "/bla/cux/baz"`

Je kunt ook een `-` gebruiken om aan te geven dat het om een rij van letters gaat. Zo zal `"/bla/[a-e]ux/baz"` alleen matchen met:

- `cue "/bla/aux/baz"`
- `cue "/bla/bux/baz"`
- `cue "/bla/cux/baz"`
- `cue "/bla/dux/baz"`
- `cue "/bla/eux/baz"`

## Gecombineerde Matches

Wanneer `sync` of `get` wordt aangeroepen ben je geheel vrij de `Matchers` in iedere volgorde te gebruiken met elk `Time State` event aangemaakt door `cue` of `set`. Laten we het volgende (ver gezochte) voorbeeld bekijken:

    in_thread do
      sync "/?la/[a-z]*/**/ba*/{quux,quaax}/"
      sample :loop_amen
    end
    sleep 1
    cue "/bla/beans/a/b/c/d/e/bark/quux/"

## OSC Patroon Matching

Voor de nieuwsgierigen; deze matching regels zijn gebaseerd op de Open Sound Control Pattern Matching Specification welke uitgebreid uitgelegd staat op de volgende website: http://opensoundcontrol.org/spec-1_0

# 11 - MIDI

Wanneer je het converteren van code naar muziek volledig beheerst, zou je jezelf kunnen afvragen: “Wat is het volgende?”. Soms kan het uitsluitend werken binnen de syntax van Sonic Pi en het geluidssysteem uitdagend genoeg zijn om je in een nieuwe creatieve positie te stoppen. Het is echter soms noodzakelijk om uit de code naar de echte wereld te stappen. We willen twee extra dingen:

1. Om acties vanuit de echte wereld te converteren naar Sonic Pi events om mee te coderen
2. Om vanuit Sonic Pi’s sterke timing model en semantiek objecten in de echte wereld te controleren en manipuleren

Gelukkig bestaat er sinds de jaren 80 een protocol wat precies deze interactie levert - MIDI. Er is een groot aantal externe apparaten beschikbaar, waaronder keyboards, controllers en sequencers, naast diverse pro audio software die allemaal MIDI ondersteunen. We kunnen MIDI gebruiken om data op te halen en te versturen.

Sonic Pi levert volledige ondersteuning voor het MIDI protocol waarmee je jouw live code kunt verbinden aan de echte wereld. Laten we hier verder induiken.

# 11.1 - MIDI in

In deze sectie zullen we leren hoe een MIDI controller events kan sturen naar Sonic Pi, om de synthesizer en geluiden te controleren. Gebruik een MIDI controller zoals een keyboard en steek de handen uit de mouwen!

## Verbinden van een MIDI Controller

Om informatie van een extern MIDI apparaat in te lezen in Sonic Pi zullen we eerst moeten verbinden met onze computer. Dit zal meestal gebeuren via een USB verbinding, alhoewel oudere apparatuur over een 5-pin DIN connector beschikt waarvoor extra computer hardware is benodigd (bijvoorbeeld een geluidskaart). Zodra het apparaat verbonden is kan Sonic Pi worden gestart en het IO venster in het Voorkeuren (‘Preferences’ panel) worden bekeken. Je apparaat zou daar zichtbaar moeten zijn. Indien dit niet het geval is kan geprobeerd worden de ‘Reset MIDI’ knop in te drukken. Indien hierna nog steeds niets gezien kan worden is controleren van de besturingssysteem MIDI configuratie, om te bekijken of hier het apparaat wel tussen staat. Indien dit allemaal niet werkt, voel je vrij om hulp te vragen op onze forums: https://in-thread.sonic-pi.net

## Ontvangen Van MIDI Events

Wanneer je apparaat verbonden is zal Sonic Pi automatisch events ontvangen. Je kunt dit zelf zien door het manipuleren van je MIDI apparaat en de ‘Cue’ logger rechts onderin het venster te bekijken (onder de log). Wanneer dit niet zichtbaar is kan naar Voorkeuren->Editor->Show & Hide genavigeerd worden, waar de ‘Show Cue Log’ checkbox ingeschakeld kan worden. Een opeenvolging van event zoals de volgende is zichtbaar:

    /midi:nanokey2_keyboard:0:1/note_off  [55, 64]
    /midi:nanokey2_keyboard:0:1/note_on   [53, 102]
    /midi:nanokey2_keyboard:0:1/note_off  [57, 64]
    /midi:nanokey2_keyboard:0:1/note_off  [53, 64]
    /midi:nanokey2_keyboard:0:1/note_on   [57, 87]
    /midi:nanokey2_keyboard:0:1/note_on   [55, 81]
    /midi:nanokey2_keyboard:0:1/note_on   [53, 96]
    /midi:nanokey2_keyboard:0:1/note_off  [55, 64]

Als een opeenvolging van berichten zoals deze zichtbaar is, is het MIDI apparaat succesvol verbonden. Gefeliciteerd, laten wij is kijken wat we hiermee kunnen doen!

## MIDI Time State

Deze events kunnen worden gescheiden in twee secties. Enerzijds zijn de namen van events zoals `/midi:nanokey2_keyboard:0:1/note_on` zichtbaar, anderzijds zijn waarden van events zoals `[18, 62]` te zien. Deze twee zaken zijn benodigd om informatie op te slaan binnen Time State. Sonic Pi voert automatisch events afkomstig van MIDI in naar TIme State. Dit betekent dat de laatste MIDI waarden en eveneens `sync` wacht op de volgende MIDI waarde, zoals omschreven in sectie 10 van deze handleiding.

## Besturingscode

Nu een MIDI apparaat is verbonden, zijn diverse events zichtbaar in de `cue log` en kan worden herkend dat onze kennis van Time State alles is wat we nodig hebben om met de events te werken. Nu kunnen we plezier hebben en een eenvoudige MIDI piano maken:

    live_loop :midi_piano do
      note, velocity = sync "/midi:nanokey2_keyboard:0:1/note_on"
      synth :piano, note: note
    end

Er gebeuren een aantal dingen in de bovenstaande code, waaronder een aantal problemen. Ten eerste beschikken we over een eenvoudige `live_loop` die voortdurend herhaald zal worden tussen de `do` en `end` blokken. Dit werd geïntroduceerd in sectie 9.2. Ten tweede roepen we `sync` aan om te wachten op het volgende matchende Time State event. We gebruiken een string waarde die het MIDI bericht representeerd waar wij op wachten (hetzelfde als in de `Cue Logger`). Merk op dat deze lange string geleverd wordt door Sonic Pi’s automatisch aanvullingen (autocomplete) systeem, waardoor het niet allemaal met de hand getypt hoeft te worden. In de log zagen wij dat er twee waarden voor iedere MIDI noot per event zichtbaar waren, het resultaat kan daarom gedeclareerd worden aan twee variabelen `note` en `velocity`. Tot slot kan de `:piano` synthesizer worden aangeroepen door onze noot.

Nu kun jij het proberen. Type in de bovenstaande code een sync key met een matchende string specifiek voor jouw MIDI apparaat en klik op Run. Nu heb je een werkende piano! Er zullen je echter een aantal problemen opvallen. Ten eerste zijn alle tonen hetzelfde volume ongeacht hoe hard jij op je keyboard drukt. Dit kan eenvoudig worden opgelost door deze `velocity` midi waarde te converteren naar een amplitude. Er is gegeven dat MIDI een bereik heeft van 0->127, om dit te converteren naar een waarde tussen 0 en 1 kan worden gedeeld door 127:

    live_loop :midi_piano do
      note, velocity = sync "/midi:nanokey2_keyboard:0:1/note_on"
      synth :piano, note: note, amp: velocity / 127.0
    end

Update de code en klik opnieuw op Run. Nu zal de velocity van het keyboard worden gehonoreerd. We kunnen nu die irritante pauze oplossen.

## Verwijderen van Latency

Alvorens we de pauze kunnen verwijderen, moeten wij onderzoeken waarom deze hier is. Om alle synthesizers en effecten goed te timen tussen verschillende capabele processoren (CPU’s) maakt Sonic Pi gebruik van een vertraging van standaard 0.5s. (Merk op dat deze latency geconfigureerd kan worden middels de fns `set_sched_ahead_time!` en `use_sched_ahead_time`). Deze latency van 0.5s wordt toegevoegd aan onze `:piano` synthesizer triggers zoals bij alle synthesizers getriggerd via Sonic Pi. De motivatie voor deze latency is de garantie dat alle events goed worden getimed. Dit heeft alleen uitsluitend nut bij code die gebruik maakt van `play` en `sleep`. In dit geval triggeren wij de `:piano` synthesizer met een extern MIDI apparaat en willen we niet dat Sonic Pi deze timing bepaald voor ons. We kunnen deze latency uitschakelen middels het `use_real_time` commando, die de latency voor de huidige thread zal uitschakelen. Dit betekent dat een real-time mode voor live loops qua timing bestuurd zal worden via `sync`ing met externe apparaten en alle overige loops wel gewoon de standaard latency gebruiken. Laten we hier naar kijken:

    live_loop :midi_piano do
      use_real_time
      note, velocity = sync "/midi:nanokey2_keyboard:0:1/note_on"
      synth :piano, note: note, amp: velocity / 127.0
    end

Update je code om te matchen met de bovenstaande code en druk opnieuw op Run. We hebben nu een piano met lage latency en variabele velocity gecodeerd in slechts 5 regels. Was dat niet makkelijk!

## Waarden Ophalen

Tot slot zullen onze MIDI events direct naar de Time State gaan, we kunnen eveneens gebruik maken van de `get` fn om de laatst gelezen waarde op te vragen. Dit zal niet de huidige thread blokkeren en geeft `nil` terug indien geen data gevonden kan worden (dit kan worden overschreven met een standaard waarde, zie de documentatie voor `get`). Herinner je dat de aanroep `get` in iedere thread iedere tijd mag plaatsvinden om de laatste matching Time State waarde op te vragen. Zelfs `time_warp` kan worden gebruikt om terug te gaan in de tijd en om via `get` events uit het verleden te bekijken…

## Nu heb jij de Besturing

Het leukste ding om nu te doen is het gebruik maken van code structuren om `sync` en `get` MIDI informatie van iedere MIDI apparaat op te halen. Je kunt nu kiezen wat je MIDI apparaat zal doen!

# 11.2 - MIDI Uit

Naast de ontvangst van MIDI events kunnen MIDI events ook verzonden worden om externe hardware synthesizers, keyboards en andere apparaten te manipuleren. Sonic Pi levert een volledige set van functies om diverse MIDI berichten te versturen, zoals:

1. Note aan - `midi_note_on`
2. Note uit - `midi_note_off`
3. Control verandering - `midi_cc`
4. Pitch benden - `midi_pitch_bend`
5. Klok tikken - `midi_clock_tick`

Er zijn vele andere ondersteunde MIDI berichten - bekijk de API documentatie voor alle functies die starten met `midi_`.

## Verbinden met een MIDI apparaat

Om een MIDI bericht naar een extern apparaat te versturen, moet deze eerst zijn verbonden. Bekijk de subsectie ‘Verbinden van een MIDI Controller’ in sectie 11.1 voor meer details. Merk op dat wanneer USB wordt gebruikt, het verbinden naar een apparaat waar data toe wordt verzonden (anders dan ontvangen) dezelfde procedure is. Indien gebruik wordt gemaakt van DIN connectoren moet verbonden worden met de ‘MIDI out’ poort van de computer. Hiervoor moet je MIDI apparaat in het voorkeuren paneel zichtbaar zijn.

## Versturen van MIDI events

De vele `midi_*` functies werken zoals `play`, `sample` en `synth` op de manier dat ze een bericht sturen via de huidige (logische) tijd. Om bijvoorbeeld calls uit te delen naar `midi_*` functies kan `sleep` worden gebruikt, zoals gedaan via `play`. Laten we hiernaar kijken:

    midi_note_on :e3, 50

Dit zal een MIDI noot versturen naar het verbonden MIDI apparaat met velocity 50. (Merk op dat Sonic Pi automatisch noten converteert in de vorm `:e3` naar de equivalente MIDI nummers zoals, in dit geval, 52.)

Indien je verbonden MIDI apparaat een synthesizer betreft, zou je een noot moeten kunnen horen. Om dit uit te schakelen kan `midi_note_off` worden gebruikt:

    midi_note_off :e3

## Selecteren van een MIDI apparaat

Sonic Pi zal standaard alle MIDI berichten naar alle aangesloten apparaten op alle MIDI kanalen versturen. Dit is om het eenvoudig te maken om één aangesloten apparaat te werken, zonder dat er instellingen hoeven worden aangepast. Maar, soms verwerkt een MIDI apparaat een MIDI kanaal op een afwijkende manier (wellicht krijgt elke noot zijn eigen kanaal) en wellicht wil je meerdere MIDI apparaten tegelijk aansluiten. In zulke meer ingewikkelde opstellingen, wil je specifieker kunnen aangeven welke berichten naar welk apparaat en kanaal gaan.

We kunnen aangeven naar welk apparaat gestuurd gaat worden door de `port:` optie mee te geven. Gebruik de apparaat naam zoals in de voorkeuren staat:

    midi_note_on :e3, port: "moog_minitaur"

We kunnen ook aangeven via welk kanaal gestuurd gaat worden met de `channel:` optie (gebruik een waarde tussen 1-16):

    midi_note_on :e3, channel: 3

Natuurlijk kunnen we ze ook beide tegelijk meegeven om naar een specifiek apparaat op een specifiek kanaal te sturen:

    midi_note_on :e3, port: "moog_minitaur", channel: 5

## MIDI Studio

En als laatste, wat ook leuk is om te doen, is om de audio-uitgang van je MIDI synthesizer aan te sluiten op een van de audio-ingangen (line-in) van je audio-apparaat.Op deze manier kun je synthesizer bedienen via de `midi_*` functies en ook het geluid van je synthesizer daarna weer bewerken via `live_audio` en effecten:

    with_fx :reverb, room: 1 do
      live_audio :moog
    end
    live_loop :moog_trigger do
      midi (octs :e1, 3).tick, sustain: 0.1
      sleep 0.125
    end

(De functie `midi` is beschikbaar als een handige notatie om zowel “note aan” als “note uit” events te sturen in één commando. Bekijk de `midi` documentatie voor meer informatie).

# 12 - OSC

Naast MIDI is er nog een andere manier om berichten uit te wisselen met Sonic Pi. Over het netwerk gebruik je dan een eenvoudig protocol dat OSC - Open Sound Control heet. Dit stelt je in staat om berichten met externe programma’s uit te wisselen (zowel als deze op je eigen computer draait of zelfs op een andere computer op het netwerk). Dit opent meer mogelijkheden dan MIDI bied, welke door zijn ontwerp uit de 1980s, wat gelimiteerd is.

Je zou bijvoorbeeld een programma kunnen schrijven in een andere programmeertaal dat OSC berichten kan sturen en ontvangen en zo direct kunt communiceren met Sonic Pi. Er is voor bijna elke gebruikelijke taal een library voor gemaakt die je kunt gebruiken in je programma. Hoe je deze interactie mogelijk wilt gebruiken is volledig aan jou.

# 12.1 - OSC Ontvangen

Wanneer Sonic Pi opstart zal het standaard luisteren, op poort 4560, naar inkomende OSC berichten, van programma’s op dezelfde computer. Dit betekend dat je zonder dat je iets hoeft aan te passen, Sonic Pi OSC berichten kunt sturen, welke worden weergegeven in de cue log, net als inkomende MIDI berichten. Dit betekend ook dat alle inkomende OSC berichten worden toegevoegd aan de “Time State”, zodat je `get` en `sync` kan laten werken met ontvangen gegevens - net als dat dat met MIDI en synchronisatie van `live_loop`s kan - zie secties 5.7 en 10.2 voor meer informatie over hoe dat werkt.

## Een basis OSC berichten afhandelaar

Laten we een basis OSC berichten afhandelaar maken:

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

In dit voorbeeld beschrijven het volgende OSC pad `"/osc*/trigger/prophet"` waarop we synchroniseren. Dit kan elk geldig OSC pad zijn. Een geldig pad mag alle letters en cijfers bevatten waarbij de `/`, zoals bij URLs, word gebruikt om het pad in meerdere woorden op te delen. Het `/osc` voorvoegsel word door Sonic Pi toegevoegd aan alle OSC berichten, dus we moeten OSC berichten sturen met pad `/trigger/prophet` om onze `sync` te laten doorlopen en de prophet synth te triggeren.

## OSC berichten sturen naar Sonic Pi

We kunnen vanuit elke programmeertaal met een OSC module berichten naar Sonic Pi sturen. Als je bijvoorbeeld een OSC bericht wilt sturen vanuit Python kun je iets als dit doen:

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

Of, als je een OSC bericht vanuit Closure wilt sturen kunt het volgende doen vanuit de interactieve input omgeving (REPL):

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

## Ontvang van andere computers

Vanwege veiligheidsvoorzorgen laat Sonic Pi niet standaard machines op afstand OSC-berichten verzenden. Maar je kan dit toestaan in Voorkeuren->IO->Netwerk->Ontvang OSC-berichten op afstand. Wanneer je dit hebt aangezet, kan je OSC-berichten van elke computer op je netwerk ontvangen. Normaal zal de versturende machine moeten weten wat het IP-adres is (een unieke waarde die je computer identificeert op je netwerk - net als een telefoonnummer of een emailadres). Je kan je eigen IP-adres opzoeken door te kijken naar de IO-sectie in het voorkeursscherm. Als je computer meerdere IP-adressen heeft, ga dan met de muis over het adres om een lijst van alle bekende adressen te krijgen.

Weet dat sommige programma’s, zoals TouchOSC for iPhone en Android het versturen van OSC-berichten standaard ondersteunen. Dit betekent dat wanneer je luistert naar computers die van buitenaf berichten versturen en je weet je IP-adres, je meteen berichten kan gaan versturen van apps zoals TouchOSC waarmee je je eigen gebouwde drukknoppen en schuifregelaars, knoppen en draaiknoppen kan maken en zo meer. Hiermee kan je een ongelooflijke hoeveelheid inputmogelijkheden creëren.

# 12.2 - Versturen van OSC

Naast het ontvangen van OSC berichten in combinatie met “Time State”, kunnen we ook OSC berichten op de maat van de muziek versturen (net als dat we MIDI berichten in de maat van de muziek kunne sturen). We hoeven alleen te weten naar welk IP-adres en port we moeten sturen. Probeer maar eens:

    use_osc "localhost", 4560
    osc "/hello/world"

Als je bovenstaande code afspeelt zul je merken dat Sonic Pi zichzelf een OSC bericht stuurt! Omdat we het IP-adres van de huidige computer en de standaard OSC poort hebben aangegeven. Dit komt eigenlijk neer op jezelf een brief sturen - het OSC berichtje word aangemaakt, verlaat Sonic Pi, en komt via het netwerk en je besturings-systeem weer terug bij Sonic Pi. Die het ontvangt en afhandelt als elk ander OSC berichtje. Vervolgens word het berichtje zichtbaar in het cue log als een ingekomen bericht: `/osc:127.0.0.1:4560/hello/world`. (Zie je dat Sonic Pi automatisch alle inkomende OSC berichten aanvult met `/osc` de hostnaam en de poort aan het begin.)

## Stuur OSC berichten naar andere programma’s

Naar jezelf een OSC berichtje sturen is natuurlijk reuze leuk, maar handig is anders. Het echte voordeel hiervan krijg je wanneer je berichten naar andere programma’s stuurt:

    use_osc "localhost", 123456
    osc "/hello/world"

In dit geval nemen we aan dat er een ander programma op dezelfde computer luistert naar poort 123456. Als die er is zal het een `"/hello/world"` OSC bericht ontvangen, waarmee het kan doen wat het wil.

Als dat programma op een andere machine draait, hebben we het IP-adres nodig van die machine en dat gebruiken in plaats van `"localhost"`:

    use_osc "192.168.10.23", 123456
    osc "/hello/world"

Nu kunnen we OSC berichten sturen naar elk apparaat dat via ons lokale netwerk en zelf het internet bereikbaar is!

# 13 - Multi-kanaal Audio

Tot nu toe hebben we het als we het hebben over muziek maken gehad over het triggeren van opgenomen geluiden via de `play`, `synth` en `sample` functies. Deze hebben vervolgens geluiden gegenereerd en ten gehore gebracht op onze stereo speakers. Maar, veel computers bieden ook de mogelijk om geluid te ontvangen, mogelijk met een microfoon en om geluid naar meer dan twee speakers te sturen. Vaak word dit mogelijk gemaakt door gebruik te maken van een externe geluidskaart - deze zijn beschikbaar voor alle systemen. In dit deel van de handleiding gaan we kijken naar hoe we het meeste kunnen halen uit deze extra mogelijkheden en met Sonic Pi moeiteloos kunnen omgaan met meerdere in- en uitgangs kanalen.

# 13.1 - Uitgaand Geluid

Een eenvoudige (en mogelijk bekende) manier om geluids-ingangen te benaderen is het bekende `synth` met de `:sound_in` synth:

    synth :sound_in

Dit werkt eigenlijk gelijk elke andere synth zoals `synth :dsaw` met als bijzonderheid dat het gegenereerde geluid direct uit de eerste geluids-ingang van je computers geluids-kaart word gelezen. Op een laptop is dit meestal de ingebouwde microfoon, maar het je externe geluidskaart dan kun je zelf bepalen wat je in de eerste ingang plugt.

## Duurtijd vergroten

Zoals je merkt duurt het geluid van `:sound_in`, net als bij `synth :dsaw`, maar 1 tel. Ook op `:sound_in` is namelijk de standaard envelope van toepassing. Door de envelope instellingen aan te passen kun je het kanaal langer houden. Het volgende houd de synth bijvoorbeeld 8 tellen open voordat het kanaal weer gesloten word:

    synth :sound_in, sustain: 8

## FX Toevoegen

Natuurlijk kun je net als bij andere synth een effect toepassen met een FX block (`with_fx`):

    with_fx :reverb do
      with_fx :distortion do
        synth :sound_in, sustain: 8
      end
    end

Als als een gitaar hebt aangesloten op de eerste ingang dan kun je deze nu horen met de toegevoegde vervorming en echo totdat de synth zoals verwacht weer stopt.

Je bent helemaal vrij om de `:sound_in` synth zo vaak je maar wilt gelijktijdig te gebruiken (net zoals dat kan met alle andere synth). Het volgende speelt bijvoorbeeld twee `:sound_in` synths tegelijk, waarbij er één met vervorming en één met een echo te horen is:

    with_fx :distortion do
      synth :sound_in, sustain: 8
    end
    with_fx :reverb do
      synth :sound_in, sustain: 8
    end

## Meerdere inputs

Je kunt aangeven welke audio ingang je wilt gebruiken met de `input:` optie. Om een stereo ingang aan te geven (dit zijn eigenlijk twee opvolgende mono kanalen) gebruik je de `:sound_in_stereo` optie van de synth. Heb je bijvoorbeeld een geluidskaart met tenminste drie ingangen, dan kunt je de eerste twee bundelen tot een vervormd stereo geluid en de derde als een mono geluid met echo, met de volgende code:

    with_fx :distortion do
      synth :sound_in_stereo, sustain: 8, input: 1
    end
    with_fx :reverb do
      synth :sound_in, sustain: 8, input: 3
    end

## Mogelijke problemen

Alhoewel dit een handige feature is, heeft het ook zo zijn beperkingen. Allereerst werkt het maar voor een vastgestelde tijd (vanwege de aanwezigheid van de ADSR envelop op alle synth). Ten tweede is er geen manier om de effecten te veranderen zodra de synth is gestart. Beide van deze beperkingen zijn veel gevraagd wanneer er gewerkt word met externe audio, denk hierbij aan microfoons, gitaren en externe synthesizers. Sonic Pi heeft een oplossing voor het probleem van het manipuleren van een (potentieel) oneindig live geluid: `live_audio`.

# 13.2 - Live audio

De `:sound_in` synth zoals beschreven in de vorige sectie bied een flexibele en bekende manier om met ingang audio te werken. Maar, zoals ook beschreven heeft het een paar onhandigheden wanneer het gaat om werken met een enkelvoudig ingangs geluid als een enkel instrument (zoals een stem of een gitaar). De allerbeste manier om met een oneindig geluid te werken is `live_audio` gebruiken.

## Audio ingang met een naam

Er zijn een paar ontwerp beperkingen die `live_audio` deelt met `live_loop` (vandaar dat hun naam gelijk-ig is). Allereerst moet het een unieke naam hebben. Ten tweede mag er ook maar één `live_audio` met dezelfde naam tegelijk bestaan. Zie hier:

    live_audio :bla

Deze code gedraagt zich gelijk aan `synth :sound_in` met een paar belangrijke verschillen: de code blijft altijd actief (tot je het expliciet stopt) en je het dynamisch naar een nieuwe effect context verplaatsen.

## Werken met Effecten

Als een `live_audio` blok als eerste gespeeld word, gedraagt het zich zoals je zou verwachten bij effecten. Om een live geluid van nagalm te voorzien gebruik je gewoon een `:reverb` effect blok:

    with_fx :reverb do
      live_audio :bla
    end

Maar aangezien een `live_audio` geluid maar door blijft gaan (in ieder geval tot je het stopt) zou het best een beperking zijn als, dat zoals bij synths, het gekoppelde effect `:reverb` er voor altijd aan vast zou zitten. Gelukkig is dit niet het geval en was het ontworpen om eenvoudig van effect te wisselen. Laten het eens proberen. Start de code hierboven om het geluid horen dat uit eerst ingang van je geluidskaart komt. Let op, als je een laptop gebruikt zal dit doorgaans de ingebouwde microfoon zijn, het is dus aan te raden om een koptelefoon te gebruiken om rondzingen te voorkomen.

Wijzig, terwijl je de live audio uit de geluidskaart nog met nagalm (reverb) hoort, de code naar het volgende:

    with_fx :echo do
      live_audio :bla
    end

Druk op Afspelen en je zult meteen horen dat het geluid een echo effect heeft gekregen en geen nagalm meer. Als je ze beide wil, pas de code aan en druk op Afspelen:

    with_fx :reverb do
      with_fx :echo do
        live_audio :bla
      end
    end

Het is belangrijk om je er op te wijzen dat je `live_audio :bla` vanuit elke thread or live loop kunt aanroepen zodat het geluid ervan in die threads effect context terecht komt. Je kunt dus eenvoudig vanuit meerdere live loops `live_audio :bla` aanroepen op verschillende momenten, met als resultaat dat de effecten context automatisch word vervangen. Dit zal zeker wat interessante resultaten opleveren.

## Live audio stoppen

Een `live_audio` heeft in tegenstelling tot andere synths geen envelop en zal oneindig doorgaan (zelfs als je de code verwijderd, blijft het code blok actief in het geheugen). Om het stoppen gebruik je het `:stop` argument:

    live_audio :bla, :stop

Hij kan eenvoudig weer gestart worden door de code opnieuw af te spelen zonder het `:stop` argument:

    live_audio :bla

Daar komt nog bij dat alle `:sound_in` synth worden gestopped zodra je op de “Stop” knop hebt gedrukt (net zoals dat met alle andere synths en effecten het geval is).

## Stereo ingang

Als het gaat om audio kanalen werkt `live_audio` gelijk aan de `:sound_in` synth. Het neemt de mono input van de audio en zet dit om in een stereo geluid met de aangegeven balans. Net als bij `:sound_in_stereo`is het ook mogelijk om aan`live_audio` te vertellen om twee opeenvolgende audio ingangen samen te voegen tot een linker en rechter kanaal. Dit doe je door de `:stereo` optie te gebruiken. Om bijvoorbeeld ingang kanaal 2 als links en kanaal 3 als rechts te gebruiken, zet je de `input:` optie op 2 en activeer je de stereo modus op de volgende manier:

    live_audio :bla, stereo: true, input: 2

Zodra je een live audio geluid in stereo modus hebt gestart kun je deze niet weer veranderen naar mono modus zonder te stoppen en te starten. Omgekeerd kun je ook de mono modus niet omzetten naar stereo zonder te stoppen en weer te starten.

# 13.3 - Geluid Uitvoer

Tot nu toe hebben we gekeken naar hoe we meerdere geluiden Sonic Pi binnen krijgen - hetzij door gebruik te maken van `:sound_in` dan wel via het krachtige `live_audio` mechanisme. Naast omgaan met meerdere binnenkomende kanalen kan Sonic Pi ook meerdere uitgaande kanalen afhandelen. Dit word bereikt met het `:sound_out` effect.

## Uitgangs contexten

Laten we snel even herhalen hoe Sonic Pi’s synths en effecten hun geluid in de huidige effecten context krijgen. Kijk bijvoorbeeld eens naar het volgende:

    with_fx :reverb do    # C
      with_fx :echo do    # B
        sample :bd_haus   # A
      end
    end

De eenvoudigste manier om te begrijpen wat er gebeurd met een geluid is te beginnen bij diepst geneste (binnenste) context en naar buiten te werken. In dit geval is de binnenste context aangegeven met `A` waar de `:bd_haus` sample word gespeeld. Het geluid hiervan word direct aan de volgende context `B` (het `:echo` effect) gegeven. Deze voegt de echo toe aan het geluid en geeft dat weer door aan de context `C` (het `:reverb` (nagalm) effect). Deze voegt de nagalm to aan het inkomende geluid en geeft het op zijn beurt weer door aan de buitenste context - de linker en rechter speaker (uitgang 1 en 2 van je geluidskaart).

## Geluid Uitvoer effecten

Bovenstaand gedrag geld voor alle synths (inclusief `live_audio`) en het gros van de effecten met uitzondering van `:sound_out`. Het `:sound_out` effect doet twee dingen. Allereerst geeft het zijn geluid door aan de omliggende context zoals hierboven uitgelegd. Ten tweede zal geluid ook direct naar een uitgang van geluidskaart worden gestuurd. Dat ziet er dan zo uit:

    with_fx :reverb do                 # C
      with_fx :sound_out, output: 3 do # B
        sample :bd_haus                # A
      end
    end

In dit voorbeeld gaat het sample geluid `:bd_haus` naar zijn omvattende context, het `:sound_out` effect in dit geval. Welke het, zoals verwacht, op haar beurt doorgeeft aan zijn omvattende context, het `:reverb` effect. Maar het zal ook een mono mix van het geluid naar de 3de uitgang van de computers geluidskaart sturen. Het geluid door `:sound_out` heeft dan dus twee bestemmingen, het `:reverb` effect en geluidskaart uitgang nummer 3.

## Mono en Stereo uit

Zoals we hebben gezien zal het `:sound_out` effect een mono mix maken van het inkomende stereo geluid. Dit levert wel een stereo geluid op dat (zoals verwacht) aan de buitenste context word gegeven. Als je nou liever geen mono mix wilt doorgeven dan zijn er een aantal alternatieve opties. Allereerst kun je met de `mode:` optie kiezen of je alleen het linker of het rechter inkomende geluid wilt gebruiken. Of je kunt het `:sound_out_stereo` effect gebruiken om twee opeenvolgende uitgangen op je geluidskaart te gebruiken. Meer informatie en voorbeelden kun je in de functie documentatie vinden.

## Direct uit

Zoals we hebben gezien is het standaard gedrag van `:sound_out` en `:sound_out_stereo` om het geluid zowel naar volgende context (dit doen alle effecten) en naar de aangegeven uitgang op geluidskaart te sturen. Soms zul echter wensen dat het geluid alleen maar naar de uitgang op je geluidskaart word gestuurd en niet naar de volgende context (en zodoende dus niet in de mix terecht komt naar uitgang 1 en 2). Dit kun je bereiken door gebruik te maken van de standaard effecten optie `amp:`, welke pas word toegepast nadat het effect is toegepast op het geluid:

    with_fx :sound_out, output: 3, amp: 0 do # B
      sample :loop_amen                      # A
    end

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.

# - Conclusies

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.

Heb je vragen die nog niet behandeld zijn in de tutorial, ga even naar [Sonic Pi forums] (http://groups.google.com/group/sonic-pi/) en stel je vraag daar. Dan vind je vast wel iemand die vriendelijk en bereid is om je een handje te helpen.

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.

Dus speel, heb veel plezier, deel jouw code, treed op voor vrienden, toon jouw scherm en vergeet niet:

Er zijn geen fouten, alleen maar kansen

Sam Aaron

# - MagPi artikelen

Bijlage A verzamelt alle de Sonic Pi artikelen geschreven voor het tijdschrift MagPi.

## Duik in Onderwerpen

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.

## Lees de MagPi

Je kan ze in hun glorieuze professioneel ✓ vorm zien in de gratis PDF-downloads van de MagPi : https://www.raspberrypi.org/magpi/

## Een onderwerp suggereren

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. Jouw suggestie kan wel eens het onderwerp van het volgende artikel zijn!

# - Vijf Top Tips

## 1. Er bestaan geen fouten

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.

## 2. FX gebruiken

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:

    sample :loop_garzul
    16.times do
      sample :bd_haus
      sleep 0.5
    end

Als je een FX aan de `:loop_garzul` sample wil toevoegen, moet je deze gewoon in een `with_fx` blok steken zoals hier:

    with_fx :flanger do
      sample :loop_garzul
    end
    16.times do
      sample :bd_haus
      sleep 0.5
    end

Als je nu ook een FX aan de bass drum wil voegen, omhul deze dan ook met een `with_fx`:

    with_fx :flanger do
      sample :loop_garzul
    end
    with_fx :echo do
      16.times do
        sample :bd_haus
        sleep 0.5
      end
    end

Denk eraan , je kan elke code omhullen met `with_fx` en elke klank hierin gecreëerd zal door deze FX passeren.

## 3. Het parametreren van jouw synths

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:

    sample :guit_em9

Ooh, een mooie gitaarklank! Nu gaan we hiermee spelen. Wat dacht je van zijn koers te veranderen?

    sample :guit_em9, rate: 0.5

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:

    with_fx :flanger, feedback: 0.6 do
      sample :guit_em9
    end

Probeer nu de feedback te verhogen naar 1 om wat gekke geluiden te horen. Lees de documentatie voor details over de beschikbare opties.

## 4. Live Code

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:

    live_loop :experiment do
      sample :loop_amen, cutoff: 70
      sleep 1.75
    end

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`…

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.

## 5. Surfen op random golven

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:

    live_loop :rand_surfer do
      use_synth :dsaw
      notes = (scale :e2, :minor_pentatonic, num_octaves: 2)
      16.times do
        play notes.choose, release: 0.1, cutoff: rrand(70, 120)
        sleep 0.125
      end
    end

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`:

    live_loop :rand_surfer do
      use_random_seed 1
      use_synth :dsaw
      notes = (scale :e2, :minor_pentatonic, num_octaves: 2)
      16.times do
        play notes.choose, release: 0.1, cutoff: rrand(70, 120)
        sleep 0.125
      end
    end

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.

# - Live Coderen

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.

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.

## Live Loop

De hoofdzaak bij het live coderen ligt bij het beheersen van de `live_loop`. Hier kijken we naar zo ééntje:

    live_loop :beats do
      sample :bd_haus
      sleep 0.5
    end

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!.

## Ter plekke herdefiniëren

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:

    live_loop :choral_drone do
      sample :ambi_choir, rate: 0.4
      sleep 1
    end

Klik nu op de afspeelknop of gebruik `alt-r`. Je luistert nu naar de prachtige klank van een koor. Verander de koers, terwijl de code speelt van `0.4` naar `0.38`. Klik terug op afspelen. Wauw! Hoorde je het koor van toon veranderen? Verander deze terug naar `0.4` om terug te keren hoe het was. Verlaag deze nu naar `0.2`, verlaag naar `0.19` en terug naar omhoog naar `0.4`. Hierbij zie je dat het improviseren op één parameter, jou de controle over jouw muziek geeft? Speel zelf met de waarden die je kiest. Probeer negatieve getallen, hele kleine en hele grote getallen. Experimenteer!

## Slapen is belangrijk

Een van de belangrijkste lessen over `live_loop`s is dat ze rust nodig hebben. Beschouw deze volgende ‘live_loop’:

    live_loop :infinite_impossibilities do
      sample :ambi_choir
    end

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.

## Geluiden combineren

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!

    live_loop :beats do
      sample :bd_tek
      with_fx :echo, phase: 0.125, mix: 0.4 do
        sample  :drum_cymbal_soft, sustain: 0, release: 0.1
        sleep 0.5
      end
    end
    live_loop :bass do
      use_synth :tb303
      synth :tb303, note: :e1, release: 4, cutoff: 120, cutoff_attack: 1
      sleep 4
    end

Hier hebben we twee `live_loops`, de ene speelt snel en maakt beats, de andere speelt snel en maakt maffe bas geluiden.

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:

    # Steve Reich's Piano Phase
    notes = (ring :E4, :Fs4, :B4, :Cs5, :D5, :Fs4, :E4, :Cs5, :B4, :Fs4, :D5, :Cs5)
    live_loop :slow do
      play notes.tick, release: 0.1
      sleep 0.3
    end
    live_loop :faster do
      play notes.tick, release: 0.1
      sleep 0.295
    end

## Waardoor het allemaal samen valt

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…

    with_fx :reverb, room: 1 do
      live_loop :time do
        synth :prophet, release: 8, note: :e1, cutoff: 90, amp: 3
        sleep 8
      end
    end
    live_loop :machine do
      sample :loop_garzul, rate: 0.5, finish: 0.25
      sample :loop_industrial, beat_stretch: 4, amp: 1
      sleep 4
    end
    live_loop :kik do
      sample :bd_haus, amp: 2
      sleep 0.5
    end
    with_fx :echo do
      live_loop :vortex do
        # use_random_seed 800
        notes = (scale :e3, :minor_pentatonic, num_octaves: 3)
        16.times do
          play notes.choose, release: 0.1, amp: 1.5
          sleep 0.125
        end
      end
    end

# - Gecodeerd Beats

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.

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!

## De Amen Break

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.

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:

    sample :loop_amen

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.

## Beat Stretching

Laat ons de Amen Break loopen in onze goede vriend `live_loop`, geïntroduceerd in deze tutorial van vorige maand:

    live_loop :amen_break do
      sample :loop_amen
      sleep 2
    end

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.

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.

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.

    live_loop :amen_break do
      sample :loop_amen, beat_stretch: 2
      sleep 2
    end

Nu zijn we aan het dansen! Maar misschien willen we het wat sneller of wat trager om de juiste stemming te pakken te krijgen.

## Spelen met Tijd

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:

    live_loop :amen_break do
      use_bpm 30
      sample :loop_amen, beat_stretch: 2
      sleep 2
    end

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.

Nu komt het leuke! Terwijl de loop nog altijd speelt, verander de`30`in de `use_bpm 30`regel naar `50`. Alles gaat nu sneller, en wordt nog steeds in maat gehouden, goed hoor! Probeer sneller te gaan - omhoog naar 80, naar 120, doe nu eens goed zot en gebruik 200!

## Filteren

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:

    live_loop :amen_break do
      use_bpm 50
      sample :loop_amen, beat_stretch: 2, cutoff: 70
      sleep 2
    end

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.

## Slicing (Snijden)

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:

    live_loop :amen_break do
      use_bpm 50
      with_fx :slicer, phase: 0.25, wave: 0, mix: 1 do
        sample :loop_amen, beat_stretch: 2, cutoff: 100
      end
      sleep 2
    end

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

## Waardoor het allemaal samen valt

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…

    use_bpm 100
    live_loop :amen_break do
      p = [0.125, 0.25, 0.5].choose
      with_fx :slicer, phase: p, wave: 0, mix: rrand(0.7, 1) do
        r = [1, 1, 1, -1].choose
        sample :loop_amen, beat_stretch: 2, rate: r, amp: 2
      end
      sleep 2
    end
    live_loop :bass_drum do
      sample :bd_haus, cutoff: 70, amp: 1.5
      sleep 0.5
    end
    live_loop :landing do
      bass_line = (knit :e1, 3, [:c1, :c2].choose, 1)
      with_fx :slicer, phase: [0.25, 0.5].choose, invert_wave: 1, wave: 0 do
        s = synth :square, note: bass_line.tick, sustain: 4, cutoff: 60
        control s, cutoff_slide: 4, cutoff: 120
      end
      sleep 4
    end

# - Synth Riffs

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.

Ok, zet je Raspberry Pi op, maak Sonic Pi v2.6+ open en maak wat lawaai!

## Timbrale mogelijkheden

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…

We creëren een eenvoudige loop waar we de huidige synth voortdurend gaan veranderen:

    live_loop :timbre do
      use_synth (ring :tb303, :blade, :prophet, :saw, :beep, :tri).tick
      play :e2, attack: 0, release: 0.5, cutoff: 100
      sleep 0.5
    end

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.

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.

## Timbre

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.

## Melodische Compositie

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 :

    live_loop :riff do
      use_synth :prophet
      riff = (ring :e3, :e3, :r, :g3, :r, :r, :r, :a3)
      play riff.tick, release: 0.5, cutoff: 80
      sleep 0.25
    end

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.

## Auto Melodie

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:

    live_loop :random_riff do
      use_synth :dsaw
      use_random_seed 3
      notes = (scale :e3, :minor_pentatonic).shuffle
      play notes.tick, release: 0.25, cutoff: 80
      sleep 0.25
    end

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 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!

## Pseudo randomiseren

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.

## Jouw Ritme Vinden

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:

    live_loop :random_riff do
      use_synth :dsaw
      use_random_seed 30
      notes = (scale :e3, :minor_pentatonic).shuffle
      16.times do
        play notes.tick, release: 0.2, cutoff: 90 if one_in(2)
        sleep 0.125
      end
    end

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.

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.

## Waardoor het allemaal samen valt

Ok, laat ons nu alles wat we geleerd hebben in een laatste voorbeeld combineren. Tot volgende keer!

    live_loop :random_riff do
      #  uncomment to bring in:
      #  synth :blade, note: :e4, release: 4, cutoff: 100, amp: 1.5
      use_synth :dsaw
      use_random_seed 43
      notes = (scale :e3, :minor_pentatonic, num_octaves: 2).shuffle.take(8)
      8.times do
        play notes.tick, release: rand(0.5), cutoff: rrand(60, 130) if one_in(2)
        sleep 0.125
      end
    end

    live_loop :drums do
      use_random_seed 500
      16.times do
        sample :bd_haus, rate: 2, cutoff: 110 if rand < 0.35
        sleep 0.125
      end
    end

    live_loop :bd do
      sample :bd_haus, cutoff: 100, amp: 3
      sleep 0.5
    end

# - Acid Bass

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.

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.

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:

    use_synth :tb303
    play :e1

Acid Bass in een oogwenk! We gaan hier mee spelen…

## Smak die Bas

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:

    use_synth :tb303
    live_loop :squelch do
      n = (ring :e1, :e2, :e3).tick
      play n, release: 0.125, cutoff: 100, res: 0.8, wave: 0
      sleep 0.125
    end

Laten we naar elke regel een kijkje nemen.

1. Op de eerste regel zetten we de standaard synth als ‘tb303’ met de ‘use_synth’ fn.
2. Op regel twee creëren we een live loop genaamd ‘: squelch’ die in een lus loopt.
3. 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.
4. 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.
5. 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.
6. Regel 6 is het einde van de live loop. Deze vertelt aan Sonic Pi waar het einde van de live loop is.

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.

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 :) …

Een andere optie die de moeite waard is, is `res`. Deze bedient het resonantieniveau 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` of hoger de verschillen makkelijker hoorbaar zullen zijn. Doe tenslotte maar eens goed gek, door bijvoorbeeld ´0.999´ te gebruiken, voor een krankzinnig geluid. Bij een `res` die zo hoog is zal de cutoff filter zo hard resoneren dat deze zelf gaat oscilleren en zo zelf een geluidsbron wordt!

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

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.

## De TB-303 deconstrueren

Het ontwerp van de oorspronkelijke TB-303 is eigenlijk vrij eenvoudig. Zoals je in het volgende diagram ziet, zijn er maar 4 belangrijke kerndelen.

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:

    use_synth :tb303
    with_fx :reverb, room: 1 do
      live_loop :space_scanner do
        play :e1, cutoff: 100, release: 7, attack: 1, cutoff_attack: 4, cutoff_release: 4
        sleep 8
      end
    end

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`.

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!

## Waardoor het allemaal samen valt

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…

    use_synth :tb303
    use_debug false

    with_fx :reverb, room: 0.8 do
      live_loop :space_scanner do
        with_fx :slicer, phase: 0.25, amp: 1.5 do
          co = (line 70, 130, steps: 8).tick
          play :e1, cutoff: co, release: 7, attack: 1, cutoff_attack: 4, cutoff_release: 4
          sleep 8
        end
      end

      live_loop :squelch do
        use_random_seed 3000
        16.times do
          n = (ring :e1, :e2, :e3).tick
          play n, release: 0.125, cutoff: rrand(70, 130), res: 0.9, wave: 1, amp: 0.8
          sleep 0.125
        end
      end
    end

# - Muzikale Minecraft

Niet meer beschikbaar * Excuses, maar dit artikel werd teruggeschreven toen Minecraft Pi Edition nog steeds deel uitmaakte van Raspberry Pi OS. Sonic Pi had toen ingebouwde ondersteuning om het met code te bedienen. Helaas is dit niet langer het geval en zijn de minecraft specifieke code, (de `mc_*` functies) niet meer beschikbaar in Sonic Pi. Dit artikel wordt hier echter achtergelaten als herinnering aan wat ooit mogelijk was.*

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:

- Live Code - ter plekke wijzigen van het geluid,
- Geweldige Beats coderen,
- Krachtige synth leads, genereren
- De bekende TB-303 recreëren.

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.

## Hello Minecraft World

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.

In een nieuwe buffer typ je dan het volgende:

    mc_message "Hello Minecraft from Sonic Pi!"

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!

## Sonic Teleporter

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:

    mc_teleport 80, 40, 100

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.

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:

- x - hoe ver links en rechts (80 in ons voorbeeld)
- y - hoe hoog we willen zijn (40 in ons voorbeeld)
- z - hoe ver voorwaarts of achterwaarts (100 in ons voorbeeld)

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…

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:

    mc_message "Preparing to teleport...."
    sample :ambi_lunar_land, rate: -1
    sleep 1
    mc_message "3"
    sleep 1
    mc_message "2"
    sleep 1
    mc_message "1"
    sleep 1
    mc_teleport 90, 20, 10
    mc_message "Whoooosh!"

## Magische blokken

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:

    x, y, z = mc_location
    mc_set_block :melon, x, y + 5, z

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:

    live_loop :melon_trail do
      x, y, z = mc_location
      mc_set_block :melon, x, y-1, z
      sleep 0.125
    end

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.

## Minecraft Live Coderen

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.

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:

    live_loop :bass_trail do
      tick
      x, y, z = mc_location
      b = (ring :melon, :brick, :glass).look
      mc_set_block b, x, y -1, z
      note = (ring :e1, :e2, :e3).look
      use_synth :tb303
      play note, release: 0.1, cutoff: 70
      sleep 0.125
    end

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?

## Waardoor het allemaal samen valt

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…

    live_loop :note_blocks do
      mc_message "This is Sonic Minecraft"
      with_fx :reverb do
        with_fx :echo, phase: 0.125, reps: 32 do
          tick
          x = (range 30, 90, step: 0.1).look
          y = 20
          z = -10
          mc_teleport x, y, z
          ns = (scale :e3, :minor_pentatonic)
          n = ns.shuffle.choose
          bs = (knit :glass, 3, :sand, 1)
          b = bs.look
          synth :beep, note: n, release: 0.1
          mc_set_block b, x+20, n-60+y, z+10
          mc_set_block b, x+20, n-60+y, z-10
          sleep 0.25
        end
      end
    end
    live_loop :beats do
      sample :bd_haus, cutoff: 100
      sleep 0.5
    end

# - Bizet Beats

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.

## Schandalig en Disruptief

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!

## De Habanera decoderen

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:

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.

## Noten

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.

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:

## Rusttijden

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.

Als je de partituur aandachtig bekijkt zal je zien dat deze een combinatie van zwarte punten met lijnen bevat 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.

## Ritme

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.

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.

## De Habanera Hercoderen

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:

    (ring :d, :r, :r, :a, :f5, :r, :a, :r)

Laten we eens kijken hoe dit klinkt. Gooi het in een live loop en “tick” erdoor heen:

    live_loop :habanera do
      play (ring :d, :r, :r, :a, :f5, :r, :a, :r).tick
      sleep 0.25
    end

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!

## Moody Synths

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:

    live_loop :habanera do
      use_synth :fm
      use_transpose -12
      play (ring :d, :r, :r, :a, :f5, :r, :a, :r).tick
      sleep 0.25
    end
    with_fx :reverb do
      live_loop :space_light do
        with_fx :slicer, phase: 0.25 do
          synth :blade, note: :d, release: 8, cutoff: 100, amp: 2
        end
        sleep 8
      end
    end

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`.

## Waardoor het allemaal samen valt

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.

    use_debug false
    bizet_bass = (ring :d, :r, :r, :a, :f5, :r, :a, :r)
    #bizet_bass = (ring :d, :r, :r, :Bb, :g5, :r, :Bb, :r)

    with_fx :reverb, room: 1, mix: 0.3 do
      live_loop :bizet do
        with_fx :slicer, phase: 0.125 do
          synth :blade, note: :d4, release: 8,
            cutoff: 100, amp: 1.5
        end
        16.times do
          tick
          play bizet_bass.look, release: 0.1
          play bizet_bass.look - 12, release: 0.3
          sleep 0.125
        end
      end
    end

    live_loop :ind do
      sample :loop_industrial, beat_stretch: 1,
        cutoff: 100, rate: 1
      sleep 1
    end

    live_loop :drums do
      sample :bd_haus, cutoff: 110
      synth :beep, note: 49, attack: 0,
        release: 0.1
      sleep 0.5
    end

# - Word een Minecraft VJ

Niet meer beschikbaar * Excuses, maar dit artikel werd teruggeschreven toen Minecraft Pi Edition nog steeds deel uitmaakte van Raspberry Pi OS. Sonic Pi had toen ingebouwde ondersteuning om het met code te bedienen. Helaas is dit niet langer het geval en zijn de minecraft specifieke code, (de `mc_*` functies) niet meer beschikbaar in Sonic Pi. Dit artikel wordt hier echter achtergelaten als herinnering aan wat ooit mogelijk was.*

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.

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.

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.

Laten we starten…

## Starten

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:

    mc_message "Let's get started..."

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…

## Zandstormen

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:

- `sleep` - voor het invoegen van een vertraging tussen acties
- `mc_location` - om onze huidige lokatie te vinden
- `mc_set_block`- om de zandblokken op een bepaalde plaats te zetten
- `rrand` - om ons toe te laten random waarden binnen een bepaald bereik te genereren
- `live_loop` - om ons toe te laten een constante stroom aan regen te maken

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.

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:

    x, y, z = mc_location
    mc_set_block :sand, x, y + 20, z + 5
    sleep 2
    mc_set_block :sand, x, y + 20, z + 6
    sleep 2
    mc_set_block :sand, x, y + 20, z + 7
    sleep 2
    mc_set_block :sand, x, y + 20, z + 8

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!

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.

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!

## Live Loops ontketend

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!

    live_loop :sand_storm do
      x, y, z = mc_location
      xd = rrand(-10, 10)
      zd = rrand(-10, 10)
      co = rrand(70, 130)
      synth :cnoise, attack: 0, release: 0.125, cutoff: co
      mc_set_block :sand, x + xd, y+20, z+zd
      sleep 0.125
    end

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:

- `xd` - het verschil bij x welke tussen -10 en 10 liggen
- `zd` - het verschil bij z ook tussen -10 en 10
- `co` - een cutoff waarde voor de low pass filter tussen 70 en 130

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.

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?

## Epische blok patronen

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:

    x, y, z = mc_location
    bs = (ring :gold, :diamond, :glass)
    10.times do |xd|
      10.times do |yd|
        mc_set_block bs.choose, x + xd, y + yd, z
      end
    end

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.

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!

# - Surfen op Random Streams

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!

## Er is geen random

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:

    print rand

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.

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.

## Een Random Melodie

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.

Laten we deze kennis te gebruiken om een herhalende willekeurige melodie te genereren:

    8.times do
     play rrand_i(50, 95)
     sleep 0.125
    end

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.

## Handige randomisering Functies

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:

- `rand` - geeft gewoon de volgende waarde van de stream weer
- `rrand` - geeft een random waarde binnen een bereik weer
- `rrand_i` - Geeft een random geheel getal binnen een bereik weer
- `one_in` - Geeft true of false weer met de gegeven probabiliteit
- `dice` - Immiteerd het rollen van een dobbelsteen en geeft waarden tussen 1 en 6 weer
- `choose` - Kiest een willekeurige waarde uit een lijst

Bekijk hun documentatie in het Help-systeem voor meer informatie en voorbeelden.

## Resetten van de Stream

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.

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:

    use_random_seed 0
    3.times do
      play rrand_i(50, 95)
      sleep 0.125
    end

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:

    use_random_seed 1
    3.times do
      play rrand_i(50, 95)
      sleep 0.125
    end

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.

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.

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:

    live_loop :random_riff do
      use_random_seed 0
      8.times do
        play rrand_i(50, 95), release: 0.1
        sleep 0.125
      end
    end

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.

## Waardoor het allemaal samen valt

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.

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.

    live_loop :random_riff do
      use_random_seed 10300
      use_synth :prophet
      s = [0.125, 0.25, 0.5].choose
      8.times do
        r = [0.125, 0.25, 1, 2].choose
        n = (scale :e3, :minor).choose
        co = rrand(30, 100)
        play n, release: r, cutoff: co
        sleep s
      end
    end
    live_loop :drums do
      use_random_seed 2001
      16.times do
        r = rrand(0.5, 10)
        sample :drum_bass_hard, rate: r, amp: rand
        sleep 0.125
      end
    end

# - Jouw Geluid Controllen

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.

## Een Basis Klank

Laat ons even een leuke eenvoudige klank maken. Start Sonic Pi en typ in een nieuwe buffer het volgende:

    synth :prophet, note: :e1, release: 8, cutoff: 100

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!

## Synth Nodes

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:

    sn = synth :prophet, note: :e1, release: 8, cutoff: 100
    sleep 1
    control sn, cutoff: 130

Laten we de verschillende regels op zijn beurt even bekijken:

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.

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.

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 .

Moduleerbare Opties

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:

- Standaard instelling: 0
- Moet nul of groter dan nul zijn
- Kan niet worden aangepast eens ingesteld
- Geschaald met huidige BPM waarde

## Meerdere veranderingen

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:

    notes = (scale :e3, :minor_pentatonic)
    sn = synth :prophet, note: :e1, release: 8, cutoff: 100
    sleep 1
    16.times do
      control sn, note: notes.tick
      sleep 0.125
    end

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.

Merk op dat we meerdere opts tegelijk kunnen veranderen. Probeer de control regel naar het volgende te wijzigen en hoor nu het verschil:

    control sn, note: notes.tick, cutoff: rrand(70, 130)

## Sliden

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.

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:

    sn = synth :prophet, note: :e1, release: 8, cutoff: 70, cutoff_slide: 2
    sleep 1
    control sn, cutoff: 130

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 …

## Waardoor het allemaal samen valt

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 .

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!

    live_loop :moon_rise do
      with_fx :echo, mix: 0, mix_slide: 8 do |fx|
        control fx, mix: 1
        notes = (scale :e3, :minor_pentatonic, num_octaves: 2).shuffle
        sn = synth :prophet , sustain: 8, note: :e1, cutoff: 70, cutoff_slide: 8
        control sn, cutoff: 130
        sleep 2
        32.times do
          control sn, note: notes.tick, pan: rrand(-1, 1)
          sleep 0.125
        end
      end
    end

# - De maat houden

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.

## De beat tellen

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.

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:

    puts tick #=> 0

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:

    puts tick #=> 0
    puts tick #=> 1
    puts tick #=> 2

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.

## De beat nagaan

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`:

    puts tick #=> 0
    puts tick #=> 1
    puts look #=> 1
    puts look #=> 1

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.

## Ringen

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:

    puts (ring :a, :b, :c).tick #=> :a

`.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:

    puts (ring :a, :b, :c).tick #=> :a
    puts (ring :a, :b, :c).tick #=> :b
    puts (ring :a, :b, :c).tick #=> :c
    puts (ring :a, :b, :c).tick #=> :a
    puts look                   #=> 3

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.

## Een Live Loop Arpeggiator

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:

1. Een ring die de te doorlopen noten bevat.
2. Een middel om de beat te verkrijgen en te verhogen.
3. De mogelijkheid om een noot te spelen volgens de huidige beat.
4. Een loop structuur waarin de arpegiator zich herhaalt.

Deze concepten vind je in de volgende code terug:

    notes = (ring 57, 62, 55, 59, 64)
    live_loop :arp do
      use_synth :dpulse
      play notes.tick, release: 0.2
      sleep 0.125
    end

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 loopen.

## Meerdere simultane beats

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:

    notes = (ring 57, 62, 55, 59, 64)
    with_fx :reverb do
      live_loop :arp do
        use_synth :dpulse
        play notes.tick + 12, release: 0.1
        sleep 0.125
      end
    end
    live_loop :arp2 do
      use_synth :dsaw
      play notes.tick - 12, release: 0.2
      sleep 0.75
    end

## Botsende Beats

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`:

    use_bpm 300
    use_synth :blade
    live_loop :foo do
      play (ring :e1, :e2, :e3).tick
      play (scale :e3, :minor_pentatonic).tick
      sleep 1
    end

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

## Waardoor het allemaal samen valt

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…

    use_bpm 240
    notes = (scale :e3, :minor_pentatonic).shuffle
    live_loop :foo do
      use_synth :blade
      with_fx :reverb, reps: 8, room: 1 do
        tick
        co = (line 70, 130, steps: 32).tick(:cutoff)
        play (octs :e3, 3).look, cutoff: co, amp: 2
        play notes.look, amp: 4
        sleep 1
      end
    end
    live_loop :bar do
      tick
      sample :bd_ada if (spread 1, 4).look
      use_synth :tb303
      co = (line 70, 130, steps: 16).look
      r = (line 0.1, 0.5, steps: 64).mirror.look
      play notes.look, release: r, cutoff: co
      sleep 0.5
    end

# - Het snijden van een sample

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 .

## Geluid als data

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:

    sample :loop_amen

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?

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.

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.

## Een deel van een sample afspelen

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`:

    sample :loop_amen, finish: 0.5

We kunnen ook een `start:` toevoegen om een nog kleiner stukje van de sample te kunnen spelen:

    sample :loop_amen, start: 0.25, finish: 0.5

Voor de lol kunnen we de waarde van `finish:` laten vallen vòòr de waarde van `start:` om de selectie achterstevoren te laten afspelen:

    sample :loop_amen, start: 0.5, finish: 0.25

## Het afspelen van een sample herordenen

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.

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:

    live_loop :beat_slicer do
      slice_idx = rand_i(8)
      slice_size = 0.125
      s = slice_idx * slice_size
      f = s + slice_size
      sample :loop_amen, start: s, finish: f
      sleep sample_duration :loop_amen, start: s, finish: f
    end

1. 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`.
2. 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.
3. We berekenen de beginpositie ‘ door de ‘slice_idx’ met ‘slice_size’ te vermenigvuldigen .
4. We berekenen de eind-positie `f` door de ´slice_size`aan de startpositie` s` toe te voegen.
5. We kunnen nu deze sample-slice afspelen door de waarden van `s`en `f`, in de `start:` en `finish:` opts voor `sample` te steken.
6. 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.
7. We steken deze code in een `live_loop` zodat we verder nieuwe random slices kunnen uitpikken.

## Waardoor het allemaal samen valt

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…

    live_loop :sliced_amen do
      n = 8
      s =  line(0, 1, steps: n).choose
      f = s + (1.0 / n)
      sample :loop_amen, beat_stretch: 2, start: s, finish: f
      sleep 2.0  / n
    end
    live_loop :acid_bass do
      with_fx :reverb, room: 1, reps: 32, amp: 0.6 do
        tick
        n = (octs :e0, 3).look - (knit 0, 3 * 8, -4, 3 * 8).look
        co = rrand(70, 110)
        synth :beep, note: n + 36, release: 0.1, wave: 0, cutoff: co
        synth :tb303, note: n, release: 0.2, wave: 0, cutoff: co
        sleep (ring 0.125, 0.25).look
      end
    end

# - Codeer een probabilistische Sequencer

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!

## Probabiliteit

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:

    8.times do
      puts dice
      sleep 1
    end

Kijk hoe in het logboek waarden tussen 1 en 6 wordt afgedrukt, alsof we een echte dobbelsteen geworpen zouden hebben.

## Random Beats

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:

    live_loop :random_beat do
      sample :drum_snare_hard if dice == 1
      sleep 0.125
    end

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.

## Probabiliteit veranderen

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:

    live_loop :different_probabilities do
      sample :drum_snare_hard if one_in(6)
      sleep 0.125
    end

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!

## Probabiliteit combineren

Echt spannend wordt het wanneer je meerdere samples combineert, die worden geactiveerd met verschillende kansen. Bijvoorbeeld:

    live_loop :multi_beat do
      sample :elec_hi_snare if one_in(6)
      sample :drum_cymbal_closed if one_in(2)
      sample :drum_cymbal_pedal if one_in(3)
      sample :bd_haus if one_in(4)
      sleep 0.125
    end

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!

## Herhaalbare ritmes

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.

    live_loop :multi_beat do
      use_random_seed 1000
      8.times do
        sample :elec_hi_snare if one_in(6)
        sample :drum_cymbal_closed if one_in(2)
        sample :drum_cymbal_pedal if one_in(3)
        sample :bd_haus if one_in(4)
        sleep 0.125
      end
    end

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.

## Waardoor het allemaal samen valt

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!

    live_loop :multi_beat do
      use_random_seed 2000
      8.times do
        c = rrand(70, 130)
        n = (scale :e1, :minor_pentatonic).take(3).choose
        synth :tb303, note: n, release: 0.1, cutoff: c if rand < 0.9
        sample :elec_hi_snare if one_in(6)
        sample :drum_cymbal_closed if one_in(2)
        sample :drum_cymbal_pedal if one_in(3)
        sample :bd_haus, amp: 1.5 if one_in(4)
        sleep 0.125
      end
    end

# - Amplitude Modulatie

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.

## Snij de Amp

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:

    synth :prophet, note: :e1, release: 8, cutoff: 70
    synth :prophet, note: :e1 + 4, release: 8, cutoff: 80

Laat ons dit nu door het `:slicer`FX leiden:

    with_fx :slicer do
      synth :prophet, note: :e1, release: 8, cutoff: 70
      synth :prophet, note: :e1 + 4, release: 8, cutoff: 80
    end

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:

    with_fx :slicer, phase: 0.125 do
      synth :prophet, note: :e1, release: 8, cutoff: 70
      synth :prophet, note: :e1 + 4, release: 8, cutoff: 80
    end

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.

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`.

## Golfsoort Instellen

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:

    with_fx :slicer, phase: 0.5, wave: 3 do
      synth :dsaw, note: :e3, release: 8, cutoff: 120
      synth :dsaw, note: :e2, release: 8, cutoff: 100
    end

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.

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.

## Het instellen van je niveaus

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:

    with_fx :slicer, amp_min: 0.25, amp_max: 0.75, wave: 3, phase: 0.25 do
      synth :saw, release: 8
    end

Dit is zoals je de volumeknop van je hi-fi op en neer zou bewegen, zodat het geluid een beetje aan en uit ‘wiebelt’.

## Probabiliteit

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:

    with_fx :slicer, phase: 0.125, probability: 0.6  do
      synth :tb303, note: :e1, cutoff_attack: 8, release: 8
      synth :tb303, note: :e2, cutoff_attack: 4, release: 8
      synth :tb303, note: :e3, cutoff_attack: 2, release: 8
    end

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.

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.

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:

    with_fx :slicer, phase: 0.125, probability: 0.6, prob_pos: 1  do
      synth :tb303, note: :e1, cutoff_attack: 8, release: 8
      synth :tb303, note: :e2, cutoff_attack: 4, release: 8
      synth :tb303, note: :e3, cutoff_attack: 2, release: 8
    end

## Beats Slicen (Opknippen)

Wat ook heel leuk is om te doen is het gebruik van `:slicer` om een drum beat aan en uit te knipperen:

    with_fx :slicer, phase: 0.125 do
      sample :loop_mika
    end

Hiermee kunnen we met een willekeurige sample nieuwe ritmische mogelijkheden creëren. Dit is 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 goed overeenkomt.

## Tempo Veranderen

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:

    use_sample_bpm :loop_amen
    with_fx :slicer, phase: 0.125 do
      sample :loop_amen
    end

## Waardoor het allemaal samen valt

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!

    live_loop :dark_mist do
      co = (line 70, 130, steps: 8).tick
      with_fx :slicer, probability: 0.7, prob_pos: 1 do
        synth :prophet, note: :e1, release: 8, cutoff: co
      end

      with_fx :slicer, phase: [0.125, 0.25].choose do
        sample :guit_em9, rate: 0.5
      end
      sleep 8
    end
    live_loop :crashing_waves do
      with_fx :slicer, wave: 0, phase: 0.25 do
        sample :loop_mika, rate: 0.5
      end
      sleep 16
    end

# - Vijf Live-Coding Technieken

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.

## 1. Het onthouden van de Sneltoetsen

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.

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.

## 2. Handmatig je geluid van lagen voorzien

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:

    synth :tb303, note: :e2 - 0, release: 12, cutoff: 90

Klik nu op de `Afspeel` knop wanneer de klank loopt, verander de code om vier tonen te zakken door het volgende te doen:

    synth :tb303, note: :e2 - 4, release: 12, cutoff: 90

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.

Je kan deze techniek ook gebruiken met lange abstracte samples. Bijvoorbeeld:

    sample :ambi_lunar_land, rate: 1

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.

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.

## 3.Live Loops Masteren

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.

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.

## 4. De Master Mixer gebruiken

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!`. Probeer bijvoorbeeld het volgende, terwijl je de code loopt en hoort in een vrije buffer en druk op `Afspelen`:

` set_mixer_control! lpf: 50 `

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!`.

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:

    set_mixer_control! lpf_slide: 16, lpf: 30

Je kan dan snel terug naar boven schuiven voor een hogere waarde met:

    set_mixer_control! lpf_slide: 1, lpf: 130

Als u optreed is het nuttig om een lege buffer vrij te houden om zoals hier met de mixer te werken.

## 5. Oefening

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 .

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”.

## Waardoor het allemaal samen valt

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.

# - 8 Tips om Live-Coding te oefenen

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.

## Regelmatig oefenen

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.

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.

## Leer blind typen

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.

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.

## Codeer terwijl je rechtstaat

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.

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.

## Oefen het opstellen

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.

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.

## Experimenteer op muzikaal vlak

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.

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!

## Hoor de code

Veel muzikanten kunnen naar bladmuziek kijken en de muziek in hun hoofd horen, zonder deze te moeten spelen. Dit is een zeer nuttige vaardigheid en het is de moeite waard om deze te integreren in je oefen sessies live-coding.

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.

## Verwijder alle afleiding

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.

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 .

## Hou een oefenboek bij

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!

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.

## Waardoor het allemaal samen valt

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!

# - Sample Stretching

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!

## Samples vertragen

Om de afspeelsnelheid van de sample te wijzigen moeten we de `rate:` optie gebruiken:

    sample :guit_em9, rate: 1

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`:

    sample :guit_em9, rate: 0.5

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.

## Samples versnellen

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`:

    sample :loop_amen, rate: -1

Nu versnellen we deze een beetje:

    sample :loop_amen, rate: 1.5

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!

## In achteruit versnelling

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:

    sample :elec_filt_snare, rate: 1

Cool! Het speelt achterstevoren:

    sample :elec_filt_snare, rate: -1

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!

## Sample, Rate and Pitch [Sidebar]

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?

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.

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.

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.

## Pitch Bending

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:

    sample :bass_trance_c, rate: 1
    sample :bass_trance_c, rate: 2
    sample :bass_trance_c, rate: 0.5

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:

    sample :bass_trance_c
    sample :bass_trance_c, rpitch: 3
    sample :bass_trance_c, rpitch: 7

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:

    sample :ambi_choir, rate: 0.25, rpitch: 3
    sleep 3
    sample :ambi_choir, rate: 0.25, rpitch: 5
    sleep 2
    sample :ambi_choir, rate: 0.25, rpitch: 6
    sleep 1
    sample :ambi_choir, rate: 0.25, rpitch: 1

## Waardoor het allemaal samen valt

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.

    live_loop :beats do
      sample :guit_em9, rate: [0.25, 0.5, -1].choose, amp: 2
      sample :loop_garzul, rate: [0.5, 1].choose
      sleep 8
    end

    live_loop :melody do
      oct = [-1, 1, 2].choose * 12
      with_fx :reverb, amp: 2 do
        16.times do
          n = (scale 0, :minor_pentatonic).choose
          sample :bass_voxy_hit_c, rpitch: n + 4 + oct
          sleep 0.125
        end
      end
    end

# - Additieve Synthese

Dit is de eerste van een reeks korte artikeltjes over het gebruik van Sonic Pi bij klankontwerp (Sounddesign). We nemen een rondleiding door een aantal technieken die voor je beschikbaar zijn om je eigen unieke klank te ontwikkelen. De eerste techniek die we zullen bekijken heet * additieve synthese *. Dit kan ingewikkeld klinken - maar als we elk woord even apart bekijken is de betekenis vrij snel duidelijk. Ten eerste, additief betekent letterlijk de combinatie van een aantal elementen en het tweede woord synthese, betekent geluid creëren . Additieve synthese betekent daarom niets minder dan * bestaande geluiden combineren om nieuwe te maken *. Deze synthese techniek dateert al van lang geleden - bijvoorbeeld pijporgels in de middeleeuwen hadden veel lichtjes verschillende cillinderpijpen die je met tussenpozen kan in- of uitschakelen. De stop uit een bepaalde pijp trekken ‘voegt deze aan de mix toe’ en maakt het geluid rijker en complexer. Nu, laten we eens kijken hoe we dat kunnen doen met Sonic Pi.

## Eenvoudige combinaties

Laten we beginnen met het meest elementaire geluid dat er is - de eenvoudige zuiver gestemde sinus golf:

    synth :sine, note: :d3

Laten we eens kijken hoe dit klinkt gecombineerd met een blokgolf:

    synth :sine, note: :d3
    synth :square, note: :d3

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.

## Mengen

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:

    synth :sine, note: :d3
    synth :square, note: :d3
    synth :tri, note: :d4, amp: 0.4

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.

## Detuning (Ontstemmen)

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:

    detune = 0.7
    synth :square, note: :e3
    synth :square, note: :e3 + detune

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 .

Sommige van de ingebouwde synths beschikken reeds over een detune optie die exact dit toepast in één synth. Probeer te spelen met de ‘ detune: ‘ opt van ‘: dsaw ‘,’: dpulse’ en ‘: dtri’.

## Amplitude vormgeven

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.

    detune = 0.1
    synth :square, note: :e1, release: 2
    synth :square, note: :e1 + detune, amp: 2, release: 2
    synth :gnoise, release: 2, amp: 1, cutoff: 60
    synth :gnoise, release: 0.5, amp: 1, cutoff: 100
    synth :noise, release: 0.2, amp: 1, cutoff: 90

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

## Waardoor het allemaal samen valt

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!

    Speel een melodie met onze nieuwe klok!

# - Subtractieve synthese

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.

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.

## Complex Bron Signaal

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:

    synth :saw, note: :e2, release: 4

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:

    synth :beep, note: :e2, release: 4

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.

## Filters

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:

    with_fx :lpf, cutoff: 100 do
      synth :saw, note: :e2, release: 4
    end

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.

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.

    with_fx :hpf, cutoff: 90 do
      synth :saw, note: :e2, release: 4
    end

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.

## Low Pass Filter

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.

## Filter Modulatie

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:

    with_fx :lpf, cutoff: 50 do |fx|
      control fx, cutoff_slide: 3, cutoff: 130
      synth :prophet, note: :e2, sustain: 3.5
    end

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.

## Waardoor het allemaal samen valt

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.

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

    define :subt_synth do |note, sus|
      at do
        with_fx :lpf, cutoff: 40, amp: 2 do |fx|
          control fx, cutoff_slide: 6, cutoff: 100
          synth :prophet, note: note, sustain: sus
        end
        with_fx :hpf, cutoff_slide: 0.01 do |fx|
          synth :dsaw, note: note + 12, sustain: sus
          (sus * 8).times do
            control fx, cutoff: rrand(70, 110)
            sleep 0.125
          end
        end
      end
    end
    subt_synth :e1, 8
    sleep 8
    subt_synth :e1 - 4, 8

# - Creative coding in the classroom with Sonic Pi

(This article was published in issue 9 of the Hello World Magazine)

Code is one of the most creative media that humans have created. The initially obscure symbols of parentheses and lambdas are not just deeply rooted in science and mathematics, they are the closest we have managed to get to casting the same kind of magical spells as Gandalf and Harry Potter. I believe that this provides a powerful means of engagement in our learning spaces. Through the magic of code we are able to conjure up individually meaningful stories and learning experiences.

We are surrounded by magical experiences. From the sleight of hand of a stage magician making the ball disappear into thin air, to the wonder of seeing your favourite band perform on a big stage. It is these “wow” moments that inspire us to pick up a magic book and learn the French Drop or to start jamming power chords on an old guitar. How might we create similarly deep and lasting senses of wonder that will motivate people to practice and learn the fundamentals of programming?

## Musical Engines and Notation

The histories of music and computers have been intricately woven together since the inception of computing machines, or “engines” as Charles Babbage’s powerful analytical engine was called. Back in 1842 the Mathematician Ada Lovelace, who worked very closely with Babbage, saw the creative potential of these engines. Whilst these first engines had originally been designed to accurately solve hard maths problems, Ada dreamt about making music with them:

”..the engine might compose elaborate and scientific pieces of music of any degree of complexity or extent.” Ada Lovelace, 1842.

Of course, today in 2019 much of our music, regardless of genre, has either been composed, produced or mastered with a digital computer. Ada’s dream came true. It is even possible to trace the history back even further. If you see coding as the art of writing sequences of special symbols that instruct a computer to do specific things, then musical composition is a very similar practice. In Western music, the symbols are black dots positioned on a stave of lines that tell the musician which notes to play and when. Intriguingly, if we trace the roots of Western music notation back to the Italian Benedictine monk, Guido d’Arezzo, we find that the dots and lines system that modern orchestras use is just one of a number of notation systems he worked on. Some of the others were much closer to what we might now see as code.

Get

## Sonic Pi Performances

Jylda and Sam Aaron perform at the Thinking Digital Conference in the Sage Gateshead. Photo credit: TyneSight Photos.

Sonic Pi has been used to perform in a wide range of venues such as school halls, nightclubs, outdoor stages at musical festivals, college chapels and prestigious music venues. For example the amazing Convo project which brought 1000 children together in the Royal Albert Hall to perform an ambitious new composition by composer Charlotte Harding. The piece was written for traditional instruments, choirs, percussion and Sonic Pi code. The pop-artist Jylda also performed with Sonic Pi in the Sage Gateshead for the Thinking Digital Conference, where she created a unique live-coded improvised remix of her song Reeled.

Sonic Pi used as one of the instruments as part of Convo at the Royal Albert Hall. Photo credit: Pete Jones.

## Live coding in the classroom

Sonic Pi is a code-based music creation and performance tool that builds on all of these ideas. Unlike the majority of computing education software, it is both simple enough to use for education and also powerful enough for professionals. It has been used to perform in international music festivals, used to compose in a range of styles from classical, EDM and heavy metal, and was even reviewed in the Rolling Stone magazine. It has a diverse community of over 1.5 million live coders with a variety of backgrounds all learning and sharing their ideas and thoughts through the medium of code. It is free to download for Mac, PC and Raspberry Pi and includes a friendly tutorial that assumes you know nothing about either code or music.

Sonic Pi was initially conceived as a response to the UK’s newly released Computing curriculum in 2014. The goal was to find a motivating and fun way to teach the fundamentals of programming. It turns out that there is a lot in common and it’s huge fun to explain sequencing as melody, iteration as rhythm, conditionals as musical variety. I developed the initial designs and first iterations of the platform with Carrie Anne Philbin, who brought a teacher’s perspective to the project. Since then, Sonic Pi has undergone iterative improvements thanks to the feedback gained from observing learners and collaborating directly with educators in the classroom. A core design philosophy was to never add a feature that couldn’t be easily taught to a 10 year old child. This meant that most ideas had to be heavily refined and reworked until they were simple enough. Making things simple whilst keeping them powerful continues to be the hardest part of the project.

In order to provide the magical motivation, Sonic Pi’s design was never limited to a pure focus on education. Ideally there would be famous musicians and performers using Sonic Pi as a standard instrument alongside guitars, drums, vocals, synths, violins, etc. These performers would then act as motivational role models demonstrating the creative potential of code. For this to be possible sufficient focus and effort therefore had to be placed on making it a powerful instrument whilst still keeping it simple enough for 10 year olds to pick up. In addition to educators, I also worked directly with a variety of different artists in classrooms, art galleries, studios and venues in the early stages of Sonic Pi’s development. This provided essential feedback which enabled Sonic Pi to grow and ultimately flourish as a tool for creative expression.

There were a number of exciting and unexpected side effects of this dual focus on education and professional musicians. Many of the features are beneficial to both groups. For example, a lot of effort has been put into making error messages more friendly and useful (rather than being a huge complicated mess of jargon). This turns out to be very useful when you write a bug while performing in front of thousands of people. Additionally, functionality such as playing studio quality audio samples, adding audio effects, providing access to live audio from the microphone all turn out to make the learning experience more fun, rewarding and ultimately meaningful.

The Sonic Pi community continues to grow and share amazing code compositions, lesson plans, musical algorithms, and much more. Much of this happens on our friendly forum in_thread (in-thread.sonic-pi.net) which is home to a very diverse group of people that includes educators, musicians, programmers, artists and makers. It is a real joy to see people learn to use code to express themselves in new ways and for that in turn to inspire others to do the same.

# - Some fun capabilities

From a Computer Science perspective, Sonic Pi provides you with the building blocks to teach you the basics as found in the UK’s curriculum such as sequencing, iteration, conditionals, functions, data structures, algorithms, etc. However, it also builds on a number of important and relevant concepts which have become adopted in mainstream industry such as concurrency, events, pattern matching, distributed computing and determinism - all whilst keeping things simple enough to explain to a 10 year old child.

Get

    play 70

A melody can be constructed with one more command, sleep:

    lay 72
    sleep 0.5
    play 75
    sleep 0.5
    play 79

In this example, we play the note 70 (roughly the 70th note on a piano), wait for 1 second, play note 72, wait for half a second and then play note 75. What’s interesting here is that with just two commands we have access to pretty much all of Western notation (which notes to play and when) and learners can code any melody they’ve ever heard. This leads to huge variety in expressive outcomes whilst focussing on the same computing concept: sequencing in this case.

Taking ideas from the professional music world, we can also play back any recorded sound. Sonic Pi can play any audio file on your computer but also has a number of sounds built-in to make things easy to get started:

    sample :loop_amen

Deze code zal de drumbreak spelen die het basisingredient vormde van de oorspronkelijke hiphop, Drum & Bass en Jungle. Een aantal van de eerste hiphop-artiesten speelden bijvoorbeeld deze drumbreak op halve snelheid terug om het een meer ontspannen gevoel te geven:

    sample :loop_amen, rate: 0.5

In de jaren 90 ontstonden een aantal muziekscenes door nieuwe technologie die artiesten in staat stelde om drumbreaks als deze uit elkaar te halen en in een andere volgorde opnieuw samen te komen. Bijvoorbeeld:

    live_loop :jungle do
     sample :loop_amen, onset: pick
     sleep 0.125
    end

In dit voorbeeld introduceren we een basislus genaamd :jungle die een willekeurige drumhit uit ons audiovoorbeeld haalt, een achtste van een seconde wacht en vervolgens een nieuwe drumhit kiest. Dit resulteert in een eindeloze stroom willekeurige drumbeats om op te dansen terwijl je ervaart wat een lus is.

# - Essentiële Kennis

Deze sectie gaat over nuttige - in feite essentiële - kennis om het meeste uit Sonic Pi te halen.

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.

# - Sneltoetsen gebruiken

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.

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!

Daarom, als je de shortcuts leert, leer je je toetsenbord efficienter te gebruiken en je zal in geen tijd live coderen als een pro.

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.

## Samenhang tussen Platforms

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.

Unfortunately there are a number of standards for shortcuts with macOS and Windows being two of the major styles and other more esoteric editors such as Emacs offering other approaches. You can currently choose between one of these three styles using the menu `IO -> Shortcut Mode`. You can therefore switch between a Windows and a macOS machine and keep your shortcuts consistent.

## Controle en Meta

A key 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.

## Afkortingen

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.”

Enkele van de sneltoetsen die ik het meest nuttig vind.

## Stoppen en starten

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.

## Navigatie

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.

For example, if you’re in Emacs Live short cut mode, 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`. Other modes will have their own shortcuts which can be easily discovered in the app menu.

## Nette Code

Voor het automatisch uitlijnen van jouw code druk `M-m`.

## Help-systeem

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!

Voor een volledige lijst kijk je naar punt 10.2 Shortcut Cheatsheet.

# - Shortcut Cheatsheet

The following is a summary of the main Emacs Live shortcuts available within Sonic Pi. Please see Section B.1 for motivation and background.

## Conventies

In deze lijst, gebruiken we de volgende conventies (waar Meta staat is dit Alt op Windows/Linux en Cmd op Mac):

- `C-a` betekend hou de Control toets en de a toets tegelijkertijd in, laat dan los.
- `M-r`betekent hou de Meta toets en druk dan de r toets tegelijkertijd in, laat dan los.
- `S-M-z` betekent hou de Shift toets, dan de Meta toets, en tenslotte de z toets tegelijkertijd allemaal in en laat dan los.
- `C-M-f` betekent hou de Control toets, dan de Meta en tenslotte de f toets allemaal tegelijkertijd in, en dan los deze dan.

## Belangrijkste Applicatie Manipulatie

- `M-r` - code afspelen
- `M-s` - Stop code
- `M-i` - Help Systeem Schakelaar
- `M-p` - Voorkeursinstellingen Aan/Uit
- `M-{` - Buffer naar links omwisselen
- `M-}` - Buffer naar links omwisselen
- `S-M-0` - Wissel naar buffer 0
- `S-M-1` - Wissel naar buffer 1
- …
- `S-M-9` - Wissel naar buffer 9
- `M-+` - Vergroot de tekstgrootte van de huidige buffer
- `M--` - Verkleint de tekstgrootte van de huidige buffer

## Selectie/Kopiëren/Plakken

- `M-a` - Selecteer alles
- `M-c` - kopieer selectie om buffer te plakken
- `M-]` - Kopieer selectie om buffer te plakken
- `M-x` - Knip selectie om buffer te plakken
- `C-]` - Knip selectie om buffer te plakken
- `C-k` - Knip tot het einde van de lijn
- `M-v` - Plak naar editor vanaf plak buffer
- `C-y` - Plak naar editor vanaf plak buffer
- `C-SPACE` - Zet markering. Navigatie zal nu gemarkeerd gebied manipuleren. Gebruik `C-g` om te verlaten.

## Bewerken van tekst

- `M-m` - Alle tekst uitlijnen
- `Tab` - Huidige lijn uitlijnen of selectie (of selecteer automatisch aanvullen)
- `C-l` - Editor Centreren
- `M-/` - Comment/Uncomment huidige lijn of selectie
- `C-t` - Karakters omzetten/ruilen
- `M-u` - Volgende woord (of selectie) omzetten in hoofdletters.
- `M-l` - -Volgende woord (of selectie) omzetten in kleine letters.

## Navigatie

- `C-a` - Naar het begin van de lijn
- `C-e` -Verplaats naar einde van regel
- `C-p` -Verplaatsen naar vorige regel
- `C-n` - Verplaatsen naar volgende regel
- `C-f` -Eén teken naar rechts verplaatsen
- `C-b` - Eén teken naar achter verplaatsen
- `M-f` - Eén woord naar voor springen
- `M-b` - Eén woord naar achter springen
- `C-M-n` -Zet lijn of selectie naar beneden
- `C-M-p` - Zet lijn of selectie naar boven
- `S-M-u` - 10 lijnen naar boven gaan
- `S-M-d` - 10 lijnen naar beneden gaan
- `M-<` - Naar het begin van de buffer gaan
- `M->` - Naar het eind van de buffer gaan

## Verwijdering

- `C-h` - Vorige teken verwijderen
- `C-d` - Volgend teken verwijderen

## Geavanceerde Editor Functies

- `C-i` - Toon docs voor het woord onder de cursor
- `M-z` - Ongedaan maken
- `S-M-z` - Opnieuw maken
- `C-g` - Verlaten
- `S-M-f` - Tussen Fullscreen modus schakelen
- `S-M-b`- Zichtbaarheid van knoppen in-/uitschakelen
- `S-M-l` - Zichtbaarheid van log in-/uitschakelen
- `S-M-m` - Tussen licht/donker modus schakelen
- `S-M-s` - Inhoud van de buffer als een bestand opslaan
- `S-M-o` - Inhoud van buffer vanuit een bestand laden

# - Delen

Sonic Pi gaat helemaal over het delen en leren met elkaar.

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.

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 .

## Code -> GitHub

[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.

## Audio -> SoundCloud

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.

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

## Hoop

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.

# - Optreden

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.

We noemen dit Live coderen.

## Laat je scherm zien

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.

## Vorm een Band

Maak muziek met elkaar en vorm een echte live-coding band! Het is superleuk om samen muziek te maken ofwel jammen. De een kan het ritme doen terwijl een ander wat achtergrond geluid toevoegd, enzovoorts. Gebruik de `live_audio` functionaliteit om je geluiden te combineren met andere instrumenten als een gitaar of een microfoon.

Sta verbaast over de interessante combinaties van geluid jij kunt creëren met code.

## TOPLAP

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.

## Algorave

Een andere interessante bron om de wereld van live coding te leren kennen is Algorave. Hier kan je alles vinden over de verschillende onderdelen om live te spelen in een nachtclub.