Sonic Pi - en to nb translation catalogue (313 entries)

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

en: Welcome friend :-)
nb: Velkommen, min venn :-)

en: Welcome to Sonic Pi. Hopefully you're as excited to get started making crazy sounds as I am to show you. It's going to be a really *fun* ride where you'll learn all about music, synthesis, programming, composition, performance and more.
nb: Velkommen til Sonic Pi! Forhåpentligvis er du like ivrig etter å komme igang med å lage sprø lyder som jeg er etter å lære deg det.  Det kommer til å bli en *morsom* opplevelse hvor du vil lære om musikk, syntese, programmering, komponering, fremføring og mer.

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.
nb: Vent litt, så uhøflig av meg! La meg presentere meg selv - Jeg er [Sam Aaron](http://twitter.com/samaaron) - fyren som laget Sonic Pi. Du finner meg som [@samaaron](http://twitter.com/samaaron) på Twitter og jeg hilser mer enn gjerne på deg. Du vil kanskje også være interessert i mine [direktesendte opptredener](https://youtube.com/samaaron) hvor jeg koder med Sonic Pi på direkten 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!
nb: Hvis du har tanker eller idéer om hvordan Sonic Pi kan bli bedre, vær så snill å bring dem videre - tilbakemeldinger er veldig nyttige. En vet jo aldri, kanskje din ide kan bli neste store nyvinning!

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.
nb: Denne opplæringen er delt opp i seksjoner gruppert etter kategori. Selv om jeg har skrevet dem i den hensikt at du skal følge enkel læringsprogresjon fra start til slutt, kan du ta deg den frihet å ta for deg de delene du syns passer. Hvis du føler at det er noe som mangler, gi meg beskjed, og jeg skal vurdere det for en fremtidig versjon.

en: OK, let's get started...
nb: OK, la oss komme igang...

en: 1.1 Live Coding
nb: 1.1 Koding på direkten

en: Live Coding
nb: Koding på direkten

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.
nb: En av de mest spennende aspektene ved Sonic Pi er at det lar deg skrive og *endre koden i sanntid*. Lag musikk, akkurat som du gjør med gitar. Med litt øvelse kan du faktisk ta med Sonic Pi på scenen og holde konsert med det.

en: Free your mind
nb: Frigjør tankene

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...
nb: Før vi kommer inn på de praktiske detaljene om hvordan Sonic Pi fungerer i fortsettelsen av denne opplæringen, vil jeg deg en erfaring av hva det er å kode i sanntid. Bli ikke bekymret hvis du ikke forstår mye (eller noe) av dette. Bare bli sittende og nyt…

en: A live loop
nb: En levende løkke

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:
nb: Nå, trykk på "Kjør"-knappen og du vil høre en fin, rask basstromme som hamrer løs. Hvis du vil stoppe lyden kan du når som helst trykke på "Stopp"-knappen. Men ikke trykk riktig ennå... Følg disse trinnene videre:

en: Make sure the bass drum sound is still running
nb: Forsikre deg om at basstrommelyden fremdeles går

en: Change the `sleep` value from `0.5` to something higher like `1`.
nb: Endre verdien til `sleep` fra `0.5` til noe høyere, som for eksempel `1`.

en: Press the `Run` button again
nb: Trykk på `Kjør`-knappen igjen

en: Notice how the drum speed has changed.
nb: Legg merke til hvordan trommetakten endret seg.

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...
nb: Til slutt, *husk dette øyeblikket*, dette er første gang du har kodet i sanntid med Sonic Pi og det blir sannsynligvis ikke den siste…

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:
nb: OK, det var enkelt nok. La oss legge inn noe mer. Over `sample: bd_haus` legg til linjen `sample: ambi_choir, rate: 0,3`. Koden skal se slik ut:

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).
nb: Nå kan du leke deg litt. Endre verdiene, hva skjer når du bruker store, små eller negative verdier? Se hva som skjer hvis du endrer litt på `rate:`-verdien for `: ambi_choir`-lydklippet (til `0.29` for eksempel). Hva skjer hvis du velger en svært lav verdi for `sleep`? Se om du kan få det til å gå så hurtig at datamaskinen din stopper med en feilmelding fordi den ikke kan holde følge med tempoet (hvis det skjer, bare velg en større verdi for `sleep` og trykk `Kjør` igjen).

en: Try commenting one of the `sample` lines out by adding a `#` to the beginning:
nb: Prøv å kommentere ut en av `sample`-linjene ved å legge til en `#` på starten av 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.
nb: Legg merke til at den får maskinen til å hoppe over denne linjen, så vi ikke hører den. Dette kalles en kommentar. I Sonic Pi kan vi bruke kommentarer til å ta ut ting fra miksen, og legge dem til igjen.

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:
nb: Til slutt, la meg gi deg noe morsomt å leke med. Ta koden nedenfor, kopier den til et ledig hurtiglager. Du behøver ikke å forstå så mye av den, annet enn å se at det er to sløyfer - så to ting kjører samtidig. Nå, gjør det du gjør best - eksperimentér og lek. Her er noen forslag:

en: Try changing the blue `rate:` values to hear the sample sound change.
nb: Prøv å endre den blå `rate:`-verdien for å høre at lydkarakteren til klippet endres.

en: Try changing the `sleep` times and hear that both loops can spin round at different rates.
nb: Prøv å endre `sleep`-tiden og høre at begge løkkene kan spinne rundt med forskjellige hastigheter.

en: Try uncommenting the sample line (remove the `#`) and enjoy the sound of the guitar played backwards.
nb: Prøv å avkommentere sample-linjen (fjern `#`) og nyt lyden av gitaren spilt baklengs.

en: Try changing any of the blue `mix:` values to numbers between `0` (not in the mix) and `1` (fully in the mix).
nb: Prøv å endre noen av de blå 'mix:'-verdiene til tall mellom '0' (borte fra miksen) og '1' (helt med i miksen).

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...
nb: Husk å trykke `Kjør` og du vil høre endringen neste gang sløyfen går rundt. Ikke bekymre deg for om du gjør feil og det slutter å fungere, bare trykk 'Stopp', slett koden og lim inn en ny kopi - du er klar å jamme igjen. Det er ved å gjøre feil du lærer raskest...

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.
nb: Fortsett gjerne å spille og eksperimentere til nysgjerrigheten på hvordan dette egentlig fungerer tar overhånd. Når du begynne å lure på hva annet du kan gjøre med dette, er du klar til å ta fatt på resten av opplæringen.

en: So what are you waiting for...
nb: Så, venter hva du på…

en: 1.2 Exploring the Interface
nb: 1.2 Utforskning av brukergrensesnittet

en: The Sonic Pi Interface
nb: Sonic Pi-grensesnittet

en: Sonic Pi has a very simple interface for coding music. Let's spend a little time exploring it.
nb: Sonic Pi har et svært enkelt brukergrensesnitt for koding av musikk. La oss bruke litt tid på å utforske det.

en: *A* - Play Controls
nb: *A* - Avspillingskontroller

en: *B* - Editor Controls
nb: *B* - Redigeringskontroller

en: *C* - Info and Help
nb: *C* - Info og hjelp

en: *D* - Code Editor
nb: *D* - Kodebehandler

en: *E* - Prefs Panel
nb: *E* - Innstillingspanelet

en: *F* - Log Viewer
nb: *F* - Loggvisning

en: *G* - Help System
nb: *G* - Hjelpesystem

en: *H* - Scope Viewer
nb: *H* - Skopvisning

en: A. Play Controls
nb: A. Avspillingskontroller

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.
nb: Disse rosa knappene er hovedkontrollene for å starte og stoppe musikken. *Kjør*-knappen kjører koden i kodebehandleren, *Stopp* stopper all kjørende kode, *Lagre* for å lagre koden til en ekstern fil og *Spill inn* for å lage et opptak (en WAV-fil) av musikken som spiller.

en: B. Editor Controls
nb: B. Redigeringskontroller

en: C. Info and Help
nb: C. Info og hjelp

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.
nb: De blå knappene gir tilgang til informasjon, hjelp og innstillinger. *Info*-knappen åpner vinduet med informasjon om Sonic Pi-kjerneteamet, historien, bidragsytere og arbeidsmiljøet/fellesskapet (community). *Help*-knappen veksler i hjelpesystemet (*G*) - og *Prefs*-knappen veksler i innstillingsvinduet som lar deg kontrollere noen grunnleggende systemparametre.

en: D. Code Editor
nb: D. Kodebehandleren

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.
nb: Dette er området hvor du skal skrive koden og komponere/fremføre musikk. Det er en enkel tekstbehandler der du kan skrive kode, slette den, klippe og lime, osv. Tenk på det som en svært grunnleggende versjon av Libreoffice eller nettbasert tekstbehandling. Tekstbehandleren vil automatisk farge opp ord basert på deres betydning i koden. Dette kan virke rart i begynnelsen, men du vil snart finne det svært nyttig. For eksempel vet du at noe er et nummer fordi det er blått.

en: E. Prefs Panel
nb: E. Innstillingspanel

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.
nb: Sonic Pi lar deg endre en rekke innstillinger som blir tilgjengelige ved å klikke på knappen *Innstillingspanel*. Når du klikker på denne knappen kommer panelet med innstillinger til syne. Klikk én gang til for å skjule det igjen.  Noen eksempler på innstillinger du kan gjøre er låsing til mono og invertering av stereo, hvor mye info som skal logges, en lydstyrkekontroll, og kanalvelger på Rasberry Pi-en.

en: F. Log Viewer
nb: F. Loggvisning

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.
nb: Når du kjører koden, vises informasjon om hva programmet gjør i logg-visningen. Som forvalg vil du se én melding for hver lyd du oppretter med nøyaktig tid for når lyden ble utløst. Dette er svært nyttig for feilsøking i koden, og for å forstå hva koden gjør.

en: G. Help System
nb: G. Hjelpesystem

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.
nb: Endelig, en av de viktigste delene av Sonic Pi-grensesnittet er hjelpesystemet som vises nederst i vinduet. Dette kan slås av og på ved å klikke på den blå "Help"-knappen. Hjelpesystemet inneholder hjelp og informasjon om alle aspekter ved Sonic Pi, inkludert denne opplæringen, en liste over tilgjengelige synther, lydklipp, eksempler, FX og en fullstendig liste over alle funksjoner Sonic Pi har for koding av musikk.

en: H. Scope Viewer
nb: H. Oscilloskopvisning

en: 1.3 Learning through Play
nb: 1.3 Læring gjennom lek

en: Learning through Play
nb: Læring gjennom lek

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.
nb: Sonic Pi oppfordrer deg til å lære om både databehandling og musikk gjennom lek og eksperimentering. Viktigst er at du har det gøy, og før du vet det vil du tilfeldigvis ha lært hvordan du koder, komponerer og fremfører.

en: There are no mistakes
nb: Ingenting er feil

en: Start Simple
nb: Start enkelt

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.
nb: Når du lærer, er det fristende å ønske å gjøre utrolige ting *nå*. Hold imidlertid på den tanken og se på det som et fjernt mål som kan nås *senere*. Foreløpig, i stedet for tenke på det *enkleste* du kan skrive, som ville være moro og givende, er det et lite skritt mot den fantastiske tingen du har i hodet. Så snart du har en idé om dette enkle trinnet, prøv å bygge på det, lek med det, og deretter se hva nye idéer gir deg. Det går ikke leng tid før du er travelt opptatt med å ha det gøy og gjøre virkelig fremgang.

en: Just make sure to share your work with others!
nb: Bare sørg for å dele arbeidet ditt med andre!

en: 2 Synths
nb: 2 Synter

en: Synths
nb: Synter

en: OK, enough of the intros - let's get into some sound.
nb: OK, nok introer - la oss lage lyd.

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...
nb: Ikke bli lurt av den umiddelbare enkelheten i grensesnittet til Sonic Pi.  Du kan dykke veldig dypt inn i sofistikert lydmanipulering, hvis det er noe for deg.  Hold på hatten...

en: 2.1 Your First Beeps
nb: 2.1 Dine første pipelyder

en: Your First Beeps
nb: Dine første pipelyder

en: Take a look at the following code:
nb: Ta en titt på denne koden:

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...
nb: Det er her alt starter.  Sett igang, klipp og lim det inn i kodevinduet på toppen av programmet (det store hvite feltet under Run-knappen).  Deretter, trykk Run...

en: Beep!
nb: Pip!

en: Intense. Press it again. And again. *And again...*
nb: Intenst.  Trykk den på nytt.  Og på nytt.  *Og på nytt...*

en: Woah, crazy, I'm sure you could keep doing that all day. But wait, before you lose yourself in an infinite stream of beeps, try changing the number:
nb: Oi, snålt. Jeg er sikker på at du kan holde på å gjøre dette hele dagen. Men vent, før du går vill i en uendelig strøm av piping, prøv å endre nummeret:

en: Can you hear the difference? Try a lower number:
nb: Kan du høre forskjellen? Prøv et lavere nummer:

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*.
nb: Ingen grunn til bekymring om dette ikke betyr noe for deg - det gjorde ikke det for meg da jeg startet. Alt som teller nå, er at du vet at "lave tall lager lavere lyder" og "høyere tall lager høyere lyder".

en: Chords
nb: Akkorder

en: Playing a note is quite fun, but playing many at the same time can be even better. Try it:
nb: Å spille e n note er ganske morsomt, men å spille flere samtidig kan være bedre. Prøv:

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.
nb: Jazzy! Så, når du skriver flere 'strofer', spilles alle på samme tid. Prøve det selv - hvilke tall høres bra sammen? Som høres forferdelig ut? Eksperimenter, utforsk og finn ut selv.

en: Melody
nb: 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:
nb: Så, noter og akkorder er gøy - men hva med en melodi? Hva om du ønsket å spille en note etter den andre og ikke samtidig? Vel, det er enkelt, du trenger bare å 'sove' mellom tonene:

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`:
nb: Hvor deilig, en liten arpeggio. Så hva betyr '1' i 'sleep 1'? Vel det betyr *varigheten av søvnen*. Det betyr faktisk å sove i et slag, men akkurat nå kan vi tenke på det som å sove i 1 sekund. Så, hva om vi ønsket å gjøre vår arpeggio litt raskere? Vel, vi må bruke kortere søvnverdier. Hva med en halv dvs. '0,5':

en: Notice how it plays faster. Now, try for yourself, change the times - use different times and notes.
nb: Legg merke til hvordan det spilles raskere. Prøv selv, endre antall ganger - bruk forskjellige tider og noter.

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.
nb: En ting å prøve er mellomnoter slike som 'play 52,3' og 'play 52.63'. Det er slett ikke nødvendig å holde seg til hele standardnoter. Lek og ha det gøy.

en: Traditional Note Names
nb: Tradisjonelle notenavn

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:
nb: For de av dere som allerede vet noe om tonesetting (ikke bekymre deg hvis du ikke gjør det - du trenger ikke det å ha det gøy) kan du skrive en melodi ved hjelp av notenavn som C og F# heller enn tall. Med Sonic Pi er du dekket. Du kan gjø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:
nb: Husk å sette kolon ':' foran notenavnet ditt slik at det blir rosa. Du kan også angi oktaven ved å legge til et tall etter notenavnet:

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`.
nb: Hvis du vil lage en note skarp, legge til en 's' notenavnet som 'play :Fs3' og hvis du vil lage et notat flat, legge til en 'b' som 'play :Eb3'.

en: Now go *crazy* and have fun making your own tunes.
nb: Nå *slipp deg løs* og ha det gøy med å lage dine egne låter.

en: 2.2 Synth Options
nb: 2.2 Synth-valg

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.
nb: Så vell som å styre hvilken note som skal spilles eller hvilket utvalg som skal startes, tilbyr Sonic Pi en rekke alternativer for å lage og kontrollere lydene. Vi vil dekke mange av disse mulighetene i denne opplæringen, og det er omfattende dokumentasjon for hver av dem i hjelpesystemet. Men nå vil vi introdusere to av de nyttigste: *amplitude* og *pan*. Først, la oss se på hva disse mulighetene egentlig er.

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).
nb: Sonic Pi støtter begrepet Options (eller opts for kort) for sine synter. Opts er kontroller du legger til "play" som endre og styrer egenskapene til lyden du hører. Hver synt har sitt eget sett av opts til å finstemme lyden. Men det er felles sett med opts som deles av mange lyder, som 'amp:' og omslagsopts (dekket i en annen seksjon).

en: Opts have two major parts, their name (the name of the control) and their value (the value you want to set the control at). For example, you might have a opt called `cheese:` and want to set it with a value of `1`.
nb: Opts har to store deler, navnet deres (navnet på kontrollen) og verdien (verdien du vil angi kontrollen under). Du kan for eksempel ha en opt kalt 'ost:' og vil sette den med en verdi på '1'.

en: Opts are passed to calls to `play` by using a comma `,` and then the name of the opt such as `amp:` (don't forget the colon `:`) and then a space and the value of the opt. For example:
nb: Opts sendes for å starte 'play' ved å bruke komma ',' og deretter navnet på opt-et slik som 'amp:' (ikke glem kolon ':') og deretter et mellomrom og verdien på opt. For eksempel:

en: play 50, cheese: 1
nb: play 50, ost: 1

en: (Note that `cheese:` isn't a valid opt, we're just using it as an example).
nb: (Merk at "ost:' er ikke en gyldig opt, vi bruker det bare som et eksempel).

en: You can pass multiple opts by separating them with a comma:
nb: Du kan sende flere opt ved å skille dem med komma:

en: play 50, cheese: 1, beans: 0.5
nb: play 50, ost: 1, bønner: 0.5

en: The order of the opts doesn't matter, so the following is identical:
nb: Rekkefølgen på opt-ene spiller ingen rolle, så de følgende er identiske:

en: play 50, beans: 0.5, cheese: 1
nb: play 50, bønner: 0.5, ost: 1

en: Opts that aren't recognised by the synth are just ignored (like `cheese` and `beans` which are clearly ridiculous opt names!)
nb: Opts som ikke gjenkjennes av synth ignoreres bare (som 'ost' og 'bønner' som tydelig er latterlige som opt-navn!)

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:
nb: Hvis du tilfeldigvis bruker samme opt to ganger med ulike verdier, vinner den siste. For eksempel at 'bønner:' her vil ha verdien 2 i stedet for 0.5:

en: play 50, beans: 0.5, cheese: 3, eggs: 0.1, beans: 2
nb: play 50, bønner: 0.5, ost: 3, egg: 0.1, bønner: 2

en: Many things in Sonic Pi accept opts, so just spend a little time learning how to use them and you'll be set! Let's play with our first opt: `amp:`.
nb: Mange ting i Sonic Pi godtar opts, så bare bruke litt tid på å lære hvordan du bruker dem, så har du konfigurert! La oss leke med vår første opt: 'amp:'.

en: Amplitude
nb: Utslag

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.
nb: Amplituden er en datagjengivelse lydstyrken i en lyd. A *høy amplitude produserer en høy lyd* og *lav amplituden produserer en lav lyd*. I Sonic Pi symboliserer tall tid og noter, og tall symboliserer amplituden. Amplituden 0 betyr stille (du hører ingenting) mens amplituden 1 er normalt volum. Du kan selv skru opp amplituden høyere 2, 10, 100. Du bør imidlertid notere at når samlede amplituden til alle lydene blir for høy, bruker Sonic Pi det som kalles en kompressor for å klemme sammen alle, slik at det ikke blir for høyt for ørene. Dette kan ofte gjøre lyden uklar og rar. Så prøv å bruke lave amplituder, dvs i området 0 til 0,5 å unngå komprimering.

en: Amp it up
nb: Forsterk den opp

en: To change the amplitude of a sound, you can use the `amp:` opt. For example, to play at half amplitude pass 0.5:
nb: Hvis du vil endre amplituden til en lyd, kan du bruke "amp:" opten. For eksempel for å spille med halv amplitude sett inn 0.5:

en: To play at double amplitude pass 2:
nb: For å spille på dobbel amplitude sett inn 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):
nb: "amp:"-opt-en endrer bare valget for det "play" det er tilknyttet. Så i dette første eksemplet, er det første "play"-valget halvt volum og det andre er tilbake til standard (1):

en: Of course, you can use different `amp:` values for each call to play:
nb: Selvfølgelig, du kan bruke forskjellige "amp:"-verdier for hver play-valg:

en: Panning
nb: Stereo

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.
nb: En annen morsom opt er ' pan:' som legger ut, panorere, en lyd i stereo. Å panorere en lyd til venstre betyr at du hører denv fra venstre høyttaler, og panorere til høyre betyr at du hører dem fra din høyre høyttaler. Våre verdier, bruker vi -1 for fullt til venste, 0 representerer sentrum, og 1 er fullt til høyre i stereofeltet. Selvfølgelig, står vi fritt til å bruke alle verdier mellom -1 og 1 for å kontrollere den nøyaktige posisjonen av lyden vår.

en: Let's play a beep out of the left speaker:
nb: La oss spille et lydsignal fra venstre høyttaler:

en: Now, let's play it out of the right speaker:
nb: Nå, la oss spille det av den høyre høyttaleren:

en: Finally let's play it back out of the center of both (the default position):
nb: Til slutt, la oss spille den tilbake fra sentrum av begge (standardoppsettet):

en: Now, go and have fun changing the amplitude and panning of your sounds!
nb: Nå, sett i gang med å ha det gøy med å endre amplituden og panoreringen av lydene dine!

en: 2.3 Switching Synths
nb: 2.3 Bytte synter

en: Switching Synths
nb: Bytte synter

en: Buzzy saws and prophets
nb: Travle sager og profeter

en: A fun sound is the *saw wave* - let's give it a try:
nb: En morsom lyd er *sagbølgen* - la oss gi den et forsøk:

en: Let's try another sound - the *prophet*:
nb: La oss prøve en annen lyd, *prophet*-en:

en: How about combining two sounds. First one after another:
nb: Hvordan kombinere to lyder. Første en etter en:

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`.
nb: Legg merke til at kommandoen 'use synth' bare påvirker den følgende bruken av 'play'. Tenk på det som en 'stor bryter' - ny bruk av -'play" vil spille hvilken som helst synt det pekes til. Med bryteren kan du skifte til en ny synt med 'use_synth'.

en: Discovering Synths
nb: Å oppdage synter

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.
nb: Nå, kos deg med *å bytte synter for din musikk*. Ha det gøy med å kombinere synter for å lage nye lyder som vel som å bruke ulike synter for forskjellige deler av musikken.

en: 2.4 Duration with Envelopes
nb: 2.4 Varighet med Envelopes

en: Duration with Envelopes
nb: Varighet med omslag

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.
nb: I et tidligere avsnitt så vi hvordan vi bruker kommandoen 'sleep' for å utløse lydene våre. Men har vi ennå ikke klart å styre varigheten av lydene våre.

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:
nb: For å gi oss et enkelt, men kraftig grep til å 'kontrollere varigheten' til lydene våre, har Sonic Pi innebygd *ADSR amplitude omslag* (vil dekker hva ADSR betyr senere i denne delen). En amplitude-omslag tilbyr to nyttige kontrollmuligheter:

en: control over the duration of a sound
nb: kontrollere varigheten av en lyd

en: control over the amplitude of a sound
nb: kontroll over en lyds amplitude

en: Duration
nb: Varighet

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.
nb: Varigheten er hvor lenge lyden varer. En lengre varighet betyr at du hører lyden lenger. Sonic Pis lyder har alle en kontrollerbar amplitude-omslag, og den totale varigheten av dette omslaget er varigheten av lyden. Derfor, ved å kontrollere omslaget styrer du varigheten.

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.
nb: ADSR-omslaget kontrollerer ikke bare varighet, det gir deg også *god kontroll over lydens amplitude*. Alle hørbare lyder starter og avslutter stille og inneholder noen ikke-stille deler i mellom. Med omslag kan du skyve og holde amplituden til lydens ikke-stille deler imellom. Det er som å gi noen instruksjoner om hvordan å skru opp og ned volumet på en gitarforsterker. For eksempel kan du be noen "å starte i stillhet, sakte flytte opp til full volum, holder den litt, så raskt gå tilbake til stillhet." Med Sonic Pi kan du programmere akkurat dette med omslag.

en: Just to recap, as we have seen before, an amplitude of 0 is silence and an amplitude of 1 is normal volume.
nb: Bare for å oppsummere, som vi har sett før, amplituden 0 er stillhet og  amplituden 1 er normalt volum.

en: Now, let us look at each of the parts of the envelopes in turn.
nb: Nå, la oss se på hver av delene av omslagene igjen.

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):
nb: Den eneste delen av envelope som brukes som standard, er utfasingstidspunktet. Det er tiden det tar for syntens lyd til å dø ut. Alle synter som har utfasingstid 1 som betyr at de har en standard varighet på 1 slag (som standard er en BPM på 60 1 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:
nb: Noten vil være hørbar i 1 sekund. Gå i gang med å sette tiden :-) Dette er kortversjonen av en lengre og mer eksplisitt versjon:

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:
nb: Legg merke til hvordan dette høres akkurat som det samme (lyden varer ett sekund). Men det er nå svært enkelt å endre varigheten ved å endre verdien av 'release:' opt:

en: We can make the synth sound for a very short amount of time by using a very small release time:
nb: Vi kan lage en svært kort syntlyd ved hjelp av en liten løslate tid:

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:
nb: Varigheten av tiden lyden sendes kalles *release phase*-en og som standard er den lineær dvs. en rett linje. Diagrammet nedenfor illustrerer denne overgangen:

en: You can therefore change the duration of your sound by changing the release time. Have a play adding release times to your music.
nb: Du kan derfor endre varigheten til lyden ved å endre innkoblingstiden. Ha en tillagt spillevarighet til din musikk.

en: Attack Phase
nb: Angrepsfasen

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:
nb: Standard er *attack phase* er 0 for alle synter som betyr de flytter fra  amplitude 0 til 1 umiddelbart. Dette gir synt en første perkusjonslyd. Men kanskje du ønsker å fade ut lyden. Dette kan oppnås med 'attack:' opt-et. Prøv utfading med noen lyder:

en: You may use multiple opts at the same time. For example for a short attack and a long release try:
nb: Du kan bruke flere opt-er samtidig. For eksempel i et kort angrep og med lang versjon:

en: This short attack and long release envelope is illustrated in the following diagram:
nb: Dette korte angrep og lange versjonsomslaget er illustrert i følgende diagram:

en: Of course, you may switch things around. Try a long attack and a short release:
nb: Selvfølgelig kan du flytte ting rundt. Prøv et lengre angrep og en kort versjon:

en: Finally, you can also have both short attack and release times for shorter sounds.
nb: Til slutt, du kan også ha både korte angrep og versjontider for kortere lyder.

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.
nb: I tillegg til å angi angrep og versjonstid, kan du også angi en beholdefase for  kontroll av *sustain phase*-en. Dette er tiden når lyden opprettholdes med full amplitude mellom angrep og versjonsfasene.

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.
nb: "Sustain time" er nyttig for viktige lyder du ønsker å gi fullt nærvær i miksen før du skriver inn en valgfri versjon av fasen. Selvfølgelig, det er helt lovlig å angi både 'attack:'  og 'release:' opts  til 0 og bare bruke sustain for å ha absolutt ingen inn- eller utfasing for lyden. Men vær advart, en release på 0 kan produsere klikk i lyden og det er ofte bedre å bruke en veldig liten verdi som 0,2.

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:
nb: For et ekstra kontrollnivå, kan du også angi sluttid (decay). Dette er en fase i omslaget som passer mellom angrepet og opprettholdesesfasen og angir et tidspunkt der amplituden vil synke fra 'attack_level:' til 'decay_level:' (som, med mindre du eksplisitt har satt den, blir satt til 'sustain_level:'). Som standard 'decay:' opt er 0 og både angrepet og sluttiden er 1 så de må spesifiseres for at sluttiden skal ha noen effekt:

en: Decay Level
nb: Decay nivå

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:
nb: Ett siste triks er at selv om opsjonen 'decay_level:' i utgangspunktet har den samme verdien som 'sustain_level:' kan du angi dem med ulike verdier for å ha full kontroll over omslaget. Dette lar deg lage omslag slik som dette:

en: It's also possible to set the `decay_level:` to be higher than `sustain_level:`:
nb: Det er også mulig å sette 'decay_level:' høyere enn 'sustain_level:':

en: ADSR Envelopes
nb: ADSR omslag

en: So to summarise, Sonic Pi's ADSR envelopes have the following phases:
nb: For å oppsummere, har Sonic Pi ADSR-omslagene følgende følgende faser:

en: *attack* - time from 0 amplitude to the `attack_level`,
nb: *attack*-tid fra 0-amplitude til `attack_level`,

en: *decay* - time to move amplitude from `attack_level` to `decay_level`,
nb: *decay*-tid for å flytte amplituden fra `attack_level` til `decay_level`,

en: *sustain* - time to move the amplitude from `decay_level` to `sustain_level`,
nb: *sustain*-tid for å flytte amplitude-nivået fra 'decay_level' til 'sustain_level',

en: *release* - time to move amplitude from `sustain_level` to 0
nb: *Release*-tid for å 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:
nb: -Det er viktig å merke seg at varigheten av en lyd er summen for hver av disse fasene. Derfor har følgende lyd har en varighet på 0,5 + 1 + 2 + 0,5 = 4 rytmer:

en: Now go and have a play adding envelopes to your sounds...
nb: Nå sett i gang å leke med å legge omslag på dine lyder...

en: 3 Samples
nb: 3 Sampler

en: Samples
nb: Sampler

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.
nb: En flott måte å utvikle musikken den på er å bruke forhåndsinnspilte lyder. I den store hip-hop tradisjonen, kaller vi disse pre-innspilte lydene *samples*. Så, hvis du tar med en mikrofon utenfor, ta opp milde lyden av regn som treffer et lerret, du har nettopp opprettet et sampel.

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...
nb: Sonic Pi lar deg gjøre masse morsomme ting med sampler. Ikke bare kommer den med over 130 offentlige sampler klar for deg til å jamme med, de lar deg spille og kontrollere dine egne. La oss komme i gang...

en: 3.1 Triggering Samples
nb: 3.1 Trigge sampler

en: Triggering Samples
nb: Trigge sampler

en: Playing beeps is only the beginning. Something that's a lot of fun is triggering pre-recorded samples. Try it:
nb: Spille pipelyder er bare begynnelsen. Noe som er moro er å trigge forhåndsinnspilte sampler. Prøv:

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:
nb: Sonic Pi inneholder mange eksempler til å spille med. Du kan bruke dem akkurat som du bruker kommandoen "play". For å spille flere prøver og noter er det bare å skrive dem inn, den ene etter hverandre:

en: If you want to space them out in time, use the `sleep` command:
nb: Hvis du vil fordele dem ut over tid, bruk kommandoen "sleep":

en: Discovering Samples
nb: Å oppdage sampler

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:
nb: Alternativt kan du bruke den "autofullføring-systemet". Skriv starten av en sampelgruppe som: "sampel: ambi_" og du vil se en nedtrekksliste du kan velge fra. Prøv følgende kategori-forstavelser:

en: Now start mixing samples into your compositions!
nb: Nå start med å bruke miksing av sampler i dine komposisjoner!

en: 3.2 Sample Parameters
nb: 3.2 Sampel-parametre

en: Sample Parameters: Amp and Pan
nb: Sampel-parametre: Apm og Pan

en: As we saw with synths, we can easily control our sounds with parameters. Samples support exactly the same parameterisation mechanism. Let's revisit our friends `amp:` and `pan:`.
nb: Som vi så med synter, kan vi enkelt styre vår lyder med parametere. Sampler støtter nøyaktig samme parameter-mekanisme. La oss gå tilbake til våre venner `amp:` og `pan:`.

en: Amping samples
nb: Ampe samples

en: You can change the amplitude of samples with exactly the same approach you used for synths:
nb: Du kan endre amplituden i sampler med nøyaktig samme tilnærming du brukte for synter:

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:
nb: Vi kan også bruke `pan:`-parametre på sampler. For eksempel, her er hvordan vi ville spille Amen Break i det venstre øret og deretter halvveis igjennom spille det igjen gjennom høyre øre:

en: Note that 0.877 is half the duration of the `:loop_amen` sample in seconds.
nb: Merk at 0.877 i sekunder er halvparten så lenge som ":loop_amen" samplet.

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`.
nb: Til slutt, vær oppmerksom på at hvis du setter en synt standard med 'use_synth_defaults' (som vi vil diskutere senere), vil dette bli ignorert av `sample`.

en: 3.3 Stretching Samples
nb: 3.3 Strekke Sampler

en: Stretching Samples
nb: Strekke sampler

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.
nb: Nå som vi kan spille en rekke synter og samler til å lage litt musikk, er det tiden for å lære å endre både synter og sampler for å gjøre musikken enda mer unik og interessant. Først, la oss utforske bruken av *stretch* og *squash* på sampler.

en: Sample Representation
nb: Sampel Representation

en: Samples are pre-recorded sounds stored as numbers which represent how to move the speaker cone to reproduce the sound. The speaker cone can move in and out, and so the numbers just need to represent how far in and out the cone needs to be for each moment in time. To be able to faithfully reproduce a recorded sound the sample typically needs to store many thousands of numbers per second! Sonic Pi takes this list of numbers and feeds them at the right speed to move your computer's speaker in and out in just the right way to reproduce the sound. However, it's also fun to change the speed with which the numbers are fed to the speaker to change the sound.
nb: Samples er pre-innspilte lyder som lagres som tall som representerer hvordan du beveger høyttalermembranen til å gjenskape lyden. Høyttalermembranen kan bevege seg inn og ut, så tallene bare trenger å representere hvor langt inn og ut membran hvert øyeblikk må være. For å kunne gjengi en innspilt lyd må samplet vanligvis lagre tusenvis av tall per sekund! Sonic Pi tar denne listen med tall og gir dem på rett hastighet for å bevege datamaskinens høyttaler inn og ut akkurat den rette måten for å gjenskape lyden. Men det også morsomt å endre hastigheten som tallene sendes til høyttaleren med for å endre lyden.

en: Changing Rate
nb: Endre raten

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`:
nb: La oss spille med en de omkringliggende lydene: ': ambi_choir'. For å spille det med standard hastighet, kan du sende en `rate:` opt 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`:
nb: Dette spiller den med normal hastighet (1), så ikke noe er spesielt ennå. Men vi kan fritt endre det nummeret til noe annet. Hva 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.
nb: Oj! Hva skjer her? Vel, to ting. For det første tar samplet dobbelt så lang tid å spille, dernest er lyden en oktav lavere. La oss utforske disse tingene litt nærmere.

en: Let's stretch
nb: La oss strekke ut

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:
nb: Et eksempel som er morsomt er å strekke og komprimere Amen Break. Med normal hastighet, kan vi tenke oss å legge det i et *tromme og bass*-spor:

en: However by changing the rate we can switch up genres. Try half speed for *old school hip-hop*:
nb: Ved å endre hastigheten kan vi imidlertid bytte sjangere. Prøv halv fart for *old school hip-hop*:

en: If we speed it up, we enter *jungle* territory:
nb: Hvis vi øker farten går vi inn i *jungel*-territoriet:

en: Now for our final party trick - let's see what happens if we use a negative rate:
nb: Nå vårt siste festknep - la oss se hva som skjer hvis vi bruker en negativ rate:

en: Woah! It plays it *backwards*! Now try playing with lots of different samples at different rates. Try very fast rates. Try crazy slow rates. See what interesting sounds you can produce.
nb: Oj! Det spiller det *baklengs*! Nå prøv å spille med mange forskjellige sampler med forskjellige hastigheter. Prøv snålt sakte rater. Se hvilke interessante lyder du kan lage.

en: A Simple Explanation of Sample Rate
nb: En enkel forklaring på sampleraten

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.
nb: En nyttig måte å tenke på prøvene er som fjærer. Avspillingshastighet er som å klemme sammen å trekke ut fjæren. Hvis du spiller samplet på rate 2, *klemmes fjæren sammen* til det halve av sin vanlige lengde. Samplet tar derfor halvparten av tiden til avspillingen fordi de det er kortere. Når du spiller samplet i halv fart *strekker du fjæren* til dobbelt lengde. Samplet tar da  dobbelt så lang tid å spille fordi det lengre. Jo mer du klemmer (høyere hastighet), jo kortere blir den, jo mer du strekke (lavere rate), jo lengre det blir det.

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*.
nb: Å presse sammen en fjær øker tettheten (antall viklinger per cm). Dette tilsvarer at samlet lyder med *en høyere tone*. Strekkes fjæren ut reduseres tettheten og tilsvarer en lyd som har en *lavere tone*.

en: The Maths Behind Sample Rate
nb: Matematikken bak sampelraten

en: (This section is provided for those that are interested in the details. Please feel free to skip it...)
nb: (Denne delen gis for de som er interessert i detaljene. Du må gjerne hoppe over den...)

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:
nb: Som vi så ovenfor, er et sampel representert av en stor, lang liste med tall som sier hva høyttaleren skal gjøre over tid. Vi kan ta denne listen med tall og bruke den til å tegne et diagram som vil se slik ut:

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.
nb: Du kanskje har sett bilder som dette før. Det kalles  samplets *bølgeform*. Det er bare en graf med tall. En bølgeform som dette har vanligvis 44100 datapunkter per sekund (dette ut fra Nyquist-Shannons samplingsteorem). Så, hvis samlet varer i 2 sekunder, vil bølgeformen være representert ved 88200 punkter som vi ville mate høyttaleren med en hastighet på 44100 punkter per sekund. Selvfølgelig vi kan mate den med dobbel hastighet, som ville være 88200 punkter per sekund. Dette ville det derfor bare ta et sekund å spille. Vi kan også spille det med halv fart, som ville være 22050 punkter per sekund, som tar 4 sekunder å spille.

en: The duration of the sample is affected by the playback rate:
nb: Samlets varigheten påvirkes av avspillingshastigheten:

en: Doubling the playback rate halves the playback time,
nb: Doblet avspillingshastighet halverer spilletiden,

en: Halving the playback rate doubles the playback time,
nb: Halvering av avspillingshastigheten dobler spilletiden,

en: Using a playback rate of one fourth quadruples the playback time,
nb: Settes avspillingshastigheten til en fjerdedel, firedoble avspillingstiden,

en: Using a playback rate of 1/10 makes playback last 10 times longer.
nb: Å bruke en avspillingshastighet på 1/10 gjør avspillingen 10 ganger lengre.

en: We can represent this with the formula:
nb: Vi kan representere dette med formelen:

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.
nb: Endret avspillingshastighet påvirker også samplets tonehøyde. Frekvensen eller tonen til en bølgeform avgjøres av hvor raskt den beveger seg opp og ned. Hjernen vår oppfatter raske bevegelser i høyttalerne som høye toner og langsomme bevegelser i høyttalere som lave toner. Det er derfor du noen ganger du til og med kan se en stor basshøyttaler flytter seg når den pumper ut superlav bass - den flytter seg faktisk mye langsommere inn og ut enn en høyttaler som lager høyere notater.

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.
nb: Hvis du tar en bølge og klemmer den sammen vil den flytte opp og ned flere ganger per sekund. Dette vil gjøre at den høres høyere ut. Det viser seg at dobbel mengde opp og ned bevegelser (svingninger) dobler frekvensen. Så *å spille ditt sampel med dobbel hastighet vil doble frekvensen du høre det på*. Altså vil *halv hastighet halvere frekvensen*. Andre hastigheter påvirker frekvensen tilsvarende.

en: 3.4 Enveloped Samples
nb: 3.4 Omslag for sampler

en: Enveloped Samples
nb: Sampler med omslag

en: It is also possible to modify the *duration* and *amplitude* of a sample using an ADSR envelope. However, this works slightly differently to the ADSR envelope available on synths. Sample envelopes only allow you to reduce the amplitude and duration of a sample - and never to increase it. The sample will stop when either the sample has finished playing or the envelope has completed - whichever is first. So, if you use a very long `release:`, it won't extend the duration of the sample.
nb: Det er også mulig å endre samplets *varighet* og *amplitude* ved å bruke et ADSR-omslag. Men dette virker litt annerledes for ADSR-omslaget som er tilgjengelig for synter. Sampelomsalgene tillater deg bare å redusere amplituden og varigheten for et sampel - men aldri å øke dem. Samplet vil stoppe når sampler er ferdig med å spille eller omslaget er fullført - uavhengig av hvilket som kommer først. Så hvis du bruker en svært lang `versjon`, vil det ikke forlenge samplets varighet.

en: Amen Envelopes
nb: Amen omslag

en: Let's return to our trusty friend the Amen Break:
nb: La oss gå tilbake til vår gode venn Amen Break:

en: With no opts, we hear the full sample at full amplitude. If we want to fade this in over 1 second we can use the `attack:` param:
nb: Uten ops, hører vi hele samlet med full amplitude. Hvis vi vil fade dette ut i mer enn ett sekund, kan vi  bruke  'attack:' param:

en: For a shorter fade in, choose a shorter attack value:
nb: For en kortere utfasing velger du en kortere angrepsverdi:

en: Where the ADSR envelope's behaviour differs from the standard synth envelope is in the *sustain* value. In the standard synth envelope, the sustain defaulted to 0 unless you set it manually. With samples, the sustain value defaults to an *automagical* value - the time left to play the rest of the sample. This is why we hear the full sample when we pass no defaults. If the attack, decay, sustain and release values were all 0 we'd never hear a peep. Sonic Pi therefore calculates how long the sample is, deducts any attack, decay and release times and uses the result as your sustain time. If the attack, decay and release values add up to more than the duration of the sample, the sustain is simply set to 0.
nb: ADSR-omslag avviker fra standard synt-omslag i *sustain*-verdien. I synth-omslaget, er varigheten (sustain) som standard satt til 0, om du ikke angir verdien manuelt. I sampler, er sustain-verdien som standard en *automagisk* verdi - tiden som er igjen for å spille resten av samplet. Det er derfor vi hører det hele samplet når vi ikke gir noen forhåndsinnstillinger. Hvis attac, decay-, sustain- og release-verdiene alle er 0 vil vil aldri høre et pip. Sonic Pi beregner derfor hvor langt samplet er, trekker fra eventuelle attack-, decay- and release-tider og bruker resultatet som varigheten. Hvis attac-, decay- og release verdiene tilsammen blir mer enn varigheten av samplet, blir varigheten helt enkelt satt til 0.

en: Fade Outs
nb: Utfasing

en: To explore this, let's consider our Amen break in more detail. If we ask Sonic Pi how long the sample is:
nb: For å utforske dette, la oss se på vår Amen Break mer i detalj. Hvis vi spør Sonic Pi hvor langt samplet er:

en: It will print out `1.753310657596372` which is the length of the sample in seconds. Let's just round that to `1.75` for convenience here. Now, if we set the release to `0.75`, something surprising will happen:
nb: Det vil skrive ut "1.753310657596372" som er lengden på samplet i sekunder. La oss her bare avrunde det til '1.75' for enkelhets skyld. Nå, hvis vi setter versjonen til '0,75', vil det skje noe overraskende:

en: Fade In and Out
nb: Ton inn og ut

en: Percussive cymbals
nb: Trommesettsymbaler

en: 3.5 Partial Samples
nb: 3.5 Delvise Prøver

en: Choosing a starting point
nb: Valg av startpunkt

en: Choosing a finish point
nb: Valg av sluttpunkt

en: Specifying start and finish
nb: Bestemmelse av start of slutt

en: Cool! It plays it backwards!
nb: Kult! Den spiller det baklengs!

en: Conclusions
nb: Konklusjoner

en: This concludes the Sonic Pi introductory tutorial. Hopefully you've learned something along the way. Don't worry if you feel you didn't understand everything - just play and have fun and you'll pick things up in your own time. Feel free to dive back in when you have a question that might be covered in one of the sections.
nb: Med dette er innføringen i Sonic Pi ferdig.  Forhåpentligvis har du lært noe på veien. Ikke bekymre deg hvis du opplever at du ikke forstår alt - bare lek og ha det morro, så får du tak i ting når du er klar for det.  Kom gjerne tilbake hit når du har spørsmål som kanskje er dekket i en av delene.

en: Finally, I also invite you to take a deeper look at the rest of the documentation in this help system. There are a number of features that haven't been covered in this tutorial that are waiting for your discovery.
nb: Til slutt vil jeg invitere deg til å ta en nøyere titt på resten av dokumentasjonen i dette hjelpesystemet.  Det er en rekke egenskaper som ikke er dekket av denne innføringen, og som venter på at du skal oppdage dem.

en: So play, have fun, share your code, perform for your friends, show your screens and remember:
nb: Lek deg, ha det moro, del på koden din, spill for dine venner, vis frem skjermbildene dine og husk:

en: *There are no mistakes, only opportunities.*
nb: *Det finnes ingen feil, kun muligheter.*

en: A.1 Tips for Sonic Pi
nb: A.1 Tips om Sonic Pi

en: 1. There are no mistakes
nb: 1. Det finnes ingen feil

en: 3. Parameterise your synths
nb: 3. Parameteriser dine synther

en: Now, try increasing that feedback to 1 to hear some crazy sounds! Read the docs for full details on all the many opts available to you.
nb: Forsøk nå å øk feedback-en til 1 for å høre noe ville lyder!  Les dokumentasjonen for alle detaljene om de mange tilvalgene som er tilgjengelig.

en: 5. Surf the random streams
nb: 5. Surf på de tilfeldige strømmene

en: Finally, one thing I love doing is cheating by getting Sonic Pi to compose things for me. A really great way to do this is using randomisation. It might sound complicated but it really isn't. Let's take a look. Copy this into a spare workspace:
nb: Til slutt, en ting jeg virkelig elsker å gjøre er å jukse ved å la Sonic Pi komponere ting for meg.  En virkelig flott måte å gjøre dette er ved å bruke tilfeldighet.  Det høres kanskje kompliset ut, men det er virkelig enkelt.  La oss ta en titt.  Kopier dette inn i et ledig arbeidsområde:

en: Everyone has played Minecraft. You will all have built amazing structures, designed cunning traps and even created elaborate cart lines controlled by redstone switches. How many of you have performed with Minecraft? We bet you didn't know that you could use Minecraft to create amazing visuals just like a professional VJ.
nb: Alle har spilt Minecraft.  Dere har nok laget utrolige strukturer, utformet snedige feller og til og med laget kompliserte trallespor kontrollert av rødsteinsbrytere.  Hvor mange av dere har gjennomført fremvisninger med Minecraft?  Vi vedder på at du ikke viste at du kan bruke Minecraft til å skape utrolige visuelle effekter akkurat som en profesjonell VJ.

en: Let's get started...
nb: La oss komme igang...

en: mc_message "Let's get started..."
nb: mc_message *La oss komme igang...*

en: A.14 Amplitude Modulation
nb: A.14 Utslagsmodulering

en: Amplitude Modulation
nb: Utslagsmodulering

en: Changing tempo
nb: Endrer tempo

en: A.15 Five Live Coding Techniques
nb: A.15 Fem teknikker for direkteoverført koding

en: Five Live Coding Techniques
nb: Fem teknikker for direkteoverført koding

en: A.16 How to Practice Live Coding
nb: A.16 Hvordan øve på direkteoverført koding

en: 8 Tips for Live Coding Practice
nb: 8 øvetips for direkteoverført koding

en: Filter Modulation
nb: Filtermodulasjon

en: Selection/Copy/Paste
nb: Merket område/Kopier/Lim inn

en: `M-a` - Select all
nb: `M-a` - Merk alt

en: `M-c` - Copy selection to paste buffer
nb: `M-c` - Kopier merket omrade til innlimingsmellomlager

en: `M-]` - Copy selection to paste buffer
nb: `M-]` - Kopier merket omrade til innlimingsmellomlager

en: `M-x` - Cut selection to paste buffer
nb: `M-x` - Klipp ut merket område til innlimingsmellomlager

en: `C-]` - Cut selection to paste buffer
nb: `C-]` - Klipp ut merket område til innlimingsmellomlager

en: `C-k` - Cut to the end of the line
nb: `C-k` - Klipp ut til slutten av linjen

en: `M-v` - Paste from paste buffer to editor
nb: `M-v` - Lim in fra innlimingsmellomlageret til tekstredigeringsfeltet

en: `C-y` - Paste from paste buffer to editor
nb: `C-y` - Lim in fra innlimingsmellomlageret til tekstredigeringsfeltet

en: `C-SPACE` - Set mark. Navigation will now manipulate highlighted region. Use `C-g` to escape.
nb: `C-SPACE` - Sett merke.  Navigering vil nå manipulere uthevet område.  Bruk `C-g` for å komme ut.

en: Text Manipulation
nb: Tekstmanipulering

en: `M-/` - Comment/Uncomment current line or selection
nb: `M-/` - Kommenter/avkommenter gjeldende linje eller merket område

en: `M-u` - Convert next word (or selection) to upper case.
nb: `M-u` - Gjør om neste ord (eller utvalg) til store bokstaver.

en: `M-l` - Convert next word (or selection) to lower case.
nb: `M-l` - Gjør om neste ord (eller utvalg) til små bokstaver.

en: `C-a` - Move to beginning of line
nb: `C-a` - Flytt til starten av linjen

en: `C-e` - Move to end of line
nb: `C-e` - Flytt til slutten av linjen

en: `C-p` - Move to previous line
nb: `C-p` - Flytt til forrige linje

en: `C-n` - Move to next line
nb: `C-n` - Flytt til neste linje

en: `C-f` - Move forward one character
nb: `C-f` - Flytt forover ett tegn

en: `C-b` - Move backward one character
nb: `C-b` - Flytt bakover ett tegn

en: `M-f` - Move forward one word
nb: `M-f` - Flytt forover ett ord

en: `M-b` - Move backward one word
nb: `M-b` - Flytt bakover ett ord

en: `C-M-n` - Move line or selection down
nb: `C-M-n` - Flytt linje eller utvalg ned

en: `C-M-p` - Move line or selection up
nb: `C-M-p` - Flytt linje eller utvalg opp

en: `S-M-u` - Move up 10 lines
nb: `S-M-u` - Flytt opp 10 linjer

en: `S-M-d` - Move down 10 lines
nb: `S-M-d` - Flytt ned 10 linjer

en: Deletion
nb: Sletting

en: Sonic Pi now supports a simple API for interacting with Minecraft Pi - the special edition of Minecraft which is installed by default on the Raspberry Pi's Raspbian Linux-based operating system.
nb: Sonic Pi støtter i dag et enkelt programmeringsgrensesnitt for å samvirke med Minecraft Pi - spesialutgaven av Minecraft som er installert i standardutgaven av Raspberry Pi sitt Linux-baserte Raspbian-operativsystem.

en: No need to import libraries
nb: Det er ikke nødvendig å importere biblioteker

en: The Minecraft Pi integration has been designed to be insanely easy to use. All you need to do is to launch Minecraft Pi and create a world. You're then free to use the `mc_*` fns just like you might use `play` and `synth`. There's no need to import anything or install any libraries - it's all ready to go and works out of the box.
nb: Minecraft Pi-integrasjonen er utformet for å være sinnsykt enkel å bruke.  Alt du trenger er å starte Minecraft Pi og lage en verden.  Du står så fritt til å bruke `mc_*`-funksjonene akkurat som du gjør med `play` og `synth`.  Det er ikke nødvendig å importere noe eller installere noen biblioteker.  Alt er klart til å gå i gang og virker ut av boksen.

en: Automatic Connection
nb: Automatisk oppkobling

en: The Minecraft Pi API takes care of managing your connection to the Minecraft Pi application. This means you don't need to worry about a thing. If you try and use the Minecraft Pi API when Minecraft Pi isn't open, Sonic Pi will politely tell you. Similarly, if you close Minecraft Pi whilst you're still running a `live_loop` that uses the API, the live loop will stop and politely tell you that it can't connect. To reconnect, just launch Minecraft Pi again and Sonic Pi will automatically detect and re-create the connection for you.
nb: API-et til Minecraft Pi tar seg av å styre forbindelsen din til Minecraft Pi-programmet.  Dette betyrat du ikke trenger bekymre deg for noen ting.  Hvis du forsøker å bruke API-et til Minecraft Pi når Minecraft Pi ikke er aktiv så vil Sonic Pi vennlig fortelle deg det.  Tilsvarende, hvis du lukker Minecraft Pi mens du fortsatt kjører en "live_loop" som bruker API-et, sa vil den aktive løkken stoppe og vennlig fortelle deg at den ikke kan koble seg opp.  For å opprette ny forbindelse er det bare å starte Minecraft Pi på nytt slik at Sonic Pi automatisk kan oppdage den og gjenopprette forbindelsen for deg.

en: Designed to be Live Coded
nb: Utformet for å programmeres mens programmet kjøres

en: Requires a Raspberry Pi 2.0
nb: Krever en Raspberry Pi 2.0

en: It is highly recommended that you use a Raspberry Pi 2 if you wish to run both Sonic Pi and Minecraft at the same time - especially if you want to use Sonic Pi's sound capabilities.
nb: Det er svært anbefalt at du bruker en Raspberry Pi 2 hvis du ønsker a bruke både Sonic Pi og Minecraft på samme tid - spesielt hvis du ønsker å bruke lydevnene til Sonic Pi.

en: API Support
nb: API-støtte

en: Basic Minecraft Pi API
nb: Grunnleggende Minecraft Pi-API

en: Sonic Pi currently supports the following basic interactions with Minecraft Pi:
nb: Sonic Pi støtter følgende grunnleggende samhandlinger med Minecraft Pi:

en: Displaying chat messages
nb: Vise frem samtalemeldinger

en: Setting the position of the user
nb: Sette brukerens posisjon

en: Getting the position of the user
nb: Hente ut brukerens posisjon

en: Setting the block type at a given coordinate
nb: Sette blokk-typen på et gitt koordinat

en: Getting the block type at a given coordinate
nb: Hente ut blokktypen på et gitt koordinat

en: Let's look at each of these in turn.
nb: La oss se på hver av disse etter tur.

en: Coordinates
nb: Koordinater

en: Now, in Minecraft two numbers isn't quite enough. We also need to know how high we are. We therefore need three numbers:
nb: Mens i Minecraft er to tall ikke helt nok.  Vi trenger også å vite hvor høyt vi er.  Vi trenger derfor tre tall:

en: How far from right to left in the world - `x`
nb: Hvor langt fra høyre til venstre i verden - `x`

en: How far from front to back in the world - `z`
nb: Hvor langt fra forran til bak i verden - `z`

en: How high up we are in the world - `y`
nb: Hvor høyt oppe i er i verden - `y`

en: One more thing - we typically describe these coordinates in this order `x`, `y`, `z`.
nb: Og forresten - vi beskriver typisk disse koordinatene i denne rekkefølgen `x`, `y`, `z`.

en: Finding your current coordinates
nb: Finne dine nåværende koordinater

en: Let's have a play with coordinates. Navigate to a nice place in the Minecraft map and then switch over to Sonic Pi. Now enter the following:
nb: La oss leke med koordinater.  Naviger til en fin plass i Minecraft-kartet og bytt så over til Sonic Pi.  Skriv deretter inn det følgende:

en: When you hit the *Run* button you'll see the coordinates of your current position displayed in the log window. Take a note of them, then move forward in the world and try again. Notice how the coordinates changed! Now, I recommend you spend some time repeating exactly this - move a bit in the world, take a look at the coordinates and repeat. Do this until you start to get a feel for how the coordinates change when you move. Once you've understood how coordinates work, programming with the Minecraft API will be a complete breeze.
nb: Når du trygger på *Kjør*-knappen vil du se koordinatene til din gjeldende posisjon vist frem i loggvinduet.  Merk deg dem og beveg deg fremover i verden og forsøk igjen.  Merk hvordan koordinatene endret seg!  Nå anbefaler jeg at du bruker litt tid til å gjenta akkurat dette - flytt litt i verden, titt på koordinatene og gjenta.  Gjør dette helt til du har en følelse om hvordan koordinatene endrer seg når du beveger deg.  Når du har forstått hvordan koordinater virker vil programmering med Minecraft-API-et være enkelt.

en: Let's Build!
nb: La oss bygge!

en: Now that you know how to find the current position and to teleport using coordinates, you have all the tools you need to start building things in Minecraft with code. Let's say you want to make the block with coordinates `40`, `50`, `60` to be glass. That's super easy:
nb: Nå når du vet hvordan du finner gjeldende posisjon og kan teleporte ved hjelp av koordinater, har du alle verktøyene du trenger for å gå i gang med å bygge ting i Minecraft med programmering.  Lå oss si at du vil få blokken med koordinater `40`, `50`, `60` til å bli glass.  Det er superenkelt:

en: Haha, it really was that easy. To see your handywork just teleport nearby and take a look:
nb: Haha, det er virkelig så enkelt.  For å se håndverket ditt trenger du bare teleportere til et sted i nærheten og ta en titt:

en: Now turn around and you should see your glass block! Try changing it to diamond:
nb: Nå kan du snu deg rundt og der bør du se glassblokken din.  Forsøk å endre den til diamant:

en: If you were looking in the right direction you might have even seen it change in front of your eyes! This is the start of something exciting...
nb: Hvis du tittet i riktig retning kan du til og me ha sett at den endret deg foran øynene på deg.  Dette er starten på noe fantastisk...

en: Looking at blocks
nb: Ser på blokker

en: Available block types
nb: Tilgjengelige blokktyper
