9.1 Fondamenti di live coding

# Programmare dal vivo

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:

* Essere capaci di scrivere codice che genera suoni.
* Essere capaci di scrivere funzioni.
* Essere capaci di utilizzare thread (con nomi).

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:

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

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.

Qui abbiamo la definizione di una funzione che suona la nota 50 e si ferma per un battito. Dopodiché definiamo un thread chiamato `:looper`che non fa altro che ripetersi chiamando `my_loop`.

Se riproduci questo codice, sentirai la nota 50 ripetersi...

## Facciamo dei cambiamenti

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!

Non ha aggiunto un nuovo livello perché utilizziamo thread con un nome ed è possibile avere un solo thread per ciascun nome. Inoltre il suono cambia perché *ridefiniamo* la funzione. Abbiamo dato a `:my_loop` una nuova definizione. Quando il thread `:looper` si ripete, semplicemente chiama una nuova definizione.

Prova a cambiarlo ancora, cambia la nota, cambia il tempo di pausa. E se aggiungessimo `use_synth`? Per esempio cambiamolo in:

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

Ora comincia a diventare interessante, ma possiamo renderlo ancora meglio. Invece di suonare sempre la stessa nota, suoniamo un accordo:

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

Perché non suonare note casuali prese dall'accordo:

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

O usando un valore casuale per il cutoff:

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

Infine, aggiungiamo un po' di batteria:

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

Ora si che sta diventando interessante!

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