capítulo 9

Author: thraex41

etc/doc/tutorial/es/08-Data-Structures.md

@@ -15,3 +15,9 @@ necesitamos considerar una estructura de datos muy sencilla - la lista.
 Mirémosla en mayor detalle. Cubriremos su forma básica y también el modo de
 utilizarlas para representar escalas y acordes.
 
+
+
+
+
+
+

etc/doc/tutorial/es/09-Live-Coding.md

@@ -0,0 +1,15 @@
+9 Live Coding
+
+# Live Coding
+
+Uno de los aspectos más excitantes de Sonic Pi es que permite escribir
+y modificar código 'al vuelo' para hacer música, así como harías con
+una guitarra. Una ventaja de esto es que te da más retroalimentación
+mientras compones (corre un bucle sencillo (juega con él hasta que sea
+perfecto). Sin embargo, la mayor ventaja es poder ejecutar Sonic Pi en
+vivo en escena.
+
+En esta sección cubriremos lo fundamental de tornar tu código estático de
+composiciones en ejecuciones dinámicas.
+
+¡Prepárate!

etc/doc/tutorial/es/09.1-Live-Coding-Fundamentals.md

@@ -0,0 +1,106 @@
+9.1 Fundamentos de Live Coding 
+
+# Live Coding
+
+Ya sabemos lo suficiente para comenzar a divertirnos en serio. En esta
+sección te mostraré cómo comenzar a crear composiciones musicales en vivo
+y convertirlas en ejecuciones. Para ello necesitamos 3 ingredientes:
+
+* Habilidad para escribir código que haga sonidos - CHECK!
+* Habilidad de escribir funciones - CHECK!
+* Hbilidad de usar hilos (nominales) - CHECK!
+
+¡Muy bien, comencemos! Hagamos nuestros primeros sonidos de códigos en vivo
+Primero necesitamos una función conteniendo el código que necesitamos tocar
+Comencemos con algo simple. También necesitamos llamadas en bucle a esa 
+función en un hilo:
+```
+define :my_loop do
+  play 50
+  sleep 1
+end
+
+in_thread(name: :looper) do
+  loop do
+    my_loop
+  end
+end
+```
+
+Si te parece complicado, vuelve a leer las secciones de funciones e hilos.
+No es tan complicado una vez entiendes bien esos conceptos.
+
+Lo que tenemos es una función que toca la nota 50 y duerme por un pulso. 
+Después definimos un hilo llamado `:looper` que bucle llamando `my_loop` 
+repetidamente.
+
+Si corres este código, escucharás la nota 50 una y otra vez...
+
+## ¡Cambiandolo al vuelo!
+
+Aquí es donde comienza la diversión. Mientras el código *aún corre*
+cambia 50 a otro número, digamos 55, y presiona Run otra vez. ¡Woah!
+¡cambió en vivo!
+
+No añadió una nueva capa porque usamos hilos nombrados, los que sólo 
+permiten un hilo por cada nombre. El sonido cambió porque *redefinimos*
+la función. LE dimos a `:my_loop`una nueva definición. CUando el hilo
+`:looper` bucleó, simplemente llamó la nueva definición.
+
+Sigue cambiándolo, cambia la nora, el tiempo de pausa. ¿qué tal añadir un
+`use_synth`? Por ejemplo, esto:
+
+```
+define :my_loop do
+  use_synth :tb303
+  play 50, release: 0.3
+  sleep 0.25
+end
+```
+Ahora suena interesante, pero podemos mejorarlo, aún. En vez de tocar la
+misma nota, hagámoslo con un acorde:
+
+```
+define :my_loop do
+  use_synth :tb303
+  play chord(:e3, :minor), release: 0.3
+  sleep 0.5
+end
+```
+
+¿tocamos notas del acorde al azar?:
+
+```
+define :my_loop do
+  use_synth :tb303
+  play choose(chord(:e3, :minor)), release: 0.3
+  sleep 0.25
+end
+```
+
+o usando un valor de corte al azar:
+
+```
+define :my_loop do
+  use_synth :tb303
+  play choose(chord(:e3, :minor)), release: 0.2, cutoff: rrand(60, 130)
+  sleep 0.25
+end
+```
+
+Al final, añadamos un poco de batería:
+
+```
+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
+```
+
+¡Ahora está volviéndose excitante! 
+
+Sin embargo, antes de saltar y comenzar a Live Coding con funciones e 
+hilos, lee la próxima sección sobre `live_loop` que cambiará la manera 
+en la que codifiques con Sonic Pi para siempre...

etc/doc/tutorial/es/09.2-Live-Loops.md

@@ -0,0 +1,74 @@
+9.2 Bucles en Vivo
+
+# Bucles en Vivo 
+
+Bien, ésta sección del tutorial es la joya de la corona. Si leyeses
+sólo una sección, debería ser ésta. Si leíste la sección previa sobre
+los Fundamentos de Live Coding, `live_loop` es una manera simple de
+hacer exactamente eso, pero sin tener que escribir tanto.
+
+Si no leíste la sección anterior, `live_loop` es como mejor se puede
+tocar con Sonic Pi.
+
+Toquemos algo. Escribe el siguiente código en un buffer nuevo:
+
+```
+live_loop :foo do
+  play 60
+  sleep 1
+end
+```
+
+Presiona el botón de Run. Escucharás un beep básico en cada pulso. Nada
+muy divertido en ello. Sin embargo, todavía no presiones Stop. Cambia
+el `60` a `65` y presiona otra vez Run.
+
+¡Woah Se cambió automáticamente sin perder un tan sólo pulso!¡Esto es Live
+Coding!
+
+Hagámoslo más a bajo, sólo cambiemos el código un poco:
+```
+live_loop :foo do
+  use_synth :prophet
+  play :e1, release: 8
+  sleep 8
+end
+```
+
+Ahora aprieta Run 
+
+Movamos el punto de corte:
+
+```
+live_loop :foo do
+  use_synth :prophet
+  play :e1, release: 8, cutoff: rrand(70, 130)
+  sleep 8
+end
+```
+
+Presiona Run otra vez.
+
+Añadamos baterías:
+
+```
+live_loop :foo do
+  sample :loop_garzul
+  use_synth :prophet
+  play :e1, release: 8, cutoff: rrand(70, 130)
+  sleep 8
+end
+```
+Cambiemos la nota de `e1` a `c1`:
+
+```
+live_loop :foo do
+  sample :loop_garzul
+  use_synth :prophet
+  play :c1, release: 8, cutoff: rrand(70, 130)
+  sleep 8
+end
+```
+
+Ahora deja de leerme y cambia lo que quieras por tu cuenta.
+¡Diviértete!

etc/doc/tutorial/es/09.3-Multiple-Live-Loops.md

@@ -0,0 +1,95 @@
+9.3 Múltiples Bucles en Vivo
+
+# Múltiples Bucles en Vivo 
+
+Considera el siguiente bucle en vivo:
+
+```
+live_loop :foo do
+  play 50
+  sleep 1
+end
+```
+Quizás te preguntas el por qué es importante el nombre `foo`, la respuesta
+es que es importante porque significa que este bucle es diferente de TODOS
+los otros.
+
+*Nunca pueden haber dos bucles en vivo con el mismo nombre ejecutándose
+simultáneamente* 
+
+Esto significa que si queremos múltiples bucles concurrentes, debemos darles
+diferentes nombres:
+
+```
+live_loop :foo do
+  use_synth :prophet
+  play :c1, release: 8, cutoff: rrand(70, 130)
+  sleep 8
+end
+
+live_loop :bar do
+  sample :bd_haus
+  sleep 0.5
+end
+```
+
+Ahora puedes actualizar y cambiar cada bucle independientemente y
+funcionará siempre.
+
+## Sincronizando bucles en vivo
+
+Una cosa que ya habrás notado es que los bucles en vivo trabajan
+automáticamente automáticamente con el mecanismo de marca de hilos
+que exploramos anteriormente. Cada bucle en vivo genera un evento `cue`
+Gracias a ello podemos sincronizarlos para asegurar bucles sin pausa.
+
+Considera este código mal sincronizado:
+
+```
+live_loop :foo do
+  play :e4, release: 0.5
+  sleep 0.4
+end
+
+live_loop :bar do
+  sample :bd_haus
+  sleep 1
+end
+```
+
+Veamos si podemos arreglar el timing y sincronizar sin parar. Primero,
+arreglemos el bucle `:foo` para hacer el factor de sleep 1 a algo como
+`0.5`:
+
+```
+live_loop :foo do
+  play :e4, release: 0.5
+  sleep 0.5
+end
+
+live_loop :bar do
+  sample :bd_haus
+  sleep 1
+end
+```
+
+Todavía no terminamos, pues notarás que los pulsos no se alinean correctamente.
+Esto se debe a que los bucles están desfasados *out of phase*. Arreglemos Esto
+sincronizándolos entre sí:
+
+```
+live_loop :foo do
+  play :e4, release: 0.5
+  sleep 0.5
+end
+
+live_loop :bar do
+  sync :foo
+  sample :bd_haus
+  sleep 1
+end
+```
+
+¡Wow, todo está sincronizado ahora y sin parar!
+
+¡Ahora ve y codifica en vivo con bucles en vivo!