Sonic Pi - en to da translation catalogue (235 entries)

en: 1 Welcome to Sonic Pi
da: 1 Velkommen til Sonic Pi

en: Welcome friend :-)
da: Velkommen min ven :-)

en: But wait, how rude of me! Let me introduce myself - I'm [Sam Aaron](https://twitter.com/samaaron) - the chap that created Sonic Pi. You can find me at [@samaaron](http://twitter.com/samaaron) on Twitter and I'd be more than happy to say hello to you. You might also be interested in finding out more about my [Live Coding Performances](https://youtube.com/samaaron) where I code with Sonic Pi live in front of audiences.
da: Men lad mig først introducere mig selv: Jeg hedder [Sam Aaron](http://twitter.com/samaaron) - ham fyren der har lavet Sonic Pi. Du kan finde mig på Twitter under navnet [@samaaron](http://twitter.com/samaaron), hvor jeg med glæde vil hilse på dig. Det kan også være at du vil synes det er spændende at at se mere om mine [live-kodnings-optrædener](https://youtube.com/samaaron) , hvor jeg koder i Sonic Pi foran publikum.

en: If you have any thoughts, or ideas for improving Sonic Pi - please pass them on - feedback is so helpful. You never know, your idea might be the next big feature!
da: Hvis du har ideer til, hvordan Sonic Pi kan forbedres, så send dem endelig til mig - feedback hjælper så meget. Hvem ved, måske bliver din idé til den næste store feature!

en: This tutorial is divided up into sections grouped by category. Whilst I've written it to have an easy learning progression from start to finish, feel very free just to dip in and out of sections as you see fit. If you feel that there's something missing, do let me know and I'll consider it for a future version.
da: Denne vejledning er opdelt i sektioner, som er grupperet efter kategori. Denne vejledning er skrevet for at have et let læringsforløb fra start til slut. Spring bare til de sektioner du har lyst til. Føler du at der er noget der mangler, så fortæl mig det, og så vil jeg overveje det til en fremtidig version.

en: Finally, watching others live code is a really great way to learn. I regularly stream live on [https://youtube.com/samaaron](http://youtube.com/samaaron) so please do drop by, say hi and ask me lots of questions :-)
da: At se andre kode live kan være en rigtig god måde at lære på. Jeg streamer ofte live på [http://youtube.com/samaaron](http://youtube.com/samaaron), så kom endelig forbi, sig hej og stil en masse spørgsmål :-)

en: OK, let's get started...
da: Okay, lad os komme i gang...

en: 1.1 Live Coding
da: 1.1 Live-kodning

en: Live Coding
da: Live-kodning

en: One of the most exciting aspects of Sonic Pi is that it enables you to write and *modify code live* to make music, just like you might perform live with a guitar. This means that given some practice you can take Sonic Pi on stage and gig with it.
da: Et af de mest interessante aspekter af Sonic Pi er, at det giver dig mulighed for at skrive og *ændre kode live* for at lave musik, præcis som man måske vil spille live på en guitar. Det betyder at når du har øvet dig, kan du tage Sonic Pi med på scenen og spille med det.

en: Free your mind
da: Frigør dine tanker

en: Before we get into the real details of how Sonic Pi works in the rest of this tutorial, I'd like to give you an experience of what it's like to live code. Don't worry if you don't understand much (or any) of this. Just try to hold onto your seats and enjoy...
da: Før vi rigtig går i detaljerne med hvordan Sonic Pi virker i resten af denne vejledning, vil jeg gerne give dig en oplevelse af, hvordan det er at kode live. Bliv ikke urolig hvis du ikke forstår meget (hvis noget) af koden. Hold fast i stolen og nyd det...

en: A live loop
da: En live-løkke

en: Let's get started, copy the following code into an empty buffer:
da: Lad os starte! Kopier det følgende kode ind i et tomt kodefelt ovenfor:

en: Now, press the `Run` button and you'll hear a nice fast bass drum beating away. If at any time you wish to stop the sound just hit the `Stop` button. Although don't hit it just yet... Instead, follow these steps:
da: Hvis du nu trykker på `Run`-knappen, vil du høre lyden af en hurtig stortromme. Hvis du ønsker at stoppe, trykker du på `Stop`-knappen. Men tryk ikke på den endnu... følg i stedet disse skridt:

en: Make sure the bass drum sound is still running
da: Sørg for, at lyden af stortrommen stadig kører

en: Change the `sleep` value from `0.5` to something higher like `1`.
da: Prøv at ændre værdien for `sleep` fra `0.5` til en højere værdi, fx `1`.

en: Press the `Run` button again
da: Tryk på `Run`-knappen igen

en: Notice how the drum speed has changed.
da: Læg mærke til, hvordan trommelydens hastighed har ændret sig.

en: Finally, *remember this moment*, this is the first time you've live coded with Sonic Pi and it's unlikely to be your last...
da: Til sidst, *husk øjeblikket*, dette er første gang du har live-kodet med Sonic Pi, men sandsynligvis ikke den sidste...

en: Ok, that was simple enough. Let's add something else into the mix. Above `sample :bd_haus` add the line `sample :ambi_choir, rate: 0.3`. Your code should look like this:
da: Okay, det var enkelt nok. Lad os tilføje noget mere. Over `sample: bd_haus` tilføj linjen `sample :ambi_choir, rate: 0.3`. Din kode skal se sådan ud:

en: Now, play around. Change the rates - what happens when you use high values, or small values or negative values? See what happens when you change the `rate:` value for the `:ambi_choir` sample just slightly (say to `0.29`). What happens if you choose a really small `sleep` value? See if you can make it go so fast your computer will stop with an error because it can't keep up (if that happens, just choose a bigger `sleep` time and hit `Run` again).
da: Tid til at lege lidt. Skift satserne - hvad sker der når du bruger store værdier, små værdier eller negative værdier? Se hvad der sker når du ændrer `rate:`-værdien for lydklippet `:ambi_choir` en smule (fx til `0.29`). Hvad sker der hvis du vælger en meget kort `sleep`-værdi? Se om du kan få det til at gå så hurtigt at din computer vil stoppe med en fejl fordi den ikke kan følge med (hvis det sker, skal du bare vælge en længere `sleep`-tid og trykke på `Run` igen).

en: Try commenting one of the `sample` lines out by adding a `#` to the beginning:
da: Prøv at udkommentere en af `sample`-linjerne ved at tilføje et `#` i starten af linjen:

en: Notice how it tells the computer to ignore it, so we don't hear it. This is called a comment. In Sonic Pi we can use comments to remove and add things into the mix.
da: Bemærk hvordan linjen bliver ignoreret af computeren, så vi ikke hører den. Dette kaldes en kommentar. I Sonic Pi kan vi bruge kommentarer til at fjerne og tilføje dele mens man mixer.

en: Finally, let me leave you something fun to play with. Take the code below, and copy it into a spare buffer. Now, don't try to understand it too much other than see that there are two loops - so two things going round at the same time. Now, do what you do best - experiment and play around. Here are some suggestions:
da: Lad mig afslutningsvis give dig lidt sjovt at lege med. Tag koden herunder, og kopier den til et ekstra kodefelt. Du behøver ikke at forstå præcis hvad koden gør, andet end at der er to løkker - to dele der bliver gentaget samtidig. Gør nu det, du gør bedst - eksperimentér og leg. Her er nogle forslag:

en: Try changing the blue `rate:` values to hear the sample sound change.
da: Prøv at ændre den blå `rate:`-værdi og hør hvordan lydklippet ændrer sig.

en: Try changing the `sleep` times and hear that both loops can spin round at different rates.
da: Prøv at ændre `sleep`-tiderne og hør efter hvordan begge løkker kan køre rundt på forskellige hastigheder.

en: Try uncommenting the sample line (remove the `#`) and enjoy the sound of the guitar played backwards.
da: Prøv at fjerne kommenteringen på `sample`-linjen (fjern `#`) og nyd lyden af guitaren der spiller baglæns.

en: Try changing any of the blue `mix:` values to numbers between `0` (not in the mix) and `1` (fully in the mix).
da: Prøv at ændre nogen af de blå `mix:`-værdier til tal mellem `0` (ikke med i mixet) og `1` (helt med i mixet).

en: Remember to press `Run` and you'll hear the change next time the loop goes round. If you end up in a pickle, don't worry - hit `Stop`, delete the code in the buffer and paste a fresh copy in and you're ready to jam again. Making mistakes is how you'll learn the quickest...
da: Husk at trykke `Run`. Så vil du høre ændringen næste gang løkken starter. Hvis du ender med noget rod, så bare rolig: Tryk `Stop`, slet koden i kodefeltet og sæt en frisk kopi ind. Så er du klar til at lave musik igen. At lave fejl er en af de bedste måder at lære på...

en: Now, keep playing and experimenting until your curiosity about how this all actually works kicks in and you start wondering what else you can do with this. You're now ready to read the rest of the tutorial.
da: Bliv ved med at eksperimentere indtil du bliver nysgerrig på hvordan det hele faktisk virker, og du begynder at spekulere på hvad ellers du kan lave. Nu er du klar til at følge resten af vejledningen.

en: So what are you waiting for...
da: Så hvad venter du på...?

en: 1.2 Exploring the Interface
da: 1.2 Udforskning af brugerfladen

en: The Sonic Pi Interface
da: Sonic Pi-brugerfladen

en: Sonic Pi has a very simple interface for coding music. Let's spend a little time exploring it.
da: Sonic Pi har en meget simpel brugerflade til at kode musik. Lad os tage et kig på den.

en: ![Sonic Pi Interface](../../../etc/doc/images/tutorial/GUI.png)
da: ![Sonic Pi-brugerfladen](../../../etc/doc/images/tutorial/GUI.png)

en: *A* - Play Controls
da: *A* - Afspilning

en: *B* - Editor Controls
da: *B* - Styring af kodefelt

en: *C* - Info and Help
da: *C* - Information og hjælp

en: *D* - Code Editor
da: *D* - Kodefelt

en: *E* - Prefs Panel
da: *E* - Indstillinger

en: *F* - Log Viewer
da: *F* - Logfremviser

en: *G* - Help System
da: *G* - Hjælpesystem

en: *H* - Scope Viewer
da: *H* - Oscilloskop

en: *I* - Cue Viewer
da: *F* -In/ud Punkt viser

en: A. Play Controls
da: A. Afspilning

en: These pink buttons are the main controls for starting and stopping sounds. There's the *Run* button for running the code in the editor, *Stop* for stopping all running code, *Save* for saving the code to an external file and *Record* to create a recording (a WAV file) of the sound playing.
da: Disse lyserøde knapper bruger du til at starte og stoppe lydene. Der er *Run*-knappen til at køre koden i kodefeltet, *Stop* til at stoppe al kørende kode, *Save* til at gemme koden til en ekstern fil og *Record* til at lave en optagelse (en WAV-fil) af den lyd der bliver afspillet.

en: B. Editor Controls
da: B. Styring af kodefelt

en: These orange buttons allow you to manipulate the code editor. The *Size +* and *Size -* buttons allow you to make the text bigger and smaller.
da: Disse orange knapper giver mulighed for at ændre kodefeltet. Knapperne *Size +* og *Size -* giver dig mulighed for at gøre teksten større og mindre.

en: C. Info and Help
da: C. Information og hjælp

en: These blue buttons give you access to information, help and preferences. The *Info* button will open up the information window which contains information about Sonic Pi itself - the core team, history, contributors and community. The *Help* button toggles the help system (*G*) and the *Prefs* button toggles the preferences window which allows you to control some basic system parameters.
da: Disse blå knapper giver adgang til information, hjælp og indstillinger. *Info*-knappen vil åbne informationsvinduet som giver information om selve Sonic Pi - kerne-udviklerholdet, historien, bidragsydere og fællesskabet. *Help*-knappen viser og skjuler hjælpesystemet (*G*), og *Prefs*-knappen viser og skjuler indstillingsvinduet som giver mulighed for at styre nogle grundlæggende systemindstillinger.

en: D. Code Editor
da: D. Kodefelt

en: This is the area where you'll write your code and compose/perform music. It's a simple text editor where you can write code, delete it, cut and paste, etc. Think of it like a very basic version of Word or Google Docs. The editor will automatically colour words based on their meaning in the code. This may seem strange at first, but you'll soon find it very useful. For example, you'll know something is a number because it is blue.
da: Dette er stedet hvor du skriver din kode og komponerer/opfører din musik. Det er et simpelt tekst-redigeringsfelt hvor du kan skrive kode, slette det, klippe og kopiere osv. Tænk på det som en meget simpel udgave af Word eller Google Docs. Redigeringsfeltet vil automatisk farve ord på baggrund af deres betydning i koden. Det virker måske mærkeligt i starten, men du vil snart finde det meget nyttigt. For eksempel vil du vide at noget er et tal fordi det er blåt.

en: E. Prefs Panel
da: E. Indstillinger

en: Sonic Pi supports a number of tweakable preferences which can be accessed by toggling the *prefs* button in the Info and Help button set. This will toggle the visibility of the Prefs Panel which includes a number of options to be changed. Examples are forcing mono mode, inverting stereo, toggling log output verbosity and also a volume slider and audio selector on the Raspberry Pi.
da: Sonic Pi stiller en række instillinger til rådighed som kan tilgås via *Prefs*-knappen i området Information og hjælp. Den vil vise eller skjule indstillingspanelet som indeholder et antal indstillinger som kan ændres. For eksempel kan du gennemtvinge mono-tilstand, bytte rundt på stereo, og vælge hvad der skal i loggen. Der er også styring af lydstyrken og en lydvælger på Raspberry Pi.

en: F. Log Viewer
da: F. Logfremviser

en: When you run your code, information about what the program is doing will be displayed in the log viewer. By default, you'll see a message for every sound you create with the exact time the sound was triggered. This is very useful for debugging your code and understanding what your code is doing.
da: Når du kører din kode, vil information om hvad programmet laver, blive vist i logfremviseren. Som udgangspunkt vil du se en besked for hver lyd du spiller med det præcise tidspunkt lyden blev startet på. Det er meget nyttigt til fejlfinding i din kode og til at forstå hvad din kode faktisk gør.

en: G. Help System
da: G. Hjælpesystem

en: One of the most important parts of the Sonic Pi interface is the help system which appears at the bottom of the window. This can be toggled on and off by clicking on the blue *Help* button. The help system contains help and information about all aspects of Sonic Pi including this tutorial, a list of available synths, samples, examples, FX and a full list of all the functions Sonic Pi provides for coding music.
da: En af de vigtigste dele af brugerfladen i Sonic Pi er hjælpesystemet som bliver vist i bunden af vinduet. Det kan vises eller skjules ved at trykke på den blå *Help*-knap. Hjælpesystemet indeholder hjælp og information om alle dele af Sonic Pi, bl.a. denne vejledning, en liste af tilgængelige synths, lydklip, eksempler, effekter og en komplet liste af alle funktionerne som Sonic Pi stiller til rådighed for at kode musik.

en: H. Scope Viewer
da: H. Oscilloskop

en: The scope viewer allows you to see the sound you're hearing. You can easily see that the saw wave looks like a saw and that the basic beep is a curvey sine wave. You can also see the difference between loud and quiet sounds by the size of the lines. There are 3 scopes to play with - the default is a combined scope for the left and right channels, there is a stereo scope which draws a separate scope for each channel. Finally there is a Lissajous curve scope which will show the phase relationship between the left and right channels and allows you to draw pretty pictures with sound (https://en.wikipedia.org/wiki/Lissajous_curve).
da: Oscilloskopet viser den lyd du hører. Her kan du se at en `saw`-synth ligner en sav, og at det grundlæggende bip er en sinusbølge. Du kan også se forskellen mellem larmende og stille lyde fra størrelsen af linjerne. Der er tre oscilloskoper at lege med. Standard-oscilloskopet viser venstre og højre lydudgange kombineret. Der er også en stereo-visning som tegner separate oscilloskoper for hver kanal. Endelig er der et Lissajous-kurve-skop som viser fase-afhængighederne mellem venstre og højre kanal og giver mulighed for at tegne flotte billeder med lyd (https://en.wikipedia.org/wiki/Lissajous_curve).

en: 1.3 Learning through Play
da: 1.3 Læring gennem leg

en: Learning through Play
da: Læring gennem leg

en: Sonic Pi encourages you to learn about both computing and music through play and experimentation. The most important thing is that you're having fun, and before you know it you'll have accidentally learned how to code, compose and perform.
da: Sonic Pi opfordrer dig til at lære om både programmering og musik gennem leg og eksperimenter. Det vigtigste er at du har det sjovt, og før du ved af det, har du også lært at kode, komponere og opføre musik.

en: There are no mistakes
da: Der er ingen fejl

en: Whilst we're on this subject, let me just give you one piece of advice I've learned over my years of live coding with music - *there are no mistakes, only opportunities*. This is something I've often heard in relation to jazz but it works equally well with live coding. No matter how experienced you are - from a complete beginner to a seasoned live coder, you'll run some code that has a completely unexpected outcome. It might sound insanely cool - in which case run with it. However, it might sound totally jarring and out of place. It doesn't matter that it happened - what matters is what you do next with it. Take the sound, manipulate it and morph it into something awesome. The crowd will go *wild*.
da: Nu vi taler om det, så lad mig give dig et råd som jeg har lært over årene med live-kodning af musik - *der er ingen fejl, kun muligheder*. Det er noget jeg ofte har hørt i forhold til jazz, men det fungerer lige så godt med live-kodning. Lige meget hvor erfaren du er - fra fuldstændig begynder til en erfaren live-koder - så vil du komme til at køre noget kode som lyder helt uventet. Det lyder måske sindssygt godt - i det tilfælde kan du bare køre videre med det. Det kan dog også lyde disharmonisk og malplaceret. Det er lige meget hvad der skete - hvad der betyder noget, er hvad du efterfølgende gør med det. Tag lyden, manipuler den og gør den til noget fantastisk. Publikum bliver *ellevilde*.

en: Start Simple
da: Start simpelt

en: When you're learning, it's tempting to want to do amazing things *now*. However, just hold that thought and see it as a distant goal to reach *later*. For now, instead think of the *simplest* thing you could write which would be fun and rewarding that's a small step towards the amazing thing you have in your head. Once you have an idea about that simple step, then try and build it, play with it and then see what new ideas it gives you. Before long you'll be too busy having fun and making real progress.
da: Når du lærer noget nyt, er det fristende at forsøge at lave fantastiske ting *nu*. Men tag den med ro og betragt det som et fjernt mål at nå *senere*. Tænk i stedet over den *simpleste* ting du kan skrive som kan være sjov og berigende, og som kan være et lille skridt mod den fantastiske ting du har i hovedet. Når du får en ide om sådan et simpelt skridt, så byg det, leg med det og se hvad andre nye ideer du får. Før du får set dig om, vil du have det sjovt og lave rigtige fremskridt.

en: Just make sure to share your work with others!
da: Husk nu at dele dit arbejde med andre!

en: OK, enough of the intros - let's get into some sound.
da: Okay, nok indledning - lad os lave noget lyd.

en: In this section we'll cover the basics of triggering and manipulating synths. Synth is short for synthesiser which is a fancy word for something which creates sounds. Typically synths are quite complicated to use - especially analog synths such as Eurorack modules connected together by a mess of wires. However, Sonic Pi gives you much of that power in a very simple and approachable manner.
da: I denne sektion vil vi dække grundlæggende afspilning og manipulation af synths. Synth er en forkortelse for synthesiser, som er et smart ord for noget som laver lyde. Normalt er synths ret svære at bruge - specielt analoge synths såsom Eurorack-moduler forbundet med et virvar af ledninger. Heldigvis giver Sonic Pi dig mange muligheder på en simpel og tilgængelig måde.

en: Don't be fooled by the immediate simplicity of Sonic Pi's interface. You can get very deep into very sophisticated sound manipulation if that's your thing. Hold on to your hats...
da: Lad dig ikke narre af den umiddelbare enkelthed af brugerfladen i Sonic Pi. Du kan dykke langt ned i meget sofistikeret manipulation af lyd hvis det er det du ønsker. Hold på hat og briller...

en: 2.1 Your First Beeps
da: 2.1 Dine første bip

en: Your First Beeps
da: Dine første bip

en: Take a look at the following code:
da: Betragt følgende kode:

en: This is where it all starts. Go ahead, copy and paste it into the code window at the top of the app (the big white space under the Run button). Now, press Run...
da: Det er her det hele begynder. Bare kopier linjen og sæt den ind i kodefeltet i toppen af applikationen (det store, hvide felt under Run-knappen). Prøv nu at trykke Run...

en: Beep!
da: Bip!

en: Intense. Press it again. And again. *And again...*
da: Vildt. Tryk på knappen igen. Og igen. *Og igen...*

en: Can you hear the difference? Try a lower number:
da: Kan du høre forskellen? Prøv et lavere tal:

en: So, lower numbers make lower pitched beeps and higher numbers make higher pitched beeps. Just like on a piano, the keys at the lower part of the piano (the left hand side) play lower notes and the keys on the higher part of the piano (the right hand side) play higher notes.
da: Så lavere tal giver dybere bip, og højere tal giver lysere bip. Præcis som på et klaver, hvor tangenterne i den lave del af klaveret (venstre side) vil spille dybe toner, mens tangenterne i den høje den af klaveret (højre side) vil spille lyse toner.

en: It turns out that the C of the 4th octave (C in English notation) is identified by the number 60. `play 60` therefore plays the C of the 4th octave. To play the next piano key to the right, you have to add 1 to 60 and then type `play 61`, which in this case is the black key of the C sharp. To play the D, the next key to the right, `play 62`.
da: Det viser sig at C i fjerde oktav (det man normalt bare kalder C) svarer til tallet 60. `play 60` spiller derfor C i fjerde oktav. For at spille næste klavertangent til højre skal du lægge 1 til 60 og derfor skrive `play 61`, som i dette tilfælde giver den sorte tangent der svarer til Cis. For at spille D, dvs. den næste tangent til højre, skal du skrive `play 62`.

en: *Don't worry* if this means nothing to you - it didn't to me when I first started. All that matters right now is that you know that *low numbers make lower beeps* and *high numbers make higher beeps*.
da: *Bare rolig* hvis det her ikke giver mening for dig - det gjorde det heller ikke for mig da jeg begyndte. Det der betyder noget lige nu, er at du ved at *lavere tal giver dybere bip* og *højere tal giver lysere bip*.

en: Chords
da: Akkorder

en: Playing a note is quite fun, but playing many at the same time can be even better. Try it:
da: Det er sjovt at spille en enkelt tone, men det kan være endnu bedre at spille flere på en gang. Prøv det:

en: Jazzy! So, when you write multiple `play`s, they all play at the same time. Try it for yourself - which numbers sound good together? Which sound terrible? Experiment, explore and find out for yourself.
da: Jazzet! Når du skriver flere `play`-linjer, så bliver de alle sammen spillet på samme tid. Prøv selv - hvilke tal lyder godt sammen? Hvilke lyder forfærdeligt? Eksperimentér, udforsk og find selv ud af det.

en: Melody
da: Melodi

en: So, playing notes and chords is fun - but how about a melody? What if you wanted to play one note after another and not at the same time? Well, that's easy, you just need to `sleep` between the notes:
da: Det er sjovt at spille toner og akkorder - men hvad med en melodi? Hvad hvis du ønsker at spille en tone efter en anden, og ikke på samme tid? Det er heldigvis nemt: Du skal bare sætte `sleep` mellem tonerne:

en: How lovely, a little arpeggio. So what does the `1` mean in `sleep 1`? Well it means the *duration of the sleep*. It actually means sleep for one beat, but for now we can think about it as sleeping for 1 second. So, what if we wanted to make our arpeggio a little faster? Well, we need to use shorter sleep values. What about a half i.e. `0.5`:
da: Hvor yndigt - en lille arpeggio. `sleep` betyder `sov` på engelsk, og bruges når der skal ventes. Men hvad betyder så `1` i `sleep 1`? Det står for *ventetiden*. Det betyder egentlig at der skal ventes et slag, men indtil videre kan vi betragte det som om der ventes 1 sekund. Så hvad hvis vi ønsker at få vores arpeggio til at køre lidt hurtigere? Så skal vi bruge kortere ventetider. Hvad med halvdelen, dvs. `0.5`:

en: Notice how it plays faster. Now, try for yourself, change the times - use different times and notes.
da: Bemærk at det kører hurtigere. Prøv nu selv at ændre ventetiderne - brug forskellige ventetider og toner.

en: One thing to try is in-between notes such as `play 52.3` and `play 52.63`. There's absolutely no need to stick to standard whole notes. Play around and have fun.
da: Du kan også prøve at bruge mellemtoner såsom `play 52.3` og `play 52.63`. Du behøver overhovedet ikke at holde dig til standard-toner. Leg og hav det sjovt.

en: Traditional Note Names
da: Traditionelle nodenavne

en: For those of you that already know some musical notation (don't worry if you don't - you don't need it to have fun) you might want to write a melody using note names such as C and F# rather than numbers. Sonic Pi has you covered. You can do the following:
da: For de af jer der allerede kender til musikalsk notation (bare rolig hvis du ikke gør - du behøver ikke at kende til det for at have det sjovt), ønsker I måske at skrive en melodi med nodenavne såsom C og F# i stedet for tal. Det kan du også gøre i Sonic Pi. Du kan gøre følgende:

en: Remember to put the colon `:` in front of your note name so that it goes pink. Also, you can specify the octave by adding a number after the note name:
da: Husk at sætte kolon (`:`) foran nodenavnet så det bliver lyserødt. Du kan også angive oktaven ved at føje et tal til nodenavnet:

en: If you want to make a note sharp, add an `s` after the note name such as `play :Fs3` and if you want to make a note flat, add a `b` such as `play :Eb3`.
da: Hvis du ønsker at hæve en halv tone, så føj et `s` til nodenavnet, såsom `play :Fs3`, og hvis du ønsker at sænke en halv tone, så tilføj `b`, såsom `play :Eb3`.

en: 2.2 Synth Options
da: 2.2 Synth-parametre

en: Synth Options: Amp and Pan
da: Synth-parametre: Amplitude og panorering

en: As well as allowing you to control which note to play or which sample to trigger, Sonic Pi provides a whole range of options to craft and control the sounds. We'll be covering many of these in this tutorial and there's extensive documentation for each in the help system. However, for now we'll introduce two of the most useful: *amplitude* and *pan*. First, let's look at what options actually are.
da: Ligesom du kan styre hvilken tone du spiller eller hvilket lydklip du starter, stiller Sonic Pi en række parametre til rådighed for at udforme og styre lydene. Vi kommer til at dække mange af disse i denne vejledning, og der er udførlig dokumentation for alle parametrene i hjælpesystemet. Indtil videre vil vi dog nøjes med at præsentere to af de mest brugbare: *amplitude* (lydstyrke) og *panorering* (bevægelse mellem stereo-højttalerne).

en: Options
da: Parametre

en: Sonic Pi supports the notion of options (or opts for short) for its synths. Opts are controls you pass to `play` which modify and control aspects of the sound you hear. Each synth has its own set of opts for finely tuning its sound. However, there are common sets of opts shared by many sounds such as `amp:` and envelope opts (covered in another section).
da: Sonic Pi giver mulighed for at sætte parametre når du afspiller synths. Du styrer parametrene ved at give dem med til `play`, og du kan på den måde styre lyden. Hver synth har sine egne parametre for at ændre dens lyd. Der er dog nogle parametre der går igen på tværs af mange lyde, fx `amp:` (til amplitude) og envelope-muligheder (kontur af lyden - det dækker vi i et andet kapitel).

en: Opts are passed to calls to `play` by using a comma `,` and then the name of the opt such as `amp:` (don't forget the colon `:`) and then a space and the value of the opt. For example:
da: Parametre gives til kald til `play` ved at bruge et komma (`,`), navnet på parameteren såsom `amp:` (glem ikke kolonet, `:`) og til sidste et mellemrum og værdien for parameteren. For eksempel:

en: (Note that `cheese:` isn't a valid opt, we're just using it as an example).
da: (For god ordens skyld: `cheese` er ikke en rigtig parameter; vi bruger den blot som et eksempel.)

en: You can pass multiple opts by separating them with a comma:
da: Du kan sætte flere parametre ved at adskille dem med komma:

en: The order of the opts doesn't matter, so the following is identical:
da: Rækkefølgen af parametre er ligegyldig, så nedenstående gør det samme:

en: Opts that aren't recognised by the synth are just ignored (like `cheese` and `beans` which are clearly ridiculous opt names!)
da: Parametre som ikke kan sættes på synth'en, ignoreres blot, såsom `cheese` og `beans` som er åbenlyst fjollede parameternavne!

en: If you accidentally use the same opt twice with different values, the last one wins. For example, `beans:` here will have the value 2 rather than 0.5:
da: Hvis du ved et uheld sætter samme parameter to gange med forskellige værdier, bruges den sidste. For eksempel vil `beans` her få værdien 2, ikke 0.5:

en: Many things in Sonic Pi accept opts, so just spend a little time learning how to use them and you'll be set! Let's play with our first opt: `amp:`.
da: Mange ting i Sonic Pi kan tage parametre, så brug lidt tid på at lære hvordan du bruger dem. Lad os lege med vores første parameter: `amp:`.

en: Amplitude is a computer representation of the loudness of a sound. A *high amplitude produces a loud sound* and a *low amplitude produces a quiet sound*. Just as Sonic Pi uses numbers to represent time and notes, it uses numbers to represent amplitude. An amplitude of 0 is silent (you'll hear nothing) whereas an amplitude of 1 is normal volume. You can even crank up the amplitude higher to 2, 10, 100. However, you should note that when the overall amplitude of all the sounds gets too high, Sonic Pi uses what's called a compressor to squash them all to make sure things aren't too loud for your ears. This can often make the sound muddy and strange. So try to use low amplitudes, i.e. in the range 0 to 0.5 to avoid compression.
da: Amplitude er en computers repræsentation af lydniveauet. En *høj amplitude giver en kraftig lyd*, og en *lav amplitude giver en stille lyd*. Ligesom Sonic Pi bruger tal til at repræsentere tid og toner, bruger den tal til at repræsentere amplitude. En amplitude på 0 er helt stille (du vil ikke høre noget), hvorimod en amplitude på 1 svarer til normalt lydniveau. Du kan endda skrue amplituden højere - på 2, 10, 100... Du skal dog være opmærksom på at når den samlede amplitude af alle lydene bliver for høj, bruger Sonic Pi hvad der kaldes en kompressor til at komprimere lydene sådan at de ikke bliver for høje for dine ører. Det kan gøre lyden mudret og mærkelig. Så prøv at bruge lave amplituder, dvs. i området fra 0 til 0.5, for at undgå komprimering.

en: Amp it up
da: Skru det op

en: To change the amplitude of a sound, you can use the `amp:` opt. For example, to play at half amplitude pass 0.5:
da: For at ændre amplituden af en lyd kan du bruge parameteren `amp:`. Du kan fx spille med halv amplitude ved at bruge 0.5:

en: To play at double amplitude pass 2:
da: Du kan spille med dobbelt amplitude ved at bruge 2:

en: The `amp:` opt only modifies the call to `play` it's associated with. So, in this example, the first call to play is at half volume and the second is back to the default (1):
da: Parameteren `amp:` ændrer kun det kald til `play` som den bruges på. I dette eksempel vil det første kald til `play` blive spillet på halvt niveau, mens det andet kald vil gå tilbage til udgangspunktet (1):

en: Of course, you can use different `amp:` values for each call to play:
da: Du kan selvfølgelig bruge forskellige værdier for `amp:` ved hvert kald til `play`:

en: Panning
da: Panorering

en: Another fun opt to use is `pan:` which controls the panning of a sound in stereo. Panning a sound to the left means that you hear it out of the left speaker, and panning it to the right means you hear it out of your right speaker. For our values, we use a -1 to represent fully left, 0 to represent center and 1 to represent fully right in the stereo field. Of course, we're free to use any value between -1 and 1 to control the exact positioning of our sound.
da: En anden sjov parameter at pille ved er `pan:` som styrer panoreringen af en lyd i stereo. Hvis du panorerer en lyd til venstre, vil du høre den fra venstre højttaler, og hvis du panorerer en lyd til højre, vil du høre den fra højre højttaler. I Sonic Pi vil en værdi på -1 betyde "helt til venstre", 0 vil betyde "i midten", og 1 vil betyde "helt til højre". Vi kan selvfølgelig vælge enhver værdi mellem -1 og 1 for at styre den præcise placering af vores lyd.

en: Let's play a beep out of the left speaker:
da: Lad os spille et bip ud af venstre højttaler:

en: Now, let's play it out of the right speaker:
da: Lad os nu spille det ud af højre højttaler:

en: Finally let's play it back out of the center of both (the default position):
da: Lad os til sidst spille det i midten (udgangspositionen):

en: Now, go and have fun changing the amplitude and panning of your sounds!
da: Prøv nu at more dig med at ændre amplituden og panoreringen af dine lyde!

en: 2.3 Switching Synths
da: 2.3 Skift af synths

en: Switching Synths
da: Skift af synths

en: So far we've had quite a lot of fun making beeps. However, you're probably starting to get bored of the basic beep noise. Is that all Sonic Pi has to offer? Surely there's more to live coding than just playing beeps? Yes there is, and in this section we'll explore some of the exciting range of sounds that Sonic Pi has to offer.
da: Indtil videre har vi moret os vældigt med at lave biplyde, men det kan være at du er ved at kede dig lidt over den simple lyd. Er det virkelig alt hvad Sonic Pi kan? Er der mon ikke andet i live-kodning end blot at spille biplyde? Jo da, og i dette kapitel vil vi udforske nogle af de spændende muligheder for forskellige lyde som Sonic Pi tilbyder.

en: Sonic Pi has a number of different instruments it calls synths (which is *short for synthesisers*). Whereas samples represent pre-recorded sounds, synths are capable of generating new sounds depending on how you control them (which we'll explore later in this tutorial). Sonic Pi's synths are very powerful and expressive and you'll have a lot of fun exploring and playing with them. First, let's learn how to select the current synth to use.
da: Sonic Pi har en masse forskellige instrumenter som vi kalder synths. Det er en forkortelse for *synthesisers*. I modsætning til samples, som er lydklip der er optaget på forhånd, kan synths generere nye lyde afhængigt af hvordan du styrer dem - det vil vi komme nærmere ind på senere i denne vejledning. De synths som Sonic Pi tilbyder, er meget udtryksfulde, og du vil få meget sjov ud af at udforske og lege med dem. Lad os først få lært hvordan man vælger en synth.

en: Buzzy saws and prophets
da: Brummende save og profeter

en: A fun sound is the *saw wave* - let's give it a try:
da: En sjov lyd er *sav-bølgen* - lad os prøve den:

en: Let's try another sound - the *prophet*:
da: Lad os prøve en anden lyd - *profeten*:

en: How about combining two sounds. First one after another:
da: Hvad med en kombination af de to lyde? Først den ene efter den anden:

en: Now multiple sounds at the same time (by not sleeping between successive calls to `play`):
da: Nu flere lyde på samme tid - det opnår vi ved ikke at kalde `sleep` mellem kaldene til `play`:

en: Notice that the `use_synth` command only affects the following calls to `play`. Think of it like a *big switch* - new calls to `play` will play whatever synth it's currently pointing to. You can move the switch to a new synth with `use_synth`.
da: Bemærk at kommandoen `use_synth` kun påvirker de efterfølgende kald til `play`. Betragt det som en *stor pegepind* - nye kald til `play` vil spille en hvilken som helst synth som den peger på nu. Du kan bagefter pege på en ny synth med `use_synth`.

en: Discovering Synths
da: Udforskning af synths

en: To see which synths Sonic Pi has for you to play with take a look at the Synths option in the menu at the bottom of this help screen (between Examples & Fx). There are over 20 to choose from. Here are a few of my favourites:
da: For at se hvilke synths Sonic Pi giver dig at lege med, kan du tage et kig i Synths-fanen i menuen nederst i denne hjælpeskærm (mellem Examples og Fx). Der er over 20 at vælge imellem. Her er nogle af mine yndlings-synths:

en: Now play around with *switching synths during your music*. Have fun combining synths to make new sounds as well as using different synths for different sections of your music.
da: Prøv nu at *skifte synths undervejs i din musik*. Leg med at kombinere synths for at lave nye lyde, og prøv at bruge forskellige synths til forskellige dele af din musik.

en: 2.4 Duration with Envelopes
da: 2.4 Varighed med envelopes

en: Duration with Envelopes
da: Varighed med envelopes

en: In an earlier section, we looked at how we can use the `sleep` command to control when to trigger our sounds. However, we haven't yet been able to control the duration of our sounds.
da: I et tidligere kapitel så vi hvordan vi kan bruge `sleep`-kommandoen til at bestemme hvornår vores lyde starter. Vi har dog endnu ikke kunnet styre varigheden af vores lyde.

en: In order to give us a simple, yet powerful means of *controlling the duration* of our sounds, Sonic Pi provides the notion of an *ADSR amplitude envelope* (we'll cover what ADSR means later in this section). An amplitude envelope offers two useful aspects of control:
da: For at tilbyde en simpel, men alligevel fleksibel måde at *styre varigheden* af vores lyde gør Sonic Pi brug af begrebet *ADSR-amplitude-envelope*. Vi vil komme tilbage til hvad ADSR dækker over, senere i dette kapitel. Envelope kaldes også lydens kontur på dansk. En amplitude-envelope, eller amplitude-kontur, giver os mulighed for at styre to nyttige aspekter af lyden:

en: control over the duration of a sound
da: lydens varighed

en: control over the amplitude of a sound
da: lydens amplitude

en: Duration
da: Varighed

en: The duration is the length the sound lasts for. A longer duration means that you hear the sound for longer. Sonic Pi's sounds all have a controllable amplitude envelope, and the total duration of that envelope is the duration of the sound. Therefore, by controlling the envelope you control the duration.
da: Varigheden bestemmer hvor længe lyden kan høres. En længere varighed betyder at du hører lyden i længere tid. Alle lydene i Sonic Pi har en amplitude-envelope som kan styres, og den totale varighed af denne envelope er varigheden af lyden. Ved at styre lydens envelope styrer du derfor dens varighed.

en: The ADSR envelope not only controls duration, it also gives you *fine control over the amplitude of the sound*. All audible sounds start and end silent and contain some non-silent part in-between. Envelopes allow you to slide and hold the amplitude of non-silent parts of the sound. It's like giving someone instructions on how to turn up and down the volume of a guitar amplifier. For example you might ask someone to "start at silence, slowly move up to full volume, hold it for a bit, then quickly fall back to silence." Sonic Pi allows you to program exactly this behaviour with envelopes.
da: En ADSR-envelope styrer ikke kun varighed, den giver dig også *detaljeret styring over lydens amplitude*. Alle hørbare lyde starter og slutter stille og indeholder en ikke-stille del derimellem. Envelopes giver dig mulighed for at skrue op for og holde amplituden af de ikke-stille dele af lyden. Det svarer til at give nogen instruktioner om hvordan der skal skrues op og ned for lyden på en guitar-forstærker. For eksempel kan du bede nogen om at "starte med stilhed, skrue langsomt op til fuld lydstyrke, holde niveauet lidt tid og så hurtigt skrue ned til stilhed". Sonic Pi giver dig mulighed for at programmere præcis denne opførsel med envelopes.

en: Just to recap, as we have seen before, an amplitude of 0 is silence and an amplitude of 1 is normal volume.
da: For at opsummere: Som vi har været inde på tidligere, betyder en amplitude på 0 stilhed, mens en amplitude på 1 svarer til normal lydstyrke.

en: Now, let us look at each of the parts of the envelopes in turn.
da: Lad os nu se på hver del af en envelope ad gangen.

en: Release Phase
da: Release-fasen

en: The only part of the envelope that's used by default is the release time. This is the time it takes for the synth's sound to fade out. All synths have a release time of 1 which means that by default they have a duration of 1 beat (which at the default BPM of 60 is 1 second):
da: Den eneste del af envelopen der som udgangspunkt bruges, er release-varigheden. Det er den tid det tager for synth-lyden at falme ud. Alle synths har en release-varighed på 1. Det betyder at de som udgangspunkt har en varighed på ét slag, som ved standard-BPM på 60 svarer til et sekund:

en: The note will be audible for 1 second. Go ahead and time it :-) This is short hand for the longer more explicit version:
da: Dennne tone vil kunne høres i et sekund. Prøv at tage tid :-) Du kan også skrive det mere eksplicit:

en: Notice how this sounds exactly the same (the sound lasts for one second). However, it's now very easy to change the duration by modifying the value of the `release:` opt:
da: Bemærk at dette giver præcis samme resultat - lyden varer i et sekund. Men nu er det nemt at ændre varigheden ved at ændre på `release:`-parameteren:

en: We can make the synth sound for a very short amount of time by using a very small release time:
da: Vi kan få synth'en til at spille i meget kort tid ved at bruge en meget kort release-varighed:

en: The duration of the release of the sound is called the *release phase* and by default is a linear transition (i.e. a straight line). The following diagram illustrates this transition:
da: Den tid det tager lyden at falme ud, kaldes *release-fasen* og er som udgangspunkt en lineær overgang (dvs. en lige linje hvis man tegner den). Dette diagram illustrerer overgangen:

en: ![release envelope](../../../etc/doc/images/tutorial/env-release.png)
da: ![release-envelope](../../../etc/doc/images/tutorial/env-release.png)

en: The vertical line at the far left of the diagram shows that the sound starts at 0 amplitude, but goes up to full amplitude immediately (this is the attack phase which we'll cover next). Once at full amplitude it then moves in a straight line down to zero taking the amount of time specified by `release:`. *Longer release times produce longer synth fade outs.*
da: Den lodrette linje helt til venstre i diagrammet viser at lyden starter med amplitude 0, men straks går op til fuld amplitude. Det er attack-fasen som vi vil komme ind på om lidt. Når lyden er på fuld amplitude, vil den med konstant hastighed gå mod nul, og den vil tage den tid der er angivet som `release:`, for at nå nulpunktet. *Længere release-varigheder gør at synths tager længere tid om at falme ud.*

en: You can therefore change the duration of your sound by changing the release time. Have a play adding release times to your music.
da: På den måde kan du ændre varigheden af dine lyde ved at ændre på `release:`-parameteren. Prøv at have lidt sjov med at tilføje release-varigheder til din musik.

en: Attack Phase
da: Attack-fasen

en: By default, the *attack phase* is 0 for all synths which means they move from 0 amplitude to 1 immediately. This gives the synth an initial percussive sound. However, you may wish to fade your sound in. This can be achieved with the `attack:` opt. Try fading in some sounds:
da: Som udgangspunkt er *attack-fasen* 0 for alle synths, hvilket betyder at de straks går fra amplitude 0 til 1. Det giver synth'en et indledende anslag. Det kan dog være at du ønsker at lade din lyd falme ind. Det kan du opnå med `attack:`-parameteren. Prøv det på nogle lyde:

en: You may use multiple opts at the same time. For example for a short attack and a long release try:
da: Du kan sætte flere parametre ad gangen. Prøv for eksempel dette for et kort "attack" og en lang "release":

en: This short attack and long release envelope is illustrated in the following diagram:
da: Den tilsvarende envelope for det korte "attack" og den lange "release" er illustreret på det følgende diagram:

en: ![attack release envelope](../../../etc/doc/images/tutorial/env-attack-release.png)
da: ![attack-release-envelope](../../../etc/doc/images/tutorial/env-attack-release.png)

en: Of course, you may switch things around. Try a long attack and a short release:
da: Du kan selvfølgelig også bytte rundt på tingene. Prøv et langt attack og en kort release:

en: ![long attack short release envelope](../../../etc/doc/images/tutorial/env-long-attack-short-release.png)
da: ![envelope for lang attack, kort release](../../../etc/doc/images/tutorial/env-long-attack-short-release.png)

en: Finally, you can also have both short attack and release times for shorter sounds.
da: Du kan også give korte varigheder både til attack og release. Det giver kortere lyde.

en: ![short attack short release envelope](../../../etc/doc/images/tutorial/env-short-attack-short-release.png)
da: ![envelope for kort attack, kort release](../../../etc/doc/images/tutorial/env-short-attack-short-release.png)

en: Sustain Phase
da: Sustain-fasen

en: In addition to specifying attack and release times, you may also specify a sustain time to control the *sustain phase*. This is the time for which the sound is maintained at full amplitude between the attack and release phases.
da: Ud over at angive attack- og release-varigheder kan du styre *sustain-fasen* som angiver en "bevarings-varighed". Den bestemmer hvor længe lyden holdes på fuld amplitude mellem attack- og release-faserne.

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

en: The sustain time is useful for important sounds you wish to give full presence in the mix before entering an optional release phase. Of course, it's totally valid to set both the `attack:` and `release:` opts to 0 and just use the sustain to have absolutely no fade in or fade out to the sound. However, be warned, a release of 0 can produce clicks in the audio and it's often better to use a very small value such as 0.2.
da: Sustain-varigheden er nyttig til vigtige lyde som du ønsker at have fuldt til stede i mixet før de begynder på deres release-fase. Du kan selvfølgelig også sætte både `attack:` og `release:` til 0 og blot bruge `sustain:` for helt at undgå at lyden falmer ind eller ud. Men pas på - en release på 0 kan give uønskede kliklyde, så det er tit bedre at bruge en meget lille værdi såsom 0.2.

en: Decay Phase
da: Decay-fasen

en: For an extra level of control, you can also specify a decay time. This is a phase of the envelope that fits between the attack and sustain phases and specifies a time where the amplitude will drop from the `attack_level:` to the `decay_level:` (which unless you explicitly set it will be set to the `sustain_level:`). By default, the `decay:` opt is 0 and both the attack and sustain levels are 1 so you'll need to specify them for the decay time to have any effect:
da: For et ekstra niveau af kontol kan du også angive en henfalds-varighed: decay. Den bruges i decay-fasen, som er en fase i envelopen som sidder mellem attack- og sustain-faserne og angiver hvor længe amplituden er om at falde fra `attack_level:` (amplituden som attack-fasen slutter på) til `decay_level:` (amplituden som decay-fasen slutter på - og som, medmindre du har sat den til andet, får samme værdi som `sustain_level:`). Som udgangspunkt er `decay:`-parameteren 0, og både attack- og sustain-amplituderne er 1, så du er nødt til at angive dem for at decay-varigheden får en effekt:

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

en: Decay Level
da: Decay-amplitude

en: One last trick is that although the `decay_level:` opt defaults to be the same value as `sustain_level:` you can explicitly set them to different values for full control over the envelope. This allows you to to create envelopes such as the following:
da: Et sidste trick er at selvom `decay_level:`-parameteren, altså amplituden som decay-fasen slutter på, som udgangspunkt bliver sat til det samme som `sustain_level:`, så kan du sætte parametrene til forskellige værdier for at få fuld kontrol over envelopen. Det giver dig mulighed for at lave envelopes som den følgende:

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

en: It's also possible to set the `decay_level:` to be higher than `sustain_level:`:
da: Det er også muligt at sætte `decay_level:` højere end `sustain_level:`:

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

en: ADSR Envelopes
da: ADSR-envelopes

en: So to summarise, Sonic Pi's ADSR envelopes have the following phases:
da: Lad os opsummere: ADSR-envelopes i Sonic Pi har følgende faser:

en: *attack* - time from 0 amplitude to the `attack_level`,
da: *attack* - tiden det tager at gå fra amplitude 0 til `attack_level`,

en: *decay* - time to move amplitude from `attack_level` to `decay_level`,
da: *decay* - tiden det tager at flytte amplituden fra `attack_level` til `decay_level`,

en: *sustain* - time to move the amplitude from `decay_level` to `sustain_level`,
da: *sustain* - tiden det tager at flytte amplituden fra `decay_level` til `sustain_level`,

en: *release* - time to move amplitude from `sustain_level` to 0
da: *release* - tiden det tager at flytte amplituden fra `sustain_level` til 0

en: It's important to note that the duration of a sound is the summation of the times of each of these phases. Therefore the following sound will have a duration of 0.5 + 1 + 2 + 0.5 = 4 beats:
da: Det er vigtigt at bemærke at lydens totale varighed er summen af varighederne af disse faser. Den følgende lyd vil derfor have en varighed på 0.5 + 1 + 2 + 0.5 = 4 slag:

en: Now go and have a play adding envelopes to your sounds...
da: Tag nu og leg med at føje envelopes til dine lyde...

en: Another great way to develop your music is to use pre-recorded sounds. In great hip-hop tradition, we call these pre-recorded sounds *samples*. So, if you take a microphone outside, go and record the gentle sound of rain hitting canvas, you've just created a sample.
da: En anden god måde at udvikle din musik på er at bruge optagede lydklip. I respekt for den fantastiske hip-hop-tradition kalder vi disse lydklip for *samples*. Så hvis du tager en mikrofon med dig udenfor og optager den blide lyd af regn der rammer et stykke stof, så har du lavet en sample.

en: Sonic Pi lets you do lots of fun things with samples. Not only does it ship with 130 public domain samples ready for you to jam with, it lets you play and manipulate your own. Let's get to it...
da: Sonic Pi giver dig mulighed for at gøre mange sjove ting med samples. Ikke alene kommer det med 130 indbyggede samples som du frit kan lege med; det lader dig også afspille og manipulere dine egne. Lad os prøve...

en: 3.1 Triggering Samples
da: 3.1 Afspilning af samples

en: Triggering Samples
da: Afspilning af samples

en: Playing beeps is only the beginning. Something that's a lot of fun is triggering pre-recorded samples. Try it:
da: At afspille bip-lyde er kun begyndelsen. Noget andet der er virkelig sjovt, er at afspille optagede samples. Prøv det:

en: Sonic Pi includes many samples for you to play with. You can use them just like you use the `play` command. To play multiple samples and notes just write them one after another:
da: Sonic Pi kommer med mange samples du kan lege med. Du kan bruge dem ligesom du bruger `play`-kommandoen. For at afspille flere samples og toner skriver du dem bare efter hinanden:

en: If you want to space them out in time, use the `sleep` command:
da: Hvis ikke du vil afspille dem oven i hinanden, kan du bruge `sleep`-kommandoen:

en: Notice how Sonic Pi doesn't wait for a sound to finish before starting the next sound. The `sleep` command only describes the separation of the *triggering* of the sounds. This allows you to easily layer sounds together creating interesting overlap effects.
da: Bemærk hvordan Sonic Pi ikke venter på at én lyd bliver færdig før den starter på den næste lyd. `sleep`-kommandoen styrer kun hvor lang tid der går mellem lydene *starter*. Det giver dig mulighed for nemt at lægge flere lyde oven i hinanden og skabe interessante effekter.

en: Discovering Samples
da: Udforskning af samples

en: There are two ways to discover the range of samples provided in Sonic Pi. First, you can use this help system. Click on Samples in the menu at the bottom of this help screen, choose your category and then you'll see a list of available sounds.
da: Der er to måder at udforske de mange samples der kommer med Sonic Pi. For det første kan du bruge dette hjælpesystem. Klik på Samples i menuen i bunden af dette hjælpefelt og vælg din kategori, hvorefter du vil se en liste af tilgængelige lyde.

en: Alternatively you can use the *auto-completion system*. Simply type the start of a sample group such as: `sample :ambi_` and you'll see a drop-down of sample names appear for you to select. Try the following category prefixes:
da: Du kan også bruge *auto-complete-systemet*. Skriv blot starten af navnet på en sample, såsom `sample :ambi_`, og så vil der dukke en menu op med navne på samples du kan vælge imellem. Prøv følgende begyndelser på navne i forskellige kategorier:

en: Now start mixing samples into your compositions!
da: Prøv nu at blande samples ind i dine egne kompositioner!

en: 3.2 Sample Parameters
da: 3.2 Sample-parametre

en: Sample Parameters: Amp and Pan
da: Sample-parametre: Amplitude og panorering

en: As we saw with synths, we can easily control our sounds with parameters. Samples support exactly the same parameterisation mechanism. Let's revisit our friends `amp:` and `pan:`.
da: Som vi lærte med synths, kan vi nemt styre vores lyde med parametre. Samples giver dig præcis samme parameter-mekanisme. Lad os gense vores venner `amp:` og `pan:`.

en: Amping samples
da: Amplitude for samples

en: You can change the amplitude of samples with exactly the same approach you used for synths:
da: Du kan ændre amplituden (lydstyrken) for samples præcis som du gjorde for synths:

en: Panning samples
da: Panorering af samples

en: We're also able to use the `pan:` parameter on samples. For example, here's how we'd play the amen break in the left ear and then half way through play it again through the right ear:
da: Du kan også bruge `pan:`-parameteren på samples. Sådan vil vi fx spille "amen break" først i venstre højttaler og dernæst i højre højttaler:

en: Note that 0.877 is half the duration of the `:loop_amen` sample in seconds.
da: Bemærk at 0.877 er den halve varighed af samplen `:loop_amen` i sekunder.

en: Finally, note that if you set some synth defaults with `use_synth_defaults` (which we will discuss later), these will be ignored by `sample`.
da: Bemærk slutteligt at standardværdier for synths der bliver sat med `use_synth_defaults`-kommandoen (som vi vil komme nærmere ind på senere), vil blive ignoreret af `sample`.

en: 3.3 Stretching Samples
da: 3.3 Strækning af samples

en: Stretching Samples
da: Strækning af samples

en: Now that we can play a variety of synths and samples to create some music, it's time to learn how to modify both the synths and samples to make the music even more unique and interesting. First, let's explore the ability to *stretch* and *squash* samples.
da: Nu hvor vi kan afspille en række synths og samples for at skabe musik, er det tid til at lære hvordan vi kan styre både synths og samples for at gøre musikken endnu mere unik og interessant. Lad os først udforske muligheden for at *strække* og *skrumpe* samples.

en: Sample Representation
da: Intern repræsentation af en sample

en: Samples are pre-recorded sounds stored as numbers which represent how to move the speaker cone to reproduce the sound. The speaker cone can move in and out, and so the numbers just need to represent how far in and out the cone needs to be for each moment in time. To be able to faithfully reproduce a recorded sound the sample typically needs to store many thousands of numbers per second! Sonic Pi takes this list of numbers and feeds them at the right speed to move your computer's speaker in and out in just the right way to reproduce the sound. However, it's also fun to change the speed with which the numbers are fed to the speaker to change the sound.
da: Alle samples er forud-optagede lyde der gemmes som tal. Tallene bestemmer hvor meget membranen i højttaleren bevæger sig for at gengive lyden. Membranen kan bevæge sig ind og ud, så tallene skal kun bestemme hvor meget ind og ud membranen skal være på et givet tidspunkt. For at kunne give en troværdig gengivelse af lyden skal en sample typisk indeholde mange tusind tal per sekund! Sonic Pi tager disse tal og sender dem af sted med den rigtige hastighed for at flytte din computers højttaler ind og ud på den rigtige måde for at gengive lyden. Men det er også sjovt at ændre på den hastighed som tallene bliver sendt til højttaleren med. På den måde kan man ændre lyden.

en: Changing Rate
da: Ændring af hastigheden

en: Let's play with one of the ambient sounds: `:ambi_choir`. To play it with the default rate, you can pass a `rate:` opt to `sample`:
da: Lad os lege med en af ambient-lydene: `:ambi_choir`. For at afspille den med standard-hastigheden kan du give en `rate:`-parameter med til `sample`:

en: This plays it at normal rate (1), so nothing special yet. However, we're free to change that number to something else. How about `0.5`:
da: Det afspiller den ved den normale hastighed (1), så indtil videre sker der ikke noget specielt. Du kan dog ændre tallet til noget andet. Hvad med `0.5`:

en: Woah! What's going on here? Well, two things. Firstly, the sample takes twice as long to play, secondly the sound is an octave lower. Let's explore these things in a little more detail.
da: Hov! Hvad sker der her? Faktisk to ting. For det første tager samplen dobbelt så lang tid om at blive færdig, og for det andet er lyden en oktav lavere. Lad os udforske det lidt mere detaljeret.

en: Let's stretch
da: Lad os strække ud

en: A sample that's fun to stretch and compress is the Amen Break. At normal rate, we might imagine throwing it into a *drum 'n' bass* track:
da: En sample der er sjov at strække og krympe, er Amen Break. Ved den normale hastighed kan vi overveje at smide den i et stykke *drum'n'bass*-musik:

en: However by changing the rate we can switch up genres. Try half speed for *old school hip-hop*:
da: Men ved at ændre hastigheden kan vi skifte genren. Prøv halv hastighed for noget *old-school hip-hop*:

en: If we speed it up, we enter *jungle* territory:
da: Hvis vi skruer op for hastigheden, bliver det *jungle*-agtigt:

en: Now for our final party trick - let's see what happens if we use a negative rate:
da: Nu til vores sidste gang løjer - lad os se hvad der sker hvis vi bruger en negativ hastighed:

en: A Simple Explanation of Sample Rate
da: En simpel forklaring af sample-hastighed

en: A useful way to think of samples is as springs. Playback rate is like squashing and stretching the spring. If you play the sample at rate 2, you're *squashing the spring* to half its normal length. The sample therefore takes half the amount of time to play as it's shorter. If you play the sample at half rate, you're *stretching the spring* to double its length. The sample therefore takes twice the amount of time to play as it's longer. The more you squash (higher rate), the shorter it gets, the more you stretch (lower rate), the longer it gets.
da: Man kan sammenligne en sample med en fjeder. At ændre på afspilnings-hastigheden, eller raten, svarer til at presse fjedren sammen eller strække den ud. Hvis du afspiller samplen med rate 2 (dvs. dobbelt hastighed), så *klemmer du fjedren* til halvdelen af dens oprindelige længde. Derfor tager samplen den halve tid at blive afspillet, da den er kortere. Hvis du afspiller samplen med rate 0.5 (dvs. halv hastighed), så *strækker du fjedren ud* til dobbelt længde. Samplen tager derfor den dobbelte tid at blive afspillet, da den er længere. Jo mere du presser den sammen (højere rate/hastighed), jo kortere bliver den, og jo mere du strækker den den ud (lavere rate/hastighed), jo længere bliver den.

en: Compressing a spring increases its density (the number of coils per cm) - this is similar to the sample sounding *higher pitched*. Stretching the spring decreases its density and is similar to the sound having a *lower pitch*.
da: Når man presser en fjeder sammen, øger man dens tæthed (antal spoler pr. cm) - det svarer til at samplen får en *højere tone*. Når man strækker fjedren ud, mindsker man dens tæthed, og det svarer til at samplen får en *lavere tone*.

en: The Maths Behind Sample Rate
da: Matematikken bag sample-hastighed

en: (This section is provided for those that are interested in the details. Please feel free to skip it...)
da: (Dette afsnit er henvendt til dem der er interesseret i detaljerne. Du kan springe over det hvis du vil...)

en: As we saw above, a sample is represented by a big long list of numbers representing where the speaker should be through time. We can take this list of numbers and use it to draw a graph which would look similar to this:
da: Som vi så ovenfor, består en sample af en lang liste af tal som repræsenterer hvor højttaler-membranen skal stå over tid. Vi kan tage disse tal og tegne en graf med dem. Det kan se sådan ud:

en: ![sample graph](../../../etc/doc/images/tutorial/sample.png)
da: ![sample-graf](../../../etc/doc/images/tutorial/sample.png)

en: You might have seen pictures like this before. It's called the *waveform* of a sample. It's just a graph of numbers. Typically a waveform like this will have 44100 points of data per second (this is due to the Nyquist-Shannon sampling theorem). So, if the sample lasts for 2 seconds, the waveform will be represented by 88200 numbers which we would feed to the speaker at a rate of 44100 points per second. Of course, we could feed it at double rate which would be 88200 points per second. This would therefore take only 1 second to play back. We could also play it back at half rate which would be 22050 points per second taking 4 seconds to play back.
da: Måske du har set grafer som denne før. Det kaldes *bølgeformen* af en sample. Det er bare en graf over tal. En bølgeform som denne vil typisk have 44100 datapunkter pr. sekund - det skyldes Nyquist-Shannon-samplings-teoremet. Det betyder at hvis en sample varer 2 sekunder, vil bølgeformen bestå af 88200 tal som vi kan sende til højttaleren med en hastighed på 44100 tal pr. sekund. Vi kan naturligvis også sende det med dobbelt hastighed, hvilket vil give 88200 tal pr. sekund. Så vil det kun tage 1 sekund at afspille samplen. Vi kan også afspille med halv hastighed, hvilket vil svare til 22050 tal pr. sekund. Det vil gøre at samplen tager 4 sekunder om at blive afspillet.

en: The duration of the sample is affected by the playback rate:
da: Varigheden af en sample afhænger af afspilningshastigheden:

en: Doubling the playback rate halves the playback time,
da: Den dobbelte afspilningshastighed halverer afspilningstiden,

en: Halving the playback rate doubles the playback time,
da: Den halve afspilningshastighed fordobler afspilningstiden,

en: Using a playback rate of one fourth quadruples the playback time,
da: En afspilningshastighed på en fjerdedel vil firdoble afspilningstiden,

en: Using a playback rate of 1/10 makes playback last 10 times longer.
da: En afspilningshastighed på en tiendedel vil tidoble afspilningstiden.

en: We can represent this with the formula:
da: Det kan udtrykkes med denne formel hvor rate svarer til hastigheden:

en: new_sample_duration = (1 / rate) * sample_duration
da: ny_samplevarighed = (1 / rate) * oprindelig_samplevarighed

en: Changing the playback rate also affects the pitch of the sample. The frequency or pitch of a waveform is determined by how fast it moves up and down. Our brains somehow turn fast movement of speakers into high notes and slow movement of speakers into low notes. This is why you can sometimes even see a big bass speaker move as it pumps out super low bass - it's actually moving a lot slower in and out than a speaker producing higher notes.
da: Ændring af afspilningshastigheden ændrer også tonen på samplen. Frekvensen, eller tonen, på en bølgeform er bestemt af hvor hurtigt den bevæger sig op og ned. Vores hjerner opfatter på en eller anden måde hurtige bevægelser i højttaleren som høje toner og langsomme bevægelser i højttaleren som lave toner. Det er derfor du nogle gange kan se en stor bashøjttaler bevæge sig når den pumper en superlav bas ud - den bevæger sig meget langsommere ind og ud end en højttaler der spiller højere toner.

en: If you take a waveform and squash it it will move up and down more times per second. This will make it sound higher pitched. It turns out that doubling the amount of up and down movements (oscillations) doubles the frequency. So, *playing your sample at double rate will double the frequency you hear it*. Also, *halving the rate will halve the frequency*. Other rates will affect the frequency accordingly.
da: Hvis du tager en bølgeform og krypmer den, vil den flytte sig op og ned flere gange pr. sekund. Det vil give den en højere tone. Når man fordobler antallet af bevægelser op og ned (oscillationer/svingninger) pr. sekund, fordobler man frekvensen. Så *afspiller du din sample med dobbelt hastighed, fordobler du frekvensen*. På samme måde vil du *halvere frekvensen ved at halvere hastigheden*. Andre ændringer i hastigheden vil på tilsvarende vis ændre frekvensen.

en: 4. Live Code
da: 4. Live-kodning

en: ![Sam Aaron Live Coding](../../../etc/doc/images/tutorial/articles/A.02-live-coding/sam-aaron-live-coding.png)
da: ![Sam Aaron koder live](../../../etc/doc/images/tutorial/articles/A.02-live-coding/sam-aaron-live-coding.png)

en: ![Jylda Live Coding in the Sage Gateshead](../../../etc/doc/images/tutorial/articles/A.20-creative-coding-in-the-classroom/jylda-small.png) Jylda and Sam Aaron perform at the Thinking Digital Conference in the Sage Gateshead. Photo credit: TyneSight Photos.
da: ![Jylda live-koder i Sage Gateshead](../../../etc/doc/images/tutorial/articles/A.20-creative-coding-in-the-classroom/jylda-small.png) Jylda og Sam Aaron optræder ved Thinking Digital-konferencen i Sage Gateshead. Foto: TyneSight Photos.
