9.1 Fundamentos do Live coding

# Live Coding

Agora aprendemos o suficiente para começar a ter alguma diversão. Nesta secção iremos buscar de todas as outras secções e mostrar em como podes começar a fazer composições musicais ao vivo tornando-as numa performance. Necessitamos 3 ingredientes principais para isso:

* A habilidade de escrever código que gera som - CHECK!
* Uma habilidade de escrever funções - CHECK!
* A habilidade de usar threads (nomeados) - CHECK!

Muito bem, vamos começar. Vamos codificar os nossos primeiros sons. Primeiro necessitamos de uma função contendo o código que queremos tocar. Vamos começar simples. Também queremos num loop chamar essa função num thread:

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

Se isto te parece muito complicado para ti, volta a trás e relê a secção sobre funções e threads. Não é muito complicado se já dominares estas coisas.

O que temos aqui é uma definição de função que apenas toca a nota 50 e descansa por um beat. Depois definimos um thread chamado `:looper` que em loop chama `my_loop`repetidamente.

Se correres este código, ouvirás a nota 50 repetidamente uma e outra vez...

## Fazendo alterações

Agora é quando o divertimento começa. Enquanto o código *está a correr* muda o 50 para outro número, talvez 55, depois prime o botão Run outra vez. WOW! Mudou! Em directo!

Não adicionou uma nova camada porque estamos a usar um thread com nome que apenas permite um thread para cada nome. Também o som mudou porque redefinimos a função. Demos a `:my_loop`uma nova definição. Quando o thread `:looper` repetiu simplesmente chamou a nova definição.

Experimenta mudar novamente, muda a nota, muda o tempo de descanso. Que tal adicionar uma definição `use_synth`? Por exemplo muda para:

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

Agora soa bastante interessante, mas podemos apimentar as coisas. Em vez de tocar a mesma nota uma e outra vez, tenta tocar um acorde:

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

Que tal tocar notas ao acaso do acorde:

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

Ou usar um valor de cutoff aleatório:

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

Finalmente, adiciona alguma bateria:

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

Agora as coisas estão a ficar excitantes!

No entanto, antes de saltares e começares a codificar ao vivo com funções e threads, pára o que estas a fazer e lê a próxima secção sobre `live_loop` que irá mudar a forma como escreves código no Sonic Pi para sempre...
