chapter 3

added chapter 3 and a modification on Welcome page

etc/doc/tutorial/it/01-Welcome-to-Sonic-Pi.md

@@ -1,6 +1,6 @@
 1 Benvenuto in Sonic Pi
 
-# Benvenuto amico :-)
+# Benvenuto :-)
 
 Benvenuto in Sonic Pi. Probabilmente non vedi l'ora di cominciare a fare strani 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.
 

etc/doc/tutorial/it/03-Samples.md

@@ -0,0 +1,7 @@
+3 Campioni
+
+# Campioni (Samples)
+
+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.
+
+Con Sonic Pi puoi fare un sacco di cose divertenti coi campioni. Non solo ci trovi più di 90 campioni di pubblico dominio, pronti per i tuoi mix, ma ti permette anche di suonare e trasformare quelli creati da te. Vediamo subito come...

etc/doc/tutorial/it/03.1-Triggering-Samples.md

@@ -0,0 +1,50 @@
+3.1 Suonare i campioni
+
+# Suonare i campioni
+
+Fare i beep è soltanto l’inizio. Una cosa molto divertente è suonare campioni pre-registrati. Prova questo:
+
+```
+sample :ambi_lunar_land
+```
+
+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:
+
+```
+play 36
+play 48
+sample :ambi_lunar_land
+sample :ambi_drone
+```
+
+Se vuoi distribuirli nel tempo, usa l’istruzione `sleep`:
+
+```
+sample :ambi_lunar_land
+sleep 1
+play 48
+sleep 0.5
+play 36
+sample :ambi_drone
+sleep 1
+play 36
+```
+
+Hai notato come Sonic Pi non aspetta la fine di un suono per farne partire un altro? L’istruzione `sleep` determina solo la separazione degli *attacchi* dei suoni. Questo ti permette di sovrapporre facilmente i suoni creando interessanti effetti d’insieme. Più avanti nel tutorial vedremo come controllare la *durata* dei suoni con gli inviluppi.
+
+## Scopriamo i campioni
+
+Ci sono due modi per esplorare la varietà di campioni forniti da Sonic Pi. Primo, puoi usare l’help del programma. Fai click su *Samples* nel menu verticale in basso a sinistra, scegli la categoria e lì vedrai la lista dei suoni disponibili.
+
+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: 
+
+* `:ambi_` 
+* `:bass_`
+* `:elec_`
+* `:perc_`
+* `:guit_`
+* `:drum_`
+* `:misc_`
+* `:bd_`
+
+Ora puoi cominciare a mixare campioni per realizzare le tue composizioni!

etc/doc/tutorial/it/03.2-Sample-Params.md

@@ -0,0 +1,27 @@
+3.2 I parametri dei campioni
+
+# I parametri dei campioni: Amp e Pan
+
+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:`.
+
+## Regolare l’ampiezza dei campioni
+
+Puoi cambiare l’ampiezza dei campioni con lo stesso sistema che hai usato per i synth:
+
+```
+sample :ambi_lunar_land, amp: 0.5
+```
+
+## Il panning dei campioni
+
+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:
+
+```
+sample :loop_amen, pan: -1
+sleep 0.877
+sample :loop_amen, pan: 1
+```
+
+Osserva che  0.877 è metà della durata in secondi del campione `:loop_amen`.
+
+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`.

etc/doc/tutorial/it/03.3-Stretching-Samples.md

@@ -0,0 +1,86 @@
+3.3 Stretching dei campioni
+
+# Stretching dei campioni
+
+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.
+
+## Rappresentazione dei campioni
+
+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.
+
+## Cambiare la velocità
+
+Proviamo a suonare uno dei nostri suoni *ambient*: `:ambi_choir`. Per suonarlo alla velocità di default, puoi passare un argomento `rate:` all’istruzione `sample:`
+
+```
+sample :ambi_choir, rate: 1
+```
+
+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. Che ne dici di `0.5:`?
+
+```
+sample :ambi_choir, rate: 0.5
+```
+
+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.
+
+## Stretchiamo!
+
+Un campione divertente da stirare e comprimere è il loop di batteria *Amen*. A velocità normale, potremmo immaginare di buttarlo dentro una traccia *drum’n bass*:
+
+```
+sample :loop_amen
+```
+
+Ma, cambiando la velocità, ecco che possiamo anche cambiare genere. Proviamo a mezza velocità per un *hip-hop* vintage:
+
+```
+sample :loop_amen, rate: 0.5
+```
+
+Se aumentiamo la velocità, entriamo nel territorio del *jungle*:
+
+```
+sample :loop_amen, rate: 1.5
+```
+
+Adesso, come ultimo effetto a sorpresa, vediamo che succede se usiamo una velocità negativa:
+
+```
+sample :loop_amen, rate: -1
+```
+
+Wow! Suona *al contrario*! Proviamo a suonare molti campioni diversi a velocità diverse. Provatene di molto veloci o di lentissime. Guarda che suoni interessanti puoi creare.
+
+## Una semplice spiegazione della velocità di lettura del campione.
+
+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.
+
+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ù basso*.
+
+
+## La matematica della velocità di lettura del campione.
+
+(Questa parte è per quelli che sono interessati ai dettagli. Sentitevi liberi di saltarla…)
+
+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:
+
+![sample graph](../images/tutorial/sample.png)
+
+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.
+
+La durata di un campione dipende dalla velocità di lettura del dato digitale:
+
+* Raddoppiare la velocità dimezza la durata,
+* Dimezzare la velocità raddoppia la durata,
+* Usare una velocità di lettura di un quarto quadruplica la durata,
+* Usare una velocità di 1/10 rende la durata 10 volte più lunga.
+
+```
+new_sample_duration = (1 / rate) * sample_duration 
+```
+
+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.
+
+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.
+

etc/doc/tutorial/it/03.4-Enveloped-Samples.md

@@ -0,0 +1,90 @@
+3.4 Campioni inviluppati
+
+# Campioni inviluppati
+
+È 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.
+
+## Inviluppare il campione Amen
+
+Torniamo al nostro amico fidato, il loop di batteria Amen:
+
+```
+sample :loop_amen
+```
+
+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):
+
+```
+sample :loop_amen, attack: 1
+```
+
+Per un fade-in più corto, impostiamo un tempo di attacco più corto:
+
+```
+sample :loop_amen, attack: 0.3
+```
+
+## Auto sustain
+
+
+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.
+
+## Fade out (dissolvenza in uscita)
+
+Per esaminare questo aspetto, consideriamo il nostro loop Amen più in dettaglio. Se chiediamo a Sonic Pi quanto dura il campione:
+
+```
+print sample_duration :loop_amen
+```
+
+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:
+
+```
+sample :loop_amen, release: 0.75
+```
+
+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.
+
+Ricorda: di default il tempo di rilascio va contato dalla fine del campione.
+
+## Fade in e fade out (dissolvenza in entrata e in uscita)
+
+Possiamo usare insieme sia `attack:` che `release:` con l’autosustain per avere sia il fade in che il fade out sulla durata del campione:
+
+```
+sample :loop_amen, attack: 0.75, release: 0.75
+```
+
+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à.
+
+## Sustain esplicito
+
+Possiamo benissimo tornare al comportamento normale dell’ADSR dei synth impostando `sustain:` manualmente su un valore, ad esempio 0:
+
+```
+sample :loop_amen, sustain: 0, release: 0.75
+```
+
+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.
+
+## Piatti...percussivi 
+
+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`:
+
+```
+sample :drum_cymbal_open
+```
+
+Puoi sentire il suono del piatto riusuonare per un certo tempo. Tuttavia, possiamo usare il nostro inviluppo per rendere il suono più percussivo:
+
+```
+sample :drum_cymbal_open, attack: 0.01, sustain: 0, release: 0.1
+```
+
+Puoi emulare il colpo di piatto e il successivo smorzamento aumentando il tempo di sostegno: 
+```
+sample :drum_cymbal_open, attack: 0.01, sustain: 0.3, release: 0.1
+```
+
+E adesso divertiti ad applicare gli inviluppi ai campioni. Prova a cambiare anche la velocità di lettura per risultati davvero interessanti.

etc/doc/tutorial/it/03.5-Partial-Samples.md

@@ -0,0 +1,86 @@
+3.5 Esecuzione parziale dei campioni
+
+# Esecuzione parziale dei campioni
+
+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:
+
+```
+sample :loop_amen
+```
+
+Quindi abbiamo visto come cambiare la velocità di lettura dei campioni in modo da farli suonare a velocità dimezzata:
+
+```
+sample :loop_amen, rate: 0.5
+```
+
+Abbiamo visto come inserire un fade-in all’inizio del campione (ora facciamolo a velocità dimezzata):
+
+```
+sample :loop_amen, rate: 0.5, attack: 1
+```
+
+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:
+
+```
+sample :loop_amen, rate: 2, attack: 0.01, sustain: 0, release: 0.35
+```
+
+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?
+
+## Scegliere il punto d’inizio
+
+È 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:
+
+```
+sample :loop_amen, start: 0.5
+```
+
+Ed ecco l’ultimo quarto soltanto:
+
+```
+sample :loop_amen, start: 0.75
+```
+
+## Scegliere il punto finale
+
+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:
+
+```
+sample :loop_amen, finish: 0.5
+```
+
+## Specificare un punto d’inizio e un punto finale
+
+È 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:
+
+```
+sample :loop_amen, start: 0.4, finish: 0.6
+```
+
+Ma cosa succede se scegliamo un punto d’inizio collocato dopo il punto finale?
+
+```
+sample :loop_amen, start: 0.6, finish: 0.4
+```
+
+Forte! Suona all’indietro!
+
+## Combinare velocità di lettura ed esecuzione parziale del campione
+
+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:
+
+```
+sample :loop_amen, start: 0.5, finish: 0.7, rate: 0.2
+```
+
+## Combinare inviluppi ed esecuzione parziale del campione
+
+
+Possiamo infine combinare tutto questo con gli inviluppi ADSR per ottenere risultati interessanti:
+
+```
+sample :loop_amen, start: 0.5, finish: 0.8, rate: -0.2, attack: 0.3, release: 1
+```
+
+E ora sbizzarriamoci a creare mix di campioni manipolati in tutti questi fantastici modi...