Sonic Pi - en to it translation catalogue (1468 entries)

en: 1 Welcome to Sonic Pi
it: 1 Benvenuto in Sonic Pi

en: Welcome friend :-)
it: Benvenuto :-)

en: Welcome to Sonic Pi. Hopefully you're as excited to get started making your own 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.
it: Benvenuto in Sonic Pi. Spero tu non veda l'ora di cominciare a creare i tuoi suoni almeno quanto io sono impaziente di mostrarti come si fa. Sarà un viaggio veramente *divertente* nel quale imparerai tutto su musica, sintesi, programmazione, composizione, performance e altro.

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.
it: Un momento, non mi sono nemmeno presentato! Sono [Sam Aaron](http://twitter.com/samaaron) - il tipo che ha realizzato Sonic Pi. Mi puoi trovare su Twitter [@samaaron](http://twitter.com/samaaron) e mi farà molto piacere conoscerti. Magari ti interessa sapere qualcosa di più anche delle mie [Live Coding Performances](https://youtube.com/samaaron) dove scrivo codice dal vivo con Sonic PI davanti al pubblico.

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!
it: Se hai qualche suggerimento o idea per migliorare Sonic PI, mi raccomando, fammela sapere: il tuo feedback è un aiuto importante. Non si può mai sapere, la tua idea potrebbe essere la prossima "big 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.
it: Questo tutorial è suddiviso in sezioni raggruppate in categorie. Anche se l'ho pensato per un apprendimento facile e progressivo dall'inizio alla fine, sentiti libero di passare da un argomento all'altro senza seguire necessariamente l'ordine del tutorial. Se pensi che manchi qualcosa, fammelo sapere e io prenderò in considerazione il tuo suggerimento per una prossima versione.

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 :-)
it: Infine, guardare gli altri che fanno live coding è un ottimo modo per imparare. Faccio regolarmente dirette streaming on line su [http://youtube.com/samaaron](http://youtube.com/samaaron) quindi passa per un saluto e fammi tante domande :-)

en: OK, let's get started...
it: Ok, possiamo cominciare...

en: 1.1 Live Coding
it: 1.1 Programmare dal vivo

en: Live Coding
it: Programmare dal vivo

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.
it: Uno degli aspetti più divertenti di Sonic Pi è che ti permette di scrivere e *modificare codice live* per fare musica, proprio come se suonassi una chitarra dal vivo. Questo significa che dopo un po’ di pratica puoi salire sul palco ed esibirti con Sonic Pi.

en: Free your mind
it: Libera la tua mente

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...
it: Prima di entrare nel vivo del funzionamento di Sonic Pi, vorrei farti capire meglio cosa vuol dire programmare dal vivo. Per il momento non ti preoccupare se non capisci molto (o anche nulla) di quello che vedremo. Mettiti solo comodo e divertiti...

en: A live loop
it: Un live loop

en: Let's get started, copy the following code into an empty buffer:
it: Allora cominciamo, copia il codice qui di seguito in uno dei buffer vuoti:

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:
it: Ora premi il tasto `Run` e sentirai un bel suono di cassa che batte a tempo. Per fermare il suono basta premere sul tasto `Stop`. Però, per il momento, non premerlo ancora… Segui invece questi passaggi:

en: Make sure the bass drum sound is still running
it: Assicurati che il suono della cassa sia ancora attivo

en: Change the `sleep` value from `0.5` to something higher like `1`.
it: Cambia il valore di `sleep` da `0.5` a qualcosa di più grande, ad esempio: `1`.

en: Press the `Run` button again
it: Premi di nuovo il tasto `Run`

en: Notice how the drum speed has changed.
it: Nota come è cambiata la velocità della batteria.

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...
it: Infine, *ricorda questo momento*: questa è la prima volta che hai fatto live coding con Sonic Pi ed è probabile che non sarà l’ultima...

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:
it: Ok, fin qui era abbastanza semplice. Adesso aggiungi qualcos’altro al mix. Sopra `sample :bd_haus` aggiungi l’istruzione `sample :ambi_choir, rate: 0.3`. Il tuo codice dovrebbe apparire così:

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).
it: E adesso, sbizzarrisciti. Cambia il parametro `rate:` - cosa succede se usi valori grandi, o piccoli, o negativi? Guarda cosa succede se cambi il valore di `rate:` del campione `:ambi_choir` anche di pochissimo (diciamo 0.29). Cosa succede se scegli un valore molto piccolo per `sleep`? Prova a farlo così velocemente da provocare un errore, perché il computer non riesce a stargli dietro (se succede, basta scegliere un valore di `sleep` più grande e premere di nuovo `Run`).

en: Try commenting one of the `sample` lines out by adding a `#` to the beginning:
it: Prova a inserire all’inizio di una delle istruzioni `sample` un `#`:

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.
it: Fai caso a come il `#` dice al computer di ignorare quello che c’è scritto dopo, e di conseguenza non sentiamo più il campione. In Sonic Pi possiamo usare i commenti per togliere o reinserire elementi al mix.

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:
it: Infine, ecco qualcosa di divertente con cui giocare. Prendi il codice qui sotto e copialo in un buffer vuoto. Poi, non cercare di capire altro, se non che ci sono due loop - due cose che suonano nello stesso tempo. Quindi, fai quello che sai fare meglio: provare e sperimentare. Ecco alcuni suggerimenti:

en: Try changing the blue `rate:` values to hear the sample sound change.
it: Prova a cambiare i valori scritti in blu di `rate:` e ascolta il suono del campione che cambia.

en: Try changing the `sleep` times and hear that both loops can spin round at different rates.
it: Prova a cambiare i tempi di `sleep` e senti come tutti e due i loop possono girare a differenti velocità.

en: Try uncommenting the sample line (remove the `#`) and enjoy the sound of the guitar played backwards.
it: Prova a rimuovere il commento dalla riga con l’istruzione sample (togli il `#`) e goditi il suono della chitarra al contrario.

en: Try changing any of the blue `mix:` values to numbers between `0` (not in the mix) and `1` (fully in the mix).
it: Prova a cambiare uno qualsiasi dei valori scritti in blu di `mix` con numeri che vanno da `0` (tutto fuori dal mix) a `1` (tutto nel mix).

en: Remember to press `Run` and you'll hear the change next time the loop goes round. If you end up in a pickle, don't worry - hit `Stop`, delete the code in the buffer and paste a fresh copy in and you're ready to jam again. Making mistakes is how you'll learn the quickest...
it: Ricordati di premere `Run` e sentirai il cambiamento non appena il loop viene suonato di nuovo. Se fai qualche errore, non preoccuparti: premi `stop`, cancella il codice nel buffer, copia di nuovo il codice originale e sei pronto per ricominciare. Sbagliare è il modo più veloce per imparare...

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.
it: Suona e fai esperimenti finché non avrai soddisfatto la tua curiosità su come funziona tutto questo e avrai cominciato a chiederti che altro ci puoi fare. A quel punto sarai pronto per proseguire con il tutorial.

en: So what are you waiting for...
it: Allora, che aspetti?

en: 1.2 Exploring the Interface
it: 1.2 Esploriamo l’interfaccia

en: The Sonic Pi Interface
it: L’interfaccia di Sonic Pi

en: Sonic Pi has a very simple interface for coding music. Let's spend a little time exploring it.
it: Sonic Pi ha un’interfaccia molto semplice per programmare la musica. Diamogli un’occhiata.

en: *A* - Play Controls
it: *A* - Controlli di riproduzione

en: *B* - Editor Controls
it: *B* - Controlli di modifica

en: *C* - Info and Help
it: *C* - Info e Help

en: *D* - Code Editor
it: *D* - Editor del codice

en: *E* - Prefs Panel
it: *E* - Pannello preferenze

en: *F* - Log Viewer
it: *F* - Visualizzatore Messaggi

en: *G* - Help System
it: *G* - Sistema d'aiuto

en: *H* - Scope Viewer
it: *H* - Visualizzatore di segnale

en: *I* - Cue Viewer
it: *I* - Visualizzatore Messaggi

en: A. Play Controls
it: A. Controlli di riproduzione

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.
it: Questi tasti rosa sono i controlli principali per far partire o fermare i suoni. Il tasto *Run* esegue il codice che hai scritto nell’editor, *Stop* ferma tutto il codice in esecuzione, *Save* per salvare il codice in un file esterno e *Record* per registrare (in un file WAV) i suoni riprodotti.

en: B. Editor Controls
it: B. Controlli di modifica

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.
it: Questi pulsanti arancioni ti permettono di modificare l'interfaccia. I pulsanti *Size +* e *Size -* ti permettono di ingrandire o rimpicciolire il testo.

en: C. Info and Help
it: C. Info e Help

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.
it: Questi tasti blu ti danno accesso alle informazioni, all’aiuto e alle opzioni. Il tasto *Info* apre la finestra delle informazioni che contiene le notizie su Sonic Pi, il team di sviluppo, la storia, i collaboratori e la community. Il tasto *Help* apre e chiude l’help (*G*) e il tasto *Prefs* apre e chiude la finestra delle opzioni che ti permette di modificare alcune impostazioni di base del programma.

en: D. Code Editor
it: D. Editor del codice

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.
it: Questa è l’area dove scriverai il tuo codice e comporrai/eseguirai la tua musica. È un semplice editor di testo dove puoi scrivere le tue istruzioni, cancellarle, copiarle e incollarle etc. Pensalo come una versione molto elementare di Word o Google Docs. L’editor cambia il colore delle parole sulla base del loro significato nel linguaggio. Questo all’inizio può sembrare strano, ma presto ti accorgerai che è molto utile. Per esempio, qualunque testo colorato di blu è sicuramente un numero.

en: E. Prefs Panel
it: E. Pannello delle preferenze

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.
it: Attraverso il tasto *prefs* nel gruppo di tasti Info e Help, puoi accedere alle opzioni di configurazione di Sonic Pi. Questo tasto ti permette di aprire e chiudere la finestra delle preferenze che possono essere modificate. Per esempio, forzare la modalità mono, invertire i canali stereo, modificare il livello di dettaglio dei messaggi di log e c'è anche un cursore per il livello del suono in uscita e un selettore audio se stai usando un Raspberry Pi.

en: F. Log Viewer
it: F. Visualizzatore messaggi

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.
it: Quando i tuoi programmi girano, le informazioni su cosa stiano facendo vengono visualizzate nella finestra di log. Di default, noterai che c’è un messaggio per ogni suono che generi e che riporta il tempo esatto in cui il suono viene prodotto. Vedrai che questo ti sarà molto utile quando dovrai fare il debug, ovvero individuare gli errori, del tuo codice o capire cosa sta facendo il tuo programma.

en: G. Help System
it: G. Sistema di aiuto

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.
it: Infine, una delle parti più importanti dell’interfaccia di Sonic Pi è la sezione Help che appare in basso nella finestra del programma. Puoi attivarla o disattivarla usando il tasto *Help*. La sezione Help contiene aiuti e informazioni su tutti gli aspetti di Sonic Pi, compreso questo tutorial, una lista dei sintetizzatori e dei campioni disponibili, esempi, effetti (FX) ed una lista completa di tutte le funzioni e le istruzioni disponibili nel linguaggio di Sonic Pi.

en: H. Scope Viewer
it: H. Visualizzatore di segnale

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).
it: Il visualizzatore di segnale ti permette di "guardare" il suono che stai ascoltando. Poi osservare facilmente che l'onda a dente di sega ha davvero la forma di una sega e che il beep è una curva della funzione seno. Puoi inoltre distinguere i suoni forti dai suoni deboli osservando la grandezza delle linee. Ci sono tre sezioni a disposizione: la predefinita è dedicata alla combinazione dei canali destro e sinistro, poi c'è quella che permette di visualizzare i due canali separatamente e infine c'è la sezione che mostra la "figura di Lissajous". Quest'ultima indica la relazione parametrica fra canale sinistro e canale destro, inoltre ti permette di disegnare delle forme geometriche con il suono (https://en.wikipedia.org/wiki/Lissajous_curve).

en: All internal and external events (called cues in Sonic Pi) are automatically logged in the Cue Viewer. For example, if you have a MIDI controller connected and press one of its buttons, you'll see a new cue event in the Cue Viewer telling you the name of the controller and which button you pressed. Once you've mastered the basics of making and producing sounds, you'll start to want to cue sounds or whole sections of sounds based on events such as these. A cue event is just an indication that something happened. For example, every time a live loop spins round, it sends a cue event out which is logged in the Cue Viewer. Also, external events such as MIDI messages from connected MIDI equipment and OSC messages from other programs or computers are also displayed in the Cue Viewer. It is also possible to directly generate cue events using the `cue` function. Anything that appears in the Cue Viewer can be used to trigger something happening. This is covered in more detail in Sections 10 to 12 of this tutorial.
it: Tutti gli eventi interni ed esterni (denominati cues in Sonic Pi) sono automaticamente registrati nel Cue Viewer. Ad esempio, se hai un controller MIDI collegato e premi uno dei suoi tasti, vedrai un nuovo evento cue nel Cue Viewer che mostra il nome del controller e il valore del tasto premuto. Una volta acquisita la padronanza base per creare e riprodurre suoni, comincerai a volere gestire i suoni o intere sezioni di suoni sulla base di eventi come questi. Un evento cue è in pratica un'indicazione che qualcosa è avvenuto. Ad esempio, per ogni volta che un loop ricomincia da capo manda un evento cue che viene registrato nel Cue Viewer. Inoltre, eventi esterni come gli eventi MIDI da una periferica MIDI collegata oppure eventi OSC provenienti da altri programmi o computer sono anch'essi mostrati nel Cue Viewer. E' inoltre possibile generare eventi cue usando la funzione 'cue'. Qualunque cosa appaia nel Cue Viewer può essere usato per innescare qualcosa. Questo è spiegato con maggiori dettagli nelle sezioni da 10 a 12 di questo tutorial.

en: 1.3 Learning through Play
it: 1.3 Imparare suonando

en: Learning through Play
it: Imparare suonando

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.
it: Sonic PI ti incoraggia ad imparare sia l’informatica che la musica suonando e sperimentando. La cosa più importante è che, mentre ti diverti, senza accorgertene impari a programmare, a comporre e a esibirti.

en: There are no mistakes
it: Non esistono errori

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*.
it: Già che ne stiamo parlando, permettimi di darti una dritta che ho imparato in anni di live coding in musica: *non esistono errori, ma solo opportunità*. È una cosa che ho spesso sentito dire a proposito del jazz, ma funziona altrettanto bene con il live coding. Non importa quanto tu sia esperto - un principiante o un Algoraver navigato: ti capiterà sempre di eseguire del codice dal risultato completamente inaspettato. Potrebbe suonare maledettamente bene, e allora vai tranquillo. Ma potrebbe suonare anche totalmente cacofonico e sballato. Non è importante quello che è venuto fuori, ma quello che ci farai subito dopo. Prendi il suono, manipolalo e modellalo fino a farlo diventare qualcosa di spettacolare. Il pubblico *impazzirà*.

en: Start Simple
it: Comincia dalle cose semplici

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.
it: Mentre si sta imparando, si è tentati di fare *subito* cose straordinarie. Metti da parte questo obiettivo e consideralo come qualcosa da raggiungere più in là. Per adesso, pensa piuttosto che la cosa *più semplice* che potresti scrivere con divertimento e soddisfazione è un piccolo passo verso ciò che hai in mente. Una volta che hai un’idea su quel piccolo passo, prova a realizzarlo, suonalo e vedi quali nuove idee ti suggerisce. Sarai ben presto troppo occupato a divertirti e a fare progressi concreti.

en: Just make sure to share your work with others!
it: Accertati sempre di condividere il tuo lavoro con gli altri!

en: 2 Synths
it: 2 Synth (Sintetizzatori)

en: Synths
it: Synth (Sintetizzatori)

en: OK, enough of the intros - let's get into some sound.
it: OK, di introduzione ne abbiamo abbastanza - cominciamo a produrre qualche suono.

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.
it: In questa parte vedremo le basi dell'utilizzo dei synth. Synth è l'abbreviazione di *synthesizer* (sintetizzatore), che è una strana parola per indicare un generatore di suoni. Di solito i synth sono abbastanza complicati da usare - specialmente quelli analogici che sono formati da tanti moduli collegati fra di loro da decine di cavi. Sonic Pi, invece, permette gran parte di quella potenzialità, ma in modo semplice e intuitivo.

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...
it: Non farti ingannare dall’apparente semplicità dell’interfaccia di Sonic Pi. Potrai arrivare a padroneggiare tecniche molto potenti di manipolazione del suono, se non ti mancherà la passione. Reggiti forte alla sedia...

en: 2.1 Your First Beeps
it: 2.1 I tuoi primi Beep

en: Your First Beeps
it: I tuoi primi Beep

en: Take a look at the following code:
it: Dai un’occhiata a questa istruzione:

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...
it: È da qui che comincia tutto. Copiala e incollala nella finestra del codice in alto (il grande spazio bianco sotto il tasto Run). Ora, premi Run...

en: Intense. Press it again. And again. *And again...*
it: Forte, no?. Premilo ancora. E ancora. *E ancora…*

en: Can you hear the difference? Try a lower number:
it: Senti la differenza? Prova con un numero più piccolo:

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.
it: Quindi, abbassare il numero produce suoni più gravi mentre alzarlo li rende più acuti. Proprio come in un pianoforte: i tasti nella parte più bassa (quelli a sinistra) producono note più gravi mentre i tasti nella parte alta (quella a sinistra) producono note più acute.

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`.
it: A quanto pare, il Do nella quarta ottava (che si scrive C nella notazione inglese) è identificato dal numero 60. `play 60`, quindi, suona il Do nella 4a ottava. Per suonare il tasto successivo sulla destra, devi aggiungere 1 a 60: scrivendo `play 61`, che in questo caso rappresenta il tasto nero del Do diesis. Per suonare un Re, il tasto bianco successivo procedendo verso destra, scrivi `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*.
it: *Non ti preoccupare* se ti sembra che non abbia alcun senso: nemmeno per me lo aveva quando ho cominciato. Tutto quello che ti serve di sapere per ora è che *numeri piccoli fanno beep più gravi* e *numeri grandi fanno beep più acuti*.

en: Chords
it: Accordi

en: Playing a note is quite fun, but playing many at the same time can be even better. Try it:
it: Suonare una nota è divertente, ma suonarne tante contemporaneamente può esserlo anche di più. Prova:

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.
it: Forte! Quindi, quando scrivi tanti `play`, suonano tutti contemporaneamente. Prova da solo: quali numeri suonano bene insieme? Quali invece stridono? Sperimenta, esplora e scopri da solo.

en: Melody
it: Melodia

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:
it: Quindi, suonare note e accordi è divertente, ma che ne dici di provare con una melodia? Ovvero, come si fa a far suonare una nota dopo l’altra e non tutte insieme? Beh, è facile, basta fare una pausa (`sleep`) tra le note:

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`:
it: Che bello, un piccolo arpeggio. Ma che significa quell’ `1` in `sleep 1`? Quel numero indica la *durata dello sleep*. Vuol dire: "fermati per un beat", ma per il momento pensiamo che significhi uno stop di un secondo. E se invece volessimo suonare il nostro arpeggio un po’ più velocemente? Basta usare valori più piccoli per l’istruzione `sleep`. Che ne dici della metà, `0.5`?

en: Notice how it plays faster. Now, try for yourself, change the times - use different times and notes.
it: Hai notato che suona più veloce? Ora prova, da solo, a cambiare note e tempi.

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.
it: Una cosa che puoi provare sono i valori intermedi per le note, come `play 52.3` oppure `play 52.63`. Non c’è nessun bisogno, infatti, di limitarsi ai valori interi delle note. Divertiti a provare da solo.

en: Traditional Note Names
it: Nomi tradizionali delle note

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:
it: (N.d.T. in inglese le note si chiamano con le lettere dell’alfabeto e cominciano dal La invece che dal Do. Quindi A = La, B = Si, C = Do, D = Re, E = Mi, F = Fa, G = Sol.) Se già conosci un po’ di notazione musicale (se non la conosci non ti preoccupare, per il momento non è necessaria per divertirsi) potresti voler scrivere una melodia usando i nomi delle note come C e F# invece dei numeri. Sonic Pi ha pensato anche a questo. Puoi fare così:

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:
it: Non dimenticare i due punti `:` prima del nome della nota in modo che diventi rosa. Puoi anche specificare l’ottava indicando un numero dopo il nome della nota:

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`.
it: Se ti serve una nota col *diesis* (in inglese *sharp*), aggiungi una `s` dopo il nome della nota come in `play :Fs3` o se ti serve col *bemolle* (in inglese *flat*) aggiungi una `b` come in `play :Eb3`.

en: There's also a handy shortcut for a rest (a musical way of saying not to play anything instead of a note) using `:r`, `:rest` or `nil`.
it: Esiste inoltre una comoda scorciatoia per la pausa (un modo nel linguaggio musicale per indicare di suonare nulla invece che una nota) usando `:r`, `:rest` or `nil`.

en: 2.2 Synth Options
it: 2.2 Parametri dei Synth

en: Synth Options: Amp and Pan
it: Paramentri dei Synth: Amp e Pan

en: As well as allowing you to control which note to play or which sample to trigger, Sonic Pi provides a whole range of options to craft and control the sounds. We'll be covering many of these in this tutorial and there's extensive documentation for each in the help system. However, for now we'll introduce two of the most useful: *amplitude* and *pan*. First, let's look at what options actually are.
it: Oltre a permetterti di controllare quale nota o quale campione suonare, Sonic Pi fornisce un insieme completo di parametri per inventare e controllare il suono. Ne incontreremo molti in questo tutorial e puoi trovare una trattazione completa nell’help. Per il momento, però, ne introdurremo due tra i più utili: *ampiezza* e *bilanciamento* (in inglese *amplitude* e *pan*). Prima di tutto diamo un’occhiata a cosa sono effettivamente i parametri.

en: Options
it: Parametri

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).
it: Sonic Pi usa il concetto di parametro per i suoi synth. I parametri sono quantità che vengono passati all’istruzione `play` e che controllano e modificano caratteristiche del suono che ascolti. Ogni synth ha il suo gruppo di parametri per controllare in modo dettagliato il suono generato, ma comunque molti synth hanno in comune alcuni parametri come per esempio `amp:` e quelli che riguardano l’inviluppo (trattati in un paragrafo successivo).

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:
it: I parametri sono passati alle istruzioni `play` usando una virgola `,` seguita dal nome del parametro, per esempio `amp:` (non dimenticare i due punti `:`) e quindi da uno spazio e dal valore del parametro. Per esempio:

en: (Note that `cheese:` isn't a valid opt, we're just using it as an example).
it: (Nota bene che `cheese:` non è un parametro valido, è solo per fare un esempio).

en: You can pass multiple opts by separating them with a comma:
it: Puoi passare più parametri in una volta separandoli con una virgola:

en: The order of the opts doesn't matter, so the following is identical:
it: L’ordine dei parametri non conta, quindi questa istruzione ha lo stesso effetto di quella precedente:

en: Opts that aren't recognised by the synth are just ignored (like `cheese` and `beans` which are clearly ridiculous opt names!)
it: I parametri che non sono riconosciuti dal synth vengono ignorati (come `cheese` e `beans` che sono ovviamente nomi assurdi per dei parametri!)

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:
it: Se per sbaglio usi lo stesso parametro due volte con diversi valori, l’ultimo vince. Per esempio `beans` in questa istruzione avrà il valore 2 invece di 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:`.
it: Molte cose in Sonic Pi accettano parametri, quindi passa un po’ di tempo a capire come usarli e sarai pronto! Giochiamo un po' con il nostro primo parametro `amp:`.

en: Amplitude
it: Ampiezza

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.
it: L’ampiezza è una rappresentazione digitale del volume di un suono. *Un’ampiezza elevata produce un suono forte* mentre *un valore basso di ampiezza produce un suono debole*. Come Sonic Pi usa numeri per rappresentare il tempo e le note, allo stesso modo usa numeri per rappresentare anche l’ampiezza. Un’ampiezza di valore 0 equivale al silenzio (non si sentirà nulla) mentre un’ampiezza di valore 1 equivale al volume normale. Puoi anche forzare l’ampiezza a valori più alti (2, 10, 100), ma vedrai che quando l’ampiezza complessiva di tutti i suoni diventa troppo alta, Sonic Pi usa il cosiddetto compressore per riportarla di nuovo a valori tali da non risultare troppo alti per le orecchie. Ciò può rendere il suono confuso e strano. Perciò prova ad usare ampiezze basse, diciamo tra 0 e 0.5, per evitare la compressione.

en: Amp it up
it: Amplifichiamo

en: To change the amplitude of a sound, you can use the `amp:` opt. For example, to play at half amplitude pass 0.5:
it: Per cambiare l’ampiezza di un suono, puoi usare il parametro `amp:`. Ad esempio, per suonare alla metà del volume, dai un valore di 0.5:

en: To play at double amplitude pass 2:
it: Per suonare ad ampiezza doppia, dai un valore di 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):
it: Il parametro `amp:` modifica soltanto la chiamata a `play` a cui è associato. Così, ad esempio, la prima chiamata a `play` è a metà volume, mentre la seconda è di nuovo sul valore di default:

en: Of course, you can use different `amp:` values for each call to play:
it: Naturalmente puoi usare differenti valori per `amp:` per ogni play:

en: Panning
it: Bilanciamento

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.
it: Un altro parametro divertente è `pan:`, che controlla la collocazione del suono (*panning*) sul fronte stereofonico. Bilanciare il suono a sinistra significa sentirlo solo dalla cassa di sinistra mentre, spostarlo a destra significa sentirlo dalla cassa di destra. In Sonic Pi usiamo un -1 per posizionare il suono tutto a sinistra, 0 per posizionare il suono al centro e 1 per posizionare il suono tutto a destra. Ovviamente siamo liberi di usare qualsiasi parametro tra -1 e 1 per controllare l'esatto posizionamento del nostro suono.

en: Let's play a beep out of the left speaker:
it: Facciamo suonare un beep dall’altoparlante a sinistra:

en: Now, let's play it out of the right speaker:
it: Ora, dall’altoparlante a destra:

en: Finally let's play it back out of the center of both (the default position):
it: Infine, facciamolo suonare al centro (che è la posizione di default):

en: Now, go and have fun changing the amplitude and panning of your sounds!
it: E adesso divertiti a cambiare le ampiezze e il panning dei tuoi suoni!

en: 2.3 Switching Synths
it: 2.3 Muoversi fra i Synth

en: Switching Synths
it: Muoversi fra i Synth

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.
it: Finora ci siamo divertiti un sacco con i beep. Ma probabilmente questi semplici beep staranno cominciando ad annoiarti. È tutto qui quello che Sonic Pi ha da offrire? Ci sarà qualcosa di più nel live coding che suonare dei beep! Certo che c’è, e in questa sezione esploriamo la vasta gamma di suoni che offre Sonic Pi.

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.
it: Sonic Pi offre una ampia gamma di strumenti chiamati synth, forma abbreviata per *sintetizzatori*. Mentre i sample contengono suoni pre-registrati, i synth sono in grado di generare nuovi suoni in base a come li controlli (cosa che esploreremo più in là nel tutorial). I synth di Sonic Pi sono molto potenti ed espressivi e ti divertirai molto nell’esplorarne le possibilità e nel suonarli. Per prima cosa, impariamo a selezionare il synth da suonare.

en: Buzzy saws and prophets
it: Onde a dente di sega e prophets

en: A fun sound is the *saw wave* - let's give it a try:
it: Un suono divertente è il *dente di sega*. Proviamolo:

en: Let's try another sound - the *prophet*:
it: Adesso proviamo un altro suono - il *prophet*:

en: How about combining two sounds. First one after another:
it: E se combinassimo insieme due suoni? Prima uno, poi l’altro:

en: Now multiple sounds at the same time (by not sleeping between successive calls to `play`):
it: Ora riproduciamo più suoni contemporaneamente (non mettendo sleep tra chiamate successive di `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`.
it: Nota che il comando `use_synth` influenza soltanto le chiamate seguenti a `play`. Pensalo come un *grande switch* - le nuove chiamate a `play` useranno qualsiasi sintetizzatore sia in uso in quel momento. Puoi regolare lo switch su un nuovo synth con l’istruzione `use_synth`.

en: Discovering Synths
it: Alla scoperta dei Synth

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:
it: Per vedere quali sintetizzatori Sonic Pi mette a tua disposizione, dai un’occhiata all’opzione Synths nel menu in basso in questa schermata di aiuto (tra Esempi e FX). Ce ne sono più di 20 tra cui scegliere. Ecco qui sotto soltanto alcuni dei miei preferiti:

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.
it: Ora divertiti a *cambiare i synth mentre fai la tua musica*. Divertiti a combinare i synth per fare nuovi suoni e ad usare synth differenti in diverse sezioni della tua musica.

en: 2.4 Duration with Envelopes
it: 2.4 Durate e inviluppi

en: Duration with Envelopes
it: Durate e inviluppi

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.
it: Nelle sezioni precedenti, abbiamo visto come usare il comando `sleep` per controllare l’attacco della nota, ma non siamo ancora in grado di controllare la durata dei suoni.

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:
it: Per dotarci di uno strumento semplice ma potente per *controllare le durate* dei suoni, Sonic Pi implementa il concetto di *inviluppo ADSR* (ci occuperemo più oltre in questa stessa sezione di cosa voglia dire ADSR). Un inviluppo di ampiezza permette di gestire due utili aspetti del controllo:

en: control over the duration of a sound
it: controllo della durata di un suono

en: control over the amplitude of a sound
it: controllo dell’ampiezza di un suono

en: Duration
it: Durata

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.
it: La durata è il tempo che un suono... dura! Una durata più lunga significa che sentirai il suono per un tempo più lungo. Tutti i suoni in Sonic Pi hanno un inviluppo di ampiezza controllabile, e la durata di tale inviluppo corrisponde alla durata del suono. Quindi, controllando l’inviluppo, controlli allo stesso tempo la durata.

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.
it: L'inviluppo ADSR non controlla soltanto la durata, ma fornisce anche un *controllo accurato dell’ampiezza del suono*. Tutti i suoni udibili iniziano dal silenzio e finiscono nel silenzio, e contengono una parte non-silenziosa nel mezzo. Gli inviluppi ti permettono di variare e mantenere l’ampiezza della parte non-silenziosa del suono. È come dare a qualcuno istruzioni su come e quanto alzare e abbassare il volume dell’amplificatore della chitarra. Per esempio, potresti chiedere a questa persona di *iniziare dal silenzio, alzare il volume lentamente fino al massimo, mantenerlo per un po’ e riabbassarlo di colpo*. Sonic Pi ti permette di controllare con precisione questo tipo di comportamento mediante gli inviluppi.

en: Just to recap, as we have seen before, an amplitude of 0 is silence and an amplitude of 1 is normal volume.
it: Tanto per riassumere: come abbiamo visto prima, una ampiezza di 0 equivale a silenzio e un’ampiezza 1 è il volume normale.

en: Now, let us look at each of the parts of the envelopes in turn.
it: Ora, diamo un’occhiata alle parti da cui l’inviluppo è composto.

en: Release Phase
it: Fase di rilascio (Release)

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):
it: L’unica parte dell’inviluppo che viene usata di default è il rilascio (release). Si tratta del tempo che il suono di un synth impiega a sfumare. Tutti i synth hanno un tempo di rilascio impostato a 1, il che vuol dire che, di default, hanno la durata di 1 beat (che a sua volta, al tempo di default di 60BPM, equivale a 1 secondo):

en: The note will be audible for 1 second. Go ahead and time it :-) This is short hand for the longer more explicit version:
it: La nota resterà udibile per 1 secondo. Prova a verificare tu stesso. Questa era la forma breve in luogo di quella più lunga ed esplicita:

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:
it: Nota come il suono abbia esattamente la stessa durata di prima (il suono dura un secondo). Ma ora è molto facile cambiare la durata modificando il valore dell’opzione `release:`:

en: We can make the synth sound for a very short amount of time by using a very small release time:
it: Possiamo anche far suonare il synth per una durata molto breve usando un valore molto piccolo del tempo di rilascio:

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:
it: La durata del rilascio di un suono è chiamata *fase di rilascio* e, di default, è una transizione lineare (cioè segue una linea retta), Il seguente diagramma illustra questa transizione:

en: You can therefore change the duration of your sound by changing the release time. Have a play adding release times to your music.
it: Ora poi cambiare la durata dei suoni cambiando il tempo di rilascio. Divertiti ad aggiungere i tempi di rilascio alle note della tua musica.

en: Attack Phase
it: Fase d’attacco

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:
it: Di default, la *fase d’attacco* è 0 per tutti i synth, il che significa che questi salgono da ampiezza 0 a 1 immediatamente. Ciò conferisce ai synth un timbro percussivo. Tuttavia, potresti volere che il suono raggiunga l’ampiezza 1 più lentamente (*fade in*). Puoi ottenere questo risultato con l’opzione `attack:`:

en: You may use multiple opts at the same time. For example for a short attack and a long release try:
it: Puoi usare opzioni multiple contemporaneamente. Per esempio, per un attacco corto e un rilascio lungo, prova così:

en: This short attack and long release envelope is illustrated in the following diagram:
it: Un inviluppo con attacco corto e rilascio lungo è illustrato nel diagramma seguente:

en: Of course, you may switch things around. Try a long attack and a short release:
it: È ovvio che puoi fare anche l’inverso. Prova un attacco lungo e un rilascio corto:

en: Finally, you can also have both short attack and release times for shorter sounds.
it: Infine, puoi anche impostare un tempo corto sia per l’attacco che per il rilascio, per avere suoni più brevi.

en: Sustain Phase
it: Fase di sostegno (Sustain)

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.
it: Oltre ai tempi di attacco e rilascio, puoi specificare anche un tempo di sostegno (sustain) per controllare la *fase di sostegno*. Essa corrisponde al tempo in cui il suono è mantenuto ad ampiezza fissa dopo l’attacco e prima del rilascio.

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.
it: Il tempo di sostegno è utile per suoni a cui vuoi dare maggior presenza nel mix prima di inserire una fase, opzionale, di rilascio. Naturalmente, è del tutto valido anche impostare sia l’attacco che il rilascio a 0 per non avere alcun tipo di dissolvenza né in entrata né in uscita. Bada però che un tempo di rilascio uguale a 0 genera dei click, ed è meglio usare valori molto piccoli come 0.2.

en: Decay Phase
it: Fase di decadimento (Decay)

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:
it: Per un ulteriore livello di controllo, puoi specificare anche un tempo di decadimento. Si tratta di una fase dell’inviluppo che si trova tra attacco e sostegno e specifica il tempo in cui l’ampiezza scende da `attack_level:` (livello d’attacco) a `decay_level:` (livello di decadimento). Di default, l’opzione `decay:` ha valore 0 e sia il livello di attacco che il livello di sostegno sono impostati su 1, e ciò significa che dovrai impostarne il valore in modo esplicito se vuoi che il tempo di decadimento sortisca qualche effetto:

en: Decay Level
it: Livello di decadimento

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:
it: Un’altra possibilità è impostare esplicitamente i valori di `decay_level:` e `sustain_level:` (anche se di default sono uguali) per avere pieno controllo sull’inviluppo. Ciò consente di creare inviluppi nel modo seguente:

en: It's also possible to set the `decay_level:` to be higher than `sustain_level:`:
it: È possibile anche impostare un `decay_level:` più alto del `sustain_level:`:

en: ADSR Envelopes
it: Inviluppi ADSR

en: So to summarise, Sonic Pi's ADSR envelopes have the following phases:
it: Riassumendo, gli inviluppi di Sonic Pi hanno le seguenti fasi:

en: *attack* - time from 0 amplitude to the `attack_level`,
it: tempo di *attacco*: per transitare da ampiezza 0 a `attack_level`,

en: *decay* - time to move amplitude from `attack_level` to `decay_level`,
it: tempo di *decadimento*: per transitare da `attack_level` a `decay_level`,

en: *sustain* - time to move the amplitude from `decay_level` to `sustain_level`,
it: tempo di *sostegno*: per transitare da `decay_level` a `sustain_level`,

en: *release* - time to move amplitude from `sustain_level` to 0
it: tempo di *rilascio*: per transitare da `sustain_level` a 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:
it: È importante sottolineare che la durata di un suono è pari alla somma dei tempi di ciascuna di queste quattro fasi. Quindi, il suono seguente avrà una durata pari a 0.5 + 1 + 2 + 0.5, ovvero 4 beat:

en: Now go and have a play adding envelopes to your sounds...
it: E adesso datti da fare ad aggiungere gli inviluppi ai tuoi suoni...

en: 3 Samples
it: 3 Campioni

en: Samples
it: Campioni (Samples)

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.
it: Un altro modo molto interessante per creare musica è quello di usare suoni pre-registrati. Nella grande tradizione hip-hop li chiamiamo *campioni* (in inglese, *samples*). Quindi, se ti armi di microfono e vai in giro a registrare, per esempio, il suono leggero della pioggia su una tela, hai appena creato un campione.

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...
it: Con Sonic Pi puoi fare un sacco di cose divertenti coi campioni: ci sono più di 90 campioni di pubblico dominio, pronti per i tuoi mix, ma il programma ti permette anche di suonare e trasformare quelli creati da te. Vediamo subito come...

en: 3.1 Triggering Samples
it: 3.1 Suonare i campioni

en: Triggering Samples
it: Suonare i campioni

en: Playing beeps is only the beginning. Something that's a lot of fun is triggering pre-recorded samples. Try it:
it: Fare i beep è soltanto l’inizio. Una cosa molto divertente è suonare campioni pre-registrati. Prova questo:

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:
it: In Sonic Pi troverai molti campioni precaricati coi quali lavorare. Puoi usarli nello stesso modo in cui usi il comando `play`. Per suonare insieme note e campioni ti basta scrivere le istruzioni una dopo l’altra:

en: If you want to space them out in time, use the `sleep` command:
it: Se vuoi distribuirli nel tempo, usa l’istruzione `sleep`:

en: Discovering Samples
it: Scopriamo i campioni

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:
it: Altrimenti puoi usare il *sistema di autocompletamento*. Prova a scrivere la prima parte del nome di un gruppo di campioni, come: `sample: ambi_` e vedrai che apparirà un menu a tendina con i nomi dei campioni tra i quali potrai scegliere. Prova con questi prefissi di categoria:

en: Now start mixing samples into your compositions!
it: Ora puoi cominciare a mixare campioni per realizzare le tue composizioni!

en: 3.2 Sample Parameters
it: 3.2 I parametri dei campioni

en: Sample Parameters: Amp and Pan
it: I parametri dei campioni: Amp e 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:`.
it: Come abbiamo visto con i sintetizzatori, possiamo facilmente controllare i nostri suoni con i parametri. I campioni supportano esattamente lo stesso meccanismo di parametrizzazione. Torniamo dai nostri amici `amp:` e `pan:`.

en: Amping samples
it: Regolare l’ampiezza dei campioni

en: You can change the amplitude of samples with exactly the same approach you used for synths:
it: Puoi cambiare l’ampiezza dei campioni con lo stesso sistema che hai usato per i synth:

en: Panning samples
it: Il panning dei campioni

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:
it: Sui campioni possiamo usare anche il parametro `pan:`. Per esempio, ecco come faremmo per suonare un loop di batteria due volte passando dall’orecchio sinistro al destro:

en: Note that 0.877 is half the duration of the `:loop_amen` sample in seconds.
it: Osserva che 0.877 è metà della durata in secondi del campione `:loop_amen`.

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`.
it: Ricorda infine che, se imposti alcuni parametri di default dei synth con `use_synth_defaults` (di cui parleremo più in là), questi saranno ignorati dall’istruzione `sample`.

en: 3.3 Stretching Samples
it: 3.3 Stretching dei campioni

en: Stretching Samples
it: Stretching dei campioni

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.
it: Finora abbiamo imparato a suonare una varietà di synth e campioni per fare un po’ di musica. È tempo di imparare a modificare sia i synth che i campioni per rendere la musica ancora più originale e interessante. Prima di tutto, esploriamo la capacità di Sonic Pi di *stirare* (in inglese, *stretch*) e *schiacciare* i suoni.

en: Sample Representation
it: Rappresentazione dei campioni

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.
it: I campioni sono suoni pre-registrati immagazzinati come dati numerici che rappresentano come muovere il cono dell’altoparlante per riprodurre il suono. Il cono dell’altoparlante può muoversi in dentro e in fuori, quindi i numeri devono rappresentare lo stato (cioè quanto in dentro o quanto in fuori) in cui si deve trovare il cono dell’altoparlante in ogni istante. Per riprodurre fedelmente un suono registrato, un campione ha bisogno tipicamente di alcune migliaia di numeri al secondo! Sonic Pi prende questa lista di numeri e li riproduce alla velocità opportuna per creare il movimento in dentro e in fuori della membrana degli altoparlanti del computer, esattamente nel modo richiesto per riprodurre quel dato suono. Ma è divertente anche cambiare la velocità con cui i numeri sono inviati agli altoparlanti, in modo da cambiare anche il suono.

en: Changing Rate
it: Cambiare la velocità

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`:
it: Proviamo a suonare uno dei nostri suoni *ambient*: `:ambi_choir`. Per suonarlo alla velocità di default, puoi passare un argomento `rate:` all’istruzione `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`:
it: Questa istruzione fa suonare il campione a velocità normale (1), e per il momento non succede niente di speciale. Ma siamo liberi di cambiare quel numero in qualcos’altro. Proviamo con `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.
it: Forte! Che cosa sta succedendo? Essenzialmente due cose. Primo, il campione ci mette il doppio a suonare; secondo, il suono è un’ottava sotto. Esploriamo la cosa nel dettaglio.

en: Let's stretch
it: Stretchiamo

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:
it: Un campione divertente da stirare e comprimere è il loop di batteria *Amen Break*. A velocità normale, potremmo immaginare di buttarlo dentro una traccia *drum’n bass*:

en: However by changing the rate we can switch up genres. Try half speed for *old school hip-hop*:
it: Ma, cambiando la velocità, ecco che possiamo anche cambiare genere. Proviamo a mezza velocità per un *hip-hop* vintage:

en: If we speed it up, we enter *jungle* territory:
it: Se aumentiamo la velocità, entriamo nel territorio del *jungle*:

en: Now for our final party trick - let's see what happens if we use a negative rate:
it: Adesso, come ultimo effetto a sorpresa, vediamo che succede se usiamo una velocità negativa:

en: A Simple Explanation of Sample Rate
it: Una semplice spiegazione della velocità di lettura del campione

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.
it: Un modo utile di pensare i campioni è pensarli come molle. La velocità di lettura corrisponde a comprimere e distendere la molla. Se suoni con una velocità 2, stai *comprimento la molla* a metà della sua lunghezza normale, quindi il campione dura circa metà del tempo, essendo più corto. Se invece suoni il campione a metà velocità, stai *distendendo la molla* fino a raddoppiarne la lunghezza; di conseguenza il campione dura due volte il tempo normale, essendo più lungo. Più comprimi (velocità maggiori), più corto diventa il suono; più distendi (velocità più basse) più il suono diventa lungo.

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*.
it: Comprimere la molla ne aumenta la densità (numero di giri della molla per centimetro) analogamente al campione che suona *più acuto*. Allungare la molla fa diminuire la densità, analogamente al campione che suona *più grave*.

en: The Maths Behind Sample Rate
it: La matematica della velocità di lettura del campione

en: (This section is provided for those that are interested in the details. Please feel free to skip it...)
it: (Questa parte è per quelli che sono interessati ai dettagli. Sentitevi liberi di saltarla…)

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:
it: Come abbiamo visto, un campione è rappresentato da una lunga lista di numeri che rappresentano come la membrana dell’altoparlante deve muoversi nel tempo. Possiamo usare questa lista di numeri per tracciare un grafico simile a questo:

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.
it: Potreste aver già visto immagini come questa prima d’ora. Si tratta della *forma d’onda* del campione. È semplicemente un grafico dei numeri. Tipicamente, una forma d’onda come questa avrà 44100 punti per ogni secondo (ciò è una conseguenza del teorema del campionamento di Nyquist-Shannon). Così, se il campione dura 2 secondi, la forma d’onda sarà rappresentata da 88200 numeri che vengono inviati all’altoparlante, opportunamente convertiti in segnale elettrico, alla velocità di 44100 numeri al secondo. Potremmo naturalmente farlo a frequenza doppia (88200 numeri al secondo), e ci vorrebbe solo un secondo per suonarli tutti. Potremmo anche dimezzare la frequenza a 22050 numeri al secondo, e in quel caso ci vorrebbero 4 secondi per suonare tutta la lista di numeri.

en: The duration of the sample is affected by the playback rate:
it: La durata di un campione dipende dalla velocità di lettura del dato digitale:

en: Doubling the playback rate halves the playback time,
it: Raddoppiare la velocità dimezza la durata,

en: Halving the playback rate doubles the playback time,
it: Dimezzare la velocità raddoppia la durata,

en: Using a playback rate of one fourth quadruples the playback time,
it: Usare una velocità di lettura di un quarto quadruplica la durata,

en: Using a playback rate of 1/10 makes playback last 10 times longer.
it: Usare una velocità di 1/10 rende la durata 10 volte più lunga.

en: We can represent this with the formula:
it: Possiamo rappresentare questo concetto con la seguente formula:

en: new_sample_duration = (1 / rate) * sample_duration
it: nuova_durata_campione = (1 / velocità) * durata_del_campione

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.
it: Cambiare la velocità di lettura influisce anche sul pitch del campione. La frequenza, o pitch di una forma d’onda, è determinata da quanto velocemente essa oscilla. Il nostro cervello interpreta un’oscillazione veloce come note acute e un’oscillazione lenta come note gravi. Ecco perché a volte puoi perfino veder muovere il cono di un grosso altoparlante che emette frequenze molto basse: in effetti, sta effettuando il suo movimento in dentro e in fuori a una velocità molto più bassa di quella di un altoparlante che produce note acute.

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.
it: Se prendi una forma d’onda e la comprimi, quella oscillerà un numero maggiore di volte al secondo. Ciò renderà il suono più acuto. Comprendiamo allora che raddoppiare il numero di oscillazioni raddoppia la frequenza. Così, *suonare il tuo campione a velocità doppia raddoppia la frequenza che ascolti*. E *dimezzare la velocità dimezza la frequenza*. Diverse variazioni di velocità influiranno sulla frequenza in proporzione.

en: 3.4 Enveloped Samples
it: 3.4 Inviluppo dei campioni

en: Enveloped Samples
it: Inviluppo dei campioni

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.
it: È possibile anche modificare la *durata* e l’*ampiezza* di un campione adoperando un inviluppo ADSR. Questo funziona però in modo lievemente differente dall’ADSR disponibile nei synth. Gli inviluppi dei campioni ti permettono soltanto di ridurre l’ampiezza e la durata di un campione, ma mai di aumentarle. Il campione si fermerà o quando sarà stato suonato tutto oppure quando sarà completato l’inviluppo, quale delle due cose accada per prima. Quindi, anche se usi un tempo di rilascio (`release:`) molto lungo, non per questo aumenterai la durata del campione.

en: Amen Envelopes
it: Inviluppo del campione Amen

en: Let's return to our trusty friend the Amen Break:
it: Torniamo al nostro amico fidato, il loop di batteria Amen:

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:
it: Senza parametri, ascoltiamo il campione intero ad ampiezza piena. Se vogliamo creare un *fade-in* (dissolvenza in entrata) di 1 secondo, possiamo usare il parametro `attack:` (tempo di attacco):

en: For a shorter fade in, choose a shorter attack value:
it: Per un fade-in più corto, impostiamo un tempo di attacco più corto:

en: Auto Sustain
it: Auto sustain

en: Where the ADSR envelope's behaviour differs from the standard synth envelope is in the *sustain* value. In the standard synth envelope, the sustain defaulted to 0 unless you set it manually. With samples, the sustain value defaults to an *automagical* value - the time left to play the rest of the sample. This is why we hear the full sample when we pass no defaults. If the attack, decay, sustain and release values were all 0 we'd never hear a peep. Sonic Pi therefore calculates how long the sample is, deducts any attack, decay and release times and uses the result as your sustain time. If the attack, decay and release values add up to more than the duration of the sample, the sustain is simply set to 0.
it: La fase dell’inviluppo in cui il comportamento dell’ADSR differisce, per i campioni, da quello standard dei synth, è il tempo di `sustain:` (sostegno). Negli inviluppi standard dei synth, esso è impostato di default su 0 a meno che non venga impostato manualmente su un valore diverso. Con i campioni, il sustain si imposta su un valore *automagico*, cioè il tempo necessario ad eseguire il resto del campione. Ecco perché sentiamo l’intero campione quando non impostiamo alcun valore. Se attacco, decadimento, sostegno e rilascio fossero tutti impostati su 0, non sentiremmo un bel niente. Sonic Pi calcola perciò la lunghezza del campione, ne sottrae eventuali tempi di attacco, decadimento e rilascio, e usa il risultato come tempo di sostegno. Se attacco, decadimento e rilascio sommati durano più della durata effettiva del campione, il sustain è lasciato, semplicemente, a 0.

en: Fade Outs
it: Fade out (dissolvenza in uscita)

en: To explore this, let's consider our Amen break in more detail. If we ask Sonic Pi how long the sample is:
it: Per esaminare questo aspetto, consideriamo il nostro loop Amen più in dettaglio. Se chiediamo a Sonic Pi quanto dura il campione:

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:
it: lui stamperà `1.753310657596372`, che è la lunghezza del campione in secondi. Per comodità, arrotondiamolo a `1.75`. Adesso, se impostiamo il rilascio a `0.75`, ecco cosa accade:

en: It will play the first second of the sample at full amplitude before then fading out over a period of 0.75 seconds. This is the *auto sustain* in action. By default, the release always works from the end of the sample. If our sample was 10.75 seconds long, it would play the first 10 seconds at full amplitude before fading out over 0.75s.
it: Suonerà il primo secondo del campione ad ampiezza piena prima di dissolvere in un tempo di 0.75 secondi. Ecco l’*autosustain* in azione. Di default, il rilascio funziona sempre contando a ritroso dalla fine del campione. Se il nostro campione fosse di 10.75 secondi, suonerebbe i primi 10 secondi ad ampiezza piena prima di dissolvere in 0.75 secondi.

en: Remember: by default, `release:` fades out at the end of a sample.
it: Ricorda: di default il tempo di rilascio va contato dalla fine del campione.

en: Fade In and Out
it: Fade in e fade out (dissolvenza in entrata e in uscita)

en: We can use both `attack:` and `release:` together with the auto sustain behaviour to fade both in and out over the duration of the sample:
it: Possiamo usare insieme sia `attack:` che `release:` con l’autosustain per avere sia il fade in che il fade out sulla durata del campione:

en: As the full duration of the sample is 1.75s and our attack and release phases add up to 1.5s, the sustain is automatically set to 0.25s. This allows us to easily fade the sample in and out.
it: Dal momento che la durata completa del campione è 1.75 secondi e i nostri tempi di attacco e rilascio durano complessivamente 1.5 secondi, il sustain è impostato automaticamente a 0.25 secondi. Ciò permette di applicare le dissolvenze al campione con grande facilità.

en: Explicit sustain
it: Sustain esplicito

en: We can easily get back to our normal synth ADSR behaviour by manually setting `sustain:` to a value such as 0:
it: Possiamo benissimo tornare al comportamento normale dell’ADSR dei synth impostando `sustain:` manualmente su un valore, ad esempio 0:

en: Now, our sample only plays for 0.75 seconds in total. With the default for `attack:` and `decay:` at 0, the sample jumps straight to full amplitude, sustains there for 0s then releases back down to 0 amplitude over the release period - 0.75s.
it: Adesso il nostro campione suona per soli 0.75 secondi totali. Con il valore di default 0 per `attack:` e `decay:`, il campione va immediatamente alla massima ampiezza, tiene il suono per...0 secondi e poi se ne va ad ampiezza 0 con un tempo di rilascio di 0.75 secondi.

en: Percussive cymbals
it: Piatti... percussivi

en: We can use this behaviour to good effect to turn longer sounding samples into shorter, more percussive versions. Consider the sample `:drum_cymbal_open`:
it: Possiamo servirci di questo comportamento come effetto per trasformare campioni lunghi in versioni corte e più percussive dello stesso campione. Consideriamo il campione `:drum_cymbal_open`:

en: You can hear the cymbal sound ringing out over a period of time. However, we can use our envelope to make it more percussive:
it: Puoi sentire il suono del piatto riusuonare per un certo tempo. Tuttavia, possiamo usare il nostro inviluppo per rendere il suono più percussivo:

en: You can then emulate hitting the cymbal and then dampening it by increasing the sustain period:
it: Puoi emulare il colpo di piatto e il successivo smorzamento aumentando il tempo di sostegno:

en: Now go and have fun putting envelopes over the samples. Try changing the rate too for really interesting results.
it: E adesso divertiti ad applicare gli inviluppi ai campioni. Prova a cambiare anche la velocità di lettura per risultati davvero interessanti.

en: 3.5 Partial Samples
it: 3.5 Esecuzione parziale dei campioni

en: Partial Samples
it: Esecuzione parziale dei campioni

en: This section will conclude our exploration of Sonic Pi's sample player. Let's do a quick recap. So far we've looked at how we can trigger samples:
it: Con questa sezione si conclude la nostra esplorazione su come Sonic Pi gestisce i campioni audio. Facciamo un breve riassunto. Finora abbiamo visto come avviare l’esecuzione di un campione:

en: We then looked at how we can change the rate of samples such as playing them at half speed:
it: Quindi abbiamo visto come cambiare la velocità di lettura dei campioni in modo da farli suonare a velocità dimezzata:

en: Next, we looked at how we could fade a sample in (let's do it at half speed):
it: Abbiamo visto come inserire un fade-in all’inizio del campione (ora facciamolo a velocità dimezzata):

en: We also looked at how we could use the start of a sample percussively by giving `sustain:` an explicit value and setting both the attack and release to be short values:
it: Abbiamo visto anche come dare al campione un attacco percussivo dando un valore di `sustain:` esplicito (zero) e impostando attacco e rilascio su valori molto corti:

en: However, wouldn't it be nice if we didn't have to always start at the beginning of the sample? Wouldn't it also be nice if we didn't have to always finish at the end of the sample?
it: Ma non sarebbe bello se non dovessimo suonare il campione sempre dall’inizio? E non sarebbe altrettanto bello non doverlo suonare sempre fino alla fine?

en: Choosing a starting point
it: Scegliere il punto d’inizio

en: It is possible to choose an arbitrary starting point in the sample as a value between 0 and 1 where 0 is the start of the sample, 1 is the end and 0.5 is half way through the sample. Let's try playing only the last half of the amen break:
it: È possibile scegliere un punto d’inizio a piacere nell’esecuzione del campione come valore associato al parametro `start:` compreso tra 0 e 1, dove 0 corrisponde all’inizio del campione, 1 alla fine e 0.5 esattamente a metà. Proviamo a suonare soltanto la seconda metà del nostro solito loop di batteria:

en: How about the last quarter of the sample:
it: Ed ecco l’ultimo quarto soltanto:

en: Choosing a finish point
it: Scegliere il punto finale

en: Similarly, it is possible to choose an arbitrary finish point in the sample as a value between 0 and 1. Let's finish the amen break half way through:
it: In modo simile è possibile scegliere a piacere un punto finale all’interno del campione impostando un valore tra 0 e 1 per il parametro `finish:`. Eseguiamo il loop di batteria fino a metà campione:

en: Specifying start and finish
it: Specificare un punto d’inizio e un punto finale

en: Of course, we can combine these two to play arbitrary segments of the audio file. How about only a small section in the middle:
it: È possibile, naturalmente, combinare queste due istruzioni per eseguire a piacere un frammento del file audio. Ecco come eseguire una piccola porzione al centro del file:

en: What happens if we choose a start position after the finish position?
it: Ma cosa succede se scegliamo un punto d’inizio collocato dopo il punto finale?

en: Cool! It plays it backwards!
it: Forte! Suona all’indietro!

en: Combining with rate
it: Combinare velocità di lettura ed esecuzione parziale del campione

en: We can combine this new ability to play arbitrary segments of audio with our friend `rate:`. For example, we can play a very small section of the middle of the amen break very slowly:
it: Possiamo combinare questa nuova possibilità di suonare frammenti a scelta di un file audio con la nostra vecchia conoscenza `rate:`, la velocità di lettura. Possiamo ad esempio eseguire un frammento brevissimo del loop di batteria ad una velocità molto bassa:

en: Combining with envelopes
it: Combinare inviluppi ed esecuzione parziale del campione

en: Finally, we can combine all of this with our ADSR envelopes to produce interesting results:
it: Possiamo infine combinare tutto questo con gli inviluppi ADSR per ottenere risultati interessanti:

en: Now go and have a play mashing up samples with all of this fun stuff...
it: E ora sbizzarriamoci a creare mix di campioni manipolati in tutti questi fantastici modi...

en: 3.6 External Samples
it: 3.6 Campioni esterni

en: External Samples
it: Campioni esterni

en: Whilst the built-in samples can get you up and started quickly, you might wish to experiment with other recorded sounds in your music. Sonic Pi totally supports this. First though, let's have a quick discussion on the portability of your piece.
it: Con i campioni compresi in Sonic Pi puoi cominciare a lavorare subito. Tuttavia, arriverai a voler sperimentare inserendo altri suoni registrati nella tua musica. Prima però discutiamo brevemente sulla portabilità del tuo pezzo.

en: Portability
it: Portabilità

en: When you compose your piece purely with built-in synths and samples, the code is all you need to faithfully reproduce your music. Think about that for a moment - that's amazing! A simple piece of text you can email around or stick in a [Gist](https://gist.github.com) represents everything you need to reproduce your sounds. That makes it *really easy to share* with your friends as they just need to get hold of the code.
it: Quando componi un pezzo soltanto con i synth e i campioni compresi in Sonic Pi, tutto ciò di cui hai bisogno per riprodurre fedelmente la tua musica è il codice. Pensaci un attimo - è straordinario! Un semplice frammento di testo che puoi inviare per email o depositare in un \[Gist\] (https://gist.github.com) è tutto quello che ti serve per riprodurre i tuoi suoni. Ciò rende *davvero facile condividerli* con i tuoi amici, perché tutto quello di cui anche loro hanno bisogno è il codice.

en: However, if you start using your own pre-recorded samples, you lose this portability. This is because to reproduce your music other people not only need your code, they need your samples too. This limits the ability for others to manipulate, mash-up and experiment with your work. Of course this shouldn't stop you from using your own samples, it's just something to consider.
it: Tuttavia, se cominci ad usare campioni tuoi, perdi la portabilità. Questo perché, per riprodurre la tua musica, le altre persona non hanno bisogno soltanto del codice, ma anche dei campioni. Ciò limita la possibilità per gli altri di manipolare, creare mix e sperimentare con il tuo lavoro. Naturalmente questo non deve impedirti di usare suoni tuoi: è solo un fatto da tenere in considerazione.

en: Local Samples
it: Campioni locali

en: Sonic Pi will automatically load and play the sample. You can also pass all the standard params you're used to passing `sample`:
it: In questo modo Sonic Pi carica automaticamente il campione e lo suona. A quel punto puoi passare tutti i parametri standard che hai usato finora con `sample`:

en: 3.7 Sample Packs
it: 3.7 Pacchetti di sample

en: Sample Packs
it: Pacchetti di sample

en: **Note: this section of the tutorial covers the advanced topic of working with large directories of your own samples. This will be the case if you've downloaded or bought your own sample packs and wish to use them within Sonic Pi.**
it: **Nota: questa sezione del tutorial copre argomenti avanzati e spiega come lavorare con directory contenenti molti sample. Questo, ad esempio, può accadere se hai scaricato o comprato dei sample pack e vuoi utilizzarli con Sonic Pi.**

en: **Feel free to skip this if you're happy working with the built-in samples.**
it: **Sentiti libero di saltare questa sezione se i campioni già presenti in Sonic Pi ti sono sufficienti.**

en: When working with large folders of external samples it can be cumbersome to have to type the whole path every time to trigger an individual sample.
it: Quando lavori con cartelle piene di file esterni, può essere scomodo digitare l'intero percorso ogni volta che vuoi lanciare un singolo campione.

en: For example, say you have the following folder on your machine:
it: Per esempio, facciamo finta che tu abbia questa cartella sul tuo computer:

en: When we look inside that folder we find the following samples:
it: Quando guardiamo all'interno di quella cartella, troviamo i seguenti campioni:

en: Typically in order to play the piano sample we can use the full path:
it: Di solito, per suonare i campioni di pianoforte dovremmo usare il percorso completo:

en: If we want to then play the guitar sample we can use its full path too:
it: Se volessimo usare anche i campioni di chitarra, anche in questo caso dovremmo usare il percorso completo:

en: However, both of these calls to sample requires us to *know* the names of the samples within our directory. What if we just want to listen to each sample in turn quickly?
it: Purtroppo, per caricare questi campioni è necessario *conoscere* i nomi dei campioni all'interno della nostra cartella. E se volessimo ascoltare velocemente ciascun sample a turno?

en: Indexing Sample Packs
it: Indicizzare i pacchetti di campioni

en: If we want to play the first sample in a directory we just need to pass the directory's name to `sample` and the index `0` as follows:
it: Se vogliamo suonare il primo campione in una cartella, dobbiamo semplicemente passare il nome della cartella al comando `sample`e l'indice `0` in questo modo:

en: We can even make a shortcut to our directory path using a variable:
it: Se vogliamo, possiamo anche creare una scorciatoia per la nostra cartella utilizzando una variabile:

en: Now, if we want to play the second sample in our directory, we just need to add 1 to our index:
it: Ora, se vogliamo suonare il secondo sample nella directory, dobbiamo aggiungere 1 al nostro indice:

en: Notice that we no longer need to know the names of the samples in the directory - we just need to know the directory itself (or have a shortcut to it). If we ask for an index which is larger than the number of samples, it simply wraps round just like Rings. Therefore, whatever number we use we're guaranteed to get one of the samples in that directory.
it: Puoi notare come non sia più necessario conoscere i nomi dei campioni nella cartella, dobbiamo solo conoscere la posizione della cartella stessa (o avere una scorciatoia). Se proviamo a utilizzare un indice maggiore del numero dei campioni, ripartirà semplicemente da capo come nei Rings. Per cui, indipendentemente dal numero usato, abbiamo la sicurezza che verrà utilizzato un campione in quella cartella.

en: Filtering Sample Packs
it: Filtrare i pacchetti di campioni

en: Usually indexing is enough, but sometimes we need more power to sort and organise our samples. Luckily many sample packs add useful information in the filenames. Let's take another look at the sample file names in our directory:
it: Di solito è sufficiente indicizzare, ma qualche volta abbiamo bisogno di maggiore potenza per organizzare i nostri campioni. Per fortuna molti pacchetti di campioni aggiungono informazioni nei nomi dei file. Diamo ancora un'occhiata ai campioni nella nostra cartella:

en: Notice that in these filenames we have quite a bit of information. Firstly, we have the BPM of the sample (beats per minute) at the start. So, the piano sample is at 120 BPM and our first three melodies are at 100 BPM. Also, our sample names contain the key. So the guitar sample is in Bb and the melodies are in A#. This information is very useful for mixing in these samples with our other code. For example, we know we can only play the piano sample with code that's in 120 BPM and in the key of Bb.
it: Puoi notare come i nomi dei file hanno molte informazioni. Per iniziare abbiamo il BPM del sample (beat per minuto) all'inizio del nome. PEr cui se il campione del pianoforte è a 120BPM mentre le nostre tre melodie sono a 100BPM. In aggiunta, il nome dei campioni contiene anche la tonalità: il campione di chitarra è in Bb (Si bemolle) e le melodie in A# (La diesis). Questa informazione è molto utile per mixare questi sample con il nostro codice. Per esempio, sappiamo che possiamo suonare il campione del piano se il nostro codice è a 120BPM e in tonalità di Bb.

en: It turns out that we can use this particular naming convention of our sample sets in the code to help us filter out the ones we want. For example, if we're working at 120 BPM, we can filter down to all the samples that contain the string `"120"` with the following:
it: È possibile usare questa convenzione sui nomi dei file del nostro set di campioni nel codice per aiutarci a filtrare quelli che vogliamo. Per esempio, se stiamo lavorando a 120BPM, possiamo visualizzare tutti i campioni che contengono la stringa `"120"` come segue:

en: This will play us the first match. If we want the second match we just need to use the index:
it: Questo farà suonare il primo risultato. Se volessimo il secondo, possiamo usare l'indice:

en: Finally, we're still free to add our usual opts to the call to `sample`:
it: Infine, possiamo sentirci liberi di usare i parametri di `sample` che abbiamo già visto:

en: Sources
it: Fonti

en: For example, take a look at the following code:
it: Per esempio, diamo un'occhiata a questo codice:

en: Here, we're combining the contents of the samples within two directories and adding a specific sample. If `"/path/to/my/samples/"` contained 3 samples and `"/path/to/my/samples2/"` contained 12, we'd have 16 potential samples to index and filter (3 + 12 + 1).
it: In questo caso stiamo combinando il contenuto dei campioni all'interno di due cartelle e aggiungendo un campione specifico. Se `"/path/to/my/samples/"` contiene 3 campioni e `"/path/to/my/samples2/"` ne contiene 12, abbiamo 16 potenziali campioni da indicizzare e filtrare (3 + 12 + 1).

en: By default, only the sample files within a directory are gathered into the candidate list. Sometimes you might have a number of nested folders of samples you wish to search and filter within. You can therefore do a recursive search for all samples within all subfolders of a particular folder by adding `**` to the end of the path:
it: Per impostazione predefinita, sono inclusi nella lista dei candidati solo i campioni contenuti in una cartella. E' possibile talvolta che in una serie di cartelle di campioni annidate, si voglia eseguire una ricerca e applicarvi dei filtraggi. Pertanto, è possibile eseguire una ricerca ricorsiva per tutti i campioni contenuti in ogni sottocartella di una data cartella aggiungendo `**` alla fine del percorso:

en: Take care though as searching through a very large set of folders may take a long time. However, the contents of all folder sources are cached, so the delay will only happen the first time.
it: Fai attenzione quindi, perché la ricerca all'interno di un gruppo di cartelle ampio può impegare parecchio tempo ad essere portata a termine. Comunque, il contenuto di tutte le cartelle sorgenti sono memorizzati nella cache, quindi soltanto la prima volta la ricerca impiegherà più tempo.

en: Finally, note that the sources *must go first*. If no source is given, then the set of built-in samples will be selected as the default list of candidates to work with.
it: Infine, tieni presente che la sorgente *deve essere inserita prima*. Ne nessuna sorgente viene indicata, allora il gruppo di campioni già presenti nel sistema verrà selezionato automaticamente per la sessione.

en: Filters
it: Filtri

en: Once you have a list of candidates you may use the following filtering types to further reduce the selection:
it: Quando avrai ottenuto una lista di campioni da usare durante la sessione, puoi quindi utilizzare le seguenti chiavi per ridurne ulteriormente il numero:

en: `"foo"` Strings will filter on substring occurrence within file name (minus directory path and extension).
it: La stringa `"foo"` filtrerà le occorrenze all'interno del nome del file (cartella di percorso ed estensione escluse).

en: `/fo[oO]/` Regular Expressions will filter on pattern matching of file name (minus directory path and extension).
it: L'espressione regolare `/fo[oO]/` filtrerà il pattern riconosciuto nel nome del file (cartella di percorso ed estensione esclusi).

en: `:foo` - Keywords will filter candidates on whether the keyword is a direct match of the filename (minus directory path and extension).
it: La parola chiave `:foo` filtrerà i vari file candidati se la parola chiave avrà riscontro diretto nel nome del file (cartella di percorso ed estensione esclusi).

en: `lambda{|a| ... }` - Procs with one argument will be treated as a candidate filter or generator function. It will be passed the list of current candidates and must return a new list of candidates (a list of valid paths to sample files).
it: I Procs `lambda{|a| ... }` (ndT: in Ruby i Procs sono blocchi di codice legati a variabili locali) con un argomento saranno trattati come filtri o funzioni di generazione. La lista dei file correnti candidati deve essere passata all'oggetto che restituirà una nuova lista di candidati (una lista di percorsi validi ai file).

en: `1` - Numbers will select the candidate with that index (wrapping round like a ring if necessary).
it: I numeri `1` selezioneranno il file candidato a quell'indice (ripartendo dall'inizio se necessario).

en: For example, we can filter over all the samples in a directory containing the string `"foo"` and play the first matching sample at half speed:
it: Per esempio, possiamo filtrare tutti i campioni in una cartella che contengono la stringa `"foo"` e riproduttre il primo risultato a metà della velocità:

en: See the help for `sample` for many detailed usage examples. Note that the ordering of the filters is honoured.
it: Vedi il capitolo relativo ai `sample` nel manuale per altri esempi di utilizzo. Attenzione: verrà rispettato l'ordine dei filtri.

en: Composites
it: Compositi

en: Finally, you may use lists wherever you may place a source or filter. The list will be automatically flattened and the contents will be treated as regular sources and filters. Therefore the following calls to `sample` are semantically equivalent:
it: Infine, puoi usare delle liste sia al posto delle fonti che dei filtri. Le liste saranno automaticamente appiattite e il loro contenuto sarà trattato come una fonte o un filtro. Per questo motivo, i seguenti esempi su `sample` sono equivalenti a livello semantico:

en: Wrapping Up
it: Conclusione

en: This was an advanced section for people that need real power to manipulate and use sample packs. If most of this section didn't make too much sense, don't worry. It's likely you don't need any of this functionality just yet. However, you'll know when you do need it and you can come back and re-read this when you start working with large directories of samples.
it: Questa era una sezione per coloro che hanno bisogno di manipolare e usare i pacchetti di campioni in modo avanzato. Se per te questa sezione non aveva alcun senso, non ti preoccupare. Probabilmente non hai ancora bisogno di utilizzare queste funzionalità. In ogni caso ora sai dove si trova questa sezione e potrai tornare indietro a rileggerla quando ne avrai bisogno.

en: 4 Randomisation
it: 4 Randomizzazione

en: Randomisation
it: Randomizzazione

en: A great way to add some interest into your music is using some random numbers. Sonic Pi has some great functionality for adding randomness to your music, but before we start we need to learn a shocking truth: in Sonic Pi *random is not truly random*. What on earth does this mean? Well, let's see.
it: Un modo molto efficace per rendere interessante la tua musica è utilizzare numeri casuali. Sonic Pi ha delle funzioni che ti permettono di introdurre un po' di casualità all'interno della tua musica ma, prima di cominciare, dovete conoscere un'importante verità: in Sonic Pi i numeri casuali non sono *veramente casuali*. Che significa? Vediamo insieme.

en: Repeatability
it: Ripetibilità

en: A really useful random function is `rrand` which will give you a random value between two numbers - a *min* and a *max*. (`rrand` is short for ranged random). Let's try playing a random note:
it: Una delle funzioni per avere numeri casuali è `rrand` che restituisce un valore compreso tra due numeri, un *minimo* e un *massimo*. (`rrand` è l'abbreviazione di ranged random, ovvero una casualità tra una serie di valori). Proviamo a suonare una nota casuale:

en: Ooh, it played a random note. It played note `83.7527`. A nice random note between 50 and 95. Woah, wait, did I just predict the exact random note you got too? Something fishy is going on here. Try running the code again. What? It chose `83.7527` again? That can't be random!
it: Wow, abbiamo suonato una nota a caso. La nota suonata è `83.7527`. Un numero casuale tra 50 e 95. Ehi, un momento, ho appena predetto il valore esatto della nota casuale che hai suonato anche tu? Sta succedendo qualcosa di strano. Prova a eseguire nuovamente il codice. È uscito ancora `83.7527`? Non può essere casuale!

en: The answer is that it is not truly random, it's pseudo-random. Sonic Pi will give you random-like numbers in a repeatable manner. This is very useful for ensuring that the music you create on your machine sounds identical on everybody else's machine - even if you use some randomness in your composition.
it: La risposta è che non è realmente casuale, è pseudo-random. Sonic Pi restituirà sempre dei valori pseudo-casuali in un modo ripetibile. Questo è utile per essere sicuri che la musica create sulla nostra macchina suonerà identica su qualsiasi altro computer, anche utilizzando un po' di casualità nella nostra composizione.

en: Of course, in a given piece of music, if it 'randomly' chose `83.7527` every time, then it wouldn't be very interesting. However, it doesn't. Try the following:
it: Ovviamente, in un brano musicale, se venisse scelto in modo "casuale" sempre il valore `83.7527` non sarebbe interessante. Comunque non sempre restituirà quel risultato. Prova con il seguente codice:

en: Yes! It finally sounds random. Within a given *run* subsequent calls to random functions will return random values. However, the next run will produce exactly the same sequence of random values and sound exactly the same. It's as if all Sonic Pi code went back in time to exactly the same point every time the Run button was pressed. It's the Groundhog Day of music synthesis!
it: Evviva! Finalmente suona casuale. Se richiamiamo più volte la funzione random, otterremo in cambio valori davvero casuali. Ricorda comunque che al successivo avvio, otterremo la stessa sequenza di numeri casuali per cui suonerà esattamente nello stesso modo. È come se il codice scritto in Sonic Pi andasse indietro nel tempo tornando allo stesso punto di inizio ogni volta che premiamo il pulsante di avvio. È il giorno della marmotta nella sintesi musicale!

en: Haunted Bells
it: Campane stregate

en: A lovely illustration of randomisation in action is the haunted bells example which loops the `:perc_bell` sample with a random rate and sleep time between bell sounds:
it: Un bell'esempio dell'utilizzo di valori casuali è nel seguente codice, chiamato "Campane stregate" che esegue una ripetizione del campione `:perc_bell` con valori casuali di velocità (rate) e pausa (sleep) tra i vari suoni di campana:

en: Random cutoff
it: Cutoff (taglio di frequenze) casuale

en: Another fun example of randomisation is to modify the cutoff of a synth randomly. A great synth to try this out on is the `:tb303` emulator:
it: Un altro esempio sull'utilizzo di valori casuali può essere applicato al taglio di frequenze su un sintetizzatore. Un ottimo synth con cui provarlo è l'emulatore `:tb303`:

en: Random seeds
it: Semi casuali

en: So, what if you don't like this particular sequence of random numbers Sonic Pi provides? Well it's totally possible to choose a different starting point via `use_random_seed`. The default seed happens to be 0, so choose a different seed for a different random experience!
it: E se non ci piacesse la sequenza casuale generata da Sonic Pi? Ovviamente è possibile scegliere un punto di partenza diverso utilizzando `use_random_seed`. Il seme di default è 0; puoi utilizzare semi differenti per ottenere effetti casuali diversi!

en: Consider the following:
it: Prova con questo esempio:

en: Every time you run this code, you'll hear the same sequence of 5 notes. To get a different sequence simply change the seed:
it: Ogni volta che avvierai questo codice, sentirai la stessa sequenza di 5 note. Per avere una sequenza differente, proviamo a cambiare il seme:

en: This will produce a different sequence of 5 notes. By changing the seed and listening to the results you can find something that you like - and when you share it with others, they will hear exactly what you heard too.
it: Questo codice produrrà una sequenza di 5 note diversa dalla precedente. Cambiando il seme e ascoltando il risultato ottenuto possiamo trovare qualcosa che ci piace e quando lo condivideremo con altre persone, loro ascolteranno sempre la stessa identica cosa.

en: Let's have a look at some other useful random functions.
it: Allora, diamo un'occhiata ad alcune funzioni casuali.

en: choose
it: choose (scegli)

en: A very common thing to do is to choose an item randomly from a list of known items. For example, I may want to play one note from the following: 60, 65 or 72. I can achieve this with `choose` which lets me choose an item from a list. First, I need to put my numbers in a list which is done by wrapping them in square brackets and separating them with commas: `[60, 65, 72]`. Next I just need to pass them to `choose`:
it: Un'opzione molto utile è quella di scegliere in oggetto a caso da una lista di oggetti già conosciuti. Per esempio, potrei voler suonare una nota dal seguente elenco: 60, 65, 72. Posso ottenere questo risultato con la funzione 'choose' che mi permette di scegliere un oggetto da una lista. Prima di tutto, devo mettere i miei numeri in una lista che può essere creata inserendo i numeri all'interno di parentesi quadre, separati da virgole. Così: '[60,65,72]'. Successivamente, è sufficiente attivare la funzione 'choose':

en: Let's hear what that sounds like:
it: Ascoltiamo che cosa ne è venuto fuori:

en: rrand
it: rrand (Funzione random)

en: We've already seen `rrand`, but let's run over it again. It returns a random number between two values exclusively. That means it will never return either the top or bottom number - always something in between the two. The number will always be a float - meaning it's not a whole number but a fraction of a number. Examples of floats returned by `rrand(20, 110)`:
it: Abbiamo già visto la funzione 'rrand', ma proviamo a riavviarla di nuovo. Il risultato è un numero casuale contenuto all'interno di due valori. Questo significa che non otterremo mai il valore esatto dei due numeri estremi ma sempre numeri contenuti in questo intervallo. I numeri saranno sempre dei numeri decimali, ovvero non dei numeri interi ma piuttosto delle frazioni di un numero. Per esempio, proviamo a osservare i numeri che escono da: 'rrand(20,110)':

en: rrand_i
it: rrand_i (numeri interi casuali)

en: Occasionally you'll want a whole random number, not a float. This is where `rrand_i` comes to the rescue. It works similarly to `rrand` except it may return the min and max values as potential random values (which means it's inclusive rather than exclusive of the range). Examples of numbers returned by `rrand_i(20, 110)` are:
it: Può capitare di avere bisogno di un numero casuale che sia intero e non decimale. Qui entra in gioco la funzione `rrand_i`. Funziona in modo simile a `rrand` con la differenza che può restituire il valore minimo e massimo come possibili valori (si tratta, infatti, di una funzione inclusiva). Questi sono degli esempi di valori restituiti da `rrand_i(20, 110)`:

en: This will return a random float between 0 (inclusive) and the max value you specify (exclusive). By default it will return a value between 0 and one. It's therefore useful for choosing random `amp:` values:
it: Questa funzione restituirà un numero compreso tra 0 (incluso) e il valore massimo specificato (escluso). Di default restituirà un valore compreso tra 0 e 1. Ad esempio, può essere usata per scegliere un valore casuale per `amp:`:

en: Similar to the relationship between `rrand_i` and `rrand`, `rand_i` will return a random whole number between 0 and the max value you specify.
it: Dal momento che `rrand_i` e `rrand` si comportano in modo simile, `rand_i` restituirà un numero intero compreso tra 0 e il valore massimo specificato.

en: dice
it: dice (ndT: dado)

en: Sometimes you want to emulate a dice throw - this is a special case of `rrand_i` where the lower value is always 1. A call to `dice` requires you to specify the number of sides on the dice. A standard dice has 6 sides, so `dice(6)` will act very similarly - returning values of either 1, 2, 3, 4, 5, or 6. However, just like fantasy role-play games, you might find value in a 4 sided dice, or a 12 sided dice, or a 20 sided dice - perhaps even a 120 sided dice!
it: A volte vuoi simulare il lancio di un dato. Questo è un caso specifico della funzione `rrand_i` dove il valore più basso è sempre 1. Quando utilizziamo la funzione `dice` dobbiamo specificare il numero di facce del dado. Un dado comune ha 6 facce, quindi `dice(6)` può restituire i valori 1, 2, 3, 4, 5 oppure 6. Ciononostante, come avviene nei giochi di ruolo fantasy, può capitare di usare dadi a 4 facce, a 12, 20 oppure a 120!

en: Finally you may wish to emulate throwing the top score of a dice such as a 6 in a standard dice. `one_in` therefore returns true with a probability of one in the number of sides on the dice. Therefore `one_in(6)` will return true with a probability of 1 in 6 or false otherwise. True and false values are very useful for `if` statements which we will cover in a subsequent section of this tutorial.
it: Infine può capitare di voler simulare l'uscita del punteggio più alto di un dado (6, nel caso di un dado comune). La funzione `one_in` restituisce true con una probabilità di uno sul numero di facce del dado. Di conseguenza `one_in(6)` restituirà true con una probabilità di 1/6 e false negli altri casi. I valori true e false sono molto utili quando si utilizzano i costrutti `if` di cui parleremo più avanti.

en: Now, go and jumble up your code with some randomness!
it: È arrivato il momento di sperimentare un po' di casualità nel tuo codice!

en: 5 Programming Structures
it: 5 Strutture di programmazione

en: Programming Structures
it: Strutture di programmazione

en: Now that you've learned the basics of creating sounds with `play` and `sample` and creating simple melodies and rhythms by `sleep`ing between sounds, you might be wondering what else the world of code can offer you...
it: Adesso che hai imparato come creare i suoni attraverso l'uso delle funzioni 'play' e 'sample' e che hai creato semplici melodie e ritmi utilizzando la funzione 'sleep' combinata con le precedenti, ti starai chiedendo che cos'altro può offrirti il mondo della programmazione...

en: Well, you're in for an exciting treat! It turns out that basic programming structures such as looping, conditionals, functions and threads give you amazingly powerful tools to express your musical ideas.
it: Bene, ti aspetta qualcosa di davvero eccitante! Ci risulta che le strutture basilari della programmazione, come i concetti di loop, condizionali, funzioni e catene ti mettono in mano degli strumenti davvero potenti per esprimere le tue idee musicali.

en: Let's get stuck in with the basics...
it: Cominciamo a vedere come funzionano questi elementi di base...

en: 5.1 Blocks
it: 5.1 Blocchi

en: Blocks
it: Blocchi

en: A structure you'll see a lot in Sonic Pi is the block. Blocks allow us to do useful things with large chunks of code. For example, with synth and sample parameters we were able to change something that happened on a single line. However, sometimes we want to do something meaningful to a number of lines of code. For example, we may wish to loop it, to add reverb to it, to only run it 1 time out of 5, etc. Consider the following code:
it: Una struttura che vedrai molto spesso utilizzando Sonic Pi è il blocco. I blocchi ci permettono di fare delle cose molto utili con pezzi di codice notevolmente lunghi. Per esempio, abbiamo visto come con i parametri dei sintetizzatori e dei campioni eravamo in grado di cambiare qualcosa che accadeva soltanto all'interno di una singola linea di programma. Però a volte potremmo voler fare qualcosa che abbia effetto su diverse linee di programma e non una sola. Per esempio, potremmo volerle mettere in loop, aggiungerci un riverbero, avviarlo soltanto una volta ogni cinque cicli e così via. Prendi in considerazione il codice che segue:

en: To do something with a chunk of code, we need to tell Sonic Pi where the code block *starts* and where it *ends*. We use `do` for start and `end` for end. For example:
it: Per fare qualcosa con un pezzo di codice, dobbiamo dire a Sonic Pi dove il blocco inizia e finisce. Per indicare l'inizio, il linguaggio di Sonic Pi utilizza il termine 'do' mentre per indicare la fine utilizza il termine 'end'. Per esempio:

en: However, this isn't yet complete and won't work (try it and you'll get an error) as we haven't told Sonic Pi what we want to do with this *do/end block*. We tell Sonic Pi this by writing some special code before the `do`. We'll see a number of these special pieces of code later on in this tutorial. For now, it's important to know that wrapping your code within `do` and `end` tells Sonic Pi you wish to do something special with that chunk of code.
it: Tuttavia, questo ancora non è completo e infatti non è funzionante (prova tu stesso/a ad avviarlo e otterrai un errore). Infatti non abbiamo detto a Sonic Pi cosa deve fare con il blocco in questione. Dobbiamo indicare l'azione da compiere scrivendo un codice particolare dopo il 'do'. Vedremo una serie di esempi in seguito, all'interno di questa guida. Per il momento è importante sapere che avvolgendo il codice all'interno di 'do' e 'end' comunichi a Sonic Pi la tua intenzione di fare qualcosa di particolare con quelle linee di codice.

en: 5.2 Iteration and Loops
it: 5.2 Iterazioni e anelli

en: Iteration and Loops
it: Iterazioni e anelli

en: So far we've spent a lot of time looking at the different sounds you can make with `play` and `sample` blocks. We've also learned how to trigger these sounds through time using `sleep`.
it: Fino a questo momento, abbiamo passato molto tempo a spiegare i differenti suoni che puoi ottenere utilizzando le funzioni 'play' e 'sample'. Hai anche imparato come scansionare il tempo tra i suoni attraverso la funzione 'sleep'.

en: As you've probably found out, there's a *lot* of fun you can have with these basic building blocks. However, a whole new dimension of fun opens up when you start using the power of code to structure your music and compositions. In the next few sections we'll explore some of these powerful new tools. First up is iteration and loops.
it: Come avrai probabilmente scoperto, puoi divertirti un sacco con questi blocchi basilari. Tuttavia, quando comincerai a utilizzare il potere del codice per strutturare le tue composizioni e la tua musica, tutta una nuova dimensione di divertimento ti si aprirà davanti. Nelle prossime sezioni, illustreremo alcuni di questi potenti strumenti. I primi saranno le iterazioni e gli anelli.

en: Repetition
it: Ripetizione

en: Have you written some code you'd like to repeat a few times? For example, you might have something like this:
it: Hai mai scritto una stringa di codice che ti piacerebbe ripetere alcune volte? Per esempio, qualcosa tipo:

en: What if we wished to repeat this 3 times? Well, we could do something simple and just copy and paste it three times:
it: Che cosa dobbiamo fare se vogliamo ripetere questo codice tre volte? Bene, potremmo semplicemente copiarlo e incollarlo per tre volte di seguito:

en: Now that's a lot of code! What happens if you want to change the sample to `:elec_plip`? You're going to have to find all the places with the original `:elec_blup` and switch them over. More importantly, what if you wanted to repeat the original piece of code 50 times or 1000? Now that would be a lot of code, and a lot of lines of code to alter if you wanted to make a change.
it: Certo che è proprio un codice lunghissimo! Che cosa accadrebbe se tu volessi cambiare il campione indicato con 'elec_plip'? Dovresti trovare tutti i punti in cui è menzionato l'originale, cioè 'elec_blup', e cambiarlo. Ma ancora peggio, che cosa accadrebbe se tu volessi ripetere il codice originale per 50 o adirittura 1000 volte? A questo punto avresti un codice enorme, con un sacco di linee da variare se tu volessi effettuare un qualsiasi cambiamento.

en: Iteration
it: Iterazione

en: In fact, repeating the code should be as easy as saying *do this three times*. Well, it pretty much is. Remember our old friend the code block? We can use it to mark the start and end of the code we'd like to repeat three times. We then use the special code `3.times`. So, instead of writing *do this three times*, we write `3.times do` - that's not too hard. Just remember to write `end` at the end of the code you'd like to repeat:
it: Ripetere più volte una o più stringhe di codice può essere semplice come dire *fai questo tre volte*. Alla fine, è proprio questo che faremo. Ti ricordi del nostro vecchio amico chiamato blocco di codice? Possiamo utilizzarlo per indicare l'inizio e la fine di un gruppo di codice che vogliamo ripetere per tre volte. Quindi, invece di scrivere *fai questo tre volte*, noi scriveremo '3.times do'. Non è troppo difficile, vero? Devi solo ricordare di scrivere 'end' alla fine del codice che vuoi ripetere:

en: Now isn't that much neater than cutting and pasting! We can use this to create lots of nice repeating structures:
it: Non è molto più facile che fare copia e incolla? Possiamo usare questa struttura per creare un sacco di strutture interessanti fatte con la ripetizione:

en: Nesting Iterations
it: Intrecciare le iterazioni

en: We can put iterations inside other iterations to create interesting patterns. For example:
it: Possiamo anche mettere le iterazioni una dentro l'altra per creare delle strutture interessanti. Per esempio:

en: Looping
it: Creare anelli (loop)

en: If you want something to repeat a lot of times, you might find yourself using really large numbers such as `1000.times do`. In this case, you're probably better off asking Sonic Pi to repeat forever (at least until you press the stop button!). Let's loop the amen break forever:
it: Se volessi che un blocco di codice si ripetesse tante volte, potresti trovare utile l'utilizzo di numeri grandi come '1000.times do'. In questi casi, però, faresti forse meglio a dire a Sonic Pi di ripetere il blocco all'infinito (o almeno finché non premi stop!). Proviamo a creare un anello con il campione amen_break:

en: The important thing to know about loops is that they act like black holes for code. Once the code enters a loop it can never leave until you press stop - it will just go round and round the loop forever. This means if you have code after the loop you will *never* hear it. For example, the cymbal after this loop will never play:
it: Un'aspetto importante da sapere degli anelli è che essi si comportano come dei buchi neri per il codice. Infatti, una volta che il codice entra in un anello, non riesce più a uscirne finché non premi stop. Il codice continuerà a girare in cerchio all'infinito. Quindi, se hai scritto del codice successivamente a un anello, questo non verrà mai eseguito. Nel caso seguente il piatto scritto dopo l'anello non suonerà mai:

en: Now, get structuring your code with iteration and loops!
it: Adesso puoi cominciare a strutturare il tuo codice inserendo le iterazioni e gli anelli, vai!

en: 5.3 Conditionals
it: 5.3 Condizionali

en: Conditionals
it: Condizionali

en: A common thing you'll likely find yourself wanting to do is to not only play a random note (see the previous section on randomness) but also make a random decision and based on the outcome run some code or some other code. For example, you might want to randomly play a drum or a cymbal. We can achieve this with an `if` statement.
it: Una cosa che probabilmente vorrai fare è non soltanto suonare note casuali (se vuoi riguardati la sezione precedente sulla casualità) ma anche prendere decisioni casuali e basate sul risultato ottenuto da una o un'altra stringa di codice precisa. Per esempio, potresti voler suonare in maniera casuale un tamburo o un piatto. Possiamo ottenere quanto detto sopra utilizzando la funzione 'if'.

en: Flipping a Coin
it: Tirare una moneta

en: So, let's flip a coin: if it's heads, play a drum, if it's tails, play a cymbal. Easy. We can emulate a coin flip with our `one_in` function (introduced in the section on randomness) specifying a probability of 1 in 2: `one_in(2)`. We can then use the result of this to decide between two pieces of code, the code to play the drum and the code to play the cymbal:
it: Quindi, tiriamo una moneta: se fosse testa, suona un tamburo, se fosse croce, suona un piatto. Facile no? Possiamo imitare il comportamento del lancio di una moneta con la funzione 'one_in' (introdotto nella sezione sulla casualità) specificando la probabilità di 1 ogni 2: 'one_in(2)'. Possiamo quindi utilizzare i risultati di questa funzione per decidere quali di due stringhe di codice scegliere, quello del tamburo o quello del piatto:

en: Notice that `if` statements have three parts:
it: Tieni conto che la struttura di 'if' è composta di tre parti:

en: The question to ask
it: La domanda da chiedere

en: The first choice of code to run (if the answer to the question is yes)
it: La prima scelta del codice da eseguire (se la risposta alla domanda è sì)

en: The second choice of code to run (if the answer to the question is no)
it: La seconda scelta del codice da eseguire (se la risposta alla domanda è no)

en: Typically in programming languages, the notion of yes is represented by the term `true` and the notion of no is represented by the term `false`. So we need to find a question that will give us a `true` or `false` answer which is exactly what `one_in` does.
it: Di solito all'interno dei linguaggi di programmazione, la nozione di sì è definita come 'vera', mentre la nozione di no è definita come 'falsa'. Quindi dobbiamo trovare una domanda che ci dia una risposta 'vera' o 'falsa', il che è esattamente quello che la funzione 'one_in' fa.

en: Notice how the first choice is wrapped between the `if` and the `else` and the second choice is wrapped between the `else` and the `end`. Just like do/end blocks you can put multiple lines of code in either place. For example:
it: Fai caso a come la prima scelta è inclusa tra la parola 'if' e la parola 'else' e invece la seconda scelta è tra 'else' e 'end'. Funziona ugualmente alla struttura 'do/end', dove puoi inserire più linee di codice in ogni posizione. Per esempio:

en: This time we're sleeping for a different amount of time depending on which choice we make.
it: Nel caso precedente, abbiamo creato suoni di lunghezza diversa attraverso la funzione 'sleep' a seconda della scelta eseguta.

en: Simple if
it: Funzione 'if' semplice

en: Sometimes you want to optionally execute just one line of code. This is possible by placing `if` and then the question at the end. For example:
it: A volte puoi aver bisogno di creare un'opzione per eseguire una linea di codice. Puoi fare questo costruendo la struttura di 'if' e ponendo la domanda alla fine. Per esempio:

en: This will play chords of different numbers with the chance of each note playing having a different probability.
it: Il codice scritto precedentemente suonerà un accordo composto da un numero sempre differente di note dipendente dal grado diverso di probabilità attribuito all'esecuzione di ogni nota.

en: 5.4 Threads
it: 5.4 Catene

en: Threads
it: Catene

en: So you've made your killer bassline and a phat beat. How do you play them at the same time? One solution is to weave them together manually - play some bass, then a bit of drums, then more bass... However, the timing soon gets hard to think about, especially when you start weaving in more elements.
it: Quindi per il momento hai creato un ritmo coinvolgente e un basso che ti entra dentro. Come puoi fare a suonarli contemporaneamente? Una delle soluzioni è di intrecciarli a mano: suona un po' di bassi, poi qualche colpo di batteria, poi ancora bassi...Tuttavia, la loro sincronizzazione può diventare presto difficile, specialmente quando cominci ad aggiungere numerosi elementi.

en: What if Sonic Pi could weave things for you automatically? Well, it can, and you do it with a special thing called a *thread*.
it: Che ne dici se Sonic Pi intrecciasse i vari strumenti per te, automaticamente? Bene, non ci crederai ma Sonic Pi può farlo per te! E lo può fare utilizzando una funzione speciale chiamata *thread*, ovvero tessitura.

en: Infinite Loops
it: Anelli infiniti

en: To keep this example simple, you'll have to imagine that this is a phat beat and a killer bassline:
it: Per fare un esempio semplice, devi immaginarti che il codice che segue sia un basso che pompa e un ritmo coinvolgente:

en: As we've discussed previously, loops are like *black holes* for the program. Once you enter a loop you can never exit from it until you hit stop. How do we play both loops at the same time? We have to tell Sonic Pi that we want to start something at the same time as the rest of the code. This is where threads come to the rescue.
it: Come abbiamo detto in precedenza, gli anelli sono delle specie di *buchi neri* per il programma. Una volta che entri all'interno di un anello non puoi più uscirne finché non premi stop. Quindi, come facciamo a suonare entrambi gli anelli contemporaneamente? Dobbiamo dire a Sonic Pi che vogliamo iniziare diverse parti di codice nello stesso momento. Questo è quello che fa la funzione *thread*.

en: Threads to the Rescue
it: La funzione *thread* viene a salvarci dai buchi neri

en: By wrapping the first loop in an `in_thread` do/end block we tell Sonic Pi to run the contents of the do/end block at *exactly* the same time as the next statement after the do/end block (which happens to be the second loop). Try it and you'll hear both the drums and the bassline weaved together!
it: Abbiamo messo all'interno di una struttura 'in_thread', composta da un blocco do/end, il primo anello. Questo comunica a Sonic Pi di eseguire il contenuto di questo blocco *esattamente* nello stesso momento del codice presente dopo il blocco (che in questo caso è il secondo anello). Prova a eseguirlo e potrai sentire sia la batteria sia il basso contemporaneamente!

en: Now, what if we wanted to add a synth on top. Something like:
it: Proviamo adesso a inserire un synth all'inizio:

en: Now we have the same problem as before. The first loop is played at the same time as the second loop due to the `in_thread`. However, *the third loop is never reached*. We therefore need another thread:
it: Ci ritroviamo con lo stesso problema di prima. Il primo anello è suonato contemporaneamente al secondo, grazie a 'in_thread'. Però *il terzo anello non viene mai eseguito*. Dobbiamo quindi aggiungere un altro 'filo' al tessuto:

en: Runs as threads
it: Avvii come ulteriori fili aggiunti al tessuto sonoro

en: What may surprise you is that when you press the Run button, you're actually creating a new thread for the code to run. This is why pressing it multiple times will layer sounds over each other. As the runs themselves are threads, they will automatically weave the sounds together for you.
it: Potrebbe sorprenderti il fatto che, quando premi il bottone 'run', in realtà stai creando un nuovo filo di codice da eseguire. Questo spiega perché quando premi il tasto più volte, il suono si sovrappone a quello che che è già in esecuzione. Visto che ogni esecuzione è un filo di codice, questi fili vengono intrecciati automaticamente.

en: Scope
it: Influenza del codice

en: As you learn how to master Sonic Pi, you'll learn that threads are the most important building blocks for your music. One of the important jobs they have is to isolate the notion of *current settings* from other threads. What does this mean? Well, when you switch synths using `use_synth` you're actually just switching the synth in the *current thread* - no other thread will have their synth switched. Let's see this in action:
it: Via via che scoprirai tutti i segreti di Sonic Pi, imparerai come questi 'tessuti' di suoni sono in realtà i mattoni principali con cui costruire la tua musica. Uno dei compiti principali di questi tessuti è quello di isolare la nozione di *impostazioni correnti* da quello degli altri orditi. Che cosa significa? Per esempio, quando associ un synth a un blocco utilizzando 'use_synth' stai associandolo soltanto a quel blocco e non ad altri. Vediamo un esempio:

en: Notice how the middle sound was different to the others? The `use_synth` statement only affected the thread it was in and not the outer main run thread.
it: Hai sentito come il suono di mezzo era differente dagli altri? La funzione 'use_synth' aveva effetto soltanto sul blocco in cui era incluso e non sugli altri blocchi all'esterno.

en: Inheritance
it: Ereditarietà

en: When you create a new thread with `in_thread`, the new thread will automatically inherit all of the current settings from the current thread. Let's see that:
it: Quando crei un nuovo filone, un nuovo ordito utilizzando 'in_thread', quest'ultimo erediterà automaticamente tutte le impostazioni correnti da quello precedente. Prova a dare un'occhiata qui:

en: Notice how the second note is played with the `:tb303` synth even though it was played from a separate thread? Any of the settings modified with the various `use_*` functions will behave in the same way.
it: Hai visto che la seconda nota è suonata con il timbro del synth ':tb303' nonostante questo appartenesse a un altro blocco? Qualsiasi impostazione che viene modificata utilizzando la stringa 'use_*' si comporterà nello stesso modo.

en: When threads are created, they inherit all the settings from their parent but they don't share any changes back.
it: Quando i fili di codice vengono creati, ereditano tutte le impostazioni dai fili 'genitori', ovvero quelli che li hanno generati. Tuttavia, le modifiche effettuate nel codice 'figlio' non hanno nessun effetto sui 'genitori'.

en: Naming Threads
it: Dare un nome ai diversi fili

en: Finally, we can give our threads names:
it: Per concludere, se vogliamo, possiamo dare dei nomi ai nostri fili di codice:

en: Look at the log pane when you run this code. See how the log reports the name of the thread with the message?
it: Dai uno sguardo alla sezione di destra quando esegui questo codice. Qui vengono visualizzati tutti i codici eseguiti. Vedi come questo 'diario' riporta il nome del filo da noi creato accoppiato con il messaggio?

en: Only One Thread per Name Allowed
it: Un nome può essere attribuito a un solo filo

en: One last thing to know about named threads is that only one thread of a given name may be running at the same time. Let's explore this. Consider the following code:
it: Un'ultima cosa da sapere a proposito dei nomi è che non possono essere eseguiti due fili con lo stesso nome contemporaneamente. Proviamo a dare un'occhiata a questa caratteristica. Leggi il codice seguente:

en: Go ahead and paste that into a buffer and press the Run button. Press it again a couple of times. Listen to the cacophony of multiple amen breaks looping out of time with each other. Ok, you can press Stop now.
it: Vai avanti e incollalo all'interno di una finestra e premi Run. Prova a premerlo ancora un paio di volte. Ascolta per un po' la cacofonia creata da più campioni 'amen_break' che suonano contemporaneamente ma fuori tempo. Bene, adesso puoi premere stop.

en: This is the behaviour we've seen again and again - if you press the Run button, sound layers on top of any existing sound. Therefore if you have a loop and press the Run button three times, you'll have three layers of loops playing simultaneously.
it: Questo è il comportamento che abbiamo osservato numerose volte, ovvero: se premi Run, i suoni si sovrappongono agli altri già in esecuzione. Quindi, se hai un anello e premi Run tre volte, otterrai tre strati di suono che sono eseguiti contemporaneamente.

en: However, with named threads it is different:
it: Con i fili ai quali è stato attribuito un nome, è tutta un'altra cosa:

en: Try pressing the Run button multiple times with this code. You'll only ever hear one amen break loop. You'll also see this in the log:
it: Prova a premere Run numerose volte inserendo questo codice. Potrai ascoltare un solo 'amen_break'. Puoi verificare il perché leggendo nella finestra a destra:

en: ==> Skipping thread creation: thread with name :amen already exists.
it: Visualizzerai questo messaggio ==> Skipping thread creation: thread with name :amen already exists.

en: Sonic Pi is telling you that a thread with the name `:amen` is already playing, so it's not creating another.
it: Sonic Pi, che parla inglese, ti sta dicendo che il filo di codice chiamato ':amen' è già in esecuzione, quindi non ne può creare un altro.

en: This behaviour may not seem immediately useful to you now - but it will be very handy when we start to live code...
it: Questo comportamento potrebbe non sembrarti particolarmente utile adesso, ma invece lo sarà quando cominceremo a fare live coding, ovvero a suonare dal vivo...

en: 5.5 Functions
it: 5.5 Funzioni

en: Functions
it: Funzioni

en: Once you start writing lots of code, you may wish to find a way to organise and structure things to make them tidier and easier to understand. Functions are a very powerful way to do this. They give us the ability to give a name to a bunch of code. Let's take a look.
it: Quando cominci ad avere dei codici molto lunghi, potresti sentire il bisogno di organizzare e strutturare le cose per renderle più pulite e chiare da comprendere. Le funzioni sono un modo molto efficace per farlo. Ci consentono di dare un nome a un insieme di linee. Diamo un'occhiata a questa possibilità.

en: Defining functions
it: Definire le funzioni

en: Here, we've defined a new function called `foo`. We do this with our old friend the do/end block and the magic word `define` followed by the name we wish to give to our function. We didn't have to call it `foo`, we could have called it anything we want such as `bar`, `baz` or ideally something meaningful to you like `main_section` or `lead_riff`.
it: Qui sopra, abbiamo definito una nuova funzione chiamandola 'foo'. L'abbiamo fatto usando la nostra vecchia conoscenza, il blocco do/end, accoppiato alla parola magica 'define', seguita dal nome che abbiamo voluto dare alla funzione. Non dobbiamo per forza chiamarla 'foo' ma possiamo usare un nome qualsiasi, come 'bar', 'baz' o qualsiasi cosa che ci aiuti a ricordarne il ruolo, come 'sezione_principale' o 'riff_principale'. Si può usare un termine in qualsiasi lingua.

en: Calling functions
it: Richiamare le funzioni

en: Once we have defined our function we can call it by just writing its name:
it: Una volta che abbiamo definito la nostra funzione, possiamo poi richiamarla semplicemente scrivendo il suo nome:

en: We can even use `foo` inside iteration blocks or anywhere we may have written `play` or `sample`. This gives us a great way to express ourselves and to create new meaningful words for use in our compositions.
it: Possiamo utilizzare 'foo' anche dentro un blocco di iterazione o ovunque abbiamo scritto 'play' o 'sample'. Questo ci permette di esprimere i nostri pensieri musicali e di creare delle parole con un senso preciso da utilizzare nelle nostre composizioni.

en: Functions are remembered across runs
it: Le funzioni vengono ricordate anche in esecuzioni diverse

en: So far, every time you've pressed the Run button, Sonic Pi has started from a completely blank slate. It knows nothing except for what is in the buffer. You can't reference code in another buffer or another thread. However, functions change that. When you define a function, Sonic Pi *remembers* it. Let's try it. Delete all the code in your buffer and replace it with:
it: Fin qui, ogni volta che hai premuto Run, Sonic Pi ha iniziato da zero. Il sistema non conosceva niente più di quello che era scritto della finestra. Non puoi richiamare un codice tra una finestra e l'altra o tra un gruppo di codice e l'altro. Le funzioni sono diverse. Quando ne hai definita una, Sonic Pi si *ricorda* di lei. Prova. Cancella tutto il codice che hai scritto e sostituiscilo con questo:

en: Press the Run button - and hear your function play. Where did the code go? How did Sonic Pi know what to play? Sonic Pi just remembered your function - so even after you deleted it from the buffer, it remembered what you had typed. This behaviour only works with functions created using `define` (and `defonce`).
it: Premi Run e ascolta la fuzione in esecuzione. Dov'è finito il codice? Come fa Sonic Pi a sapere cosa eseguire? Sonic Pi, semplicemente, si ricorda della tua funzione, quindi anche se l'ha cancellata dalla finestra, si ricorda che cosa avevi digitato. Tutto ciò funziona soltanto se le funzioni sono state create utilizzando 'define' (e 'defonce').

en: Parameterised functions
it: Funzioni parametrizzate

en: You might be interested in knowing that just like you can pass min and max values to `rrand`, you can teach your functions to accept arguments. Let's take a look:
it: Potresti essere interessato/a a sapere che, nello stesso modo in cui puoi passare da valori minimi a massimi o addittura casuali ('rrand'), puoi insegnare alle tue funzioni ad accettare degli argomenti. Prova a dare un'occhiata a quanto segue:

en: This isn't very exciting, but it illustrates the point. We've created our own version of `play` called `my_player` which is parameterised.
it: Quanto presentato non è molto eccitante, ma illustra bene la questione. Abbiamo creato la nostra personale versione di 'play' chiamata 'my_player' che è stata poi sottoposta a dei parametri.

en: The parameters need to go after the `do` of the `define` do/end block, surrounded by vertical goalposts `|` and separated by commas `,`. You may use any words you want for the parameter names.
it: I parametri devono essere scritti successivmente al 'do' del blocco do/end 'define'. Devono essere inclusi nelle barre verticali '|' ed essere separati dalle virgole ','. Puoi usare una qualsiasi parola a tuo piacimento per dare il nome ai parametri.

en: The magic happens inside the `define` do/end block. You may use the parameter names as if they were real values. In this example I'm playing note `n`. You can consider the parameters as a kind of promise that when the code runs, they will be replaced with actual values. You do this by passing a parameter to the function when you call it. I do this with `my_player 80` to play note 80. Inside the function definition, `n` is now replaced with 80, so `play n` turns into `play 80`. When I call it again with `my_player 90`, `n` is now replaced with 90, so `play n` turns into `play 90`.
it: La magia accade sempre all'interno del blocco do/end 'define'. Puoi usare anche i nomi dei parametri come se fossero dei valori reali. Nell'esempio precedente noi stavamo suonando la nota 'n'. Puoi considerare i parametri come una sorta di promessa che quando il codice è in esecuzione, essi verranno sostituiti con valori reali. Puoi fare ciò passando un parametro a una funzione quando lo richiami. Scrivendo il codice precedente, quanto detto è stato ottenuto digitando 'my_player 80' per suonare la nota corrispondente. All'interno della definizione della funzione, 'n' è sostituito con 80. Quindi se scrivi 'play n' la n verrà sostituita con 80. Se richiamassi di nuovo questa funzione scrivendo 'my_player 90', il valore n diventerebbe 90 e quindi scrivendo 'play n' otteniamo questa volta lo stesso suono di 'play 90'.

en: Let's see a more interesting example:
it: Ma guardiamo un esempio più interessante:

en: Here I used `repeats` as if it was a number in the line `repeats.times do`. I also used `root` as if it was a note name in my call to `play`.
it: Qui abbiamo digitato 'repeats' come se fosse un numero nella linea 'repeats.times do'. Abbiamo inserito 'roots' come se fosse un nome di una nota all'interno dell'esecuzione di 'play'.

en: See how we're able to write something very expressive and easy to read by moving a lot of our logic into a function!
it: Guarda come, grazie alle funzioni, riusciamo a scrivere qualcosa di molto espressivo, semplice da leggere e che compatta tutti i nostri ragionamenti!

en: 5.6 Variables
it: 5.6 Variabili

en: Variables
it: Variabili

en: A useful thing to do in your code is to create names for things. Sonic Pi makes this very easy: you write the name you wish to use, an equal sign (`=`), then the thing you want to remember:
it: Una cosa che può risultarti utile è quella di creare nomi da assegnare alle cose. Sonic Pi rende questo processo molto semplice: basta che scrivi il nome desiderato, il segno uguale ('='), e dopo la cosa che vuoi ricordarti:

en: Here, we've 'remembered' the symbol `:loop_amen` in the variable `sample_name`. We can now use `sample_name` everywhere we might have used `:loop_amen`. For example:
it: Nell'esempio sopra ci siamo 'ricordati' il simbolo ':loop_amen' grazie alla variabile 'sample_name'. Adesso, possiamo utilizzare 'sample_name' ovunque avremmo usato ':loop_amen'. Ecco un esempio:

en: There are three main reasons for using variables in Sonic Pi: communicating meaning, managing repetition and capturing the results of things.
it: Ci sono tre ragioni principali che rendono utile l'impiego di variabili in Sonic_Pi: comunicare significati, organizzare le ripetizioni e catturare i risultati delle cose.

en: Communicating Meaning
it: Comunicare i significati

en: When you write code it's easy to just think you're telling the computer how to do stuff - as long as the computer understands it's OK. However, it's important to remember that it's not just the computer that reads the code. Other people may read it too and try to understand what's going on. Also, you're likely to read your own code in the future and try to understand what's going on. Although it might seem obvious to you now - it might not be so obvious to others or even your future self!
it: Quando programmi è facile pensare semplicemente che stai dicendo al computer come fare qualcosa. E finché il computer capisce, va tutto bene! Tuttavia, è importante tenere a mente che non solo il computer legge il codice,ma anche altre persone potrebbero farlo per capire cosa sta succedendo. Inoltre, è probabile che tu stesso/a andrai prima o poi a rileggere il tuo codice e cercare di capire a che cosa serve. Anche se adesso qualche passaggio ti sembra ovvio, potrebbe non esserlo per qualcun altro o per te stesso/a nel futuro!

en: One way to help others understand what your code is doing is to write comments (as we saw in a previous section). Another is to use meaningful variable names. Look at this code:
it: Un modo per aiutare gli altri a comprendere il tuo programma è scrivere commenti (come abbiamo visto nella sezione precedente. Un altro modo è usare dei nomi di variabili che abbiano un significato. Per esempio, guarda il codice seguente:

en: Why does it use the number `1.7533`? Where did this number come from? What does it mean? However, look at this code:
it: Perché in questo codice è scritto il numero '1,7533'? Da dove salta fuori? Che cosa significa? Guarda invece questo codice:

en: Now, it's much clearer what `1.7533` means: it's the duration of the sample `:loop_amen`! Of course, you might say why not simply write:
it: Adesso è molto più chiaro a cosa si riferisce '1,7533':è la durata del campione ':loop_amen'! Adesso, potresti domandarti perché non scrivere semplicemente:

en: Which, of course, is a very nice way of communicating the intent of the code.
it: Questa è certamente un modo molto semplice e carino di comunicare lo scopo di un codice.

en: Managing Repetition
it: Gestire le ripetizioni

en: Often you see a lot of repetition in your code and when you want to change things, you have to change it in a lot of places. Take a look at this code:
it: Spesso può succedere che nel codice ci siano molte ripetizioni e quando vuoi cambiare qualcosa, è necessario farlo in molti punti. Guarda questo esempio:

en: We're doing a lot of things with `:loop_amen`! What if we wanted to hear what it sounded like with another loop sample such as `:loop_garzul`? We'd have to find and replace all `:loop_amen`s with `:loop_garzul`. That might be fine if you have lots of time - but what if you're performing on stage? Sometimes you don't have the luxury of time - especially if you want to keep people dancing.
it: Facciamo un sacco di cose con `:loop_amen`! E se volessimo sentire la stessa cosa ma con un loop diverso come, ad esempio, `:loop_garzul`? Saremmo costretti a trovare e rimpiazzare tutti i `:loop_amen`con `:loop_garzul`. Potresti farlo se avessi a disposizione molto tempo ma se ti stai esibendo su un palco? Spesso non hai il lusso di avere molto tempo, specialmente se non vuoi che la gente smetta di ballare.

en: What if you'd written your code like this:
it: E se avessimo scritto il codice in questo modo:

en: Now, that does exactly the same as above (try it). It also gives us the ability to just change one line `sample_name = :loop_amen` to `sample_name = :loop_garzul` and we change it in many places through the magic of variables.
it: Questo codice fa esattamente la stessa cosa di quello di prima (prova) ma ci dà la possibilità di cambiare una riga di codice `sample_name = :loop_amen` in `sample_name = :loop_garzul` e, grazie a questa variabile magica, verrà cambiato dappertutto.

en: Capturing Results
it: Catturare i risultati

en: Finally, a good motivation for using variables is to capture the results of things. For example, you may wish to do things with the duration of a sample:
it: Un buon motivo per utilizzare le variabili è la possibilità di catturare i risultati delle cose. Per esempio, magari vuoi provare a lavorare con la durata di un sample:

en: We can now use `sd` anywhere we need the duration of the `:loop_amen` sample.
it: Ora possiamo usare `sd` in ogni punto dove abbiamo bisogno della durata del camptione `:loop_amen`.

en: Perhaps more importantly, a variable allows us to capture the result of a call to `play` or `sample`:
it: Un risultato ancora più importante, forse, è che una variabile ci permette di catturare il risultato quando chiamiamo `play` o `sample`:

en: Now we have caught and remembered `s` as a variable, which allows us to control the synth as it is running:
it: Ora che abbiamo catturato `s` come variabile, possiamo controllare il sintetizzatore mentre sta funzionando:

en: We'll look into controlling synths in more detail in a later section.
it: Vedremo come controllare i sintetizzatori in modo più dettagliato più tardi in questa sezione.

en: Warning: Variables and Threads
it: Attenzione: Variabili e Thread

en: Whilst variables are great for giving things names and capturing the results of things, it is important to know that they should typically only be used locally within a thread. For example, *don't do this*:
it: Mentre le variabili sono ottime per assegnare nomi alle cose ed acquisire i relativi risultati, è importante sapere che dovrebbero essere generalmente usate in locale all'interno di un thread. Per esempio, *non fare questo*:

en: In the above example we assign a ring of numbers to a variable `a` and then used it within two separate `live_loop`s. In the first live loop every `0.5`s we sort the ring (to `(ring 1, 2, 3, 4, 5, 6)`) and then print it out to the log. If you run the code, you'll find that the printed list *is not always sorted!*. This may surprise you - especially that sometimes the list is printed as sorted, and sometimes it is not. This is called non-deterministic behaviour and is the result of a rather nasty problem called a race-condition. The problem is due to the fact that the second live loop is also manipulating the list (in this case shuffling it) and by the time the list is printed, sometimes it has just been sorted and sometimes it has just been shuffled. Both live loops are racing to do something different to the same variable and every time round a different loop 'wins'.
it: Nell'esempio di sopra, assegniamo un cerchio di numeri a un variabile `a` e poi l'usiamo in due `live_loop` (cicli dinamici) diversi. Nel primo `live_loop`, ogni `0.5` secondi, ordiniamo il cerchio (a `(ring 1,2,3,4,5,6)`) e lo stampiamo sul log. Se esegui il codice, trovi che l'elenco stampato *non è sempre ordinato!*. Questo forse ti sorprenderà — specialmente che a volte l'elenco viene stampato in ordine e a volte no. Questo si chiama comportamento "non-deterministico" ed è il risultato di un problema piuttosto difficile che si chiama "condizione di gara". Il problema è dovuto al fatto che anche il secondo ciclo sta manipolando l'elenco (in questo caso, rimescolandolo) e al punto che l'elenco viene stampato, alcune volte è appena stato ordinato ed alcune volte è appena stato rimescolato. Entrambi i cicli fanno una gara di fare qualcosa differente con lo stesso variabile ed ogni volta "vince" un ciclo diverso.

en: There are two solutions to this. Firstly, *don't use the same variable in multiple live loops or threads*. For example, the following code will always print a sorted list as each live loop has its own separate variable:
it: Esistono due soluzioni a questo. Prima, *non usare lo stesso variable in cicli o thread molteplici*. Per esempio, il codice seguente sempre stamperà un elenco ordinato perché ogni ciclo ha un proprio variabile:

en: However, sometimes we do want to share things across threads. For example, the current key, BPM, synth etc. In these cases, the solution is to use Sonic Pi's special thread-safe state system via the fns `get` and `set`. This is discussed later on in section 10.
it: Comunque, a volte vogliamo condividere cose fra diversi thread. Per esempio, la chiave attuale, BPM, sintetizzatore, ecc. In questi casi, la soluzione è usare il sistema speciale di stato "thread-safe" (sicuro per i thread) di Sonic Pi attraverso le funzioni `get` e `set`. Questo si descrive dopo, nella sezione 10.

en: 5.7 Thread Synchronisation
it: 5.7 Sincronizzazione dei thread

en: Thread Synchronisation
it: Sincronizzazione dei thread

en: Once you have become sufficiently advanced live coding with a number of functions and threads simultaneously, you've probably noticed that it's pretty easy to make a mistake in one of the threads which kills it. That's no big deal, because you can easily restart the thread by hitting Run. However, when you restart the thread it is now *out of time* with the original threads.
it: Raggiungendo un livello avanzato di live coding e usando molte funzioni e thread simultaneamente, ti sarai accordo che è semplice fare un errore che ferma un thread. Non è un problema perché puoi sempre farlo ripartire premendo Run ma, quando si riavvierà, sarà *fuori tempo* rispetto al thread originale.

en: Inherited Time
it: Ereditare il tempo

en: As we discussed earlier, new threads created with `in_thread` inherit all of the settings from the parent thread. This includes the current time. This means that threads are always in time with each other when started simultaneously.
it: Come abbiamo discusso in precedenza, i nuovi thread creati con `in_thread` ereditano le impostazioni dal thread principale. Questo include, ovviamente, anche il tempo. Questo significa che i thread sono sempre a tempo quando partono in simultanea.

en: However, when you start a thread on its own it starts with its own time which is unlikely to be in sync with any of the other currently running threads.
it: Tuttavia, quando fai partire un thread da solo, questo partirà con il suo tempo ed è davvero improbabile che sia sincronizzato con gli altri thread.

en: Cue and Sync
it: Segnale (cue) e sincronizzazione

en: Sonic Pi provides a solution to this problem with the functions `cue` and `sync`.
it: Sonic Pi offre una soluzione a questo problema con le funzioni `cue` e `sync`.

en: `cue` allows us to send out heartbeat messages to all other threads. By default the other threads aren't interested and ignore these heartbeat messages. However, you can easily register interest with the `sync` function.
it: La funzione `cue`ci permette di inviare il messaggio del cuore pulsante a tutti gli altri thread. Di default, gli altri thread non sono interessati a ricevere questo messaggio e lo ignorano. È possibile, però, attivare l'interesse al segnale utilizzando la funzione `sync`.

en: The important thing to be aware of is that `sync` is similar to `sleep` in that it stops the current thread from doing anything for a period of time. However, with `sleep` you specify how long you want to wait while with `sync` you don't know how long you will wait - as `sync` waits for the next `cue` from another thread which may be soon or a long time away.
it: La cosa importante da sapere è che `sync` funziona in modo simile a `sleep` nel senso che ferma il thread corrente per un certo periodo di tempo. La differenza è che con `sleep` specifichiamo quanto tempo aspettare mentre con `sync` non è possibile sapere quando aspetterà dal momento che `sync` aspetta il segnale `cue` da un altro thread che potrebbe essere vicino oppure lontano nel tempo.

en: Let's explore this in a little more detail:
it: Proviamo ad andare nel dettaglio:

en: Here we have two threads - one acting like a metronome, not playing any sounds but sending out `:tick` heartbeat messages every beat. The second thread is synchronising on `tick` messages and when it receives one it inherits the time of the `cue` thread and continues running.
it: Qui abbiamo due thread, uno che si comporta come un metronomo e non riproduce alcun suono ma invia il segnale `:tick` a ogni battito. Il secondo thread è sincronizzato al messaggio `tick` e quando ne riceve uno, eredita il tempo del thread `cue`e continua a funzionare.

en: As a result, we will hear the `:drum_heavy_kick` sample exactly when the other thread sends the `:tick` message, even if the two threads didn't start their execution at the same time:
it: Di conseguenza, sentiremo il campione `:drum_heavy_kick` esattamente nel momento in cui l'altro thread invia il messaggio `:tick`, anche se i due thread non vengono avviati in contemporanea:

en: That naughty `sleep` call would typically make the second thread out of phase with the first. However, as we're using `cue` and `sync`, we automatically sync the threads bypassing any accidental timing offsets.
it: Quella chiamata a `sleep` normalmente manderebbe il secondo thread fuori fase rispetto al primo, ma, dal momento che usiamo `cue` e `sync`, sincronizziamo automaticamente i thread bypassando ogni possibile deviazione di tempo.

en: Cue Names
it: Nominare i segnali di cue

en: You are free to use whatever name you'd like for your `cue` messages - not just `:tick`. You just need to ensure that any other threads are `sync`ing on the correct name - otherwise they'll be waiting for ever (or at least until you press the Stop button).
it: Sei libero di usare tutti i nomi che vuoi per i messaggi `cue`, non solo `:tick`. Devi solo assicurarti che tutti i thread siano sincronizzati sullo stesso nome, altrimenti aspetteranno all'infinito (o, fino alla pressione del pulsante di Stop).

en: Let's play with a few `cue` names:
it: Facciamo qualche prova con diversi nomi per `cue`:

en: Here we have a main `cue` loop which is randomly sending one of the heartbeat names `:foo`, `:bar` or `:baz`. We then also have three loop threads syncing on each of those names independently and then playing a different sample. The net effect is that we hear a sound every 0.5 beats as each of the `sync` threads is randomly synced with the `cue` thread and plays its sample.
it: Qui abbiamo un loop principale `cue` che in modo casuale invia segnali chiamati `:foo`, `:bar` o `:baz`. Abbiamo poi tre thread di loop con suoni differenti, ciascuno dei quali si sincronizza con quei segnali in modo indipendente. L'effetto rete fa si che sentiamo un suono ogni 0.5 battiti dal momento che ciascuno dei thread `sync` è sincronizzato in modo casuale con i thread `cue` che riproducono il campione.

en: This of course also works if you order the threads in reverse as the `sync` threads will simply sit and wait for the next `cue`.
it: Questo ovviamente funziona se ordini i thread al contrario dal momento che i thread `sync` aspetteranno di ricevere il `cue` successivo.

en: 6 FX
it: 6 Effetti

en: Studio FX
it: Effetti

en: One of the most rewarding and fun aspects of Sonic Pi is the ability to easily add studio effects to your sounds. For example, you may wish to add some reverb to parts of your piece, or some echo or perhaps even distort or wobble your basslines.
it: Uno degli aspetti più gratificante e divertente di Sonic Pi è la possibilità di aggiungere effetti ai tuoi suoni in modo semplice. Per fare un esempio, può succedere che tu voglia aggiungere un po' di riverbero ad alcune parti del tuo brano, oppure un po' di echo oppure distorsione e tremolo alle tue linee di basso.

en: Sonic Pi provides a very simple yet powerful way of adding FX. It even allows you to chain them (so you can pass your sounds through distortion, then echo and then reverb) and also control each individual FX unit with opts (in a similar way to giving params to synths and samples). You can even modify the opts of the FX whilst it's still running. So, for example, you could increase the reverb on your bass throughout the track...
it: Sonic Pi ti permette di aggiungere potenti effetti in modo semplice. Ti consente di collegarli in catena tra loro (così puoi passare il tuo suono prima dal distorsore, poi dall'echo e, infine, dal riverbero) e di controllare i parametri di ciascuno individualmente (in modo simile a come abbiamo fatto con synth e campioni). È possibile modificare i parametri dell'effetto mentre sta funzionando per cui, ad esempio, puoi aumentare il riverbero sul basso mentre riproduci la traccia...

en: Guitar Pedals
it: Pedali da chitarra

en: Let's explore FX!
it: Esploriamo gli effetti!

en: 6.1 Adding FX
it: 6.1 Aggiungere un effetto

en: Adding FX
it: Aggiungere un effetto

en: In this section we'll look at a couple of FX: reverb and echo. We'll see how to use them, how to control their opts and how to chain them.
it: In questa sezione, analizzeremo un paio di effetti: riverbero e echo. Vedremo insieme come usarli, come controllare i loro parametri e come collegarli in sequenza.

en: Sonic Pi's FX system uses blocks. So if you haven't read section 5.1 you might want to take a quick look and then head back.
it: Il sistema di effetti di Sonic Pi utilizza dei blocchi. Se non hai ancora letto la sezione 5.1, ti consiglio di dargli un'occhiata veloce prima di andare avanti.

en: Reverb
it: Riverbero

en: If we want to use reverb we write `with_fx :reverb` as the special code to our block like this:
it: Se vogliamo usare un riverbero, scriviamo `with_fx :reverb` nel nostro blocco di codice, così:

en: Now play this code and you'll hear it played with reverb. It sounds good, doesn't it! Everything sounds pretty nice with reverb.
it: Prova a suonare questo codice e sentirai che c'è del riverbero. Suona bene, vero? Tutto suona bene con un po' di riverbero.

en: Now let's look what happens if we have code outside the do/end block:
it: Ora vediamo cosa succedete se abbiamo del codice al di fuori del blocco do/end:

en: Notice how the final `play 55` isn't played with reverb. This is because it is *outside* the do/end block, so it isn't captured by the reverb FX.
it: Nota come la nota finale `play 55` viene riprodotta senza riverbero. Questo perché è *fuori* dal blocco do/end, quindi non viene catturata dal riverbero.

en: Similarly, if you make sounds before the do/end block, they also won't be captured:
it: Allo stesso modo, se riproduci un suono prima del blocco do/end, anche questi non verranno catturati dall'effetto:

en: There are many FX to choose from. How about some echo?
it: Ci sono molti effetti da cui scegliere. Perché non provare con un po' di echo?

en: One of the powerful aspects of Sonic Pi's FX blocks is that they may be passed opts similar to opts we've already seen with `play` and `sample`. For example a fun echo opt to play with is `phase:` which represents the duration of a given echo in beats. Let's make the echo slower:
it: Uno delle caratteristiche più importanti dei blocchi di codice degli effetti è che possiamo passargli dei parametri come abbiamo già visto con `play` e `sample`. Per esempio, un parametro dell'echo con cui giocare è `phase:` che rappresenta la durata dell'echo in battiti. Rendiamo l'effetto più lento:

en: Let's also make the echo faster:
it: Ora rendiamolo più veloce:

en: Let's make the echo take longer to fade away by setting the `decay:` time to 8 beats:
it: Facciamo in modo che l'echo abbia un fade out più lungo impostando il valore di `decay:` a 8 battiti:

en: Nesting FX
it: Nidificazione degli effetti

en: One of the most powerful aspects of the FX blocks is that you can nest them. This allows you to very easily chain FX together. For example, what if you wanted to play some code with echo and then with reverb? Easy, just put one inside the other:
it: Un'altra caratteristica molto importante è la possibilità di nidificare gli effetti. Questo ci permette di collegare in modo semplice un effetto all'altro. Se volessimo, ad esempio, suonare un po' di codice con l'eco e il riverbero? Facile! Inseriamo un effetto dentro l'altro:

en: Think about the audio flowing from the inside out. The sound of all the code within the inner do/end block such as `play 50` is first sent to the echo FX and the sound of the echo FX is in turn sent out to the reverb FX.
it: Pensa all'audio che passa dall'uno all'altro. Il suono del codice all'interno del blocco do/end (ad esempio `play 50`) è inviato prima all'echo e poi, il suono effettato, è inviato al riverbero.

en: Discovering FX
it: Scoprire gli effetti

en: Sonic Pi ships with a large number of FX for you to play with. To find out which ones are available, click on FX in the far left of this help system and you'll see a list of available options. Here's a list of some of my favourites:
it: Sonic Pi ha al suo interno un gran numero di effetti con cui puoi giocare. Per scoprire quelli che puoi usare, clicca su FX nella parte più a sinistra di questo help. Questi sono i miei preferiti:

en: 6.2 FX in Practice
it: 6.2 Effetti in pratica

en: FX in Practice
it: Effetti in pratica

en: Although they look deceptively simple on the outside, FX are actually quite complex beasts internally. Their simplicity often entices people to overuse them in their pieces. This may be fine if you have a powerful machine, but if - like me - you use a Raspberry Pi to jam with, you need to be careful about how much work you ask it to do if you want to ensure the beats keep flowing.
it: Anche se dall'esterno possono sembrare semplici, gli effetti sono, in realtà, molto complessi al loro interno. Data la loro semplicità di utilizzo, spesso le persone ne abusano. Questo potrebbe non essere un problema se hai una macchina potente ma se, come me, usi un Rasberry Pi, devi fare attenzione a quante risorse chiedi alla macchina se vuoi essere sicuro che non ci siano interruzioni.

en: Consider this code:
it: Guarda questo esempio:

en: In this code we're playing note 60 with a very short release time, so it's a short note. We also want reverb so we've wrapped it in a reverb block. All good so far. Except...
it: Con questo codice suoniamo la nota 60 con un tempo di rilascio molto breve. Siccome vogliamo del riverbero, abbiamo aggiunto un blocco di codice. Fin qui tutto bene, anche se...

en: Let's look at what the code does. First we have a `loop` which means everything inside of it is repeated forever. Next we have a `with_fx` block. This means we will create a new reverb FX *every time we loop*. This is like having a separate FX reverb pedal for every time you pluck a string on a guitar. It's cool that you can do this, but it's not always what you want. For example, this code will struggle to run nicely on a Raspberry Pi. All the work of creating the reverb and then waiting until it needs to be stopped and removed is all handled by `with_fx` for you, but this takes CPU power which may be precious.
it: Proviamo a vedere cosa fa esattamente il codice. Per prima cosa abbiamo un `loop` che significa che tutto quello che c'è al suo interno viene ripetuto all'infinito. Poi abbiamo un blocco `with_fx`. Questo significa che verrà creato un nuovo riverbero *ogni ripetizione del loop*. È come, sulla chitarra, avere un pedale del riverbero diverso per ogni corda. È figo poterlo fare ma non sempre è quello che vogliamo. Per esempio questo codice fa fatica a girare su un Raspberry Pi. La creazione del riverbero, l'utilizzo e il suo spegnimento sono gestiti da `with_fx` e questo potrebbe consumare preziosa potenza di calcolo.

en: How do we make it more similar to a traditional setup where our guitarist has just *one* reverb pedal which all sounds pass through? Simple:
it: Come possiamo fare per rendere il setup simile a quello dei chitarristi che hanno *un pedale* di riverbero dentro cui passa tutto il segnale? Molto semplice:

en: We put our loop *inside* the `with_fx` block. This way we only create a single reverb for all notes played in our loop. This code is a lot more efficient and would work fine on a Raspberry Pi.
it: Dobbiamo spostare il loop *dentro* il blocco `with_fx`. In questo modo creiamo un solo riverbero per tutte le note suonate nel nostro loop. Questo codice è molto più efficiente e funziona a meraviglia su un Rasberry Pi.

en: A compromise is to use `with_fx` over an iteration within a loop:
it: Un compromesso potrebbe essere usare `with_fx` in un'iterazione dentro a un loop:

en: This way we've lifted the `with_fx` out of the inner part of the `loop` and we're now creating a new reverb every 16 notes.
it: In questo modo abbiamo tolto `with_fx` dalla parte interna del `loop` e creiamo un riverbero ogni 16 note.

en: This is such a common pattern that `with_fx` supports an opt to do exactly this but without having to write the `16.times` block:
it: Questo è un modo di fare talmente comune che `with_fx` lo supporta come opzione senza la necessità di scrivere un blocco di ripetizione `16.times`:

en: Both the `reps: 16` and `16.times do` examples will behave identically. The `reps: 16` essentially repeats the code in the `do/end` block 16 times so you can use them both interchangeably and choose the one that feels best for you.
it: I blocchi di codice con `reps: 16` e `16.times do` funzionano allo stesso modo. Quello con `reps: 16` in pratica ripete il codice nel blocco `do/end` 16 volte per cui puoi usare entrambi i sistemi in modo intercambiabile scegliendo quello che preferisci.

en: Remember, there are no mistakes, just possibilities. However, some of these approaches will have a different sound and also different performance characteristics. So play around and use the approach that sounds best to you whilst also working within the performance constraints of your platform.
it: Ricorda: non ci sono errori, solo possibilità. Tuttavia alcuni di questi approcci genereranno suoni e performance differenti. Fai un po' di prove e trova l'approccio che, secondo te, suona meglio tenendo sempre in considerazione la questione delle performance della tua piattaforma.

en: 7 Control
it: 7 Controlli

en: Controlling running sounds
it: Controllare i suoni durante la riproduzione

en: So far we've looked at how you can trigger synths and samples, and also how to change their default opts such as amplitude, pan, envelope settings and more. Each sound triggered is essentially its own sound with its own list of options set for the duration of the sound.
it: Finora abbiamo visto come lanciare synth e campioni e come cambiare i loro parametri di default come il volume, il pan, l'inviluppo ecc... Ogni suono lanciato è, essenzialmente, un singolo suono con la sua lista di opzioni di durata.

en: Wouldn't it also be cool if you could change a sound's opts whilst it's still playing, just like you might bend a string of a guitar whilst it's still vibrating?
it: Non sarebbe bello poter cambiare i parametri di un suono mentre viene riprodotto, proprio come se stessimo facendo un bending sulla corda di una chitarra?

en: You're in luck - this section will show you how to do exactly this.
it: Siete fortunati, questa sezione vi spiegherà esattamente come farlo.

en: 7.1 Controlling Running Synths
it: 7.1 Controllare i sintetizzatori in riproduzione

en: Controlling Running Synths
it: Controllare i sintetizzatori in riproduzione

en: So far we've only concerned ourselves with triggering new sounds and FX. However, Sonic Pi gives us the ability to manipulate and control currently running sounds. We do this by using a variable to capture a reference to a synth:
it: Finora ci siamo preoccupati solo di lanciare nuovi suoni ed effetti. Ciononostante Sonic Pi ci dà la possibilità di manipolare e controllare tutti i suoni in riproduzione. Lo possiamo fare utilizzando una variabile:

en: Here, we have a run-local variable `s` which represents the synth playing note 60. Note that this is *run-local* - you can't access it from other runs like functions.
it: Qui abbiamo una variabile locale `s` che rappresenta il sintetizzatore che suona la nota 60. Nota bene: si tratta di una variabile *locale* che non può essere richiamata da altre funzioni.

en: Once we have `s`, we can start controlling it via the `control` function:
it: Ora che abbiamo `s`, possiamo cominciare a controllarlo utilizzando la funzione `control`:

en: The thing to notice is that we're not triggering 4 different synths here - we're just triggering one synth and then change the pitch 3 times afterwards, while it's playing.
it: Notiamo come non stiamo utilizzando 4 synth differenti, stiamo utilizzando un solo sintetizzatore cambiando il pitch della nota 3 volte mentre sta suonando.

en: We can pass any of the standard opts to `control`, so you can control things like `amp:`, `cutoff:` or `pan:`.
it: Possiamo passare tutti i parametri standard attraverso `control`, per cui possiamo controllare cose come `amp:`, `cutoff:` oppure `pan:`.

en: Non-controllable Options
it: Parametri non controllabili

en: Some of the opts can't be controlled once the synth has started. This is the case for all the ADSR envelope parameters. You can find out which opts are controllable by looking at their documentation in the help system. If the documentation says *Can not be changed once set*, you know it's not possible to control the opt after the synth has started.
it: Alcuni parametri non possono essere modificati una volta che il synth è partito, per esempio l'inviluppo ADSR. Puoi scoprire quali parametri puoi modificare guardando nella documentazione. Se trovi scritto *non può essere modificato una volta impostato*, saprai che non puoi modificarlo una volta avviato il synth.

en: 7.2 Controlling FX
it: 7.2 Controllare gli effetti

en: Controlling FX
it: Controllare gli effetti

en: It is also possible to control FX, although this is achieved in a slightly different way:
it: È possibile controllare anche gli effetti, anche se bisogna farlo in modo leggermente differente:

en: Instead of using a variable, we use the goalpost parameters of the do/end block. Inside the `|` bars, we need to specify a unique name for our running FX which we then reference from the containing do/end block. This behaviour is identical to using parameterised functions.
it: Invece di utilizzare una variabile, utilizziamo un parametro di riferimento nel blocco do/end. Dentro le barre `|`, dobbiamo specificare un nome univoco per ogni effetto che poi richiamiamo all'interno del blocco do/end. Questo comportamento è identico all'utilizzare funzioni parametrizzate.

en: Now go and control some synths and FX!
it: Ora prova a controllare qualche synth ed effetto!

en: 7.3 Sliding Options
it: 7.3 Parametri scorrevoli

en: Sliding Opts
it: Parametri scorrevoli

en: Whilst exploring the synth and FX opts, you might have noticed that there are a number of opts ending with `_slide`. You might have even tried calling them and seeing no effect. This is because they're not normal parameters, they're special opts that only work when you control synths as introduced in the previous section.
it: Esplorando i parametri dei synth e degli effetti avrai notato come alcuni di essi terminano con `_slide`. Magari hai anche provato a richiamarli ma senza alcun risultato. Questo succede perché, a differenza dei normali parametri, funzionano solo quando controlli il synth come discusso nella sezione precedente.

en: Consider the following example:
it: Considera il seguente esempio:

en: Here, you can hear the synth pitch changing immediately on each `control` call. However, we might want the pitch to slide between changes. As we're controlling the `note:` parameter, to add slide, we need to set the `note_slide` parameter of the synth:
it: Puoi sentire il pitch del sintetizzatore cambiare a ogni chiamata di `control`. Può capire, però, che ci sia uno slide tra i vari cambiamenti. Siccome stiamo controllando il parametro `note:`, per aggiungere lo scorrimento, dobbiamo impostare il parametro `note_slide`:

en: Now we hear the notes being bent between the `control` calls. It sounds nice, doesn't it? You can speed up the slide by using a shorter time such as `note_slide: 0.2` or slow it down by using a longer slide time.
it: Ora sentiamo che la nota viene "piegata" ogni volta che `control` viene richiamato. Suona bene, vero? Possiamo velocizzare lo slide utilizzando un tempo inferiore come `note_slide: 0.2` o rallentarlo usando valori più lunghi.

en: Every parameter that can be controlled has a corresponding `_slide` parameter for you to play with.
it: Ogni parametro che puoi controllare, ha un parametro corrispettivo `_slide` con cui puoi giocare.

en: Sliding is sticky
it: Lo scorrimento è delicato

en: Once you've set a `_slide` parameter on a running synth, it will be remembered and used every time you slide the corresponding parameter. To stop sliding you must set the `_slide` value to 0 before the next `control` call.
it: Ogni volta che imposti un parametro `_slide` su un synth in riproduzione, verrà ricordato e usato ogni volta che scorri il parametro corrispondente. Per fermare lo slide, devi impostare il valore di `_slide`a 0 prima del successivo `control`.

en: Sliding FX Opts
it: Parametri di scorrimento degli effetti

en: It is also possible to slide FX opts:
it: È possibile controllare lo scorrimento degli effetti:

en: Now have fun sliding things around for smooth transitions and flowing control...
it: Ora possiamo divertirci utilizzando lo scorrimento per creare transizioni più fluide...

en: 8 Data Structures
it: 8 Strutture di dati

en: Data Structures
it: Strutture di dati

en: A very useful tool in a programmer's toolkit is a data structure.
it: Uno strumento molto utile nella cassetta degli attrezzi di un programmatore sono le strutture di dati.

en: Sometimes you may wish to represent and use more than one thing. For example, you may find it useful to have a series of notes to play one after another. Programming languages have data structures to allow you do exactly this.
it: Può capitare che tu voglia rappresentare o usare più di una cosa. Per esempio, può essere utile avere una serie di note che suonano una dopo l'altra. I linguaggi di programmazione utilizzano le strutture di dati proprio per questo.

en: There are many exciting and exotic data structures available to programmers - and people are always inventing new ones. However, for now we only really need to consider a very simple data structure - the list.
it: Ci sono moltissime strutture di dati a disposizione dei programmatori e le persone continuano a inventarsene di nuove. Tuttavia, per il momento, prendiamo in considerazione una struttura semplice: la lista.

en: Let's look at it in more detail. We'll cover its basic form and then also how lists can be used to represent scales and chords.
it: Andiamo nel dettaglio: capiremo la sua forma base e come utilizzare le liste per scale e accordi.

en: 8.1 Lists
it: 8.1 Liste

en: Lists
it: Liste

en: In this section we'll take a look at a data structure which is very useful - the list. We met it very briefly before in the section on randomisation when we randomly chose from a list of notes to play:
it: In questa sezione analizzeremo come funziona una lista come struttura di dati. Ne abbiamo accennato in precedenza nella sezione relativa alla casualità quando abbiamo scelto di suonare una nota in modo casuale da una lista:

en: In this section we'll explore using lists to also represent chords and scales. First let's recap how we might play a chord. Remember that if we don't use `sleep`, sounds all happen at the same time:
it: In questa sezione esploreremo come utilizzare le liste per accordi e scale. Prima ripassiamo come possiamo suonare un accordo: ricordi che se non usiamo sleep, tutti i suoni vengono riprodotti in contemporanea:

en: Let's look at other ways to represent this code.
it: Proviamo a trovare altri modi di rappresentare questo codice.

en: Playing a List
it: Suonare una lista

en: One option is to place all the notes in a list: `[52, 55, 59]`. Our friendly `play` function is smart enough to know how to play a list of notes. Try it:
it: Un'opzione è di inserire tutte le note in una lista: `[52, 55, 59]`. La nostra amata funzione `play` è così furba da sapere come suonare una lista di note. Provala:

en: Ooh, that's already nicer to read. Playing a list of notes doesn't stop you from using any of the parameters as normal:
it: Ooh, si legge molto più facilmente. Suonare una lista di note non ti deve fermare dall'usare i parametri:

en: Of course, you can also use the traditional note names instead of the MIDI numbers:
it: Ovviamente puoi usare anche i nomi delle note tradizionali invece che numeri MIDI:

en: Now those of you lucky enough to have studied some music theory might recognise that chord as *E Minor* played in the 3rd octave.
it: Ora, quelli di voi che hanno avuto la fortuna di studiare un po' di teoria musicale, riconosceranno quell'accordo come *Mi minore* (E Minor NdT), suonato nella terza ottava.

en: Accessing a List
it: Accedere a una lista

en: Another very useful feature of a list is the ability to get information out of it. This may sound a bit strange, but it's no more complicated than someone asking you to turn a book to page 23. With a list, you'd say, what's the element at index 23? The only strange thing is that in programming indexes usually start at 0 not 1.
it: Un'altra caratteristica utile delle liste è la possibilità di ottenere informazioni da essa. Può sembrare un po' strano ma non è molto più complicato che chiedere a qualcuno di aprire un libro a pagina 23. Con una lista, chiederai: qual è l'elemento all'indice 23? L'unica cosa strana è che nei linguaggi di programmazioni gli indici iniziano da 0 e non da 1.

en: With list indexes we don't count 1, 2, 3... Instead we count 0, 1, 2...
it: Con gli indici nelle liste non contiamo 1, 2, 3... ma 0, 1, 2...

en: Let's look at this in a little more detail. Take a look at this list:
it: Proviamo a capirci di più, guarda questo esempio di lista:

en: There's nothing especially scary about this. Now, what's the second element in that list? Yes, of course, it's `55`. That was easy. Let's see if we can get the computer to answer it for us too:
it: Non c'è niente di spaventoso. Qual è il secondo elemento in quella lista? Ovviamente è `55`. Facile. Vediamo se riusciamo a far rispondere il computer al posto nostro:

en: OK, that looks a bit weird if you've never seen anything like it before. Trust me though, it's not too hard. There are three parts to the line above: the word `puts` , our list `52, 55, 59` and our index `[1]`. Firstly we're saying `puts` because we want Sonic Pi to print the answer out for us in the log. Next, we're giving it our list, and finally our index is asking for the second element. We need to surround our index with square brackets and because counting starts at `0`, the index for the second element is `1`. Look:
it: Ok, sembra qualcosa di strano che non abbiamo mai visto prima. Credimi, non c'è nulla di difficile. Ci sono tre sezioni nella linea qui sopra: la parola `puts`, la nostra lista `52, 55, 59`, e il nostro indice `[1]`. Per prima cosa, usiamo `puts` perché vogliamo che Sonic Pi stampi nel log una risposta. Poi, gli diamo la nostra lista e, infine, l'indice richiede il secondo elemento in essa. Dobbiamo inserire il nostro indice tra parentesi quadre perché il conteggio inizia a 0, l'indice per il secondo elemento sarà `1`. Guarda:

en: Try running the code `puts [52, 55, 59][1]` and you'll see `55` pop up in the log. Change the index `1` to other indexes, try longer lists and think about how you might use a list in your next code jam. For example, what musical structures might be represented as a series of numbers...
it: Prova a far girare il codice `puts [52, 55, 59][1]` e vedrai `55` comparire nel log. Prova a cambiare l'indica `1` con altri valori, prova ad allungare la lista e pensa a come usare una lista nei tuoi prossimi esperimenti. Per esempio, quale struttura musicale può essere rappresentata da una serie di numeri...

en: 8.2 Chords
it: 8.2 Accordi

en: Sonic Pi has built-in support for chord names which will return lists. Try it for yourself:
it: Sonic Pi supporta anche l'uso dei nomi di accordi. Prova tu stesso/a:

en: Now, we're really getting somewhere. That looks a lot more pretty than the raw lists (and is easier to read for other people). So what other chords does Sonic Pi support? Well, a *lot*. Try some of these:
it: Stiamo ottenendo davvero dei bei risultati, e il codice appare molto più ordinato e piacevole di una semplice lista di elementi (oltre che essere più facilmente leggibile dalle altre persone). Quindi, quali altri accordi supporta Sonic Pi? In realtà, ne supporta molti. Prova a digitare quello che segue:

en: `chord(:E3, :m7)`
it: 'chord(:E3, :m7)'

en: Arpeggios
it: Arpeggi

en: We can easily turn chords into arpeggios with the function `play_pattern`:
it: Possiamo semplicemente suonare gli accordi in forma di arpeggio usando la funzione 'play_pattern':

en: We can even pass a list of times which it will treat as a circle of times:
it: Possiamo anche inserire una lista di durate che verrà trattata come un circolo, ovvero ripetendola ad anello:

en: This is the equivalent to:
it: Quanto scritto è equivalente a:

en: Which would you prefer to write?
it: Quale preferisci scrivere?

en: 8.3 Scales
it: 8.3 Scale

en: Scales
it: Scale

en: Sonic Pi has support for a wide range of scales. How about playing a C3 major scale?
it: Sonic Pi supporta anche una larga tipologia di scale. Che ne pensi di provare a suonare una scala di Do3 maggiore (C3 nel sistema anglossassone)?

en: We can even ask for more octaves:
it: Possiamo anche chiere di eseguire altre ottave:

en: How about all the notes in a pentatonic scale?
it: Proviamo invece a suonare tutte le note in una scala pentatonica?

en: Random notes
it: Note casuali

en: Chords and scales are great ways of constraining a random choice to something meaningful. Have a play with this example which picks random notes from the chord E3 minor:
it: Gli accordi e le scale sono degli utilissimi strumenti per limitare la scelta di elementi casuali all'interno di qualcosa di significativo. Prova a suonare questo esempio che seleziona note casuali all'interno di una scala di Mi3 maggiore (E3):

en: Try switching in different chord names and cutoff ranges.
it: Prova a cambiare il nome dell'accordo e i limiti all'interno di cui vengono selezionate le note.

en: Discovering Chords and Scales
it: Scopri gli accordi e le scale

en: To find out which scales and chords are supported by Sonic Pi simply click the Lang button on the far left of this tutorial and then choose either chord or scale in the API list. In the information in the main panel, scroll down until you see a long list of chords or scales (depending on which you're looking at).
it: Per scoprire quali scale e accordi sono supportati da Sonic Pi, clicca semplicemente sul bottone 'Lang' a sinistra di questa guida e quindi scegli gli accordi o le scale all'interno della lista. All'interno delle informazioni del pannello principale, scorri verso il basso il cursore finché non verdrai una lunga lista di accordi e di scale.

en: Have fun and remember: there are no mistakes, only opportunities.
it: Divertiti! E ricorda sempre: non ci sono errori, soltanto opportunità.

en: 8.4 Rings
it: 8.4 Anelli

en: Rings
it: Anelli

en: An interesting spin on standard lists are rings. If you know some programming, you might have come across ring buffers or ring arrays. Here, we'll just go for ring - it's short and simple.
it: Un'altra opzione interessante sulle liste standard sono gli anelli (ring). Se conosci un po' di programmazione, potresti aver incontrato anelli buffer o anelli array. Qui, per comodità e semplicità, utilizzeremo solo anelli.

en: In the previous section on lists we saw how we could fetch elements out of them by using the indexing mechanism:
it: Nella sezione precedente abbiamo visto come accedere agli elementi di una lista utilizzando il sistema dell'indice:

en: Now, what happens if you want index `100`? Well, there's clearly no element at index 100 as the list has only three elements in it. So Sonic Pi will return you `nil` which means nothing.
it: Ora, cosa succede se vogliamo l'indice `100`? Beh, ovviamente non c'è nessun elemento all'indice 100 perché la lista contiene solo 3 elementi. Sonic Pi restituirà `nil` che significa nulla.

en: However, consider you have a counter such as the current beat which continually increases. Let's create our counter and our list:
it: Tuttavia, consideriamo di avere un contatore come, ad esempio, la pulsazione corrente che viene incrementata di continuo. Creiamo il nostro contatore e la nostra lista:

en: We can now use our counter to access a note in our list:
it: Possiamo usare il nostro contatore per accedere alle note nella lista:

en: Great, we got `52`. Now, let's increment our counter and get another note:
it: Bene, abbiamo `52`. Ora, incrementiamo il nostro contatore per ottenere un'altra nota:

en: Super, we now get `55` and if we do it again we get `59`. However, if we do it again, we'll run out of numbers in our list and get `nil`. What if we wanted to just loop back round and start at the beginning of the list again? This is what rings are for.
it: Fantastico, ora abbiamo `55` e se lo facciamo di nuovo otteniamo `59`. Se, però, lo facciamo ancora, non avremo più numeri nella nostra lista e otterremo `nil`. E se volessimo tornare all'inizio della lista e ricominciare da capo? A questo servono gli anelli.

en: Creating Rings
it: Creare anelli

en: We can create rings one of two ways. Either we use the `ring` function with the elements of the ring as parameters:
it: Abbiamo due modi per creare un anello. Possiamo usare `ring` come funzione dell'elemento o ring come parametro:

en: Or we can take a normal list and convert it to a ring by sending it the `.ring` message:
it: Oppure possiamo prendere una normale lista e convertirla in un anello inviando il messaggio `.ring`:

en: Indexing Rings
it: Indicizzare gli anelli

en: Once we have a ring, you can use it in exactly the same way you would use a normal list with the exception that you can use indexes that are negative or larger than the size of the ring and they'll wrap round to always point at one of the ring's elements:
it: Quando abbiamo un anello, possiamo usarlo esattamente come abbiamo fatto con le normali liste con l'eccezione che possiamo usare indici che sono negativi oppure di grandezza maggiore rispetto all'anello perché ripartiranno da capo e punteranno sempre a un elemento dell'anello:

en: Using Rings
it: Utilizzare gli anelli

en: Let's say we're using a variable to represent the current beat number. We can use this as an index into our ring to fetch notes to play, or release times or anything useful we've stored in our ring regardless of the beat number we're currently on.
it: Diciamo che vogliamo utilizzare una variabile per rappresentare il battito corrente. Possiamo usarla come indice nel nostro anello per scegliere le note da suonare o i tempi di rilascio oppure qualsiasi altra cosa che abbiamo salvato nel nostro anello, indipendentemente dal numero di battiti in cui siamo.

en: Scales and Chords are Rings
it: Scale e accordi sono anelli

en: A useful thing to know is that the lists returned by `scale` and `chord` are also rings and allow you to access them with arbitrary indexes.
it: Una cosa interessante da sapere è che liste restituite da `scale` e `chord` sono anche anelli e ci possiamo accedere con indici arbitrari.

en: Ring Constructors
it: Costruzione di anelli

en: In addition to `ring` there are a number of other functions which will construct a ring for us.
it: Oltre a `ring` ci sono una serie di altre funzioni che costruiranno un anello per noi.

en: `range` invites you specify a starting point, end point and step size.
it: `range` ci invita a specificare un punto di partenza, uno di fine e la grandezza dei passi.

en: `bools` allows you to use `1`s and `0`s to succinctly represent booleans.
it: `bools` ci permette di usare `1` e `0` per rappresentare variabili booleane.

en: `knit` allows you to knit a sequence of repeated values.
it: `knit` ci consente di unire una sequenza di valori ripetuti.

en: `spread` creates a ring of bools with a Euclidean distribution.
it: `spread` crea un anello di booleani con una distribuzione euclidea.

en: Take a look at their respective documentation for more information.
it: Dai un'occhiata alla relativa documentazione per maggiori informazioni a riguardo.

en: 8.5 Ring Chains
it: 8.5 Catene di anelli

en: Ring Chains
it: Catene di anelli

en: In addition to the constructors such as `range` and `spread` another way of creating new rings is to manipulate existing rings.
it: In aggiunta ai costrutti tipo `range` e `spread`, un altro modo di creare nuovi anelli è manipolando anelli esistenti.

en: Chain Commands
it: Comandi di concatenazione

en: To explore this, take a simple ring:
it: Per capirci di più, prendiamo un semplice anello:

en: What if we wanted it backwards? Well we'd use the chain command `.reverse` to take the ring and turn it around:
it: Se volessimo riprodurlo al contrario? Beh, utilizzeremo il comando `.reverse` per girare quell'anello:

en: Now, what if we wanted the first three values from the ring?
it: Ora, se volessimo solo i primi tre valori dell'anello?

en: Finally, what if we wanted to shuffle the ring?
it: Infine, se volessimo dei valori casuali?

en: Multiple Chains
it: Concatenazioni multiple

en: This is already a powerful way of creating new rings. However, the *real* power comes when you chain a few of these commands together.
it: Questo è già un modo per creare nuovi anelli. Tuttavia il *vero* potere arriva quando concateniamo assieme alcuni comandi.

en: How about shuffling the ring, dropping 1 element and then taking the next 3?
it: Se volessimo mescolare l'anello, rimuovere 1 elemento e poi prendere i successivi 3?

en: Let's take this in stages:
it: Analizziamo passo dopo passo:

en: `(ring 10, 20, 30, 40, 50)` - our initial ring
it: `(ring 10, 20, 30, 40, 50)` - il nostro anello inziale

en: `(ring 10, 20, 30, 40, 50).shuffle` - shuffles - `(ring 40, 30, 10, 50, 20)`
it: `(ring 10, 20, 30, 40, 50).shuffle` - mescoliamo - `(ring 40, 30, 10, 50, 20)`

en: `(ring 10, 20, 30, 40, 50).shuffle.drop(1)` - drop 1 - `(ring 30, 10, 50, 20)`
it: `(ring 10, 20, 30, 40, 50).shuffle.drop(1)` - rimuoviamo il primo elemento - `(ring 30, 10, 50, 20)`

en: `(ring 10, 20, 30, 40, 50).shuffle.drop(1).take(3)` - take 3 - `(ring 30, 10, 50)`
it: `(ring 10, 20, 30, 40, 50).shuffle.drop(1).take(3)` - prendiamo gli ultimi tre - `(ring 30, 10, 50)`

en: Can you see how we can just create a long chain of these methods by just *sticking them together*. We can combine these in any order we want creating an extremely rich and powerful way of generating new rings from existing ones.
it: Come puoi vedere, possiamo creare una lunga catena di questi metodi semplicemente *collegandoli insieme*. Possiamo farlo in qualsiasi ordine vogliamo per creare nuovi anelli partendo da anelli già esistenti.

en: Immutability
it: Immutabilità

en: These rings have a powerful and important property. They are immutable which means that they can not change. This means that the chaining methods described in this section *do not change rings* rather they *create new rings*. This means you're free to share rings across threads and start chaining them within a thread knowing you won't be affecting any other thread using the same ring.
it: Questi anelli hanno una proprietà molto potente e importante. Sono immutabili, il che significa che non possono cambiare. Questo significa che i metodi di concatenazione descritti in questa sezione *non cambiano gli anelli* ma *ne creano di nuovi*. Puoi condividere anelli tra i vari thread e cominciare a concatenarli all'interno del thread sapendo che non andrai a modificare gli altri thread in cui viene usato lo stesso anello.

en: Available Chain Methods
it: Metodi di concatenazione disponibili

en: Here's a list of the available chain methods for you to play with:
it: Questa è una lista dei metodi di concatenazione a tua disposizione:

en: `.reverse` - returns a reversed version of the ring
it: `.reverse` - restituisce un anello invertito

en: `.sort` - creates a sorted version of the ring
it: `.sort` - crea una versione ordinata dell'anello

en: `.shuffle` - creates a shuffled version of the ring
it: `.shuffle` - crea una versione mescolata dell'anello

en: `.pick(3)` - returns a ring with the results of calling `.choose` 3 times
it: `.pick(3)` - restituisce un anello con i risultati della chiamata di `.choose` 3 volte

en: `.take(5)` - returns a new ring containing only the first 5 elements
it: `.take(5)` - restituisce un anello che contiene solo i primi 5 elementi

en: `.drop(3)` - returns a new ring with everything but the first 3 elements
it: `.drop(3)` - restituisce un nuovo anello con tutti gli elementi eccetto i primi 3

en: `.butlast` - returns a new ring with the last element missing
it: `.butlast` - restituisce un nuovo anello senza l'ultimo elemento

en: `.drop_last(3)` - returns a new ring with the last 3 elements missing
it: `.drop_last(3)` - restituisce un anello senza gli ultimi 3 elementi

en: `.take_last(6)`- returns a new ring with only the last 6 elements
it: `.take_last(6)`- restituisce un nuovo anello con soltanto gli ultimi 6 elementi

en: `.stretch(2)` - repeats each element in the ring twice
it: `.stretch(2)` - ripete ogni elemento nell'anello due volte

en: `.repeat(3)` - repeats the entire ring 3 times
it: `.repeat(3)` - ripete l'intero anello 3 volte

en: `.mirror` - adds the ring to a reversed version of itself
it: `.mirror` - aggiunge all'anello una versione invertita di se stesso

en: `.reflect` - same as mirror but doesn't duplicate middle value
it: `.reflect` - come mirror ma non duplica il valore di mezzo

en: `.scale(2)` - returns a new ring with all elements multiplied by 2 (assumes ring contains numbers only)
it: `.scale(2)` - restituisce un nuovo anello con tutti gli elementi moltiplicati per 2 (suppone che l'anello contiene solo numeri)

en: Of course, those chain methods that take numbers can take other numbers too! So feel free to call `.drop(5)` instead of `.drop(3)` if you want to drop the first 5 elements.
it: Ovviamente, questi metodi di concatenazione accettano anche altri valori! Sentiti libero di chiamare `.drop(5)` invece che `.drop(3)` se vuoi rimuovere i primi 5 elementi.

en: 9 Live Coding
it: 9 Programmare Live

en: One of the most exciting aspects of Sonic Pi is that it enables you to write and modify code live to make music, just like you might perform live with a guitar. One advantage of this approach is to give you more feedback whilst composing (get a simple loop running and keep tweaking it till it sounds just perfect). However, the main advantage is that you can take Sonic Pi on stage and gig with it.
it: Uno degli aspetti più interessanti di Sonic Pi è la possibilità di scrivere e modificare il codice live per creare musica, come se stessi suonando una chitarra. Un vantaggio di questo approccio è avere più feedback mentre componi (ad esempio riproducendo continuamente un loop e continuando a modificarlo finché non suona perfetto). Ovviamente il più grande vantaggio è poter usare Sonic Pi su un palco.

en: In this section we'll cover the fundamentals of turning your static code compositions into dynamic performances.
it: In questa sezione copriremo gli aspetti fondamentali per trasformare la composizione statica in una performance dinamica.

en: Hold on to your seats...
it: Tieniti forte...

en: 9.1 Live Coding Fundamentals
it: 9.1 Fondamenti di live coding

en: Now we've learned enough to really start having some fun. In this section we'll draw from all the previous sections and show you how you can start making your music compositions live and turning them into a performance. For that we'll need 3 main ingredients:
it: Ora abbiamo imparato abbastanza per cominciare a divertirci. In questa sezione tireremo le somme delle cose viste fino ad ora e ti mostrerò come comporle live e trasformarle in una performance. Abbiamo bisogno di 3 ingredienti:

en: An ability to write code that makes sounds - CHECK!
it: Essere capaci di scrivere codice che genera suoni.

en: An ability to write functions - CHECK!
it: Essere capaci di scrivere funzioni.

en: An ability to use (named) threads - CHECK!
it: Essere capaci di utilizzare thread (con nomi).

en: Alrighty, let's get started. Let's live code our first sounds. We first need a function containing the code we want to play. Let's start simple. We also want to loop calls to that function in a thread:
it: Ok, cominciamo. Programmiamo live i nostri primi suoni. Per prima cosa abbiamo bisogno di una funzione che contenga il codice che vogliamo suonare. Cominciamo in modo semplice: vogliamo, ovviamente, richiamare di continuo quella funzione in un thread:

en: If that looks a little too complicated to you, go back and re-read the sections on functions and threads. It's not too complicated if you've already wrapped your head around these things.
it: Se ti sembra troppo complicato, torna indietro per rileggere le sezioni relative alle funzioni e ai thread. Non è troppo complicato se hai capito come funzionano queste cose.

en: If you run this code, you'll hear note 50 repeating again and again...
it: Se riproduci questo codice, sentirai la nota 50 ripetersi...

en: Changing it up
it: Facciamo dei cambiamenti

en: Now, this is where the fun starts. Whilst the code is *still running* change 50 to another number, say 55, then press the Run button again. Woah! It changed! Live!
it: Ora è dove cominciamo a divertirci. Mentre il codice sta *ancora funzionando* cambia 50 in un altro numero, per esempio 55, e premi il pulsante Run di nuovo. Visto? È cambiato! Live!

en: Try changing it again, change the note, change the sleep time. How about adding a `use_synth` statement? For example, change it to:
it: Prova a cambiarlo ancora, cambia la nota, cambia il tempo di pausa. E se aggiungessimo `use_synth`? Per esempio cambiamolo in:

en: Now it sounds pretty interesting, but we can spice it up further. Instead of playing the same note again and again, try playing a chord:
it: Ora comincia a diventare interessante, ma possiamo renderlo ancora meglio. Invece di suonare sempre la stessa nota, suoniamo un accordo:

en: How about playing random notes from the chord:
it: Perché non suonare note casuali prese dall'accordo:

en: Or using a random cutoff value:
it: O usando un valore casuale per il cutoff:

en: Finally, add some drums:
it: Infine, aggiungiamo un po' di batteria:

en: Now things are getting exciting!
it: Ora si che sta diventando interessante!

en: However, before you jump up and start live coding with functions and threads, stop what you're doing and read the next section on `live_loop` which will change the way you code in Sonic Pi forever...
it: Ora, prima di cominciare a programmare dal vivo con funzioni e thread, fermati un secondo e leggi la prossima sezione su `live_loop` che cambierà per sempre il modo in cui programmi in Sonic Pi...

en: 9.2 Live Loops
it: 9.2 Loop Live

en: Live Loops
it: Loop Live

en: Ok, so this section of the tutorial is the real gem. If you only read one section, it should be this one. If you read the previous section on Live Coding Fundamentals, `live_loop` is a simple way of doing exactly that but without having to write so much.
it: Ok, questa sezione del tutorial è la vera gemma. Se hai deciso di leggere una sola sezione, dovrebbe essere questa. Se hai letto la precedente, `live_loop` è un modo più semplice di fare esattamente la stessa cosa evitando troppe preoccupazioni.

en: If you didn't read the previous section, `live_loop` is the best way to jam with Sonic Pi.
it: Se non hai letto la sezione precedente, `live_loop` è il modo migliore per improvvisare con Sonic Pi.

en: Let's play. Write the following in a new buffer:
it: Ok, suoniamo. Prova a scrivere il seguente codice in un buffer:

en: Now press the Run button. You hear a basic beep every beat. Nothing fun there. However, don't press Stop just yet. Change the `60` to `65` and press Run again.
it: Ora premi il pulsante Run, sentirai un beep di base ogni battito. Niente di divertente. Ora, però, non premere Stop. Cambia `60` in `65` e premi Run di nuovo.

en: Woah! It changed *automatically* without missing a beat. This is live coding.
it: Whoah! È cambiato *automaticamente* senza perdere un colpo. Questo è live coding.

en: Why not change it to be more bass like? Just update your code whilst it's playing:
it: Perché non cambiarlo per farlo suonare più basso? Aggiorna il tuo codice mentre sta suonando:

en: Then hit Run.
it: Poi premi Run.

en: Let's make the cutoff move around:
it: Giochiamo un po' con il cutoff:

en: Hit Run again.
it: Premi run di nuovo.

en: Add some drums:
it: Aggiungiamo un po' di batteria:

en: Change the note from `e1` to `c1`:
it: Cambia la nota da `e1` a `c1`:

en: Now stop listening to me and play around yourself! Have fun!
it: Ora smettila di ascoltarmi e prova a fare da solo! Divertiti!

en: 9.3 Multiple Live Loops
it: 9.3 Live loop multipli

en: Multiple Live Loops
it: Live loop multipli

en: Consider the following live loop:
it: Guarda questo live loop:

en: You may have wondered why it needs the name `:foo`. This name is important because it signifies that this live loop is different from all other live loops.
it: Forse ti stai chiedendo perché c'è il nome `:foo`. L'aggiunta del nome è importante perché significa che questo live loop è diverso da tutti gli altri.

en: *There can never be two live loops running with the same name*.
it: *Non possono esistere due live loop con lo stesso nome*.

en: This means that if we want multiple concurrently running live loops, we just need to give them different names:
it: Questo significa che se vogliamo avere più live loop, dobbiamo assegnare loro nomi differenti:

en: You can now update and change each live loop independently and it all just works.
it: Ora puoi aggiornare e cambiare ciascun live loop indipendentemente e tutto funziona.

en: Syncing Live Loops
it: Sincronizzare i live loop

en: One thing you might have already noticed is that live loops work automatically with the thread cue mechanism we explored previously. Every time the live loop loops, it generates a new `cue` event with the name of the live loop. We can therefore `sync` on these cues to ensure our loops are in sync without having to stop anything.
it: Una cosa che potresti aver notate è che i live loop lavora automaticamente con il sistema dei cue (segnali di sincronizzazione) che abbiamo visto in precedenza. Ogni volta che il live loop parte, genera un nuovo evento `cue` con il nome del live loop. Possiamo, di conseguenza, usare `sync` con uno di questi cue per essere sicuri che i loop siano sincronizzati tra loro senza fermare nulla.

en: Consider this badly synced code:
it: Prendiamo in esame questo codice mal sincronizzato:

en: Let's see if we can fix the timing and sync without stopping it. First, let's fix the `:foo` loop to make the sleep a factor of 1 - something like `0.5` will do:
it: Vediamo se riusciamo a sistemare il timing e la sincronizzazione senza stoppare. Per prima cosa, sistemiamo il loop `:foo` cambiamo il fatto di sleep 1 a qualcosa tipo `0.5`:

en: We're not quite finished yet though - you'll notice that the beats don't quite line up correctly. This is because the loops are *out of phase*. Let's fix that by syncing one to the other:
it: Non abbiamo ancora finito del tutto, avrai notato come i battiti non siano perfettamente allineati. Questo perché i loop sono *fuori fase*. Sistemiamo il problema sincronizzandoli tra loro:

en: Wow, everything is now perfectly in time - all without stopping.
it: Wow, ora è tutto a tempo, senza aver fermato nulla.

en: Now, go forth and live code with live loops!
it: Ora, andiamo avanti e programmiamo live con live loop!

en: 9.4 Ticking
it: 9.4 Ticchettio

en: Ticking
it: Ticchettio

en: Something you'll likely find yourself doing a lot when live coding is looping through rings. You'll be putting notes into rings for melodies, sleeps for rhythms, chord progressions, timbral variations, etc. etc.
it: Una cosa che ti troverai a fare spesso programmando live è utilizzare gli anelli. Inserirai note dentro anelli per le melodie, sleep per il ritmo, progressioni armoniche, variazioni di timbro, ecc...

en: Ticking Rings
it: Ticchettio con anelli

en: Sonic Pi provides a *very* handy tool for working with rings within `live_loop`s. It's called the tick system. In the section about the rings we were talking about the counter that is constantly increasing, like a current beat number. Tick just implements this idea. It provides you with the ability to *tick through rings*. Let's look at an example:
it: Sonic Pi ha uno strumento *veramente* utile per lavorare con gli anelli all'interno dei `live_loop`. È chiamato sistema di ticchettio (tick system NdT). Nella sezione relativa agli anelli, abbiamo parlato del contatore che cresce costantemente, come, ad esempio, il numero di battiti. Il ticchettio implementa questa idea. Ci permette di usare il *ticchettio con gli anelli*. Vediamo un esempio:

en: This is equivalent to:
it: Questo equivale a:

en: Here, we're just grabbing the scale E3 minor pentatonic and ticking through each element. This is done by adding `.tick` to the end of the scale declaration. This tick is local to the live loop, so each live loop can have its own independent tick:
it: Qui stiamo utilizzando la scala minore pentatonica di E3 ticchettando con ogni elemento. Possiamo farlo utilizzando `.tick` alla fine della dichiarazione della scala. Questo tick è locale in relazione al live loop per cui ogni loop può avere il suo tick indipendente:

en: You can also call `tick` as a standard fn and use the value as an index:
it: You anche usare `tick` come una funzione standard e usare il suo valore come un indice:

en: However, it is much nicer to call `.tick` at the end. The `tick` fn is for when you want to do fancy things with the tick value and for when you want to use ticks for other things than indexing into rings.
it: Tuttavia, è meglio chiamare `.tick` alla fine. La funzione `tick` viene usata quando vuoi fare cose particolari con il valore di tick e quando vuoi usare il valore dei tick per altre cose rispetto all'indice negli anelli.

en: Look
it: Look (Guarda)

en: The magical thing about tick is that not only does it return a new index (or the value of the ring at that index) it also makes sure that next time you call tick, it's the next value. Take a look at the examples in the docs for `tick` for many ways of working with this. However, for now, it's important to point out that sometimes you'll want to just look at the current tick value and *not increase* it. This is available via the `look` fn. You can call `look` as a standard fn or by adding `.look` to the end of a ring.
it: La cosa magica riguardo tick è che non solo restituisce un nuovo indice (o il valore dell'anello a quell'indice) ma fa in modo che quando viene chiamato successivamente, restituirà il valore successivo. Dai un'occhiata agli esempi nella documentazione relativa a `tick` per capire come lavorarci. A volte può capitare di voler vedere il valore di tick in quel momento senza *incrementarlo*. Questo è possibile grazie alla funzione `look`. Puoi chiamare `look` come una funzione standard oppure aggiungendo `.look` alla fine di un anello.

en: Naming Ticks
it: Nominare i tick

en: Finally, sometimes you'll need more than one tick per live loop. This is achieved by giving your tick a name:
it: Infine, a volte hai bisogno di avere più di un tick per live loop. Questo può essere fatto assegnando un nome ai tick:

en: Here we're using two ticks one for the note to play and another for the sleep time. As they're both in the same live loop, to keep them separate we need to give them unique names. This is exactly the same kind of thing as naming `live_loop`s - we just pass a symbol prefixed with a `:`. In the example above we called one tick `:foo` and the other `:bar`. If we want to `look` at these we also need to pass the name of the tick to `look`.
it: Qui usiamo due tick: uno per le note da suonare e un altro per il tempo di sleep. Siccome sono entrambi all'interno dello stesso live loop, per tenerli separati dobbiamo assegnargli nomi unici. È lo stesso identico procedimento che abbiamo visto nel nominare i `live_loop`: usiamo un simbolo anticipato da `:`. Nell'esempio qui sopra, abbiamo chiamato un tick `:foo` e l'altro `:bar`. Se vogliamo usare `look` dobbiamo chiamarli col nome corretto.

en: Don't make it too complicated
it: Non renderlo troppo complicato

en: Most of the power in the tick system isn't useful when you get started. Don't try and learn everything in this section. Just focus on ticking through a single ring. That'll give you most of the joy and simplicity of ticking through rings in your `live_loop`s.
it: Gran parte della potenza di questo sistema di tick non è utile quando stai cominciando. Non provare a imparare tutto quello di cui abbiamo parlato in questa sezione. Per il momento concentrati sul ticchettio all'interno di uno stesso anello. Questo sarà sufficiente per darti la gioia di usare i tick all'interno dei tuoi `live_loop`.

en: Take a look at the documentation for `tick` where there are many useful examples and happy ticking!
it: Dai un'occhiata alla documentazione alla voce `tick`, troverai molti esempi a riguardo!

en: Often it is useful to have information that is *shared across multiple threads or live loops*. For example, you might want to share a notion of the current key, BPM or even more abstract concepts such as the current 'complexity' (which you'd potentially interpret in different ways across different threads). We also don't want to lose any of our existing determinism guarantees when doing this. In other words, we'd still like to be able to share code with others and know exactly what they'll hear when they run it. At the end of Section 5.6 of this tutorial we briefly discussed why we *should not use variables to share information across threads* due to a loss of determinism (in turn due to race conditions).
it: È spesso utile avere informazioni che *si condividono attraverso vari thread o cicli vivi*. Per esempio, forse vuoi condividere l'idea della chiave attuale, BPM, o anche concetti più astratti come la "complessità" attuale (che si potrebbe interpretare diversamente in diversi thread). Non vogliamo nemmeno perdere le garanzie deterministiche quando facciamo questo. Cioè, vorremmo condividere il nostro codice con gli altri e sapere esattamente ciò che sentiranno quando lo eseguono. Alla fine della Sezione 5.6 di questa lezione, abbiamo trattato in breve la ragione perché *non dobbiamo usare variabili per condividere informazioni attraverso i thread*, dovuta alla perdita del determinismo (a sua volta dovuta alle condizioni di gara).

en: Meet `get` and `set`...
it: Ti presento `get` e `set`...

en: 10.1 Set and Get
it: 10.1 Set e Get

en: Set and Get
it: Set e Get

en: Sonic Pi has a global memory store called Time State. The two main things you do with it are to `set` information and `get` information. Let's dive deeper...
it: Sonic Pi ha un archivio globale di memoria chiamato Time State. Le due cose principali che fai con questo sono `set` (impostare) e `get` (richiamare) informazioni. Immergiamoci di più...

en: To store information into the Time State we need two things:
it: Per impostare informazioni nel Time State abbiamo bisogno di due cose:

en: the information we want to store,
it: le informazioni che vogliamo impostare,

en: a unique name (key) for the information.
it: un nome unico (la chiave) per le informazioni.

en: For example, we might want to store the number `3000` with the key `:intensity`. This is possible using the `set` function:
it: Per esempio, forse vogliamo impostare il numero `3000` sotto la chiave `:intensity`. Questo è possibile utilizzano la funzione `set`:

en: We can use any name for our key. If information has already been stored with that key, our new `set` will override it:
it: Possiamo usare qualsiasi nome per la chiave. Se si sono già impostate informazioni con quella chiave, il nuovo `set` le sostituisce:

en: In the above example, as we stored both numbers under the same key, the last call to `set` 'wins', so the number associated with `:intensity` will be `3000` as the first call to `set` is effectively overridden.
it: Nell'esempio sopra, visto che abbiamo memorizzato tutti e due i numeri sotto la stessa chiave, "vince" l'ultima chiamata di `set`, così il numero associato con `:intensity` sarà `3000` perché la prima chiamata di `set` è in effetti soprascritta.

en: To fetch information from the Time State we just need the key we used to `set` it, which in our case is `:intensity`. We then just need to call `get[:intensity]` which we can see by printing out the result to the log:
it: Per recuperare informazioni dal Time State abbiamo bisogno solamente della chiave usata per fare il `set`; in questo caso, `:intensity`. Poi, basta che chiamiamo `get[:intensity]`, che possiamo verificare facilmente stampandone il risultato sul log:

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

en: Notice that calls to `get` can return information that was `set` in a previous run. Once a piece of information has been `set` it is available until either the information is overridden (just like we clobbered the `:intensity` value of `1000` to `3000` above) or Sonic Pi is closed.
it: Nota che le chiamate a `get` possono restituire informazioni che erano `set` da una esecuzione   precedente. Una volta impostata una informazione con `set`, è disponibile fino a quando non viene soprascritta (come sopra abbiamo rimpiazzato il valore `1000` di `:intensity` con `3000`) o fino a quando non viene chiuso Sonic Pi.

en: Multiple Threads
it: Thread multipli

en: The main benefit of the Time State system is that it can be safely used across threads or live loops. For example, you could have one live loop setting information and another one getting it:
it: Il beneficio principale del sistema Time State è che si può usare senza rischi attraverso thread o cicli vivi. Per esempio, puoi avere un ciclo vivo che imposta informazioni ed un altro che le recupera:

en: The nice thing about using `get` and `set` across threads like this is that it will always produce the same result every time you hit run. Go on, try it. See if you get the following in your log:
it: Una cosa bella  dell'uso di `get` e `set` in questo modo attraverso i thread è che genera sempre lo stesso risultato ogni volta che premi "Run". Dai, provalo. Vedi se ottieni il seguente nel tuo log:

en: Try running it a few times - see, it's the same every time. This is what we call deterministic behaviour and it's really very important when we want to share our music as code and know that the person playing the code is hearing exactly what we wanted them to hear (just like playing an MP3 or internet stream sounds the same for all listeners).
it: Prova ad eseguire alcune volte — vedi, è uguale ogni volta. Questo si chiama comportamento deterministico ed è importantissimo quando vogliamo condividere la nostra musica in forma di codice e sapere che la persona che la esegue sente esattamente quello che abbiamo voluto che sentisse (come un MP3 o un flusso di internet suona lo stesso per tutti gli ascoltatori).

en: A Simple Deterministic State System
it: Un Sistema Semplice di Stato Deterministico

en: Back in Section 5.6 we discussed why using variables across threads can lead to random behaviour. This stops us from being able to reliably reproduce code such as this:
it: Nella Sezione 5.6 abbiamo parlato della ragione perché usare variabili attraverso thread può causare comportamento casuale. Questo ci blocca da potere riprodurre code come questo in maniera affidabile:

en: ## An Example of Non-Deterministic Behaviour
    ## (due to race conditions caused by multiple
    ## live loops manipulating the same variable
    ## at the same time).
    ##  
    ## If you run this code you'll notice
    ## that the list that's printed is
    ## not always sorted!
    a = (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      a = a.shuffle
      sleep 0.5
    end
    live_loop :sorted do
      a = a.sort
      sleep 0.5
      puts "sorted: ", a
    end
it: ## Un Esempio di Comportamento Non-Deterministico
    ## (dovuto a condizioni di gara causate da vari
    ## cicli vivi che manipolano lo stesso variabile allo
    ## stesso tempo).
    ##  
    ## Se esegui questo codice noterai
    ## che l'elenco che viene stampato non
    ## è sempre in ordine!
    a = (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      a = a.shuffle
      sleep 0.5
    end
    live_loop :sorted do
      a = a.sort
      sleep 0.5
      puts "sorted: ", a
    end

en: Let's take a look at how this might look using `get` and `set`:
it: Guardiamo come possiamo fare questo con `get` e `set`:

en: ## An Example of Deterministic Behaviour
    ## (despite concurrent access of shared state)
    ## using Sonic Pi's new Time State system.
    ##
    ## When this code is executed, the list that's
    ## printed is always sorted!
    set :a, (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      set :a, get[:a].shuffle
      sleep 0.5
    end
    live_loop :sorted do
      set :a, get[:a].sort
      sleep 0.5
      puts "sorted: ", get[:a]
    end
it: ## Un Esempio di Comportamento Deterministico
    ## (nonostante accesso concorrente dello
    ## stato condiviso) usando il nuovo sistema
    ## Time State di Sonic Pi.
    ##
    ## Quando questo codice si esegue, l'elenco che
    ## viene stampato è sempre in ordine!
    ##
    set :a, (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      set :a, get[:a].shuffle
      sleep 0.5
    end
    live_loop :sorted do
      set :a, get[:a].sort
      sleep 0.5
      puts "sorted: ", get[:a]
    end

en: Notice how this code is pretty much identical to the version using a variable before it. However when you run the code, it behaves as you would expect with any typical Sonic Pi code - *it does the same thing every time* in this case thanks to the Time State system.
it: Nota che questo codice è quasi uguale alla versione prima che usava un variabile. Ma quando esegui questo codice, si comporta come si aspetta con qualsiasi codice tipico di Sonic Pi — *fa la stessa cosa ogni volta* in questo caso, grazie al sistema Time State.

en: Therefore, when sharing information across live loops and threads, use `get` and `set` instead of variables for deterministic, reproducible behaviour.
it: Dunque, quando si condividono informazioni fra cicli vivi e thread, usa `get` e `set` invece di variabili per avere comportamento deterministico e riproducibile.

en: Passing values into the Future
it: Passare valori nel Future

en: 10.3 Pattern Matching
it: 10.3 Confrontare i Pattern

en: Matching partial segments
it: Confrontare segmenti parziali

en: Matching Nested Path Segments
it: Confrontare segmenti in percorsi annidati

en: Matching Single Letters
it: Trovare corrispondenze di lettere singole

en: Matching Multiple Words
it: Trovare corrispondenze di parole multiple

en: If you know that a segment may be one of a select number of words, you can use the `{` and `}` matchers to specify a list of choices such as `"/foo/{bar,beans,eggs}/quux"` which will only match the following:
it: Se sai che un segmento potrebbe essere uno di un numero selezionato di parole, puoi usare l'operatore `{` and `}` per specificare una lista di scelte come `"/foo/{bar,beans,eggs}/quux"` che troverà corrispondenza solo con:

en: Matching Multiple Letters
it: Trovare corrispondenze di lettere multiple

en: Finally, you can match against a selection of letters if you use the `[` and `]` matchers to specify a list of choices such as `"/foo/[abc]ux/baz"` which will match only:
it: Infine, puoi cercare corrispondenze in una selezione di lettere se usi `{` and `}` per specificare una lista di scelte come ad esempio `"/foo/[abc]ux/baz"` che corrisponderà solo a:

en: You can also use the `-` character to specify ranges of letters. For example `"/foo/[a-e]ux/baz"` which will match only:
it: Puoi anche usare il carattere `-` per specificare un intervallo di lettere. Ad esempio `"/foo/[a-e]ux/baz"` che corrisponderà solo a:

en: Combining Matchers
it: Combinare corrispondenze

en: When calling `sync` or `get` you are free to combine matchers in any order you see fit to powerfully match any Time State event created by `cue` or `set`. Let's look at a far-fetched example:
it: Nelle chiamate `sync` o `get` sei libero di combinare i parametri di confronto in qualunque ordine per intercettare qualunque evento Time State creato da `cue` o `set`. Diamo un'occhiata a un esempio inverosimile:

en: OSC Pattern Matching
it: Confrontare patter OSC

en: Once you've mastered converting code to music, you might wonder - what's next? Sometimes the constraints of working purely within Sonic Pi's syntax and sound system can be exciting and put you into a new creative position. However, sometimes it is essential to break out of the code into the real world. We want two extra things:
it: Una volta che padroneggi la conoscenza per convertire il codice in musica, potresti chiederti - cosa posso fare dopo? Qualche volta i vincoli di lavorare puramente all'interno della sintassi di Sonic Pi e del suo sistema audio possono essere eccitanti e metterti in una nuova posizione creativa. Tuttavia, qualche volta è necessario uscire dal codice verso il mondo reale. Vogliamo quindi 2 cose extra:

en: To be able to convert actions in the real world into Sonic Pi events to code with
it: Per poter convertire azioni nel mondo reale negli eventi Sonic Pi per programmare con

en: To be able to use Sonic Pi's strong timing model and semantics to control and manipulate objects in the real world
it: Per poter usare il potente modello di timing e semantica di Sonic Pi al fine di controllare e manipolare oggetti nel mondo reale

en: Luckily there's a protocol that's been around since the 80s that enables exactly this kind of interaction - MIDI. There's an incredible number of external devices including keyboards, controllers, sequencers, and pro audio software that all support MIDI. We can use MIDI to receive data and also use it to send data.
it: Fortunatamente esiste un protocollo disponibile dagli anni 80 che permette esattamente questo tipo di interazione - MIDI. C'è un numero incredibile di dispositivi esterni che includono tastiere, controller, sequencers e software audio professionale che supportano il MIDI. Possiamo usare il MIDI per ricevere e inviare dati.

en: Sonic Pi provides full support for the MIDI protocol enabling you to connect your live code to the real world. Let's explore it further...
it: Sonic Pi offre pieno supporto al protocollo MIDI permettendoti di connettere il codice live al mondo reale. Esploriamolo più in dettaglio...

en: In this section we will learn how to connect a MIDI controller to send events into Sonic Pi to control our synths and sounds. Go and grab a MIDI controller such as a keyboard or control surface and let's get physical!
it: In questa sezione impareremo a collegare un controller MIDI per mandare eventi a Sonic Pi per controllare i nostri synths e suoni. Procurati un controller MIDI come una tastiera o una superficie di controllo e andiamo sul fisico!

en: Connecting a MIDI Controller
it: Collegamento a un controller MIDI

en: In order to get information from an external MIDI device into Sonic Pi we first need to connect it to our computer. Typically this will be via a USB connection, although older equipment will have a 5-pin DIN connector for which you'll need hardware support for your computer (for example, some sound cards have MIDI DIN connectors). Once you've connected your device, launch Sonic Pi and take a look at the IO section of the Preferences panel. You should see your device listed there. If not, try hitting the 'Reset MIDI' button and see if it appears. If you're still not seeing anything, the next thing to try is to consult your operating system's MIDI config to see if it sees your device. Failing all that, feel free to ask questions in our friendly forums: https://in-thread.sonic-pi.net
it: Per poter ricevere informazioni da un dispositivo MIDI esterno in Sonic Pi dobbiamo innanzitutto collegarlo al nostro computer. Tipicamente questo avviene via USB anche se dispositivi più vecchi possono avere il connettore DIN a 5 pin, per il quale servirà hardware specifico (ad esempio una scheda audio con connettori MIDI DIN). Una volta collegato il dispositivo, lancia Sonic Pi e controlla la sezione IO nel pannello preferenze. Dovresti vedere il tuo dispositivo elencato qui. Se non è così, prova a premere il tasto 'Reset MIDI' e controlla se compare. Se ancora non vedi la periferica, la prossima cosa da fare è controllare la configurazione MIDI del tuo sistema operativo e controllare se rileva il tuo dispositivo. Se nessuna di queste cose funziona, sentiti libero di chiedere aiuto nel nostro forum https://in-thread.sonic-pi.net

en: Receiving MIDI Events
it: Ricevere eventi MIDI

en: Once your device is connected, Sonic Pi will automatically receive events. You can see for yourself by manipulating your MIDI device and looking at the cue logger in the bottom right of the application window below the log (if this isn't visible go to Preferences->Editor->Show & Hide and enable the 'Show cue log' tickbox). You'll see a stream of events such as:
it: Una volta che il tuo dispositivo è connesso, Sonic Pi riceverà automaticamente gli eventi. Puoi vederlo da te manipolando il tuo dispositivo MIDI e controllando il cue logger nella sezione inferiore destra della finestra applicazione sotto il registro eventi (se non fosse visibile vai su Preferenze->Editor->Show & Hide e abilita 'Show cue log'). Vedrai un flusso di eventi come:

en: Once you can see a stream of messages like this, you've successfully connected your MIDI device. Congratulations, let's see what we can do with it!
it: Una volta che riesci a vedere un flusso di dati come questo significa che hai collegato correttamente la tua periferica MIDI. Congratulazioni, ora vediamo cosa ci puoi fare!

en: MIDI Time State
it: Stato del MIDI Time

en: These events are broken into two sections. Firstly there's the name of the event such as `/midi:nanokey2_keyboard:0:1/note_on` and secondly there's the values of the event such as `[18, 62]`. Interestingly, these are the two things we need to store information in Time State. *Sonic Pi automatically inserts incoming MIDI events into Time State*. This means you can `get` the latest MIDI value and also `sync` waiting for the next MIDI value using everything we learned in section 10 of this tutorial.
it: Questi eventi si dividono in due sezioni. Prima c'è il nome dell'evento come ad esempio `/midi:nanokey2_keyboard:0:1/note_on` seguito dal valore degli eventi come ad esempio `[18, 62]`. Nota interessante, queste sono le 2 cose di cui abbiamo bisogno per salvare le informazioni nel Time State. *Sonic Pi inserisce automaticamente gli eventi MIDI in ingresso nel Time State*. Questo significa che puoi ottenere il valore dell'ultimo evento MIDI e allo stesso tempo aspettare l'evento successivo usando quanto imparato nella sezione 10 di questo tutorial.

en: Now we've connected a MIDI device, seen its events in the cue log and discovered that our knowledge of Time State is all we need to work with the events, we can now start having fun. Let's build a simple MIDI piano:
it: Ora che abbiamo connesso un dispositivo MIDI, visto gli eventi nel cue log e scoperto che la conoscenza del Time State è tutto ciò che ci serve per lavorare con gli eventi, possiamo ora cominciare a divertirci. Costruiamo un piano MIDI semplice:

en: There's a few things going on in the code above including some issues. Firstly, we have a simple `live_loop` which will repeat forever running the code between the `do`/`end` block. This was introduced in Section 9.2. Secondly, we're calling `sync` to wait for the next matching Time State event. We use a string representing the MIDI message we're looking for (which is the same as was displayed in the cue logger). Notice that this long string is provided to you by Sonic Pi's autocompletion system, so you don't have to type it all out by hand. In the log we saw that there were two values for each MIDI note on event, so we assign the result to two separate variables `note` and `velocity`. Finally we trigger the `:piano` synth passing our note.
it: Ci sono alcune cose che succedono nel codice riportato sopra, inclusi alcuni problemi. Innanzitutto abbiamo un semplice `live_loop` che si ripete all'infinito eseguendo il codice fra i blocchi `do`/`end`. Questo è stato introdotto nella sezione 9.2. Secondariamente, stiamo chiamando `sync` per attendere il prossimo evento Time State corrispondente. Usiamo una stringa che rappresenta il messaggio MIDI che stiamo cercando (che è lo stesso mostrato nel cue logger). Nota che questa lunga stringa è fornita dal sistema di auto completamento di Sonic Pi, quindi non è necessario digitarla tutta a mano. Nel registro abbiamo visto che c'erano due valori per ogni evento MIDI note, quindi assegnamo il risultato a due diverse variabili `note` e `velocity`. Infine triggeriamo il synth `:piano` passandogli la nostra nota.

en: Now, you try it. Type in the code above, replace the sync key with a string matching your specific MIDI device and hit Run. Hey presto, you have a working piano! However, you'll probably notice a couple of problems: firstly all the notes are the same volume regardless of how hard you hit the keyboard. This can be easily fixed by using the velocity MIDI value and converting it to an amplitude. Given that MIDI has a range of 0->127, to convert this number to a value between 0->1 we just need to divide it by 127:
it: Ora prova tu. Modifica il codice sopra, sostituisci la chiave sync con una stringa che corrisponda alla tua specifica periferica MIDI e premi Run. Hey presto, hai un piano funzionante! Tuttavia, probabilmente noterai un paio di problemi: primo, tutte le note escono allo stesso volume indipendentemente dalla forza applicata sulla tastiera. Questo può essere sistemato facilmente usando il valore MIDI velocity e convertendolo in amplitude. Dato che MIDI ha un intervallo di 0->127, per convertire questo numero in un valore compreso fra 0->1 dobbiamo dividerlo per 127:

en: Update the code and hit Run again. Now the velocity of the keyboard is honoured. Next, let's get rid of that pesky pause.
it: Aggiorna il codice e premi Run di nuovo. Ora la velocity della tastiera dovrebbe essere rispettata. Ora, liberiamoci di quella fastidiosa latenza.

en: Removing Latency
it: Rimuovere la latenza

en: Before we can remove the pause, we need to know why it's there. In order to keep all the synths and FX well-timed across a variety of differently capable CPUs, Sonic Pi schedules the audio *in advance* by 0.5s by default. (Note that this added latency can be configured via the fns `set_sched_ahead_time!` and `use_sched_ahead_time`). This 0.5s latency is being added to our `:piano` synth triggers as it is added to all synths triggered by Sonic Pi. Typically we really want this added latency as it means all synths will be well timed. However, this only makes sense for synths triggered by code using `play` and `sleep`. In this case, we're actually triggering the `:piano` synth with our external MIDI device and therefore don't want Sonic Pi to control the timing for us. We can turn off this latency with the command `use_real_time` which disables the latency for the current thread. This means you can use real time mode for live loops that have their timing controlled by `sync`ing with external devices, and keep the default latency for all other live loops. Let's see:
it: Prima di poter rimuovere la latenza, dobbiamo capire da cosa è causata. Al fine di mantenere tutti i synth e gli effetti ben sincronizzati su tutte le possibili CPU e relative capacità, Sonic Pi programma l'audio *in anticipo* di 0.5 secondi come valore predefinito. (Notare che questa latenza aggiuntiva può essere configurata attraverso le funzioni `set_sched_ahead_time!` e `use_sched_ahead_time`). Questa latenza di 0.5s viene aggiunta al nostro synth `:piano` perchè viene aggiunta a tutti i synth triggerati da Sonic Pi. Tipicamente desideriamo questa latenza perchè significa avere tutti i synth ben sincronizzati. Tuttavia questo ha senso solo per i synth gestiti a codice usando `play` e `sleep`. In questo caso stiamo triggerando il synth `:piano` con un dispositivo MIDI esterno e di conseguenza non vogliamo che Sonic Pi controlli la sincronizzazione per noi. Possiamo spegnere questa latenza usando il comando `use_real_time` che disabilita la latenza per il thread corrente. Questo significa che puoi usare il modo real time per i live loop che hanno la loro sincronizzazione controllata dai `sync` con i dispositivi esterni e mantenere la latenza predefinita per tutti gli altri live loop. Vediamo:

en: Update your code to match the code above and hit Run again. Now we have a low latency piano with variable velocity coded in just 5 lines. Wasn't that easy!
it: Aggiorna il tuo codice per allinearlo al codice sopra e premi Run di nuovo. Ora abbiamo un piano a bassa latenza con velocity variabile codificato in appena 5 righe. Facile vero!

en: Getting Values
it: Ottenere i valori

en: Finally, as our MIDI events are going straight into the Time State, we can also use the `get` fn to retrieve the last seen value. This doesn't block the current thread and returns `nil` if there's no value to be found (which you can override by passing a default value - see the docs for `get`). Remember that you can call `get` in any thread at any time to see the latest matching Time State value. You can even use `time_warp` to jump back in time and call `get` to see past events...
it: Finalmente, ora che i nostri eventi MIDI vanno dritti nel Time State, possiamo anche usare la funziona `get` per recuperare l'ultimo messaggio passato. Questo non blocca il thread corrente e restituisce `nil` se nessun valore viene trovato (cosa che può essere superata passando un valore di default - vedi la documentazione per `get`). Ricorda che puoi chiamare `get` in qualunque thread in qualunque momento per vedere l'ultimo evento corrispondente al valore nel Time State. Puoi anche usare `time_warp` per tornare indietro nel tempo e chiamare `get` per vedere gli eventi passati...

en: Now You are in Control
it: Ora hai tu il controllo

en: In addition to receiving MIDI events we can also send out MIDI events to trigger and control external hardware synths, keyboards and other devices. Sonic Pi provides a full set of fns for sending various MIDI messages such as:
it: In aggiunta alla ricezione degli eventi MIDI, possiamo anche inviare eventi MIDI per controllare synth esterni, tastiere e altri dispositivi. Sonic Pi fornisce un set completo di funzioni per mandare vari eventi MIDI come ad esempio:

en: There are many other supported MIDI messages too - check out the API documentation for all the other fns that start with `midi_`.
it: Ci sono inoltre molti altri messaggi MIDI supportati - Controlla la documentazione API per tutte le altre funzioni che cominciano per `midi_`.

en: Connecting to a MIDI Device
it: Collegamento di un dispositivo MIDI

en: In order to send a MIDI message to an external device, we must first have connected it. Check out the subsection 'Connecting a MIDI Controller' in section 11.1 for further details. Note that if you're using USB, connecting to a device which you're sending to (rather than receiving from) is the same procedure. However, if you're using the classic DIN connectors, make sure you connect to the MIDI out port of your computer. You should see your MIDI device listed in the preferences pane.
it: Per poter inviare messaggi MIDI a un dispositivo esterno, dobbiamo prima averlo collegato. Controlla la sotto-sezione "Collegamento di un Controller MIDI" nella sezione 11.1 per ulteriori dettagli. Nota che se stai usando la porta USB, il collegamento di un dispositivo per l'invio (e la ricezione) segue la stessa procedura. Tuttavia, se stai usando il classico connettore DIN, assicurati di aver collegato il dispositivo alla porta MIDI Out del tuo computer. Dovresti vedere il tuo dispositivo MIDI elencato nel pannello preferenze.

en: Sending MIDI events
it: Invio degli eventi MIDI

en: The many `midi_*` fns work just like `play`, `sample` and `synth` in that they send a message at the current (logical) time. For example, to spread out calls to the `midi_*` fns you need to use `sleep` just like you did with `play`. Let's take a look:
it: Le molte funzioni `midi_*` funzionano esattamente come play`, `sample` e `synth`, mandando un messaggio al tempo (logico) corrente. Per esempio, per distribuire chiamate alla funzione `midi_*` dovrai usare `sleep` come hai fatto per `play`. Diamo un'occhiata:

en: This will send a MIDI note on event to the connected MIDI device with velocity 50. (Note that Sonic Pi will automatically convert notes in the form `:e3` to their corresponding MIDI number such as 52 in this case.)
it: Questo invierà un evento MIDI note on al dispositivo MIDI connesso con velocity 50. (Nota che Sonic Pi convertirà le note dal formato `:e3` al loro numero MIDI corrispondente come ad esempio 52 in questo caso.)

en: If your connected MIDI device is a synthesiser, you should be able to hear it playing a note. To disable it use `midi_note_off`:
it: Se il dispositivo collegato è un sintetizzatore, dovresti sentirlo suonare una nota. Per disabilitarla, usa `midi_note_off`:

en: Selecting a MIDI device
it: Selezionare un dispositivo MIDI

en: By default, Sonic Pi will send each MIDI message to all connected devices on all MIDI channels. This is to make it easy to work with a single connected device without having to configure anything. However, sometimes a MIDI device will treat MIDI channels in a special way (perhaps each note has a separate channel) and also you may wish to connect more than one MIDI device at the same time. In more complicated setups, you may wish to be more selective about which MIDI device receives which message(s) and on which channel.
it: Come impostazione predefinita, Sonic Pi manda ogni messaggio MIDI a tutti i dispositivi connessi su tutti i canali MIDI. Questo è per rendere semplice lavorare con un singolo dispositivo connesso senza dover configurare nulla. Tuttavia, talvolta un dispositivo MIDI gestirà i canali MIDI in un modo particolare (magari ogni nota ha un canale separato) e magari avresti bisogno di collegare più di un dispositivo contemporaneamente. In allestimenti più complessi, potresti voler essere più selettivo riguardo a quale dispositivo MIDI riceve quale messaggio attraverso quale canale.

en: We can specify which device to send to using the `port:` opt, using the device name as displayed in the preferences:
it: Possiamo specificare a quale dispositivo inviare usando l'opzione `port:`, usando il nome dispositivo come è mostrato nelle preferenze:

en: We can also specify which channel to send to using the `channel:` opt (using a value in the range 1-16):
it: Possiamo anche specificare in quale canale inviare usando l'opzione `channel:` (usando un valore compreso nell'intervallo 1-16):

en: Of course we can also specify both at the same time to send to a specific device on a specific channel:
it: Naturalmente possiamo specificare entrambe le cose contemporaneamente, per un dispositivo specifico su un canale specifico:

en: Finally, a really fun thing to do is to connect the audio output of your MIDI synthesiser to one of the audio inputs of your soundcard. You can then control your synth with code using the `midi_*` fns and also manipulate the audio using `live_audio` and FX:
it: Infine, una cosa veramente divertente da fare è collegare l'uscita audio del tuo sintetizzatore MIDI a uno degli ingressi della tua scheda audio. Puoi a quel punto controllare il tuo sintetizzatore usando le funzioni `midi_*` e allo stesso tempo manipolare l'audio usando `live_audio` ed effetti:

en: (The fn `midi` is available as a handy shortcut to sending both note on and note off events with a single command. Check out its documentation for further information).
it: (La funzione `midi` è disponibile con una comoda scorciatoia per mandare sia eventi note on che note off con un comando singolo. (Controlla questa documentazione per ulteriori informazioni).

en: In addition to MIDI, another way to get information in and out of Sonic Pi is via the network using a simple protocol called OSC - Open Sound Control. This will let you send messages to and from external programs (both running on your computer and on external computers) which opens up the potential for control way beyond MIDI which has limitations due to its 1980s design.
it: In aggiunta al MIDI, un altro modo per ottenere informazioni da e verso Sonic Pi è via rete usando un semplice protocollo chiamato OSC - Open Sound Control. Questo ti permetterà di inviare messaggi a e da programmi esterni (sia che siano in esecuzione sul tuo computer o computer esterni) il che apre a un potenziale molto più avanzato rispetto al MIDI che risente di limitazioni derivante dalla sua concezione risalente agli anni 80.

en: For example, you could write a program in another programming language which sends and receives OSC (there are OSC libraries for pretty much every common language) and work directly with Sonic Pi. What you can use this for is only limited by your imagination.
it: Per esempio puoi scrivere un programma con un altro linguaggio di programmazione che invia e riceve OSC (ci sono librerie OSC per praticamente ogni linguaggio comune) e interagisce direttamente con Sonic Pi. Le possibili applicazioni di questo sono limitate solo dalla tua immaginazione.

en: 12.1 Receiving OSC
it: 12.1 Ricevere OSC

en: Receiving OSC
it: Ricevere OSC

en: A Basic OSC Listener
it: Un listener OSC basico

en: Let's build a basic OSC listener:
it: Costruiamo un listener OSC basico:

en: In this example we described an OSC path `"/osc*/trigger/prophet"` which we're syncing on. This can be any valid OSC path (all letters and numbers are supported and the `/` is used like in a URL to break up the path to multiple words). The `/osc` prefix is added by Sonic Pi to all incoming OSC messages, so we need to send an OSC message with the path `/trigger/prophet` for our `sync` to stop blocking and the prophet synth to be triggered.
it: In questo esempio viene descritto un percorso OSC `"/osc*/trigger/prophet"` col quale ci stiamo sincronizzando. Questo può essere un qualunque percorso OSC valido (tutte le lettere e numeri sono supportati e la `/` è usata come in un URL per separare il percorso in parole multiple.) Il prefisso `/osc` viene aggiunto da Sonic Pi a tutti i messaggi OSC in ingresso, quindi dobbiamo mandare un messaggio OSC con un percorso `/trigger/prophet` per fare in modo che il nostro `sync` interrompa il blocco e il sintetizzatore prophet sia innescato.

en: Sending OSC to Sonic Pi
it: Mandare OSC a Sonic Pi

en: We can send OSC to Sonic Pi from any programming language that has an OSC library. For example, if we're sending OSC from Python we might do something like this:
it: Possiamo inviare OSC a Sonic Pi da qualunque linguaggio di programmazione che abbia una libreria OSC. Ad esempio, se stiamo mandando OSC da Python potremmo fare qualcosa tipo questo:

en: Or, if we're sending OSC from Clojure we might do something like this from the REPL:
it: Oppure, se stiamo inviando OSC da Clojure potremmo fare qualcosa di questo tipo dal REPL:

en: Receiving from External Machines
it: Ricevere da Macchine Esterne

en: For security reasons, by default Sonic Pi does not let remote machines send it OSC messages. However, you can enable support for remote machines in Preferences->IO->Networked OSC->Allow OSC from other computers. Once you've enabled this, you can receive OSC messages from any computer on your network. Typically the sending machine will need to know your IP address (a unique identifier for your computer on your network - kind of like a phone number or an email address). You can discover the IP address of your computer by looking at the IO section of the preferences pane. (If your machine happens to have more than one IP address, hovering the mouse over the listed address will pop up with a list of all known addresses).
it: Per ragioni di sicurezza, Sonic Pi non permette per default che macchine remote gli mandino messaggio OSC. Tuttavia, puoi abilitare il supporto per macchine esterne in Preferences->IO->Networked OSC->Allow OSC da altri computer. Una volta abilitato questo, puoi ricevere messaggi OSC da qualunque computer nel tuo network. Tipicamente la macchina che invia dovrà conoscere il tuo l'indirizzo IP (un identificatore univoco per il tuo computer nella tua rete - tipo un numero di telefono o un indirizzo email). Puoi scoprire l'indirizzo ip del tuo computer guardando nella sezione IO nel pannello preferenze. (Nel caso la tua macchina avesse più di un indirizzo ip, passando col mouse sopra l'indirizzo mostrato comparirà elenco con tutti gli indirizzi conosciuti).

en: Note, some programs such as TouchOSC for iPhone and Android support sending OSC as a standard feature. So, once you're listening to remote machines and know your IP address you can instantly start sending messages from apps like TouchOSC which enable you to build your own custom touch controls with sliders, buttons, dials etc. This can provide you with an enormous range of input options.
it: Nota: alcuni programmi tipo TouchOSC per iPhone e Android supportano invio di OSC come caratteristica standard. Quindi, una volta che sei in ascolto di macchine remote e conosci il tuo indirizzo IP, puoi istantaneamente cominciare a mandare messaggi da app come TouchOSC che ti permette di costruire la tua superficie di controllo personalizzata con slider, bottoni, tasti ecc. Con questo puoi ottenere un'enorme gamma di opzioni.

en: 12.2 Sending OSC
it: 12.2 Mandare OSC

en: Sending OSC
it: Mandare OSC

en: In addition to receiving OSC and working with it using Time State, we can also send out OSC messages in time with our music (just like we can send out MIDI messages in time with our music). We just need to know which IP address and port we're sending to. Let's give it a try:
it: In aggiunta al ricevere OSC e lavorarci usando Time State, possiamo anche inviare messaggi OSC a tempo con la nostra musica (esattamente come possiamo inviare messaggi MIDI a tempo con la nostra musica). Dobbiamo solo conoscere a quale indirizzo IP e porta stiamo inviando. Proviamolo:

en: If you run the code above, you'll notice that Sonic Pi is sending itself an OSC message! This is because we set the IP address to the current machine and the port to the default OSC in port. This is essentially the same as posting a letter to yourself - the OSC packet is created, leaves Sonic Pi, gets to the network stack of the operating system which then routes the packet back to Sonic Pi and then it's received as a standard OSC message and is visible in the cue logger as the incoming message `/osc:127.0.0.1:4560/hello/world`. (Notice how Sonic Pi automatically prefixes all incoming OSC messages with `/osc` and then the hostname and port of the sender.)
it: Se esegui il codice sopra, noterai che Sonic Pi sta mandando a sé stesso un messaggio OSC! Questo perché abbiamo impostato l'indirizzo IP alla macchina locale e la porta OSC predefinita. Questo è esattamente come mandare una lettera a sé stessi - il pacchetto OSC viene creato, lascia Sonic Pi, va alla struttura network del tuo sistema operativo la quale ruota indietro il pacchetto verso Sonic pi che poi lo riceve come messaggio OSC standard ed è visibile nel registro cue come messaggio in ingresso `/osc:127.0.0.1:4560/hello/world`. (Nota come Sonic Pi aggiunga automaticamente prefisso `/osc` a tutti i messaggi OSC in ingresso seguito da nome host e porta dell'inviante.)

en: Sending OSC to other programs
it: Mandare OSC ad altri programmi

en: Of course, sending OSC messages to ourselves may be fun but it's not that useful. The real benefit starts when we send messages to other programs:
it: Naturalmente, mandare messaggi OSC a noi stessi potrebbe essere divertente ma non è molto utile. I veri benefici cominciano quando mandiamo messaggi ad altri programmi:

en: In this case we're assuming there's another program on the same machine listening to port 123456. If there is, then it will receive a `"/hello/world` OSC message with which it can do what it wants.
it: In questo caso stiamo assumendo che ci sia un altro programma sulla stessa macchina in ascolto sulla porta 123456. Se c'è, allora riceverà un messaggio OSC `"/hello/world` col quale può fare ciò che vuole.

en: If our program is running on another machine, we need to know its IP address which we use instead of `"localhost"`:
it: Se il nostro programma sta girando su un'altra macchina, dovremo conoscere il suo indirizzo IP che useremo al posto di `"localhost"`:

en: Now we can send OSC messages to any device reachable to us via our local networks and even the internet!
it: Ora possiamo inviare messaggi OSC a qualunque dispositivo che possiamo raggiungere nella nostra rete locale e anche su internet!

en: 13 Multichannel Audio
it: 13 Audio Multicanale

en: Multichannel Audio
it: Audio Multicanale

en: So far, in terms of sound production, we've explored triggering synths and recorded sounds via the fns `play`, `synth` and `sample`. These have then generated audio which has played through our stereo speaker system. However, many computers also have the ability to input sound, perhaps through a microphone, in addition to the ability to send sound out to more than two speakers. Often, this capability is made possible through the use of an external sound card - these are available for all platforms. In this section of the tutorial we'll take a look at how we can take advantage of these external sound cards and effortlessly work with multiple channels of audio in and out of Sonic Pi.
it: Fino a ora, in termini di produzione audio, abbiamo esplorato l'innesco di sintetizzatori e riprodotto suoni attraverso le funzioni `play`, `synth` e `sample`. Queste hanno quindi generato audio che è stato riprodotto attraverso il nostro sistema di diffusori stereo. Tuttavia, molti computer hanno anche la possibilità di gestire audio in ingresso, magari attraverso un microfono, in aggiunta alla possibilità di mandare audio a più di due diffusori. Spesso, questa capacità è resa possibile grazie all'uso di schede audio esterne - queste sono disponibili per tutte le piattaforme. in questa sezione del tutorial daremo un'occhiata a come possiamo sfruttare queste schede audio esterne e lavorare facilmente con canali audio multipli in ingresso. e in uscita da Sonic Pi.

en: 13.1 Sound In
it: 13.1 Suono in ingresso

en: Sound In
it: Suono in ingresso

en: One simple (and perhaps familiar) way of accessing sound inputs is using our friend `synth` by specifying the `:sound_in` synth:
it: Un modo semplice (e magari familiare) per accedere ai suoni in ingresso è usare il nostro amico `synth` specificando il synth `:sound_in`:

en: This will operate just like any synth such as `synth :dsaw` with the exception that the audio generated will be read directly from the first input of your system's sound card. On laptops, this is typically the built-in microphone, but if you have an external sound card, you can plug any audio input to the first input.
it: Questo opererà proprio come qualunque altro synth tipo `synth :dsaw` con l'eccezione che l'audio generato sarà letto direttamente dal primo ingresso della tua scheda audio di sistema. Sui computer portatili, questo è tipicamente il microfono integrato, ma se hai una scheda audio esterna, puoi collegare qualunque sorgente audio al primo ingresso.

en: One thing you might notice is that just like `synth :dsaw` the `:sound_in` synth only lasts for 1 beat as it has a standard envelope. If you'd like to keep it open for a little longer, change the ADSR envelope settings. For example the following will keep the synth open for 8 beats before closing the connection:
it: Una cosa che potresti notare è che, proprio come `synth :dsaw` il synth `:sound_in` dura solo 1 beat in quanto ha un envelope standard. Se vuoi tenerlo aperto un po' più a lungo, cambia le impostazioni ADSR envelope. Ad esempio, quanto segue terrà il synth aperto per 8 beat prima di chiudere la connessione:

en: Of course, just like any normal synth, you can easily layer on effects with the FX block:
it: Naturalmente, come per qualunque altro synth normale, puoi aggiungere facilmente effetti tramite il blocco FX:

en: If you have plugged in a guitar to your first input, you should be able to hear it with distortion and reverb until the synth terminates as expected.
it: Se hai collegato una chitarra al tuo primo ingresso, dovresti riuscire a sentirla con distorsione e riverbero fino a che il synth termina come atteso.

en: You are free to use the `:sound_in` synth as many times as you like concurrently (just like you would do with any normal synth). For example, the following will play two `:sound_in` synths at the same time - one through distortion and one through reverb:
it: Sei libero di usare il synth `:sound_in` quante volte vuoi contemporaneamente (proprio come faresti con qualunque altro synth). Ad esempio, quanto segue suonerà due synth `:sound_in` simultaneamente - uno con distorsione e uno con riverbero:

en: You can select which audio input you want to play with the `input:` opt. You can also specify a stereo input (two consecutive inputs) using the `:sound_in_stereo` synth. For example, if you have a sound card with at least three inputs, you can treat the first two as a stereo stream and add distortion and the third as a mono stream and add reverb with the following code:
it: Puoi selezionare quale ingresso audio far suonare attraverso l'opzione `input:`. Puoi anche specificare un ingresso stereo (2 ingressi paralleli) usando il synth `:sound_in_stereo`. Per esempio, se hai una scheda audio con almeno 3 ingressi, puoi trattare i primi 2 come un flusso stereo e aggiungere distorsione, e il terzo come un flusso mono con riverbero aggiunto con il seguente codice:

en: Potential Issues
it: Potenziali problemi

en: However, although this is a useful technique, there are a couple of limitations to this approach. Firstly, it only works for a specific duration (due to it having an ADSR envelope) and secondly, there's no way to switch the FX around once the synth has been triggered. Both of these things are typical requests when working with external audio feeds such as microphones, guitars and external synthesisers. We'll therefore take a look at Sonic Pi's solution to the problem of manipulating a (potentially) infinite stream of live audio input: `live_audio`.
it: Anche se è una tecnica molto utile, ci sono un paio di limitazioni a questo approccio. Innanzitutto funziona solo per una specifica durata (in seguito al fatto che ha un envelopre ADSR) e secondariamente non c'è modo di cambiare l'effetto una volta che il synth è stato aperto. Entrambe queste cose sono tipicamente richieste quando si lavora con sorgenti audio esterne come microfoni, chitarre e sintetizzatori esterni. Daremo tuttavia un'occhiata alle soluzioni di Sonic Pi a questo problema di manipolazione di un (potenzialmente) infinito flusso di ingresso audio `live_audio`.

en: The `:sound_in` synth as described in the previous section provides a very flexible and familiar method for working with input audio. However, as also discussed it has a few issues when working with a single input of audio as a single instrument (such as a voice or guitar). By far the best approach to working with a single continuous stream of audio is to use `live_audio`.
it: Il synth `:sound_in`, come descritto nella sezione precedente, fornisce un metodo molto semplice e flessibile per lavorare con audio in ingresso. Tuttavia, come già discusso, ha qualche problema quando si lavora con un singolo ingresso audio come singolo strumento (come una voce o una chitarra). Di gran lunga il miglior approccio per un singolo flusso di audio continuo è l'uso di `live_audio`.

en: A Named Audio Input
it: Un Ingresso Audio Nominato

en: `live_audio` shares a couple of core design constraints with `live_loop` (hence the similar name). Firstly it must have a unique name and secondly only one `live_audio` stream with that name may exist at any one time. Let's take a look:
it: `live_audio` condivide un paio di restrizioni di base con `live_loop` (da qui il nome simile). Innanzitutto deve avere un nome univoco e secondariamente solo un flusso `live_audio` per volta con quel nome può esistere nello stesso momento. Diamo un'occhiata:

en: This code will act in a similar fashion to `synth :sound_in` with some key differences: it runs forever (until you explicitly stop it) and you can *move* it to new FX contexts dynamically.
it: Questo codice si comporterà in modo analogo a `synth :sound_in` con alcune differenze chiave: viene eseguito per sempre (fino a che non lo interrompi esplicitamente) e puoi "spostarlo" a un nuovo contesto di effetti dinamicamente.

en: Working with FX
it: Lavorare con FX

en: On initial triggering `live_audio` works exactly as you might expect it to work with FX. For example, to start a live audio stream with added reverb simply use a `:reverb` FX block:
it: All'innesco iniziale `live_audio` funziona esattamente come ti aspetteresti che funzioni con FX. Ad esempio, per avviare un flusso audio con aggiunta di riverbero semplicemente usa il blocco FX `:reverb`:

en: However, given that `live_audio` runs forever (at least until you stop it) it would be pretty limiting if, like typical synths, the live audio was bound within the `:reverb` FX for its entire existence. Luckily this is not the case and it was designed to be easy to move between different FX. Let's try it. Run the code above to hear live audio coming directly from the first input of your sound card. Note, if you're using a laptop, this will typically be out of your built-in microphone, so it's recommended to use headphones to stop feedback.
it: Tuttavia, dato che `live_audio` gira per sempre (almeno fino a quando lo fermi) sarebbe piuttosto limitante se, come tipicamente i synth, fosse chiuso dentro un blocco FX `:reverb` per la sua intera esistenza. Fortunatamente non è questo il caso in quanto è stato progettato per essere semplice spostarsi su un FX diverso. Proviamo. Esegui il codice sopra per sentire l'audio dal vivo proveniente dal primo ingresso della tua scheda audio. Nota, se stai usando un portatile, questo sarà tipicamente il microfono integrato quindi è consigliabile usare le cuffie per prevenire il feedback.

en: Now, hit Run, and you'll immediately hear the audio played through the echo FX and no longer through reverb. If you wanted them both, just edit the code again and hit Run:
it: Ora, premi Run, e sentirai immediatamente l'audio riprodotto attraverso un FX echo e non più attraverso riverbero. Se li avessi voluti entrambi, semplicemente modifica il codice nuovamente e premi Run:

en: Stopping live audio
it: Fermare live Audio

en: Unlike standard synths, as `live_audio` has no envelope, it will continue running forever (even if you delete the code, just like a function is still defined in memory if you delete the code in the editor). To stop it, you need to use the `:stop` arg:
it: A differenza dei synth standard, dato che `live_audio` non ha un envelope, continuerà a girare all'infinito (anche se cancelli il codice, come una funzione rimane definita in memoria se cancelli il codice nell'editor). Per fermarlo devi usare l'arg `:stop`:

en: It can easily be restarted by calling it without the `:stop` arg again:
it: Può essere facilmente riavviato chiamandolo senza l'arg `:stop`:

en: Additionally all running live audio synths are stopped when you hit the global Stop button (as with all other running synths and FX).
it: Addizionalmente, tutti i synth live audio vengono arrestati quando premi il pulsante Stop globale (come per tutti gli altri synth e FX in esecuzione).

en: Stereo input
it: Ingressi Stereo

en: With respect to audio channels, by default `live_audio` acts similarly to the `:sound_in` synth in that it takes a single mono input stream of audio and converts it to a stereo stream using the specified panning. However, just like `:sound_in_stereo` it's also possible to tell `live_audio` to read two consecutive audio inputs and treat them as the left and right channels directly. This is achieved via the `:stereo` opt. For example, to treat input 2 as the left signal and input 3 as the right signal, you need to configure the `input:` opt to 2 and enable stereo mode as follows:
it: Rispetto ai canali audio, di default `live_audio` si comporta in modo simile al synth `:sound_in` in quanto prende un flusso audio mono e lo converte in un flusso stereo usando un panning specifico. Tuttavia, come `:sound_in_stereo` è possibile dire a `live_audio` di leggere 2 ingressi audio consecutivi e trattarli come canali destro e sinistro direttamente. Questo si ottiene attraverso l'opzione `:stereo`. Ad esempio, per trattare ingresso 2 come segnale sinistro e ingresso 3 come segnale destro, devi configurare l'opzione `input:` a 2 e abilitare modalità stereo come segue:

en: Note that once you have started a live audio stream in stereo mode, you cannot change it to mono without stopping and starting. Similarly, if you start it in the default mono mode, you can't switch to stereo without starting and stopping the stream.
it: Notare che dopo aver avviato lo stream audio in modalità stereo, non puoi cambiarla a mono senza fermarla e riavviarla. Similmente, se avvi nella modalità mono di default, non puoi passare a stereo senza fermare e riavviare il flusso.

en: So far in this section we've looked at how to get multiple streams of audio into Sonic Pi - either through the use of the `:sound_in` synth or via the powerful `live_audio` system. In addition to working with multiple streams of input audio, Sonic Pi can also output multiple streams of audio. This is achieved via the `:sound_out` FX.
it: Fino a qui abbiamo visto come ottenere flussi audio multipli in Sonic pi - sia attraverso l'uso del synth `:sound_in` sia attraverso il potente sistema `live_audio`. In aggiunta all'uso di flussi audio multipli in ingresso, Sonic Pi può erogare flussi audio multipli in uscita. Questo si ottiene tramite l'FX `:sound_out`.

en: Output contexts
it: Contesti di Uscita

en: Let's quickly recap on how Sonic Pi's synths and FX output their audio to their current FX context. For example, consider the following:
it: Facciamo un rapido riepilogo di come i synth ed FX di Sonic pi erogano il loro audio nel loro contesto FX corrente. Ad esempio, consideriamo quanto segue:

en: The simplest way to understand what's happening with the audio stream is to start at the innermost audio context and work our way out. In this case, the innermost context is labelled `A` and is the `:bd_haus` sample being triggered. The audio for this goes directly into its context which is `B` - the `:echo` FX. This then adds echo to the incoming audio and outputs it to its context which is `C` - the `:reverb` FX. This then adds reverb to the incoming audio and outputs to its context which is the top level - the left and right speakers (outputs 1 and 2 in your audio card). The audio flows outwards with a stereo signal all the way through.
it: Il modo più semplice per capire cosa succede al flusso audio è cominciare dal contesto audio più annidato e man mano valutarne i contorni. In questo caso l'oggetto più annidato è etichettato `A` ed è il sample `:bd_haus` che viene triggerato. L'audio di questo va direttamente nel suo contesto che è `B` - ovvero `:echo` FX. Questo aggiunge echo all'audio in arrivo e lo eroga nel suo contesto che è `C` - ovvero `:reverb` FX. Questo aggiunge quindi riverbero al flusso audio in ingresso e lo eroga nel suo contesto che è il livello più alto - ovvero diffusori sinistro e destro (uscita 1 e 2 della tua scheda audio). L'audio fluisce in uscita in un segnale stereo direttamente.

en: The above behaviour is true for all synths (including `live_audio`) and the majority of FX with the exception of `:sound_out`. The `:sound_out` FX does two things. Firstly it outputs its audio to its external context as described above. Secondly it *also* outputs its audio directly to an output on your sound card. Let's take a look:
it: Il comportamento sopra è vero per tutti i synth (incluso `live_audio`) e la maggioranza degli FX ad eccezione di `:sound_out`. L'FX `:sound_out` fa due cose. Innanzitutto eroga il proprio audio nel suo contesto esterno come descritto sopra. Secondariamente eroga *anche* il proprio audio direttamente verso un'uscita della tua scheda audio. Diamo un'occhiata:

en: In this example, our `:bd_haus` sample outputs its audio to its external context which is the `:sound_out` FX. This in turn outputs its audio to its external context the `:reverb` FX (as expected). However, it *also* outputs a mono mix to the 3rd output of the system's soundcard. The audio generated within `:sound_out` therefore has two destinations - the `:reverb` FX and audio card output 3.
it: In questo esempio, il nostro sample `:bd_haus`eroga il proprio audio nel suo contesto esterno che è l'FX `:sound_out`. Questo a sua volta eroga il proprio audio al suo contesto esterno `:reverb` FX (come atteso). Tuttavia eroga *anche* un mix mono alla terza uscita della scheda audio di sistema. L'audio generato all'interno di `:sound_out` tuttavia ha due destinazioni - l'FX `:reverb` e l'uscita 3.

en: Mono and Stereo out
it: Mono e Stereo out

en: As we have also seen, the default behaviour for `:sound_out` and `:sound_out_stereo` is to send the audio both to their external context (as is typical of all FX) *and* to the specified output on your soundcard. However, occasionally you may wish to *only* send to the output on your soundcard and not to the external context (and therefore not have any chance of the sound being mixed and sent to the standard output channels 1 and 2). This is possible by using the standard FX opt `amp:` which operates on the audio *after* the FX has been able to manipulate the audio:
it: Come abbiamo visto, il comportamento di default per `:sound_out` e `:sound_out_stereo` è mandare audio sia nel loro contesto esterno (come tipicamente tutti gli FX) *e* a un'uscita specifica della scheda audio. Tuttavia, occasionalmente potresti voler mandare *solo* all'uscita della tua scheda audio e non al contesto esterno (e di conseguenza evitare che il suono sia mixato e mandato alle uscite standard 1 e 2). Questo è possibile usando l'opzione FX standard amp:` che interviene sull'audio *dopo* che l'FX ha potuto manipolare l'audio:

en: In the above example, the `:loop_amen` sample is sent to its outer context, the `:sound_out` FX. This then sends a mono mix to audio card output 3 and then multiplies the audio by 0 which essentially silences it. It is this silenced signal which is then sent out to the `:sound_out`'s outer context which is the standard output. Therefore with this code, the default output channels will not receive any audio, and channel 3 will receive a mono mix of the amen drum break.
it: Nell'esempio sopra, il sample `:loop_amen` viene mandato al suo contesto esterno, l'FX `:sound_out`. Questo a sua volta manda un mix mono all'uscita 3 della scheda audio dopo di che l'audio per 0, cosa che in pratica lo silenzia. E' proprio questo segnale silenziato che viene inviato al contesto esterno `:sound_out, che è a sua volta l'output standard. Quindi con questo codice, i canali di uscita audio predefiniti non riceveranno alcun audio, mentre il canale 3 riceverà un mix mono del break di batteria `amen` .

en: Conclusions
it: Conclusioni

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.
it: Abbiamo concluso il tutorial introduttivo di Sonic Pi. Spero che tu abbia imparato qualcosa. Non ti preoccupare se non hai capito tutto nel dettaglio, suona e divertiti. Sentiti libero di tornare indietro quando ti vengono domande su sezioni di cui abbiamo parlato in questo tutorial.

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.
it: Infine, ti invito a dare un'occhiata al resto della documentazione presente in questo help. Ci sono cose di cui non abbiamo parlato che non vedono l'ora di essere scoperte.

en: So play, have fun, share your code, perform for your friends, show your screens and remember:
it: Per cui suona, divertiti, condividi il tuo codice, esibisciti per i tuoi amici, mostra il tuo schermo e ricorda:

en: *There are no mistakes, only opportunities.*
it: *Non ci sono errori, solo opportunità.*

en: A Appendix A - MagPi Articles
it: A Appencice A - Articoli MagPi

en: MagPi Articles
it: Articoli MagPi

en: Appendix A collects all the Sonic Pi articles written for the MagPi magazine.
it: L'appendice A contiene una raccolta di tutti gli articoli su Sonic Pi scritti per il magazine MagPi.

en: Dive into Topics
it: Scopri gli argomenti

en: These articles aren't meant to be read in any strict order and contain a lot of cross-over material from the tutorial itself. Rather than try and teach you all of Sonic Pi, they instead each focus on a specific aspect of Sonic Pi and cover it in a fun and accessible way.
it: Questi articoli non sono pensati per essere letti in un ordine specifico dal momento che contengono materiale che copre vari argomenti. Invece che provare a insegnarti a usare Sonic Pi per intero, ciascuno si concentra su un aspetto specifico di Sonic Pi e cerca di coprirlo in modo accessibile.

en: Read the MagPi
it: Leggi il magazine MagPi

en: You can see them in their glorious professionally typeset form in the free PDF downloads of The MagPi here: https://www.raspberrypi.org/magpi/
it: Puoi vederli nella loro forma professionale in PDF gratuito qui: https://www.raspberrypi.org/magpi/

en: Suggest a Topic
it: Suggerisci un argomento

en: If you don't see a topic that interests you covered in these articles - why not suggest one? The easiest way to do that is to tweet your suggestion to [@Sonic_Pi](http://twitter.com/sonic_pi). You never know - your suggestion might be the subject of the next article!
it: Se non trovi un argomento di tuoi interesse in questi articoli, perché non suggerirne uno? Il modo più semplice è di twittare a [@Sonic_Pi](http://twitter.com/sonic_pi). Non si può mai sapere, magari il tuo suggerimento diventerà il prossimo articolo!

en: A.1 Tips for Sonic Pi
it: A.1 Consigli per Sonic Pi

en: Five Top Tips
it: I cinque consigli migliori

en: 1. There are no mistakes
it: 1. Non ci sono errori

en: The most important lesson to learn with Sonic Pi is that there really are no mistakes. The best way to learn is to just try and try and try. Try lots of different things out, stop worrying whether your code sounds good or not and start experimenting with as many different synths, notes, FX and opts as possible. You'll discover a lot of things that make you laugh because they sound just awful and some real gems that sound truly amazing. Simply drop the things you don't like and keep the things you do. The more 'mistakes' you allow yourself to make the quicker you'll learn and discover your personal coding sound.
it: La lezione più importante da imparare con Sonic Pi è che non ci sono errori. Il modo migliore di imparare è provando. Prova un sacco di cose, smettila di preoccuparti se il tuo codice suona bene o no e prova diversi synth, note, effetti e parametri. Scoprirai un sacco di cose che ti faranno divertire perché suonano in modo orribile e alcune gemme preziose che suoneranno incredibilmente. Semplicemente elimina le cose che non ti piacciono e tieni quelle che ti piacciono. Più 'errori' ti permetti di fare, più velocemente imparerai.

en: 2. Use the FX
it: 2. Usa gli effetti

en: Say you've already mastered the Sonic Pi basics of making sounds with `sample`, `play`? What's next? Did you know that Sonic Pi supports over 27 studio FX to change the sound of your code? FX are like fancy image filters in drawing programs except that instead of blurring or making something black and white, you can add things like reverb, distortion and echo to your sound. Think of it like sticking the cable from your guitar to an effects pedal of your choice and then into the amplifier. Luckily, Sonic Pi makes using FX really easy and requires no cables! All you need to do is to choose which section of your code you'd like the FX added to and wrap it with the FX code. Let's look at an example. Say you had the following code:
it: Scommetto che hai imparato a utilizzare le funzioni di base di Sonic Pi come `sample` e `play`. Cosa c'è dopo? Lo sapevi che Sonic Pi ha al suo interno più di 27 effetti per cambiare il suono del tuo codice? Gli effetti sono come i filtri nei programmi di grafica solo che invece di sfocare l'immagine o trasformarla in bianco e nero aggiungono riverbero, distorsione, echo. Pensali come se stessi collegando un pedale da chitarra all'amplificatore. Per fortuna Sonic Pi rende l'utilizzo degli FX super semplice e non richiede cavi! Tutto quello che devi fare è prendere una sezione di codice e racchiuderla dentro un effetto. Proviamo con un esempio:

en: If you wanted to add FX to the `:loop_garzul` sample, you'd just tuck it inside a `with_fx` block like this:
it: Se vuoi aggiungere un effetto al campione `:loop_garzul`, metti tutto dentro il blocco `with_fx`:

en: Now, if you wanted to add FX to the bass drum, go and wrap that with `with_fx` too:
it: Ora, se vuoi aggiungere un effetto alla cassa della batteria, inserisci anche quella dentro `with_fx`:

en: Remember, you can wrap *any* code within `with_fx` and any sounds created will pass through that FX.
it: Ricorda: puoi inserire *qualsiasi* codice dentro `with_fx` e ogni suono creato passerà attraverso quell'effetto.

en: 3. Parameterise your synths
it: 3. Controllare i sintetizzatori

en: In order to really discover your coding sound you'll soon want to know how to modify and control synths and FX. For example, you might want to change the duration of a note, add more reverb, or change the time between echoes. Luckily, Sonic Pi gives you an amazing level of control to do exactly this with special things called optional parameters or opts for short. Let's take a quick look. Copy this code into a workspace and hit run:
it: Per scoprire i tuoi suoni, avrai presto bisogno di modificar e controllare i tuoi synth e gli effetti. Per esempio, magari vuoi cambiare la lunghezza di una nota, aggiungere più riverbero, cambiare il tempo tra le ripetizioni dell'eco. Sonic Pi ti permette di avere un grande livello di controllo attraverso i parametri opzionali. Vediamo velocemente come fare. Copia il seguente codice e premi Run:

en: Ooh, a lovely guitar sound! Now, let's start playing with it. How about changing its rate?
it: Ooh, un bellissimo suono di chitarra. Ora cominciamo a giocarci. Perché non cambiare la velocità?

en: Hey, what's that `rate: 0.5` bit I just added at the end? That's called an opt. All of Sonic Pi's synths and FX support them and there's loads to play around with. They're also available for FX too. Try this:
it: Hey, cos'è quel `rate: 0.5` che ho appena aggiunto alla fine? È un parametro. Tutti i synth e gli effetti in Sonic Pi li supportano e ce ne sono un sacco con cui giocare. Sono disponibili anche per gli effetti; prova questo:

en: The best way to quickly experiment and explore Sonic Pi is to live code. This allows you to start off some code and continually change and tweak it whilst it's still playing. For example, if you don't know what the cutoff parameter does to a sample, just play around. Let's have a try! Copy this code into one of your Sonic Pi workspaces:
it: Il modo migliore per sperimentare velocemente con Sonic Pi è attraverso il live code. Questo ti permette di partire con del codice e continuare a cambiarlo mentre continua a funzionare. Per esempio, se non sai cosa fa il parametro di cutoff a un campione, prova a usarlo. Copia questo codice in un workspace:

en: Now, hit run and you'll hear a slightly muffled drum break. Now, change the `cutoff:` value to `80` and hit run again. Can you hear the difference? Try `90`, `100`, `110`...
it: Ora previ run e sentirai un suono di batteria soffocato. Ora cambia il valore di `cutoff:` a `80` e premi di nuovo run. Riesci a sentire la differenza? Ora prova `90`, `100`, `110`...

en: Once you get the hang of using `live_loop`s you'll not turn back. Whenever I do a live coding gig I rely on `live_loop` as much as a drummer relies on their sticks. For more information about live coding check out Section 9 of the built-in tutorial.
it: Una volta che capisci come usare `live_loop` non tornerai più indietro. Ogni volta che faccio una performance, mi baso completamente su `live_loop` tanto quanto un batterista si affida alle sue bacchette. Per maggiori informazioni sul live coding, guarda la sezione 9 del tutorial all'interno di Sonic Pi.

en: 5. Surf the random streams
it: 5. Naviga le acqua della casualità

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:
it: Una delle cose che amo fare con Sonic Pi è fare in modo che componga al posto mio. Un ottimo modo per farlo è utilizzare la casualità. Può sembrare complicato ma non lo è per niente. Dai un'occhiata a questo codice:

en: Now, when you play this, you'll hear a constant stream of random notes from the scale `:e2 :minor_pentatonic` played with the `:dsaw` synth. "Wait, wait! That's not a melody", I hear you shout! Well, here's the first part of the magic trick. Every time we go round the `live_loop` we can tell Sonic Pi to reset the random stream to a known point. This is a bit like going back in time in the TARDIS with the Doctor to a particular point in time and space. Let's try it - add the line `use_random_seed 1` to the `live_loop`:
it: Ora, quando suoni questo, sentirai un flusso costante di nome della scala `:e2 :minor_pentatonic` suonate con un synth `:dsaw`. Vi sento gridare: "Aspetta un momento, quella non è una melodia". Beh, questa è la prima parte del mio trucco magico. Ogni volta che riproduciamo dall'inizio `live_loop` possiamo dire a Sonic Pi di resettare il flusso casuale. È come andare indietro nel tempo. Prova questo, aggiungi la linea `use_random_seed 1` al `live_loop`:

en: Now, every time the `live_loop` loops around, the random stream is reset. This means it chooses the same 16 notes every time. Hey presto! An instant melody. Now, here's the really exciting bit. Change the seed value from `1` to another number. Say `4923`. Wow! Another melody! So, just by changing one number (the random seed), you can explore as many melodic combinations as you can imagine! Now, that's the magic of code.
it: Ogni volta che il `live_loop` ricomincerà, i numeri random saranno resettati. Questo significa che sceglierà sempre le stesse 16 note ogni volta. Voilà, una melodia. Ora, questa è la parte interessante. Cambia il valore del seme da `1` a, diciamo, `4923`. Wow! Un'altra melodia! Semplicemente cambiando un numero (quello del seme), puoi esplorare tutte le combinazioni di melodie che vuoi. Questa è magia.

en: A.2 Live Coding
it: A.2 Programmare Live

en: This may sound like a far fetched story from a futuristic night club but coding music like this is a growing trend and is often described as Live Coding (http://toplap.org). One of the recent directions this approach to music making has taken is the Algorave (http://algorave.com) - events where artists like myself code music for people to dance to. However, you don't need to be in a nightclub to Live Code - with Sonic Pi v2.6+ you can do it anywhere you can take your Raspberry Pi and a pair of headphones or some speakers. Once you reach the end of this article, you'll be programming your own beats and modifying them live. Where you go afterwards will only be constrained by your imagination.
it: Questa può sembrare una storia di una notte in un club futuristico ma programmare musica è un trend in crescita ed è spesso descritto come Live Coding (http://toplap.org). Uno delle direzioni più recenti che ha preso questo approccio alla musica è l'Algorave (http://algorave.com), eventi dove gli artisti come me programmano musica affinché le persone possano ballare. Non è necessario, però, che tu sia in un nightclub per fare del live coding; con Sonic Pi v.2.6+ puoi farlo ovunque ti porti il tuo Rasberry Pi, un paio di cuffie e delle casse. Quando raggiungerai la fine di questo articoli, saprai programmare e modificare il tuo personalissimo beat. Il punto di arrivo dipenderà solo dalla tua immaginazione.

en: The key to live coding with Sonic Pi is mastering the `live_loop`. Let's look at one:
it: La chiave per programmare live con Sonic Pi è capire il funzionamento di `live_loop`. Proviamo a vederne uno:

en: Redefining On-the-fly
it: Ridefinire on-the-fly

en: Ok, so what's so special about the `live_loop`? So far it just seems like a glorified `loop`! Well, the beauty of `live_loop`s is that you can redefine them on-the-fly. This means that whilst they're still running, you can change what they do. This is the secret to live coding with Sonic Pi. Let's have a play:
it: Ok, cosa c'è di così importante in `live_loop`? Fin qui sempre un normale `loop`! Beh, la bellezza del `live_loop` è che puoi modificarli al volo. Questo significa che mentre stanno ancora andando, puoi cambiare il loro comportamento. Questo è il segreto del live coding in Sonic Pi. Proviamo:

en: Sleeping is important
it: Il tempo di sleep è importante

en: One of the most important lessons about `live_loop`s is that they need rest. Consider the following `live_loop`:
it: Una delle lezioni più importanti riguardo a `live_loop` è che devono riposarsi. Guarda questo codice:

en: If you try running this code, you'll immediately see Sonic Pi complaining that the `live_loop` did not sleep. This is a safety system kicking in! Take a moment to think about what this code is asking the computer to do. That's right, it's asking the computer to play an infinite amount of choir samples in zero time. Without the safety system the poor computer will try and do this and crash and burn in the process. So remember, your `live_loop`s must contain a `sleep`.
it: Se provi a far funzionare questo codice, Sonic Pi si lamenterà subito che `live_loop` non si ferma. Questo è un sistema di sicurezza! Prenditi un secondo per analizzare cosa questo codice sta chiedendo al computer di fare. Giusto, sta chiedendo di suonare un numero infinito di campioni di coro senza pausa. Senza il sistema di sicurezza il computer proverebbe ad eseguirlo e crasherebbe nel tentativo. Ricorda: i `live_loop` devono contenere `sleep`.

en: Combining Sounds
it: Combinare suoni

en: Music is full of things happening at the same time. Drums at the same time as bass at the same time as vocals at the same time as guitars... In computing we call this concurrency and Sonic Pi provides us with an amazingly simple way of playing things at the same time. Simply use more than one `live_loop`!
it: La musica è fatta di cose che accadono nello stesso momento. Batteria, basso, voce, chitarre... tutto in contemporanea. In informatica questo lo chiamiamo concordanza e Sonic Pi lo fa in modo molto semplice. È sufficiente usare più di un `live_loop`!

en: One of the interesting things about using multiple `live_loop`s is that they each manage their own time. This means it's really easy to create interesting polyrhythmical structures and even play with phasing Steve Reich style. Check this out:
it: Una delle cose interessanti riguardo i `live_loop` è che possono gestire individualmente il loro tempo. Questo vuol dire che è molto semplice creare strutture poliritmiche interessanti o suonare sfasati nello stile di Steve Reich. Ascolta questo:

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

en: Bringing it all together
it: Mettiamo tutto insieme

en: In each of these tutorials, we'll end with a final example in the form of a new piece of music which draws from all of the ideas introduced. Read this code and see if you can imagine what it's doing. Then, copy it into a fresh Sonic Pi buffer and hit Run and actually hear what it sounds like. Finally, change one of the numbers or comment and uncomment things out. See if you can use this as a starting point for a new performance, and most of all have fun! See you next time...
it: In ognuno di questi tutorial, finiremo con un esempio di musica che deriva dalle idee che abbiamo introdotto oggi. Leggi il codice e cerca di immaginare il risultato. Poi copialo in un buffer vuoto di Sonic Pi e premi Run e ascolta come suona. Infine, cambia uno dei numeri o utilizza i commenti. Prova a capire se puoi usarli come punti di partenza per una performance e, soprattutto, divertiti! A presto...

en: A.3 Coded Beats
it: A.3 Beat codificati

en: Coded Beats
it: Beat codificati

en: One of the most exciting and disrupting technical developments in modern music was the invention of samplers. These were boxes that allowed you to record any sound into them and then manipulate and play back those sounds in many interesting ways. For example, you could take an old record, find a drum solo (or break), record it into your sampler and then play it back on repeat at half-speed to provide the foundation for your latest beats. This is how early hip-hop music was born and today it's almost impossible to find electronic music that doesn't incorporate samples of some kind. Using samples is a really great way of easily introducing new and interesting elements into your live coded performances.
it: Tra gli sviluppi tecnologici che hanno avuto maggiore impatto nel mondo della musica moderna, c'è sicuramente l'invenzione dei campionatori. Inizialmente i campionatori erano degli scatolotti in grado di registrare e mantenere al proprio interno un qualsiasi suono, in maniera da poterlo manipolare e riprodurre in tanti modi diversi. Per esempio, potevi prendere una vecchia canzone, individuare un assolo di batteria, registrarlo all'interno del campionatore, e successivamente riprodurlo in ripetizione continua ad una velocità dimezzata. Questo è esattamente il modo con cui sono stati creati i primi beat hip hop e oggi è praticamente impossibile travare nella musica elettronica una canzone che non contenga in qualche modo dei “campioni”. L'utilizzo dei campioni è l'ideale per introdurre in maniera semplice e veloce interessanti elementi nella tua esibizione di live coding.

en: So where can you get a sampler? Well you already have one - it's your Raspberry Pi! The built-in live coding app Sonic Pi has an extremely powerful sampler built into its core. Let's play with it!
it: Ma quindi dove lo troviamo un campionatore? Beh, in realtà ne abbiamo già uno. E' nel nostro Raspberry Pi! Nel cuore di Sonic Pi è integrato un campionatore molto potente: proviamo a giocarci un po'!

en: The Amen Break
it: L'Amen Break

en: One of the most classic and recognisable drum break samples is called the Amen Break. It was first performed in 1969 in the song "Amen Brother" by the Winstons as part of a drum break. However, it was when it was discovered by early hip-hop musicians in the 80s and used in samplers that it started being heavily used in a wide variety of other styles such as drum and bass, breakbeat, hardcore techno and breakcore.
it: Uno dei campioni di batteria più conosciuti e maggiormente riconoscibili è L'Amen Break. L'Amen Break è contenuto in una canzone del 1969 intitolata "Amen Brother" eseguita dalla band americana The Winstons. "Break" in Inglese significa pausa e nella musica rappresenta un interludio strumentale che collega due parti di una canzone. Questo particolare Break fu scoperto all'inizio negli anni 80 da dei musicisti hip hop e da lì utilizzato in una grande varietà di generi musicali come drum and bass, breakbeat, hardcore techno and breakcore.

en: I'm sure you're excited to hear that it's also built right into Sonic Pi. Clear up a buffer and throw in the following code:
it: Sarai contento di sapere che questo particolare campione è già incluso in Sonic Pi. Ripulisci un buffer e scrivici dentro il seguente codice:

en: Hit *Run* and boom! You're listening to one of the most influential drum breaks in the history of dance music. However, this sample wasn't famous for being played as a one-shot, it was built for being looped.
it: Premi *Run* e bum! Stai ascoltando uno dei più influenti campioni di batteria della storia della musica dance! Tuttavia, questo campione non è famoso per essere suonato singolarmente, bensì per essere riprodotto all'interno di un loop.

en: Beat Stretching
it: Stretchare il beat

en: Let's loop the Amen Break by using our old friend the `live_loop` introduced in this tutorial last month:
it: Eseguiamo l'Amen Break in loop facendoci aiutare dal nostro vecchio amico `live_loop`, già introdotto in questo tutorial:

en: OK, so it is looping, but there's an annoying pause every time round. That is because we asked it to sleep for `2` beats and with the default BPM of 60 the `:loop_amen` sample only lasts for `1.753` beats. We therefore have a silence of `2 - 1.753 = 0.247` beats. Even though it's short, it's still noticeable.
it: Ok, è in loop, ma c'è una fastidiosa pausa ad ogni ripetizione. Questo è perché abbiamo chiesto uno sleep pari a `2` battute e con una velocità predefinita di 60 BPM, il nostro campione `:loop_amen` dura soltanto `1.753` battute. Quindi abbiamo un silenzio di `2 - 1.753 = 0.247` battute. Anche se è breve, risulta ben evidente.

en: To fix this issue we can use the `beat_stretch:` opt to ask Sonic Pi to stretch (or shrink) the sample to match the specified number of beats.
it: Per risolvere questo problema, possiamo usare `beat_stretch:` chiedendo a Sonic Pi di "streatchare" (stiracchiare) il campione, in modo da farlo durare uno specifico numero di battute.

en: Sonic Pi's `sample` and `synth` fns give you a lot of control via optional parameters such as `amp:`, `cutoff:` and `release:`. However, the term optional parameter is a real mouthful so we just call them *opts* to keep things nice and simple.
it: Le funzioni `sample` e `synth` ti danno la possibilità di avere un grande controllo attraverso i parametri opzionali `amp:`, `cutoff:` e `release:`. Tuttavia, il termine "parametri opzionali" è lungo e complicato da dire, quindi utilizzeremo la parola *opts*.

en: Now we're dancing! Although, perhaps we want to speed it up or slow it down to suit the mood.
it: Adesso si che si balla! Anche se, forse vorremmo rallentare o accelerare il ritmo per adattarlo al nostro umore.

en: Playing with Time
it: Giocare con il tempo

en: OK, so what if we want to change styles to old school hip hop or breakcore? One simple way of doing this is to play with time - or in other words mess with the tempo. This is super easy in Sonic Pi - just throw in a `use_bpm` into your live loop:
it: Bene, quindi che dobbiamo fare se vogliamo cambiare stile e passare all'hip hop old school o al breakcore? Un modo semplice è di giocare con il tempo, o meglio incasinare il tempo. Con Sonic Pi è facilissimo, basta infilare un 'use_bpm' dentro il tuo live loop:

en: Whilst you're rapping over those slow beats, notice that we're still sleeping for 2 and our BPM is 30, yet everything is in time. The `beat_stretch` opt works with the current BPM to make sure everything just works.
it: Mentre stai rappando sopra questi ritmi lenti, fai caso a come il programma rimanga fermo per 2 battiti (sleep 2) e i nostri bpm sono a 30. Quindi tutto è a tempo. L'opzione 'beat_stretch' funziona con i bpm di riferimento per fare in modo che tutto torni.

en: Filtering
it: Filtraggio

en: Now we can live loop samples, let's look at some of the most fun opts provided by the `sample` synth. First up is `cutoff:` which controls the cutoff filter of the sampler. By default this is disabled but you can easily turn it on:
it: Adesso che abbiamo imparato a mettere i campioni nel live loop, diamo un'occhiata ad alcune delle opzioni più divertenti del synth 'sample'. Il primo è 'cutoff:', che controlla il filtro di taglio del campionatore. Di norma è disabilitato ma puoi facilmente attivarlo:

en: Go ahead and change the `cutoff:` opt. For example, increase it to 100, hit *Run* and wait for the loop to cycle round to hear the change in the sound. Notice that low values like 50 sound mellow and bassy and high values like 100 and 120 are more full-sounding and raspy. This is because the `cutoff:` opt will chop out the high frequency parts of the sound just like a lawn-mower chops off the top of the grass. The `cutoff:` opt is like the length setting - determining how much grass is left over.
it: Vai avanti e cambia il 'cutoff:'. Per esempio, aumentalo a 100, premi *Run* e aspetta che il loop torni all'inizio per ascoltare il risultato sonoro. I valori più bassi, tipo 50, suonano più bassi e caldi mentre valori alti tipo 100 o 120 sono più secchi. Ciò accade perché l'opzione 'cutoff:' taglia le frequenze alte nello stesso modo in cui una falciatrice taglia l'erba. Il valore di 'cutoff:' è come regolare l'altezza della falciatrice e determina quanto l'erba deve essere tagliata.

en: Slicing
it: Affettare

en: Another great tool to play with is the slicer FX. This will chop (slice) the sound up. Wrap the `sample` line with the FX code like this:
it: Un altro strumento divertente è l'effetto slicer. Questo affetterà (slice in inglese) il suono. Avvolgi la linea di 'sample' dentro il codice di effetto, così:

en: Notice how the sound bounces up and down a little more. (You can hear the original sound without the FX by changing the `mix:` opt to `0`.) Now, try playing around with the `phase:` opt. This is the rate (in beats) of the slicing effect. A smaller value like `0.125` will slice faster and larger values like `0.5` will slice more slowly. Notice that successively halving or doubling the `phase:` opts val tends to always sound good. Finally, change the `wave:` opt to one of 0, 1, or 2 and hear how it changes the sound. These are the various wave shapes. 0 is a saw wave, (hard in, fade out) 1 is a square wave (hard in, hard out) and 2 is a triangle wave (fade in, fade out).
it: Fai caso a come il suono salta sù e giù (se vuoi sentire il suono originale, senza effetti, cambia il valore di 'mix:' a 0). Adesso, proviamo a giocare con i valori di 'phase:'. Questa è la frequenza (in battiti) dell'effetto di affettamento. Un valore piccolo, tipo '0.125', affetterà più velocemente e uno più grande, tipo '0.5', più lentamente. Senti come il dimezzamento o il raddoppiamento dei valori di 'phase:' tendono sempre a suonare piacevoli. Infine, cambia il valore di 'wave:' a 0, 1 o 2 e ascolta la differenza. I diversi numeri rappresentato le differenti forme d'onda. 0 è un'onda a dente di sega (attacco veloce e rilascio lento), 1 è un'onda quadrata ( attacco e rilascio veloce), 2 infine è un'onda triangolare (attacco e rilascio lento).

en: Finally, let's go back in time and revisit the early Bristol drum and bass scene with this month's example. Don't worry too much about what all this means, just type it in, hit Run, then start live coding it by changing opt numbers and see where you can take it. Please do share what you create! See you next time...
it: Infine, andiamo indietro nel tempo al primo periodo drum and bass di Bristol con questo esempio. Non ti preoccupare troppo di cosa significa questa frase. Digita il codice, premi Run e comincia a fare live coding cambiando i valori delle opzioni e osserva i risultati. Mi raccomando, condividi quello che hai ottenuto. Ci vediamo la prossima volta...

en: A.4 Synth Riffs
it: A.4 Riff di synth

en: Synth Riffs
it: Riff di synth

en: Whether it's the haunting drift of rumbling oscillators or the detuned punch of saw waves piercing through the mix, the lead synth plays an essential role on any electronic track. In last month's edition of this tutorial series we covered how to code our beats. In this tutorial we'll cover how to code up the three core components of a synth riff - the timbre, melody and rhythm.
it: Sia che siano i minacciosi scivolamenti i oscillatori rumorosi, sia che siano i colpi scordati di onde a dente di sega che trapuntano il suono, il synth principale gioca un ruolo essenziale in ogni brano elettronico. Nell'edizione del mese scorso, in questa guida abbiamo trattato le modalità di programmazione dei ritmi. In questa edizione tratteremo invece di come programmare tre componenti centrali di un riff fatto con il synth: il timbro, la melodia e il ritmo.

en: OK, so power up your Raspberry Pi, crack open Sonic Pi v2.6+ and let's make some noise!
it: Bene, allora accendiamo il Raspberry Pi, apriamo Sonic Pi in versione 2.6 o più recente, e mettiamoci a fare un po' di rumore!

en: Timbral Possibilities
it: Possibilità trimbriche

en: An essential part of any synth riff is changing and playing with the timbre of the sounds. We can control the timbre in Sonic Pi in two ways - choosing different synths for a dramatic change and setting the various synth opts for more subtle modifications. We can also use FX, but that's for another tutorial...
it: Una parte essenziale di ogni riff fatto con il synth è di cambiare il timbro dei suoni e giocarci. In Sonic Pi, il timbro può essere controllato in due modi: cambiando totalmente synth per avere delle modifiche più radicali, cambiando le varie caratteristiche del synth che siamo utilizzando per avere delle modifiche più raffinate e precise. Possiamo utilizzare anche FX, ma questo è spiegato in un'altra guida...

en: Let's create a simple live loop where we continually change the current synth:
it: Creiamo un semplice live loop dove continuiamo a cambiare il sintetizzatore usato:

en: Take a look at the code. We're simply ticking through a ring of synth names (this will cycle through each of these in turn repeating the list over and over). We pass this synth name to the `use_synth` fn (function) which will change the `live_loop`'s current synth. We also play note `:e2` (E at the second octave), with a release time of 0.5 beats (half a second at the default BPM of 60) and with the `cutoff:` opt set to 100.
it: Dai uno sguardo al codice. Siamo semplicemente scorrendo attraverso una serie di nomi di synth (quando arriverai in fondo, la lista riparte da capo). Ogni nome viene selezionato attraverso la funzione 'use_synth', che cambierà anche il synth utilizzato all'interno del 'live_loop' corrente. Stiamo suonando anche la nota ':e2' (E, o 'Mi' nel sistema italiano, alla seconda ottava), con un rilascio della nota di 0,5 battiti (mezzo secondo con i BPM preimpostati a 60) e il livello di 'cutoff:' impostato a 100.

en: Hear how the different synths have very different sounds even though they're all playing the same note. Now experiment and have a play. Change the release time to bigger and smaller values. For example, change the `attack:` and `release:` opts to see how different fade in/out times have a huge impact on the sound. Finally change the `cutoff:` opt to see how different cutoff values also massively influence the timbre (values between 60 and 130 are good). See how many different sounds you can create by just changing a few values. Once you've mastered that, just head to the Synths tab in the Help system for a full list of all the synths and all the available opts each individual synth supports to see just how much power you have under your coding fingertips.
it: Ascolta adesso come i diversi synth hanno un suono radicalmente diverso, anche se tutti suonano la stessa nota. Prova a sperimentare, cambiando il tempo di rilascio della nota ('release:') o cambiando anche il tempo di attacco ('attack:') così da capire come questi parametri hanno un forte impatto sul suono. Infine, prova a cambiare il 'cutoff:' per vedere come diversi valori cambiano il timbro (i valori tra 60 e 130 sono i migliori). Fai caso a quanti differenti suoni puoi creare semplicemente modificando alcuni valori. Quando avrai imparato a gestirli, vai alla scheda Synth dentro il sistema Help e qui troverai tutti i synth a disposizione e tutti i parametri che ogni synth supporta. Così ti renderai conto di quanto potenti possono essere le tue dita programmatrici.

en: Timbre
it: Timbro

en: Timbre is just a fancy word describing the sound of a sound. If you play the same note with different instruments such as a violin, guitar, or piano, the pitch (how high or low it sounds) would be the same, but the sound quality would be different. That sound quality - the thing which allows you to tell the difference between a piano and a guitar is the timbre.
it: Timbro è solo un bella parola per descrivere il suono di un suono. Se, infatti, provi a suonare la stessa nota con strumenti differenti come, ad esempio, il violino, la chitarra, il pianoforte, il pitch (l'altezza della nota) sarà lo stesso ma la qualità sonora sarà diversa. Questa qualità sonora, quella che ti permette di distinguere un pianoforte da una chitarra è il timbro.

en: Melodic Composition
it: Composizioni melodiche

en: Another important aspect to our lead synth is the choice of notes we want to play. If you already have a good idea, then you can simply create a ring with your notes in and tick through them:
it: Un'altro aspetto importante per il nostro synth lead è la scelta delle note che vogliamo suonare. Se hai già un'idea a riguardo, puoi creare semplicemente un ring con le note e utilizzare il tick per scorrere da una all'altra:

en: Here, we've defined our melody with a ring which includes both notes such as `:e3` and rests represented by `:r`. We're then using `.tick` to cycle through each note to give us a repeating riff.
it: In questo esempio abbiamo definito la nostra melodia con un anello che include sia note come, ad esempio `:e3` che pause rappresentate da `:r`. Usiamo `.tick` per scorrere tra le note e avere un riff che si ripete.

en: Auto Melody
it: Melodia automatica

en: It's not always easy to come up with a nice riff from scratch. Instead it's often easier to ask Sonic Pi for a selection of random riffs and to choose the one you like the best. To do that we need to combine three things: rings, randomisation and random seeds. Let's look at an example:
it: Spesso non è semplice trovare un buon riff partendo da zero. Spesso è più semplice chiedere a Sonic Pi una selezione di riff casuale per scegliere il migliore. Per fare una cosa del genere, abbiamo bisogno di tre cose: anelli, casualità e seme di casualità. Proviamo a vedere un esempio:

en: There's a few things going on - let's look at them in turn. First, we specify that we're using random seed 3. What does this mean? Well, the useful thing is that when we set the seed, we can predict what the next random value is going to be - it's the same as it was last time we set the seed to 3! Another useful thing to know is that shuffling a ring of notes works in the same way. In the example above we're essentially asking for the 'third shuffle' in the standard list of shuffles - which is also the same every time as we're always setting the random seed to the same value right before the shuffle. Finally we're just ticking through our shuffled notes to play the riff.
it: Qui succedono un po' di cose... cerchiamo di andare con ordine. Per prima cosa specifichiamo che stiamo usando 3 come seme di casualità. Cosa significa? La cosa importante è sapere che quando utilizziamo un seme, possiamo fare una predizione su quello che sarà il prossimo numero casuale. Un'altro punto importante è che mescolare un anello di note funziona nello stesso modo. Nell'esempio qui sopra stiamo semplicemente chiedendo la il terzo mescolamento nella lista standard dei mescolamenti (che sarà sempre la stessa quando impostiamo lo stesso seme prima di mescolare). Infine utilizziamo il tick per scorrere tra le note per suonare il riff.

en: Now, here's where the fun starts. If we change the random seed value to another number, say 3000, we get an entirely different shuffling of the notes. So now it's extremely easy to explore new melodies. Simply choose the list of notes we want to shuffle (scales are a great starting point) and then choose the seed we want to shuffle with. If we don't like the melody, just change one of those two things and try again. Repeat until you like what you hear!
it: Qui comincia il bello. Se cambiamo il seme a, per esempio, 3000, otterremo un mescolamento completamente differente. Così diventa semplice esplorare nuove melodie:è sufficiente scegliere una lista di note che vogliamo mescolare (le scale sono un ottimo punto di partenza) e poi scegliere il seme con cui le vogliamo mescolare. Se non ci piace la melodia, basta cambiare una delle due cose e riprovare finché non sentiamo qualcosa che ci piace.

en: Pseudo Randomisation
it: Pseudo casualità

en: Sonic Pi's randomisation is not actually random it's what's called pseudo random. Imagine if you were to roll a dice 100 times and write down the result of each roll onto a piece of paper. Sonic Pi has the equivalent of this list of results which it uses when you ask for a random value. Instead of rolling an actual dice, it just picks the next value from the list. Setting the random seed is just jumping to a specific point in that list.
it: La casualità in Sonic Pi non è realmente casuale ma è quello che si chiama pseudo-random. Immagina di lanciare un dado 100 volte e scrivere il risultato di ogni lancio su un foglio di carta. Sonic Pi ha lo stesso numero di possibili risultati quando gli chiediamo un numero casuale ma, invece che lanciare un dado, prendere il valore successivo in lista. Impostando un seme stabiliamo un punto specifico di inizio da quella lista.

en: Finding your Rhythm
it: Trovando il tuo ritmo

en: Another important aspect to our riff is the rhythm - when to play a note and when not to. As we saw above we can use `:r` in our rings to insert rests. Another very powerful way is to use spreads which we'll cover in a future tutorial. Today we'll use randomisation to help us find our rhythm. Instead of playing every note we can use a conditional to play a note with a given probability. Let's take a look:
it: Un altro aspetto importante del riff è il ritmo ovvero quando suonare una nota e quando no. Come abbiamo visto in precedenza, possiamo usare `:r` nel nostro anello per aggiungere le pause. Un'altra possibilità è l'utilizzo degli spread che vedremo in futuro. Oggi continueremo a usare la casualità per trovare il nostro ritmo. Invece che suonare ogni nota, possiamo usare una condizione per far sì che suoni con una certa probabilità. Diamo un'occhiata:

en: A really useful fn to know is `one_in` which will give us a `true` or `false` value with the specified probability. Here, we're using a value of 2 so on average one time every two calls to `one_in` it will return `true`. In other words, 50% of the time it will return `true`. Using higher values will make it return `false` more often introducing more space into the riff.
it: Una funzione molto utile da conoscere è `one_in` che restituisce il valore `true` o `false` con la probabilità specificata. Qui stiamo usando un valore 2 quindi `one_in` restituirà `true` una volta su due. In altre parole, il 50% delle volte avremo `true`. Utilizzando valori più alti, alzeremo le probabilità che ritorni `false` aumentando gli spazi nel riff.

en: Notice that we've added some iteration in here with `16.times`. This is because we only want to reset our random seed value every 16 notes so our rhythm repeats every 16 times. This doesn't affect the shuffling as that is still done immediately after the seed is set. We can use the iteration size to alter the length of the riff. Try changing the 16 to 8 or even 4 or 3 and see how it affects the rhythm of the riff.
it: Da notare che abbiamo usato l'iterazione `16.times`. Questo perché vogliamo resettare il nostro valore di seme ogni 16 così per cui il nostro ritmo si ripeterà per 16 volte. Questo non ha effetti sul mescolamento perché viene eseguito immediatamente appena è impostato il seme. Possiamo modificare le quantità di ripetizioni nell'iterazione per allungare il riff. Prova a cambiare il valore da 16 a 8 oppure 4 o 3 per vedere come cambia il ritmo del riff.

en: OK, so let's combine everything we've learned together into one final example. See you next time!
it: Ok, mettiamo insieme tutto quello che abbiamo imparato oggi in un ultimo esempio. Alla prossima!

en: live_loop :random_riff do
      #  uncomment to bring in:
      #  synth :blade, note: :e4, release: 4, cutoff: 100, amp: 1.5
      use_synth :dsaw
      use_random_seed 43
      notes = (scale :e3, :minor_pentatonic, num_octaves: 2).shuffle.take(8)
      8.times do
        play notes.tick, release: rand(0.5), cutoff: rrand(60, 130) if one_in(2)
        sleep 0.125
      end
    end
     
    live_loop :drums do
      use_random_seed 500
      16.times do
        sample :bd_haus, rate: 2, cutoff: 110 if rand < 0.35
        sleep 0.125
      end
    end
     
    live_loop :bd do
      sample :bd_haus, cutoff: 100, amp: 3
      sleep 0.5
    end
it: live_loop :random_riff do
      #  togli il cancelletto che serve per i commenti per attivare la funzione:
      #  synth :blade, note: :e4, release: 4, cutoff: 100, amp: 1.5
      use_synth :dsaw
      use_random_seed 43
      notes = (scale :e3, :minor_pentatonic, num_octaves: 2).shuffle.take(8)
      8.times do
        play notes.tick, release: rand(0.5), cutoff: rrand(60, 130) if one_in(2)
        sleep 0.125
      end
    end
     
    live_loop :drums do
      use_random_seed 500
      16.times do
        sample :bd_haus, rate: 2, cutoff: 110 if rand < 0.35
        sleep 0.125
      end
    end
     
    live_loop :bd do
      sample :bd_haus, cutoff: 100, amp: 3
      sleep 0.5
    end

en: It's impossible to look through the history of electronic dance music without seeing the enormous impact of the tiny Roland TB-303 synthesiser. It's the secret sauce behind the original acid bass sound. Those classic squealing and squelching TB-303 bass riffs can be heard from the early Chicago House scene through to more recent electronic artists such as Plastikman, Squarepusher and Aphex Twin.
it: È impossibile ripercorrere la storia della musica elettronica senza riscontrare l'impatto del piccolo sintetizzatore Roland TB-303. È l'ingrediente segreto alle spalle del suono acid bass. I riff creati con il TB-303 si sentono dai primi brani della scena House di Chicago fino ad artisti più recenti come Plastikman, Squarepusher e Aphex Twin.

en: Although getting your hands on an original TB-303 is not so easy you will be pleased to know that you can turn your Raspberry Pi into one using the power of Sonic Pi. Behold, fire up Sonic Pi and throw this code into an empty buffer and hit Run:
it: Anche se non è così semplice mettere le mani su una TB-303 originale, puoi far si che il tuo Raspberry Pi ne diventi una grazie alla potenza di Sonic Pi. Apri il programma e scrivi questo codice e premi Run:

en: Instant acid bass! Let's play around...
it: Acid bass istantaneo! Proviamo a smanettare un po'...

en: Squelch that Bass
it: Modifichiamo quel basso

en: First, let's build a live arpeggiator to make things fun. In the last tutorial we looked at how riffs can just be a ring of notes that we tick through one after another, repeating when we get to the end. Let's create a live loop that does exactly that:
it: Per prima cosa, costruiamo un arpeggiatore. Nell'ultimo tutorial abbiamo visto come i riff possano essere semplicemente degli anelli di note suonate in sequenza e ripetute. Creiamo un live loop che faccia esattamente questo:

en: Take a look at each line.
it: Guarda ogni linea di codice.

en: On the first line we set the default synth to be `tb303` with the `use_synth` fn.
it: Nella prima riga, impostiamo il sintetizzatore di default `tb303` con la funzione `use_synth`.

en: On line two we create a live loop called `:squelch` which will just loop round and round.
it: Nella seconda riga, creiamo un live loop chiamato `:squelch` che continua a ripetersi.

en: Line three is where we create our riff - a ring of notes (E in octaves 1, 2, and 3) which we simply tick through with `.tick`. We define `n` to represent the current note in the riff. The equals sign just means to assign the value on the right to the name on the left. This will be different every time round the loop. The first time round, `n` will be set to `:e1`. The second time round it will be `:e2`, followed by `:e3`, and then back to `:e1`, cycling round forever.
it: La terza riga è dove creiamo il nostro riff: un anello di note (E dalla prima alla terza ottava) che suoniamo in ordine con `.tick`. Definiamo `n` affinché rappresenti la nota corrente del riff. Il simbolo di uguale significa: assegna il valore a destra al nome sulla sinistra. Questa sarà diversa ogni volta che il loop si ripete. La prima volta `n` sarà `:e1`, la seconda `:e2` seguita da `:e3` e poi dall'inizio.

en: Line four is where we actually trigger our `:tb303` synth. We're passing a few interesting opts here: `release:`, `cutoff:`, `res:` and `wave:` which we'll discuss below.
it: La quarta linea è dove effettivamente facciamo suonare il synth `:tb303`. Passiamo una serie di parametri interessanti: `release:`, `cutoff:`, `res:`, e `wave:` che discuteremo più avanti.

en: Line five is our `sleep` - we're asking the live loop to loop round every `0.125`s or 8 times a second at the default BPM of 60.
it: La quinta linea è per la pausa `sleep` (stiamo chiedendo al nostro loop di ripetersi ogni `0.125` secondi o 8 volte al secondo a 60BPM).

en: Line six is the `end` to the live loop. This just tells Sonic Pi where the end of the live loop is.
it: La sesta linea è la fine `end` del live loop. Questo dice a Sonic Pi dove finisce il live loop.

en: Whilst you're still figuring out what's going on, type in the code above and hit the Run button. You should hear the `:tb303` kick into action. Now, this is where the action is: let's start live coding.
it: Anche se stai ancora cercando di capire che sta succedendo, scrivi il codice sopra e premi Run. Dovresti sentire il battito del ':tb303' in azione. Quindi, ecco dove sta l'azione: cominciamo a fare live coding.

en: Whilst the loop is still live, change the `cutoff:` opt to `110`. Now hit the Run button again. You should hear the sound become a little harsher and more squelchy. Dial in `120` and hit run. Now `130`. Listen how higher cutoff values make it sound more piercing and intense. Finally, drop it down to `80` when you feel like a rest. Then repeat as many times as you want. Don't worry, I'll still be here...
it: Anche se il loop è ancora attivo, cambia il valore di 'cutoff:' a '110' e premi di nuovo Run. Dovresti sentire il suono divenare un po' più ruvido e gracchiante. Digita '120' e premi Run e poi '130' e di nuovo Run. Ascolta i cambiamenti nel suono provocati da queste variazioni. Infine, prova a mettere un valore più basso, tipo '80'. Quindi poi ripeti questi cambiamenti con i numeri che vuoi e quante volte vuoi. Non preoccuparti, io ti aspetto qui...

en: Finally, for a big impact on the timbre try changing the `wave:` opt to `1`. This is the choice of source oscillator. The default is `0` which is a sawtooth wave. `1` is a pulse wave and `2` is a triangle wave.
it: Infine, per avere variazioni significative del timbro, prova a cambiare 'wave:', ovvero forma d'onda, mettendo '1'. Questo parametro infatti ti permette di variare l'oscillatore che genera il suono. Quello preimpostato è '0', cioè un generatore di onda a dente di sega. Il numero '1' è un generatore di impulsi e infine '2' è un generatore di onda triangolare.

en: Of course, try different riffs by changing the notes in the ring or even picking notes from scales or chords. Have fun with your first acid bass synth.
it: Quindi, adesso puoi senz'altro provare differenti giri di note cambiando i suoni all'interno dell'anello o anche prendere note da scale o accordi. Divertiti con il tuo primo sintetizzatore di bassi acidi.

en: Deconstructing the TB-303
it: Decostruire il TB-303

en: The design of the original TB-303 is actually pretty simple. As you can see from the following diagram there's only 4 core parts.
it: Il progetto del TB-303 originale è piuttosto semplice. Compe potrai notare dal diagramma che segue, ci sono soltanto 4 parti principali.

en: First is the oscillator wave - the raw ingredients of the sound. In this case we have a square wave. Next there's the oscillator's amplitude envelope which controls the amp of the square wave through time. These are accessed in Sonic Pi by the `attack:`, `decay:`, `sustain:` and `release:` opts along with their level counterparts. For more information read Section 2.4 'Duration with Envelopes' in the built-in tutorial. We then pass our enveloped square wave through a resonant low pass filter. This chops off the higher frequencies as well as having that nice resonance effect. Now this is where the fun starts. The cutoff value of this filter is also controlled by its own envelope! This means we have amazing control over the timbre of the sound by playing with both of these envelopes. Let's take a look:
it: Il primo è l'oscillatore d'onda, ovvero l'ingrediente base del suono. In questo caso noi abbiamo un oscillatore di onda quadra. Sussessivamente, abbiamo ampiezza dell'inviluppo dell'oscillatore, che controlla l'ampiezza dell'onda quadra nel tempo. Questa dimensione è accessibile da Sonic Pi mediante i parametri 'attack:', 'decay:', 'sustain:' e 'release:'. Per maggiori informazioni, leggi la sezione 2.4 'Durata degli inviluppi' all'interno della guida. Poi facciamo passare la nostra onda attraverso un filtro passa-basso. Questo taglia le frequenze più acute e dà al suono quella risonanza particolare. E qui comincia il bello. Infatti il valore di taglio (cutoff) del filtro è anche determinato dal suo stesso inviluppo! Questo significa che abbiamo un controllo straodinario sul timbro del suono se giochiamo con entrambi gli inviluppi. Dai un'occhiata sotto:

en: Notice that I've passed everything through a `:reverb` FX for extra atmosphere - try other FX to see what works!
it: Come avrai visto, abbiamo fatto passare tutto il segnale attraverso un effetto di reverbero con ':reverb', ottenendo una bella ambientazione sonora. Provane altri per vedere che succede!

en: A.6 Musical Minecraft
it: A.6 Minecraft Musicale

en: Musical Minecraft
it: Minecraft Musicale

en: Hello and welcome back! In the previous tutorials we've focussed purely on the music possibilities of Sonic Pi - (turning your Raspberry Pi into a performance ready musical instrument). So far we've learned how to:
it: Ciao, bentornato/a! Nella guida precedente ci siamo concentrati maggiormente sulle possibilità musicali di Sonic Pi, ovvero far diventare il tuo Raspberry Pi uno strumento musicale pronto all'uso. Fino ad ora, abbiamo imparato a:

en: Live Code - changing the sounds on-the-fly,
it: Fare live coding: cambiare i suoni in tempo reale,

en: Code some huge beats,
it: Scrivere codice per produrre dei bei bassi che pompano,

en: Generate powerful synth leads,
it: Generare delle potenti linee melodiche con i synth,

en: Re-create the famous TB-303 acid-bass sound.
it: Ricreare il suono acido e basso del TB-303.

en: There's so much more to show you (which we will explore in future editions). However, this month, let's look at something Sonic Pi can do that you probably didn't realise: control Minecraft.
it: C'è anche molto altro che vorrei mostrarti e che tratteremo in edizioni future di questa guida. Comunque, questo mese, diamo un'occhiata a qualcosa che Sonic Pi può fare e della quale probabilmente non sei a conoscenza: controllare Minecraft.

en: Hello Minecraft World
it: Ciao mondo di Minecraft

en: OK, let's get started. Boot up your Raspberry Pi, fire up Minecraft Pi and create a new world. Now start up Sonic Pi and re-size and move your windows so you can see both Sonic Pi and Minecraft Pi at the same time.
it: Bene, cominciamo allora. Accendi il tuo Raspberry Pi e avvia il tuo Minecraft Pi creando un nuovo mondo. Quando hai fatto, avvia Sonic Pi, ridimensiona e sposta la finestra in modo tale da riuscire a vedere le due finestre contemporaneamente.

en: In a fresh buffer type the following:
it: In una finestra vuota di Sonic Pi inserisci il codice seguente:

en: Now, hit Run. Boom! Your message appeared in Minecraft! How easy was that? Now, stop reading this for a moment and play about with your own messages. Have fun!
it: Adesso premi Run. Booom! Il tuo messaggio è apparso dentro Minecraft! E' stato facile, vero? Adesso, smetti per un momento di leggere e mettiti a giocare scrivendo alcuni messaggi a tuo piacimento. Goditela!

en: Sonic Teleporter
it: Teletrasporto sonico

en: Now let's do some exploring. The standard option is to reach for the mouse and keyboard and start walking around. That works, but it's pretty slow and boring. It would be far better if we had some sort of teleport machine. Well, thanks to Sonic Pi, we have one. Try this:
it: Adesso, mettiamoci un attimo a esplorare. Solitamente utilizziamo il mouse e la tastiera per camminare in giro. Funziona, è vero, ma è piuttosto lento e noioso. Sarebbe molto meglio avere una sorta di macchina del teletrasporto. Beh, grazie a Sonic Pi, ce l'abbiamo. Prova il codice seguente:

en: Crikey! That was a long way up. If you weren't in flying-mode then you would have fallen back down all the way to the ground. If you double-tap space to enter flying-mode and teleport again, you'll stay hovering at the location you zap to.
it: Perbacco! Era una strada lunga. Se non fossi stato in modalità volante saresti ricaduto giù a terra. Se tocchi due volte lo spazio per entrare in modalità volo e teletrasportarti di nuovo, rimarrai a fluttuare nel posto che hai toccato.

en: Now, what do those numbers mean? We have three numbers which describe the coordinates of where in the world we want to go. We give each number a name - x, y and z:
it: Allora, cosa significano quei numeri? Abbiamo tre numeri che descrivono le coordinate del posto nel mondo in cui vogliamo andare. Diamo a ogni numero un nome: x, y e z:

en: x - how far left and right (80 in our example)
it: x indica quanto ci spostiamo a destra o sinistra (80 nel nostro esempio)

en: y - how high we want to be (40 in our example)
it: y indica quando in alto vogliamo rimanere (40 nel nostro esempio)

en: z - how far forward and back (100 in our example)
it: z indica quanto vogliamo andare avanti o indietro (100 nel nostro esempio)

en: By choosing different values for x, y and z we can teleport *anywhere* in our world. Try it! Choose different numbers and see where you can end up. If the screen goes black it's because you've teleported yourself under the ground or into a mountain. Just choose a higher y value to get back out above land. Keep on exploring until you find somewhere you like...
it: Scegliendo differenti valori per x, y e z possiamo teletrasportarci ovunque nel nostro mondo. Prova! Scegli dei numeri diversi e guarda dove vai a finire. Se lo schermo diventa nero è perché ti sei teletrasportato/a sotto terra o in una montagna. Scegli un numero di y più alto e vedrai che tornerai in superficie. Continua a esplorare finché non trovi un posto che ti piace...

en: Using the ideas so far, let's build a Sonic Teleporter which makes a fun teleport sound whilst it whizzes us across the Minecraft world:
it: Usa le idee spiegate fino a ora e costruisci un Teletrasporto Sonico che rende divertente spostare dei suoni mentre ci spara in giro nel mondo di Minecraft:

en: Magic Blocks
it: Blocchi magici

en: Now you've found a nice spot, let's start building. You could do what you're used to and start clicking the mouse furiously to place blocks under the cursor. Or you could use the magic of Sonic Pi. Try this:
it: Adesso che hai finalmente trovato un posto bello, comincia a costruire. Puoi fare quello che fai di solito e cominciare a cliccare il mouse furiosamente per mettere i blocchi sotto il cursore. Oppure, puoi utilizzare la magia di Sonic Pi. Prova questo codice:

en: Now look up! There's a melon in the sky! Take a moment to look at the code. What did we do? On line one we grabbed the current location of Steve as the variables x, y and z. These correspond to our coordinates described above. We use these coordinates in the fn `mc_set_block` which will place the block of your choosing at the specified coordinates. In order to make something higher up in the sky we just need to increase the y value which is why we add 5 to it. Let's make a long trail of them:
it: Guarda in alto! C'è un melone nel cielo! Guarda un attimo il codice. Che cosa abbiamo fatto? Nella prima riga abbiamo preso la posizione attuale di Steve e codificata come variable di x, y e z. Queste lettere corrispondono alle coordinate descritte in precedenza. Abbiamo usato queste coordianate nella funzione 'mc_set_block' che pone il blocco scelto nel luogo indicato dalle coordinate. Per porre qualcosa nel cielo, dobbiamo soltanto incrementare il valore di y. E' per questo che abbiamo aggiunto 5. Proviamo a fare una lunga striscia di meloni:

en: Now, jump over to Minecraft, make sure you're in flying-mode (double tap space if not) and fly all around the world. Look behind you to see a pretty trail of melon blocks! See what kind of twisty patterns you can make in the sky.
it: Quindi, torniamo a Minecraft, assicurati di essere in modalità volo (tocca due volte spazio se non lo sei) e vola intorno al mondo. Guarda in giù e vedrai una bellissima scia di meloni. Guarda che belle figure intrecciate che puoi fare nel cielo.

en: Live Coding Minecraft
it: Fare live coding con Minecraft

en: Those of you that have been following this tutorial over the last few months will probably have your minds blown at this point. The trail of melons is pretty cool, but the most exciting part of the previous example is that you can use `live_loop` with Minecraft! For those that don't know, `live_loop` is Sonic Pi's special magic ability that no other programming language has. It lets you run multiple loops at the same time and allows you to change them whilst they run. They are incredibly powerful and amazing fun. I use `live_loop`s to perform music in nightclubs with Sonic Pi - DJs use discs and I use `live_loop`s :-) However, today we're going to live code both music and Minecraft.
it: Coloro che hanno seguito questa guida durante gli ultimi mesi avranno probabilmente la mente già aperta. La scia di meloni è molto bella, ma la parte più interessante dell'esempio precedente è il poter fare un 'live_loop' con Minecraft! Per chi non lo sapesse, 'live_loop' è un'abilità magica di Sonic Pi che nessun altro linguaggio di programmazione ha. Ti permette di far girare numerosi loop contemporaneamente e di cambiarli mentre sono in esecuzione. Sono incredibilmente potenti e fonte di estremo divertimento. Io uso i 'live_loop' per suonare musica nei locali con Sonic Pi; i DJ usano i dischi e io uso i 'live_loop' :-). Comunque, oggi andremo a programmare dal vivo sia la musica sia Minecraft.

en: Let's get started. Run the code above and start making your melon trail again. Now, without stopping the code, just simply change `:melon` to `:brick` and hit run. Hey presto, you're now making a brick trail. How simple was that! Fancy some music to go with it? Easy. Try this:
it: Iniziamo. Esegui il codice sopra e inizia nuovamente a costruire la tua scia di meloni. Adesso, senza fermare l'esecuzione, cambia ':melon' con ':brick' (mattone) e premi Run. Bravo! Adesso stai facendo una scia di mattoni. Semplice no?! Vuoi aggiungere anche un po' di musica? Facile, prova questo:

en: Now, whilst that's playing start changing the code. Change the block types - try `:water`, `:grass` or your favourite block type. Also, try changing the cutoff value from `70` to `80` and then up to `100`. Isn't this fun?
it: Ora, mentre la musica sta suonando, tu comincia a cambiare il codice. Cambia i tipi di blocco: prova ':water', ':grass' o la tua categoria di blocchi preferita. Cambia anche il valore 'cutoff:' da '70' a '80' e successivamente anche a '100'. Non è divertente?

en: Let's combine everything we've seen so far with a little extra magic. Let's combine our teleportation ability with block placing and music to make a Minecraft Music Video. Don't worry if you don't understand it all, just type it in and have a play by changing some of the values whilst it's running live. Have fun and see you next time...
it: Combiniamo tutto quello che abbiamo visto finora aggiungendo un tocco di ulteriore magia. Associamo la nostra abilità di teletrasportarci, il posizionamento dei blocchi e la musica per fare una sorta di video musicale di Minecraft. Non ti preoccupare se non riesci a capire tutto. Digita soltanto il testo e divertiti cambiando alcuni valori mentre il codice è in esecuzione. Divertiti e ci vediamo la prossima volta...

en: A.7 Bizet Beats
it: A.7 Battiti di Bizet

en: Bizet Beats
it: Battiti di Bizet

en: After our brief excursion to the fantastic world of coding Minecraft with Sonic Pi last month, let's get musical again. Today we're going to bring a classical operatic dance piece straight into the 21st century using the awesome power of code.
it: Dopo la nostra breve trattazione del fantastico mondo del controllo di Minecraft attraverso Sonic Pi dello scorso mese, ricominciamo a fare musica. Oggi, ci occuperemo di creare un fantastico pezzo dance del 21° secolo usando le meravigliose proprietà del codice.

en: Outrageous and Disruptive
it: Oltraggioso e distruttivo

en: Let's jump into a time machine back to the year 1875. A composer called Bizet had just finished his latest opera Carmen. Unfortunately like many exciting and disruptive new pieces of music people initially didn't like it at all because it was too outrageous and different. Sadly Bizet died ten years before the opera gained huge international success and became one of the most famous and frequently performed operas of all time. In sympathy with this tragedy let's take one of the main themes from Carmen and convert it to a modern format of music that is also too outrageous and different for most people in our time - live coded music!
it: Torniamo indetro al 1875. Un compositore chiamato Bizet aveva appena terminato la sua ultima opera, Carmen. Sfortunatamente, come molti pezzi che rompevano gli schemi preesistenti, le persone non apprezzarono questa opera perché fu considerata oltraggiosa e troppo fuori dai canoni. Purtroppo, Bizet morì dieci anni prima di vedere il suo lavoro salire al successo internazionale, diventando una delle opere più famose ed eseguite della storia della musica. Per onorare questa tragedia, prendiamo una delle melodie più famose della Carmen e rivisitiamola in chiave moderna rendendola anche noi oltraggiosa e differente dai canoni prestabiliti a noi contemporanei. La suoneremo attraverso il live coding!

en: Decoding the Habanera
it: Decodificare la Habanera

en: Trying to live code the whole opera would be a bit of a challenge for this tutorial, so let's focus on one of the most famous parts - the bass line to the Habanera:
it: Suonare con il live coding l'intera opera sarebbe una cosa un po' difficile da far entrare in questa guida, quindi focalizziamoci soltanto sulle parti più famose. In questo caso, prendiamo la linea di basso dell'Habanera:

en: This may look extremely unreadable to you if you haven't yet studied music notation. However, as programmers we see music notation as just another form of code - only it represents instructions to a musician instead of a computer. We therefore need to figure out a way of decoding it.
it: Questa cosa potrebbe sembrare particolarmente difficile da leggere se non hai studiato la notazione musicale. Tuttavia, noi programmatori consideriamo la notazione musicale come una forma diversa di codice. Infatti essa rappresenta delle istruzioni destinate a un musicista invece che a un computer. Quindi, dobbiamo solo capire come riuscire a decodificarla.

en: Notes
it: Note

en: The notes are arranged from left to right like the words in this magazine but also have different heights. *The height on the score represents the pitch of the note.* The higher the note on the score, the higher the pitch of the note.
it: Le note sono organizzate da destra a sinistra, in modo simile alle parole di questa rivista. Però, esse hanno anche differenti altezze. *La posizione verticale della nota rappresenta anche quanto essa è acuta o grave.* Più è posta in alto nel pentagramma, più la nota sarà acuta.

en: In Sonic Pi we already know how to change the pitch of a note - we either use high or low numbers such as `play 75` and `play 80` or we use the note names: `play :E` and `play :F`. Luckily each of the vertical positions of the musical score represents a specific note name. Take a look at this handy look up table:
it: Abbiamo già visto come cambiare l'altezza di una nota in Sonic Pi. Possiamo usare sia numeri più o meno alti come 'play 75' o 'play 80', sia i nomi delle note in notazione alfabetica come 'play :E' e 'play :F' (ovvero suona Mi e suona Fa in notazione italiana). Fortunatamente, ogni posizione della nota nella partitura rappresenta il nome di una specifica nota. Dai un'occhiata a questa tabella:

en: Rests
it: Pause

en: Music scores are an extremely rich and expressive kind of code capable of communicating many things. It therefore shouldn't come as much of a surprise that musical scores can not only tell you what notes to play but also when *not* to play notes. In programming this is pretty much equivalent to the idea of `nil` or `null` - the absence of a value. In other words not playing a note is like the absence of a note.
it: La partitura musicale è un tipo di codice molto ricco ed espressivo, capace di comunicare molte cose. Non dovrebbe essere troppo soprendente quindi scoprire che essa non solo ti dice quale nota suonare ma anche quando non devi suonarne. Nei linguaggi di programmazione, questo aspetto somiglia all'idea di 'nil' o 'null', ovvero l'assenza di un valore. In altre parole, non suonare una nota significa l'assenza di una nota.

en: If you look closely at the score you'll see that it's actually a combination of black dots with lines which represent notes to play and squiggly things which represent the rests. Luckily Sonic Pi has a very handy representation for a rest: `:r`, so if we run: `play :r` it actually plays silence! We could also write `play :rest`, `play nil` or `play false` which are all equivalent ways of representing rests.
it: Se guardi attentamente la partitura, ti accorgerai che è formata da una combinazione di punti neri dotati di linee che rappresentano la nota da suonare e delle cose strambe che rappresentano le pause. Fortunatamente, Sonic Pi ha una rappresentazione molto pratica delle pause: ':r'. Quindi se eseguiamo l'istruzione 'plat :r', Sonic Pi suonerà il silenzio! Possiamo anche scrivere 'play :rest', 'play nil' o 'play false', che sono tutti equivalenti alla prima.

en: Rhythm
it: Ritmo

en: Finally, there's one last thing to learn how to decode in the notation - the timings of the notes. In the original notation you'll see that the notes are connected with thick lines called beams. The second note has two of these beams which means it lasts for a 16th of a beat. The other notes have a single beam which means they last for an 8th of a beat. The rest has two squiggly beams which means it also represents a 16th of the beat.
it: Infine c'è un'ultima cosa da imparare: come decodificare la notazione ovvero il timing delle note. Nella notazione originale, puoi vedere che le note sono connesse da linee spesse chiamate codette (o stanghette). La seconda nota ha due stanghette quindi dura 1/16. Le altre note hanno una singola stanghetta che indica una durata di 1/8. La pausa ha anch'essa due stanghette infatti ha una durata di 1/16.

en: When we attempt to decode and explore new things a very handy trick is to make everything as similar as possible to try and see any relationships or patterns. For example, when we re-write our notation purely in 16ths you can see that our notation just turns into a nice sequence of notes and rests.
it: Quando proviamo a decodificare o esplorare nuove cose, un trucco è rendere tutto il più simile possibile per vedere eventuali relazioni o pattern. Per esempio, quando riscriviamo tutto con note da 1/16 puoi notare come la notazione diventi una bella sequenza di note e pause.

en: Re-coding the Habanera
it: Programmare l'Habanera

en: We're now in a position to start translating this bass line to Sonic Pi. Let's encode these notes and rests in a ring:
it: Stiamo per tradurre questa linea di basso in Sonic Pi. Codifichiamo queste note e pause in un anello:

en: Let's see what this sounds like. Throw it in a live loop and tick through it:
it: Proviamo a sentire come suona. Inseriamo tutto in un live loop con un tick per scorrere:

en: Fabulous, that instantly recognisable riff springs to life through your speakers. It took a lot of effort to get here, but it was worth it - high five!
it: Fantastico, il riff che suona dalle casse è istantaneamente riconoscibile. È stato molto faticoso arrivare fino a qui ma ne valeva la pena. Batti un cinque!

en: Moody Synths
it: Synth malinconico

en: Now we have the bass line, let's re-create some of the ambience of the operatic scene. One synth to try out is `:blade` which is a moody 80s style synth lead. Let's try it with the starting note `:d` passed through a slicer and reverb:
it: Ora che abbiamo la linea di basso, ricreiamo l'ambientazione della scene lirica. Un synth da provare è `:blade` che è un sintetizzatore malinconico degli anni '80. Proviamolo facendo passare la nota iniziale `:d` attraverso uno slicer e un riverbero:

en: Now, try the other notes in the bass line: `:a` and `:f5`. Remember, you don't need to hit stop, just modify the code whilst the music is playing and hit run again. Also, try different values for the slicer's `phase:` opt such as `0.5`, `0.75` and `1`.
it: Ora, proviamo con le altre note nella linea di basso: `:a` e `:f5`. Ricorda: non devi premere stop, puoi modificare il codice mentre la musica sta suonando e premere Run di nuovo. Prova anche a cambiare i valori (ad esempio `0.5`, `0.75` e `1`) del parametro `phase:` dello slicer.

en: Finally, let's combine all the ideas so far into a new remix of the Habanera. You might notice that I've included another part of the bass line as a comment. Once you've typed it all into a fresh buffer hit Run to hear the composition. Now, without hitting stop, *uncomment* the second line by removing the `#` and hit run again - how marvellous is that! Now, start mashing it around yourself and have fun.
it: Infine, combiniamo tutte le idee che abbiamo avuto fino ad ora per un remix dell'Habanera. Come puoi notare, ho aggiunto un'altra linea di basso come un commento. Una volta scritto tutto in un buffer vuoto, premi Run e senti come suona la composizione. Ora, senza premere stop *togli il commento* dalla seconda linea rimuovendo il `#` e poi premi di nuovo Run. Quando è figo? Ora prova a fare un po' di cambiamenti e divertiti.

en: A.8 Become a Minecraft VJ
it: A.8 Diventa un VJ di Minecraft

en: Become a Minecraft VJ
it: Diventa un DJ di Minecraft

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.
it: Tutti abbiamo giocato a Minecraft. Probabilmente avrai costruito strutture grandiose, disegnato trappole e creato linee di carrelli elaborate attraverso gli switch. Ma quanti di voi si sono esibiti con Minecraft? Scommetto che non sapevate di poter usare Minecraft per creare visual incredibili come un VJ professionista.

en: If your only way of modifying Minecraft was with the mouse, you'd have a tough time changing things fast enough. Luckily for you your Raspberry Pi comes with a version of Minecraft that can be controlled with code. It also comes with an app called Sonic Pi which makes coding Minecraft not only easy but also incredibly fun.
it: Se l'unico modo di modificare Minecraft fosse il mouse, faresti molta fatica a cambiare le cose velocemente. Per fortuna, il tuo Raspberry Pi ha una versione di Minecraft che può essere controllare con il codice. E c'è anche un'app chiamata Sonic Pi che rende programmare Minecraft facile e divertente.

en: In today's article we'll be showing you some of the tips and tricks that we've used to create performances in night clubs and music venues around the world.
it: Nell'articolo di oggi, ti mostrerò qualche trucchetto che abbiamo usato per esibirci in night club e locali in giro per il mondo.

en: Let's get started...
it: Cominciamo...

en: Getting Started
it: Cominciamo

en: Let's start with a simple warm up exercise to refresh ourselves with the basics. First up, crack open your Raspberry Pi and then fire up both Minecraft and Sonic Pi. In Minecraft, create a new world, and in Sonic Pi choose a fresh buffer and write in this code:
it: Partiamo da un semplice esercizio di riscaldamento per ricordarci le basi. Per prima cosa, apri sul tuo Raspberry Pi sia Minecraft che Sonic Pi. In Minecraft crea un nuovo mondo e in Sonic Pi scegli un buffer vuoto e incolla questo codice:

en: Hit the Run button and you'll see the message over in the Minecraft window. OK, we're ready to start, let's have some fun......
it: Premi Run e vedrai un messaggio nella finestra di Minecraft. Ok, siamo pronti per partire e divertici...

en: Sand Storms
it: Tempesta di sabbia

en: When we're using Minecraft to create visuals we try and think about what will both look interesting and also be easy to generate from code. One nice trick is to create a sand storm by dropping sand blocks from the sky. For that all we need are a few basic fns:
it: Quando usiamo Minecraft per creare visual, dobbiamo pensare a qualcosa che sia interessante da vedere e semplice da generare. Un semplice trucco è creare una tempesta di sabbia facendo cadere blocchi di sabbia dal cielo. Per farlo, abbiamo bisogno di semplici funzioni:

en: `sleep` - for inserting a delay between actions
it: `sleep` - per inserire una pausa tra le azioni

en: `mc_location` - to find our current location
it: `mc_location` - per trovare la nostra posizione attuale

en: `mc_set_block`- to place sand blocks at a specific location
it: `mc_set_block`- per piazzare blocchi di sabbia in una posizione specifica

en: `rrand` - to allow us to generate random values within a range
it: `rrand` - per generare valori casuali all'interno di un range

en: `live_loop` - to allow us to continually make it rain sand
it: `live_loop` - per avere una continua pioggia di sabbia

en: If you're unfamiliar with any of the built-in fns such as `rrand`, just type the word into your buffer, click on it and then hit the keyboard combo `Control-i` to bring up the built-in documentation. Alternatively you can navigate to the *lang* tab in the Help system and then look up the fns directly along with all the other exciting things you can do.
it: Se non sei a conoscenza di qualcuna di queste funzioni come, ad esempio, `rrand`, scrivi la parola nel buffer, fai click su di essa e poi premi `Control-i` per aprire la documentazione relativa. In alternativa puoi accedere alla tab *lang* nell'aiuto e cercare direttamente la funzione.

en: Let's make it rain a little first before unleashing the full power of the storm. Grab your current location and use it to create a few sand blocks up in the sky nearby:
it: Proviamo con un po' di pioggia prima di fare una vera tempesta. Otteniamo la posizione correte per creare qualche blocco di sabbia nel cielo:

en: When you hit Run, you might have to look around a little as the blocks may start falling down behind you depending on which direction you're currently facing. Don't worry, if you missed them just hit Run again for another batch of sand rain - just make sure you're looking the right way!
it: Quando premi Run prova a guardarti intorno perché i blocchi potrebbero scendere dietro di te in base a dove stai guardando. Non ti preoccupare, se te li sei persi, premi Run di nuovo... basta essere sicuri di guardare nella giusta direzione!

en: Let's quickly review what's going on here. On the first line we grabbed Steve's location as coordinates with the fn `mc_location` and placed them into the vars `x`, `y`, and `z`. Then on the next lines we used the `mc_set_block` fn to place some sand at the same coordinates as Steve but with some modifications. We chose the same x coordinate, a y coordinate 20 blocks higher and then successively larger z coordinates so the sand dropped in a line away from Steve.
it: Analizziamo velocemente cosa sta succedendo. Nella prima linea abbiamo preso la posizione di Steve come coordinate per la funzione `mc_location` e le abbiamo inserite nelle variabili `x`, `y`, e `z`. Poi, nella riga successiva, abbiamo usato `mc_set_block` per piazzare un po' di sabbia nelle stesse coordinate con una leggera modifica: abbiamo scelto la stessa x mentre y e z con valori di 20 blocchi maggiori per far si che i blocchi di sabbia cadessero in linea lontano da Steve.

en: Why don't you take that code and start playing around with it yourself? Try adding more lines, changing the sleep times, try mixing `:sand` with `:gravel` and choose different coordinates. Just experiment and have fun!
it: Perché non provi a modificare un po' questo codice? Aggiungi un po' di righe, cambia i tempi di pausa, prova a modificare `:sand` con `:gravel` e scegli coordinate different. Sperimenta e divertiti!

en: Live Loops Unleashed
it: Liberiamo il Live Loop

en: OK, it's time to get the storm raging by unleashing the full power of the `live_loop` - Sonic Pi's magical ability which unleashes the full power of live coding - changing code on-the-fly whilst it's running!
it: Ok, è tempo di fare un vera e propria tempesta utilizzando la potenza di `live_loop`, una delle funzioni magiche di Sonic Pi che ci permette di esplorare tutta la potenza del live coding: modificare il codice mentre sta funzionando!

en: What fun! We're looping round pretty quickly (8 times a second) and during each loop we're finding Steve's location like before but then generating 3 random values:
it: Che divertimento! Stiamo ripetendo tutto abbastanza velocemente (8 volte al secondo) e ad ogni loop cerchiamo la posizione di Steve ma stavolta generiamo 3 valori casuali:

en: `xd` - the difference for x which will be between -10 and 10
it: 'xd' - quando x è tra -10 e 10

en: `zd` - the difference for z also between -10 and 10
it: 'zd' - quando anche z è tra -10 e 10

en: `co` - a cutoff value for the low pass filter between 70 and 130
it: 'co' - è un valore di taglio di un filtro passabasso e può stare tra 70 e 130

en: We then use those random values in the fns `synth` and `mc_set_block` giving us sand falling in random locations around Steve along with a percussive rain-like sound from the `:cnoise` synth.
it: Quindi usiamo quei valori casuali nelle funzioni 'synth' e 'mc_set_block' per creare della sabbia che cade in luoghi casuali intorno a Steve insieme a un suono percussivo di pioggia prodotto dal synth ':cnoise'.

en: For those of you new to live loops - this is where the fun really starts with Sonic Pi. Whilst the code is running and the sand is pouring down, try changing one of the values, perhaps the sleep time to `0.25` or the `:sand` block type to `:gravel`. Now hit run *again*. Hey Presto! Things changed without the code stopping. This is your gateway to performing like a real VJ. Keep practising and changing things around. How different can you make the visuals without stopping the code?
it: Per quelli e quelle che ancora non conoscono i live loop, posso dirvi che è proprio qui che ci si comincia a divertire con Sonic Pi. Mentre il codice è in esecuzione e la sabbia sta cadendo, prova a cambiare uno dei valori, magari il tempo di sleep a '0.25' oppure la tipologia di blocco da ':sand' a ':gravel'. Premi di nuovo Run. Hey, facile! Le cose sono cambiate senza arrestare l'esecuzione. Questo è il tuo primo passo nella carriera di VJ! Continua a fare pratica e a cambiare le cose. Quanto puoi cambiare le immagini senza arrestare l'esecuzione del codice?

en: Epic Block Patterns
it: Combinazioni di blocchi epiche

en: Finally, another great way of generating interesting visuals is to generate huge patterned walls to fly towards and close by. For this effect we'll need to move from placing the blocks randomly to placing them in an ordered manner. We can do this by nesting two sets of iteration (hit the Help button and navigate to section 5.2 of the tutorial "Iteration and Loops" for more background on iteration). The funny `|xd|` after the do means that `xd` will be set for each value of the iteration. So the first time it will be 0, then 1, then 2... etc. By nesting two lots of iteration together like this we can generate all the coordinates for a square. We can then randomly choose block types from a ring of blocks for an interesting effect:
it: Infine, un altro modo molto divertente di generare delle immagini interessanti è di creare enormi muri con diverse combinazioni di blocchi sopra cui volare e avvicinarsi. Per creare questo effetto, dobbiamo smettere di posizionare i blocchi casualmente, mettendoli invece in maniera ordinata. Possiamo farlo intrecciando due gruppi di iterazioni diverse (premi il tasto Help e vai alla sezione 5.2, "Iterazione e loop" per maggiori informazioni sull'iterazione). Il valore '|xd|' posizionato dopo il 'do' significa che 'xd' sarà il valore stabilito per ogni iterazione. Quindi, la prima volta sarà 0, poi 1, 2 e così via. Intrecciando due iterazioni tra loro in questo modo possiamo generare tutte le coordinate di un quadrato. Così, poi possiamo scegliere casualmente i tipi di blocco per creare degli effetti interessanti:

en: Pretty neat. Whilst we're having fun here, try changing `bs.choose` to `bs.tick` to move from a random pattern to a more regular one. Try changing the block types and the more adventurous of you might want to try sticking this within a `live_loop` so that the patterns keep changing automatically.
it: Abbastanza chiaro. Mentre ci divertiamo qui, proviamo a cambiare 'bs.choose' con 'bs.tick' per spostarci da uno schema casuale a uno più regolare. Prova a cambiare anche il tipo di blocco e i più coraggiosi possono anche provare a includere tutto in un 'live_loop' così che la struttura continuerà a cambiare automaticamente.

en: Now, for the VJ finale - change the two `10.times` to `100.times` and hit Run. Kaboom! A Huge gigantic wall of randomly placed bricks. Imagine how long it would take you to build that manually with your mouse! Double-tap space to enter fly-mode and start swooping by for some great visual effects. Don't stop here though - use your imagination to conjure up some cool ideas and then use the coding power of Sonic Pi to make it real. When you've practised enough dim the lights and put on a VJ show for your friends!
it: Quindi, per un gran finale da VJ, cambia i due '10.times' con '100.times' e premi Run. Booom! Un muro gigantesco di blocchi posti casualmente! Immaginati quando tempo potresti impiegare a costruire una cosa del genere usando solo il mouse! Premi due volte lo spazio per entrare in modalità volante e comincia a sorvolare tutto per creare un fantastico effetto visivo. Non fermarti qui, usa la tua immaginazione per dar forma alle tue idee e poi utilizza il potere del codice di Sonic Pi per realizzarle. Quando avrai fatto pratica a sufficienza, abbassa le luci e organizza uno spettacolo visuale per i tuoi amici!

en: A.9 Randomisation
it: A.9 Randomizzazione

en: Surfing Random Streams
it: Scivolare su correnti casuali

en: Back in episode 4 of this tutorial series we took a brief look at randomisation whilst coding up some sizzling synth riffs. Given that randomisation is such an important part of my live coding DJ sets I thought it would be useful to cover the fundamentals in much greater detail. So, get your lucky hat on and let's surf some random streams!
it: Tornando indietro all'episodio 4 di questo tutorial, avevamo dato un breve sguardo alla randomizzazione mentre programmavamo alcuni riff di synth. Considerando che la randomizzazione è una parte importante della mia pratica musicale live code DJ, ho pensato che fosse utile di trattare i fondamentali di questo aspetto più nel dettaglio. Quindi, mettiti comodo e partiamo sulle strade della randomizzazione!

en: There is no random
it: Il caso non esiste

en: The first thing to learn which might really surprise you when playing with Sonic Pi's randomisation functions is that they're not actually really random. What does this actually mean? Well, let's try a couple of tests. First, imagine a number in your head between 0 and 1. Keep it there and don't tell me. Now let me guess... was it `0.321567`? No? Bah, I'm clearly no good at this. Let me have another go, but let's ask Sonic Pi to choose a number this time. Fire up Sonic Pi v2.7+ and ask it for a random number but again don't tell me:
it: La prima cosa da imparare, e che potrebbe sorprenderti quando suoni le funzioni random di Sonic PI, è che in realtà esse non sono davvero casuali. Che significa questo? Proviamo a fare un paio di prove. Primo: prova a pensare un numero tra 0 e 1. Tienitelo in mente e non dirmelo. Provo a indovinare...Era '0.321567'? No? Bah, non sono molto bravo allora. Fammi fare un altro tentativo, ma stavolta fai scegliere il numero a Sonic Pi. Avvia il programma e chiedigli un numero casuale; ma anche stavolta non dirmelo:

en: print rand
it: print rand (stampa i numeri casuali)

en: Now for the reveal... was it `0.75006103515625`? Yes! Ha, I can see you're a little sceptical. Perhaps it was just a lucky guess. Let's try again. Press the Run button again and see what we get... What? `0.75006103515625` again? This clearly can't be random! You're right, it's not.
it: Quindi riproviamoci...era `0.75006103515625`? Sì! Riesco a vedere il tuo scetticismo. Forse era solo fortuna. Riproviamo. Premi di nuovo Run e vediamo che cosa esce...Cosa, `0.75006103515625` di nuovo? Questo non può essere sicuramente casuale! Sì, hai ragione, non lo è.

en: What's going on here? The fancy computer science word here is determinism. This just means that nothing is by chance and everything is destined to be. Your version of Sonic Pi is destined to always return `0.75006103515625` in the program above. This might sound pretty useless, but let me assure you that it's one of the most powerful parts of Sonic Pi. If you stick at it you'll learn how to rely on the deterministic nature of Sonic Pi's randomisation as a fundamental building block for your compositions and live coded DJ sets.
it: Che sta succedendo? La parola usata in informatica è determinismo. Questo significa che niente è casuale e tutto è destinato a esserlo. La tua versione di Sonic Pi è destinata sempre a restituire il numero `0.75006103515625` se esegui il programma scritto sopra. Questo potrebbe sembrarti piuttosto inutile, ma ti assicuro che invece è uno degli aspetti più utili di Sonic Pi. Se ti applichi un po' imparerai come rapportarti alla natura deterministica della randomizzazione di Sonic Pi e capirai che questo aspetto è fondamentale per le tue composizioni e le tue performance da DJ.

en: A Random Melody
it: Una melodia casuale

en: When Sonic Pi boots it actually loads into memory a sequence of 441,000 pre-generated random values. When you call a random function such as `rand` or `rrand`, this random stream is used to generate your result. Each call to a random function consumes a value from this stream. Therefore the 10th call to a random function will use the 10th value from the stream. Also, every time you press the Run button, the stream is reset for that run. This is why I could predict the result to `rand` and why the 'random' melody was the same every time. Everybody's version of Sonic Pi uses the exact same random stream which is very important when we start sharing our pieces with each other.
it: Quando Sonic Pi si avvia, in realtà carica nella memoria una sequenza di 441000 valori casuali già generati. Quando richiami una funzione che genera casualità, come 'rand' o 'rrand', questo flusso casuale è usato per generare il tuo risultato. Ogni richiamo di una funzione di questo tipo prende i valori da questo flusso. Quindi la decima chiamata di una funzione random userà il decimo valore di quel flusso. Inoltre, ogni volta che premi Run, il flusso riparte da zero. Questo è il motivo per cui sono riuscito a predire il risultato prima ed è anche il motivo per cui una melodia 'casuale' è sempre uguale ogni volta. Ogni versione di Sonic Pi usa lo stesso flusso di valori casuali. Questo è molto importante quando cominciamo a condividere i nostri brani musicali tra noi.

en: Let's use this knowledge to generate a repeatable random melody:
it: Usiamo quanto appena imparato per generare una melodia casuale ripetibile:

en: Type this into a spare buffer and hit Run. You'll hear a melody consisting of 'random' notes between 50 and 95. When it's finished, hit Run again to hear exactly the same melody again.
it: Digita il codice sopra in una finestra vuota e premi Run. Ascolterai una melodia di note 'casuali' incluse tra 50 e 95. Quando è terminata, premi di nuovo Run e sentirai esattamente la stessa melodia.

en: Handy Randomisation Functions
it: Funzioni utili di randomizzazione

en: Sonic Pi comes with a number of useful functions for working with the random stream. Here's a list of some of the most useful:
it: Sonic Pi viene fornito con una serie di funzioni utili per lavorare con il flusso di dati casuali. Eccoti una lista di alcune delle migliori:

en: `rand` - Simply returns the next value in the random stream
it: 'rand' - Semplicemente restituisce il prossimo valore del flusso di numeri casuali

en: `rrand` - Returns a random value within a range
it: 'rrand' - Restituisce un valore casuale all'interno di due valori predeterminati

en: `rrand_i` - Returns a random whole number within a range
it: 'rrand_i' - Restituisce un numero intero casuale all'interno di un intervallo predeterminato

en: `one_in` - Returns true or false with the given probability
it: 'one_in' - è vero o falso secondo una casualità predeterminata

en: `dice` - Imitates rolling a dice and returns a value between 1 and 6
it: 'dice' - imita il comportamento di un dado e quindi restituisce valori casuali tra 1 e 6

en: `choose` - Chooses a random value from a list
it: 'choose' - sceglie valori casuali da una lista

en: Check out their documentation in the Help system for detailed information and examples.
it: Dai un'occhiata alla loro documentazione nella sezione Help se vuoi maggiori informazioni o degli esempi.

en: Resetting the Stream
it: Azzerare il flusso

en: Whilst the ability to repeat a sequence of chosen notes is essential to allow you to replay a riff on the dance floor, it might not be exactly the riff you want. Wouldn't it be great if we could try a number of different riffs and choose the one we liked best? This is where the real magic starts.
it: L'abilità di ripetere una sequenza di note predeterminate è essenziale per riprodurre un riff mentre suoni. Tuttavia, quello che senti potrebbe non essere esattamente il riff a cui avevi pensato. Non sarebbe bello poter provare alcuni differenti riff e scegliere quello preferito? Qui è dove la magia ha inizio.

en: We can manually set the stream with the fn `use_random_seed`. In Computer Science, a random seed is the starting point from which a new stream of random values can sprout out and blossom. Let's try it:
it: Possiamo regolare il flusso usando la funzione 'use_random_seed'. In informatica, un random seed, ovvero un generatore di numeri casuali, ha un punto di inizio dal quale il flusso di valori causali parte. Prova quanto segue:

en: Great, we get the first three notes of our random melody above: `84`, `83` and `71`. However, we can now change the seed to something else. How about this:
it: Bene! Abbiamo ottenuto le prime tre note della nostra melodia casuale: '84', '83' e '71. Tuttavia, se vogliamo possiamo cambiare questa serie. Prova a eseguire questo:

en: Interesting, we get `83`, `71` and `61` . You might notice that the first two numbers here are the same as the last two numbers before - this isn't a coincidence.
it: Interessante, abbiamo ottenuto '83', '71' e '61'. Forse noterai che le prime due cifre di questa serie sono le stesse delle ultime due appartenenti alla serie precedente. E non è una coincidenza.

en: Remember that the random stream is just a giant list of 'pre-rolled' values. Using a random seed simply jumps us to a point in that list. Another way of thinking about it is to imagine a huge deck of pre-shuffled cards. Using a random seed is cutting the deck at a particular point. The fabulous part of this is that it's precisely this ability to jump around the random stream which gives us huge power when making music.
it: Ricordati che il flusso di dati casuali è semplicemente una lista gigante di valori già predeterminati. Eseguendo 'use_random_seed' scegliamo da dove partire. Un'altra immagine che può renderti l'idea è un enorme mazzo di carte già mischiato. Usando questa funzione, noi scegliamo dove tagliare il mazzo. La cosa eccitante di questa funzione è proprio la sua abilità di saltare al punto del flusso che vogliamo, dandoci infinite possibilità musicali.

en: Let's revisit our random melody of 8 notes with this new stream resetting power, but let's also throw in a live loop so we can experiment live whilst it's playing:
it: Riguardiamo brevemente la nostra melodia casuale di 8 note implementando questa funzione. Prima però inserisci il codice all'interno di un live loop, così possiamo effettuare modifiche mentre la melodia continua a suonare:

en: Now, whilst it's still playing, change the seed value from `0` to something else. Try `100`, what about `999`. Try your own values, experiment and play around - see which seed generates the riff you like best.
it: Adesso, mentre sta ancora suonando, cambia il valore della funzione da '0' a qualcos'altro. Prova '100' oppire '999'. Prova anche valori a tua scelta, sperimenta e divertiti. Valuta qual'è il riff che ti piace di più.

en: This month's tutorial has been quite a technical dive into the workings of Sonic Pi's randomisation functionality. Hopefully it has given you some insight into how it works and how you can start using randomisation in a reliable way to create repeatable patterns within your music. It's important to stress that you can use repeatable randomisation *anywhere* you want. For example, you can randomise the amplitude of notes, the timing of the rhythm, the amount of reverb, the current synth, the mix of an FX, etc. etc. In the future we'll take a close look at some of these applications, but for now let me leave you with a short example.
it: Il tutorial di questo mese è stato un bel tuffo nelle funzioni di casualità utilizzabili in Sonic Pi. Spero di essere riuscito a darvi un'idea di come funziona e di aver suggerito un punto di partenza per usare la casualità in modo affidabile per creare pattern ripetitivi nella tua musica. È importante ribadire che puoi usare questa casualità ripetute *dovunque* tu voglia. Per esempio lo puoi fare per il volume delle note, il tempo di un ritmo, la quantità di riverbero, il synth corrente, il mix di un effetto ecc... In futuro vedremo alcune di queste applicazioni in dettaglio ma, per oggi, vi lascio con un piccolo esempio.

en: Type the following into a spare buffer, hit Run, and then start changing the seeds around, hit Run again (whilst it's still playing) and explore the different sounds, rhythms and melodies you can make. When you find a nice one, remember the seed number so you can get back to it. Finally, when you've found a few seeds you like, put on a live coded performance for your friends by simply switching between your favourite seeds to create a full piece.
it: Scrivi il seguente codice in un buffer vuoto, premi Run e prova a cambiare il valore di seed. Premi Run di nuovo (mentre sta andando) e esplora le differenze sonore, di ritmo e di melodia che riesci a fare. Quando ne trovi una bella, ricordati del numero di seed per poterla risuonare. Infine, quando hai trovato un secondo valore di seed che produce risultati interessanti, fai una performance per i tuoi amici cambiando semplicemente tra un valore di seed e l'altro.

en: A.10 Control
it: A.10 Controlli

en: Controlling Your Sound
it: Controllare il tuo suono

en: So far during this series we've focussed on triggering sounds. We've discovered that we can trigger the many synths built into Sonic Pi with `play` or `synth` and how to trigger pre-recorded samples with `sample`. We've also looked at how we can wrap these triggered sounds within studio FX such as reverb and distortion using the `with_fx` command. Combine this with Sonic Pi's incredibly accurate timing system and you can produce a vast array of sounds, beats and riffs. However, once you've carefully selected a particular sound's options and triggered it, there's no ability to mess with it whilst it's playing right? Wrong! Today you're going to learn something very powerful - how to control running synths.
it: Fino ad ora ci siamo concentrati su come far partire suoni. Abbiamo scoperto che possiamo usare i synth inclusi in Sonic Pi utilizzando `play` o `synth` e come far suonare suoni pre-registrati con `sample`. Abbiamo anche imparato come aggiungere degli effetti a questi suoni come, ad esempio, il riverbero, utilizzando il comando `with_fx`. Combinando tutte queste cose con la gestione del tempo di Sonic Pi, puoi produrre una grande quantità di suoni, beat e riff. Però, una volta lanciata un'opzione di un suono, non c'è modo di controllarla, giusto? Sbagliato! Oggi impareremo qualcosa di molto importante: come controllare i synth mentre suonano.

en: A Basic Sound
it: Un suono semplice

en: Let's create a nice simple sound. Fire up Sonic Pi and in a fresh buffer type the following:
it: Creiamo un suono semplice. Apri Sonic Pi e scrivi questo codice:

en: Now press the Run button at the top left to hear a lovely rumbling synth sound. Go ahead, press it again a few times to get a feel for it. OK, done? Let's start controlling it!
it: Ora premi il pulsante Run in alto a sinistra per ascoltare il suono. Ok, premilo un altro paio di volte per sentire come suona. Fatto? Bene, ora cominciamo a controllarlo!

en: Synth Nodes
it: Nodi dei synth

en: A little known feature in Sonic Pi is that the fns `play`, `synth` and `sample`, return something called a `SynthNode` which represents a running sound. You can capture one of these `SynthNode`s using a standard variable and then **control** it at a later point in time. For example, let's change the value of the `cutoff:` opt after 1 beat:
it: Una cosa di Sonic Pi che conoscono in pochi è che le funzioni `play`, `synth` e `sample` restituiscono una cosa chiamata `SynthNode` che rappresenta un suono riprodotto. È possibile controllare questi `SynthNode` usando una variabile e poi **controllarla** successivamente. Proviamo a cambiare il valore di `cutoff:` dopo 1 beat:

en: Let's look at each line in turn:
it: Guardiamo ogni linea di codice:

en: Firstly we trigger the `:prophet` synth using the `synth` fn as normal. However we also capture the result in a variable called `sn`. We could have called this variable something completely different such as `synth_node` or `jane` - the name doesn't matter. However, it's important to choose a name that's meaningful to you for your performances and for people reading your code. I chose `sn` as it's a nice short mnemonic for synth node.
it: Per prima cosa abbiamo suonato il synth `:prophet` utilizzando la normale funzione `synth`. Abbiamo, però, catturato il risultato in una variable chiamata `sn`. Avremmo potuto usare qualsiasi nome come, ad esempio, `synth_note`, o `jane`. Non avrebbe fatto differenza. È importante, però, scegliere nomi che abbiano un senso per la performance e per le persone che leggono il tuo codice. Io ho scelto `sn` perché è diminutivo facile da ricordare per synth node.

en: On line 2 we have a standard `sleep` command. This does nothing special - it just asks the computer to wait for 1 beat before moving onto the next line.
it: Nella seconda linea abbiamo un comando `sleep` normalissimo; non fa nulla di speciale se non dire al computer di aspettare 1 beat prima di andare avanti.

en: Line 3 is where the control fun starts. Here, we use the `control` fn to tell our running `SynthNode` to change the cutoff value to `130`. If you hit the **Run** button, you'll hear the `:prophet` synth start playing as before, but after 1 beat it will shift to sound a lot brighter.
it: La linea 3 è dove comincia il divertimento. Ora usiamo la funzione `control` per dire al nostro `SynthNode` di cambiare il valore di cutoff a `130`. Se premi **Run** sentirai il `:prophet` suonare come prima ma, dopo 1 beat, il suono diventerà molto più chiaro.

en: Modulatable Options
it: Opzioni modulabili

en: Most of Sonic Pi's synths and FX opts may be changed after being triggered. However, this isn't the case for all of them. For example, the envelope opts `attack:`, `decay:`, `sustain:` and `release:` can only be set when triggering the synth. Figuring out which opts can and can't be changed is simple - just head to the documentation for a given synth or FX and then scroll down to the individual option documentation and look for the phrases "May be changed whilst playing" or "Can not be changed once set". For example, the documentation for the `:beep` synth's `attack:` opt makes it clear that it's not possible to change it:
it: La maggior parte dei valori dei synth e degli effetti di Sonic Pi possono essere cambiati. Non è così per tutto, però. Per esempio i valori di inviluppo: `attack:`, `decay:`, `sustain:` e `release:` possono essere impostati prima dell'avvio del synth. Capire quali opzioni è possibile cambiare in corso d'opera è semplice, controlla nella documentazione per cercare la frase: "Può cambiare mentre sta suonando" oppure "Non può essere cambiato una volta impostato". Per esempio guardando la documentazione relativa al parametro `attack:` del synth `:beep` dice chiaramente che non può essere modificato:

en: Must be zero or greater
it: Deve essere più grande di 0

en: Can not be changed once set
it: Non può essere modificato una volta impostato

en: Scaled with current BPM value
it: Scalato con il valore BPM corrente

en: Multiple Changes
it: Cambi multipli

en: Whilst a synth is running you're not limited to changing it only once - you're free to change it as many times as you like. For example, we can turn our `:prophet` into a mini arpeggiator with the following:
it: Finché un synth sta suonando, non sei limitato al cambiarlo una volta sola; puoi farlo quante volte vuoi. Per esempio possiamo trasformare il nostro `:prophet` in un piccolo arpeggiatore così:

en: In this snippet of code we just added a couple of extra things. First we defined a new variable called `notes` which contains the notes we'd like to cycle through (an arpeggiator is just a fancy name for something that cycles through a list of notes in order). Secondly we replaced our single call to `control` with an iteration calling it 16 times. In each call to `control` we `.tick` through our ring of `notes` which will automatically repeat once we get to the end (thanks to the fabulous power of Sonic Pi's rings). For a bit of variety try replacing `.tick` with `.choose` and see if you can hear the difference.
it: In questo codice, abbiamo aggiunto un paio di cose in più. Per prima cosa abbiamo una variabile chiamata `notes` che contiene le note che vogliamo riprodurre (arpeggiatore è il nome carino che viene dato a qualcosa che suona delle note in ciclo). Seconda cosa: rimpiazziamo la nostra chiamata a `control` con un'interazione di 16 volte. In ogni chiamata a `control` usiamo `.tick`per il nostro anello di `notes` che si ripeterà automaticamente. Per un po' di varietà, prova a sostituire `.tick` con `.choose` e vedi se senti la differenza.

en: Note that we can change multiple opts simultaneously. Try changing the control line to the following and listen for the difference:
it: Ora che puoi controllare più parametri simultaneamente, prova a cambiare la linea di controllo con questo codice:

en: When we control a `SynthNode`, it responds exactly on time and instantly changes the value of the opt to the new one as if you'd pressed a button or flicked a switch requesting the change. This can sound rhythmical and percussive - especially if the opt controls an aspect of the timbre such as `cutoff:`. However, sometimes you don't want the change to happen instantaneously. Instead, you might want to smoothly move from the current value to the new one as if you'd moved a slider or dial. Of course, Sonic Pi can also do this too using the `_slide:` opts.
it: Quando controlliamo un `SynthNode`, risponde esattamente a tempo cambiando immediatamente il valore di un parametro come se avessi premuto un bottone. Questo può dare un suono percussivo, specialmente se il parametro controlla un aspetto del timbro come il `cutoff:`. Tuttavia a volte non vuoi che il cambiamento sia istantaneo; a volte vorresti che fosse graduale, come utilizzando uno slider. Ovviamente Sonic Pi ti permette di farlo usando il parametro `_slide:`.

en: Each opt that can be modified also has a special corresponding `_slide:` opt that allows you to specify a slide time. For example, `amp:` has `amp_slide:` and `cutoff:` has `cutoff_slide:`. These slide opts work slightly differently than all the other opts in that they tell the synth note how to behave **next time they are controlled**. Let's take a look:
it: Ogni parametro che può essere modificato ha un corrispondente con `_slide:` che permette di impostare un tempo. Per esempio `amp:` ha `amp_slide:` e `cutoff:` ha `cutoff_slide:`. Questi parametri funzionano in modo leggermente diverso dagli altri perché dicono al synth come comportarsi **la volta successiva che vengono controllati**. Diamo un'occhiata:

en: Notice how this example is exactly the same as before except with the addition of `cutoff_slide:`. This is saying that next time this synth has its `cutoff:` opt controlled, it will take 2 beats to slide from the current value to the new one. Therefore, when we use `control` you can hear the cutoff slide from 70 to 130. It creates an interesting dynamic feel to the sound. Now, try changing the `cutoff_slide:` time to a shorter value such as 0.5 or a longer value such as 4 to see how it changes the sound. Remember, you can slide any of the modifiable opts in exactly this way and each `_slide:` value can be totally different so you can have the cutoff sliding slowly, the amp sliding fast and the pan sliding somewhere in between if that's what you're looking to create...
it: Nota come questo esempio sia esattamente come lo stesso di prima con la sola aggiunta di `cutoff_slide:`. Questo significa che quando modificheremo il parametro `cutoff:` impiegherà 2 secondi per andare dal valore attuale al successivo. Possiamo usare `control` per sentire lo slide tra 70 e 130. Questo crea una dinamica interessante del suono. Ora prova a cambiare il valore `cutoff_slide:` su un intervallo di tempo più breve come 0.5 oppure più lungo come 4 e vedi come cambia il suono. Ricorda che puoi usare slide per ogni parametro modificabile e ciascuno `_slide:` può avere parametri differenti per cui puoi avere un cutoff lento e un amp veloce e un pan che sta tra i due.

en: Let's look at a short example which demonstrates the power of controlling synths after they've been triggered. Notice that you can also slide FX just like synths although with a slightly different syntax. Check out section 7.2 of the built-in tutorial for more information on controlling FX.
it: Proviamo a guardare a un breve esempio che dimostra la potenza del controllo dei synth. Nota come puoi controllare anche gli effetti cambiando leggermente la sintassi. Rileggiti la sezione 7.2 dei tutorial per maggiori informazioni sugli effetti.

en: Copy the code into a spare buffer and take a listen. Don't stop there though - play around with the code. Change the slide times, change the notes, the synth, the FX and the sleep times and see if you can turn it into something completely different!
it: Copia il codice su un buffer vuoto e ascoltalo. Non fermarlo, metti mano al codice. Cambia i tempi di slide, cambia le note, i synth, gli effetti e i tempi di sleep. Vedi se riesci a creare qualcosa di totalmente differente!

en: Tracking the Beat
it: Tenere traccia del beat

en: Last month in this series we took a deep technical dive into the randomisation system underpinning Sonic Pi. We explored how we can use it to deterministically add new levels of dynamic control over our code. This month we're going to continue our technical dive and turn our attention to Sonic Pi's unique tick system. By the end of this article you'll be ticking your way through rhythms and riffs on your way to being a live coding DJ.
it: Il mese scorso in questa serie abbiamo parlato in modo approfondito della casualità alla base di Sonic pi. Abbiamo capito come poterla sfruttare in modo deterministico per aggiungere nuovi livelli di controllo del nostro codice. Questo mese continueremo questa analisi approfondendo il sistema di tick di Sonic Pi. Alla fine di questo articolo utilizzerai i tick per i tuoi ritmi e nei tuoi riff per diventare un DJ live coder.

en: Beat Counting
it: Contrare i battiti

en: When making music we often want to do a different thing depending on which beat it is. Sonic Pi has a special beat counting system called `tick` to give you precise control over when a beat actually occurs and even supports multiple beats with their own tempos.
it: Quando facciamo musica spesso vogliamo che accada qualcosa in base al beat in cui ci troviamo. Sonic Pi ha un sistema di conteggio chiamato `tick` per avere totale controllo di dove ci troviamo nella battuta e, ovviamente, supporta beat multipli ciascuno col suo tempo.

en: Let's have a play - to advance the beat we just need to call `tick`. Open up a fresh buffer, type in the following and hit Run:
it: Diamoci da fare, per avanzare nel beat dobbiamo solo chiamare `tick`. Apriamo un buffer vuoto, scriviamo il seguente codice e premiamo su Run:

en: This will return the current beat: `0`. Notice that even if you press the Run button a few times it will always return `0`. This is because each run starts a fresh beat counting from 0. However, whilst the run is still active, we can advance the beat as many times as we want:
it: Ci verrà restituito il beat corrente, quindi `0`. Nota come anche premendo Run più volte il risultato sarà sempre `0`. Questo perché ad ogni avvio, il beat riparte da 0. Tuttavia, mentre Run è ancora attivo, possiamo avanzare nel beat tutte le volte che vogliamo:

en: Whenever you see the symbol `#=>` at the end of a line of code it means that that line will log the text on the right-hand-side. For example, `puts foo #=> 0` means the code `puts foo` prints `0` to the log at that point in the program.
it: Quando vedi il simbolo `#=>` alla fine di una riga vuol dire che quella linea di codice restituirà del testo nel log nella parte destra. Per esempio `puts foo #=> 0` significa che il codice `puts foo` scriverà `0` nel log.

en: Checking the Beat
it: Controllare il beat

en: We've seen that `tick` does two things. It increments (adds one) and returns the current beat. Sometimes we just want to look at the current beat without having to increment it which we can do via `look`:
it: Abbiamo visto che `tick` fa due cose: incrementa di uno il beat e restituisce il valore corrente. A volte vogliamo solo vedere il valore corrente senza incrementalo. Possiamo farlo usando `look`:

en: In this code we tick the beat up twice and then call `look` twice. We'll see the following values in the log: `0`, `1`, `1`, `1`. The first two `tick`s returned `0`, then `1` as expected, then the two `look`s just returned the last beat value twice which was `1`.
it: In questo codice usiamo il tick per aumentare la pulsazione due volte e poi usiamo `look`, anch'esso due volte. Nel log vedremo questi valori:  `0`, `1`, `1`, `1`. I primi due tick restituiscono `0` e `1` come ci aspettiamo i due `look` restituiscono l'ultimo valore due volte, ovvero `1`.

en: So now we can advance the beat with `tick` and check the beat with `look`. What next? We need something to tick over. Sonic Pi uses rings for representing riffs, melodies and rhythms and the tick system has been specifically designed to work very closely with them. In fact, rings have their own dot version of `tick` which does two things. Firstly, it acts like a regular tick and increments the beat. Secondly it looks up the ring value using the beat as the index. Let's take a look:
it: Quindi ora possiamo avanzare nel tempo con `tick` e controllare il beat con `look`. Cosa possiamo fare ancora? Dobbiamo avere qualcosa con cui usare tick. Sonic Pi utilizza gli anelli (ring) per rappresentare i riff, melodie e ritmi e il sistema dei tick è stato pensato per lavorare con essi. Di fatto gli anelli hanno la loro versione di `tick` che fa due cose. Innanzitutto funziona come un tick normale e incrementa il beat. In secondo luogo guarda il valore del ring utilizzano il valore del beat come indice. Diamo un'occhiata:

en: `.tick` is a special dot version of `tick` which will return the first value of the ring `:a`. We can grab each of the values in the ring by calling `.tick` multiple times:
it: `.tick` è una versione speciale di `tick` che ritornerà il primo valore del ring `:a`. Possiamo prendere ciascun valore del ring chiamando `.tick` più volte:

en: Take a look at the log and you'll see `:a`, `:b`, `:c` and then `:a` again. Notice that `look` returns `3`. Calls to `.tick` act just like they are regular calls to `tick` - they increment the local beat.
it: Prova a guarda il log e vedrai `:a`, `:b`, `:c` e poi di nuovo `:a`. Nota come `look` restituisce `3`. Le chiamate a `.tick` funzionano come normali chiamate di `tick`, incrementano il beat locale.

en: A Live Loop Arpeggiator
it: Un arpeggiatore con Live Loop

en: The real power comes when you mix `tick` with rings and `live_loop`s. When combined we have all the tools we need to both build and understand a simple arpegiator. We need just four things:
it: La vera potenza viene fuori quando utilizziamo `tick` con ring e `live_loop`. Quando combiniamo queste cose abbiamo tutti gli strumenti per costruite un semplice arpeggiatore. Abbiamo bisogno di quattro cose:

en: A ring containing the notes we want to loop over.
it: Un anello (ring) che contenga le note che vogliamo ripetere.

en: A means of incrementing and obtaining the beat.
it: Un mezzo per incrementare e ottenere il valore del beat.

en: The ability to play a note based on the current beat.
it: La possibilità di suonare una nota basata sul beat corrente.

en: A loop structure to keep the arpegiator repeating.
it: Una struttura di loop per continuare a ripetere l'arpeggiatore.

en: These concepts can all be found in the following code:
it: Tutti questi concetti possono essere ritrovati in questo codice:

en: Let's look at each of these lines. First we define our ring of notes which we'll continually play. We then create a `live_loop` called `:arp` which loops round for us. Each time round the `live_loop` we set our synth to `:dpulse` and then play the next note in our ring using `.tick`. Remember that this will increment our beat counter and use the latest beat value as an index into our notes ring. Finally, we wait for an eighth of a beat before looping round again.
it: Guardiamo ciascuna linea di codice. Per prima cosa definiamo un ring di note che continuerà a suonare. Dopodiché creiamo un `live_loop` chiamato `:arp` che continuerà a ripetersi. Ogni volta che si ripete il `live_loop`, impostiamo il synth per essere `:dpulse` e poi suonando la nota successiva usando `.tick`. Ricorda che questo incrementerà il nostro contatore di beat e userà l'ultimo valore di beat come indice nel nostro anello. Alla fine, aspettiamo per 1/8 di beat prima di ricominciare da capo.

en: Multiple Simultaneous Beats
it: Beat multipli simultanei

en: A really important thing to know is that `tick`s are local to the `live_loop`. This means that each `live_loop` has its own independent beat counter. This is much more powerful than having a global metronome and beat. Let's take a look at this in action:
it: Una cosa importante da sapere è che i `tick` valgono localmente nel `live_loop`. Questo significa che ciascun `live_loop` ha il suo contatore beat indipendente. Questa cosa è molto più potente che avere un metronomo globale e un beat. Proviamo a vederlo in azione:

en: Clashing Beats
it: Scontri tra beat

en: A big cause of confusion with Sonic Pi's tick system is when people want to tick over multiple rings in the same `live_loop`:
it: Una cosa che causa confusione con il sistema di tick di Sonic Pi è che le persone vogliono utilizzare il tick in più ring nello stesso `live_loop`:

en: Even though each `live_loop` has its own independent beat counter, we're calling `.tick` twice within the same `live_loop`. This means that the beat will be incremented twice every time round. This can produce some interesting polyrhythms but is often not what you want. There are two solutions to this problem. One option is to manually call `tick` at the start of the `live_loop` and then use `.look` to look up the current beat in each `live_loop`. The second solution is to pass a unique name to each call to `.tick` such as `.tick(:foo)`. Sonic Pi will then create and track a separate beat counter for each named tick you use. That way you can work with as many beats as you need! See the section on named ticks in 9.4 of the built-in tutorial for more information.
it: Anche se ciascun `live_loop` ha il suo beat counter indipendente, stiamo chiamando `.tick` due volte all'interno dello stesso `live_loop`. Questo significa che il beat verrà incrementato due volte ogni loop. Questo può generare dei poliritmi interessanti ma spesso non è quello che vogliamo. Ci sono due soluzioni per questo problema. Una è chiamare `tick`all'inizio del `live_loop` per poi usare `.look` per controllare il valore; la seconda è dare un nome a ogni chiamata `.tick` come, ad esempio `.tick(:foo)`. Sonic Pi creerà e terrà traccia di un contatore di beat per ciascun nome che utilizzerai. In questo modo puoi lavorare con quanti beat tu voglia! Prova a vedere la sezione 9.4 dei tutorial per maggiori informazioni.

en: Let's bring all this knowledge of `tick`s, `ring`s and `live_loop`s together for a final fun example. As usual, don't treat this as a finished piece. Start changing things and play around with it and see what you can turn it into. See you next time...
it: Mettiamo insieme tutto quello che abbiamo imparato su `tick`, `ring` e `live_loop` per un ultimo esempio. Come al solito, non trattarlo come un pezzo finito. Prova a cambiare le cose e a giocare con questo codice per vedere cosa riesci a combinare. Alla prossima...

en: A.12 Sample Slicing
it: A.12 Tagliare i campioni

en: Sample Slicing
it: Tagliare i campioni

en: Sound as Data
it: Il suono come dati

en: Before we get started let's just take a brief moment to understand how to work with samples. By now, you've all hopefully played with Sonic Pi's powerful sampler. If not, there's no time like the present! Boot up your Raspberry Pi, launch Sonic Pi from the Programming menu, type the following into a fresh buffer and then hit the Run button to hear a pre-recorded drum beat:
it: Prima di cominciare, prendiamo un momento per analizzare come lavorare con i campioni. Fino ad ora, avrai utilizzato il campionatore di Sonic Pi. Se non l'hai fatto, è il momento di cominciare! Accendi il tuo Rasberry Pi, apri Sonic Pi dal menu Programming e scrivi il seguente codice in un buffer vuoto e poi premi il pulsante Run per sentire un beat di batteria pre-registrato:

en: A recording of a sound is simply represented as data - lots of numbers between -1 and 1 which represent the peaks and troughs of the sound wave. If we play those numbers back in order, we get the original sound. However, what's to stop us from playing them back in a different order and creating a new sound?
it: Una registrazione di un suono può essere rappresentato come un flusso di dati: un sacco di numeri compresi tra -1 e 1 che rappresentano i picchi e, più in generale, l'onda sonora. Se suoniamo questi numeri in ordine, otteniamo il suono originale. Ma se decidessimo di suonarli in un ordine diverso per creare un nuovo suono?

en: How are samples actually recorded? It's actually pretty simple once you understand the basic physics of sound. When you make a sound - for example by hitting a drum, the noise travels through the air in a similar fashion to how the surface of a lake ripples when you throw a pebble into it. When those ripples reach your ears, your eardrum moves sympathetically and converts those movements into the sound you hear. If we wish to record and play back the sound, we therefore need a way of capturing, storing and reproducing those ripples. One way is to use a microphone which acts like an eardrum and moves back and forth as the sound ripples hit it. The microphone then converts its position into a tiny electric signal which is then measured many times a second. These measurements are then represented as a series of numbers between -1 and 1.
it: Come sono registrati i campioni? È una cosa abbastanza semplice una volta capita la fisica del suono. Quando produci un suono, per esempio colpendo una batteria, il rumore viaggia attraverso l'aria in modo simile al comportamento delle increspature della superficie del lago quando lanci un sasso. Quando queste increspature raggiungono le tue orecchie, il timpano si muove per simpatia e converte questi movimento nel suono che tu ascolti. Se vogliamo registrare e riprodurre un suono, dobbiamo catturare, salvare e riprodurre quelle increspature. Possiamo usare un microfono che agisce come un timpano e si muove avanti e indietro quando il suono lo colpisce. Il microfono converte la sua posizione in un un segnale elettrico che viene misurato molte volte al secondo. Queste misurazioni sono poi rappresentate da una serie di valori compresi tra -1 e 1.

en: If we were to plot a visualisation of the sound it would be a simple graph of data with time on the x axis and microphone/speaker position as a value between -1 and 1 on the y axis. You can see an example of such a graph at the top of the diagram.
it: Se dovessimo rappresentare graficamente il suono, risulterebbe un grafico di dati con il tempo sull'asse x e la posizione del microfono/speaker come un valore tra -1 e 1 sull'asse y. Puoi vedere un esempio di questo grafico in cima al diagramma.

en: Playing Part of a Sample
it: Suonare una parte di un campione

en: So, how do we code Sonic Pi to play a sample back in a different order? To answer this question we need to take a look at the `start:` and `finish:` opts for `sample`. These let us control the start and finish positions of our playback of the numbers which represent the sound. The values for both of these opts are represented as a number between `0` and `1` where `0` represents the start of the sample and `1` is the end. So, to play the first half of the Amen Break, we just need to specify a `finish:` of `0.5`:
it: Quindi, come programmiamo Sonic Pi per suonare un campione in ordine differente? Per rispondere a questa domanda, dobbiamo dare un'occhiata ai parametri `start:` e `finish:` di `sample`. Questi valori ci permettono di controllare la posizione iniziale della riproduzione dei numeri che rappresentano i suoni. I valori di questi parametri possono essere rappresentati da numeri compresi tra `0` e `1` dove `0` rappresenta l'inizio del campione e `1` la fine. Per cui, per suonare la prima metà dell'Amen Break, è sufficiente specificare un valore di `finish:` pari a `0.5`:

en: We can add in a `start:` value to play an even smaller section of the sample:
it: Possiamo aggiungere un valore `start:` per suonare una porzione del campione:

en: For fun, you can even have the `finish:` opt's value be *before* `start:` and it will play the section backwards:
it: Per puro divertimento, puoi avere il parametro `finish:` che sia *prima* di `start:` e il campione suonerà al contrario:

en: Re-ordering Sample Playback
it: Riordinare la riproduzione del campione

en: Now that we know that a sample is simply a list of numbers that can be played back in any order and also how to play a specific part of a sample we can now start having fun playing a sample back in the 'wrong' order.
it: Ora che abbiamo capito che i campioni sono un semplice elenco di numeri che possono essere riprodotti in qualsiasi ordine e abbiamo capito come riprodurre una parte specifica; ora possiamo divertirci suonando un campione in un ordine 'sbagliato'.

en: Let's take our Amen Break and chop it up into 8 equally-sized slices and then shuffle the pieces around. Take a look at the diagram: at the top A) represents the graph of our original sample data. Chopping it into 8 slices gives us B) - notice that we've given each slice a different colour to help distinguish them. You can see each slice's start and finish values at the top. Finally C) is one possible re-ordering of the slices. We can then play this back to create a new beat. Take a look at the code to do this:
it: Prendiamo il nostro Amen Break e tagliamolo in 8 parti uguali e poi riordiniamo i vari pezzi. Dai un'occhiata all'immagine; all'inizio A) rappresenta il grafico dei nostri dati originali. Tagliarlo in 8 parti diventa B) - nota come abbiamo assegnato un colore differente a ciascun pezzo per aiutarci a distinguerli. Puoi vedere i valori di inizio e di fine di ciascun pezzo all'inizio. Infine C) è una possibilità di riordinare i pezzi. Poi possiamo suonarlo per creare un nuovo beat. Dai un'occhiata a questo codice:

en: we choose a random slice to play which should be a random number between 0 and 7 (remember that we start counting at 0). Sonic Pi has a handy function for exactly this: `rand_i(8)`. We then store this random slice index in the variable `slice_idx`.
it: Abbiamo scelto un pezzo in modo casuale prendendo un numero compreso tra 0 e 7 (ricordati che iniziamo a contare da 0). Sonic Pi ha una funzione che ci viene in aiuto: `rand_i(8)`. Dopodiché salviamo il valore di indice nella variabile `slice_idx`.

en: We define our `slice_size` which is 1/8 or 0.125. The `slice_size` is necessary for us to convert our `slice_idx` into a value between 0 and 1 so we can use it as our `start:` opt.
it: Definiamo la nostra `slice_size` che è 1/8 o 0.125. Il parametro `slice_size` è necessario per noi per convertire `slice_idx` in un valore compreso tra 0 e 1 per poterlo usare come parametro di `start:`.

en: We calculate the start position `s` by multiplying the `slice_idx` by the `slice_size`.
it: Calcoliamo la posizione iniziale `s` moltiplicando l'indice `slice_idx` per la dimensione `slice_size`.

en: We calculate the finish position `f` by adding the `slice_size` to the start position `s`.
it: Calcoliamo la posizione finale `f` aggiungendo la dimensione della sottosequenza `slice_size` alla posizione iniziale `s`.

en: We can now play the sample slice by plugging in the `s` and `f` values into the `start:` and `finish:` opts for `sample`.
it: Ora possiamo riprodurre i pezzi del campione agganciando i valori `s` e `f` dentro i parametri `start:` e `finish:` di `sample`.

en: Before we play the next slice we need to know how long to `sleep` which should be the duration of the sample slice. Luckily, Sonic Pi has us covered with `sample_duration` which accepts all the same opts as `sample` and simply returns the duration. Therefore, by passing `sample_duration` our `start:` and `finish:` opts, we can find out the duration of a single slice.
it: Prima di iniziare a suonare il pezzo successivo, dobbiamo sapere quanto lungo deve essere il valore di `sleep` che dovrebbe essere uguale alla durata del pezzo del campione. Per fortuna Sonic Pi ha la funzione `sample_duration` che accetta gli stessi parametri di `sample` e restituisce il valore della durata. Per cui, passando il valore `sample_duration` ai parametri `start:` e `finish:`, possiamo conoscere la durata di un singolo pezzo.

en: We wrap all of this code in a `live_loop` so that we continue to pick new random slices to play.
it: Inseriamo tutto questo codice in un `live_loop` per poter continuare a scegliere di suonare un pezzo casualmente.

en: Let's combine everything we've seen so far into a final example which demonstrates how we can take a similar approach to combine randomly sliced beats with some bass to create the start of an interesting track. Now it's your turn - take the code below as a starting point and see if you can take it in your own direction and create something new...
it: Combiniamo tutto quello che abbiamo visto fino ad ora in un ultimo esempio che rappresenti come usare un approccio simile per combinare pezzi di campione con una nuova linea di basso per creare l'inizio di una traccia. Ora è il tuo turno, prendi il codice qui sotto come punto di partenza e vedi se puoi trovare la tua strada per creare qualcosa di nuovo...

en: A.13 Code a Probabilistic Sequencer
it: A.13 Programma un Sequencer Probabilistico

en: Code a Probabilistic Sequencer
it: Programma un Sequencer Probabilistico

en: In a previous episode of this Sonic Pi series we explored the power of randomisation to introduce variety, surprise and change into our live coded tracks and performances. For example, we randomly picked notes from a scale to create never-ending melodies. Today we're going to learn a new technique which uses randomisation for rhythm - probabilistic beats!
it: In un precedente episodio della serie su Sonic Pi abbiamo scoperto il potere della randomizzazione, utile a introdurre varietà e sorpresa durante le nostre sessioni di live coding. Per esempio, abbiamo scelto a caso delle note da una scala per comporre melodie infinite. Oggi impareremo una nuova tecnica che usa la randomizzazione per i beat del ritmo!

en: Probability
it: Probabilità

en: Before we can start making new beats and synth rhythms we need to take a quick dive into the basics of probability. This might sound daunting and complicated, but really it's just as simple as rolling a dice - honestly! When you take a regular 6 sided board game dice and roll it what's actually happening? Well, firstly you'll roll either a 1, 2, 3, 4, 5 or 6 with exactly the same chance of getting any of the numbers. In fact, given that it's a 6 sided dice, on average (if you roll lots and lots of times) you'll throw a 1 every 6 throws. This means you have a 1 in 6 chance of throwing a 1. We can emulate dice rolls in Sonic Pi with the fn `dice`. Let's roll one 8 times:
it: Prima di cominciare a creare ritmi e synth, facciamo una breve panoramica su concetti base di probabilità. Detta così può sembrare complicato e spaventoso ma, in realtà, è tanto semplice quanto lanciare un dado. Quando lanci un normale dado a 6 facce in un gioco da tavolo cosa succede? Al primo tentativo i numeri 1, 2, 3, 4, 5 e 6 avranno tutti la stessa probabilità di uscire. Di fatto, essendo un dado a 6 facce, in media (se lo lanci molte volte) ti uscirà il numero 1 ogni 6 lanci. Questo significa avere una possibilità di 1 su 6 che esca 1. Possiamo simulare lo stesso comportamento in Sonic Pi utilizzando la funzione `dice`. Lanciamone uno 8 volte:

en: Notice how the log prints values between 1 and 6 just as if we'd rolled a real dice ourselves.
it: Nota come il log mostri valori tra 1 e 6 esattamente come se avessimo lanciato un vero dado.

en: Random Beats
it: Beat casuali

en: Now imagine you had a drum and every time you were about to hit it you rolled a dice. If you rolled a 1, you hit the drum and if you rolled any other number you didn't. You now have a probabilistic drum machine working with a probability of 1/6! Let's hear what that sounds like:
it: Ora, immagina di avere una batteria e che ogni volta che stai per colpirla decidi di lanciare un dado. Se esce 1, colpisci la batteria altrimenti no. Ora abbiamo una drum machine probabilistica che funziona con una probabilità di 1/6. Proviamo a sentire il risultato:

en: Let's quickly go over each line to make sure everything is very clear. First we create a new `live_loop` called `:random_beat` which will continually repeat the two lines between `do` and `end`. The first of these lines is a call to `sample` which will play a pre-recorded sound (the `:drum_snare_hard` sound in this case). However, this line has a special conditional `if` ending. This means that the line will only be executed if the statement on the right hand side of the `if` is `true`. The statement in this case is `dice == 1`. This calls our `dice` function which, as we have seen, returns a value between 1 and 6. We then use the equality operator `==` to check to see if this value is `1`. If it is `1`, then the statement resolves to `true` and our snare drum sounds, if it isn't `1` then the statement resolves to `false` and the snare is skipped. The second line simply waits for `0.125` seconds before rolling the dice again.
it: Guardiamo ogni riga di codice per essere sicuri che sia tutto chiaro. Per prima cosa creiamo un nuovo `live_loop` chiamato `:random_beat` che si ripeterà continuamente tra le righe `do` e `end`. La prima di queste righe è una chiamata a `sample` che riprodurrà un suono preregistrato (in questo caso il suono `:drum_snare_hard`). Tuttavia questa riga ha una condizione `if`alla fine. Questo significa che la linea verrà eseguita se la condizione che è scritta alla destra di `if` risulterà `true` (vero). In questo caso: `dice == 1`. Questa è una chiamata alla funzione `dice` che, come abbiamo visto, restituisce un valore tra 1 e 6. Usiamo l'operatore `==` per verificare se il valore è uguale a `1`. Se è così, la condizione restituisce `true` e viene riprodotto il suono di rullante, se il numero è diverso da `1` restituisce `false` e il rullante viene saltato. La seconda linea aspetta semplicemente che passino `0.125` secondi prima di lanciare nuovamente il dado.

en: Changing Probabilities
it: Cambiare le probabilità

en: Those of you that have played role play games will be familiar with lots of strangely shaped dice with different ranges. For example there is the tetrahedron shaped dice which has 4 sides and even a 20 sided dice in the shape of a icosahedron. The number of sides on the dice changes the chance, or probability of rolling a 1. The fewer sides, the more likely you are to roll a 1 and the more sides the less likely. For example, with a 4 sided dice, there's a one in 4 chance of rolling a 1 and with a 20 sided dice there's a one in 20 chance. Luckily, Sonic Pi has the handy `one_in` fn for describing exactly this. Let's play:
it: Quelli di voi che hanno fatto giochi di ruolo sanno che esistono dadi di diverse forme e con differenti numeri di facce. Per esempio esiste il dato a forma di tetraedro che ha solo 4 lati oppure l'icosaedro che, invece, ha 20 facce. Il numero di facce determina il cambiamento nella probabilità che esca 1. Minore è il numero di facce, più probabilità hai che esca 1. Per esempio in un dato a 4 facce, c'è 1 possibilità su 4 mentre in quello da 20 è 1 su 20. Per fortuna Sonic Pi ha la funzione `one_in` che descrive esattamente questo. Proviamo:

en: Start the live loop above and you'll hear the familiar random rhythm. However, don't stop the code running. Instead, change the `6` to a different value such as `2` or `20` and hit the `Run` button again. Notice that lower numbers mean the snare drum sounds more frequently and higher numbers mean the snare triggers fewer times. You're making music with probabilities!
it: Facendo partire il live loop qui sopra, sentirai un ritmo casuale familiare. Ora: non fermare la musa ma cambia il `6` con un valore diverso come `2` o `20` e premi nuovamente `Run`. Nota come più basso è il numero più frequentemente senti il suono di rullante mentre più è alto il numero minori sono le probabilità che venga suonato. Stai creando musica con le probabilità!

en: Combining Probabilities
it: Combinare le probabilità

en: Things get really exciting when you combine multiple samples being triggered with different probabilities. For example:
it: Le cose si fanno davvero interessanti quando diversi campioni vengono avviati con diverse probabilità. Per esempio:

en: Again, run the code above and then start changing the probabilities to modify the rhythm. Also, try changing the samples to create an entirely new feel. For example try changing `:drum_cymbal_closed` to `:bass_hit_c` for extra bass!
it: Prova a far partire il codice qui sopra cambiando ancora una volta le probabilità per modificare il ritmo. Puoi provare anche a cambiare il sample per cambiare completamente il sentimento. Modifica `:drum_cymbal_closed` in `:bass_hit_c` per avere del basso extra!

en: Repeatable Rhythms
it: Ritmi ripetibili

en: Next, we can use our old friend `use_random_seed` to reset the random stream after 8 iterations to create a regular beat. Type the following code to hear a much more regular and repeating rhythm. Once you hear the beat, try changing the seed value from `1000` to another number. Notice how different numbers generate different beats.
it: Infine, possiamo usare il caro vecchio `use_random_seed` per resettare il flusso casuale dopo 8 iterazioni per creare un beat regolare. Scrivi il seguente codice per sentire un ritmo più regolare e ripetitivo. Una volta ascoltato, prova a cambiare il valore di seed da `1000` a un altro numero. Nota come numeri differenti generato beat diversi.

en: One thing I tend to do with this kind of structure is to remember which seeds sound good and make a note of them. That way I can easily re-create my rhythms in future practice sessions or performances.
it: Solitamente, con questo tipo struttura bisogna ricordarsi quali semi suonano bene e prenderne nota. In questo modo, posso facilmente riproporre dei ritmi che ho già creato in concerti futuri.

en: Finally, we can throw in some random bass to give it some nice melodic content. Notice that we can also use our newly discovered probabilistic sequencing method on synths just as well as samples. Don't leave it at that though - tweak the numbers and make your own track with the power of probabilities!
it: Infine possiamo aggiungere un suono di basso casuale per dare un po' di contenuto melodico. Ricorda che possiamo usare il sistema di sequenze probabilistiche che abbiamo appena scoperto non solo per i sample ma anche per i sintetizzatori. Non lasciarlo così com'è, cambia i numeri e crea la tua traccia con la potenza delle probabilità!

en: A.14 Amplitude Modulation
it: A.14 Modulazione d'ampiezza

en: Amplitude Modulation
it: Modulazione d'ampiezza

en: This month we're going to take a deep dive into one of Sonic Pi's most powerful and flexible audio FX - the `:slicer`. By the end of this article you will have learned how to manipulate the overall volume of parts of our live coded sound in powerful new ways. This will allow you to create new rhythmic and timbral structures and broaden your sonic possibilities.
it: Questo mese scopriremo tutti i segreti di uno degli effetti più potenti e flessibili di Sonic Pi: lo `:slicer`. Alla fine di questo articolo avrete imparato come manipolare il volume generale di alcune parti dei suoni programmati dal vivo. Questo vi permetterà di creare nuove strutture ritmiche e timbriche e di allargare le possibilità sonore.

en: Slice that Amp
it: Affetta quell'amp

en: So, what does the `:slicer` FX actually do? One way to think about it is that it's just like having someone play around with the volume control on your TV or home hi-fi. Let's take a look but first, listen to the deep growl of the following code which triggers the `:prophet` synth:
it: Cosa fa esattamente l'effetto `:slicer`? Possiamo pensarlo come qualcuno che gioca con il controllo del volume della vostra TV o impianto hi-fi. Prima di approfondire il discorso, ascoltate il suono profondo del synth `:prophet` generato con questo codice:

en: Now, let's pipe it through the `:slicer` FX:
it: Ora inseriamo l'effetto `:slicer`:

en: Hear how the slicer acts like it's muting and unmuting the audio with a regular beat. Also, notice how the `:slicer` affects all the audio generated between the `do`/`end` blocks. You can control the speed at which it turns the audio on and off with the `phase:` opt which is short for phase duration. Its default value is `0.25` which means 4 times a second at the default BPM of 60. Let's make it faster:
it: Visto come lo slicer agisce? Sembra che silenzi e poi riattivi l'audio con un ritmo regolare. Sembra anche che ':slicer' abbia effetto sul suono generato dal codice scritto tra i blocchi 'do' e 'end'. Puoi controllare la velocità a cui il suono viene spento e riacceso con lopzione 'phase:' che è l'abbreviazione di durata di fase in inglese (phase duration). Il valore predefinito è '0.25', il che significa che lo status cambia 4 volte al secondo quando i BPM sono a 60. Proviamo a mandarlo più veloce:

en: Now, play with different `phase:` durations yourself. Try longer and shorter values. See what happens when you choose a really short value. Also, try different synths such as `:beep` or `:dsaw` and different notes. Take a look at the following diagram to see how different `phase:` values change the number of amplitude changes per beat.
it: Ora, prova a suonare con differenti valori di ':phase'. Prova valori più lunghi o più brevi. Guarda cosa accade quando scegli valori molto brevi. Poi, prova anche a cambiare synth, tipo ':beep' oppure ':dsaw' e anche note differenti. Osserva il diagramma seguente per capire come valori di ':phase' diversi cambino il numero di cambiamenti di ampiezza per ogni battito.

en: Phase duration is the length of time for one on/off cycle. Therefore smaller values will make the FX switch on and off much faster than larger values. Good values to start playing with are `0.125`, `0.25`, `0.5` and `1`.
it: La durata di una fase corrisponde alla durata del tempo per un ciclo on/off. Pertanto valori più piccoli porteranno ad un passaggio molto più veloce da on a off rispetto a valori più grandi. Dei buoni valori di partenza sono `0.125`, `0.25`, `0.5` e `1`.

en: Control Waves
it: Onde di controllo

en: By default, the `:slicer` FX uses a square wave to manipulate the amplitude through time. This is why we hear the amplitude on for a period, then immediately off for a period, then back on again. It turns out that the square wave is just one of 4 different control waves that are supported by `:slicer`. The others are saw, triangle and (co)sine. Take a look at the diagram below to see what these look like. We can also hear what they sound like. For example, the following code uses (co)sine as the control wave. Hear how the sound doesn't turn on and off abruptly but instead smoothly fades in and out:
it: Di base, l'effetto ':slicer' usa un'onda quadra per cambiare l'ampiezza d'onda nel tempo. Questo è il motivo per cui sentiamo il suono per un periodo e successivamente questo scompare per poi ricomparire e così via. Però l'effetto ':slicer' può usare 4 diverse forme d'onda per modificare il suono, che sono la dente di sega, la triangolare e la cosinusoidale. Dai un'occhiata al diagramma sotto per capire la loro forma. Possiamo anche ascoltare il loro effetto. Per esempio, se digiti il codice seguente userai l'onda cosinusoidale come onda di controllo. Infatti, in questo caso il suono non si spegne e accende a scatti, ma in maniera progressiva e senza brusche interruzioni:

en: Have a play with the different wave forms by changing the `wave:` opt to `0` for saw, `1` for square, `2` for triangle and `3` for sine. See how different waves sound with different `phase:` opts too.
it: Suona provando a cambiare le forme d'onda attraverso l'opzione 'wave:': '0' sta per dente di sega, '1' per onda quadra, '2' per triangolare e '3' per sinusoidale. Prova anche a variare la fase attraverso 'phase:' a ogni forma d'onda per sentire come cambia il suono.

en: Each of these waves can be inverted with the `invert_wave:` opt which flips it on the y axis. For example, in a single phase the saw wave typically starts high, and slowly goes down before jumping back to the top. With `invert_wave: 1` it will start low and slowly go up before jumping back down again. Additionally, the control wave can be started at different points with the `phase_offset:` opt which should be a value between `0` and `1`. By playing around with `phase:`, `wave:`, `invert_wave:` and `phase_offset` opts you can dramatically change how the amplitude is modified through time.
it: Ognuna di queste onde può essere invertita utilizzando l'opzione 'invert_wave:' che la ribalta sull'asse y. Per esempio, durante un ciclo normale l'onda a dente di sega parte dall'alto e si dirige lentamente verso il basso raggiungendo il punto in cui immediatamente ritorna al valore massimo. Invertendo la forma d'onda con 'invert_wave:1', l'onda partirà dal valore minimo ed andrà lentamente verso il valore massimo fino a quando ricadrà improvvisamente al valore minimo. Un'altra opzione è 'phase_offset:' per mezzo del quale possiamo far iniziare l'onda da un punto qualsiasi. Il valore inserito deve essere tra '0' e '1'. Quindi, giocando con i valori di 'phase:', wave:', 'invert_wave:' e 'phase_offset:' puoi cambiare, e di molto, il comportamento dell'ampiezza dell'onda nel tempo.

en: Setting your levels
it: Imposta i tuoi livelli

en: By default, `:slicer` switches between amplitude values `1` (fully loud) and `0` (silent). This can be changed with the `amp_min:` and `amp_max:` opts. You can use this alongside the sine wave setting to create a simple tremolo effect:
it: Di base, ':slicer' passa dai valore '1' (volume massimo) e '0' (silenzioso). Questi valori possono essere cambiati per mezzo delle opzione 'amp_min' e 'amp_max'. Puoi cambiare questi valori accoppiandoli con un'onda sinusoidale per creare un effetto tremolo:

en: This is just like grabbing the volume knob on your hi-fi and moving it up and down just a little so the sound 'wobbles' in and out.
it: Succederebbe praticamente la stessa cosa se prendessi il controllo del volume del tuo impianto stereo e lo muovessi in su e giù facendo ondeggiare il suono.

en: Probabilities
it: Probabilità

en: One of `:slicer`'s powerful features is its ability to use probability to choose whether or not to turn the slicer on or off. Before the `:slicer` FX starts a new phase it rolls a dice and based on the result either uses the selected control wave or keeps the amplitude off. Let's take a listen:
it: Una delle caratteristiche più divertenti di ':slicer' è la possibilità di usare la probabilità per decidere se accendere o spegnere lo slicer. Con questa possibilità, il sistema lancia un dado prima di ogni fase e agisce seguendo il valore che viene fuori. Prova a digitare e eseguire quanto segue:

en: Hear how we now have an interesting rhythm of pulses. Try changing the `probability:` opt to a different value between `0` and `1`. Values closer to `0` will have more space between each sound due to the likelihood of the sound being triggered being much lower.
it: Abbiamo ottenuto un interessante ritmo di impulsi. Prova a cambiare l'opzione 'probability:' (probabilità) con un valore tra '0' e '1'. Più ti avvicini allo '0', più i suoni saranno spaziati tra loro perché la probabilità di accensione dell'effetto risulta più bassa.

en: Another thing to notice is that the probability system in the FX is just like the randomisation system accessible via fns such as `rand` and `shuffle`. They are both completely deterministic. This means that each time you hit Run you'll hear exactly the same rhythm of pulses for a given probability. If you would like to change things around you can use the `seed:` opt to select a different starting seed. This works exactly the same as `use_random_seed` but only affects that particular FX.
it: Il sistema delle probabilità usato negli effetti è lo stesso utilizzato per la randomizzazione in funzioni come 'rand' e 'shuffle'. Sono entrambi completamente deterministici. Ciò significa che tutte le volte che premi Run, sentirai sempre la stessa sequenza per una data probabilità. Se volessi cambiare la sequenza ottenuta puoi usare l'opzione 'seed:' cambiando il seme di riferimento. Funziona esattamente come 'use_random_seed', soltanto in questo caso si agisce su quel particolare effetto e basta.

en: Finally, you can change the 'resting' position of the control wave when the probability test fails from `0` to any other position with the `prob_pos:` opt:
it: Infine, con l'opzione 'prob_pos:' puoi cambiare la posizione di riposo dell'onda di controllo quando il test di probabilità fallisce tra il valore '0' e un altro qualsiasi punto:

en: Slicing Beats
it: Affettare i beat

en: One really fun thing to do is to use `:slicer` to chop a drum beat in and out:
it: Una cosa davvero molto divertente è usare ':slicer' per affettare un beat di batteria:

en: Changing tempo
it: Cambiamenti di tempo

en: As we have already seen, changing the default BPM with `use_bpm` will make all the sleep times and synth envelope durations grow or shrink to match the beat. The `:slicer` FX honours this too, as the `phase:` opt is actually measured in beats not seconds. We can therefore fix the issue with `loop_amen` above by changing the BPM to match the sample:
it: Come abbiamo già visto, cambiare i BPM preimpostati con 'use_bpm' farà anche cambiare i tempi di 'sleep' e gli le durate degli inviluppi coerentemente al nuovo valore. L'effetto ':slicer' si comporta nello stesso modo e l'opzione 'phase:' è in realtà misurata in battiti e non in secondi. Quindi possiamo risolvere il problema di 'loop_amen' appena visto cambiando i BPM e farli coincidere con quelli del campione:

en: Let's apply all these ideas into a final example that only uses the `:slicer` FX to create an interesting combination. Go ahead, start changing it and make it into your own piece!
it: Quindi, applichiamo le idee esposte sopra nell'esempio finale che utilizza soltanto l'effetto ':slicer' per creare una combinazione interessante. Vai avanti, cambia quanto scritto e componi il tuo brano personale!

en: A.15 Five Live Coding Techniques
it: A.15 Cinque tecniche di live coding

en: Five Live Coding Techniques
it: Cinque tecniche di live coding

en: In this month's Sonic Pi tutorial we're going to take a look at how you can start treating Sonic Pi like a real instrument. We therefore need to start thinking of code in a completely different way. Live coders think of code in a similar way to how violinists think of their bow. In fact, just like a violinist can apply various bowing techniques to create different sounds (long slow motions vs short fast hits) we will explore five of the basic live coding techniques that Sonic Pi enables. By the end of this article you'll be able to start practicing for your own live coded performances.
it: Nella guida di questo mese ti spiegheremo che Sonic Pi può essere utilizzato come un vero strumento musicale. Quindi dobbiamo cominciare a pensare al codice in un modo completamente diverso. I live coder pensano al codice più o meno nello stesso modo in cui un violinista pensa al suo archetto. Infatti, come il violinista può usare diverse tecniche esecutive per creare suoni diversi (movimento lento e colpetti veloci per esempio), noi esploreremo qui 5 regole di base del live coding che si possono eseguire su Sonic Pi. Alla fine di questo articolo, tu sarai capace di eseguire la tua musica per mezzo del live coding.

en: 1. Memorise the Shortcuts
it: 1. Memorizza i tasti di scelta rapida

en: The first tip to live coding with Sonic Pi is to start using the shortcuts. For example, instead of wasting valuable time reaching for the mouse, moving it over to the Run button and clicking, you can simply press `alt` and `r` at the same time which is much faster and keeps your fingers at the keyboard ready for the next edit. You can find out the shortcuts for the main buttons at the top by hovering the mouse over them. See section 10.2 of the built-in tutorial for the full list of shortcuts.
it: Uno dei primi consigli da seguire a proposito del live coding, è quello di cominciare ad usare le combinazioni di tasti (shortcut). Ad esempio, invece di perdere tempo cercando il mouse, muoverlo sul bottone Run e cliccarlo, puoi semplicemente premere `alt` e `r` contemporaneamente. Oltre ad essere molto più veloce, le tue dita saranno già sulla tastiera pronte a digitare il prossimo comando. Puoi vedere ognuna delle combinazioni per le funzioni principali andando con il cursore del mouse sopra il pulsante relativo alla funzione stessa. Oppure, al paragrafo 10.2 del tutorial puoi trovare l'intera lista.

en: When performing, one fun thing to do is to add a bit of flair with your arm motion when hitting shortcuts. For example, it's often good to communicate to the audience when you're about to make a change - so embellish your movement when hitting `alt-r` just like a guitarist would do when hitting a big power chord.
it: Mentre stai suonando, una cosa divertente da fare è dare un po' di enfasi al movimento delle braccia quando effettui una combinazione di tasti. Ad esempio, è sempre buona cosa comunicare agli spettatori quando stai per introdurre un cambiamento, quindi amplifica il gesto quando digiti `alt-r`, al pari di un chitarrista che dà una potente pennata.

en: 2. Manually Layer your Sounds
it: 2. Stratifica manualmente i tuoi suoni

en: Now you can trigger code instantly with the keyboard, you can instantly apply this skill for our second technique which is to layer your sounds manually. Instead of 'composing' using lots of calls to `play`, and `sample` separated by calls to `sleep` we will have one call to `play` which we will manually trigger using `alt-r`. Let's try it. Type the following code into a fresh buffer:
it: Ora puoi far partire codice istantaneamente con la tastiera, puoi usare subito questa abilità per la nostra seconda tecnica che consiste nello stratificare suoni in modo manuale. Invece di 'comporre' usando molte chiamate a `play` e `sample` separate da `sleep` avremo un'unica chiamata a `play` che avvieremo automaticamente usando `alt-r`. Proviamo! Inserisci questo codice in un buffer vuoto:

en: Now, hit `Run` and whilst the sound is playing, modify the code in order to drop down four notes by changing it to the following:
it: Ora, premi `Avvia` e, mentre il suono viene riprodotto, modifica il codice in modo da eliminare quattro note cambiando il seguente codice:

en: Now, hit `Run` again, to hear both sounds playing at the same time. This is because Sonic Pi's `Run` button doesn't wait for any previous code to finish, but instead starts the code running at the same time. This means you can easily layer lots of sounds manually with minor or major modifications between each trigger. For example, try changing both the `note:` and the `cutoff:` opts and then re-trigger.
it: Ora, premi `Avvia` di nuovo per sentire entrambi i suoni nello stesso momento. Questo perché il pulsante `Avvia` di Sonic Pi non aspetta di finire di eseguire il codice già avviato ma, invece, fa partire il codice già avviato nello stesso momento. Questo vuol dire che puoi stratificare molti suoni semplicemente e manualmente con piccole modifiche tra un avvio e l'altro. Per esempio, prova a cambiare `note:` e `cutoff:` e a rilanciare il codice.

en: You can also try this technique with long abstract samples. For example:
it: Puoi usare questa tecnica con campioni lunghi. Per esempio:

en: Try starting the sample off, and then progressively halving the `rate:` opt between hitting `Run` from `1` to `0.5` to `0.25` to `0.125` and then even try some negative values such as `-0.5`. Layer the sounds together and see where you can take it. Finally, try adding some FX.
it: Prova facendo partire il campione e, poi, abbassa progressivamente il valore di `rate:` da `1` a `0.5` a `0.25` fino a `0.125` premendo continuamente `Avvia`. Prova anche con valori negativi come `-0.5`. Stratifica i suoni e vedi dove puoi arrivare. Prova anche ad aggiungere degli effetti.

en: When performing, working with simple lines of code in this way means that an audience new to Sonic Pi has a good chance to follow what you're doing and relate the code that they can read to the sounds they are hearing.
it: Quando ti esibisci, lavorare con linee di codice molto semplice può aiutare il pubblico che non ha mai visto Sonic Pi a seguire quello che stai facendo riuscendo a collegare quanto stati scrivendo con quello che sentono.

en: 3. Master Live Loops
it: 3. Controllare i live loop

en: When working with more rhythmic music, it can often be hard to manually trigger everything and keep good time. Instead, it is often better to use a `live_loop`. This provides repetition for your code whilst also giving the ability to edit the code for the next time round the loop. They also will run at the same time as other `live_loop`s which means you can layer them together both with each other and manual code triggers. Take a look at section 9.2 of the built-in tutorial for more information about working with live loops.
it: Quando si lavora con della musica più ritmata, può risultare spesso difficile sincronizzare tutto e mantenere un buon tempo. In questi casi è preferibile utilizzare un 'live_loop'. Oltre a garantire la ripetizione al tuo codice, ti dà la possibilità di modificarlo, aggiornandolo per la prossima iterazione. Inoltre, allo stesso tempo altri `live_loop` possono essere eseguiti, il che significa che è possibile sovrapporli fra loro, o a istruzioni manuali. Dai un'occhiata alla sezione 9.2 del tutorial per ulteriori informazioni sull'utilizzo dei live loop.

en: When performing, remember to make use of `live_loop`'s `sync:` opt to allow you to recover from accidental runtime mistakes which stop the live loop running due to an error. If you already have the `sync:` opt pointing to another valid `live_loop`, then you can quickly fix the error and re-run the code to re-start things without missing a beat.
it: Quando esegui un'esecuzione dal vivo, ricordarti di utilizzare nel `live_loop` l'opzione `sync:` in modo da rimediare ad eventuali errori di runtime che possono interrompere l'esecuzione in loop del tuo brano. Se hai già introdotto un `sync:` che punta a un altro valido `live_loop`, allora si può rapidamente correggere l'errore, eseguendo nuovamente il codice e ripartire senza perdere il tempo.

en: After you run this code, all existing and new sounds will have a low pass filter applied to them and will therefore sound more muffled. Note that this means that the new mixer values stick until they are changed again. However, if you want, you can always reset the mixer back to its default state with `reset_mixer!`. Some of the currently supported opts are: `pre_amp:`, `lpf:` `hpf:`, and `amp:`. For the full list, see the built-in docs for `set_mixer_control!`.
it: Dopo l'esecuzione di questo codice, verrà attivato un filtro passa basso, ottenendo un suono finale più "ovattato". Nota bene che i nuovi parametri del mixer principale verranno mantenuti finché non deciderai di modificarli nuovamente. Tuttavia, è possibile reimpostare in qualsiasi momento il mixer al suo stato predefinito con la funzione `reset_mixer!`. Alcune delle opzioni attualmente supportate sono: `pre_amp:`, `lpf:` `hpf:`, e `amp:`. Per l'elenco completo, dai un'occhiata alla documentazione relativa a `set_mixer_control!`.

en: Use the mixer's `*_slide` opts to slide one or many opts values over time. For example, to slowly slide the mixer's low pass filter down from the current value to 30, use the following:
it: Utilizza l'opzione ' * _slide' del mixer per far scorrere uno o molti valori delle opzioni nel tempo. Ad esempio, per far scorrere lentamente i valori del filtro passa-basso del mixer dal valore corrente a 30, prova a digitare il codice seguente:

en: You can then slide quickly back to a high value with:
it: Puoi scorrere velocemente a un valore più alto così:

en: When performing, it's often useful to keep a buffer free for working with the mixer like this.
it: Quanto ti esibisci può tornare utile tenere un buffer disponibile per lavorare con il mixer in questo modo.

en: 5. Practice
it: 5. Pratica

en: The most important technique for live coding is practice. The most common attribute across professional musicians of all kinds is that they practice playing with their instruments - often for many hours a day. Practice is just as important for a live coder as a guitarist. Practice allows your fingers to memorise certain patterns and common edits so you can type and work with them more fluently. Practice also gives you opportunities to explore new sounds and code constructs.
it: La tecnica più importante di live coding è fare pratica. La qualità più comune tra i musicisti professionisti di qualsiasi tipo è che fanno pratica con il loro strumento spesso per molte ore al giorno. Esercitarsi è importante per un live coder tanto quanto per un chitarrista. Fare esercizio permette alle tue dita di memorizzare alcuni pattern e modifiche comuni per cui puoi digitare e lavorare in modo più fluido. L'esercizio ti dà anche l'opportunità di esplorare nuovi suoni e codici.

en: When performing, you'll find the more practice you do, the easier it will be for you to relax into the gig. Practice will also give you a wealth of experience to draw from. This can help you understand which kinds of modifications will be interesting and also work well with the current sounds.
it: Quando ti esibisci, scoprirai che più esercizio fai, più sarà semplice rilassarsi durante il concerto. La pratica ti permetterà di avere un catalogo di esperienze da cui prendere spunto. Questo ti permette di capire che tipo di modifiche saranno interessanti e quali funzioneranno bene con i suoni che stai utilizzando in quel momento.

en: A.16 How to Practice Live Coding
it: A.16 Come far pratica di live coding

en: 8 Tips for Live Coding Practice
it: 8 consigli per la pratica di live coding

en: Last month we took a look at five important techniques for mastering live coding - in other words, we explored how we could use Sonic Pi to approach code in the same way we would approach a musical instrument. One of the important concepts that we discussed was practice. This month we're going to take a deeper dive into understanding why live coding practice is important and how you might start.
it: Il mese scorso abbiamo dato un'occhiata alle cinque tecniche più importanti per impadronirsi e impratichirsi nel live coding. In altre parole, abbiamo visto come usare Pi Sonic per approcciarsi alla programmazione musicale nello stesso modo in cui ci approcceremmo a uno strumento musicale. Uno dei concetti importanti che abbiamo trattato è stato quello della pratica. Questo mese ci occuperemo invece di capire perché la pratica continua di live coding è importante e come dovresti cominciare.

en: Practice regularly
it: Fai esercizio regolarmente

en: The most important piece of advice is to make sure you practice regularly. As a rule I typically practice for 1-2 hours a day, but 20 mins is just fine when you're starting out. Little but often is what you're aiming for - so if you can only manage 10 minutes, that's a great start.
it: Il consiglio più importante è quello di assicurarti di fare pratica regolarmente. Come regola, posso dirti che io in genere mi esercito per 1-2 ore al giorno, ma anche 20 minuti per iniziare possono andare bene. "Poco ma spesso" è l'obbiettivo al quale puntare - quindi se hai a disposizione solo 10 minuti, è comunque un ottimo inizio.

en: Practice tip #1 - start to develop a practice routine. Find a nice time in the day that works for you and try and practice at that time as many days of the week as you can. Before long you'll be looking forward to your regular session.
it: Consiglio pratico n.1 - inizia a sviluppare la routine di fare pratica. Trovati un momento piacevole e rilassante del giorno e fai pratica ogni volta che puoi. In poco tempo, non vedrai l'ora di arrivare alla tua sessione di pratica.

en: Learn to Touch Type
it: Impara a digitare senza guardare la tastiera

en: If you watch a professional musician performing on stage you'll likely notice a few things. Firstly, when they play they don't stare at their instrument. Their fingers, arms and bodies know which keys to press, strings to pluck or drums to hit without them having to think about it too much. This is known as "muscle memory" and although it might sound like something only professionals can do - it's just the same as when you first learned to walk or ride a bike - practicing through repetition. Live coders use muscle memory to free their minds from having to think about where to move their fingers so they can focus on the music. This is called touch-typing - typing without having to look at the keyboard.
it: Se osservi un musicista professionista mentre suona sul palco noterai sicuramente alcuni aspetti. In primo luogo, quando suona non guarda il proprio strumento. Le sue dita, braccia e il corpo in generale conoscono le azioni da compiere senza bisogno di pensarci su troppo tempo. Questa abilità è chiamata "memoria muscolare" e anche se potrebbe sembrare qualcosa che solo i professionisti riescono a fare, in realtà questo processo funziona semplicemente come quando hai imparato per la prima volta a camminare o andare in bicicletta: hai fatto pratica attraverso la ripetizione. I e le live coder utilizzano la memoria muscolare per liberare le loro menti dal pensiero della gestione del movimento delle loro dita, in modo che possano concentrarsi sulla musica. Questa abilità è chiamata touch-type in inglese, e corrisponde all'abilità di digitare sulla tastiera senza il bisogno di guardarla.

en: Practice tip #2 - learn how to touch type. There are many apps, websites and even games which can help you achieve this. Find one you like the look of and stick at it until you can code without looking down.
it: Consiglio pratico n.2 - imparare a dattilografare. Ci sono molte applicazioni, siti web e anche i giochi che ti possono aiutare a raggiungere questo obiettivo. Trova quello che ti piace di più e rimanici incollato/a finché non riuscirai a programmare senza guardare la tastiera.

en: Code whilst standing
it: Programma stando in piedi

en: The body of a musician is conditioned for playing their instrument. For example, a trumpet player needs to be able to blow hard, a guitar player needs to be able to grip the fretboard with strength and a drummer needs to be able to continually hit the drums for long periods of time. So, what's physical about live coding? Just like DJs, live coders typically perform whilst standing up and some even dance whilst they code! If you practice live coding whilst sitting at a desk and then have to get up and stand at a gig, you'll likely find the difference very difficult and frustrating.
it: Il corpo di un musicista si adatta alla pratica del proprio strumento. Ad esempio, un suonatore di tromba deve essere in grado di soffiare forte, un chitarrista ha bisogno di essere in grado di afferrare il manico con forza e un batterista deve essere in grado di suonare continuamente la batteria per lunghi periodi di tempo. Quindi, qual'è l'aspetto fisico nel live coding? Proprio come i e le DJ, i e le live coder in genere suonano stando in piedi e alcuni/e riescono anche a ballare mentre suonano! Se si fa pratica di live coding seduti a una scrivania, dopo sarà difficile adattarsi a suonare in piedi ad un concerto. Probabilmente troverai le due situazioni molto diverse tra loro e non sarà facile passare dall'una all'altra.

en: Practice tip #3 - stand whilst you practice. The easiest way to do this is to use a standing height desk. However, if like me you don't have one at home, there's a couple of low-fi options. The approach I take is to use an ironing board which happens to work rather well. Another is to stack some boxes or large books on a normal desk and place your keyboard on top of that. Also, make sure you stretch before you start practicing and try and dance a little during the session. Remember, nobody is watching you, so have fun and you'll feel much more natural on stage.
it: Consiglio pratico n.3 - stai in piedi mentre fai pratica. Il modo più semplice per farlo consiste nell'utilizzare una scrivania che tenga la tastiera all'altezza giusta di quando stai in piedi. Tuttavia, se come me non hai una a casa, ti posso dare un paio di consigli semplici ma efficaci. Il primo è quello di utilizzare un asse da stiro, che sembra funzionare piuttosto bene. Un altro è quello di impilare alcune scatole o libri di grandi dimensioni su una normale scrivania e posizionare la tastiera in cima alla torre. Inoltre, ti consiglio di fare un po' di allungamenti prima di iniziare a suonare e prova anche a muoverti a ritmo durante la sessione. Ricordati, nessuno ti sta guardando, quindi divertiti e comportati naturalmente. Questo ti aiuterà anche quando sarai sul palco.

en: Practice setting up
it: Esercitati sul set up

en: Most instruments require some assembly and tuning before they can be played. Unless you're a rockstar with a bus full of roadies, you'll have to set up your own instrument before your gig. This is often a stressful time and it is easy for problems to occur. One way to help with this is to incorporate the setup process into your practice sessions.
it: Molti strumenti musicali richiedono di essere assemblati e accordati prima di essere suonati. Almeno che non tu sia già una rockstar, con un autobus pieno di assistenti, dovrai preparare tutto da solo/a prima del tuo concerto. Di solito, questo è un momento piuttosto stressante ed è facile che emergano problemi. Una soluzione che può aiutarti è quella di incorporare nella pratica quotidiana anche la preparazione della strumentazione.

en: Practice tip #4 - treat setting up as an important part of your practice. For example, have a box or bag that you can keep your Raspberry Pi and keyboard in etc. Before each practice session, take out all the parts, connect everything, and work through the boot process until you have Sonic Pi running and can make sounds. Once you've finished practicing, take the time to carefully pack everything away afterwards. This may take some time at first, but before long you'll be able to setup and pack everything away incredibly quickly without having to think about it.
it: Consiglio pratico n.4. Inserisci il set-up nella tua routine di pratica quotidiana. Per esempio, procurati una scatola o una borsa in cui tenere il tuo Raspberry Pi, la tastiera ecc. Prima di ogni sessione di pratica, tira fuori tutte le parti, connettile e avvia il tutto fino a che non otterrai la schermata iniziale di Sonic Pi. Poi, quando avrai finito la tua sessione di pratica, lasciati il tempo di mettere tutto a posto con cura. All'inizio questa operazione potrebbe portarti via un po' di tempo, ma poi diventerai pratico/a anche in questo e tutto sarà molto più facile e veloce. Non ci dovrai nemmeno pensare mentre lo fai.

en: Experiment Musically
it: Sperimenta musicalmente

en: Once you've set up and are ready to start making music, you might find yourself struggling to know where to start. One problem many people face is that they might have a good idea of the kinds of sounds they want to make, but are frustrated that they can't produce them. Some people don't even know what kind of sounds they want to make! The first thing to do is not to worry - this is very common and happens to every musician - even if they've been practicing for a long time. It is much more important to be making sounds you don't like than not making any sounds at all.
it: Quando avrai sistemato tutto e sarai pronto/a per iniziare a suonare, potresti ritrovarti spaesato/a e non sapere dove cominciare. Molte persone hanno questo problema: trovare  una buona idea da cui cominciare oppure avere una buona idea ma non sapere come realizzarla. Alcune persone addirittura non hanno proprio idea di che suoni vogliono fare! La prima cosa da fare è non preoccuparsi. Infatti è una situazione molto comune e succede ad ogni musicista, anche se hanno una lunga esperienza. E' comunque molto meglio fare un suono che non ti piace piuttosto che non farne nessuno.

en: Practice tip #5 - spend time making sounds and music you don't like. Try to make time to explore new sounds and ideas. Don't worry that it might sound terrible if it's not the style you're looking for. When you're experimenting like this you increase the chance of stumbling over a sound or combination of sounds which you love! Even if 99% of the sounds you make are bad, that 1% might be the riff or intro to your new track. Forget the things you don't like and remember the parts you do. This is even easier when you're making music with code - just hit save!
it: Consiglio pratico n. 5. Passa del tempo a fare suoni e musica che non ti piacciono. Prenditi il tempo di esplorare nuove idee e nuovi suoni. Non ti preoccupare se ti sembrano orribili o se non sono nello stile che volevi ottenere. Quando sperimenti in questo modo incrementi le possibilità di imbatterti in suoni o combinazioni di essi che potresti amare! Anche se il 99% dei suoni che fai sono brutti, quell'1% potrebbe contenere un riff da inserire nel tuo nuovo brano. Dimenticati delle cose che non ti piacciono e ricordati di quelle che ti piacciono. Far ciò è anche più facile quando suoni con il codice. Infatti, puoi semplicemente premere salva!

en: Hear the Code
it: Ascolta il codice

en: Practice tip #6 - write some code into Sonic Pi but don't hit the Run button. Instead, try to imagine what sound it is going to produce. Then, hit Run, listen, and think about what you got right and what you didn't. Keep repeating this until it become a natural part of your coding process. When I practice I normally have a good idea of what the code will sound like. However, I still am occasionally surprised, and then I'll stop and spend some time thinking about why I was wrong. Each time this happens, I learn new tricks which allow me to express myself in new ways.
it: Consiglio pratico n. 6. Scrivi codice dentro Sonic Pi ma non premere Run. Prova invece ad immaginarti che suono potrebbe produrre quel codice. Solo dopo premi Run, ascolta e prova a pensare a cosa hai fatto di giusto e di sbagliato. Continua a fare questo passaggio finché non diventa un'azione naturale della tua attività di programmazione. Quando io mi esercito, di solito ho un'idea piuttosto precisa di come quel pezzo di codice suonerà. Tuttavia, riesco ancora a volte a sorprendermi. In questi casi fermo il processo e cerco di capire perché ho pensato una cosa e n'è successa un'altra. Tutte le volte che succede questo, riesco a imparare nuovi trucchi che mi permettono di esprimermi in modi nuovi.

en: Remove all distractions
it: Rimuovi tutte le distrazioni

en: A common problem when practicing is to become distracted with other things. Practicing is hard and requires real discipline regardless of the kind of music you're making - from jazz to classical to EDM. If you're struggling to get started or make progress, it's often too easy to hop on social media, or look something up on the internet etc. If you've set yourself a target of 20 minutes of practice, it's important to try and spend all that time being as productive as possible.
it: Un problema comune quando fai pratica è quello di essere distratti da altre cose. Far pratica è un'attività difficile e richiede una grande dose di disciplina, qualsiasi sia il tipo di musica che fai: jazz, classica o EDM. Se ti stai fortemente impegnando a iniziare oppure a migliorare le tue abilità, è spesso anche troppo facile andare sui social o cercare cose su internet. Se decidi di fare 20 minuti di pratica, è importante che questi 20 minuti siano dedicati totalmente a quell'attività e che siano il più produttivi possibile.

en: Practice tip #7 - before you start practicing remove as many distractions as possible. For example, disconnect from the internet, put your phone in another room and try to practice in a quiet place where you're unlikely to be disturbed. Try to focus on coding music and you can return to your distractions when you've finished.
it: Consiglio pratico n.7. Prima di iniziare a fare pratica, cerca di eliminare quanti più elementi di distrazione possibile. Per esempio, disconnetti da internet, metti il telefono in un'altra stanza e cerca un posto per fare pratica in cui difficilmente verrai disturbato. Cerca di focalizzarti sulla tua attività di live coding e poi successivamente potrai tornare alle tue distrazioni quando avrai finito.

en: Keep a practice diary
it: Tieni un diario

en: When you are practicing, you'll often find your mind is full of new exciting ideas - new musical directions, new sounds to try out, new functions to write, etc. These ideas are often so interesting that you might stop what you're doing and start working on the idea. This is another form of distraction!
it: Mentre stai facendo pratica, spesso potresti avere in mente molte idee nuove ed eccitanti. Per esempio nuove direzioni musicali, nuovi suoni, nuove funzioni ecc. Queste idee a volte possono essere talmente interessanti che potresti fermarti e provare a realizzarle. Comunque, anche questa è una forma di distrazione!

en: Practice tip #8 - keep a practice diary by your keyboard. When you get an exciting new idea, temporarily pause your practice session, quickly jot the idea down, then forget about it and carry on practicing. You can then spend some quality time thinking about and working on your ideas after you've finished practicing.
it: Consiglio pratico n.8. Tieni un diario della tua pratica vicino alla tastiera. Quando hai delle idee che ti piacciono particolarmente, ferma un attimo la tua sessione di pratica e sbozza velocemente l'idea sul diario. Appena finito, dimenticatela e vai avanti con la sessione. Potrai quindi tornare indietro successivamente su quell'idea e pensarci con maggiore attenzione.

en: Try to establish a practice routine which incorporates as many of these ideas as possible. Try to keep the sessions as fun as possible but be aware that some practice sessions will be hard and feel a little like work. However, it will all be worth it once you've created your first piece or given your first performance. Remember, practice is the key to success!
it: Cerca di mettere a punto una routine di pratica che includa queste idee nel più gran numero possibile. Cerca di rendere le sessioni il più divertenti possibile ma sii sempre consapevole che alcune sessioni saranno dure e sentirai di aver svolto un lavoro insoddisfacente. Tuttavia, tutto ti sarà stato utile quando avrai creato il tuo primo brano o avrai eseguito il tuo primo concerto. Ricordati, la pratica è la chiave per il successo!

en: A.17 Sample Stretching
it: A.17 Allungare i campioni

en: Sample Stretching
it: Allungare i campioni

en: When people discover Sonic Pi, one of the first things they learn is how simple it is to play pre-recorded sounds using the `sample` function. For example, you can play an industrial drum loop, hear the sound of a choir or even listen to a vinyl scratch all via a single line of code. However, many people don't realise that you can actually vary the speed that the sample is played back at for some powerful effects and a whole new level of control over your recorded sounds. So, fire up a copy of Sonic Pi and let's get started stretching some samples!
it: Quando le persone scoprono Sonic Pi, una delle prime cose che impara è quanto sia semplice riprodurre suoni pre-registrati usando la funzione `sample`. Ad esempio, puoi suonare un loop di tamburo industriale, ascoltare il suono di un coro o anche ascoltare un graffio di vinile tutto attraverso una singola riga di codice. Tuttavia, molte persone non si rendono conto che è possibile effettivamente variare la velocità, il campione viene riprodotto per alcuni effetti potenti e un nuovo livello di controllo sui suoni registrati. Quindi, scarica una copia di Sonic Pi e iniziamo a giocare con  alcuni campioni!

en: Slowing Samples Down
it: Rallentare i campioni (samples)

en: To modify the playback rate of a sample we need to use the `rate:` opt:
it: Per modificare la frequenza di riproduzione di un campione dobbiamo utilizzare il `rate:` opt:

en: If we specify a `rate:` of `1` then the sample is played back at the normal rate. If we want to play it back at half speed we simply use a `rate:` of `0.5`:
it: Se si specifica un `rate:` di `1` allora il campione viene riprodotto alla velocità normale. Se vogliamo riprodurlo ad una velocità dimezzata, usiamo semplicemente una `rate:` di `0.5`:

en: Notice that this has two effects on the audio. Firstly the sample sounds lower in pitch and secondly it takes twice as long to play back (see the sidebar for an explanation of why this is the case). We can even choose lower and lower rates moving towards `0`, so a `rate:` of `0.25` is a quarter speed, `0.1` is a tenth of the speed, etc. Try playing with some low rates and see if you can turn the sound into a low rumble.
it: Tieni conto che questo ha un duplice effetto sul suono. In primo luogo il campione suonerà più basso, più grave e in secondo luogo ci metterà il doppio ad essere riprodotto (dai un'occhiata alla barra laterale per una spiegazione più approfondita). Possiamo addirittura scegliere anche dei valori ancora più bassi avvicinandoci allo '0'. Per esempio '0.25' è un quarto della velocità originale, '0.1' è un decimo e così via. Prova a suonare i campioni utilizzando numeri bassi e osserva come puoi trasformare il suono in una specie di basso ruggito.

en: Speeding Samples Up
it: Accelerare i campioni

en: In addition to making the sound longer and lower using a small rate, we can use higher rates to make the sound shorter and higher. Let's play with a drum loop this time. First, take a listen to how it sounds at the default rate of `1`:
it: Oltre a prolungare ed abbassare i suoni mediante l'abbassamento del valore di rate, possiamo utilizzare dei valori più alti per accorciare e rendere più acuti i suoni. Proviamo a riprodurre un loop di batteria stavolta. Per prima cosa, prova ad ascoltare come suona alla velocità normale: '1':

en: Now, let's speed it up a little:
it: Ora acceleriamoli un pò:

en: Ha! We just moved musical genres from old-skool techno to jungle. Notice how the pitch of each drum hit is higher as well as how the whole rhythm speeds up. Now, try even higher rates and see how high and short you can make the drum loop. For example, if you use a rate of `100`, the drum loop turns into a click!
it: Ha! Ci siamo appena spostati di genere musicale dalla techno vecchia scuola alla jungle. Nota come l'intonazione di ogni colpo di batteria è più alta e come l'intera sezione ritmica accelera. Ora, prova rate ancora più alte e verifica quanto alto e corto puoi rendere il loop di batteria. Ad esempio, se usi un rate di `100`, il loop di batteria diventa un click!

en: Reverse Gear
it: Retromarcia

en: Now, I'm sure many of you are thinking the same thing right now... "what if you use a negative number for the rate?". Great question! Let's think about this for a moment. If our `rate:` opt signifies the speed with which the sample is played back, `1` being normal speed, `2` being double speed, `0.5` being half speed, `-1` must mean backwards! Let's try it on a snare. First, play it back at the normal rate:
it: Ora, sono sicuro che molti di voi stanno pensando la stessa cosa adesso ... "cosa succede se si utilizza un numero negativo per il rate?". Grande domanda! Pensiamo a questo per un momento. Se il nostro `rate:` opt significa la velocità con cui viene riprodotto il campione, `1` è la velocità normale,` 2` è doppia velocità, `0.5` è mezza velocità,` -1` deve significare all'indietro! Proviamolo su un rullante. Innanzitutto, riprodurlo al ritmo normale:

en: Now, play it backwards:
it: Adesso fallo andare all’incontrario:

en: Of course, you can play it backwards twice as fast with a rate of `-2` or backwards at half speed with a rate of `-0.5`. Now, play around with different negative rates and have fun. It's particularly amusing with the `:misc_burp` sample!
it: Naturalmente, puoi riprodurlo al contrario al doppio della velocità con il rate a `-2` oppure al contrario a mezza velocità con un rate a `-0.5`. Ora, prova a giocare con differenti rate negativi e divertiti. E' particolarmente divertente con il sample `:misc_burp`!

en: Sample, Rate and Pitch
it: Campioni, Frequenza e Intonazione

en: One of the effects of rate modification on samples is that faster rates result in the sample sounding higher in pitch and slower rates result in the sample sounding lower in pitch. Another place you may have heard this effect in every day life is when you're cycling or driving past a beeping pedestrian crossing - as you're heading towards the sound source the pitch is higher than when you're moving away from the sound - the so-called Doppler effect. Why is this?
it: Uno degli effetti del cambio di frequenza sui campioni è che frequenze più veloci portano i campioni a suonare più acuti e frequenze più lente portano i campioni a suonare più gravi in intonazione. Un altro contesto in cui potresti aver sentito questo effetto nella vita di tutti i giorni è quando passi in bicicletta o in macchina vicino al cicalino di un attraversamento pedonale - quando ti stai avvicinando l'intonazione è più alta di quando ti stai allontanando - il così detto effetto Doppler. Perché accade?

en: Let's consider a simple beep which is represented by a sine wave. If we use an oscilloscope to plot a beep, we'll see something like Figure A. If we plot a beep an octave higher, we'll see Figure B and an octave lower will look like Figure C. Notice that the waves of higher notes are more compact and the waves of lower notes are more spread out.
it: Consideriamo un semplice beep che è rappresentato da un'onda sinusoidale. Se usiamo un oscilloscopio per tracciare un beep, vedremmo qualcosa tipo la Figura A. Se tracciamo un beep un ottava più in alto, vedremo la Figura B e un ottava più in basso sarà come nella Figura C. Nota che le forme d'onda di note più alte sono più compatte mentre le forme d'onda di note più basse sono più dilatate.

en: A sample of a beep is nothing more than a lot of numbers (x, y, coordinates) which when plotted onto a graph will re-draw the original curves. See figure D where each circle represents a coordinate. To turn the coordinates back into audio, the computer works through each x value and sends the corresponding y value to the speakers. The trick here is that the rate at which the computer works through the x numbers does not have to be the same as the rate with which they were recorded. In other words, the space (representing an amount of time) between each circle can be stretched or compressed. So, if the computer walks through the x values faster than the original rate, it will have the effect of squashing the circles closer together which will result in a higher sounding beep. It will also make the beep shorter as we will work through all the circles faster. This is shown in Figure E.
it: Il campione di un beep non è altro che un insieme di molti numeri (coordinate, x,y) le quali quando tracciate in un grafico ridisegneranno le curve originali. Vedi la figura D in cui ogni cerchio rappresenta una coordinata. Per riconvertire le coordinate in audio, il computer valuta ogni valore di x e lo manda manda il corrispondente valore di y ai diffusori. Il trucco qui sta nel fatto che la frequenza alla quale il computer lavora i numeri x non deve essere la stessa frequenza alla quale sono stati registrati. In altre parole, lo spazio (che rappresenta un intervallo di tempo) fra ogni cerchio può essere allungato o compresso. Così, se il computer processa i valori di x più velocemente della frequenza originale, avrà l'effetto di schiacciare i cerchi più vicini tra loro, il che risulterà in un segnale acustico più acuto. Causerà inoltre un beep più corto in quanto processeremo tutti i cerchi più velocemente. Questo è mostrato nella figura E.

en: Finally, one last thing to know is that a mathematician called Fourier proved that any sound is actually lots and lots of sine waves all combined together. Therefore, when we compress and stretch any recorded sound we're actually stretching and compressing many sine waves all at the same time in exactly this manner.
it: Infine, un'ultima cosa da sapere è che un matematico chiamato Fourier ha provato che ogni suono è in effetti costituito da moltissime onde sinusoidali combinate insieme. Quindi, quando comprimiamo e allunghiamo qualunque suono registrato, stiamo in realtà comprimendo e allungando molte onde sinusoidali simultaneamente in questo modo.

en: Pitch Bending
it: Alterazione dell'Intonazione

en: As we've seen, using a faster rate will make the sound higher in pitch and a slower rate will make the sound lower in pitch. A very simple and useful trick is to know that doubling the rate actually results in the pitch being an octave higher and inversely halving the rate results in the pitch being an octave lower. This means that for melodic samples, playing it alongside itself at double/half rates actually sounds rather nice:
it: Come abbiamo visto, una frequenza più veloce porterà a un suono più alto in intonazione e una frequenza più lenta porterà a suono più basso in intonazione. Un trucchetto molto semplice e veloce consiste nel sapere che a un raddoppio della frequenza corrisponde un'intonazione più alta di un'ottava e, inversamente, il dimezzamento della frequenza corrisponde un'intonazione più bassa di un'ottava. Questo significa che per i sample melodici, riprodurli su sè stessi al doppio o alla metà della loro frequenza li fa suonare piuttosto bene:

en: However, what if we just want to alter the rate such that the pitch goes up one semitone (one note up on a piano)? Sonic Pi makes this very easy via the `rpitch:` opt:
it: Tuttavia, come dobbiamo procedere se vogliamo alterare la frequenza in modo che alzi di un semitono (una nota più avanti sul piano)? Sonic Pi rende questo molto semplice attraverso l'opzione `rpitch:`:

en: If you take a look at the log on the right, you'll notice that an `rpitch:` of `3` actually corresponds to a rate of `1.1892` and a `rpitch:` of `7` corresponds to a rate of `1.4983`. Finally, we can even combine `rate:` and `rpitch:` opts:
it: Se dai un'occhiata al registro eventi sulla destra, noterai che un `rpitch:` di `3` corrisponde in effetti a una frequenza di `1.1892` mentre `rpitch:` di `7` corrisponde a una frequenza di `1.4983`. Infine possiamo anche combinare le opzioni `rate:` e `rpitch:`:

en: Let's take a look at a simple piece which combines these ideas. Copy it into an empty Sonic Pi buffer, hit play, listen to it for a while and then use it as a starting point for your own piece. See how much fun it is to manipulate the playback rate of samples. As an added exercise try recording your own sounds and play around with the rate to see what wild sounds you can make.
it: Diamo un'occhiata a un semplice brano che combina queste idee. Copia in un buffer Sonic Pi vuoto, premi play, ascolta per un po' e poi usalo come punto di partenza per il tuo brano personale. Guarda quanto è divertente manipolare la frequenza di riproduzione dei sample. Come esercizio aggiuntivo prova a registrare dei tuoi suoni a giocare con le frequenze per vedere che razza di suoni selvaggi puoi creare.

en: A.18 Sound Design - Additive Synthesis
it: A.18 Sound Design - Sintesi Additiva

en: Additive Synthesis
it: Sintesi Additiva

en: This is the first of a short series of articles on how to use Sonic Pi for sound design. We'll be taking a quick tour of a number of different techniques available for you to craft your own unique sound. The first technique we'll look at is called *additive synthesis*. This may sound complicated - but if we expand each word slightly the meaning pops right out. Firstly, additive means a combination of things and secondly synthesis means to create sound. Additive synthesis therefore means nothing more complicated than *combining existing sounds to create new ones*. This synthesis technique dates back a very long time - for example, pipe organs in the middle ages had lots of slightly different sounding pipes which you could enable or disable with stops. Pulling out the stop for a given pipe 'added it to the mix' making the sound richer and more complex. Now, let's see how we can pull out all the stops with Sonic Pi.
it: Questo è il primo di una breve serie di articoli su come usare Sonic Pi per il Sound Design. Faremo un rapido tour attraverso un certo numero di tecniche che sono disponibili per creare il tuo suono unico. La prima tecnica che vedremo è chiamata *sintesi additiva". Potrebbe sembrare complicato - ma se riflettiamo brevemente sulle parole, il significato esce fuori subito. Innanzitutto additivo significa una combinazione di cose e secondariamente sintesi significa creare suono. Sintesi additiva significa quindi niente di più complesse che *combinare suoni esistenti per crearne di nuovi*. Questa tecnica di sintesi risale a molto tempo fa - ad esempio gli organi a canne nel medio evo avevano molte canne dai suoni diversi che potevi abilitare o disabilitare con degli appositi blocchi. Rimuovendo il blocco di una certa canna 'la aggiungeva al mix' creando un suono più ricco e complesso. Ora, vediamo come possiamo rimuovere questi blocchi con Sonic Pi.

en: Simple Combinations
it: Combinazioni Semplici

en: Let's start with the most basic sound there is - the humble pure-toned sine wave:
it: Cominciamo con il suono più basico che ci sia - l'umile e pura onda sinusoidale:

en: Now, let's see how this sounds combined with a square wave:
it: Ora, vediamo questo suono combinato con un'onda quadra:

en: Notice how the two sounds combine to form a new, richer sound. Of course, we don't have to stop there, we can add as many sounds as we need. However, we need to be careful with how many sounds we add together. Just like when we mix paints to create new colours, adding too many colours will result in a messy brown, similarly - adding too many sounds together will result in a muddy sound.
it: Nota come i due suoni combinati formano un nuovo e più ricco suono. Naturalmente, non dobbiamo fermarci qui, possiamo aggiungere tutti i suoni di qui abbiamo bisogno. Tuttavia, dobbiamo anche stare attenti a quanti suoni aggiungiamo insieme. Proprio come quando combiniamo pitture per creare nuovi colori, aggiungendone troppi otteniamo un paciugo marrone, similmente aggiungendo troppi suoni otterremo un suono impastato.

en: Blending
it: Mescolare

en: Let's add something to make it sound a little brighter. We could use a triangle wave at an octave higher (for that high bright sound) yet only play it at amp `0.4` so it adds something extra to the sound rather than taking it over:
it: Aggiungiamo qualcosa per ottenere un suono più chiaro. Possiamo usare un'onda triangolare in un'ottava più alta (per ottenere quel suono più chiaro) solo però riprodotta con amp `0.4` in modo che aggiunga un extra al suono senza però coprirlo:

en: Now, try creating your own sounds by combining 2 or more synths at different octaves and amplitudes. Also, note that you can play around with each synth's opts to modify each source sound before it is mixed in for even more combinations of sounds.
it: Ora, prova a creare i tuoi suoni combinando 2 o più synth in ottave e amplificazioni differenti. Nota anche come puoi giocare con le opzioni di ciascun synth per modificare ogni sorgente sonora prima del mix per ottenere ulteriori combinazioni di suoni.

en: Detuning
it: Scordatura

en: So far, when combining our different synths we've used either the same pitch or switched octave. How might it sound if we didn't stick to octaves but instead chose a slightly higher or lower note? Let's try it:
it: Fino a ora, combinando i nostri diversi synth abbiamo usato la stessa intonazione o cambiato ottava. Come suonerebbe se non cambiassimo solo le ottave ma invece applicassimo una nota lievemente più alta o più bassa? Proviamo:

en: If we detune our square waves by 0.7 notes we hear something that perhaps doesn't sound in tune or correct - a 'bad' note. However, as we move closer to 0 it will sound less and less out of tune as the pitches of the two waves get closer and more similar. Try it for yourself! Change the `detune:` opt value from `0.7` to `0.5` and listen to the new sound. Try `0.2`, `0.1`, `0.05`, `0`. Each time you change the value, take a listen and see if you can hear how the sound is changing. Notice that low detune values such as `0.1` produce a really nice 'thick' sound, with both slightly different pitches interacting with each other in interesting, often surprising, ways.
it: Se applichiamo una scordatura alle nostre onde quadre di 0.7 note, sentiremo forse qualcosa che non suona corretto o intonato - una 'brutta' nota. Tuttavia, muovendoci più vicini allo 0 suonerà sempre meno stonata man mano che l'intonazione delle 2 onde si avvicina e diventa simile. Prova tu stesso! Modifica l'opzione `detune:` da `0.7` a `0.5` e ascolta il nuovo suono. Prova `0.2`, `0.1`, `0.05`, `0`. Ogni volta che cambi il valore, ascolta e nota come cambia il suono. Nota che una scordatura più bassa come `0.1` produce un suono 'denso' molto bello, con entrambi i suoni lievemente alterati che interagiscono fra loro vengono fuori combinazioni interessanti e spesso sorprendenti.

en: Another way we can finely craft our sound is to use a different envelope and options for each synth trigger. For example this will allow you to make some aspects of the sound percussive and other aspects ring out for a period of time.
it: Un altro modo con cui possiamo finemente modellare il suono consiste nell'usare differenti envelope e opzioni per ogni innesco dei synth. Ad esempio questo vi permetterà di gestire alcuni aspetti percussivi del suono ed altri aspetti che riguardano la durata nel tempo.

en: In the example above I have mixed in a noisy percussive element to the sound along with some more persistent background rumbling. This was achieved firstly by using two noise synths with middling cutoff values (`90` and `100`) using short release times along with a noise with a longer release time but with a low cutoff value (which makes the noise less crisp and more rumbly.)
it: Nell'esempio sopra, ho mixato un elemento di rumore percussivo con un brontolio persistente in sottofondo. Questo è stato ottenuto innanzitutto usando 2 synth rumore con valori cutoff intermedi (`90` e `100`) usando tempi di rilascio brevi insieme a rumori con un rilascio più lungo ma con un valore cutoff più basso (il che rende il rumore meno nitido e più rumoroso.)

en: Let's combine all these techniques to see if we can use additive synthesis to re-create a basic bell sound. I've broken this example into four sections. Firstly we have the 'hit' section which is the initial onset part of the bell sound - so uses a short envelope (e.g. a `release:` of around `0.1`). Next we have the long ringing section in which I'm using the pure sound of the sine wave. Notice that I'm often increasing the note by roughly `12` and `24` which are the number of notes in one and two octaves. I have also thrown in a couple of low sine waves to give the sound some bass and depth. Finally, I used `define` to wrap my code in a function which I can then use to play a melody. Try playing your own melody and also messing around with the contents of the `:bell` function until you create your own fun sound to play with!
it: Combiniamo tutte queste tecniche per vedere se possiamo usare la sintesi additiva per creare un suono basico di campana. Ho diviso questo esempio in 4 sezioni. Prima abbiamo la sezione 'hit' che è la parte iniziale del suono della campana - quindi usa un inviluppo corto (e.g. una `release:` di circa `0.1`). Poi abbiamo la lunga sezione di risonanza nella quale uso il suono puro dell'onda sinusoidale. Nota che spesso aumento la nota di circa `12` e `24` che sono il numero di note in una e due ottave. Ho anche inserito un paio di onde sinusoidali basse per dare al suono un po' di bassi e profondità. Infine, ho usato `define` per racchiudere il mio codice in una funzione che posso quindi utilizzare per suonare una melodia. Prova a suonare la tua melodia e anche a incasinare i contenuti della funzione `:bell` finché non crei il tuo suono divertente con cui suonare!

en: A.19 Sound Design - Subtractive Synthesis
it: A.19 Sound Design - Sintesi Sottrattiva

en: Subtractive Synthesis
it: Sintesi Sottrattiva

en: This is the second in a series of articles on how to use Sonic Pi for sound design. Last month we looked at additive synthesis which we discovered was the simple act of playing multiple sounds at the same time to make a new combined sound. For example we could combine different sounding synths or even the same synth at different pitches to build a new complex sound from simple ingredients. This month we'll look at a new technique commonly called *subtractive synthesis* which is simply the act of taking an existing complex sound and removing parts of it to create something new. This is a technique which is commonly associated with the sound of analog synthesisers of the 1960s and 1970s but also with the recent renaissance of modular analog synths through popular standards such as Eurorack.
it: Questo è il secondo di una serie di articoli su come utilizzare Sonic Pi per il sound design. Il mese scorso abbiamo esaminato la sintesi additiva che abbiamo scoperto fosse il semplice atto di suonare più suoni contemporaneamente per creare un nuovo suono combinato. Ad esempio, potremmo combinare sintetizzatori con diversi suoni o anche lo stesso sintetizzatore a diverse intonazioni per costruire un nuovo suono complesso da ingredienti semplici. Questo mese esamineremo una nuova tecnica comunemente chiamata *sintesi sottrattiva* che è semplicemente consiste nel prendere un suono complesso esistente e rimuoverne parti per creare qualcosa di nuovo. Questa è una tecnica comunemente associata al suono dei sintetizzatori analogici degli anni '60 e '70, ma anche alla recente rinascita dei sintetizzatori analogici modulari attraverso standard popolari come Eurorack.

en: Despite this sounding like a particularly complicated and advanced technique, Sonic Pi makes it surprisingly simple and easy - so let's dive right in.
it: Nonostante sembri una tecnica particolarmente complicata e avanzata, Sonic Pi la rende sorprendentemente semplice, quindi entriamoci subito.

en: Complex Source Signal
it: Segnale Sorgente Complesso

en: For a sound to work well with subtractive synthesis, it typically needs to be fairly rich and interesting. This doesn't mean we need something hugely complex - in fact, just a standard `:square` or `:saw` wave will do:
it: Affinché un suono funzioni bene con la sintesi sottrattiva, in genere deve essere sufficientemente ricco e interessante. Questo non significa che abbiamo bisogno di qualcosa di estremamente complesso - infatti, solo un'onda standard `:square` o `:saw` produrrà:

en: Notice that this sound is already pretty interesting and contains many different frequencies above `:e2` (the second E on a piano) which add to create the timbre. If that didn't make much sense to you, try comparing it with the `:beep`:
it: Nota che questo suono è già piuttosto interessante e contiene molte frequenze diverse sopra `:e2` (il secondo MI su un pianoforte) che si aggiungono per creare il timbro. Se ti sembra che non abbia molto senso, prova a confrontarlo con `:beep`:

en: As the `:beep` synth is just a sine wave, you'll hear a much purer tone and only at `:e2` and none of the high crispy/buzzy sounds which you heard in the `:saw`. It's this buzziness and variation from a pure sine wave that we can play with when we use subtractive synthesis.
it: Poiché il synth `:beep` è solo un'onda sinusoidale, sentirai un tono molto più puro e solo a `:e2` e nessuno dei suoni acuti e nitidi che hai sentito con `:saw`. Questa vivacità e variazione da un'onda sinusoidale pura costituiscono il materiale con cui possiamo giocare quando utilizziamo la sintesi sottrattiva.

en: Once we have our raw source signal, the next step is to pass it through a filter of some kind which will modify the sound by removing or reducing parts of it. One of the most common filters used for subtractive synthesis is something called a low pass filter. This will allow all the low parts of the sound through but will reduce or remove the higher parts. Sonic Pi has a powerful yet simple to use FX system that includes a low pass filter, called `:lpf`. Let's play with it:
it: Una volta che abbiamo il nostro segnale sorgente grezzo, il passo successivo è farlo passare attraverso un filtro di qualche tipo che modificherà il suono rimuovendo o riducendone alcune parti. Uno dei filtri più comuni utilizzati per la sintesi sottrattiva è il cosiddetto filtro passa basso. Ciò consentirà il passaggio di tutte le parti basse del suono, ma ridurrà o rimuoverà le parti più alte. Sonic Pi ha un sistema FX potente ma comunque semplice da usare che include un filtro passa basso, chiamato `:lpf`. Giochiamoci un po':

en: If you listen carefully you'll hear how some of that buzziness and crispiness has been removed. In fact, all the frequencies in the sound above note `100` have been reduced or removed and only the ones below are still present in the sound. Try changing that `cutoff:` point to lower notes, say `70` and then `50` and compare the sounds.
it: Se ascolti attentamente, sentirai come un po' di quel brusio e quella nitidezza sono state rimosse. Infatti, tutte le frequenze nel suono sopra la nota `100` sono state ridotte o rimosse e solo quelle sotto sono ancora presenti nel suono. Prova a cambiare quel "cutoff:" punta alle note più basse, diciamo dì "70" e poi "50" e confronta i suoni.

en: Of course, the `:lpf` isn't the only filter you can use to manipulate the source signal. Another important FX is the high pass filter referred to as `:hpf` in Sonic Pi. This does the opposite to `:lpf` in that it lets the high parts of the sound through and cuts off the low parts.
it: Naturalmente, `:lpf` non è l'unico filtro che puoi usare per manipolare il segnale sorgente. Un altro effetto importante è il filtro passa alto denominato `:hpf` in Sonic Pi. Questo fa l'opposto di `:lpf` in quanto lascia passare le parti alte del suono e taglia le parti basse.

en: Notice how this sounds much more buzzy and raspy now that all the low frequency sounds have been removed. Play around with the cutoff value - notice how lower values let more of the original bass parts of the source signal through and higher values sound increasingly tinny and quiet.
it: Nota come questo suona con molto più ronzio e in modo roco ora che tutti i suoni a bassa frequenza sono stati rimossi. Prova a cambiare il valore di cutoff: nota come valori più bassi lasciano passare più parti dei bassi originali del segnale sorgente e valori più alti suonano sempre più metallici e silenziosi.

en: Low Pass Filter
it: Filtro Passa Basso

en: Filter Modulation
it: Modulazione Filtri

en: So far we've just produced fairly static sounds. In other words, the sound doesn't change in any way for the entirety of its duration. Often you might want some movement in the sound to give the timbre some life. One way to achieve this is via filter modulation - changing the filter's options through time. Luckily Sonic Pi gives you powerful tools to manipulate an FX's opts through time. For example, you can set a slide time to each modulatable opt to specify how long it should take for the current value to linearly slide to the target value:
it: Finora abbiamo appena prodotto suoni abbastanza statici. In altre parole, il suono non cambia in alcun modo per tutta la sua durata. Spesso potresti volere un po' di movimento nel suono per dare vita al timbro. Un modo per ottenere ciò è tramite la modulazione del filtro - modificando le opzioni del filtro nel tempo. Fortunatamente Sonic Pi ti offre potenti strumenti per manipolare le opzioni di un FX nel tempo. Ad esempio, puoi impostare un tempo di transizione per ciascuna opzione modulabile per specificare quanto tempo dovrebbe impiegare il valore corrente per scorrere linearmente fino al valore di destinazione:

en: Let's take a quick look at what's going on here. Firstly we start an `:lpf` FX block as normal with an initial `cutoff:` of a low `50`. However, the first line also finishes with the strange `|fx|` at the end. This is an optional part of the `with_fx` syntax which allows you to directly name and control the running FX synth. Line 2 does exactly this and controls the FX to set the `cutoff_slide:` opt to 3 and the new target `cutoff:` to be `130`. The FX will now start sliding the `cutoff:` opt's value from `50` to `130` over a period of 3 beats. Finally we also trigger a source signal synth so we can hear the effect of the modulated low pass filter.
it: Diamo una rapida occhiata a cosa sta succedendo qui. Innanzitutto iniziamo un blocco FX `:lpf` normale con un `cutoff:` iniziale basso di un `50`. Tuttavia, la prima riga termina anche con uno strano `|fx|` alla fine. Questa è una parte opzionale della sintassi `with_fx` che ti permette di denominare e controllare direttamente il synth FX in esecuzione. La riga 2 fa esattamente questo e controlla l'FX per impostare opzione `cutoff_slide:` a 3 e il nuovo valore di destinazione `cutoff:` a `130`. L'FX ora inizierà a muovere il valore di `cutoff:` da `50` a `130` lungo un periodo di 3 battiti. Infine attiviamo anche un sintetizzatore del segnale sorgente in modo da poter ascoltare l'effetto del filtro passa basso modulato.

en: This is just a very basic taster of what's possible when you use filters to modify and change a source sound. Try playing with Sonic Pi's many built-in FX to see what fun sounds you can design. If your sound feels too static, remember you can start modulating the options to create some movement.
it: Questo è solo un assaggio molto semplice di ciò che è possibile ottenere quando si utilizzano i filtri per modificare e cambiare un suono sorgente. Prova a giocare con i numerosi effetti integrati di Sonic Pi per vedere quali suoni divertenti puoi progettare. Se il tuo suono sembra troppo statico, ricorda che puoi iniziare a modulare le opzioni per creare un po' di movimento.

en: Let's finish by designing a function which will play a new sound created with subtractive synthesis. See if you can figure out what's going on here - and for the advanced Sonic Pi readers out there - see if you can work out why I wrapped everything inside a call to `at` (please send answers to @samaaron on Twitter).
it: Concludiamo progettando una funzione che riprodurrà un nuovo suono creato con sintesi sottrattiva. Guarda se riesci a capire cosa sta succedendo qui - e per gli utenti avanzati di Sonic Pi - guardate se riuscite a capire perché ho racchiuso tutto in una chiamata a `at` (per favore inviate le risposte a @samaaron su Twitter).

en: A.20 Creative coding in the classroom with Sonic Pi
it: A.20 Programmazione creativa in classe con Sonic Pi

en: Creative coding in the classroom with Sonic Pi
it: Programmazione creativa in classe con Sonic Pi

en: (This article was published in [issue 9 of the Hello World Magazine](https://helloworld.raspberrypi.org/issues/9))
it: (Questo articolo è stato pubblicato in [issue 9 di Hello World Magazine](https://helloworld.raspberrypi.org/issues/9))

en: Code is one of the most creative media that humans have created. The initially obscure symbols of parentheses and lambdas are not just deeply rooted in science and mathematics, they are the closest we have managed to get to casting the same kind of magical spells as Gandalf and Harry Potter. I believe that this provides a powerful means of engagement in our learning spaces. Through the magic of code we are able to conjure up individually meaningful stories and learning experiences.
it: Il codice programmazione è uno dei media più creativi che gli esseri umani abbiano creato. I simboli inizialmente oscuri di parentesi e lambda non sono solo profondamente radicati nella scienza e nella matematica, sono i più vicini che siamo riusciti a ottenere per lanciare lo stesso tipo di incantesimi come Gandalf e Harry Potter. Credo che questo fornisca un potente mezzo di coinvolgimento nei nostri spazi di apprendimento. Attraverso la magia del codice siamo in grado di evocare storie ed esperienze individuali di apprendimento significative.

en: We are surrounded by magical experiences. From the sleight of hand of a stage magician making the ball disappear into thin air, to the wonder of seeing your favourite band perform on a big stage. It is these "wow" moments that inspire us to pick up a magic book and learn the French Drop or to start jamming power chords on an old guitar. How might we create similarly deep and lasting senses of wonder that will motivate people to practice and learn the fundamentals of programming?
it: Siamo circondati da esperienze magiche. Dal gioco di prestigio di un mago del palcoscenico che fa sparire la palla nel nulla, alla meraviglia di vedere la tua band preferita esibirsi su un grande palco. Sono questi momenti "wow" che ci ispirano a prendere in mano un libro magico e imparare il French Drop o ad iniziare a suonare power chords su una vecchia chitarra. Come potremmo creare sensi di meraviglia altrettanto profondi e duraturi che motiveranno le persone a esercitarsi e ad apprendere i fondamenti della programmazione?

en: Musical Engines and Notation
it: Motori Musicali e Notazione

en: The histories of music and computers have been intricately woven together since the inception of computing machines, or "engines" as Charles Babbage's powerful analytical engine was called. Back in 1842 the Mathematician Ada Lovelace, who worked very closely with Babbage, saw the creative potential of these engines. Whilst these first engines had originally been designed to accurately solve hard maths problems, Ada dreamt about making music with them:
it: Storie di musica e di computer sono state intrecciate fin dall'inizio delle macchine computazionali, o "motori", come veniva chiamato il potente motore analitico di Charles Babbage. Già nel 1842 la matematica Ada Lovelace, che lavorò a stretto contatto con Babbage, vide il potenziale creativo di questi motori. Mentre questi primi motori erano stati originariamente progettati per risolvere accuratamente problemi di matematica complessi, Ada sognava di fare musica con loro:

en: "..the engine might compose elaborate and scientific pieces of music of any degree of complexity or extent." Ada Lovelace, 1842.
it: "...il motore potrebbe comporre brani musicali elaborati e scientifici di qualsiasi grado di complessità o estensione." Ada Lovelace, 1842.

en: Of course, today in 2019 much of our music, regardless of genre, has either been composed, produced or mastered with a digital computer. Ada's dream came true. It is even possible to trace the history back even further. If you see coding as the art of writing sequences of special symbols that instruct a computer to do specific things, then musical composition is a very similar practice. In Western music, the symbols are black dots positioned on a stave of lines that tell the musician which notes to play and when. Intriguingly, if we trace the roots of Western music notation back to the Italian Benedictine monk, Guido d'Arezzo, we find that the dots and lines system that modern orchestras use is just one of a number of notation systems he worked on. Some of the others were much closer to what we might now see as code.
it: Naturalmente, oggi nel 2019 gran parte della nostra musica, indipendentemente dal genere, è stata composta, prodotta o masterizzata con un computer digitale. Il sogno di Ada si è avverato. È anche possibile risalire ulteriormente alla storia. Se vedi la programmazione come l'arte di scrivere sequenze di simboli speciali che forniscono istruzioni a un computer per fare cose specifiche, allora la composizione musicale è una pratica molto simile. Nella musica occidentale, i simboli sono punti neri posizionati su un pentagramma di linee che indicano al musicista quali note suonare e quando. Curiosamente, se facciamo risalire le radici della notazione musicale occidentale al monaco benedettino italiano Guido d'Arezzo, scopriamo che il sistema di punti e linee utilizzato dalle orchestre moderne è solo uno dei numerosi sistemi di notazione su cui ha lavorato. Alcuni degli altri erano molto più vicini a quello che ora potremmo vedere come codice di programmazione.

en: Sonic Pi Performances
it: Sonic Pi - Prestazioni

en: Sonic Pi has been used to perform in a wide range of venues such as school halls, nightclubs, outdoor stages at musical festivals, college chapels and prestigious music venues. For example the amazing Convo project which brought 1000 children together in the Royal Albert Hall to perform an ambitious new composition by composer Charlotte Harding. The piece was written for traditional instruments, choirs, percussion and Sonic Pi code. The pop-artist Jylda also performed with Sonic Pi in the Sage Gateshead for the Thinking Digital Conference, where she created a unique live-coded improvised remix of her song Reeled.
it: Sonic Pi è stato utilizzato per esibirsi in una vasta gamma di luoghi come aule scolastiche, discoteche, palchi all'aperto in festival musicali, cappelle universitarie e prestigiosi locali musicali. Ad esempio lo straordinario progetto Convo che ha riunito 1000 bambini nella Royal Albert Hall per eseguire una nuova ambiziosa composizione della compositrice Charlotte Harding. Il pezzo è stato scritto per strumenti tradizionali, cori, percussioni e codice Sonic Pi. L'artista pop Jylda si è anche esibita con Sonic Pi al Sage Gateshead per la Conferenza Thinking Digital, dove ha creato un remix unico e improvvisato dal vivo della sua canzone Reeled.

en: ![Sonic Pi in the Royal Albert Hall](../../../etc/doc/images/tutorial/articles/A.20-creative-coding-in-the-classroom/convo-small.png) Sonic Pi used as one of the instruments as part of Convo at the Royal Albert Hall. Photo credit: Pete Jones.
it: ![Sonic Pi in the Royal Albert Hall](../../../etc/doc/images/tutorial/articles/A.20-creative-coding-in-the-classroom/convo-small.png) Sonic Pi usato come uno degli strumenti come parte del Convo presso la Royal Albert Hall. Foto: Pete Jones.

en: Live coding in the classroom
it: Live coding in classe

en: Sonic Pi is a code-based music creation and performance tool that builds on all of these ideas. Unlike the majority of computing education software, it is both simple enough to use for education and also powerful enough for professionals. It has been used to perform in international music festivals, used to compose in a range of styles from classical, EDM and heavy metal, and was even reviewed in the Rolling Stone magazine. It has a diverse community of over 1.5 million live coders with a variety of backgrounds all learning and sharing their ideas and thoughts through the medium of code. It is free to download for Mac, PC and Raspberry Pi and includes a friendly tutorial that assumes you know nothing about either code or music.
it: Sonic Pi è uno strumento di creazione e performance musicale basato su codice che si basa su tutte queste idee. A differenza della maggior parte dei software didattici, è sia abbastanza semplice da usare per l'istruzione che anche abbastanza potente per i professionisti. È stato utilizzato per esibirsi in festival musicali internazionali, per comporre in una vasta gamma di stili dalla classica, all'EDM e all'heavy metal ed è stato persino recensito sulla rivista Rolling Stone. Ha una comunità diversificata di oltre 1,5 milioni di programmatori live con una varietà di background che apprendono e condividono idee e pensieri attraverso il codice di programmazione. È scaricabile gratuitamente per Mac, PC e Raspberry Pi e include un tutorial amichevole che presuppone che tu non sappia nulla né di programmazione né di musica.

en: Sonic Pi was initially conceived as a response to the UK's newly released Computing curriculum in 2014. The goal was to find a motivating and fun way to teach the fundamentals of programming. It turns out that there is a lot in common and it's huge fun to explain sequencing as melody, iteration as rhythm, conditionals as musical variety. I developed the initial designs and first iterations of the platform with Carrie Anne Philbin, who brought a teacher’s perspective to the project. Since then, Sonic Pi has undergone iterative improvements thanks to the feedback gained from observing learners and collaborating directly with educators in the classroom. A core design philosophy was to never add a feature that couldn't be easily taught to a 10 year old child. This meant that most ideas had to be heavily refined and reworked until they were simple enough. Making things simple whilst keeping them powerful continues to be the hardest part of the project.
it: Sonic Pi è stato inizialmente concepito come una risposta al curriculum di informatica pubblicato nel Regno Unito nel 2014. L'obiettivo era trovare un modo motivante e divertente per insegnare i fondamenti della programmazione. Si scopre che c'è molto in comune ed è molto divertente spiegare il sequenziamento come melodia, l'iterazione come ritmo, i condizionali come varietà musicale. Ho sviluppato i progetti iniziali e le prime iterazioni della piattaforma con Carrie Anne Philbin, che ha portato il punto di vista di un insegnante al progetto. Da allora, Sonic Pi ha subito miglioramenti iterativi grazie al feedback ottenuto osservando gli studenti e collaborando direttamente con gli educatori in classe. Una filosofia di base nella progettazione era quella di non aggiungere mai una caratteristica che non potesse essere insegnata facilmente a un bambino di 10 anni. Ciò significava che la maggior parte delle idee doveva essere pesantemente rifinita e rielaborata fino a renderla abbastanza semplice. Rendere le cose semplici pur mantenendole potenti continua a essere la parte più difficile del progetto.

en: In order to provide the magical motivation, Sonic Pi's design was never limited to a pure focus on education. Ideally there would be famous musicians and performers using Sonic Pi as a standard instrument alongside guitars, drums, vocals, synths, violins, etc. These performers would then act as motivational role models demonstrating the creative potential of code. For this to be possible sufficient focus and effort therefore had to be placed on making it a powerful instrument whilst still keeping it simple enough for 10 year olds to pick up. In addition to educators, I also worked directly with a variety of different artists in classrooms, art galleries, studios and venues in the early stages of Sonic Pi’s development. This provided essential feedback which enabled Sonic Pi to grow and ultimately flourish as a tool for creative expression.
it: Al fine di fornire la motivazione magica, il design di Sonic Pi non si è mai limitato a un puro scopo di istruzione. Idealmente ci sarebbero musicisti e artisti famosi che usano Sonic Pi come strumento standard insieme a chitarre, batteria, voce, sintetizzatori, violini, ecc. Questi artisti agirebbero quindi come modelli motivazionali dimostrando il potenziale creativo del codice di programmazione. Affinché ciò fosse possibile, è stato quindi necessario dedicare sufficiente attenzione e sforzo per renderlo uno strumento potente pur mantenendolo abbastanza semplice da poter essere assimilato dai bambini di 10 anni. Oltre agli educatori, ho anche lavorato direttamente con una varietà di artisti diversi in classi, gallerie d'arte, studi e luoghi nelle prime fasi dello sviluppo di Sonic Pi. Ciò ha fornito un feedback essenziale che ha consentito a Sonic Pi di crescere e, infine, prosperare come strumento per l'espressione creativa.

en: There were a number of exciting and unexpected side effects of this dual focus on education and professional musicians. Many of the features are beneficial to both groups. For example, a lot of effort has been put into making error messages more friendly and useful (rather than being a huge complicated mess of jargon). This turns out to be very useful when you write a bug while performing in front of thousands of people. Additionally, functionality such as playing studio quality audio samples, adding audio effects, providing access to live audio from the microphone all turn out to make the learning experience more fun, rewarding and ultimately meaningful.
it: Ci sono stati una serie di effetti collaterali eccitanti e inaspettati di questa doppia attenzione all'istruzione e ai musicisti professionisti. Molte delle caratteristiche sono vantaggiose per entrambi i gruppi. Ad esempio, è stato fatto un grande sforzo per rendere i messaggi di errore più amichevoli e utili (piuttosto che essere un enorme complicato pasticcio di gergo). Questo risulta essere molto utile quando scrivi un bug mentre ti esibisci di fronte a migliaia di persone. Inoltre, funzionalità come la riproduzione di campioni audio di qualità da studio, l'aggiunta di effetti audio, l'accesso all'audio dal vivo dal microfono, rendono l'esperienza di apprendimento più divertente, gratificante e, in definitiva, significativa.

en: The Sonic Pi community continues to grow and share amazing code compositions, lesson plans, musical algorithms, and much more. Much of this happens on our friendly forum in_thread (in-thread.sonic-pi.net) which is home to a very diverse group of people that includes educators, musicians, programmers, artists and makers. It is a real joy to see people learn to use code to express themselves in new ways and for that in turn to inspire others to do the same.
it: La community di Sonic Pi continua a crescere e a condividere incredibili composizioni di codici, piani formativi, algoritmi musicali e molto altro. Gran parte di questo accade nel nostro amichevole forum in_thread (in-thread.sonic-pi.net) che ospita un gruppo molto diversificato di persone che include educatori, musicisti, programmatori, artisti e creatori. È una vera gioia vedere le persone imparare a usare il codice per esprimersi in modi nuovi e questo a sua volta ispira gli altri a fare lo stesso.

en: Some fun capabilities
it: Alcune caratteristiche divertenti

en: From a Computer Science perspective, Sonic Pi provides you with the building blocks to teach you the basics as found in the UK's curriculum such as sequencing, iteration, conditionals, functions, data structures, algorithms, etc. However, it also builds on a number of important and relevant concepts which have become adopted in mainstream industry such as concurrency, events, pattern matching, distributed computing and determinism - all whilst keeping things simple enough to explain to a 10 year old child.
it: Dal punto di vista dell'informatica, Sonic Pi ti fornisce i fondamenti di conoscenza per insegnarti le nozioni di base che si trovano nel curriculum del Regno Unito come sequenziamento, iterazione, condizionali, funzioni, strutture dati, algoritmi, ecc. Tuttavia, si basa anche su un numero di concetti importanti e rilevanti che sono stati adottati nell'industria tradizionale come concorrenza, eventi, comparazione di pattern, calcolo distribuito e determinismo, il tutto mantenendo le cose abbastanza semplici da poter essere spiegate a un bambino di 10 anni.

en: A melody can be constructed with one more command, sleep:
it: Una melodia può essere costruita con un ulteriore comando, sleep:

en: In this example, we play the note 70 (roughly the 70th note on a piano), wait for 1 second, play note 72, wait for half a second and then play note 75. What's interesting here is that with just two commands we have access to pretty much all of Western notation (which notes to play and when) and learners can code any melody they've ever heard. This leads to huge variety in expressive outcomes whilst focussing on the same computing concept: sequencing in this case.
it: In questo esempio, suoniamo la nota 70 (all'incirca la settantesima nota su un pianoforte), attendiamo 1 secondo, suoniamo la nota 72, attendiamo mezzo secondo e quindi suoniamo la nota 75. La cosa interessante qui è che con solo due comandi abbiamo l'accesso a praticamente tutta la notazione occidentale (quali note suonare e quando) e gli studenti possono programmare qualsiasi melodia che abbiano mai sentito. Ciò porta a un'enorme varietà di risultati espressivi mentre ci si concentra sullo stesso concetto di calcolo: il sequenziamento in questo caso.

en: Taking ideas from the professional music world, we can also play back any recorded sound. Sonic Pi can play any audio file on your computer but also has a number of sounds built-in to make things easy to get started:
it: Prendendo spunti dal mondo della musica professionale, possiamo anche riprodurre qualsiasi suono registrato. Sonic Pi può riprodurre qualsiasi file audio sul tuo computer, ma ha anche una serie di suoni integrati per rendere le cose facili subito dall'inizio:

en: This code will play back the drum break which was a pillarstone to early hip-hop, Drum and Bass and Jungle. For example, a number of early hip-hop artists played this drum break back at half speed to give it a more laid-back feeling:
it: Questo codice riprodurrà un ritmo di batteria che è stato una pietra miliare del primo hip-hop, Drum and Bass e Jungle. Ad esempio, un certo numero di primi artisti hip-hop hanno suonato questo ritmo di batteria a velocità dimezzata per dargli un andamento più rilassato:

en: In the 90s a number of music scenes burst out of new technology which enabled artists to take drum breaks like this apart and reassemble in a different order. For example:
it: Negli anni '90 una serie di scene musicali sono esplose grazie alla nuova tecnologia che ha consentito agli artisti di smontare le parti di batteria come questa e di riassemblarle in un ordine diverso. Per esempio:

en: Essential Knowledge
it: Informazioni essenziali

en: This section will cover some very useful - in fact *essential* - knowledge for getting the most out of your Sonic Pi experience.
it: Questa sezione copre alcune informazioni *essenziali* per ottenere il massimo da Sonic Pi.

en: We'll cover how to take advantage of the many keyboard shortcuts available to you, how to share your work and some tips on performing with Sonic Pi.
it: Vedremo insieme le scorciatoie da tastiera che puoi utilizzare, come condividere il tuo lavoro e qualche consiglio su come esibirti con Sonic Pi.

en: Using Shortcuts
it: Utilizzare le scorciatoie

en: Sonic Pi is as much an instrument as a coding environment. Shortcuts can therefore make playing Sonic Pi much more *efficient and natural* - especially when you're playing live in front of an audience.
it: Sonic Pi è uno strumento così come è un ambiente di sviluppo. Le scorciatoie possono rendere l'esperienza di Sonic Pi più *efficace e naturale*, soprattutto se suoni live di fronte a un pubblico.

en: Much of Sonic Pi can be controlled through the keyboard. As you gain more familiarity working and performing with Sonic Pi, you'll likely start using the shortcuts more and more. *I personally touch-type* (I recommend you consider learning too) and find myself frustrated whenever I need to reach for the mouse as it slows me down. I therefore use all of these shortcuts on a very regular basis!
it: Sonic Pi può essere controllato in larga parte grazie alla tastiera. Familiarizzando con Sonic Pi, comincerai a utilizzare sempre di più le scorciatoie. Io *suono con la tastiera* (e vi consiglio di imparare a farlo) e mi ritrovo ad essere frustrato ogni volta che devo usare il mouse perché mi rallenta. Per questo uso queste scorciatoie regolarmente!

en: Therefore, if you learn the shortcuts, you'll learn to use your keyboard effectively and you'll be live coding like a pro in no time.
it: Se impari a utilizzare le scorciatoie, programmerai live come un professionista in men che non si dica.

en: However, *don't try and learn them all at once*, just try and remember the ones you use most and then keep adding more to your practice.
it: Mi raccomando: *non provare a impararli tutti in una volta*, cerca di ricordare quelli che usi più spesso e di aggiungerne qualcuno a mano a mano che ti eserciti.

en: Consistency across Platforms
it: Coerenza tra le piattaforme

en: Imagine you're learning the clarinet. You'd expect all clarinets of all makes to have similar controls and fingerings. If they didn't, you'd have a tough time switching between different clarinets and you'd be stuck to using just one make.
it: Immagina se stessi imparando a suonare il clarinetto. Ti aspetteresti che ogni clarinetto abbia gli stessi controlli e la stessa ditteggiatura. Se così non fosse, faresti fatica a suonare clarinetti diversi e saresti costretto a usarne soltanto uno.

en: Unfortunately the three major operating systems (Linux, Mac OS X and Windows) come with their own standard defaults for actions such as cut and paste etc. Sonic Pi will try and honour these standards. However *priority is placed on consistency across platforms* within Sonic Pi rather than attempting to conform to a given platform's standards. This means that when you learn the shortcuts whilst playing with Sonic Pi on your Raspberry Pi, you can move to the Mac or PC and feel right at home.
it: Sfortunatamente ci sono tre sistemi operativi principalmente: Linux, Max OSX e Windows che hanno le loro funzioni standard per azioni come taglia e incolla, ecc... Sonic Pi cerca di rispettare questi standard. Tuttavia *la priorità è mantenere una coerenza tra le piattaforme* all'interno di Sonic Pi invece che adattarsi agli standard di ciascuna piattaforma. Questo significa che quando impari le scorciatoie usando Sonic Pi sul tuo Raspberry Pi, puoi spostarti su Mac o PC e sentirti a casa.

en: Control and Meta
it: Controllo e Meta

en: Part of the notion of consistency is the naming of shortcuts. In Sonic Pi we use the names *Control* and *Meta* to refer to the two main combination keys. On all platforms *Control* is the same. However, on Linux and Windows, *Meta* is actually the *Alt* key while on Mac *Meta* is the *Command* key. For consistency we'll use the term *Meta* - just remember to map that to the appropriate key on your operating system.
it: La prima parte relativa alla coerenza è relativa ai nomi delle abbreviazioni. In Sonic Pi usiamo i nome *Controllo* e *Meta* per fare riferimento a due combinazioni di tasti. Su tutte le piattaforme *Controllo* è lo stesso invece su Linux e Windows *Meta* è il tasto *Alt* mentre su Mac *Meta* è il tasto *Command*. Per coerenza useremo il termina *Meta*, ricordati solo di mapparlo nel modo corretto con la tastiera del tuo sistema operativo.

en: Abbreviations
it: Abbreviazioni

en: To help keep things simple and readable, we'll use the abbreviations *C-* for *Control* plus another key and *M-* for *Meta* plus another key. For example, if a shortcut requires you to hold down both *Meta* and *r* we'll write that as `M-r`. The *-* just means "at the same time as."
it: Per semplicità utilizzeremo delle abbreviazioni *C-* per *Controllo* e *M-* per *Meta*. Per esempio se per una scorciatoia devi tenere premuti contemporaneamente *Meta* e *r* noi scriveremo *M-r*. Il *-* indica "premi insieme."

en: The following are some of the shortcuts I find most useful.
it: Questi sono alcune delle scorciatoie più utili.

en: Stopping and starting
it: Fermarsi e ripartire

en: Instead of always reaching for the mouse to run your code, you can simply press `M-r`. Similarly, to stop running code you can press `M-s`.
it: Invece che andare alla ricerca del mouse per far funzionare il tuo codice, puoi premere `M-r`. Allo stesso modo, per fermare premi `M-s`.

en: Navigation
it: Navigazione

en: I'm really lost without the navigation shortcuts. I therefore highly recommend you spend the time to learn them. These shortcuts also work extremely well when you've learned to touch type as they use the standard letters rather than requiring you to move your hand to the mouse or the arrow keys on your keyboard.
it: Io mi sento davvero perso senza le scorciatoie di navigazione. Per questo ti consiglio di investire parte del tuo tempo per impararle. Queste scorciatoie funzionano molto bene quando vuoi muoverti solo utilizzando la tastiera invece che muovendo il mouse o le frecce sulla tastiera.

en: You can move to the beginning of the line with `C-a`, the end of the line with `C-e`, up a line with `C-p`, down a line with `C-n`, forward a character with `C-f`, and back a character with `C-b`. You can even delete all the characters from the cursor to the end of the line with `C-k`.
it: Puoi muoverti all'inizio della riga con `C-a`, alla fine della riga con `C-e`, alla riga precedente `C-p` oppure su quella successiva `C-n`, avanti di un carattere `C-f` oppure indietro di uno `C-b`. Puoi anche eliminare tutti i caratteri partendo dalla posizione del cursore fino alla fine della riga con `C-k`.

en: Tidy Code
it: Codice più pulito

en: To auto-align your code simply press `M-m`.
it: Per allineare automaticamente il codice, premi semplicemente 'M-m'.

en: Help System
it: Sistema di aiuto

en: To toggle the help system you can press `M-i`. However, a much more useful shortcut to know is `C-i` which will look up the word underneath the cursor and display the docs if it finds anything. Instant help!
it: Per aprire il pannello di aiuto, puoi premere `M-i`. Tuttavia è importante conoscere anche la scorciatoia `C-i` che ti aiuta a trovare nella documentazione la parola che si trova sotto il cursore per un aiuto immediato!

en: Shortcut Cheatsheet
it: Riassunto scorciatoie

en: Conventions
it: Convenzioni

en: In this list, we use the following conventions (where *Meta* is one of *Alt* on Windows/Linux or *Cmd* on Mac):
it: In questa lista vengono usate le seguenti convenzioni (dove *Meta* è *Alt* su Windows/Linux o *Cmd* su Mac):

en: `C-a` means hold the *Control* key then press the *a* key whilst holding them both at the same time, then releasing.
it: `C-a` significa tieni premuto *Control* e il tasto *a* contemporaneamente.

en: `M-r` means hold the *Meta* key and then press the *r* key whilst holding them both at the same time, then releasing.
it: `M-r` significa tieni premuti il tasto *Meta* e poi premi *r*.

en: `S-M-z` means hold the *Shift* key, then the *Meta* key, then finally the *z* key all at the same time, then releasing.
it: `S-M-z` vuol dire premi contemporaneamente *Shift*, *Meta* e il tasto *z*.

en: `C-M-f` means hold the *Control* key, then press *Meta* key, finally the *f* key all at the same time, then releasing.
it: `C-M-f` significa premi *Control*, *Meta* e *f* contemporaneamente.

en: Main Application Manipulation
it: Controllo dell'applicazione principale

en: `M-r` - Run code
it: `M-r` - Avvia il codice

en: `M-s` - Stop code
it: `M-s` - Ferma il codice

en: `M-i` - Toggle Help System
it: `M-i` - Apri/Chiudi il sistema di aiuto

en: `M-p` - Toggle Preferences
it: `M-p` - Apri/Chiudi le preferenze

en: `M-{` - Switch buffer to the left
it: `M-{` - Sposta il buffer a sinistra

en: `M-}` - Switch buffer to the right
it: `M-}` - Sposta il buffer a destra

en: `S-M-0` - Switch to buffer 0
it: `S-M-0` - Passa al buffer 0

en: `S-M-1` - Switch to buffer 1
it: `S-M-1` - Passa al buffer 1

en: `S-M-9` - Switch to buffer 9
it: `S-M-9` - Passa al buffer 9

en: `M-+` - Increase text size of current buffer
it: `M-+` - Ingrandisci la dimensione carattere del buffer corrente

en: `M--` - Decrease text size of current buffer
it: `M--` - Diminuisci la grandezza dei caratteri nel buffer corrente

en: Selection/Copy/Paste
it: Selezione/Copia/Incolla

en: `M-a` - Select all
it: `M-a` - Seleziona tutto

en: `M-c` - Copy selection to paste buffer
it: `M-c` - Copia

en: `M-]` - Copy selection to paste buffer
it: `M-]` - Copia

en: `M-x` - Cut selection to paste buffer
it: `M-x` - Taglia

en: `C-]` - Cut selection to paste buffer
it: `C-]` - Taglia

en: `C-k` - Cut to the end of the line
it: `C-k` - Taglia fino alla fine della riga

en: `M-v` - Paste from paste buffer to editor
it: `M-v` - Incolla

en: `C-y` - Paste from paste buffer to editor
it: `C-y` - Incolla

en: `C-SPACE` - Set mark. Navigation will now manipulate highlighted region. Use `C-g` to escape.
it: `C-SPACE` - Imposta un segnalibro. La navigazione controllerà la regione selezionata. Premi `C-g` per uscire.

en: Text Manipulation
it: Controllo del testo

en: `M-m` - Align all text
it: `M-m` - Allinea il testo

en: `Tab` - Align current line or selection (or select autocompletion)
it: `Tab` - Allinea la linea corrente (oppure seleziona l'autocompletamento)

en: `C-l` - Centre editor
it: `C-l` - Centra l'editor

en: `M-/` - Comment/Uncomment current line or selection
it: `M-/` - Commenta/Scommenta la linea corrente

en: `C-t` - Transpose/swap characters
it: `C-t` - Trasponi/scambia caratteri

en: `M-u` - Convert next word (or selection) to upper case.
it: `M-u` - Converti la parola successiva in maiuscolo.

en: `M-l` - Convert next word (or selection) to lower case.
it: `M-l` - Converti la parola successiva in minuscolo.

en: `C-a` - Move to beginning of line
it: `C-a` - Spostati all'inizio della riga

en: `C-e` - Move to end of line
it: `C-e` - Spostati alla fine della riga

en: `C-p` - Move to previous line
it: `C-p` - Spostati alla linea precedente

en: `C-n` - Move to next line
it: `C-n` - Spostati su quella successiva

en: `C-f` - Move forward one character
it: `C-f` - Spostati avanti di un carattere

en: `C-b` - Move backward one character
it: `C-b` - Spostati indietro di un carattere

en: `M-f` - Move forward one word
it: `M-f` - Spostati avanti di una parola

en: `M-b` - Move backward one word
it: `M-b` - Spostati indietro di una parola

en: `C-M-n` - Move line or selection down
it: `C-M-n` - Sposta linea o selezione in basso

en: `C-M-p` - Move line or selection up
it: `C-M-p` - Sposta linea o selezione in alto

en: `S-M-u` - Move up 10 lines
it: `S-M-u` - Spostati in su di 10 righe

en: `S-M-d` - Move down 10 lines
it: `S-M-d` - Spostati in giù di 10 righe

en: `M-<` - Move to beginning of buffer
it: `M-<` - Spostati all'inizio del buffer

en: `M->` - Move to end of buffer
it: `M->` - Spostati alla fine del buffer

en: Deletion
it: Cancellazione

en: `C-h` - Delete previous character
it: `C-h` - Cancella il carattere precedente

en: `C-d` - Delete next character
it: `C-d` - Cancella il carattere successivo

en: Advanced Editor Features
it: Caratteristiche avanzate dell'Editor

en: `C-i` - Show docs for word under cursor
it: 'C-i' - Mostra i documenti collegati alla parola dove si trova il cursore

en: `M-z` - Undo
it: 'M-z' - Annulla

en: `S-M-z` - Redo
it: 'S-M-z' - Torna indietro dopo l'annullamento

en: `C-g` - Escape
it: 'C-g' - Esci

en: `S-M-f` - Toggle fullscreen mode
it: 'S-M-f - Avvia la modalità a schermo intero

en: `S-M-b` - Toggle visibility of buttons
it: 'S-M-b' - Attiva la visibilità dei bottoni

en: `S-M-l` - Toggle visibility of log
it: 'S-M-l' - Rende visibile la finestra di log

en: `S-M-m` - Toggle between light/dark modes
it: 'S-M-m' - Passa dall'interfaccia scura a quella chiara e viceversa

en: `S-M-s` - Save contents of buffer to a file
it: `S-M-s` - Salva il contenuto del buffer in un file

en: `S-M-o` - Load contents of buffer from a file
it: `S-M-o` - Carica il contenuto del buffer da un file

en: Sharing
it: Condivisione

en: Sonic Pi is all about sharing and learning with each other.
it: Sonic Pi è molto incentrato sulla condivisione e sull'apprendimento in compagnia.

en: Once you've learned how to code music, sharing your compositions is as simple as sending an email containing your code. Please do *share* your code with others so they can *learn* from your work and even use parts in a new *mash-up*.
it: Una volta che avrai imparato a codificare la musica, condividere le tue composizioni sarà semplice come mandare delle email contenenti il tuo programma. Per favore, condividi il tuo codice con gli altri in modo tale da fagli imparare dal tuo lavoro e anche riutilizzarne delle parti all'interno di nuovi brani.

en: If you're unsure of the best way to share your work with others I recommend putting your code on [GitHub](https://github.com) and your music on [SoundCloud](https://soundcloud.com). That way you'll be able to easily reach a large audience.
it: Se non sai quale sia il modo migliore per condividere il tuo lavoro con gli/le altri/e, ti consiglio di metterlo su [GitHub](https://github.com). La tua musica invece può essere messa su [SoundCloud](https://soundcloud.com). In questo modo potrai raggiungere facilmente un pubblico molto vasto.

en: Code -> GitHub
it: Codice -> GitHub

en: [GitHub](https://github.com) is a site for sharing and working with code. It's used by professional developers as well as artists for sharing and collaborating with code. The simplest way to share a new piece of code (or even an unfinished piece) is to create a [Gist](https://gist.github.com). A [Gist](https://gist.github.com) is a simple way of uploading your code in a simple way that others can see, copy and share.
it: [GitHub](https://github.com) è un sito per condividere e lavorare sul codice. E' utilizzato da sviluppatori professionisti ma anche da artisti per condividere e collaborare. Il modo più semplice per condividere un nuovo programma (anche un brano non completo) è quello di creare una [Gist](https://gist-github.com). [Gist](https://gist.github.com) è un modo facile di caricare il tuo codice in un modo che gli altri possano vederlo, copiarlo e condividerlo a loro volta.

en: Audio -> SoundCloud
it: Musica -> SoundCloud

en: Another important way of sharing your work is to record the audio and upload it to [SoundCloud](https://soundcloud.com). Once you've uploaded your piece, other users can comment and discuss your work. I also recommend placing a link to a [Gist](https://gist.github.com) of your code in the track description.
it: Un altro modo in cui puoi condividere il tuo lavoro è di registrare l'audio e di caricarlo su [SoundCloud](https://soundcloud.com). Una volta che avrai caricato il tuo brano, gli altri utenti possono commentarlo. Ti raccomando di mettere un collegamento al tuo [Gist](https://gist.github.com) nella descrizione del brano.

en: To record your work, hit the `Rec` button in the toolbar, and recording starts immediately. Hit `Run` to start your code if it isn't already in progress. When you're done recording, press the flashing `Rec` button again, and you'll be prompted to enter a filename. The recording will be saved as a WAV file, which can be edited and converted to MP3 by any number of free programs (try Audacity for instance).
it: Per registrare il tuo lavoro, premi il tasto 'Rec' in alto e la registrazione comincerà immediatamente. Premi anche 'Run' per iniziare a suonare, se non l'hai già fatto. Quando hai finito di registrare, basta semplicemente premere nuovamente il bottone lampeggiante 'Rec' e ti apparirà una piccola finestra per inserire il nome desiderato. Il brano sarà salvato in formato WAV, che poi può essere modificato e convertito in MP3. Ci sono molti programmi validi e gratuiti per far questo (prova Audacity per esempio).

en: Hope
it: Speranza

en: I encourage you to share your work and really hope that we'll all teach each other new tricks and moves with Sonic Pi. I'm really excited by what you'll have to show me.
it: Ti incoraggio a condividere il tuo lavoro e spero veramente che riusciremo a insegnarci l'un l'altro nuove scorciatoie e tecniche per utilizzare Sonic Pi. Sono molto ansioso di vedere cosa mi vorrai mostrare.

en: Performing
it: Suonare dal vivo

en: One of the most exciting aspects of Sonic Pi is that it enables you to use code as a *musical instrument*. This means that writing code live can now be seen as a new way of performing music.
it: Uno degli aspetti più eccitanti di Sonic Pi è che ti permette di usare il codice come *uno strumento musicale*. Questo significa che scrivere codice live può essere visto come un modo nuovo di esibirsi.

en: We call this *Live Coding*.
it: Noi lo chiamiamo *Live Coding*.

en: Show Your Screen
it: Mostra lo schermo

en: When you live code I recommend you *show your screen* to your audience. Otherwise it's like playing a guitar but hiding your fingers and the strings. When I practice at home I use a Raspberry Pi and a little mini projector on my living room wall. You could use your TV or one of your school/work projectors to give a show. Try it, it's a lot of fun.
it: Quando programmi live, ti consiglio di *mostrare lo schermo* al tuo pubblico. Altrimenti sarebbe come suonare la chitarra nascondendo le dita. Quando faccio pratica, uso un Raspberry Pi con collegato un piccolo proiettore in salotto. Puoi usare la TV o un proiettore per fare il tuo show. Provaci, è molto divertente.

en: Form a Band
it: Forma una band

en: Don't just play on your own - form a live coding band! It's a lot of fun jamming with others. One person could do beats, another ambient background, etc. Use the `live_audio` functionality to combine code with traditional instruments such as a guitar or a microphone.
it: Non limitarti a suonare da solo: forma una band di programmazione dal vivo! È molto divertente suonare con gli altri. Una persona potrebbe suonare ritmi, un'altra sottofondo ambientale, ecc. Usa la funzionalità `live_audio` per combinare il codice con strumenti tradizionali come una chitarra o un microfono.

en: See what interesting combinations of sounds you can create with code.
it: Guarda quali combinazioni di suoni interessanti puoi creare col codice di programmazione.

en: Live coding isn't completely new - a small number of people have been doing it for a few years now, typically using bespoke systems they've built for themselves. A great place to go and find out more about other live coders and systems is [TOPLAP](http://toplap.org).
it: La programmazione live non è un concetto nuovo: un piccolo gruppo di persone lo fa da anni (usando sistemi costruiti su misura). Un ottimo posto per scoprire di più è [TOPLAP](http://toplap.org).

en: Another great resource for exploring the live coding world is [Algorave](http://algorave.com). Here you can find all about a specific strand of live coding for making music in nightclubs.
it: Un'altra importante risorsa per esplorare il live coding è il mondo degli [Algorave](http://algorave.com). Sul sito puoi trovare tutte le informazioni su eventi di live coding in locali.
