9.1 Live-Coding: Grundlagen

# Live-Coding

Inzwischen haben wir genug gelernt, um tatsächlich mit dem Spaß anzufangen. In diesem Abschnitt verwenden wir alles, was wir in den vorherigen Abschnitten behandelt haben und zeigen dir, wie du damit beginnen kannst, deine Musik live zu komponieren und in eine Performance zu verwandeln. Dazu benötigen wir 3 wesentliche Zutaten:

* Die Fähigkeit Programm-Code zu schreiben, der Klänge erzeugt - CHECK!
* Die Fähigkeit Funktionen zu schreiben - CHECK!
* Die Fähigkeit Threads (mit Namen) zu verwenden - CHECK!

Ok, lass uns loslegen. Lass uns unsere ersten Klänge live programmieren. Zuerst brauchen wir eine Funktion, die den abzuspielenden Code enthält. Lass uns einfach beginnen. Außerdem wollen wir Aufrufe an diese Funktion in einer Schleife in einem Thread ausführen:

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

Wenn dir das ein bisschen zu kompliziert vorkommt, lies bitte noch einmal die Abschnitte über Funktionen und Threads durch. Es ist nicht mehr so kompliziert, wenn du sie erstmal verstanden hast.

Was wir hier haben, ist die Definition einer Funktion, welche einfach die Note 50 spielt und danach einen Schlag lang schläft. Dann definieren wir einen Thread (mit Namen) - wir nennen ihn `:looper`- und er ruft in einer Schleife `my_sound` auf.

Wenn du diesen Code ausführst, wirst du immer und immer wieder die Note 50 hören...

## Einen Gang hochschalten

Nun, hier fängt der Spaß an. Während der Code *noch läuft*, ändere die 50 in eine andere Zahl, sagen wir 55, und klicke nochmals auf `Ausführen`. Wow! Es hat sich geändert! Live!

Es hat keine neue Ebene hinzugefügt, da wir einen benannten Thread verwendet haben und es für jeden Namen nur einen Thread geben kann. Der Klang hat sich geändert, weil wir die Funktion *umdefiniert* haben. Wir haben also `:my_sound` eine neue Definition gegeben. Während im`:looper`-Thread die Schleife lief, hat er darin einfach die neue Definition aufgerufen.

Verändere die Definition der Funktion noch einmal, ändere die Note, ändere die Pausenzeit. Und wie wäre es eine `use_synth`-Aussage hinzuzufügen? Z. B. ändere die Funktion in:

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

Jetzt klingt es schon ganz interessant, wir können es aber noch ein bisschen interessanter machen. Anstatt immer wieder die gleiche Note zu spielen, versuche einen Akkord zu spielen:

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

Und wie wäre es damit, zufällige Töne des Akkords zu spielen:

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

Oder einen zufälligen Cut-Off-Wert:

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

Und schließlich, füge etwas Schlagzeug hinzu:

```
define :my_sound 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
```

Jetzt wird die Sache langsam aufregend!

Wie auch immer, bevor du jetzt aufspringst und anfängst mit Funktionen und Threads live zu programmieren, hör mit dem was du gerade machst auf und lies den nächsten Abschnitt über `live_loop` - das wird die Art wie du in Sonic Pi programmierst, für immer verändern ...
