# 1 - Bienvenido amigo :-)

Bienvenido a Sonic Pi. Espero que estés tan emocionado por comenzar a hacer tus propios sonidos como yo lo estoy de enseñarte a hacerlos. Será realmente divertido. Aprenderás sobre música, síntesis, programación, composición, interpretación y mucho más.

Pero espera, ¡qué maleducado soy! Deja que me presente - soy Sam Aaron - el creador de Sonic Pi. Puedes encontrarme en Twitter @samaaron y estaré encantado de saludarte. Quizás te interese saber más de mis Performances de Live Coding donde programo en vivo y en directo con Sonic Pi.

Si tienes algunas observaciones o ideas para mejorar Sonic Pi - por favor pásamelas -, los comentarios son bienvenidos. Nunca se sabe, ¡tu idea podría ser incluida como una importante funcionalidad!

Este tutorial está dividido en secciones agrupadas por categoría. Lo he escrito para tener una fácil progresión de principio a fin, siéntete libre de saltar de una sección a otra cuanto te apetezca. Si piensas que hay algo que falta, házmelo saber y lo tendré en cuenta para versiones futuras.

Por último, observar a otros haciendo live-coding es una excelente manera de aprender. Yo lo hago regularmente en directo por https://youtube.com/samaaron, así que pásate por allí, salúdame y hazme muchas preguntas :-)

OK, comencemos…

# 1.1 - Live Coding (Programación en vivo)

Uno de los aspectos más excitantes de Sonic Pi es la posibilidad de escribir y modificar código para hacer música en directo, como lo harías al tocar una guitarra. Esto significa que con algo de práctica podrás usar Sonic Pi en directo.

## Abre tu mente

Antes de entrar en detalle de cómo funciona Sonic Pi, me gustaría enseñarte que es programar en directo. No te preocupes si no entiendes mucho (o nada) de esto. Simplemente siéntate y disfruta …

## Un Bucle en Vivo

Para empezar, copia el siguiente código en un buffer vacío:

    live_loop :flibble do
      sample :bd_haus, rate: 1
      sleep 0.5
    end

Ahora, presiona el botón “Ejecutar” y escucharás una batería con un ritmo rápido. Si en cualquier momento deseas parar el sonido, sólo debes presionar el botón “Parar”. Pero no lo pares, aún… antes sigue los siguientes pasos:

1. Asegúrate que el sonido de batería sigue sonando
2. Cambia el valor “sleep” de “0.5” a algo más alto, por ejemplo “1”.
3. Presiona de nuevo el botón “Ejecutar”
4. Fíjate como ha cambiado la velocidad del bombo.
5. Por último, recuerda este momento, esta es la primera vez que has programado en tiempo real con Sonic Pi y seguro que no será la última…

Ok, eso fue fácil. Añadamos algo a la mezcla. Encima de `sample :bd_haus` añade la línea `sample :ambi_choir, rate: 0.3`. Tu código debería ser así:

    live_loop :flibble do
      sample :ambi_choir, rate: 0.3
      sample :bd_haus, rate: 1
      sleep 1
    end

Ahora vamos a jugar. Cambia valores, ¿qué pasa cuando usas valores altos, bajos o negativos? Mira lo que pasa cuando cambias el valor `rate:` por `:ambi_choir` ajústalo mínimamente (digamos a 0.29). ¿Qué pasa si pones un valor muy bajo para `sleep`? prueba a hacerlo sonar tan rápido que tu computadora se cuelgue con un error (si eso sucede, simplemente elige un valor más alto para `sleep` y presiona `Ejecutar` de nuevo).

Intenta comentar una de las líneas del `sample`, añadiendo un `#` al comienzo:

    live_loop :flibble do
      sample :ambi_choir, rate: 0.3
    #  sample :bd_haus, rate: 1
      sleep 1
    end

¿Te das cuenta como le dice al ordenador que lo ignore, y así no lo oímos? Esto se llama “comentar”. En Sonic Pi podemos usar comentarios para quitar y añadir cosas a la mezcla.

Por último, te dejo con algo divertido con lo que jugar. Toma el siguiente código y cópialo en un buffer vacío. Por el momento no intentes comprender demasiado más que darte cuenta que hay dos bucles - lo que significa que hay dos eventos al mismo tiempo - experimenta y juega. Te dejo algunas sugerencias:

- Prueba cambiando el valor en azul de `rate:` para escuchar cambios en el sample.
- Prueba cambiando los tiempos de `sleep` y presta atención a cómo ambos bucles dan vueltas a diferentes valores.
- Oberva que pasa quitando el comentario de la línea de ejemplo (quita `#`) y disfruta del sonido de la guitarra tocada al revés.
- Prueba cambiar cualquiera de los valores azules `mix:` a números entre `0` (no en la mezcla) y `1` (totalmente en la mezcla).

Recuerda que debes presionar ‘Ejecutar’ para escuchar el cambio en el próximo bucle. Si termina siendo un lío, no te preocupes - dale a ‘Parar’, borra el código del buffer y pega una nueva copia del ejemplo para volver a empezar. Cometiendo errores es como aprenderás más rápidamente.

    live_loop :guit do
      with_fx :echo, mix: 0.3, phase: 0.25 do
        sample :guit_em9, rate: 0.5
      end
    #  sample :guit_em9, rate: -0.5
      sleep 8
    end
    live_loop :boom do
      with_fx :reverb, room: 1 do
        sample :bd_boom, amp: 10, rate: 1
      end
      sleep 8
    end

Ahora, sigue tocando y experimentando hasta despertar tu curiosidad y te preguntes qué más puedes hacer. Ya estás listo para leer el resto del tutorial.

¿A qué estás esperando?

# 1.2 - La interfaz de Sonic Pi

Sonic Pi tiene una interfaz sencilla para programar música. Echemos un vistazo a esto.

- A - Controles de Ejecución
- B - Controles de edición
- C - Información y Ayuda
- D - Editor de código
- E - Panel de Preferencias
- F - Visor de Registros
- G - Sistema de Ayuda
- H - Visor de Registros
- I - Visor de Cue

## A. Controles de Ejecución

Estos botones rosados son los principales controles para comenzar y parar sonidos. El botón de Ejecutar sirve para iniciar la ejecución del código y Parar para parar todo código en Ejecución, Guardar para guardar el código a un archivo externo y Grabar para crear una grabación (archivo WAV) de los sonidos ejecutándose.

## B. Controles de edición

Estos botones naranjas te permiten manipular el editor de código. Los botones de Tamaño + y Tamaño -* te permiten aumentar y disminuir el tamaño del texto.

## C. Información y Ayuda

Estos botones azules te dan acceso a información, ayuda y preferencias. El botón Info abre la ventana informativa, la cual contiene información del propio programa Sonic Pi - el equipo base, historia, contribuyentes y la comunidad. El botón de Ayuda muestra u oculta el sistema de ayuda y el botón Preferencias activa la ventana de preferencias, que te permite controlar algunos parámetros básicos del sistema.

## D. Editor de código

Esta es el área donde escribirás tu código y compondrás/ejecutarás música. Es un sencillo editor de texto donde puedes escribir, borrar, cortar, pegar, etc. Piensa que es una versión simplificada de Word o Google Docs. El editor colorea las palabras automáticamente, basado en su significado para el código. Al principio, esto puede parecer extraño, pero pronto lo encontrarás muy útil. Por ejemplo, sabrás que algo es un número, porque es de color azul.

## E. Panel de Preferencias

Sonic Pi permite cambiar ciertos parámetros accesibles a través del botón preferencias . Este botón cambia la visibilidad del panel de preferencias, el cual incluye un número de opciones a ser cambiadas. Por ejemplo forzar el modo mono, invertir el estéreo, cambiar a vista/no vista de la bitácora, mando de volumen y un selector de audio para la Raspberry Pi.

## F. Visor de Log

Cuando ejecutas un código, el visualizador del log muestra información de lo que está haciendo el programa. Predeterminado está el que veas un mensaje por cada sonido que crees con el tiempo exacto al que fue disparado el sonido. Esto es muy útil para depurar código y entender qué es lo que está haciendo.

## G. Sistema de ayuda

Finalmente, una de las partes más importantes de la interfaz de Sonic Pi es el sistema de ayuda que aparece en la parte baja de la ventana. Esta puede ser activada o desactivada al apretar el botón azul «Ayuda». El sistema de ayuda contiene información de todos los aspectos de Sonic Pi incluído este tutorial, listado de sintetizadores disponibles, muestras (samples), ejemplos, efectos y una lista de todas las funciones que Sonic Pi provee para codificar música.

## H. Visor Osciloscópico

El visor de alcance le permite ver el sonido que esta escuchando. Usted puede ver fácilmente que la onda de la sierra parece una sierra y que el pitido básico es una curva de onda senoidal. También puede ver la diferencia entre sonidos fuertes y silenciosos por el tamaño de las líneas. Hay 3 alcances para jugar - el defecto es un alcance combinado para los canales izquierdos y derechos, hay un alcance estéreo que dibuja un alcance separado para cada canal. Finalmente hay un alcance de curva Lissajous que mostrará la relación de fase entre los canales izquierdo y derecho y le permitirá dibujar imágenes bonitas con sonido (https://en.wikipedia.org/wiki/Lissajous_curve).

## I. Visor de Cue

Todos los eventos internos y externos (llamados cues en Sonic PI) son registrados automáticamente en el Visor Cue. Por ejemplo si tiene un controlador MIDI conectado y presione uno de sus botones, verá un nuevo evento cue en el Visor Cue que le dará el nombre del controlador y del botó que presionó. Una vez haya dominado lo básico de crear y producir sonidos, querrá registrar sonidos o selecciones completas de sonidos basado en eventos como esos. Un evento cue es solo una indicación de que ha ocurrido algo. Por ejemplo, cada vez que un ciclo vivo da la vuelta, envía un evento cue que es registrado en el Visor de Cue. También los eventos externos como mensajes MIDI de equipo MIDI conectado y mensajes OSC de otros programas o computadores se presentan en el Visor Cue. También es posible generar directamente eventos cue usando la función `cue`. Cualquier cosa que aparezca en el Visor Cue puede usarse para iniciar que algo ocurra. Esto se cubre en más detalle en la Secciones 10 a 12 de este tutorial.

# 1.3 - Aprender jugando

Sonic Pi te incita a aprender computación y música a través del juego y la experimentación. Lo más importante es que te diviertas y sin darte cuenta, estarás aprendiendo a programar, componer y reproducir.

## No hay errores

Hablando de eso, déjame darte un consejo, aprendido a través de mis años programando música en vivo: «no hay errores, sólo oportunidades». Esto es algo que he escuchado a menudo en relación al jazz, pero funciona igualmente bien en el live-coding. No importa lo experimentado que seas -de completo principiante a un experimentado Algoraver, alguna vez ejecutarás código que salga de manera inesperada. Puede que suene increíblemente bien, en cuyo caso continúa con él. O puede que suene mal o fuera de lugar. Pero no importa– Lo que importa es lo que hagas con él. Toma el sonido, manipúlalo y conviértelo en algo alucinante. El público se volverá loco.

## Inicio simple

Cuando estás aprendiendo es tentador querer hacer cosas ya. Sin embargo, mantén ese deseo como un objetivo para después. Por ahora, piensa en lo más simple que puedas escribir sea divertido y satisfactorio, que sea un simple paso para ese increíble objetivo que tienes en mente. Una vez tengas una idea de ese simple paso, intenta y constrúyelo, juega y mira qué nuevas ideas te trae. En poco tiempo estarás demasiado ocupado divirtiéndote y teniendo un progreso real.

Sólo asegúrate de compartir tu trabajo con los demás!

# 2 - Sintetizadores

De acuerdo, ya esta bien de introducciones - hagamos algo de sonido.

En esta sección cubriremos las bases de desencadenar y manipular un sintetizador, que no es más que una palabra rebuscada para algo que produce sonidos. Típicamente los sintetizadores son bastante complicados de usarse - especialmente los análogos con tantos cables para unir los módulos. Sin embargo, Sonic-Pi te da mucho de ese poder en una manera mucho más sencilla.

No te confundas con la sencillez del interfaz de Sonic-Pi. Puedes llegar a manipular con mucha profundidad el sonido, si eso te interesa. Mantente atento…

# 2.1 - tus primeros Sonidos

Dale una mirada al siguiente código:

    play 70

Así comienza todo. Adelante, copia y pega en la ventana superior de la aplicación (ese espacio grande en blanco debajo del botón Ejecutar) Ahora, presiona ‘Ejecutar’…

## Sonido!

Intenso. Presiónalo otra vez, otra vez, otra vez y otra vez…

Woah, loco, estoy seguro que podrías seguir así por el resto del día. Pero espera, antes de perderte en un infinito bucle de sonidos, intenta cambiando el número:

    play 75

¿Escuchas la diferencia? Intenta con un número menor:

    play 60

Los números bajos crean sonidos más graves, mientras que los altos crean sonidos más agudos. Exactamente como en un piano, las teclas en la parte baja del piano (a la izquierda) hacen sonar notas más graves, y las teclas de la parte alta del piano (a la derecha) hacen sonar notas más agudas.

Resulta que el do de la cuarta octava (C en la notación inglesa) está identificado por el número 60. Por eso, `play 60` hace sonar el do de la cuarta octava. Para hacer sonar la siguiente tecla hacia la derecha, tienes que sumar 1 a 60 y entonces escribir `play 61`, que en este caso es la tecla negra del do sostenido (o el re bemol). Para hacer sonar un re, sería la correspondiente tecla hacia la derecha, y debes escribir `play 62`.

No te preocupes si nada de esto significa algo para tí, que así fue también cuando yo comenzaba. Lo que importa es que sepas que los números menores significan sonidos más graves que los números mayores.

## Acordes

Si tocar una nota es divertido, tocar varias al mismo tiempo lo es aún más. Pruébalo:

    play 72
    play 75
    play 79

Jazzy! cuando escribes múltiples `play`s, todos se tocan al mismo tiempo. compruébalo tú mismo - ¿cuáles suenan bien juntos, cuales suenan mal?, experimenta y encuentra por tí mismo.

## Melodía

Si tocar notas y acordes es divertido, pero ¿que tal una melodía? ¿qué tal si queremos tocar notas en diferentes momentos? ¡Fácil! sólo debes poner un `sleep` entre las notas:

    play 72
    sleep 1
    play 75
    sleep 1
    play 79

¡qué adorable pequeño arpegio! Entonces, ¿qué significa el `1` en `sleep 1`? Bien, significa la duración de la interrupción. Realmente significa esperar por un pulso, aunque por ahora podemos pensar que significa detenerse por espacio de 1 segundo. Así, ¿cómo haríamos para que el arpegio suene más rápido? Bueno, necesitaríamos usar valores de ‘sleep’ menores. ¿qué tal, por ejemplo `0.5`:

    play 72
    sleep 0.5
    play 75
    sleep 0.5
    play 79

¿Notaste que se ejecutaron más rápido? ahora prueba tú mismo cambiando los valores, usando diferentes tiempos y notas.

Una cosa a probar es tocar notas como `play 52.3` y `play 52.63`. No hay necesidad alguna de usar notas enteras. Toca, prueba y diviértete.

## Nombres tradicionales de las notas

Para aquellos de vosotros que poseáis conocimientos de notación musical (no importa si no, no es absolutamente necesario para divertirte) quizás quieras escribir una melodía usando nombres de notas como C y F# en vez de números. Sonic Pi tiene todo eso cubierto. Puedes hacer lo siguiente:

    play :C
    sleep 0.5
    play :D
    sleep 0.5
    play :E

Recuerda poner los dos puntos ‘:’ delante del nombre de la nota, para que se ponga color rosa. también puedes especificar la octava, añadiendo un número delante de la nota:

    play :C3
    sleep 0.5
    play :D3
    sleep 0.5
    play :E4

Si quieres hacer una nota aguda, añádele una ‘s’ al nombre de la nota así:`play :Fs3` y si quieres hacer una nota plana, añádele una `b` así `play :Eb3`.

También hay un práctico atajo para un descanso (una forma musical de decir que no se toque nada en lugar de una nota) usando `:r`, `:rest` o `nil`.

Ahora, “enloquece” y diviértete con tus propias tonadas.

# 2.2 - Opciones de Sintetizador: Amp y Pan

Asimismo como Sonic Pi te permite controlar cuál nota tocar o cuál muestra desencadenar, también provee un completo rango de opciones para pulir y controlar los sonidos. En este tutorial cubriremos muchos de estos y existe una gran documentación para cada uno en el sistema de ayuda. Sin embargo, por ahora introduciremos dos de los más útiles: amplitude y pan. Miremos primero cuales son las opciones.

## Opciones

Sonic Pi apoya la noción de opciones (opts, abreviando) para sus sintetizadores. Opts son controles que pasas a `play` los cuales modifican y controlan aspectos del sonido que oyes. Cada sintetizador tiene su propio set de opts para sintonizar su sonido. Sin embargo, hay sets comunes de opts que comparten muchos, como `amp:` y sobre opts (cubiertas en otra sección).

Las Opts tienen dos partes principales, su nombre (el nombre del control) y su valor (el valor al que pondrás el control). Por ejemplo, puedes tener un control llamado ‘cheese:’ y querer ponerlo con un valor de `1`.

Los opts se pasan a las llamadas a `play` por medio del uso de una coma `,` y después el nombre del opt, tal como `amp:` (no olvides los dos puntos `:`) y después un espacio y el valor del opt. Ejemplo:

    play 50, cheese: 1

(Nota que `cheese:` no es un opt válido, lo usamos sólo como ejemplo).

Puedes pasar múltiples opts separados por comas:

    play 50, cheese: 1, beans: 0.5

El orden de los opts no importa, el siguiente será igual al anterior:

    play 50, beans: 0.5, cheese: 1

Si un Opt no es reconocido por el sintetizador, simplemente es ignorado (como en el caso de `cheese` y `beans` ¡los cuales son nombres ridículos, obviamente!)

Si accidentalmente utilizas el mismo opt dos veces con diferentes valores, el último gana. Por ejemplo, `beans:` aquí tendrá el valor de 2 y no el de 0.5:

    play 50, beans: 0.5, cheese: 3, eggs: 0.1, beans: 2

Muchas cosas en Sonic Pi aceptan opts, sólo debes pasar tiempo aprendiendo cómo usarlas e irás bien. Ejecutemos nuestro primer opt: `amp:`.

## Amplitud

Amplitud es una representación computarizada del volumen de un sonido. Una alta amplitud produce un sonido de alto volumen y baja amplitud produce sonido de bajo volumen. Así como Sonic Pi utiliza números para representar tonos y tiempos, usa números para representar la amplitud. Una amplitud de 0 es silencio (escucharás nada) y amplitud de 1 es volumen normal. Puedes utilizar volumen a amplitudes mayores a 2, 10, 100. Sin embargo, debes tener en cuenta que cuando la amplitud de todos los sonidos se vuelve muy alta, Sonic Pi utiliza un compresor para asegurar que no lleguen a tan alto que dañen tus oídos. Esto puede hacer que los sonidos sean extraños. Intenta con amplitudes bajas, por ejemplo en el rango de 0 to 0.5 para evitar compresión.

## Amplifícalo

Para cambiar la amplitud de un sonido, utiliza el opt `amp:`. Por ejemplo, para tocar a la mitad de la amplitud cámbialo a 0.5:

    play 60, amp: 0.5

Para hacerlo al doble de amplitud 2:

    play 60, amp: 2

El opt `amp:` sólo modifica la llamada para el `play` al que está asociado. Así, en este ejemplo, la primera llamada para tocar es a mitad de volumen y la segunda es a la predeterminada (1):

    play 60, amp: 0.5
    sleep 0.5
    play 65

Por supuesto que puedes usar diferentes valores de `amp:` para cada llamada a play:

    play 50, amp: 0.1
    sleep 0.25
    play 55, amp: 0.2
    sleep 0.25
    play 57, amp: 0.4
    sleep 0.25
    play 62, amp: 1

## Paneo

Otro concepto divertido de usar es el paneo `pan:` el cual controla el paneo de un sonido en estéreo. Panear un sonido a la izquierda, significa que lo escucharás en la bocina izquierda, panearlo a la derecha, significa que lo escucharás de la bocina derecha. Para nuestros valores, tenemos -1 para representar completamente a la izquierda, 0 para representar el centro y 1 para representar completamente a la derecha. Claro, eres libre de usar cualquier valor en medio de -1 y 1 para controlar la posición exacta de tu sonido.

Toquemos un sonido desde la bocina izquierda:

    play 60, pan: -1

ahora que salga de la bocina derecha:

    play 60, pan: 1

Finalmente, pongámoslo de nuevo al centro (predeterminado):

    play 60, pan: 0

¡Ahora diviértete cambiando las amplitudes y paneos de tus sonidos!

# 2.3 - Cambiando Sintetizadores

Hasta ahora nos hemos divertido mucho sólo con sonidos. Sin embargo, de seguro ya comienzas a cansarte del sonido básico de pitidos. ¿es eso todo lo que Sonic-Pi tiene para ofrecer? Tiene que haber más que tocar pitidos. Sí, hay mucho más y lo exploraremos en esta sección con el impresionante rango de sonidos que Sonic Pi tiene para ofrecer.

## Sintetizadores

Sonic Pi cuenta con varios instrumento llamados synths (una abreviación de sintetizadores). Mientras que los muestreos representan sonidos pre-grabados, los sintetizadores son capaces de generar nuevos sonidos dependiendo de cómo los controles (lo cual exploraremos más adelante en el tutorial). Los sintetizadores de Sonic Pi son poderosos y expresivos, y seguro que te divertirás tocando y explorándolos. Primero, aprendamos a seleccionar el synth que queremos usar.

## Sierras y Profetas

Un sonido divertido es el de la onda sierra - probémoslo:

    use_synth :saw
    play 38
    sleep 0.25
    play 50
    sleep 0.25
    play 62

Probemos otro sonido - prophet:

    use_synth :prophet
    play 38
    sleep 0.25
    play 50
    sleep 0.25
    play 62

¿Qué tal si combinamos ambos sonidos? Pongamos uno después del otro:

    use_synth :saw
    play 38
    sleep 0.25
    play 50
    sleep 0.25
    use_synth :prophet
    play 57

Ahora múltiples sonidos al mismo tiempo (al no dormir entre llamados sucesivos a `play`):

    use_synth :tb303
    play 38
    use_synth :dsaw
    play 50
    use_synth :prophet
    play 57

Debes notar que el comando `use_synth` sólo afecta a las siguientes llamadas a `play`. Piensa en él como un gran conmutador - nuevas llamadas a `play` tocarán el sintetizador que esté en uso. Puedes cambiar el conmutador a un nuevo sintetizador con `use_synth`.

## Descubriendo Sintetizadores

Para saber qué sintetizadores tiene Sonic Pi, échale un vistazo a la opción Sintetizadores en el menú al final de esta pantalla de ayuda (entre Ejemplos y Efectos). Hay más de 20 entre los que elegir. Aquí están algunos de mis favoritos:

- `:prophet`
- `:dsaw`
- `:fm`
- `:tb303`
- `:pulse`

Ahora prueba a cambiar los sintetizadores durante la ejecución de tu música. Diviértete combinando sintetizadores para hacer nuevos sonidos así como utilizando diferentes sintetizadores para diferentes secciones de tu música.

# 2.4 - Duración con Envolventes

En una sección anterior, vimos cómo utilizar el comando `sleep` para controlar cuándo disparar sonidos. Sin embargo, aún no hemos podido controlar la duración de nuestros sonidos.

Con el fin de darnos una simple pero poderosa manera de controlar la duración de nuestros sonidos, Sonic Pi proporciona el concepto de una envolvente de amplitud ADSR (más adelante en esta sección trataremos qué significa ADSR). Una envolvente de amplitud ofrece el control de dos aspectos muy útiles:

- control sobre la duración del sonido
- control sobre la amplitud del sonido

## Duración

La duración es la longitud del sonido. Una mayor duración significa que escucharás el sonido por más tiempo. Todos los sonidos de Sonic Pi tienen una envolvente de control de la amplitud, y la duración total de la envolvente es la duración del sonido. Por lo tanto, al controlar la envolvente controlas la duración.

## Amplitud

La envolvente ADSR no sólo controla la duración, también te permite control fino de la amplitud del sonido. Todos los sonidos audibles comienzan y terminan en silencio, conteniendo partes no-silentes en medio. Las envolventes permiten deslizar y mantener la amplitud de las partes no-silentes. Es como darle instrucciones a alguien sobre cómo subir y bajar el volumen del amplificador de una guitarra. Por ejemplo, puedes pedirle a alguien “comienza en silencio, lentamente llega a máximo volumen, manténlo por un momento y rápidamente vuelve a silencio”. Sonic Pi te permite controlar exactamente esta conducta con los envolventes.

Recapitulando lo visto anteriormente, una amplitud de 0 es silencio y una amplitud de 1 es volumen normal.

Ahora, veamos cada una de las partes de las envolventes.

## Fase de Release (apagado del sonido)

La única parte de la envolvente que es utilizada predeterminadamente es el release, que es el tiempo que le toma al sintetizador para apagar el sonido completamente. Todos los sintetizadores tienen un tiempo de release de 1, lo que significa que tienen una duración de un pulso (el cual por defecto es 1 segundo, si el BPM es 60):

    play 70

La nota será audible por 1 segundo. ¡Vamos, cronométralo! Esta es la manera abreviada de decir lo mismo que:

    play 70, release: 1

¡Observa que suenan exactamente igual los últimos dos comandos! Sin embargo, es ahora muy fácil cambiar la duración con tan sólo modificar el valor del `release:`:

    play 60, release: 2

Podemos hacer que el sintetizador suene por un periodo de tiempo muy corto al poner un valor de release muy pequeño:

    play 60, release: 0.2

La duración del apagado del sonido es lo que llamamos fase de release y por defecto es una transición lineal. El siguiente diagrama ilustra esta transición:

La línea vertical en la izquierda del diagrama muestra que el sonido comienza con amplitud 0, pero llega a amplitud completa (esto es el ataque, que cubriremos próximamente). Una vez que la amplitud es máxima, se mueve en línea recta hacia abajo hasta llegar a 0, tomando el tiempo que para ello se especificó en `release:`. * Cuanto más largos son los tiempos de liberación, más tiempo le toma al sintetizador desvanecerse.*

Puedes, por tanto, cambiar la duración de tu sonido, cambiando el tiempo de release. Prueba a añadir tiempos de release a tu música.

## Fase de Ataque

Por defecto, la fase de ataque es 0 para todos los sintetizadores, lo que significa que pasan inmediatamente de amplitud 0 a 1. Ésto le da al sintetizador un sonido inicial percutivo. Sin embargo, podrías desear que el sonido se inicie gradualmente. Esto se logra con el operador `attack:`. Prueba hacerlo con varios sonidos:

    play 60, attack: 2
    sleep 3
    play 65, attack: 0.5

Puedes utilizar varios operadores al mismo tiempo. Por ejemplo para un ataque corto y un release largo, prueba:

    play 60, attack: 0.7, release: 4

Este ataque corto y largo release queda ilustrado en el siguiente diagrama:

También puedes invertirlo, prueba ahora con un ataque largo y un release corto:

    play 60, attack: 4, release: 0.7

Finalmente, puedes poner el ataque y release cortos, para obtener sonidos cortos.

    play 60, attack: 0.5, release: 0.5

## Fase de Sustain

Adicionalmente a especificar los tiempos de ataque y release, también puedes especificar el tiempo de sustain para controlar la fase de sustain. Este es el tiempo en el cual el sonido está en su máxima amplitud entre las fases de ataque y release.

    play 60, attack: 0.3, sustain: 1, release: 1

El sustain es útil para sonidos que quieras resaltar en la mezcla, antes de entrar a la fase opcional de release. Por supuesto, es totalmente válido poner las opciones `attack:` y `release:` a 0; de esta forma el sonido aparecerá y desaparecerá de golpe. Sin embargo, ten en cuenta que un release de 0 puede producir clicks en el audio, por lo que se recomienda usar un valor muy pequeño como 0.2.

## Fase de Decaimiento (Decay)

También puedes especificar el tiempo de decaimiento (decay) para tener un mayor control de tu sonido. Esta fase se encuentra entre el ataque y el sostenimiento (sustain), y simboliza el tiempo que tarda la amplitud en bajar dede el nivel de ataque (`attack_level:`) hasta el nivel de decay (`decay_level:`); el `decay_level:` tiene por defecto el mismo valor que el nivel de sostenimiento (`sustain_level:`), pero puedes ponerle el valor que tú quieras. Por defecto, la opción `decay:` vale 0 y los niveles de ataque y sustain valen 1, así que tendrás que cambiar dichos valores para que el tiempo de decaimiento haga efecto:

    play 60, attack: 0.1, attack_level: 1, decay: 0.2, sustain_level: 0.4, sustain: 1, release: 0.5

## Nivel de Decaimiento

Un último truco… aunque la opción `decay_level:` está predeterminada a tener el mismo valor que el `sustain_level:` puedes ser explícit@ y asignarles diferentes valores para tener un control total del envolvente. Esto te permitirá crear envolventes como el siguiente:

    play 60, attack: 0.1, attack_level: 1, decay: 0.2, decay_level: 0.3, sustain: 1, sustain_level: 0.4, release: 0.5

También es posible poner el `decay_level:` más alto que el `sustain_level:`:

    play 60, attack: 0.1, attack_level: 0.1, decay: 0.2, decay_level: 1, sustain: 0.5, sustain_level: 0.8, release: 1.5

## Envolventes ADSR

Para resumir, las envolventes ADSR de Sonic Pi tienen las siguientes fases:

1. ataque - tiempo que tarda la amplitud en pasar de 0 al `attack_level`,
2. decaimiento (decay) - tiempo que tarda la amplitud en pasar del `attack_level` al `decay_level`,
3. sostenimiento (sustain) - tiempo que tarda la amplitud en pasar del `decay_level` al `sustain_level`,
4. release - tiempo que tarda la amplitud en pasar del `sustain_level` a 0

Es importante recalcar que la duración de un sonido es la sumatoria de los tiempos de todas las fases. Por tanto, el siguiente sonido tendrá una duración de 0.5 + 1 + 2 + 0.5 = 4 pulsos:

    play 60, attack: 0.5, attack_level: 1, decay: 1, sustain_level: 0.4, sustain: 2, release: 0.5

Ahora ve a jugar con envolventes en tus sonidos…

# 3 - Muestras

Otra gran manera de desarrollar tu música es usando sonidos pre-grabados. En la gran tradición del hip-hop, llamamos a estos sonidos pre-grabados sampleos. Así que si tomas un micrófono afuera y grabas el sonido de la lluvia golpeando la tela, ya creaste un sampleo.

Sonic Pi te deja hacer muchas y divertidas cosas con las muestras. No sólo viene con cerca de 90 muestras de dominio libre para que ser utilizados, sino que te deja manipular los tuyos. Veamos…

# 3.1 - Disparando muestras

Tocar con pitidos (beeps) es sólo el principio. Por ejemplo, puedes probar algo realmente divertido, que es lanzar samples pre-grabados. Inténtalo:

    sample :ambi_lunar_land

Sonic Pi incluye muchos samples con los que puedes tocar. Utiliza el comando `play` para dispararlos. Para tocar varios samples y notas, sólo tienes que escribirlos uno detrás del otro:

    play 36
    play 48
    sample :ambi_lunar_land
    sample :ambi_drone

Si quieres distribuirlos en el tiempo, usa el comando `sleep`:

    sample :ambi_lunar_land
    sleep 1
    play 48
    sleep 0.5
    play 36
    sample :ambi_drone
    sleep 1
    play 36

¿Notas que Sonic Pi no espera a finalizar un sonido para comenzar el siguiente? El comando `sleep` sólo describe la separación de los sonidos disparados. Esto te permite hacer capas de sonidos fácilmente, creando interesantes efectos de capas superpuestas.

## Descubriendo las muestras

Tienes dos formas de ver el rango de las muestras incluidas en Sonic Pi. Primero, puedes utilizar este sistema de ayuda. Pulsa sobre Muestras en el menú al final de la pantalla de ayuda, elige una categoria, y verás una lista de sonidos disponibles.

También puedes usar el sistema para auto completar. Sólo tienes que escribir el comienzo de un grupo de samples que empiecen por el mismo nombre; por ejemplo, `sample :ambi_`. Te saldrá un menú con nombres de samples disponibles, que puedes seleccionar. Prueba con los prefijos de las siguientes categorías:

- `:ambi_`
- `:bass_`
- `:elec_`
- `:perc_`
- `:guit_`
- `:drum_`
- `:misc_`
- `:bd_`

¡Ahora puedes comenzar a mezclar muestras en tus composiciones!

# 3.2 - Parámetros de Sample: Amplitud y Pan

Como ya vimos con los sintetizadores, podemos controlar con facilidad nuestros sonidos con parámetros. Las muestras permiten exactamente el mismo mecanismo de parametrización. Veamos a nuestros viejos conocidos `amp:` y `pan:`.

## Amplificando samples

Puedes cambiar la amplitud de los samples igual que la amplitud de los sintetizadores:

    sample :ambi_lunar_land, amp: 0.5

## Paneando los Samples

También podemos utilizar el parámetro `pan:` para los samples. En el siguiente ejemplo, el amen break suena primero en el oído izquierdo, y a la mitad, pasa al oído derecho:

    sample :loop_amen, pan: -1
    sleep 0.877
    sample :loop_amen, pan: 1

Fíjate en que 0.877 es justo la mitad de la duración (en segundos) del sample `:loop_amen` .

Finalmente, nota que si seteas algunos sintetizadores por defecto con `use_synth_defaults` (que discutiremos luego), estos serán ignorados por `sample`.

# 3.3 - Estirando Samples

Ahora que ya podemos tocar una variedad de sintetizadores y samples para crear música, es tiempo de aprender a modificar tanto los sintetizadores como los samples para hacer la música incluso más interesante y única. Primero, exploremos la habilidad de estirar y aplastar los samples.

## Representación de Samples

Los Samples son sonidos pregrabados guardados como números que representan cómo mover los conos de los parlantes para reproducir sonidos. Estos conos se pueden mover hacia dentro y hacia afuera, así que los números sólo deben representar ese movimiento en cada momento dado. Para poder reproducir fielmente un sonido, el sample debe guardar miles de números por segundo! Sonic Pi toma esta lista de números y los alimenta a la velocidad correcta para mover los parlantes de tu ordenador a la velocidad correcta para reproducir el sonido. Sin embargo, también es divertido cambiar la velocidad a la que los números son alimentados al parlante para cambiar el sonido.

## Cambiando la Velocidad

Vamos a cambiar uno de los sonidos ambientales: `:ambi_choir`. Para la modificación de la velocidad por defecto, se puede agregar `rate:` a la `sample`:

    sample :ambi_choir, rate: 1

Esto lo ejecuta a tiempo normal (1), nada especial. Sin embargo, podemos cambiar ese número por algo más. ¿Qué tal a `0.5`?:

    sample :ambi_choir, rate: 0.5

¡Woah! ¿qué sucedió? Bueno, dos cosas: Primero, el sample se ejecutó en el doble del tiempo; Segundo, sonó una octava más grave. Exploremos todo esto en más detalle.

## Estiremos

Un sample que es divertido estirar y comprimir es el Amen Break. A velocidad normal, podemos imaginar ponerlo en una pista de drum ‘n’ bass:

    sample :loop_amen

Sin embargo, cambiando la velocidad podemos cambiar géneros. Intenta con la mitad de la velocidad para algo de “hip hop de la vieja escuela”:

    sample :loop_amen, rate: 0.5

Si lo aceleramos, entramos al territorio de jungle:

    sample :loop_amen, rate: 1.5

Vamos a nuestro último truco - veamos qué sucede si utilizamos una velocidad negativa:

    sample :loop_amen, rate: -1

Ahaa! ¡Se toca al revés! Ahora intenta tocar distintos samples a distintas velocidades. Intenta con velocidades muy rápidas o lentísimas. Observa qué sonidos interesantes puedes crear.

## Velocidad de Sample: Una explicación sencilla

Una manera útil de pensar en samples es comparándolos con resortes. Piensa en la velocidad de ejecución como “estirar” o “comprimir” el resorte. Si tocas a velocidad 2 estás comprimiendo el resorte a la mitad de su tamaño, por tanto le toma la mitad del tiempo en ejecutarse, ya que es más corto. Si ejecutas el sample a la mitad de velocidad, estás en efecto alargando el resorte, por tanto estás doblando su tamaño y el tiempo que le toma ejecutarse. Entre más comprimas (mayor velocidad), más corto se vuelve, entre más estires (menor velocidad), más largo se vuelve.

Comprimir un resorte incrementa su densidad (el número de “vueltas” por cm.) - esto es similar al sample sonando más agudo. Estirar el resorte disminuye su densidad y es similar al sonido siendo más grave.

## La matemática detrás de la velocidad de sample

(Esta sección es para aquellos interesados en los detalles. Eres libre de saltártela…)

Como hemos visto, un sample está representado por una larga lista de números representando donde debe de estar el parlante a través del tiempo. Podemos tomar este listado de números y usarlo para dibujar un gráfico que sería similar a:

Quizás hayas visto imágenes parecidas a esa. Se llaman “forma de onda” de un sampleo. Simplemente es la graficación de números. Típicamente una forma de onda como ésta tendrá 44100 puntos por segundo de datos (esto es debido al teorema de sampleo de Nyquist-Shannon) Así que si el sampleo dura 2 segundos, la forma de onda será representada por 88200 números, alimentándo al altavoz a una velocidad de 44100 puntos por segundo. Claro, podemos también alimentarlos a una velocidad doble, que sería de 88200 puntos por segundo, lo cual tomaría sólo 1 segundo para ser tocado. También podríamos tocarlo a la mitad de velocidad, lo que daría 22050 puntos por segundo tomando 4 segundos de tiempo de ejecución.

La duración del sampleo es afectada por la velocidad de ejecución:

- Doblando la velocidad de reproducción se reduce a la mitad el tiempo de ejecución,
- cortando a la mitad la reproducción, doblamos el tiempo de ejecución,
- usando una velocidad de ejecución de 1/4, cuadruplicamos el tiempo de reproducción,
- El uso de una velocidad de reproducción de 1/10, hace que la reproducción dure 10 veces más.

Podemos representar esto con la fórmula:

    nuevo_sample_ = (1 / velocidad) * duración_sample

Cambiando la velocidad de ejecución se afecta el tono del muestreo. La frecuencia o tono de una onda está determinada por cuán rápido se mueve hacia arriba y hacia abajo. De alguna manera, nuestro cerebro toma los movimientos rápidos de los parlantes a notas agudas, igualmente, torna movimientos lentos de los parlantes en notas graves. Por eso es que puedes ver los parlantes de bajos moverse cuando están dando notas muy bajas, porque en realidad sí se están moviendo adentro/afuera del parlante mucho más lentamente que al producir notas altas.

Si tomas una forma de onda y la comprimes en el eje de las “x”(tiempo), se moverá más veces por segundo hacia arriba y hacia abajo, lo que producirá un sonido más agudo. Significa que doblando la cantidad de movimientos verticales (oscilaciones) se dobla la frecuencia. Así: tocar tu onda sonora al doble de velocidad, doblará la frecuencia a la que la escuchas. Asimismo, reduciendo la velocidad a la mitad, también reduce la frecuencia a la mitad. En consecuencia, cambios en las velocidades afectarán la frecuencia.

# 3.4 - Envolventes para samples

Es posible modificar la duración y amplitud de una onda muestral (sample) usando un envolvente acústico del tipo ADSR. sin embargo, este funciona un tanto diferente al envolvente acústico ADSR de los sintetizadores (synths), ya que los envolventes acústicos para ondas muestral sólo te permiten reducir la amplitud y duración de una onda sonora, pero nunca incrementarlos. La onda muestral terminará su ejecución ya sea cuando se acabe o cuando el envolvente lo haga, lo que suceda primero. Así que si utilizas un “desvanecimiento”(release) largo, ello no extenderá la duración de la onda muestral.

## Envolventes Acústicos para Amen

Volvamos a nuestro amigo, el Amen Break:

    sample :loop_amen

Sin parámetros , escuchamos la onda muestral a su amplitud total. Si quisiéramos aparecerla dentro de 1 segundo, podemos utilizar el parámetro `attack:`:

    sample :loop_amen, attack: 1

Para un aparecimiento más corto, elegiríamos un valor de ataque menor:

    sample :loop_amen, attack: 0.3

## Sustain Automático

Donde el envolvente acústico ADSR difiere en su conducta con el de un sintetizador es en el valor del sostenimiento sustain. En el envolvente acústico del sintetizador, el sostenimiento está predeterminado a 0 a menos que lo cambies manualmente. Con ondas muestrales, el valor predeterminado de sustain está en automágico el tiempo que resta para terminar el resto de la onda. A ello se debe que podamos escuchar la onda muestra completa cuando nocambiamos los parámetros por defecto. Si los valores de ataque, decaimiento,sostenimiento y desvanecimiento fueran 0, nunca escucharíamos ningún sonido de la onda. Por eso Sonic Pi calcula qué tan larga es la onda muestra, deduce su ataque, decaimiento y tiempo de desvanecimiento, para utilizar esa sumatoria como tiempo de sostenimiento. Si los valores de ataque, decaimiento y desvanecimiento son mayores al tiempo de la onda muestra,sencillamente el sostenimiennto de vuelve 0.

## Apagando (desaparición)

Para explorar esto, consideremos nuestra pista Amen break en detalle. Si le preguntamos a Sonic Pi cuán largo es el sample:

    print sample_duration :loop_amen

Imprimirá `1.753310657596372` que es el tamaño del sample en segundos. Consideremos redondearlo a `1.75` por conveniencia. Ahora, si seteamos el release a `0.75`, algo sorprendente pasará:

    sample :loop_amen, release: 0.75

Ejecutará el primer segundo del sample a amplitud completa antes de desvanecerse por un periodo de 0.75 segundos. Esto es el auto sustain en acción. Predeterminado, el release siempre trabaja al final del sample. si tu sample fuera 10.75 segundos de largo, ejecutaría los primeros 10 segundos a completa amplitud antes de comenzar a desvanecerse por los 0.75 segundos finales.

Recuerda: por defecto, “desvanecimiento”(release) :se desvanece al final de un sample.

## Fade In y Fade Out

Podemos utilizar tanto el `attack:` como el `release:` juntos con el auto sustain para aparecer y desvanecer en la duración del sample:

    sample :loop_amen, attack: 0.75, release: 0.75

Como la duración total del sampleo + ataque + release suman 1.5s, el sostenido queda automáticamente en 0.25s. Esto nos permite aparecer y desvanecer el sampleo con facilidad.

## Sostenido explícito

Podemos fácilmente volver a los parámetros normales de nuestro ADSR de sintetizador al ajustar manualmente el `sostenido:` a un valor como 0:

    sample :loop_amen, sustain: 0, release: 0.75

Ahora bien, nuestra onda muestra suena por 0.75 en total. Los parámetros pre- determinados para “ataque (attack)” y “decaimiento(decay)”: son 0, la onda muestra salta directamente aamplitud total por 0 segundos y después baja a amplitud 0 por un periodo de desvanecimiento de 0.75 segundos.

## Címbalos

Podemos utilizar este comportamiento con buenos resultados para convertir muestras más largas en versiones más cortas y percusivas. Considere la muestra `:drum_cymbal_open`:

    sample :drum_cymbal_open

Puedes escuchar el sonido del platillo sonando durante un periodo de tiempo. Sin embargo, podemos utilizar nuestra envolvente para hacerlo más percusivo:

    sample :drum_cymbal_open, attack: 0.01, sustain: 0, release: 0.1

Puedes emular el golpeo del platillo y después apagarlo, al incrementar el periodo de mantenido:

    sample :drum_cymbal_open, attack: 0.01, sustain: 0.3, release: 0.1

Ahora ve y diviértete poniendo envolventes en los sampleos. Intenta cambiar la velocidad, también para unos resultados realmente interesantes.

# 3.5 - Muestras parciales

Esta sección concluirá nuestra exploración del reproductor de muestras de Sonic Pi. Hagamos una rápida recapitulación. Hasta ahora hemos visto cómo podemos disparar muestras:

    sample :loop_amen

A continuación, analizamos cómo podemos cambiar la velocidad de las muestras, por ejemplo, reproduciéndolas a media velocidad:

    sample :loop_amen, rate: 0.5

Después miramos como podíamos aparecer un pequeño sampleo (hagámoslo a media velocidad):

    sample :loop_amen, rate: 0.5, attack: 1

También miramos como podíamos usar el comienzo de un sampleo percusivamente al darle a `mantenido:` un valor explícito y ajustar ambos el ataque y el release con valores cortos:

    sample :loop_amen, rate: 2, attack: 0.01, sustain: 0, release: 0.35

Sin embargo, ¿no sería bueno que no tuviéramos que empezar siempre por el principio de la muestra? ¿No sería bueno que no tuviéramos que terminar siempre al final de la muestra?

## Escogiendo un punto de inicio

Es posible elegir un punto de inicio arbitrario en el sampleo con un valor entre 0 y 1, donde 0 es el punto de comienzo, 1 es el punto de final y 0.5 es la mitad del sampleo. Intentemos ejecutar únicamente la última mitad del sampleo de amen break:

    sample :loop_amen, start: 0.5

¿Qué tal escuchar el último cuarto del sample?:

    sample :loop_amen, start: 0.75

## Escogiendo punto de termino

Igualmente, es posible escoger un punto de termino arbitrario en el sample, con un valor entre 0 y 1. Vamos a terminar el amen break a la mitad:

    sample :loop_amen, finish: 0.5

## Especificando el comienzo y el final

Por supuesto que podemos combinar dos para tocar segmentos del archivo de audio arbitrariamente. ¿Qué tal solo una pequeña sección en el medio?

    sample :loop_amen, start: 0.4, finish: 0.6

¿Qué pasa si elegimos comenzar en una posición después del final?

    sample :loop_amen, start: 0.6, finish: 0.4

¡Genial! ¡Lo reproduce al revés!

## Combinando con velocidad

Podemos combinar esta nueva herramienta para tocar segmentos arbitrarios de audio con nuestro amigo `rate:`. Por ejemplo, podemos tocar una pequeña sección al medio de amen break muy lentamente:

    sample :loop_amen, start: 0.5, finish: 0.7, rate: 0.2

## Combinando con envolventes

Finalmente, podemos combinar todo esto con nuestras envolventes ADSR para producir resultados interesantes:

    sample :loop_amen, start: 0.5, finish: 0.8, rate: -0.2, attack: 0.3, release: 1

Ahora vete y juega con sampleos y todas estas divertidas herramientas…

# - Muestras externas

Mientras los samples incluidos te ayudan a iniciar rápido, quizá quieras experimentar con otros sonidos grabados en tu música. Sonic Pi lo soporta completamente. Primero, revisemos brevemente la portabilidad de tu pieza musical.

## Portabilidad

Cuando compones una pieza solamente con sintetizadores y samples incluidos, el código es todo lo que necesitas para reproducir tu música. Piensa en esto por un momento - es maravilloso! Un texto sencillo que puedes enviar por email o pegar en un Gist representa todo lo que necesitas para reproducir tus sonidos. Eso hace que sea realmente fácil de compartir con tus amigos que sólo necesitan tu código.

Por otra parte, si usas tus samples pregrabados, pierdes esta portabilidad. Esto es debido a que reproducir tu música, otras personas no solo necesitan tu código, necesitan tus samples también. Esto limita la habilidad para otros de manipular, combinar y experimentar con tu trabajo. Por supuesto, esto no debe detenerte para usar tus propios samples, es solamente algo a considerar.

## Muestras locales

¿Cómo reproduces cualquier archivo WAV, AIFF o FLAC en tu computadora? Todo lo que necesitas es indicar la ubicación del archivo en `sample`:

    # Raspberry Pi, Mac, Linux
    sample "/Users/sam/Desktop/my-sound.wav"
    # Windows
    sample "C:/Users/sam/Desktop/my-sound.wav"

Sonic Pi cargará y reproducirá el sample. También puedes indicar todos los parámetros estándar que acostumbras, indicando a `sample`:

    # Raspberry Pi, Mac, Linux
    sample "/Users/sam/Desktop/my-sound.wav", rate: 0.5, amp: 0.3
    # Windows
    sample "C:/Users/sam/Desktop/my-sound.wav", rate: 0.5, amp: 0.3

# 3.7 - Paquete de samples

Nota: esta sección del tutorial cubre el tema avanzado de trabajar con grandes directorios de tus propias muestras. Este será el caso si has descargado o comprado tus propios paquetes de muestras y deseas utilizarlos dentro de Sonic Pi.

Si te gusta trabajar con las muestras incluidas, puedes omitir esta parte.

Cuando trabajas con carpetas grandes de samples externos puede ser difícil tener que escribir toda la ruta cada vez que quieras usar un sample.

Por ejemplo, si tienes la siguiente carpeta en tu máquina:

    /path/to/my/samples/

Cuando miramos dentro de esa carpeta encontramos las siguientes muestras:

- `100_A#_melody1.wav`
- `100_A#_melody2.wav`
- `100_A#_melody3.wav`
- `120_A#_melody4.wav`
- `120_Bb_guit1.wav`
- `120_Bb_piano1.wav`

Normalmente, para reproducir la muestra del piano podemos utilizar la ruta completa:

    sample "/path/to/my/samples/120_Bb_piano1.wav"

Si queremos reproducir un sample de guitarra podemos usar su ruta completa también:

    sample "/path/to/my/samples/120_Bb_guit.wav"

Sin embargo, cada uno de estos llamados a sample requieren que sepamos los nombres de los samples en nuestro directorio. ¿Que tal si solo quisiéramos escuchar cada sample, uno tras otro, rápidamente?

## Indexando los paquetes de samples

Si queremos reproducir el primer sample en un directorio, necesitamos indicar el nombre del directorio en `sample` y el índice `0` de la siguiente manera:

    sample "/path/to/my/samples/", 0

Podemos incluso hacer un acceso directo a la ruta de nuestro directorio usando una variable:

    samps = "/path/to/my/samples/"
    sample samps, 0

Ahora, si queremos reproducir un segundo sample en nuestro directorio, sólo necesitamos añadir 1 a nuestro índice:

    samps = "/path/to/my/samples/"
    sample samps, 1

Date cuenta de que ya no necesitamos saber los nombres de los samples en el directorio - solamente debemos conocer el directorio (o tener una abreviatura para él). Si requerimos un indice que es mas grande que el numero de samples, simplemente retornamos al principio del directorio como si fuera un anillo. De cualquier manera, sin importar el número de índice que usemos, esta garantizado que tendremos un sample del directorio.

## Filtrar paquetes de samples

Usualmente con indexarlos es suficiente, pero algunas veces necesitamos algo mas poderoso para organizar nuestros samples. Afortunadamente muchos paquetes de samples añaden información valiosa en los nombres de los archivos. Ahora miremos de nuevo los nombres de los samples en nuestro directorio:

- `100_A#_melody1.wav`
- `100_A#_melody2.wav`
- `100_A#_melody3.wav`
- `120_A#_melody4.wav`
- `120_Bb_guit1.wav`
- `120_Bb_piano1.wav`

Date cuenta de que en estos nombres de archivo tenemos bastante información. En primer lugar tenemos el BPM del sample (número de pulsaciones por minuto) al comienzo. Por lo tanto, el sample del piano está a 120 BPM y nuestras primeras tres melodías están a 100 BPM. Además, nuestros nombres de los samples contienen la clave musical. Por tanto, el sample de la guitarra está en Bb (si bemol) y las melodías están en A# (la sostenido). Esta información es muy útil para mezclar estos samples con el resto del código. Por ejemplo, sabemos que solamente podemos usar el sample del piano con código que está a 120 BPM y en la clave de Bb.

Podemos usar como convención esta nomenclatura de nuestros conjuntos de samples en el código para ayudarnos a filtrar los que queremos. Por ejemplo, si trabajamos a 120 BPM, podemos filtrar a todos los ejemplos que contienen la cadena `" 120 "` con lo siguiente:

    samps = "/path/to/my/samples/"
    sample samps, "120"

Ésto ejecutará el primer sample. Si queremos el segundo sample sólo necesitamos usar el índice:

    samps = "/path/to/my/samples/"
    sample samps, "120", 1

Incluso podemos usar varios filtros al mismo tiempo. Por ejemplo, si queremos un sample cuyo nombre de archivo contenga las subcadenas “120” y “A #”, lo encontraremos fácilmente con el siguiente código:

    samps = "/path/to/my/samples/"
    sample samps, "120", "A#"

Por último, podemos añadir las opciones habituales al `sample`:

    samps = "/path/to/my/samples/"
    sample samps, "120", "Bb", 1, lpf: 70, amp: 2

## Fuentes

El sistema de pre-arg de filtro del sample entiende dos tipos de información: fuentes y filtros. Las fuentes son información utilizada para crear la lista de candidatos potenciales. Una fuente puede tomar dos formas:

1. “/path/to/samples” - una cadena que representa una ruta de acceso válida a un directorio
2. “/path/to/samples/foo.wav” - Una cadena que representa una ruta válida a un sample

El ‘sample’ fn primero coge todas las fuentes y crear una lista con todos los candidatos. Esta lista se construye agregando primero todas las rutas válidas y añadiendo, luego, todos los ficheros `.flac`,`.aif`, `.aiff`,`.wav`, `.wave` contenidos en los directorios.

Por ejemplo, echemos un vistazo al siguiente código:

    samps = "/path/to/my/samples/"
    samps2 = "/path/to/my/samples2/"
    path = "/path/to/my/samples3/foo.wav"
    sample samps, samps2, path, 0

Aquí, combinamos el contenido de los samples dentro de dos directorios y añadiendo un sample específico. Si `"/path/to/my/samples/"` contiene 3 samples y `"/path/to/my/samples2/"` contiene 12, tenemos 16 samples potenciales para indexar y filtrar (3 + 12 + 1).

Por defecto, sólo los samples de un directorio se agrupan en una lista de candidatos. Es posible que tenga una serie de subcarpetas de samples en la que quieras buscar y filtrar. Por lo tanto, puedes realizar una búsqueda recursiva de todas los samples dentro de todas las subcarpetas de una carpeta determinada añadiendo `**` al final de la ruta:

    samps = "/path/to/nested/samples/**"
    sample samps, 0

Ten cuidado ya que la búsqueda en un conjunto muy grande de carpetas puede tomar mucho tiempo. Sin embargo, el contenido de todas las fuentes de las carpetas se almacenan en el caché, por lo que el retraso sólo se producirá la primera vez.

Por último, ten en cuenta que las fuentes deben ir primero. Si no se da ninguna fuente, entonces el conjunto de samples incorporados se seleccionará de la lista predeterminada de candidatos con los que trabajar.

## Filtros

Una vez que tienes una lista de candidatos deberías usar los siguientes tipos de filtros para reducir aún más la selección:

- `"foo"` Las cadenas filtrarán la ocurrencia de la subcadena dentro del nombre de archivo (menos la ruta del directorio y la extensión).
- `/fo[oO]/` Regular Expresssions filtrará aquellos archivos cuyo nombre sea más parecido al del archivo especificado (en el nombre de archivo no se incluye su ruta ni su extensión de archivo).
- `:foo` - Keywords filtrará aquellos candidatos donde la palabra clave coincida directamente con el nombre de archivo (salvo la ruta y la extensión).
- `lambda{|a| ... }` - Los procesos con un argumento serán tratados como un filtro candidato o como una función generadora. Se pasará la lista de candidatos actuales, y deberá devolver una lista nueva de candidatos (es decir, una lista de rutas válidas a archivos de samples).
- `1` - Los números seleccionarán el candidato cuyo índice coincida con dicho número (dando la vuelta como una estructura de anillo si hace falta).

Por ejemplo, podemos filtrar sobre todos las muestras en un directorio que contengan el string `"foo"` y ejecutar la primera muestra correspondiente a la mitad de su velocidad:

    sample "/path/to/samples", "foo", rate: 0.5

Mira la sección de ayuda para `sample` donde encontrarás muchos ejemplos de uso detallados. Ten en cuenta que debes respetar el orden de los filtros.

## Filtros y fuentes compuestos

Finalmente, puedes usar listas dentro de una fuente o filtro. La lista será aplanada automáticamente, y sus contenidos serán tratados como fuentes y filtros normales y corrientes. Por tanto, las siguientes llamadas a `sample` son equivalentes sintácticamente:

    sample "/path/to/dir", "100", "C#"
    sample ["/path/to/dir", "100", "C#"]
    sample "/path/to/dir", ["100", "C#"]
    sample ["/path/to/dir", ["100", ["C#"]]]

## Conclusión

Ésta es una sección avanzada pensada para gente que necesite manipular y usar paquetes de samples de forma eficiente. No te preocupes si no entiendes si esta sección. Es probable que no necesites ninguna de estas opciones ahora mismo. Cuando llegue el momento. verás si te hacen falta estas herramientas; siempre puedes volver y leer esta ayuda de nuevo cuando empieces a trabajar con directorios de samples muy grandes.

# 4 - Aleatoriedad

Una manera de añadir interés a tu música es usando números aleatorios. Sonic Pi tiene gran funcionalidad añadiendo aleatoriedad a la música, pero antes de comenzar, debemos aprender una verdad chocante: en Sonic Pi no existe aleatoriedad real. ¿Qué significa eso? Vamos a ver.

## Repetibilidad

Una función realmente útil es `rrand` la cual te da un valor aleatorio entre dos números - un min y un max. (`rrand` es la abreviatura para ranged random). Intentemos tocar una nota al azar:

    play rrand(50, 95)

¡Ooh, tocó una nota al azar! Tocó la nota `83.7527`. Una nota entre 50 y 95 Woah, espera, predije el número correcto que obtuviste? ¡Algo raro sucede! Intenta con el código de nuevo. ¿qué? Otra vez `83.7527` ? ¡Eso no es aleatorio!

La respuesta es que no es realmente aleatorio, es pseudo-aleatorio. Sonic Pi te dará números como al azar en una manera repetitiva, lo cual es muy útil para asegurar que la música que creas en tú máquina suene idéntica en cualquier otra máquina - aunque utilices números al azar en tú composición.

Claro que en una pieza musical donde quieras colocar notas al “azar” y siempre eliga `83.7527` no sería ni aleatorio ni interesante. Sin embargo, no es así. Intenta lo siguiente:

    loop do
      play rrand(50, 95)
      sleep 0.5
    end

¡Sí! Finalmente suena aleatorio. Dentro de una misma corrida las subsecuentes llamadas a funciones aleatorias dan valores..aleatorios. Sin embargo, la próxima corrida volverá a dar la misma secuencia de valores “aleatorios” y sonar exactamente igual. Es como si Sonic Pi volvió en el tiempo al mismo punto cuando se corrió run la primera vez. ¡Es el Groundhog Day de la síntesis musical!

## Campanas encantadas

Una buena ilustración de aleatoriedad en acción es el ejemplo haunted bells que buclee el sampleo de `:perc_bell` con velocidad de Aleatoriedad y tiempo de pausa entre los sonidos:

    loop do
      sample :perc_bell, rate: (rrand 0.125, 1.5)
      sleep rrand(0.2, 2)
    end

## Corte aleatorio

Otro buen ejemplo de aleatoriedad es modificar el momento de corte de un sintetizador, en forma aleatoria. Un gran synth en el que hacerlo es el emulador `:tb303`:

    use_synth :tb303
    loop do
      play 50, release: 0.1, cutoff: rrand(60, 120)
      sleep 0.125
    end

## Semillas aleatorias

¿Entonces qué, no te gusta la particular secuencia de números al azar que provee Sonic Pi? Bueno, es totalmente posible elegir un punto de comienzo via `use_random_seed`. Predeterminado está a 0, así que: ¡elige una semilla diferente para una aleatoriedad diferente!

Considera lo siguiente:

    5.times do
      play rrand(50, 100)
      sleep 0.5
    end

Cada vez que corras ese código escucharás la misma secuencia de 5 notas. Para cambiar la secuencia, simplemente cambia el valor de seed_:

    use_random_seed 40
    5.times do
      play rrand(50, 100)
      sleep 0.5
    end

Esto producirá una diferente secuencia de 5 notas. Al cambiar el valor de seed y escuchar los resultados, puedes encontrar algo que te guste y cuando lo compartas con otros, escucharán exactamente lo mismo.

Veamos otras útiles funciones de aleatoriedad.

## Elegir (choose)

Una cuestión común es elegir un ítem desde una lista de ítems conocidos Por ejemplo, quiero tocar una nota de entre las siguientes: 60, 65 or 72. Puedo lograr eso con `choose` pues me deja elegir un ítem de esa lista. Primero necesito confeccionar mi listado entre paréntesis cuadrados y separándolos por comas: `[60, 65, 72]`. Después sólo necesito pasarlos por `choose`:

    choose([60, 65, 72])

Escuchemos como suena:

    loop do
      play choose([60, 65, 72])
      sleep 1
    end

## Rango aleatorio (rrand)

Ya hemos visto la función `rrand`, pero adentrémonos más en ella. Nos proporciona un número aleatorio entre dos valores. Eso significa que nunca nos dará los números extremos del rango, sólo entre ellos. Ese número será un ‘flotante’, lo que significa que no es un número entero, sino una fracción de número. He aquí ejemplos de flotantes: `rrand(20, 110)`:

- 87.5054931640625
- 86.05255126953125
- 61.77825927734375

## Rango aleatorio ínclusivo ( rrand_i)

Ocasionalmente querrás un número entero aleatorio, no un flotante. Es entonces que `rrand_i` viene al rescate. Funcional similarmente a `rrand` excepto que incluye los valores mínimo y máximo como potenciales aleatorios (lo que significa que es inclusiva y no excluyente de los valores extremos del rango). Ejemplos de números con `rrand_i(20, 110)` son:

- 88
- 86
- 62

## rand

Esta función te regresará un número aleatorio flotante incluyendo los valores 0 y el máximo especificado. Predeterminado está el rango entre 0 y 1. Por ello es útil para elegir valores de `amp:` aleatorios:

    loop do
      play 60, amp: rand
      sleep 0.25
    end

## rand_i

De maneara similar a `rrand_i` y `rrand`, `rand_i` nos dará un número leatorio ENTERO entre 0 y el máximo especificado.

## Dado (dice)

Alguna vez querrás emular el tiro de un dado. Para ello tenemos un caso especial de `rrand_i` donde el valor inferior será siempre 1. El uso de `dice` requiere que especifiques el número de lados del dado. Un dado estándard tiene 6 lados, así `dice(6)` actuará similarmente, dando valores de 1, 2, 3, 4, 5, or 6. Sin embargo, como en los juegos de role-play encontrarás necesidad de un dado de 4, 12, 20 o inclusive de 120 caras!

## one_in

Finalmente cuando quieras emular tirar el máximo puntaje con un dado, como 6 en un dado estándard `one_in` te dará eso con una posibilidad de uno en número de lados del dado. Por lo tanto, `one_in(6)` nos dará verdad con una probabilidad de 1 en 6 o falso. Verdadero y falso son valores muy útiles para `if` el cual cubriremos en la siguiente sección de este tutorial.

¡Ahora ve a jugar con códigos y algo de aleatoriedad!

# 5 - Estructuras de Programación

Ahora que has aprendido lo básico de crear sonidos con `play` y `sample` y crear ritmos y melodías simples con `sleep` en medio de los sonidos, podrías preguntarte ¿Qué es lo que codificar puede ofrecerte?

Bueno, estás a punto de ser sorprendido, porque resulta que herramientas básicas de estructuras de programación como bules, condicionales, funciones e hilos, te dan grandes posibilidades de expresión musical.

Concentrémonos en la base…

# 5.1 - Bloques

Una estructura que verás a menudo en Sonic Pi es el bloque. Los Bloques nos permiten hacer cosas útiles con largas sábanas de código. Por ejemplo, con parámetros de synth y sample podíamos cambiar cosas en una sóla línea. sin embargo, algunas veces queremos hacer algo significativo para un número de líneas de código. Por ejemplo buclear, añadir reverberación, pero sólo correrlo 1 de cada 5 veces. Considera el siguiente código:

    play 50
    sleep 0.5
    sample :elec_plip
    sleep 0.5
    play 62

Para hacer algo con un manojo de códifo, necesitamos decirle a Sonic Pi dónde comienza el bloque de código y dónde termina. Usamos para el comienzo `do` y para el final `end` . Por ejemplo:

    do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

Sin embargo, ese código está incompleto, porque no le hemos dicho a Sonic Pi lo que queremos hacer con ese bloque do/end (intenta y te dará error). Eso se lo decimos a Sonic Pi al escribir algunos códigos especiales antes del `do`. Veremos un estos códigos especiales más adelante en este tutorial Por ahora es importante conocer que envolver tu código entre `do` y `end` le dice a Sonic Pi que deseas hacer algo especial con ese pedazo de código.

# 5.2 - Iteración y Bucles

Hasta ahora hemos invertido tiempo en los diferentes sonidos que puedes crear con bloques de `play` y `sample`. También hemos aprendido a disparar estos sonidos a través de `sleep`.

Como probablemente ya notaste, hay mucha diversión a ser obtenida con estos bloques básicos de construcción. Sin embargo, una dimensión totalmente diferente de diversión se abre cuando comienzas a usar el poder de codificar para estructurar tu música y composiciones. En los próximos segmentos exploraremos algunas de estas poderosas herramientas. Primero están las iteraciones y bucles.

## Repetición

¿Has escrito código que te gustaría se repita unas cuantas veces? Por ejemplo, algo así:

    play 50
    sleep 0.5
    sample :elec_blup
    sleep 0.5
    play 62
    sleep 0.25

¿qué tal si quieeres repetirlo 3 veces? Bueno, podrías hacer algo simple y copiarlo 3 veces:

    play 50
    sleep 0.5
    sample :elec_blup
    sleep 0.5
    play 62
    sleep 0.25
    play 50
    sleep 0.5
    sample :elec_blup
    sleep 0.5
    play 62
    sleep 0.25
    play 50
    sleep 0.5
    sample :elec_blup
    sleep 0.5
    play 62
    sleep 0.25

¡Eso fué bastante código! ¿qué pasa si quieres cambiar el sample a `:elec_plip`? Tendrías que buscar todos los lugares con el original `:elec_blup` y cambiarlo. Más importantemente, ¿qué si quisieras repetir l apieza original 1000 veces? Eso tomaría muchas líneas de código y lugares a los que ir a alterar si quisieses cambiar algo.

## Iteración

De hecho, repetir código debería ser tan fácil como decirle haz esto tres veces. Bueno, así es, casi..Recuerda nuestro viejo amigo el bloque de código, lo podemos usar para marcar el comienzo y final de código que querramos repetir tres veces. Después usamos el código especial `3.times`. Así, en vez de escribir do this three times, escribimos `3.times do` - ¿sencillo, no? Sólo recuerda escribir `end` al final del código que quieras repetir:

    3.times do
      play 50
      sleep 0.5
      sample :elec_blup
      sleep 0.5
      play 62
      sleep 0.25
    end

¿Eso fué mucho más elegante que cortar y pegar! Así crearemos muchas estructuras repetitivas_:

    4.times do
      play 50
      sleep 0.5
    end
    8.times do
      play 55, release: 0.2
      sleep 0.25
    end
    4.times do
      play 50
      sleep 0.5
    end

## Iteraciones anidadas

Podemos insertar iteraciones dentro de iteraciones para crear patrones interesantes. Por ejemplo:

    4.times do
      sample :drum_heavy_kick
      2.times do
        sample :elec_blip2, rate: 2
        sleep 0.25
      end
      sample :elec_snare
      4.times do
        sample :drum_tom_mid_soft
        sleep 0.125
      end
    end

## Bucleando

Si deseas que algo se repita muchas veces, te puedes encontrar usando números realmente grandes como `1000.times do`. En este caso es mejor pedirle a Sonic Pi que repita al infinito (hasta que aprietes el botón de parar). Bucleemos el amen break infinitamente:

    loop do
      sample :loop_amen
      sleep sample_duration :loop_amen
    end

Lo importante de saber acerca de los blucles (loops) es que actúan como hoyos negros para el código. Una vez que se entra ahí, sólo se sale con el botón de parar (stop). Esto significa que si tienes código después del loop, nunca lo escucharás. Por ejemplo, el platillo después de este bucle nunca se ejecutará:

    loop do
      play 50
      sleep 1
    end
    sample :drum_cymbal_open

¡Ahora ve a estructurar tus códigos con iteración y bucles!

# 5.3 - condicionales

Algo común que seguramente querrás hacer es tocar más que notas al azar sino también tomar decisiones al azar y, dependiendo de cómo salga, correr más código u otro código. Por ejemplo, el querer tocar al azar una batería o platillo. Esto lo podemos hacer con `if` .

## Tirar una moneda

Tiremos una moneda: si sale cara, que suene una batería, si sale cruz, que sea un platillo. Fácil. Podemos imitar el tiro de una moneda con la función `one_in` (introducida en la sección de aleatoriedad) especificando una probabilidad de 1 en 2 `one_in(2)`. Entonces podemos utilizar el resultado para decidir entre dos piezas de código, el de batería o el de platillos:

    loop do
      if one_in(2)
        sample :drum_heavy_kick
      else
        sample :drum_cymbal_closed
      end

      sleep 0.5

    end

Debes notar que los `if` están compuestos de tres partes:

- La pregunta a hacer
- La primera elección de código a correr (si la respuesta es ‘si’)
- La segunda elección de código a correr (si la respuesta es ‘no’)

Típico de lenguajes de programación, la noción de ‘sí’ está representada por el término `true` y la noción de ‘no’, por `false`. Así que debemos encontrar una pregunta que nos dé una respuesta `true` o`false` que es exactamente lo que hace `one_in` .

¿notas que la primera opción está envuelta entre el `if` y el `else` y que la segunda opción está envuelta entre el `else` y el `end`?. Igual que con los bloques do/end puedes poner múltiples líneas de código en cualquiera de esos lugares. Por ejemplo:

    loop do
      if one_in(2)
        sample :drum_heavy_kick
        sleep 0.5
      else
        sample :drum_cymbal_closed
        sleep 0.25
      end

    end

Esta vez estaremos pausando por un tiempo distinto dependiendo de cuál elección hagamos.

## Condicional simple “if”

Algunas veces querrás ejecutar sólo una línea de código. Esto es posible al colocar `if` y después la pregunta al final. Por ejemplo:

    use_synth :dsaw
    loop do
      play 50, amp: 0.3, release: 2
      play 53, amp: 0.3, release: 2 if one_in(2)
      play 57, amp: 0.3, release: 2 if one_in(3)
      play 60, amp: 0.3, release: 2 if one_in(4)
      sleep 1.5
    end

Eso tocará acordes de diferentes números con una probabilidad diferente para cada nota .

# 5.4 - Hilos

Así que hiciste una gran línea de bajo y un gran pulso. ¿cómo los tocas al mismo tiempo? Una manera de hacerlo es coserlos juntos manualmente - toca bajo, después un poco de batería y así… Sin embargo, cada vez se vuelve más complicado mantener el timing, especialmente Si’coses’ más y más elementos.

¿qué tal si Sonic Pi pudiese coser todo automáticamente para tí? Bueno, puede y lo hace con algo especial llamado thread.

## Bucles infinitos

Para mantener este ejemplo sencillo, vas a tener que imaginar que es un gran pulso y bajo:

    loop do
      sample :drum_heavy_kick
      sleep 1
    end
    loop do
      use_synth :fm
      play 40, release: 0.2
      sleep 0.5
    end

Como vimos anteriormente, bucles son como ‘hoyos negros’ para el programa, una vez entras a uno, sólo puedes salir de él con el botón ‘stop’. Así que para tocar ambos bucles al mismo tiempo, debemos indicarle a Sonic Pi que queremos comenzar algo al mismo tiempo que el resto del código, aquí es cuando los hilos vienen al rescate.

## Hilos al rescate

    in_thread do
      loop do
        sample :drum_heavy_kick
        sleep 1
      end
    end
    loop do
      use_synth :fm
      play 40, release: 0.2
      sleep 0.5
    end

Al envolver el primer bucle de bloque do/end con `in_thread` le decimos a Sonic Pi que corra los contenidos del bloque do/end exactamente al mismo tiempo que el siguiente bloque do/end (que es nuestro segundo bucle) ¿Inténtalo y escucharás ambos, el bajo y la batería conectados!

Ahora, si quisiésemos añadir un sintetizador, haríamos algo así:

    in_thread do
      loop do
        sample :drum_heavy_kick
        sleep 1
      end
    end
    loop do
      use_synth :fm
      play 40, release: 0.2
      sleep 0.5
    end
    loop do
      use_synth :zawa
      play 52, release: 2.5, phase: 2, amp: 0.5
      sleep 2
    end

Ahora volvemos a tener el mismo problema que antes, ya que los primeros dos bucles se tocan al mismo tiempo, gracias a `in_thread`. Sin embargo, el tercer bucle nunca se alcanza. Por lo tanto, necesitamos otro hilo:

    in_thread do
      loop do
        sample :drum_heavy_kick
        sleep 1
      end
    end
    in_thread do
      loop do
        use_synth :fm
        play 40, release: 0.2
        sleep 0.5
      end
    end
    loop do
      use_synth :zawa
      play 52, release: 2.5, phase: 2, amp: 0.5
      sleep 2
    end

## Ejecutar como hilos

Puede sorprenderte que cuando aprietas el botón de Correr (Run), de hecho estás creando un nuevo hilo para que corra el código. Esta es la razón por la que al apretar el botón múltiples veces, suenan las capas de sonido una encima de la otra, ya que las corridas son de hecho hilos cosidos automáticamente para sonar.

## Ámbito

En cuanto más aprendas Sonic Pi, apreciarás que los hilos son los bloques de construcción más importantes para tú música. Uno de los trabajos más importantes que realiza es aislar la noción de seteos actuales respecto a otros hilos. ¿qué significa eso? Bien, cuando cambias sintetizadores por medio de `use_synth` realmente estás cambiando el sintetizdor en el hilo actual, ya que ningún otro hilo cambiarás su sintetizador. Veamos esto en acción:

    play 50
    sleep 1
    in_thread do
      use_synth :tb303
      play 50
    end
    sleep 1
    play 50

¿Notaste que el sonido de en medio era diferente a los otros? el `use_synth` solamente afectó el hilo en el que se encontraba, no así el hilo externo principal.

## Herencia

Cuando creas un nuevo hilo con `in_thread`, este automáticamente hereda la configuración del hilo actual. Veamos:

    use_synth :tb303
    play 50
    sleep 1
    in_thread do
      play 55
    end

¿Notaste que la segunda nota es tocada por el sintetizador `:tb303` aunque era de un hilo separado? Cualquier seteo modificado con las funciones `use_*` se comportará de igual manera.

Cuando se crean hilos, ellos heredan todos los seteos de su padre, pero no los comparten a su vez.

## Nombres para los Hilos

Por último, podemos darles nombre a los hilos:

    in_thread(name: :bass) do
      loop do
        use_synth :prophet
        play chord(:e2, :m7).choose, release: 0.6
        sleep 0.5
      end
    end
    in_thread(name: :drums) do
      loop do
        sample :elec_snare
        sleep 1
      end
    end

Mira el panel de bitácora cuando corras este código. ¿ves que reporta el nombre del hilo?

    [Run 36, Time 4.0, Thread :bass]
     |- synth :prophet, {release: 0.6, note: 47}

## Sólo es permitido un nombre por hilo

Una cosa más al respecto de nombrar hilos es que sólo un hilo con su nombre puede estar corriendo a la vez. Exploremos esto, considerando el código:

    in_thread do
      loop do
        sample :loop_amen
        sleep sample_duration :loop_amen
      end
    end

Pega eso en un buffer y córrelo. Presiona Correr un par de veces. Escucha la cacofonía de los múltiples amen breaks bucleando desincronizadamente. Ok, ya puedes pararlo.

Esta es la conducta que hemos visto innumerables veces - si presionas el botón Correr, capas de sonidos suenan encima de otras. Así que si tienes un loop y presionas el botón Correr tres veces, obtendrás tres capas de bucles sonando simultáneamente.

sin embargo, con hilos nombrados, es diferente:

    in_thread(name: :amen) do
      loop do
        sample :loop_amen
        sleep sample_duration :loop_amen
      end
    end

Intenta presionando el botón Correr múltiples veces con este código. Sólo escucharás un bucle del amen break. También verás lo siguiente en la bitácora:

    ==> Omitiendo creación de hilo: ya existe un hilo con el nombre :amen.

Sonic Pi te está diciendo que un hilo con el nombre `:amen` ya existe, así que no creará otro.

Esta conducta puede no aparentar utilidad para tí - pero verás que la tiene cuando comencemos a hacer Código-vivo…

# 5.5 - Funciones

Cuando comiences a escribir mucho código, desearás encontrar una manera de organizar y estructurar todo para hacerlo más entendible. Las funciones permiten hacer exactamente eso, permitiéndonos darle nombre a muchas partes de nuestro código. Veamos:

## Definiendo Funciones

    define :foo do
      play 50
      sleep 1
      play 55
      sleep 2
    end

Aquí definimos una nueva función llamada `foo`. Lo hacemos con nuestro viejo amigo el bloque de do/end y la palabra mágica `define` seguidos del nombre que queremos darle a nuestra función. No necesitábamos llamarla `foo`, podríamos haberla llamado cualquier cosa que quisiésemos, tales como `bar`, `baz` o idealmente algo significativo para tí como `main_section` o `lead_riff`.

Recuerda anteponer dos puntos `:` al nombre de la función que defines.

## Llamando las Funciones

Una vez hemos definido nuestra función, podemos llamarla simplemente escribiendo su nombre:

    define :foo do
      play 50
      sleep 1
      play 55
      sleep 0.5
    end
    foo
    sleep 1
    2.times do
      foo
    end

Incluso podemos usar `foo` dentro de bloques de iteración o cualquier lugar donde hayamos escrito `play` o `sample`. Esto nos da una fantástica manera de expresar y crear nuevas palabras significativas a usar en nuestras composiciones.

## Las funciones permanecen en memoria

Hasta ahora, cada vez que presionamos el botón de Ejecutar, Sonic Pi ha comenzado de cero. Sólo conoce lo que está en el buffer actual. No puedes referenciar código en otro buffer o hilo. sin embargo, las funciones cambian eso. Cuando defines una función, Sonic Pi recuerda. Probemos borrando todo el código en tu buffer y reemplazandolo por:

    foo

Presiona el botón de Ejecutar y escucha. ¿Dónde se fue el código?¿cómo supo Sonic Pi qué tocar? Sonic Pi recordó tu función, inclusive cuando la borraste del buffer. Esta conducta sólo funciona con las funciones creadas con `define` (y `defonce`).

## Funciones parametrizadas

Quizás te interese saber que al igual que podías pasar valores mínimos y máximos con `rrand`, también puedes enseñar a tus funciones a aceptar argumentos. Miremos:

    define :my_player do |n|
      play n
    end
    my_player 80
    sleep 0.5
    my_player 90

Esto no es tan excitante, pero ilustra el punto. Creamos nuestra propia versión de `play` llamada `my_player` y la cual está parametrizada.

Los parámetros deben ir después del `do` y `define` en el bloque `do/end`, rodeado de postes verticales `|` y separados por comas `,`. Puedes usar cualquier palabra para los nombres de los parámetros.

Lo mágico sucede dentro del bloque do/end del `define` . Puedes usar nombres de parámetros como si fueran valores reales. En este ejemplo estoy tocando la nota `n`. Puedes considerar los parámetros como una especie de promesa de que cuando el código se ejecute, ellos serán reemplazados por los valores. Esto lo haces al pasar un parámetro a la función, cuando la llamas. Yo lo hago con `my_player 80` para tocar la nota 80. Dentro de la definición de la función `n` se reemplaza con 80, así `play n` se convierte en `play 80`. Cuando la llamo otra vez con `my_player 90`, `n` es reemplazada por 90, así que `play n` se convierte en `play 90`.

Veamos un ejemplo más interesante:

    define :chord_player do |root, repeats|
      repeats.times do
        play chord(root, :minor), release: 0.3
        sleep 0.5
      end
    end
    chord_player :e3, 2
    sleep 0.5
    chord_player :a3, 3
    chord_player :g3, 4
    sleep 0.5
    chord_player :e3, 3

Aquí usé `repeats` como si fuera un número para la línea de `repeats.times do`. También usé `root` como si fuera un nombre de nota en mi llamada a `play`.

¡Nota cómo podemos utilizar algo muy expresivo y fácil de leer sólo con mover mucho de nuestra lógica en el código!

# 5.6 - Variables

Algo útil para hacer con tú código es crear nombres para las cosas. Sonic Pi hace esto muy fácil, escribes el nombre que deseas utilizar, un símbolo de (`=`), después lo que quieres recordar:

    sample_name = :loop_amen

Aquí hemos ‘recordado’ el símbolo `:loop_amen` en la variable `sample_name`. Ahora podemos usar `sample_name` en cualquier lugar donde pudiésemos usar `:loop_amen`. Por ejemplo:

    sample_name = :loop_amen
    sample sample_name

Hay tres razones principales para utilizar variables en Sonic Pi: comunicar significado, administrar repeticón y capturar los resultados de las cosas.

## Comunicando significado

Cuando escribes código, es fácil pensar que sólo le dices a la computadora cómo hacer algo - mientras ella entienda, todo está bien. Sin embargo, es importante recordar que no sólo la computadora leerá el código. Otra gente podría leerlo e intentar comprender qué es lo que sucede. También sucede que quieras entender tu propio código en el futuro. Aunque pueda ser obvio para tí, ahora, ¡podría no serlo para otros o para tí en el futuro! When you write code it’s easy to just think you’re telling the computer how to do stuff - as long as the computer understands it’s OK. However, it’s important to remember that it’s not just the computer that reads the code. Other people may read it too and try to understand what’s going on. Also, you’re likely to read your own code in the future and try to understand what’s going on. Although it might seem obvious to you now - it might not be so obvious to others or even your future self!

Una forma de ayudar a otras personas a entender lo que hace tu código es escribir comentarios (como vimos en una sección anterior). Otra forma es utilizar nombres de variables significativos. Mira este código:

    sleep 1.7533

¿Por qué utiliza el número `1.7533`? ¿de dónde proviene? ¿qué significa? Miremos el código siguiente:

    loop_amen_duration = 1.7533
    sleep loop_amen_duration

Ahora está mucho más claro lo que significa `1.7533`: es la duración del sample `:loop_amen`! claro que puedes pensar que es mucho más simple escribir:

    sleep sample_duration(:loop_amen)

Lo cual es una muy buena manera de comunicar la intención del código.

## Administrando las repeticiones

a menudo ves muchas repeticiones en tu código y cuando quieres cambiar algo, tienes que cambiarlo enmuchos lugares. Mira este código:

    sample :loop_amen
    sleep sample_duration(:loop_amen)
    sample :loop_amen, rate: 0.5
    sleep sample_duration(:loop_amen, rate: 0.5)
    sample :loop_amen
    sleep sample_duration(:loop_amen)

Estamos haciendo muchas cosas con `:loop_amen`! ¿qué pasa si quisiésemos escuchar otro sampleo como `:loop_garzul`? tendríamos que buscar y reemplazar todos los `:loop_amen` con `:loop_garzul`. Eso estaría bien si tienes mucho tiempo - pero ¿qué si está en vivo? algunas veces no tendrás el lujo del tiempo - especialmente si quieres que la gente se mantenga bailando.

¿qué tal si hubieses escrito tú código, así?:

    sample_name = :loop_amen
    sample sample_name
    sleep sample_duration(sample_name)
    sample sample_name, rate: 0.5
    sleep sample_duration(sample_name, rate: 0.5)
    sample sample_name
    sleep sample_duration(sample_name)

Eso hace exactamente lo mismo que lo anterior (pruébalo). también nos da la habilidad de cambiar una línea `sample_name = :loop_amen` a `sample_name = :loop_garzul` y podemos hacerlo en muchos lugares gracias a las variables.

## Capturando los resultados

Un buen motivo para utilizar variables es capturar los resultados de las cosas. Por ejemplo, quizás desees hacer algo con la duración de un sampleo:

    sd = sample_duration(:loop_amen)

Ahora podemos usar `sd` en cualquier lugar donde necesitemos la duración del sampleo `:loop_amen`.

Más importantemente, una variable nos permite capturar el resultado de una llamada a `play` o `sample`:

    s = play 50, release: 8

Ahora hemos atrapado y recordado `s` como una variable, lo que nos permite controlar el sintetizador mientras corre:

    s = play 50, release: 8
    sleep 2
    control s, note: 62

Veremos en más detalle cómo controlar los sintetizadores más tarde.

## Advertencia: Variables e Hilos

Si bien las variables son buenas para nombrar cosas y guardar los resultados de estas, es importante saber que, por lo general, solo deben usarse localmente dentro de un hilo. Por ejemplo, no hagas esto:

    a = (ring 6, 5, 4, 3, 2, 1)
    live_loop :sorted do
      a = a.sort
      sleep 0.5
      puts "sorted: ", a
    end
    live_loop :shuffled do
      a = a.shuffle
      sleep 0.5
    end

En el ejemplo anterior asignamos un anillo de números a una variable `a` y luego lo usamos dentro de dos`live_loop`s separados. En el primer bucle en vivo cada `0.5`s ordenamos el anillo (a`(ring 1, 2, 3, 4, 5, 6)` ) y luego lo imprimimos en el registro. Si ejecuta el código, verá que ¡la lista impresa * no está siempre ordenada! *. Esto puede sorprenderle, especialmente que a veces la lista se imprime como ordenada, y otras no. Esto se llama comportamiento no determinista y es el resultado de un problema bastante desagradable llamado condición de raza. El problema se debe al hecho de que el segundo bucle en vivo también está manipulando la lista (en este caso, mezclándola) y para el momento en que se imprime la lista, a veces simplemente se ha ordenado y, a veces, se ha barajado. Ambos bucles en vivo están compitiendo para hacer algo diferente a la misma variable y cada vez que un ciclo diferente ‘gana’.

Hay dos soluciones a este problema. Primero, no utilices el miso variable en multiples live loops o subprocesos. Por ejemplo, el siguiente código imprimirá siempre una lista ordenada, porque cada live loop tiene su variable separado:

    live_loop :shuffled do
      a = (ring 6, 5, 4, 3, 2, 1)
      a = a.shuffle
      sleep 0.5
    end
    live_loop :sorted do
      a = (ring 6, 5, 4, 3, 2, 1)
      a = a.sort
      sleep 0.5
      puts "sorted: ", a
    end

Sin embargo, a veces queremos compartir datos entre hilos. Por ejemplo, la clave actual, la velocidad, el sintetizador etc. En estos casos, se puede utilizar el sistema especial “thread-safe” de Sonic Pi a través de los fns `get` y `set`. Esto sera discutido luego en la sección 10.

# 5.7 - Sincronización de hilos

Cuando estés lo suficientemente avanzado en live-coding con un número de funciones e hilos simultáneamente, notarás que es muy fácil cometer un error en uno de los hilos y eso lo mata. Eso no es gran cosa, porque puedes fácilmente recomenzar el hilo con apretar Run. Sin embargo, cuando recomiences el hilo estará out of time con los hilos actuales.

## Tiempo heredado

Como discutíamos anteriormente, nuevos hilos creados con `in_thread` heredan todos los seteos del hilo padre. Esto incluye el tiempo actual, lo que significa que los hilos estarán siempre en el tiempo con los demás cuando comenzados simultáneamente.

Sin embargo, cuando comienzas un hilo aparte, comienza con su propio tiempo que difícilmente estará sincronizado con alguno de los otros que estén siendo corridos.

## Cue y Sync (funciones)

Sonic Pi provee una solución a este problema con las funciones `cue` y `sync`.

`cue` permite enviar mensajes de pulso a todos los otros hilos, los cuales, en principio no están interesados e ignoran estos mensajes. Sin embargo. puedes registrar fácilmente su interés con la función `sync`.

Lo importante de notar es que `sync` es similar a `sleep` en que para el hilo actual por un tiempo. Sin embargo, con `sleep` tu especificas cuánto tiempo va a esperar, en cambio con `sync` no sabes cuánto tiempo esperará - ya que `sync` espera por el siguiente `cue` de otro hilo.

Exploremos esto en más detalle:

    in_thread do
      loop do
        cue :tick
        sleep 1
      end
    end
    in_thread do
      loop do
        sync :tick
        sample :drum_heavy_kick
      end
    end

Aquí tenemos dos hilos - uno actuando como un metrónomo, no haciendo sonidos sino que enviando `:tick` mensajes de pulso. El segundo hilo está sincronizandose con los mensajes de `tick` y cuando recibe uno, hereda el tiempo del hilo de `cue` y continúa tocando.

El resultado es que escuchamos el sample de `:drum_heavy_kick` exactamente cuando el otro hilo envía el mensaje `:tick`, aunque ambos hilos no comenzaron su ejecución al mismo tiempo:

    in_thread do
      loop do
        cue :tick
        sleep 1
      end
    end
    sleep(0.3)
    in_thread do
      loop do
        sync :tick
        sample :drum_heavy_kick
      end
    end

Esa llamada `sleep` típicamente haría que el segundo hilo vaya fuera de fase con el primero. Sin embargo, por estar usando `cue` y `sync`, sincronizamos ambos hilos automáticamente.

## Nombres de Cue

Eres libre de utilizar cualquier nombre que quieras a los mensajes de `cue` - no sólo `:tick`. Sólo debes asegurarte que los otros hilos estén `sync` sincronizándose en el nombre correcto - de otro modo se quedarán esperando por siempre (o hasta presionar el botón de Parar).

Juguemos con unos cuantos nombres para `cue`:

    in_thread do
      loop do
        cue [:foo, :bar, :baz].choose
        sleep 0.5
      end
    end
    in_thread do
      loop do
        sync :foo
        sample :elec_beep
      end
    end
    in_thread do
      loop do
        sync :bar
        sample :elec_flip
      end
    end
    in_thread do
      loop do
        sync :baz
        sample :elec_blup
      end
    end

Aquí tenemos un `cue` principal bucleado, el cual envía aleatoriamente uno de los nombres de pulso `:foo`, `:bar` o `:baz`. Después tenemos también tres bucles de hilos sincronizándose entre ellos independientemente y tocando un sampleo diferente. El efecto es que escuchamos un sonido cada 0.5 pulsos que cada uno de los hilos está aleatoriamente sincronizándose `sync` con el hilo de `cue` y toca su sampleo.

Por supuesto que esto también funciona si ordenas los hilos en reversa, ya que los hilos `sync` siempre esperarán al siguiente `cue`.

# 6 - Estudio FX

Uno de los aspectos más satisfactorios y divertidos de Sonic Pi es su habilidad de añadir efectos de estudio a tus sonidos. Por ejemplo, si quieres añadir reverberación, eco o distorsión.

Sonic Pi provee una manera simple y poderosa de añadir efectos FX. Inclusive te permite encadenarlos (así pasas tus sonidos por la distorsión, después el eco y la reverberación). También controlar cada unidad individual de FX con operandos (similar a darle parámetros a los sintetizadores y sampleos). Inclusive puedes modificar los operandos del FX mientras se ejecutan. Por ejemplo, puedes incrementar la reverberación del bajo a través de la pista…

## Pedales de Guitarra

Si todo suena un poco complicado, no te preocupes. Una vez juegues con esto, se aclarará. Antes de eso, una simple analogía es la de los pedales de efectos de una e-guitarra. Hay muchos pedales que puedes comprar. Algunos añaden reverberación, otros distorsión etc. Una guitarrista conecta su guitarra en un pedal, después a otro y así (cadena) La salida del pedal de reverberación termina siendo conectada al amplificador:

    Guitarra -> Distorsión -> Reverberación -> Amplificador

Esto se llama efectos FX en cadena. Sonic Pi soporta eso. Adicionalmente cada pedal a menudo tiene diales y deslizadores para controlar cuánta distorsión, reverberación, eco etc. aplicar. Sonic Pi soporta También esta clase de control. Finalmente, imagina un guitarrista tocar mientras otra persona controla los efectos DX. Sonic Pic también permite esto, pero en vez de otra persona, te permite a tí controlarlo todo.

¡¡ Exploremos los efectos (FX) !!

# 6.1 - Añadiendo efectos FX

En esta sección veremos los efectos: reverberación y eco. Veremos cómo usarlos, controlar sus operandos y encadenarlos. Llamaremos “FX” a los efectos.

El sistema de efectos de Sonic Pi, utiliza bloques. Así que si no has leído la sección 5.1, deberías.

## Reverberación

Si queremos usar reverberación, escribimos `with_fx :reverb` como el código especial para nuestro bloque, así:

    with_fx :reverb do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

Cuando tocas este código tendrá reverberación. ¿suena bien, no? todo suena mejor con reverberación.

Ahora veamos qué sucede si dejamos código fuera del bloque do/end:

    with_fx :reverb do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end
    sleep 1
    play 55

Nota que el lay `play 55` no se ejecutó con reberveración. Esto es porque está fuera del bloque do/end, así que no es capturado por el FX reverberación.

Similarmente, si haces sonidos antes del bloque do/end, tampoco los capturará:

    play 55
    sleep 1
    with_fx :reverb do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end
    sleep 1
    play 55

## Eco

Hay muchos FX (efectos) para escoger. ¿probamos con eco?

    with_fx :echo do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

Uno de los aspectos más sobresalientes de Sonic Pi es que los bloques de efectos operan con parámetros similares a los utilizados con `play` y `sample`. Por ejemplo, un parámetro interesante es `phase:` que representa la duración de un eco dado en pulsos. Hagamos el eco más lento:

    with_fx :echo, phase: 0.5 do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

Ahora hagamos el eco más rápido:

    with_fx :echo, phase: 0.125 do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

Hagamos que al eco le tome 8 pulsos en desvanecerse, gracias a `decay:`

    with_fx :echo, phase: 0.5, decay: 8 do
      play 50
      sleep 0.5
      sample :elec_plip
      sleep 0.5
      play 62
    end

## Anidando FX

Uno de los más poderosos aspectos de los bloques de FX es que puedes anidarlos, con lo que logramos encadenarlos con facilidad. Por ejemplo, si quisieras tocar código con eco y después reverberación, fácilmente pones un Fx dentro de otro:

    with_fx :reverb do
      with_fx :echo, phase: 0.5, decay: 8 do
        play 50
        sleep 0.5
        sample :elec_blup
        sleep 0.5
        play 62
      end
    end

Piensa en el audio fluir desde adentro. El sonido de todo el códido dentro del bloque interno do/end como `play 50` es primero enviado al FX de eco y a su vez, éste es enviado al FX reverberación.

Podemos hacer uso de anidados muy profundos para resultados extremos. Sin embargo, ten presente que los Fx consumen muchos recursos y que al anidarlos estás de hecho corriendo muchos FX simultáneamente. Así que sé consciente de su uso, especialmente en plataformas de bajo rendimiento como la Raspberry Pi.

## Descubriendo FX

Sonic Pi tiene muchos efectos con los cuales jugar. Para verlos, cliquea en FX a la izquierda de este sistema de Ayuda y verás el listado. Aquí te deja algunos de mis favoritos:

- tambaleo,
- reverberación,
- eco,
- distorsión
- rebanador

¡Ahora haz locuras con los FX, añadiéndolos en todas partes para crear nuevos sonidos!

# 6.2 - FX en la práctica

Aunque a simple vista sean simples, los FX son - internamente - unas bestias complejas. Su simplicidad a veces promueve a que la gente los sobre use en su música. Esto no es un problema si tienes una máquina poderosa, pero si - como yo - usas una Raspberry Pi para tus jams, debes ser cuidadoso acerca de cuanto trabajo le asignas para asegurarte que todo fluya sin pausas.

Considera este código:

    loop do
      with_fx :reverb do
        play 60, release: 0.1
        sleep 0.125
      end
    end

En este código estamos tocando la nota 60 con un tiempo de release muy, corto, por lo que es una nota muy corta. También queríamos reverb, así que lo envolvimos en un bloque de reverberación. Todo bien, excepto…

Veamos lo que hace el código. Primero bucleamos para que se repita por siempre todo lo que está dentro de él. Después tenemos un bloque `with_fx` Esto significa que crearemos un FX reverberación cada vez que buclee. Esto es como tener un pedal de reverberación por cada vez que toques una cuerda de la guitarra. Es bueno poder hacerlo, pero no siempre lo querrás. Por ejemplo, este código tendrá dificultades en una Raspberry Pi. Todo el trabajo de crear la reverberación y después esperar hasta que ncesite ser parado y removido, es hecho por `with_fx` pero esto consume mucho del CPU.

¿cómo lo haríamos más similar a cuando un guitarrista tiene sólo un pedal de reverberación a través del cual pasan todos los sonidos? Simple:

    with_fx :reverb do
      loop do
        play 60, release: 0.1
        sleep 0.125
      end
    end

Poniendo nuestro bucle dentro del bloque `with_fx`. Así sólo creamos un paso a reverb para todas las notas del bucle. Este código es mucho más eficiente y funcionará bien en una Raspberry Pi.

Al utilizar `with_fx` sobre una iteración en un bucle:

    loop do
      with_fx :reverb do
        16.times do
          play 60, release: 0.1
          sleep 0.125
        end
      end
    end

De esta forma, hemos sacado el `with_fx` fuera de la parte interna del `loop` y ahora estamos creando un nuevo reverb cada 16 notas.

Éste es un patrón tan común que `with_fx` ofrece una opción para hacer esto mismo, pero sin tener que escribir el bloque `16.times`:

    loop do
      with_fx :reverb, reps: 16 do
        play 60, release: 0.1
        sleep 0.125
      end
    end

Ambos ejemplos, `reps: 16` y `16.times do`, tendrán el mismo comportamiento. Básicamente, el `reps: 16` repite el código dentro del bloque `do/end` 16 veces; así que puedes usar ambos de manera intercambiable, y utilizar aquel que te guste más.

Recuerda que no hay errores, sólo posibilidades. Sin embargo, según qué manera, se producen diferentes sonidos y características de ejecución. Así que experimenta y utiliza lo que te suene mejor y funcione en la plataforma que tengas.

# 7 - Controlando los sonidos en ejecución

Hasta ahora hemos visto cómo disparar sintetizadores y sampleos, cambiar sus operandores tales como amplitude, paneo, seteos de sobres y más. Cada sonido disparado es, esencialmente, su propio sonido con su lista de opciones por la duración del sonido.

¿Te gustaría cambiar los operadores de los sonidos cuando aún están sonando, así como cuando vibras la cuerda de una guitarra?

¡Tienes suerte, pues ésta sección te mostrará cómo hacerlo!

# 7.1 - Controlando Sintetizadores en ejecución

Hasta el momento nos hemos concentrado en disparar nuevos sonidos y FXs. Sin embargo, Sonic Pi te da la posibilidad de manipular y controlar sonidos en ejecución. Esto lo hacemos al utilizar una variable para capturar una referencia de un sintetizador:

    s = play 60, release: 5

Aquí utilizamos una variable de ejecución local, `s` que representa el sintetizador tocando la nota 60. Al ser local no puede ser accesada desde otras ejecuciones, como sucede con las funciones.

Con `s`, utilizaremos la función `control`:

    s = play 60, release: 5
    sleep 0.5
    control s, note: 65
    sleep 0.5
    control s, note: 67
    sleep 3
    control s, note: 72

Es de notar que no se disparan 4 diferentes sintetizadores, sino que usando uno al que le cambiamos los tonos 3 veces durante su ejecución.

Podemos pasar operandos para `control` como `amp`, `cutoff:` o `pan:`.

## Opciones no-controlables

Algunos de los operandos no pueden ser controlados una vez comenzado el sintetizador. Este es el caso de los parámetros de sobres ADSR. Puedes encontrar cuáles operandos sí pueden ser controlados en el sistema de ayuda. Si la documentación dice no puede ser cambiado una vez seteado, es que no puedes controlar los operandos cuando el sintetizador ha comenzado.

# 7.2 - Controlando efectos (FX)

También es posible controlar los efectos, aunque de una manera diferente:

    with_fx :reverb do |r|
      play 50
      sleep 0.5
      control r, mix: 0.7
      play 55
      sleep 1
      control r, mix: 0.9
      sleep 1
      play 62
    end

En vez de usar una variable, usamos parámetros de poste “|” de los bloques do/end. Dentro de los postes `|`, debemos especificar un nombre específico para nuestro efecto en ejecución, el cual después referenciaremos desde el bloque do/end que lo contiene. Esta conducta es idéntica a usar funciones parametricazadas.

¡Ahora ve a controlar sintetizadores y efectos! Now go and control some synths and FX!

# 7.3 - Opciones con Deslizadores

Mientras explorábamos las opciones con sintetizadores y efectos, habrás notado que hay un número de opciones que terminan en `_slide`. Quizás intentaste utilizarlos y no hubo efecto. Esto es porque ellos son parámetros especiales que sólo funcionan cuando controlas los sintetizadores como dijimos en la sección anterior.

Considera el siguiente ejemplo:

    s = play 60, release: 5
    sleep 0.5
    control s, note: 65
    sleep 0.5
    control s, note: 67
    sleep 3
    control s, note: 72

Aquí puedes escuchar el sintetizador cambiando tono inmediatamente en cada llamada de `control`. Sin embargo, quizás querramos que el tono se deslice entre cambios. Ya que estamos controlando el parámetro `note`, para añadir deslizamiento (slide), debemos setear el `note_slide` del sintetizador:

    s = play 60, release: 5, note_slide: 1
    sleep 0.5
    control s, note: 65
    sleep 0.5
    control s, note: 67
    sleep 3
    control s, note: 72

Ahora escuchamos las notas “deslizadas” entre cada llamada de `control`. ¿suena bien, no? Puedes acelerar/desacelerar el arraster usando tiempos más cortos en `note_slide: 0.2`.

Cada parámetro que puede ser controlado, tiene su correspondiente `_slide` con el que jugar.

## Deslizar es pegajoso

Una vez que determines un parámetro de `_slide` en un sintetizador, será recordado y usado cada vez que deslices el correspondiente parámetro. Para detener el deslizamiento, debes setear el valor de `_slide` a 0 antes de la siguiente llamada a control.

## Deslizando opciones de Efectos (FX)

También es posible deslizar opciones de efectos (FX):

    with_fx :wobble, phase: 1, phase_slide: 5 do |e|
      use_synth :dsaw
      play 50, release: 5
      control e, phase: 0.025
    end

Ve y diviértete deslizando todo para unas transiciones suaves y control fluído…

# 8 - Estructuras de Datos

Una herramiento útil para los programadores es la Estrutura de Datos.

Algunas veces puedes desear usar más de una cosa. Por ejemplo, el tocar una serie de notas que se toquen una después de la otra. Los lenguajes de programación tienen estructuras de datos para permitirte eso.

Hay muchas estructuras de datos exóticas y excitantes a disposición de los programadores - y se siguen inventando nuevas. Sin embargo, por ahora sólo 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.

# 8.1 - Listas

En esta sección miraremos una Estructura de Datos muy útil: la Lista. Ya la vimos -brevemente- en la sección de aleatoriedad, cuando de una lista de notas elegía al azar las notas a tocar:

    play choose([50, 55, 62])

Ahora también exploraremos listas que representan acordes y escalas. Primero repasemos cómo tocar un acorde. Recuerda que si no usamos `sleep`, todos los sonidos suceden al mismo tiempo:

    play 52
    play 55
    play 59

Veamos otras maneras de representar este código.

## Ejecutando una Lista

Una opción es colocar todas las notas en una lista: `[52, 55, 59]`. Nuestro amigable `play` es lo suficientemente listo para entender cómo tocar una lista de notas. Probemos:

    play [52, 55, 59]

Ohh, eso ya está mejor para leer. El tocar un listado de notas no significa que no puedas usar los otros parámetros, normalmente:

    play [52, 55, 59], amp: 0.3

Por supuesto, puedes usar los nombres tradicionales de notas en vez de números MIDI:

    play [:E3, :G3, :B3]

Ahora, esos suertudos de ustedes con estudios en teoría musical, podrán reconocer que el acorde es Mi menor tocado en la 3ra octava.

## Accediendo a una Lista

Otro aspecto útil de una lista es la habilidad de obtener información de la misma. Puede sonar extraño, pero es igual a alguien pidiéndote que pases a la página 23 de un libro. Con una lista, dirías, ¿qué elemento hay en el índice 23? Lo único diferente es que en índices de programación se comienza con 0 y no con 1.

Con índices de listas no contamos 1, 2, 3… sino que 0, 1, 2…

Veamos eso en mayor detalle en esta lista:

    [52, 55, 59]

No hay algo espcialmente de susto en ello. Ahora, ¿qué es el segundo elemento en esa lista? Si, claro, es `55`. Fácil. Veamos si la computadora puede respondernoslo, también:

    puts [52, 55, 59][1]

Si se mira algo raro, confía en mí, no lo es. Hay tres partes en la línea de arriba: la palabra `puts`, nuestra lista `52, 55, 59` y nuestro índice `[1]`. Primero pedimos `puts` para que Sonic Pi imprima la respuesta en la bitácora. Después, le damos nuestra lista y finalmente nuestro índice le pide el segundo elemento. Necesitamos rodear nuestro índice con paréntesis cuadrados y ya que el conteo comienza en `0`, el índice para el segundo elemento es `1`. Mira:

    # indexes:  0   1   2
               [52, 55, 59]

Prueba con `puts [52, 55, 59][1]` y verás `55` en la bitácora. Cambia el índice `1` a otros índices, intenta con listas más largas en tu próximo código. Por ejemplo, estructuras musicales que podrían representarse como series de números…

# 8.2 - Acordes

Sonic Pi soporta nombres de acordes que regresarán listas. Pruébalo:

    play chord(:E3, :minor)

¡Ahora estamos en algo!. Eso se mira mucho mejor que listas crudas y es más fácil de leer para otros. ¿qué otros acordes soporta Sonic Pi? Bueno, muchos. Prueba con estos:

- `chord(:E3, :m7)`
- `chord(:E3, :minor)`
- `chord(:E3, :dim7)`
- `chord(:E3, :dom7)`

## Arpegios

Podemos convertir acordes en arpegios con facilidad, gracias a la función `play_pattern`:

    play_pattern chord(:E3, :m7)

Ok, that’s not so fun - it played it really slowly. `play_pattern` will play each note in the list with a call to `sleep 1` after each call to `play`. We can use another function `play_pattern_timed` to specify our own timings and speed things up:

    play_pattern_timed chord(:E3, :m7), 0.25

Inclusive podemos pasar una lista de tiempos, los cuales serán tratados como un círculo de tiempos:

    play_pattern_timed chord(:E3, :m13), [0.25, 0.5]

Eso equivale a:

    play 52, sustain: 0.25
    sleep 0.25
    play 55, sustain: 0.5
    sleep 0.5
    play 59, sustain: 0.25
    sleep 0.25
    play 62, sustain: 0.5
    sleep 0.5
    play 66, sustain: 0.25
    sleep 0.25
    play 69, sustain: 0.5
    sleep 0.5
    play 73, sustain: 0.25
    sleep 0.25

¿qué preferirías escribir?

Note that `play_pattern` and `play_pattern_timed` alter the sustain of the notes to fill the times. You can remove this behavior by setting the `sustain:` opt to `0`:

    play_pattern_timed chord(:E3, :m13), [0.25, 0.5], sustain: 0

# 8.3 - Escalas

Sonic Pi incluye un gran rango de escalas. ¿qué tal tocar una escala de Do3 mayor?

    play_pattern_timed scale(:c3, :major), 0.125, release: 0.1

Podemos pedir para más octavas:

    play_pattern_timed scale(:c3, :major, num_octaves: 3), 0.125, release: 0.1

¿qué tal todas las notas de la escala pentatónica?

    play_pattern_timed scale(:c3, :major_pentatonic, num_octaves: 3), 0.125, release: 0.1

## Notas al Azar

Los Acordes y Escalas son una buena manera de restringir una elección aleatoria para hacer algo significativo. Toca esl siguiente ejemplo que agarra notas al azar del acorde de E3 menor:

    use_synth :tb303
    loop do
      play choose(chord(:E3, :minor)), release: 0.3, cutoff: rrand(60, 120)
      sleep 0.25
    end

Intenta cambiar los nombres de acordes y los rangos de corte.

## Descubriendo Acordes y Escalas

Para saber cuáles acordes y escalas vienen con Sonic Pi, simplemente cliquea el botón Lang a la izquierda de este tutorial y elige acorde o escala de la lista API. En la información en el panel principal, baja hasta ver una larga lista de acordes y escalas (dependiendo de cuál estés viendo).

¡Diviértete y siempre recuerda que no hay errores, sólo oportunidades!

# 8.4 - Anillos

Una variación interesante a las listas, son los anillos. Si sabes algo de programación, puedes haberte topado con anillos de buffers o arrays. Aquí sólo iremos con los anillos - es corto y simple.

En la sección anterior de listas, vimos cómo sacar elementos de ellas a través del mecanismo de indexado:

    puts [52, 55, 59][1]

Ahora, ¿qué sucede si quieres el índice `100`? Bueno, claramente no existe un elemente en el índice 100, ya que sólo hay 3 elementos dentro. Así que Sonic Pi te responderá un `nil`.

Sin embargo, considera que tienes un contador tal como el pulso actual que se va incrementando. Hagamos nuestro contador y lista:

    counter = 0
    notes = [52, 55, 59]

Ahora podemos usar nuestro contador para acceder a una nota de nuestra lista:

    puts notes[counter]

Grandioso, obtuvimos `52`. Ahora, incrementemos nuestro contador y obtengamos otra nota:

    counter = (inc counter)
    puts notes[counter]

Super, obtuvimos `55`y después `59`. Sin embargo, si lo hacemos de nuevo, se nos acaban los números de la lista y obtenemos `nil`. Si quisiésemos buclear y volver a comenzar la lista, usaríamos los anillos.

## Creando Anillos

Podemos crear anillos de dos maneras: con la función `ring`y los elementos del anillo como parámetros:

    (ring 52, 55, 59)

O podemos tomar una lista normal y convertirla a anillo con el mensaje `.ring`:

    [52, 55, 59].ring

## Indexando Anillos

Un anillo puede ser utilizado de la misma manera que una lista, exceptuando que puedes usar índices negativos y mayores al tamaño del anillo mismo, los cuales envolverán y apuntarán siempre a alguno de los elementos del anillo:

    (ring 52, 55, 59)[0] #=> 52
    (ring 52, 55, 59)[1] #=> 55
    (ring 52, 55, 59)[2] #=> 59
    (ring 52, 55, 59)[3] #=> 52
    (ring 52, 55, 59)[-1] #=> 59

## USando Anillos

Usemos una variable para representar el número del pulso actual. Podemos usar esto como un índice a nuestro anillo para agarrar notas a ser tocadas o tiempos de release o cualquier cosa útil que tengamos en nuestro anillo, independientemente del pulso en el que estemos.

## Las escalas y acordes son anillos

Algo útil de saber es que las listas regresadas por `scale` y `acorde` también son anillos que te permiten las accedas con índices arbitrarios.

## Constructores de Anillos

Además de `ring` hay un número de funciones que construyen anillos por nosotros.

- `range` pide especificar un punto de inicio, final y tamaño del paso.
- `bools` permite usar `1`s y `0`s para representar booleanos.
- `knit` permite conectar una secuencia de valores repetidos.
- `spread` crea un anillo de booleanos con distribución euclideana.

Mira la documentación de cada uno para más información.

# 8.5 - Cadenas de Anillos

Otra forma de crear nuevos anillos, además de con constructores como `range` y `spread`, es manipulando anillos existentes.

## Comandos de Cadenas

Para explorar esta idea, mira el siguiente anillo:

    (ring 10, 20, 30, 40, 50)

¿Y si lo queremos de atrás a delante? Bueno, sólo tendríamos que usar el comando `.reverse` para coger el anillo y darle la vuelta:

    (ring 10, 20, 30, 40, 50).reverse  #=> (ring 50, 40, 30, 20, 10)

Ahora bien, ¿y si queremos los tres primeros valores del anillo?

    (ring 10, 20, 30, 40, 50).take(3)  #=> (ring 10, 20, 30)

Finalmente, ¿y si queremos mezclar (barajar) el anillo?

    (ring 10, 20, 30, 40, 50).shuffle  #=> (ring 40, 30, 10, 50, 20)

## Cadenas Múltiples

Por sí sola, ésta es una forma muy potente de crear nuevos anillos. Sin embargo, el verdadero poder viene cuando encadenas unos cuantos de estos comandos juntos.

¿Y qué me dices de desordenar el anillo, quitarle 1 elemento, y después coger los siguientes 3?

Veamos esto por pasos:

1. `(ring 10, 20, 30, 40, 50)` - nuestro anillo inicial
2. `(ring 10, 20, 30, 40, 50).shuffle` - lo desordenamos - `(ring 40, 30, 10, 50, 20)`
3. `(ring 10, 20, 30, 40, 50).shuffle.drop(1)` - quitamos 1 - `(ring 30, 10, 50, 20)`
4. `(ring 10, 20, 30, 40, 50).shuffle.drop(1).take(3)` - cogemos 3 - `(ring 30, 10, 50)`

¿Ves cómo hemos creado una cadena larga de estos métodos con sólo unirlos? Podemos combinarlos en el orden que queramos; ésta es una forma extremadamente rica y potente de generar nuevos anillos a partir de anillos existentes.

## Inmutabilidad

Estos anillos tienen una propiedad muy poderosa e importante. Son inmutables, es decir, no pueden cambiar. Esto significa que la cadena de métodos descrita en esta sección no cambia anillos, sino que crea nuevos anillos. Por eso, puedes compartir anillos entre distintos hilos con total libertad; puedes encadenarlos dentro de un hilo sabiendo que ningún otro hilo usando el mismo anillo se va a ver afectado.

## Métodos de Cadenas Disponibles

Aquí tienes una lista de los métodos de cadenas disponibles, para que juegues con ellos:

- `.reverse` - devuelve una versión del anillo dado la vuelta
- `.sort` - crea una versión ordenada del anillo
- `.shuffle` - crea una versión desordenada del anillo
- `.pick(3)` - devuelve un anillo que es el resultado de llamar `.choose` 3 veces
- `.pick(3)` - devuelve un anillo que es el resultado de llamar `.choose` 3 veces
- `.take(5)` - devuelve un anillo nuevo, que sólo contiene los primeros 5 elementos
- `.drop(3)` - devuelve un anillo nuevo con todos los elementos salvo los 3 primeros
- `.butlast` - devuelve un anillo nuevo sin el último elemento
- `.drop_last(3)` - devuelve un nuevo anillo sin los 3 últimos elementos
- `.take_last(6)`- devuelve un anillo nuevo con sólo los últimos 6 elementos
- `.stretch(2)` - repite cada elemento en el anillo dos veces
- `.repeat(3)` - repite el anillo entero 3 veces
- `.mirror` - añade el anillo a una versión invertida del mismo
- `.reflect` - lo mismo que mirror, pero no duplica el valor del medio
- `.scale(2)` - devuelve un anillo nuevo con todos los elementos multiplicados por 2 (asume que el anillo sólo contiene números)

Por supuesto, estos métodos para cadenas con números, ¡pueden utilizar otros números cualquiera! Así que, siéntete libre de llamar `.drop(5)` en vez de `.drop(3)` si quieres quitar los primeros 5 elementos.

# 9 - Live Coding (Programación en vivo)

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!

# 9.1 - Live Coding (Programación en vivo)

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…

# 9.2 - 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!

# 9.3 - 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 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!

# 9.4 - Ticado

Algo con lo que seguramente te encontrarás haciendo muchas veces al hacer live coding es buclear a través de anillos (rings), para poner notas a melodías, pausas a ritmos, progresiones de acordes, variaciones timbrales, etc. etc.

## Ticking Anillos

Sonic Pi provee una herramienta muy útil para trabajar con anillos dentro de `bucles en vivo`. Se llama el sistema de `tick`, que provee la habilidad de tickear a través de anillos. Veamos un ejemplo:

    counter = 0
    live_loop :arp do
      play (scale :e3, :minor_pentatonic)[counter], release: 0.1
      counter += 1
      sleep 0.125
    end

Esto es equivalente a:

    live_loop :arp do
      play (scale :e3, :minor_pentatonic).tick, release: 0.1
      sleep 0.125
    end

Aquí, simplemente tomamos la escala pentatónica menor de E3 y tickeamos a cada elemento al añadirles `.tick` al final de la declaración de escala. Este tick es local al bucle en vivo, por lo que cada bucle debe tener su propio e independiente tick:

    live_loop :arp do
      play (scale :e3, :minor_pentatonic).tick, release: 0.1
      sleep 0.125
    end
    live_loop :arp2 do
      use_synth :dsaw
      play (scale :e2, :minor_pentatonic, num_octaves: 3).tick, release: 0.25
      sleep 0.25
    end

## Tick

También puedes llamar `tick` como una función estándar y usar el valor como un índice:

    live_loop :arp do
      idx = tick
      play (scale :e3, :minor_pentatonic)[idx], release: 0.1
      sleep 0.125
    end

Sin embargo, es mejor llamar `.tick` al final. La función `tick` está para cuando quieras hacer cosas sofisticadas con el valor de tick y para cuando quieras hacer más que indexar dentro de los anillos.

## Mirar

Lo mágico acerca de tick es que no sólo te da un nuevo índice (o el valor del anillo en ese índice), sino que también te asegura que al próximo llamado de tick, será el próximo valor. Mira los documentos para ver ejemplos de trabajar con `tick` . Sin embargo, por ahora es importante notar que a veces querrás mirar al valor tick actual sin que aumente, lo cual se logra con la función `look`. La cual puede ser utilizada como una función estándar o añadiendo `.look` al final de un anillo. to the end of a ring.

## Nombrando los ticks

Finalmente, algunas veces necesitarás más de un tick por bucle en vivo. Esto lo lograrás nombrando a tus ticks:

    live_loop :arp do
      play (scale :e3, :minor_pentatonic).tick(:foo), release: 0.1
      sleep (ring 0.125, 0.25).tick(:bar)
    end

Aquí estamos utilizando dos ticks, uno para la nota a ser tocada y otro para el tiempo de pausa. Como ambos están en el mismo bucle, debemos separarlos nombrándolos diferentemente. Es lo mismo que hiciéramos con `live_loop` - pasamos un símbolo prefijado con un `:`. En el anterior ejemplo, llamamos a un tick `:foo` y al otro `:bar`. Si queremos mirarlos sólo debemos pasar el nombre del tick a `look`.

## No lo compliques tanto

La mayor parte del poder del sistema de tick no es útil al comenzar. No intentes aprender todo en esta sección, enfócate en el tick de un sólo anillo. Eso es lo que más te beneficiará y simplificará tickear dentro de anillos en `bucles en vivo`.

Mira la documentación de `tick`, donde tienes muchos ejemplos.

# 10 - Estado del Tiempo (Time State)

A menudo es útil tener información que es compartida a través de múltiples hilos o bucles en vivo. Por ejemplo, es posible que quieras compartir una noción de la clave actual, el BPM o incluso conceptos más abstractos como la “complejidad” actual (que potencialmente se interpretaría de diferentes maneras a través de diferentes hilos). Tampoco queremos perder ninguna de nuestras garantías de determinismo existentes al hacer esto. En otras palabras, nos gustaría seguir siendo capaces de compartir el código con otros y saber exactamente lo que van a escuchar cuando lo ejecuten. Al final de la Sección 5.6 de este tutorial discutimos brevemente por qué no deberíamos usar variables para compartir información entre hilos debido a la pérdida de determinismo (a su vez debido a las condiciones de carrera).

La solución de Sonic Pi al problema de trabajar fácilmente con variables globales de forma determinista es a través de un novedoso sistema que denomina Time State. Esto puede sonar complejo y difícil (de hecho, en el Reino Unido, programar con múltiples hilos y memoria compartida suele ser una asignatura de nivel universitario). Sin embargo, como verás, al igual que cuando tocas tu primera nota, Sonic Pi hace que sea increíblemente sencillo compartir el estado entre hilos sin dejar de mantener tus programas seguros y deterministas.

Dales la bienvenida a `get` y `set`…

# 10.1 - Set y Get

Sonic Pi tiene un almacén de memoria global llamado Time State. Las dos cosas principales que se hacen con él son `set` (establecer) información y `get` (obtener) información. Vamos a profundizar…

## Set

Para almacenar información en el Time State necesitamos dos cosas:

1. los datos que queremos almacenar,
2. un nombre único (clave) para los datos.

Por ejemplo, puede ser que queremos almacenar el número `3000` con la clave `:intensity`. Eso es posible utilizando la función `set`:

    set :intensity, 3000

Podemos utilizar cualquier nombre para nuestra clave. Si esta clave ya tiene datos almacenados, nuestro nuevo `set` tendrá primacía:

    set :intensity, 1000
    set :intensity, 3000

En el ejemplo anterior, como almacenamos ambos números bajo la misma clave, la última llamada a `set` ‘gana’, por lo que el número asociado a `:intensidad` será `3000` ya que la primera llamada a `set` es efectivamente anulada.

## Get

Para obtener la información del Time State sólo necesitamos la clave que utilizamos para `set` (establecerlo), que en nuestro caso es `:intensity`. Entonces sólo tenemos que llamar a `get[:intensity]` que podemos ver imprimiendo el resultado en el registro:

    print get[:intensity] #=> imprime 3000

Observa que las llamadas a `get` pueden devolver información que fue `set` en una ejecución anterior. Una vez que una pieza de información ha sido “fijada”, está disponible hasta que la información sea sobrescrita (al igual que el valor de `:intensity` de `1000` a `3000`) o Sonic Pi se cierra.

## Hilos

La principal ventaja del sistema Time State es que puede utilizarse de forma segura entre hilos o bucles vivos. Por ejemplo, puedes tener un bucle vivo estableciendo información y otro obteniéndola:

    live_loop :setter do
      set :foo, rrand(70, 130)
      sleep 1
    end
    live_loop :getter do
      puts get[:foo]
      sleep 0.5
    end

Lo bueno de usar `get` y `set` entre hilos de esta manera es que siempre va a producir el mismo resultado cada vez que ejecutas el código. Adelante, intentalo. Verás lo siguiente en tu bitácora:

    {run: 0, time: 0.0}
     └─ 125.72265625
    {run: 0, time: 0.5}
     └─ 125.72265625
    {run: 0, time: 1.0}
     └─ 76.26220703125
    {run: 0, time: 1.5}
     └─ 76.26220703125
    {run: 0, time: 2.0}
     └─ 114.93408203125
    {run: 0, time: 2.5}
     └─ 114.93408203125
    {run: 0, time: 3.0}
     └─ 75.6048583984375
    {run: 0, time: 3.5}
     └─ 75.6048583984375

Intenta correrlo unas cuantas veces - ¿Lo ves? Es el mismo resultado cada vez. Esto es lo que llamamos comportamiento determinista y es bastante importante cuando compartimos nuesta música como código y saber que la persona que está ejecutando el código está escuchando exactamente lo que quisimos que escuchara (justo como cuando reproducimos un MP3 o una transmisión por internet, todos los oyentes escuchan lo mismo).

## Un Sistema de Estados Determinista Simple

Ya en la Sección 5.6 discutimos por qué el uso de variables entre hilos puede conducir a un comportamiento aleatorio. Esto nos impide poder reproducir de manera fiable un código como este:

    ## An Example of Non-Deterministic Behaviour
    ## (due to race conditions caused by multiple
    ## live loops manipulating the same variable
    ## at the same time).
    ##
    ## If you run this code you'll notice
    ## that the list that's printed is
    ## not always sorted!
    a = (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      a = a.shuffle
      sleep 0.5
    end
    live_loop :sorted do
      a = a.sort
      sleep 0.5
      puts "sorted: ", a
    end

Echemos un vistazo a cómo se vería esto usando `get` y`set`:

    ## An Example of Deterministic Behaviour
    ## (despite concurrent access of shared state)
    ## using Sonic Pi's new Time State system.
    ##
    ## When this code is executed, the list that's
    ## printed is always sorted!
    set :a, (ring 6, 5, 4, 3, 2, 1)
    live_loop :shuffled do
      set :a, get[:a].shuffle
      sleep 0.5
    end
    live_loop :sorted do
      set :a, get[:a].sort
      sleep 0.5
      puts "sorted: ", get[:a]
    end

Nota como este código es casi identico a la versión donde se utiliza una variable antes de. Sin embargo cuando corres el código, se comporta como esperarías de cualquier código típico de Sonic Pi -hace exactamente lo mismo cada vez- en este caso gracias al sistema de Time State.

Siendo así, cuando compartimos información entre live loops e hilos, es preferible usar `get` y `set` en vez de variables para un comportamiento determinista y reproducible.

# 10.2 - Sincronización (Sync)

La sección 5.7 introdujo las funciones `cue` y `sync` para lidiar con el problema de sincronización de hilos. Lo que no explicó fue que es el sistema Time State es quien provee esta funcionalidad. Resulta que `set` es solo una variante de `cue` y está construido sobre la misma funcionalidad base la cual es insertar información en el sistema Time State. Adicionalmente, `sync` tambien está diseñado de tal manera que funcione sin líos con Time State - podemos sincronizarnos conrespecto a cualquier información que planeemos almacenar en Time State. En otras palabras - Usamos `sync` sobre eventos prontos a insertarse en Time State.

## Esperando eventos

Echemos un vistazo rápido de como usar `sync` para esperar a que nuevos eventos sean agregados a Time State:

    in_thread do
      sync :foo
      sample :ambi_lunar_land
    end
    sleep 2
    set :foo, 1

En este ejemplo primero creamos un hilo que espera a que un evento `:foo` sea añadido al Estado de Tiempo. Después de la declaración de este hilo, dormimos durante 2 tiempos y luego `set`-emos `:foo` a `1`. Esto libera el `sync` que pasa a la siguiente línea que es la de activar la muestra `:ambi_lunar_land`.

Ten en cuenta que `sync` siempre espera a eventos futuros y que va a bloquear el hilo de ejecución actual mientras espera al nuevo evento. Ademas, va a heredar el tiempo lógico del hilo que lo usó mediante `set` o `cue`de tal manera de que puede ser usado para sincronizar tiempo.

## Pasar valores hacia el futuro

En el ejemplo anterior hemos puesto `:foo` a `1` con el que no hemos hecho nada. En realidad podemos obtener este valor del hilo que llama a `sync`:

    in_thread do
      amp = sync :foo
      sample :ambi_lunar_land, amp: amp
    end
    sleep 2
    set :foo, 0.5

Note that values that are passed through `set` and `cue` must be thread safe - i.e. immutable rings, numbers, symbols or frozen strings. Sonic Pi will throw an error if the value you are attempting to store in the Time State is not valid.

# 10.3 - Pattern Matching

Al obtener y establecer información en el Estado de Tiempo, es posible utilizar claves más complejas que los símbolos básicos como `:foo` y `:bar`. También se pueden utilizar cadenas de estilo URL llamadas rutas como `"/foo/bar/baz"`. Una vez que empecemos a trabajar con rutas, podemos empezar a aprovechar el sofisticado sistema de concordancia de patrones de Sonic Pi para `get` (obtener) y `sync` (sincronizar) con rutas similares en lugar de idénticas. Echemos un vistazo.

## Match any path segment

Let’s assume we want to wait for the next event that has three path segments:

    sync "/*/*/*"

This will match any Time State event with exactly three path segments, regardless of their names. For example:

- foo
- foo
- `cue "/eggs/beans/toast"`
- `cue "/moog/synths/rule"`

However, it will not match paths with fewer or more path segments. The following will not match:

- foo
- foo
- `cue "/eggs"`

Each `*` means any content. So we could match paths with just one segment with `/*` or paths with five segments with `/*/*/*/*/*`

## Matching partial segments

Si sabemos con qué va a empezar o terminar el segmento, podemos utilizar un `*` además de un nombre de segmento parcial. Por ejemplo: `"/foo/b*/baz"` coincidirá con cualquier ruta que tenga tres segmentos, el primero de los cuales es `foo`, el último `baz` y el segmento del medio puede ser cualquier cosa que empiece por `b`. Por lo tanto, coincidiría:

- foo
- foo
- foo

Sin embargo, esto no sería igual lo siguiente:

- foo
- foo
- foo

También puede colocar el `*` al principio del segmento para especificar los últimos caracteres de un segmento: `"/foo/*zz/baz"` que coincidirá con cualquier `cue` o `set` de 3 segmentos donde el primer segmento sea `foo`, el último sea `baz` y el segmento del medio termine con `zz` como `"cue "/foo/whizz/baz"`.

## Coincidiendo Segmentos de la Ruta Anidados

A veces no se sabe con cuántos segmentos de la ruta se quiere hacer coincidir. En estos casos puede utilizar la poderosa estrella doble: `**` como `"/foo/**/baz"` que coincidirá:

- foo
- foo
- foo
- foo

## Coincidiendo de a una Letra

Puedes usar el caracter `?` para coincidir un caracter en particular como por ejemplo `"/?oo/bar/baz"` coincidirá con:

- foo
- `cue "/goo/bar/baz"`
- `cue "/too/bar/baz"`
- `cue "/woo/bar/baz"`

## Coincidiendo Multiples Palabras

Si sabe que un segmento puede ser uno de un número selecto de palabras, puede utilizar los comparadores `{` y `}` para especificar una lista de opciones como `"/foo/{bar,beans,eggs}/quux"` que sólo coincidirá con lo siguiente:

- foo
- foo
- foo

## Coincidiendo Multiples Letras

Por último, puede comparar con una selección de letras si utiliza los comparadores `[` y `]` para especificar una lista de opciones como `"/foo/[abc]ux/baz"` que sólo coincidirá:

- foo
- foo
- foo

También puede utilizar el carácter `-` para especificar rangos de letras. Por ejemplo, `"/foo/[a-e]ux/baz"`, que sólo coincidirá con:

- foo
- foo
- foo
- foo
- foo

## Combinando Algoritmos de Coincidencia

Al llamar a `sync` o `get` eres libre de combinar “matchers” en el orden que consideres oportuno para hacer coincidir poderosamente cualquier evento de Time State creado por `cue` o `set`. Veamos un ejemplo muy rebuscado:

    in_thread do
      sync "/?oo/[a-z]*/**/ba*/{quux,quaax}/"
      sample :loop_amen
    end
    sleep 1
    cue "/foo/beans/a/b/c/d/e/bark/quux/"

## Coincidencia de patrones OSC

For those curious, these matching rules are based on the Open Sound Control pattern matching specification which is explained in detail here: https://opensoundcontrol.stanford.edu/spec-1_0.html

# 11 - MIDI

Once you’ve mastered converting code to music, you might wonder - what’s next? Sometimes the constraints of working purely within Sonic Pi’s syntax and sound system can be exciting and put you into a new creative position. However, sometimes it is essential to break out of the code into the real world. We want two extra things:

1. To be able to convert actions in the real world into Sonic Pi events to code with
2. To be able to use Sonic Pi’s strong timing model and semantics to control and manipulate objects in the real world

Luckily there’s a protocol that’s been around since the 80s that enables exactly this kind of interaction - MIDI. There’s an incredible number of external devices including keyboards, controllers, sequencers, and pro audio software that all support MIDI. We can use MIDI to receive data and also use it to send data.

Sonic Pi provides full support for the MIDI protocol enabling you to connect your live code to the real world. Let’s explore it further…

# 11.1 - MIDI In

In this section we will learn how to connect a MIDI controller to send events into Sonic Pi to control our synths and sounds. Go and grab a MIDI controller such as a keyboard or control surface and let’s get physical!

## Connecting a MIDI Controller

Para obtener información de un dispositivo MIDI externo hacia Sonic Pi primero se necesita conectarlo al computador. Usualmente esto será por conexión USB, sin embargo dispositivos más viejos tendrán un conector DIN de 5 pines para los cuales necesitarás hardware adicional del computador para soportar su uso (por ejemplo, algunas tarjetas de sonido usan conectores DIN para MIDI). Una vez conectado el dispositivo, arranca Sonic Pi y observa la sección de IO en el Panel de Preferencias. Deberías ver el dispositivo listado aquí. De lo contrario, intenta con el botón de ‘Reiniciar MIDI’ y mirar si aparece. Si aún no algo, lo siguiente es intentar consultar la configuración de MIDI de tu sistema operativo y ver si allí aparece. Si todo lo anterior falla, tomate la libertad de preguntar en nuestros amigables foros: https://in-thread.sonic-pi.net

## Recibiendo Eventos MIDI

Una vez tu dispositivo este conectado, Sonic Pi automaticamente recibirá eventos MIDI. Puedes verlo tú mismo manipulando tu dispositivo MIDI y observando la bitácora cue en la esquina inferior derechade la aplicación, justo abajo del log (si eso no es visible, ve a Preferencias->Editor->Ver & Ocultar y activa caja de ‘Mostrar cue log’). Verás una hilera de eventos como estos:

    /midi:nanokey2_keyboard:0:1/note_off  [55, 64]
    /midi:nanokey2_keyboard:0:1/note_on   [53, 102]
    /midi:nanokey2_keyboard:0:1/note_off  [57, 64]
    /midi:nanokey2_keyboard:0:1/note_off  [53, 64]
    /midi:nanokey2_keyboard:0:1/note_on   [57, 87]
    /midi:nanokey2_keyboard:0:1/note_on   [55, 81]
    /midi:nanokey2_keyboard:0:1/note_on   [53, 96]
    /midi:nanokey2_keyboard:0:1/note_off  [55, 64]

Once you can see a stream of messages like this, you’ve successfully connected your MIDI device. Congratulations, let’s see what we can do with it!

## MIDI Time State

Estos eventos se dividen en dos secciones. En primer lugar está el nombre del evento como `/midi:nanokey2_keyboard:0:1/note_on` y en segundo lugar están los valores del evento como `[18, 62]`. Curiosamente, estas son las dos cosas que necesitamos para almacenar la información en Time State. Sonic Pi inserta automáticamente los eventos MIDI entrantes en Time State. Esto significa que puedes `get` (obtener) el último valor MIDI y también `sync` para esperar el próximo valor MIDI usando todo lo que aprendimos en la sección 10 de este tutorial.

## Controlando efectos (FX)

Now we’ve connected a MIDI device, seen its events in the cue log and discovered that our knowledge of Time State is all we need to work with the events, we can now start having fun. Let’s build a simple MIDI piano:

    live_loop :midi_piano do
      note, velocity = sync "/midi:nanokey2_keyboard:0:1/note_on"
      synth :piano, note: note
    end

There’s a few things going on in the code above including some issues. Firstly, we have a simple `live_loop` which will repeat forever running the code between the `do`/`end` block. This was introduced in Section 9.2. Secondly, we’re calling `sync` to wait for the next matching Time State event. We use a string representing the MIDI message we’re looking for (which is the same as was displayed in the cue logger). Notice that this long string is provided to you by Sonic Pi’s autocompletion system, so you don’t have to type it all out by hand. In the log we saw that there were two values for each MIDI note on event, so we assign the result to two separate variables `note` and `velocity`. Finally we trigger the `:piano` synth passing our note.

Now, you try it. Type in the code above, replace the sync key with a string matching your specific MIDI device and hit Run. Hey presto, you have a working piano! However, you’ll probably notice a couple of problems: firstly all the notes are the same volume regardless of how hard you hit the keyboard. This can be easily fixed by using the velocity MIDI value and converting it to an amplitude. Given that MIDI has a range of 0->127, to convert this number to a value between 0->1 we just need to divide it by 127:

    live_loop :midi_piano do
      note, velocity = sync "/midi:nanokey2_keyboard:0:1/note_on"
      synth :piano, note: note, amp: velocity / 127.0
    end

Update the code and hit Run again. Now the velocity of the keyboard is honoured. Next, let’s get rid of that pesky pause.

## Eliminar la latencia

Before we can remove the pause, we need to know why it’s there. In order to keep all the synths and FX well-timed across a variety of differently capable CPUs, Sonic Pi schedules the audio in advance by 0.5s by default. (Note that this added latency can be configured via the fns `set_sched_ahead_time!` and `use_sched_ahead_time`). This 0.5s latency is being added to our `:piano` synth triggers as it is added to all synths triggered by Sonic Pi. Typically we really want this added latency as it means all synths will be well timed. However, this only makes sense for synths triggered by code using `play` and `sleep`. In this case, we’re actually triggering the `:piano` synth with our external MIDI device and therefore don’t want Sonic Pi to control the timing for us. We can turn off this latency with the command `use_real_time` which disables the latency for the current thread. This means you can use real time mode for live loops that have their timing controlled by `sync`ing with external devices, and keep the default latency for all other live loops. Let’s see:

    live_loop :midi_piano do
      use_real_time
      note, velocity = sync "/midi:nanokey2_keyboard:0:1/note_on"
      synth :piano, note: note, amp: velocity / 127.0
    end

Update your code to match the code above and hit Run again. Now we have a low latency piano with variable velocity coded in just 5 lines. Wasn’t that easy!

## Manos a la Obra

Finally, as our MIDI events are going straight into the Time State, we can also use the `get` fn to retrieve the last seen value. This doesn’t block the current thread and returns `nil` if there’s no value to be found (which you can override by passing a default value - see the docs for `get`). Remember that you can call `get` in any thread at any time to see the latest matching Time State value. You can even use `time_warp` to jump back in time and call `get` to see past events…

## Now You are in Control

Lo mejor es que ahora puedes usar las mismas estructuras de código para `sync` (sincronizar) y `get` (obtener) información MIDI de cualquier dispositivo MIDI y hacer lo que quieras con los valores. ¡Ahora puedes elegir lo que hará tu dispositivo MIDI!

# 11.2 - MIDI Out

In addition to receiving MIDI events we can also send out MIDI events to trigger and control external hardware synths, keyboards and other devices. Sonic Pi provides a full set of fns for sending various MIDI messages such as:

1. Note on - `midi_note_on`
2. Note off - `midi_note_off`
3. Control change - `midi_cc`
4. Pitch bend - `midi_pitch_bend`
5. Clock ticks - `midi_clock_tick`

There are many other supported MIDI messages too - check out the API documentation for all the other fns that start with `midi_`.

## Connecting to a MIDI Device

In order to send a MIDI message to an external device, we must first have connected it. Check out the subsection ‘Connecting a MIDI Controller’ in section 11.1 for further details. Note that if you’re using USB, connecting to a device which you’re sending to (rather than receiving from) is the same procedure. However, if you’re using the classic DIN connectors, make sure you connect to the MIDI out port of your computer. You should see your MIDI device listed in the preferences pane.

## Sending MIDI events

The many `midi_*` fns work just like `play`, `sample` and `synth` in that they send a message at the current (logical) time. For example, to spread out calls to the `midi_*` fns you need to use `sleep` just like you did with `play`. Let’s take a look:

    midi_note_on :e3, 50

This will send a MIDI note on event to the connected MIDI device with velocity 50. (Note that Sonic Pi will automatically convert notes in the form `:e3` to their corresponding MIDI number such as 52 in this case.)

If your connected MIDI device is a synthesiser, you should be able to hear it playing a note. To disable it use `midi_note_off`:

    midi_note_off :e3

## Selecting a MIDI device

By default, Sonic Pi will send each MIDI message to all connected devices on all MIDI channels. This is to make it easy to work with a single connected device without having to configure anything. However, sometimes a MIDI device will treat MIDI channels in a special way (perhaps each note has a separate channel) and also you may wish to connect more than one MIDI device at the same time. In more complicated setups, you may wish to be more selective about which MIDI device receives which message(s) and on which channel.

We can specify which device to send to using the `port:` opt, using the device name as displayed in the preferences:

    midi_note_on :e3, port: "moog_minitaur"

We can also specify which channel to send to using the `channel:` opt (using a value in the range 1-16):

    midi_note_on :e3, channel: 3

Of course we can also specify both at the same time to send to a specific device on a specific channel:

    midi_note_on :e3, port: "moog_minitaur", channel: 5

## MIDI Studio

Finally, a really fun thing to do is to connect the audio output of your MIDI synthesiser to one of the audio inputs of your soundcard. You can then control your synth with code using the `midi_*` fns and also manipulate the audio using `live_audio` and FX:

    with_fx :reverb, room: 1 do
      live_audio :moog
    end
    live_loop :moog_trigger do
      midi (octs :e1, 3).tick, sustain: 0.1
      sleep 0.125
    end

(The fn `midi` is available as a handy shortcut to sending both note on and note off events with a single command. Check out its documentation for further information).

# 12 - OSC

In addition to MIDI, another way to get information in and out of Sonic Pi is via the network using a simple protocol called OSC - Open Sound Control. This will let you send messages to and from external programs (both running on your computer and on external computers) which opens up the potential for control way beyond MIDI which has limitations due to its 1980s design.

For example, you could write a program in another programming language which sends and receives OSC (there are OSC libraries for pretty much every common language) and work directly with Sonic Pi. What you can use this for is only limited by your imagination.

# 12.1 - Receiving OSC

Por defecto, cuando Sonic Pi se lanza, escucha el puerto 4560 para los mensajes OSC entrantes de los programas en el mismo ordenador. Esto significa que sin ninguna configuración, puede enviar a Sonic Pi un mensaje OSC y se mostrará en el registro de cue al igual que los mensajes MIDI entrantes. Esto también significa que cualquier mensaje OSC entrante también se añade automáticamente al Time State, lo que significa que también puede utilizar `get` y `sync` para trabajar con los datos entrantes - al igual que con MIDI y la sincronización de `live_loops` - ver las secciones 5.7 y 10.2 para recapitular cómo funciona.

## A Basic OSC Listener

Let’s build a basic OSC listener:

    live_loop :foo do
      use_real_time
      a, b, c = sync "/osc*/trigger/prophet"
      synth :prophet, note: a, cutoff: b, sustain: c
    end

In this example we described an OSC path `"/osc*/trigger/prophet"` which we’re syncing on. This can be any valid OSC path (all letters and numbers are supported and the `/` is used like in a URL to break up the path to multiple words). The `/osc` prefix is added by Sonic Pi to all incoming OSC messages, so we need to send an OSC message with the path `/trigger/prophet` for our `sync` to stop blocking and the prophet synth to be triggered.

## Sending OSC to Sonic Pi

We can send OSC to Sonic Pi from any programming language that has an OSC library. For example, if we’re sending OSC from Python we might do something like this:

    from pythonosc import osc_message_builder
    from pythonosc import udp_client
    sender = udp_client.SimpleUDPClient('127.0.0.1', 4560)
    sender.send_message('/trigger/prophet', [70, 100, 8])

Or, if we’re sending OSC from Clojure we might do something like this from the REPL:

    (use 'overtone.core)
    (def c (osc-client "127.0.0.1" 4560))
    (osc-send c "/trigger/prophet" 70 100 8)

## Receiving from External Machines

For security reasons, by default Sonic Pi does not let remote machines send it OSC messages. However, you can enable support for remote machines in Preferences->IO->Networked OSC->Allow OSC from other computers. Once you’ve enabled this, you can receive OSC messages from any computer on your network. Typically the sending machine will need to know your IP address (a unique identifier for your computer on your network - kind of like a phone number or an email address). You can discover the IP address of your computer by looking at the IO section of the preferences pane. (If your machine happens to have more than one IP address, hovering the mouse over the listed address will pop up with a list of all known addresses).

Note, some programs such as TouchOSC for iPhone and Android support sending OSC as a standard feature. So, once you’re listening to remote machines and know your IP address you can instantly start sending messages from apps like TouchOSC which enable you to build your own custom touch controls with sliders, buttons, dials etc. This can provide you with an enormous range of input options.

# 12.2 - Sending OSC

In addition to receiving OSC and working with it using Time State, we can also send out OSC messages in time with our music (just like we can send out MIDI messages in time with our music). We just need to know which IP address and port we’re sending to. Let’s give it a try:

    use_osc "localhost", 4560
    osc "/hello/world"

If you run the code above, you’ll notice that Sonic Pi is sending itself an OSC message! This is because we set the IP address to the current machine and the port to the default OSC in port. This is essentially the same as posting a letter to yourself - the OSC packet is created, leaves Sonic Pi, gets to the network stack of the operating system which then routes the packet back to Sonic Pi and then it’s received as a standard OSC message and is visible in the cue logger as the incoming message `/osc:127.0.0.1:4560/hello/world`. (Notice how Sonic Pi automatically prefixes all incoming OSC messages with `/osc` and then the hostname and port of the sender.)

## Sending OSC to other programs

Of course, sending OSC messages to ourselves may be fun but it’s not that useful. The real benefit starts when we send messages to other programs:

    use_osc "localhost", 123456
    osc "/hello/world"

In this case we’re assuming there’s another program on the same machine listening to port 123456. If there is, then it will receive a `"/hello/world` OSC message with which it can do what it wants.

If our program is running on another machine, we need to know its IP address which we use instead of `"localhost"`:

    use_osc "192.168.10.23", 123456
    osc "/hello/world"

Now we can send OSC messages to any device reachable to us via our local networks and even the internet!

# 13 - Audio multicanal

So far, in terms of sound production, we’ve explored triggering synths and recorded sounds via the fns `play`, `synth` and `sample`. These have then generated audio which has played through our stereo speaker system. However, many computers also have the ability to input sound, perhaps through a microphone, in addition to the ability to send sound out to more than two speakers. Often, this capability is made possible through the use of an external sound card - these are available for all platforms. In this section of the tutorial we’ll take a look at how we can take advantage of these external sound cards and effortlessly work with multiple channels of audio in and out of Sonic Pi.

# 13.1 - Sound In

One simple (and perhaps familiar) way of accessing sound inputs is using our friend `synth` by specifying the `:sound_in` synth:

    synth :sound_in

This will operate just like any synth such as `synth :dsaw` with the exception that the audio generated will be read directly from the first input of your system’s sound card. On laptops, this is typically the built-in microphone, but if you have an external sound card, you can plug any audio input to the first input.

## Duración

One thing you might notice is that just like `synth :dsaw` the `:sound_in` synth only lasts for 1 beat as it has a standard envelope. If you’d like to keep it open for a little longer, change the ADSR envelope settings. For example the following will keep the synth open for 8 beats before closing the connection:

    synth :sound_in, sustain: 8

## Añadiendo efectos FX

Of course, just like any normal synth, you can easily layer on effects with the FX block:

    with_fx :reverb do
      with_fx :distortion do
        synth :sound_in, sustain: 8
      end
    end

If you have plugged in a guitar to your first input, you should be able to hear it with distortion and reverb until the synth terminates as expected.

You are free to use the `:sound_in` synth as many times as you like concurrently (just like you would do with any normal synth). For example, the following will play two `:sound_in` synths at the same time - one through distortion and one through reverb:

    with_fx :distortion do
      synth :sound_in, sustain: 8
    end
    with_fx :reverb do
      synth :sound_in, sustain: 8
    end

## Cadenas Múltiples

You can select which audio input you want to play with the `input:` opt. You can also specify a stereo input (two consecutive inputs) using the `:sound_in_stereo` synth. For example, if you have a sound card with at least three inputs, you can treat the first two as a stereo stream and add distortion and the third as a mono stream and add reverb with the following code:

    with_fx :distortion do
      synth :sound_in_stereo, sustain: 8, input: 1
    end
    with_fx :reverb do
      synth :sound_in, sustain: 8, input: 3
    end

## Problemas potenciales

However, although this is a useful technique, there are a couple of limitations to this approach. Firstly, it only works for a specific duration (due to it having an ADSR envelope) and secondly, there’s no way to switch the FX around once the synth has been triggered. Both of these things are typical requests when working with external audio feeds such as microphones, guitars and external synthesisers. We’ll therefore take a look at Sonic Pi’s solution to the problem of manipulating a (potentially) infinite stream of live audio input: `live_audio`.

# 13.2 - Live Coding (Programación en vivo)

The `:sound_in` synth as described in the previous section provides a very flexible and familiar method for working with input audio. However, as also discussed it has a few issues when working with a single input of audio as a single instrument (such as a voice or guitar). By far the best approach to working with a single continuous stream of audio is to use `live_audio`.

## A Named Audio Input

`live_audio` shares a couple of core design constraints with `live_loop` (hence the similar name). Firstly it must have a unique name and secondly only one `live_audio` stream with that name may exist at any one time. Let’s take a look:

    foo

This code will act in a similar fashion to `synth :sound_in` with some key differences: it runs forever (until you explicitly stop it) and you can move it to new FX contexts dynamically.

## Working with FX

On initial triggering `live_audio` works exactly as you might expect it to work with FX. For example, to start a live audio stream with added reverb simply use a `:reverb` FX block:

    with_fx :reverb do
      live_audio :foo
    end

However, given that `live_audio` runs forever (at least until you stop it) it would be pretty limiting if, like typical synths, the live audio was bound within the `:reverb` FX for its entire existence. Luckily this is not the case and it was designed to be easy to move between different FX. Let’s try it. Run the code above to hear live audio coming directly from the first input of your sound card. Note, if you’re using a laptop, this will typically be out of your built-in microphone, so it’s recommended to use headphones to stop feedback.

Ahora, mientras sigues escuchando el audio en directo desde la tarjeta de sonido con reverberación, cambia el código por el siguiente:

    with_fx :echo do
      live_audio :foo
    end

Now, hit Run, and you’ll immediately hear the audio played through the echo FX and no longer through reverb. If you wanted them both, just edit the code again and hit Run:

    with_fx :reverb do
      with_fx :echo do
        live_audio :foo
      end
    end

Es importante señalar que puedes llamar a `live_audio :foo` desde cualquier hilo o bucle en vivo y moverá el sintetizador de audio en vivo al contexto FX actual de ese hilo. Por lo tanto, puedes tener fácilmente varios bucles en vivo llamando a `live_audio :foo` en diferentes momentos, lo que resulta en el contexto de FX que se intercambia automáticamente para algunos resultados interesantes.

## Stopping live audio

Unlike standard synths, as `live_audio` has no envelope, it will continue running forever (even if you delete the code, just like a function is still defined in memory if you delete the code in the editor). To stop it, you need to use the `:stop` arg:

    foo

It can easily be restarted by calling it without the `:stop` arg again:

    foo

Additionally all running live audio synths are stopped when you hit the global Stop button (as with all other running synths and FX).

## Entrada estéreo

With respect to audio channels, by default `live_audio` acts similarly to the `:sound_in` synth in that it takes a single mono input stream of audio and converts it to a stereo stream using the specified panning. However, just like `:sound_in_stereo` it’s also possible to tell `live_audio` to read two consecutive audio inputs and treat them as the left and right channels directly. This is achieved via the `:stereo` opt. For example, to treat input 2 as the left signal and input 3 as the right signal, you need to configure the `input:` opt to 2 and enable stereo mode as follows:

    foo

Note that once you have started a live audio stream in stereo mode, you cannot change it to mono without stopping and starting. Similarly, if you start it in the default mono mode, you can’t switch to stereo without starting and stopping the stream.

# 13.3 - Sound Out

So far in this section we’ve looked at how to get multiple streams of audio into Sonic Pi - either through the use of the `:sound_in` synth or via the powerful `live_audio` system. In addition to working with multiple streams of input audio, Sonic Pi can also output multiple streams of audio. This is achieved via the `:sound_out` FX.

## Contextos de salida

Let’s quickly recap on how Sonic Pi’s synths and FX output their audio to their current FX context. For example, consider the following:

    with_fx :reverb do    # C
      with_fx :echo do    # B
        sample :bd_haus   # A
      end
    end

The simplest way to understand what’s happening with the audio stream is to start at the innermost audio context and work our way out. In this case, the innermost context is labelled `A` and is the `:bd_haus` sample being triggered. The audio for this goes directly into its context which is `B` - the `:echo` FX. This then adds echo to the incoming audio and outputs it to its context which is `C` - the `:reverb` FX. This then adds reverb to the incoming audio and outputs to its context which is the top level - the left and right speakers (outputs 1 and 2 in your audio card). The audio flows outwards with a stereo signal all the way through.

## Sound Out FX

The above behaviour is true for all synths (including `live_audio`) and the majority of FX with the exception of `:sound_out`. The `:sound_out` FX does two things. Firstly it outputs its audio to its external context as described above. Secondly it also outputs its audio directly to an output on your sound card. Let’s take a look:

    with_fx :reverb do      # C
      with_fx :sound_out, output: 3 do # B
        sample :bd_haus     # A
      end
    end

In this example, our `:bd_haus` sample outputs its audio to its external context which is the `:sound_out` FX. This in turn outputs its audio to its external context the `:reverb` FX (as expected). However, it also outputs a mono mix to the 3rd output of the system’s soundcard. The audio generated within `:sound_out` therefore has two destinations - the `:reverb` FX and audio card output 3.

## Mono and Stereo out

Como hemos visto, por defecto, el FX `:sound_out` da salida a una mezcla mono de la entrada estéreo a un canal específico, además de pasar la alimentación estéreo al contexto exterior (como es de esperar). Si la salida de una mezcla mono no es precisamente lo que quieres hacer, hay varias opciones alternativas. En primer lugar, utilizando la opción `mode:` puede elegir la salida de sólo la señal de entrada izquierda o derecha a la tarjeta de audio. O puede utilizar la función `:sound_out_stereo` para enviar la señal a dos salidas consecutivas de la tarjeta de sonido. Consulte la documentación de la función para obtener más información y ejemplos.

## Direct Out

As we have also seen, the default behaviour for `:sound_out` and `:sound_out_stereo` is to send the audio both to their external context (as is typical of all FX) and to the specified output on your soundcard. However, occasionally you may wish to only send to the output on your soundcard and not to the external context (and therefore not have any chance of the sound being mixed and sent to the standard output channels 1 and 2). This is possible by using the standard FX opt `amp:` which operates on the audio after the FX has been able to manipulate the audio:

    with_fx :sound_out, output: 3, amp: 0 do # B
      sample :loop_amen                      # A
    end

In the above example, the `:loop_amen` sample is sent to its outer context, the `:sound_out` FX. This then sends a mono mix to audio card output 3 and then multiplies the audio by 0 which essentially silences it. It is this silenced signal which is then sent out to the `:sound_out`’s outer context which is the standard output. Therefore with this code, the default output channels will not receive any audio, and channel 3 will receive a mono mix of the amen drum break.

# - Conclusiones

Con esto concluye el tutorial introductorio a Sonic Pi. Ojalá hayas aprendido algo por el camino. No te preocupes si crees que no entendiste todo - sólo juega y diviértete y verás que entiendes a tu propio ritmo - Vuelve cuando tengas alguna duda que pueda haber sido cubierta en una de las secciones.

Si tienes preguntas que no están cubiertas en el tutorial, por favor dirígete a Sonic Pi forums y haz tu pregunta. Seguro encuentras alguien amistoso que te eche una mano.

Finalmente, te invito a que estudies el resto de la documentación en el sistema de ayuda. Hay un número de características no cubiertas en el tutorial que esperan a ser descubiertas.

Así que juega, diviértete, comparte código con amigos, muestra tu pantalla y recuerda:

No hay errores, sólo oportunidades.

Sam Aaron

# - Artículos de MagPi

El Apéndice A contiene todos los artículos de Sonic Pi escritos para la revista MagPi.

## Bucea por los Temas

Estos artículos no están pensados para ser leídos en un orden concreto, y contienen un montón de referencias a este tutorial. En vez de intentar enseñarte todo Sonic Pi, cada artículo se centra en un aspecto específico del lenguaje, y lo explica de forma divertida y accesible.

## Lee la revista MagPi

Puedes verlos con letras gloriosas y profesionales en la sección de descargas PDF gratuitas de MagPi, aquí: https://www.raspberrypi.org/magpi/

## Sugiere un Tema

Si no encuentras un tema que te interese en estos artículos… ¿por qué no lo sugieres? La forma más fácil de hacerlo es que tuitees tus sugerencias a @Sonic_Pi. Nunca se sabe; ¡tu sugerencia podría ser el tema del próximo artículo!

# - Los Cinco Mejores Consejos

## 1. No hay errores

La lección más importante que debes aprender de Sonic Pi es que realmente no hay errores. La mejor forma de aprender es sencillamente probar, probar y probar. Prueba un montón de cosas, deja de preocuparte de si tu código suena bien o no y empieza a experimentar con tantos sintetizadores, notas, FX y opciones como puedas. Quita las cosas que no te gusten y deja las cosas que te gusten, sencilamente. Cuantos más ‘errores’ te permitas hacer, más rápido aprenderás y descubrirás tu propio sonido al hacer código.

## 2. Usa los FX

¿Ya has dominado lo esencial de Sonic Pi haciendo sonidos con `sample` y `play`? ¿Y ahora, qué? ¿Sabías que Sonic Pi ofrece hasta 27 efectos FX de estudio para cambiar el sonido de tu código? Los efectos son como filtros imagen chulos para los programas de dibujo, sólo que en vez de difuminar o hacer algo blanco y negro, puedes añadir cosas como reverberación, distorsión y eco a tu sonido. Piensa en lo que haces cuando conectas el cable de tu guitarra con un pedal de efectos que te guste, que a su vez va a un amplificador. Por suerte, usar efectos en Sonic Pi es muy fácil, ¡y no necesitas cables! Sólo necesitas escoger la sección de tu código a la que le quieras añadir el efecto, y envolverla con el código del mismo. Vamos a ver un ejemplo. Imagina que tienes el siguiente código:

    sample :loop_garzul
    16.times do
      sample :bd_haus
      sleep 0.5
    end

Si quieres añadir el efecto al sample `:loop_garzul`, sólo necesitas meter el bucle en un bloque `with_fx`, así:

    with_fx :flanger do
      sample :loop_garzul
    end
    16.times do
      sample :bd_haus
      sleep 0.5
    end

Vale, y ahora si quieres añadir el efecto al pedal de la batería, vas y lo envuelves con `with_fx`, exactamente igual:

    with_fx :flanger do
      sample :loop_garzul
    end
    with_fx :echo do
      16.times do
        sample :bd_haus
        sleep 0.5
      end
    end

Recuerda, puedes envolver cualquier código en `with_fx` y cualquier sonido que haya creado el código pasará por ese efecto.

## 3. Parametriza tus sintetizadores

Si estás buscando tu verdadero sonido al hacer código, pronto querrás saber cómo modificar y controlar sintetizadores y efectos. Por ejemplo, puede que quieras cambiar la duración de una nota, añadir más reverberación, o cambiar el tiempo entre ecos. Por suerte, Sonic Pi te da un nivel de control increíble para hacer esto, con unas cosas especiales llamadas parámetros u opciones (abreviado como opts). Copia este código en tu área de trabajo y dale a Ejecutar:

    sample :guit_em9

¡Hey, un sonido de guitarra! Vamos a jugar un poco con ese sonido. ¿Qué te parece si cambiamos su ritmo?

    sample :guit_em9, rate: 0.5

Ey, ¿qué es ese `rate: 0.5` que acabo de añadir al final? Eso se llama opción (opt). Todos los sintetizadores y efectos de Sonic Pi soportan los opt’s, y hay montones con los que puedes trastear. También están disponibles para efectos. Prueba esto:

    with_fx :flanger, feedback: 0.6 do
      sample :guit_em9
    end

Ahora, ¡prueba a subir la retroalimentación (feedback) a 1, para escuchar sonidos muuy locos! Lee la documentación para más detalles sobre los muchos opts que tienes disponibles.

## 5. Live Code

La mejor forma de experimentar rápido y explorar Sonic Pi es hacer código en vivo (live coding). Esto te permite empezar con algo de código e ir cambiándolo continuamente, retocándolo mientras suena. Por ejemplo, si no sabes qué le hace el parámetro cutoff a un sample, empieza a trastear con ello. ¡Vamos a probar! Copia este código en una de tus áreas de trabajo de Sonic Pi:

    live_loop :experiment do
      sample :loop_amen, cutoff: 70
      sleep 1.75
    end

Ahora, dale a Ejecutar y escucharás un break de batería ligeramente amortiguado. Vale, ahora cambia el valor de `cutoff:` a `80` y dale a Ejecutar de nuevo. ¿Escuchas la diferencia? Prueba con `90`, `100`, `110`…

Una vez le has cogido el tranquillo a usar `live_loop`s, verás no puedes dejar de usarlo. Cada vez que toco en un concierto de live coding, confío en mi `live_loop` igual que un/a baterista confía en sus baquetas. Para más información sobre live coding, mira la Sección 9 de el tutorial incluido en el programa.

## 5. Navega por flujos aleatorios

Por último, algo que me encanta es hacer trampa dejando a Sonic Pi que componga cosas por mí. Una forma muy chula de hacer esto es usar randomización. Puede sonar complicado, pero en realidad no lo es. Vamos a echarle un vistazo. Copia esto en un área de trabajo vacía:

    live_loop :rand_surfer do
      use_synth :dsaw
      notes = (scale :e2, :minor_pentatonic, num_octaves: 2)
      16.times do
        play notes.choose, release: 0.1, cutoff: rrand(70, 120)
        sleep 0.125
      end
    end

Ahora, cuando toques esto, escucharás un flujo constante de notas aleatorias de la escala `:e2 :minor_pentatonic`, tocada con el sintetizador `:dsaw`. “¡Espera, espera! Eso no es una melodía”, te oigo decir entre gritos. Pues bien, aquí viene la primera parte del truco de magia. Cada vez que damos una vuelta en el `live_loop`, le podemos decir a Sonic Pi que resetee el flujo aleatorio a un punto que conozcamos. Vamos a probarlo - añade la línea `use_random_seed_1` al `live_loop`:

    live_loop :rand_surfer do
      use_random_seed 1
      use_synth :dsaw
      notes = (scale :e2, :minor_pentatonic, num_octaves: 2)
      16.times do
        play notes.choose, release: 0.1, cutoff: rrand(70, 120)
        sleep 0.125
      end
    end

Ahora, cada vez que el `live_loop` da una vuelta, el flujo de notas aleatorias se resetea. Esto significa que elige las mismas 16 notas cada vez. ¡Abracadabra! Una melodía en el momento. Aquí viene la parte realmente interesante. Cambia el valor de la semilla de `1` a cualquier otro número. Por ejemplo, `4923`. ¡Guau! ¡Otra melodía! O sea, con cambiar un sólo número (la semilla), ¡puedes explorar tantas combinaciones melódicas que te puedas imaginar! He aquí la magia del código.

# - Live Coding (Programación en vivo)

El rayo láser atravesaba las nubes de humo; el subwoofer bombeaba las notas graves muy profundamente, en los cuerpos del público. El ambiente estaba cargado con una embriagadora mezcla de sintetizadores y baile. Sin embargo, algo no llegaba a encajar del todo en esta discoteca. Proyectado en colores brillantes, encima de la cabina de DJ, había un texto moviéndose, bailando, relampagueante. No eran efectos visuales, sino una simple proyección de Sonic Pi ejecutándose en una Raspberri Pi. La persona que estaba en la cabina de DJ no estaba tocando discos; estaba escribiendo, editando y evaluando código. En vivo. Esto es Live Coding.

Esto puede sonar como la disparatada historia de una discoteca futurista, pero escribie música en código como en esta historia es una tendencia cada vez más extendida, y se suele llamar por el nombre de Live Coding (http://toplap.org). Una de las direcciones más recientes que este estilo ha tomado es el Algorave (http://algorave.com) - eventos en los que l@s artistas como yo programamos música para que la gente baile. No obstante, no tienes por qué estar en una discoteca para hacer Live Coding - con Sonic Pi versión 2.6 (y posteriores), puedes hacerlo siempre que tengas a mano tu Raspberry Pi y un par de auriculares o unos altavoces. Una vez llegues al final de este artículo, programarás tus propios beats y sabrás modificarlos en vivo y en directo. A dónde llegues después de esto está en el poder de tu imaginación.

## Bucle en Vivo

La clave para hacer live coding con Sonic Pi está en manejar el `live_loop` (bucle en vivo). Vamos a ver uno:

    live_loop :beats do
      sample :bd_haus
      sleep 0.5
    end

Un `live_loop` tiene 4 ingredientes fundamentales. El primero es su nombre. Nuestro `live_loop` de arriba se llama `:beats`. Eres libre de llamar a tu `live_loop` como quieras. Haz una locura. Sé creativ@. Yo suelo usar nombres que comuniquen algo sobre la música que va a sonar, pensando en el público. El segundo ingrediente es la palabra `do` que marca dónde empieza el `live_loop`. El tercer ingrediente es la palabra `end` que marca dónde el `live_loop` acaba, y finalmente está el cuerpo del `live_loop` que describe qué es lo que va a repetir el bucle (ésta es la parte entre el `do` y el `end`). En este caso estamos tocando de forma repetida un bombo de batería y luego esperamos durante medio pulso. Esto produce un pulso grave regular perfecto. Adelante, cópialo en un búfer vacío de Sonic Pi y dale a Ejecutar. ¡Boom, Boom, Boom!.

## Redefiniendo al vuelo

Vale, entonces, ¿qué hace al `live_loop` tan especial? ¡Hasta ahora parecía un `loop` glorificado! Pues bien, la belleza de los `live_loop`s está en que puedes redefinirlos sobre la marcha, al vuelo. Esto significa que mientras que éstos se ejecutan, puedes cambiar lo que hacen. Éste es el secreto de hacer live coding con Sonic Pi. Vamos a tocar un poco:

    live_loop :choral_drone do
      sample :ambi_choir, rate: 0.4
      sleep 1
    end

Ahora pulsa el botón de Ejecutar o presiona las teclas `alt-r`. Ahora mismo estás escuchando unos coros preciosos. Ahora, mientras suenan, cambia el rate de `0.4` a `0.38`. Dale a Ejecutar de nuevo. ¡Guau! ¿Notas cómo ha cambiado la nota del coro? Cámbialo de nuevo a `0.4` para volver a cómo era antes. Ahora bájalo a `0.2`, luego a `0.19` y después vuelve a `0.4`. ¿Ves cómo el cambiar un sólo parámetro sobre la marcha, te puede dar control de verdad sobre la música? Ahora trastea con el rate tú mism@ - escoge tus propios valores. Prueba con números neativos, números muy pequeños y números muy grandes. ¡Que te diviertas!

## Dormir es importante

Una de las lecciones más importantes sobre el `live_loop` es que necesitan descansar. Mira el siguiente `live_loop`:

    live_loop :infinite_impossibilities do
      sample :ambi_choir
    end

Si intentas ejecutar este código, verás de inmediato a Sonic Pi quejándose de que el `live_loop` no durmió. ¡Esto es el sistema de seguridad haciendo efecto! Tómate un segundo para pensar en lo que este código le está pidiendo al ordenador que haga. Efectivamente, le está pidiendo al ordenador que toque un número infinito de samples de coro en cero segundos. De no ser por el sistema de seguridad, el pobre ordenador intentará hacerlo y se colgará y arderá en el proceso. Así que recuerda, tu `live_loop` debe contener un `sleep`.

## Combinando Sonidos

La música está llena de cosas pasando a la vez. La batería a la vez que el bajo a la vez que las voces a la vez que las guitarras… En informática llamamos a esto concurrencia, y Sonic Pi nos ofrece una forma increíblemente fácil de tocar varias cosas a la vez. Sencillamente, ¡usa más de un `live_loop`!

    live_loop :beats do
      sample :bd_tek
      with_fx :echo, phase: 0.125, mix: 0.4 do
        sample  :drum_cymbal_soft, sustain: 0, release: 0.1
        sleep 0.5
      end
    end
    live_loop :bass do
      use_synth :tb303
      synth :tb303, note: :e1, release: 4, cutoff: 120, cutoff_attack: 1
      sleep 4
    end

Aquí tenemos dos `live_loop`s, uno dando la vuelta rápido marcando el pulso, y otro dando la vuelta lentamente y tocando un sonido de bajo muy loco.

Una de las cosas interesantes que tiene el usar varios `live_loop`s es que cada uno gestiona su propio tiempo. Esto significa que es muy fácil crear estructuras polirrítimicas interesantes, e incluso tocar con fases al estilo de Steve Reich. Échale un ojo a esto:

    # Steve Reich's Piano Phase
    notes = (ring :E4, :Fs4, :B4, :Cs5, :D5, :Fs4, :E4, :Cs5, :B4, :Fs4, :D5, :Cs5)
    live_loop :slow do
      play notes.tick, release: 0.1
      sleep 0.3
    end
    live_loop :faster do
      play notes.tick, release: 0.1
      sleep 0.295
    end

## Juntándolo todo

En cada uno de estos tutoriales, vamos a acabar con un ejemplo final en forma de una pieza de música, que coge un poco de todas las ideas que hemos ido introduciendo. Lee este código y mira si puedes imaginarte lo que está haciendo. Después, cópialo en un búfer vacío en Sonic Pi, dale a Ejecutar y escucha cómo suena. Finalmente, cambia uno de los números o comenta y descomenta cosas. Mira si puedes utilizar esto como un punto de partida para una nueva actuación, y sobre todo, ¡para pasártelo bien! Hasta la próxima…

    with_fx :reverb, room: 1 do
      live_loop :time do
        synth :prophet, release: 8, note: :e1, cutoff: 90, amp: 3
        sleep 8
      end
    end
    live_loop :machine do
      sample :loop_garzul, rate: 0.5, finish: 0.25
      sample :loop_industrial, beat_stretch: 4, amp: 1
      sleep 4
    end
    live_loop :kik do
      sample :bd_haus, amp: 2
      sleep 0.5
    end
    with_fx :echo do
      live_loop :vortex do
        # use_random_seed 800
        notes = (scale :e3, :minor_pentatonic, num_octaves: 3)
        16.times do
          play notes.choose, release: 0.1, amp: 1.5
          sleep 0.125
        end
      end
    end

# - Beats Programados

Uno de los desarrollos tecnológicos más emocionantes y disruptivos en la música moderna fue la invención de los samplers. Eran cajas que te permitían grabar cualquier sonido y manipularlo, reproduciendo estos sonidos grabados de distintas formas muy interesantes. Por ejemplo, podías coger una grabación antigua, encontrar un solo de batería (o un break), grabarlo en tu sampler y después reproducirlo en repetición a la mitad de la velocidad, para tener una base para tus beats. Así es como la música hip-hop se creó en sus inicios; hoy en día es casi imposible encontrar música electrónica que no incorpore samples de algún tipo. Usar samples es una forma maravillosa de introducir fácilmente elementos nuevos e interesantes en tus conciertos de live coding.

¿Y dónde puedes conseguir un sampler? Bueno, ya tienes uno - ¡es tu Raspberry Pi! La aplicación incorporada Sonic Pi incluye un sampler extremadamente potente. ¡Vamos a tocar con él!

## El Amen Break

Uno de los samples de batería más clásicos y reconocibles es el Amen Break. Fue utilizado por primera vez en 1969 en la canción “Amen Brother”, de los Winstons, como parte de un break de batería. Sin embargo, no fue conocido hasta que lo descubrieron los primeros músicos de hip-hop de los 80’s, quienes lo usaron en samplers; a partir de ahí empezó a usarse muchísimo, y en una gran variedad de estilos como drum and bass, breakbeat, hardcore tecno y breakcore.

Te encantará saber que este sample también está incorporado en Sonic Pi. Limpia un búfer y pega este código:

    sample :loop_amen

Dale a Ejecutar y ¡boom! Estás escuchando uno de los breaks de batería más importante de la historia de la música dance. No obstante, este sample no era famoso por ser tocado una vez; estaba pensado para ser tocado en bucle.

## Beat Stretching

Vamos a poner el Amen Break en bucle usando nuestro viejo amigo, el `live_loop` introducido en este tutorial el último mes:

    live_loop :amen_break do
      sample :loop_amen
      sleep 2
    end

Vale, está en bucle, pero a cada vuelta se escucha una molesta pausa. Esto pasa porque le dijimos que durmiese `2` pulsos; con el BPM por defecto de 60 que tiene el sample `:loop_amen`, éste sólo dura `1.753` pulsos. Por eso ponemos un silencio de `2 - 1.753 = 0.247` pulsos. Aunque es un silencio corto, se nota.

Para arreglar este problema, podemos usar el opt `beat_stretch:` para decirle a Sonic Pi que estire (stretch) o encoja (shrink) el sample, de modo que éste encaje con el número de beats que queremos.

Las funciones `sample` y `synth` en Sonic Pi te dan mucho control con parámetros opcionales, como `amp:`, `cutoff:` y `release:`. Lo de parámetro opcional suena un poco a trabalenguas, así que vamos a llamarlos opts (del inglés option, opción) para que sea más fácil.

    live_loop :amen_break do
      sample :loop_amen, beat_stretch: 2
      sleep 2
    end

¡Ahora sí se puede bailar! Tal vez queramos hacerlo más rápido o más lento, para que encaje con el carácter del baile.

## Jugando con el Tiempo

Bueno, ¿y qué pasa si queremos cambiar el estilo a hip hop de la vieja escuela, o a breakcore? Una forma fácil de hacer esto es jugar con el tiempo - o en otras palabras, toquetear el tempo de la canción. Esto es súper fácil en Sonic Pi - sólo necesitas poner un `use_bpm` en tu live loop:

    live_loop :amen_break do
      use_bpm 30
      sample :loop_amen, beat_stretch: 2
      sleep 2
    end

Mientras rapeas con esos beats lentos, fíjate en que seguimos durmiendo 2 y que nuestro BPM es 30, y aun así todo sigue a tiempo. El opt `beat_stretch` trabaja con el BPM actual para asegurarse de que todo suene bien.

Aquí viene la parte graciosa. Mientras el bucle sigue activo, cambia el `30` a `50` en la línea de `use_bpm 30`. ¡Guau, todo ha acelerado, pero sigue a tiempo! Intenta ir más rápido - a 80, a 120, ¡y ahora vuélvete loc@ y mete 200!

## Filtrando

Ahora que podemos poner samples en bucle en directo, vamos a ver uno de los opts más divertidos del sintetizador `sample`. El primero es `cutoff:`, que controla el filtro limitador (cutoff) del sampler. Está desactivado por defecto, pero puedes activarlo fácilmente:

    live_loop :amen_break do
      use_bpm 50
      sample :loop_amen, beat_stretch: 2, cutoff: 70
      sleep 2
    end

Adelante, cambia el opt `cutoff`. Por ejemplo, súbelo a 100, dale a Ejecutar y espera al bucle que dé una vuelta para escuchar el cambio en el sonido. Fíjate en que valores bajos como 50 suenan suaves, como un bajo; valores altos como 100 o 120 son más completos y ásperos. Esto pasa porque la opción `cutoff:` corta las frecuencias altas del sonido, igual que un cortacésped corta la parte de arrriba de la hierba. La opción `cutoff:` es como la longitud del cortacésped: determina cuánta hierba deja sin cortar.

## Cortando

Otra herramienta muy chula que puedes probar es el efecto de corte (slicer). Éste corta (slice) el sonido. Envuelve la línea que dice `sample` con el código del efecto, tal que así:

    live_loop :amen_break do
      use_bpm 50
      with_fx :slicer, phase: 0.25, wave: 0, mix: 1 do
        sample :loop_amen, beat_stretch: 2, cutoff: 100
      end
      sleep 2
    end

Si te das cuenta, el sonido se balancea hacia arriba y hacia abajo un poco más. (Puedes escuchar el sonido original sin el efecto cambiando el opt `mix:` a `0`). Ahora, experimenta con la opción `phase:`. Este controla el ritmo (en pulsos) del efecto de slicing. Un valor más pequeño como `0.125` corta más rápido, y valores grandes como `0.5` cortan más lento. Fíjate en que si doblas o divides por la mitad la opción `phase:` sucesivamente, siempre suena bien. Por último, cambia la opción `wave:` a 0, 1 o 2, y escucha cómo cambia el sonido. Éstos números son distintas formas de onda. 0 es una onda de sierra (inicio duro, salida suave), 1 es una onda cuadrada (inicio duro, salida dura), y 2 es una onda de triángulo (inicio suave, salida suave).

## Juntándolo todo

Por último, vamos a volver atrás en el tiempo y a visitar de nuevo la escena drum and bass de Bristol en sus inicios, con el ejemplo de este mes. No te preocupes si no lo entiendes; tú escríbelo, dale a Ejecutar, y empieza a hacer live coding cambiando los números de los opts, a ver a dónde puedes llegar con ello. Por favor, ¡comparte tus creaciones! Hasta la próxima…

    use_bpm 100
    live_loop :amen_break do
      p = [0.125, 0.25, 0.5].choose
      with_fx :slicer, phase: p, wave: 0, mix: rrand(0.7, 1) do
        r = [1, 1, 1, -1].choose
        sample :loop_amen, beat_stretch: 2, rate: r, amp: 2
      end
      sleep 2
    end
    live_loop :bass_drum do
      sample :bd_haus, cutoff: 70, amp: 1.5
      sleep 0.5
    end
    live_loop :landing do
      bass_line = (knit :e1, 3, [:c1, :c2].choose, 1)
      with_fx :slicer, phase: [0.25, 0.5].choose, invert_wave: 1, wave: 0 do
        s = synth :square, note: bass_line.tick, sustain: 4, cutoff: 60
        control s, cutoff_slide: 4, cutoff: 120
      end
      sleep 4
    end

# - Riffs con Sintetizadores

No importa si es el giro hechizante de los estrepitosos osciladores, o el golpe desafinado de las ondas de sierra perforando el remix; el sintetizador que lleva la melodía (lead synth) tiene un papel muy importante en cualquier canción de música electrónica. En la edición del último mes de esta serie de tutoriales, vimos cómo programar nuestros beats. En este tutorial, vamos a ver cómo programar los tres componentes fundamentales de un buen riff de sintetizador - timbre, melodía y ritmo.

Vale, pues enciende tu Raspberry Pi, abre Sonic Pi v2.6+ y, ¡vamos a hacer ruido!

## Posibilidades Tímbricas

Una parte esencial de cualquier riff de sintetizador es cambiar y jugar con el timbre de los sonidos. Podemos controlar el timbre en Sonic Pi de dos formas - eligiendo diferentes sintetizadores para un cambio drástico, y cambiando los opts de un mismo sintetizador para un cambio más suave. También podemos usar efectos, pero eso lo veremos en otro tutorial…

Vamos a crear un live loop sencillo, donde podamos cambiar constantemente el sintetizador actual:

    live_loop :timbre do
      use_synth (ring :tb303, :blade, :prophet, :saw, :beep, :tri).tick
      play :e2, attack: 0, release: 0.5, cutoff: 100
      sleep 0.5
    end

Échale un vistazo al código. Sólo estamos haciendo ticking sobre un anillo de nombres de sintetizador (esto recorre cada uno de ellos y repite la lista una y otra vez). Le pasamos este nombre de sintetizador a la función (abreviada como fn) `use_synth`, que cambia el sintetizador actual del `live_loop`. También estamos tocando la nota `:e2` (Mi en la segunda octava), con una separación de 0.5 pulsos (medio segundo con el BPM de 60 que está por defecto), y con la opción `cutoff:` puesta a 100.

Escucha cómo los distintos sintetizadores tienen sonidos muy diferentes, aunque estén tocando la misma nota. Ahora, experimenta y juega con ello. Cambia el tiempo de decaimiento (release) a valores más altos y más bajos. Por ejemplo, cambia las opciones `attack:` y `release:` para ver cómo distintos tiempos de entrada y salida pueden cambiar considerablemente el sonido. Finalmente, cambia el opt `cutoff:` para ver cómo distintos valores de cutoff pueden cambiar notablemente el timbre (con valores entre 60 y 130 está bien). Mira cuántos sonidos distintos puedes crear con sólo cambiar unos pocos valores. Una vez le cojas el tranquillo, ve a la pestaña de Sintetizadores en el sistema de Ayuda si quieres una lista completa de todos los sintetizadores y de todas las opciones disponibles para cada sintetizador, para que veas cuánto poder tienes en tus manos de programador/a.

## Timbre

Timbre es una palabra guay para describir cómo suena un sonido. Si tocas la misma nota con distintos instrumentos como un violín, una guitarra o un piano, la altura (cómo de agudo o grave suena) es la misma en todos ellos, pero la cualidad del sonido cambia. Esa cualidad del sonido - aquello que te permite diferenciar un piano de una guitarra, es el timbre.

## Composición Melódica

Otro aspecto importante para nuestro sintetizador lead son las notas que queremos que toque. Si ya tienes una idea, sólo tienes que crear un anillo con las notas que has pensado, y hacer ticking sobre ellas:

    live_loop :riff do
      use_synth :prophet
      riff = (ring :e3, :e3, :r, :g3, :r, :r, :r, :a3)
      play riff.tick, release: 0.5, cutoff: 80
      sleep 0.25
    end

Aquí hemos definido nuestra melodía con un anillo, que incluye notas como `:e3` y silencios representados como un ‘:r’. Después usamos `.tick` para recorrer cada nota, lo que nos da un riff repetitivo.

## Melodía Automática

No siempre es fácil inventarse una melodía desde cero. Es más fácil pedirle a Sonic Pi una selección de riffs aleatorios y esocoger aquel que te guste más. Para ello tenemos que combinar tres cosas: anillos, aleatoriedad y semillas aleatorias. Veamos un ejemplo:

    live_loop :random_riff do
      use_synth :dsaw
      use_random_seed 3
      notes = (scale :e3, :minor_pentatonic).shuffle
      play notes.tick, release: 0.25, cutoff: 80
      sleep 0.25
    end

Hay varias cosas que tenemos que revisar - vamos a verlas una por una. Primero, estamos usando una semilla aleatoria de 3. ¿Qué significa esto? Bien, hacer esto es muy útil porque, cuando especificamos la semilla, podemos predecir cuál va a ser el siguiente valor aleatorio - ¡igual que la última vez que pusimos la semilla a 3! Otra cosa útil que te viene bien saber, es que desordenar un anillo de notas funciona de la misma forma. En el ejemplo de arriba estamos preguntando por el ‘tercer desorden’ en la lista estándar de formas de desordenar notas - que también es igual cada vez porque siempre estamos usando la misma semilla para el mismo valor, justo antes de que empecemos a desordenar las notas. Finalmente, estamos haciendo ticking, recorriendo nuestras notas desordenadas para tocar el riff.

Ahora es cuando empieza la diversión. Si cambiamos el valor de la semilla aleatoria a otro número, como 3000, obtenemos una mezcla de notas totalmente distinta. Así es muy fácil explorar nuevas melodías. Sencillamente, escoge la lista de notas que queremos mezclar (una escala está bien para empezar), y selecciona la semilla con la que queremos mezclarlas. Si no te gusta la melodía, sólo tienes que cambiar las notas o la semilla, y probar de nuevo. ¡Repite hasta que te guste lo que escuchas!

## Pseudoaleatoriedad

La aleatoriedad en Sonic Pi no es aleatoria en realidad; es lo que se conoce como pseudoaleatoria. Imagina que tienes que tirar un dado 100 veces y luego escribes los resultados en una hoja de papel. Sonic Pi tiene algo parecido esta lista de resultados, que utiliza cuando le pides un valor aleatorio. Ajustar la semilla aleatoria es como saltar a un punto específico en dicha lista.

## Encontrando tu Ritmo

Otro aspecto importante de nuestro riff es el ritmo - cuándo tocar una nota y cuándo no. Como vimos arriba, podemos usar `:r` en nuestros anillos para insertar silencios. Otra forma muy potente de hacer esto es usar extensiones (spreads), que veremos en otro tutorial. Hoy vamos a usar la aleatoriedad para que nos ayude a encontrar nuestro ritmo. En vez de tocar cada nota, vamos a usar una condición para tocar una nota con una determinada probabilidad. Vamos a echarle un vistazo:

    live_loop :random_riff do
      use_synth :dsaw
      use_random_seed 30
      notes = (scale :e3, :minor_pentatonic).shuffle
      16.times do
        play notes.tick, release: 0.2, cutoff: 90 if one_in(2)
        sleep 0.125
      end
    end

Una función muy útil que deberías conocer es `one_in`, que nos devuelve un valor `true` (verdadero) o `false` (falso) con una determinada probabilidad. Vamos a usar un valor de 2, así que, de media, una de cada dos llamadas a `one_in` va a devolver `true`. Dicho de otra forma, el 50% del tiempo vamos a recibir `true`. Usar valores más altos devolverá `false` más a menudo, introduciendo más espacio en el riff.

Fíjate en que hemos añadido algo de iteración con el `16.times`. Esto es porque sólo queremos resetear el valor de nuestra semilla aleatoria cada 16 notas, de modo que nuestro ritmo se repita cada 16 veces. Esto no afecta a la mezcla, ya que dicha operación se realiza justo después de que se ajuste la semilla. Podemos usar el tamaño de la iteración para cambiar la duración del riff. Prueba a cambiar el 16 a 8, o incluso a 4 o 3, y mira cómo afecta al ritmo del riff.

## Juntándolo todo

Vale, ahora vamos a combinar todo lo que hemos aprendido en un ejemplo final. ¡Hasta la próxima!

    live_loop :random_riff do
      #  uncomment to bring in:
      #  synth :blade, note: :e4, release: 4, cutoff: 100, amp: 1.5
      use_synth :dsaw
      use_random_seed 43
      notes = (scale :e3, :minor_pentatonic, num_octaves: 2).shuffle.take(8)
      8.times do
        play notes.tick, release: rand(0.5), cutoff: rrand(60, 130) if one_in(2)
        sleep 0.125
      end
    end

    live_loop :drums do
      use_random_seed 500
      16.times do
        sample :bd_haus, rate: 2, cutoff: 110 if rand < 0.35
        sleep 0.125
      end
    end

    live_loop :bd do
      sample :bd_haus, cutoff: 100, amp: 3
      sleep 0.5
    end

# - Acid Bass

Es imposible mirar en la historia de la música electrónica dance sin ver el enorme impacto del pequeño sintetizdor Roland TB-303. Es la salsa secreta del sonido de bajo ácido (acid bass). Esos clásicos riffs de bajo chillones del TB-303 se pueden escuchar desde los inicios de la música House en Chicago, hasta en artistas electrónic@s más recientes como Plastikman, Squarepusher y Aphex Twin.

Curiosamente, Roland no diseñó el TB-303 para música de baile. Se creó inicialmente como una ayuda para practicar para guitarristas. Pensaron que la gente podría programarlos para tocar líneas de bajo eléctrico que sirviesen de acompañamiento. Por desgracia había varios problemas: eran un poco difíciles de programar, no sonaban muy bien como substitutos para un bajo eléctrico, y eran bastante caros. Para contrarrestar sus pérdidas, Roland dejó de fabricarlos después de vender 10.000 unidades, y después de unos años cogiendo polvo en armarios de guitarristas, era fácil verlos en los escaparates de tiendas de segunda mano. Estos TB-303 solitarios estaban esperando a ser descubiertos por una nueva generación de experimentador@s que empezaron a usarlos de formas en las que Roland no se habría imaginado, creando sonidos muy guays. Así nació el Acid House.

Aunque no es fácil tocar un TB-303 original, te alegrará saber que puedes convertir tu Raspberri Pi en este sintetizador usando el poder de Sonic Pi. Abre Sonic Pi, pon este código en un búfer vacío, dale a Ejecutar y contempla…:

    use_synth :tb303
    play :e1

¡Acid bass al instante! Vamos a cambiar cosillas…

## Que Chille ese Bajo

Primero, vamos a construir un arpegiador en directo para hacer las cosas más divertidas. En el último tutorial vimos cómo un riff puede ser sencillamente un anillo de notas sobre las que hacemos tick una tras otra, repitiéndolas cuando llegamos al final. Vamos a crear un live loop que haga justo eso:

    use_synth :tb303
    live_loop :squelch do
      n = (ring :e1, :e2, :e3).tick
      play n, release: 0.125, cutoff: 100, res: 0.8, wave: 0
      sleep 0.125
    end

Échale un vistazo a cada línea.

1. En la primera línea ponemos el sintetizador por defecto como `tb303`, con la función `use_synth`.
2. En la línea dos creamos un live loop llamado `:squelch` (chillar) que sencillamente da vueltas, vueltas y más vueltas.
3. En la línea tres es donde creamos nuestro riff - un anillo de notas (Mi en las octavas 1, 2 y 3), que recorremos con `.tick`. Definimos `n` para representar la nota actual dentro del riff. El símbolo de igual asigna el valor de la derecha al nombre de la izquierda. Este valor será diferente en cada vuelta del bucle. La primera vez, `n` valdrá `:e1`. La segunda vez valdrá `:e2`, luego `:e3`, y así hasta volver a `:e1`, dando vueltas para siempre.
4. En la línea cuatro es donde realmente usamos nuestro sintetizador `:tb303`. Le estamos pasando varios opts interesantes: `release:`, `cutoff:`, `res:` y `wave:`, que vamos a ver a continuación.
5. La línea cinco es nuestro `sleep` - le estamos diciendo al live loop que dé una vuelta cada `0.125`, o 8 veces cada segundo si utilizamos el BPM por defecto (60).
6. La línea séis es el `end` (fin) de nuestro live loop. Esto le dice a Sonic Pi dónde acaba el live loop, sencillamente.

Mientras te preguntas qué está pasando, escribe el código de arriba en Sonic Pi y dale a Ejecutar. Deberías escuchar el `:tb303` en acción. Ahora viene lo bueno: vamos a hacer live coding.

Mientras el bucle sigue funcionando, cambia el opt `cutoff:` a `110`. Ahora dale al botón de Ejecutar de nuevo. Deberías escuchar que el sonido se hace un poco más duro y chillón. Cambia de nuevo el `cutoff:` a `120` y dale a Ejecutar. Ahora con `130`. Escucha cómo frecuencias de cutoff más bajas hacen que suene más penetrante e intenso. Finalmente, bájalo a `80`, con lo que sentirás una sensación de respiro. Repite tantas veces como quieras. No te preocupes, yo sigo por aquí…

Otra opción que merece la pena probar es `res:`. Ésta controla el nivel de resonancia del filtro. Una resonancia alta es típica de sonidos de acid bass. Ahora mismo tenemos nuestro `res:` a `0.8`. Prueba a cambiarlo a `0.85`, luego a `0.9`, y finalmente a `0.95`. Tal vez notes que un cutoff como `110` o más alto hace las diferencias más fáciles de escuchar. Ahora haz una locura y cámbialo a `0.999` para escuchar sonidos muy chulos. ¡Con una `res` tan alta, escuchas el filtro cutoff resonando tanto que empieza a crear sonidos él mismo!

Por último, para un cambio grande en el timbre, modifica el valor de la opción `wave` a `1`. Esta opción selecciona un oscilador inicial. El valor por defecto es `0`, que es una onda de sierra. `1` es una onda de pulso y `2` es una onda triangular.

Por supuesto, prueba con distintos riffs cambiando las notas en el anillo o incluso cogiendo notas de escalas o acordes. Que te diviertas con tu primer sintetizador de acid bass.

## Desmontando el TB-303

El diseño del TB-303 original es muy sencillo en realidad. Como puedes ver en el siguiente diagrama, sólo tiene 4 partes básicas.

En primer lugar tenemos la onda de oscilador - el ingrediente crudo del sonido. En este caso tenemos una onda cuadrada. Después tenemos el envolvente (envelope) de amplitud del oscilador, que controla la amplificación (amp) de la onda cuadrada con el paso del tiempo. Estas opciones se acceden en Sonic Pi con los opts `attack:`, `decay:`, `sustain:` y `release:`, y lo mismo con sus versiones para el volumen. Para más información, lee la sección 2.4, ‘Duración con Envolventes’ en el tutorial incluido en Sonic Pi. Después del envolvente pasamos nuestra onda cuadrada por un filtro de paso bajo. Aquí es donde empieza la diversión. ¡El valor de cutoff de este filtro también se controla con su propio envolvente! Esto significa que tenemos un nivel de control alucinante sobre el tumbre del sonido con sólo jugar con estos dos envolventes. Echémosle un vistazo:

    use_synth :tb303
    with_fx :reverb, room: 1 do
      live_loop :space_scanner do
        play :e1, cutoff: 100, release: 7, attack: 1, cutoff_attack: 4, cutoff_release: 4
        sleep 8
      end
    end

Para cada opción estándar de un envolvente, hay una opción `cutoff_` equivalente en el sintetizador `:tb303`. Por tanto, podemos usar la opción `cutoff_attack:` para cambiar el valor de ataque del cutoff. Copia el código de abajo en un búfer vacío y dale a Ejecutar. Escucharás un sonido de lo más curioso, haciendo trinos arriba y abajo. Ahora empieza a tocar cosillas. Prueba a cambiar el tiempo de `cutoff_attack` a `1`, y luego a `0.5`. Ahora prueba con `8`.

Fíjate en que he pasado todo por un efecto `:reverb` para darle un poco más de ambiente - ¡prueba con otros efectos para ver cuál funciona mejor!

## Juntándolo todo

Finalmente, aquí tienes una pieza que he compuesto usando ideas de este tutorial. Cópiala en un búfer vacío, escúchala un rato y empieza a a hacer live coding con tus propios cambios. ¡A ver qué sonidos locos le puedes sacar! Hasta la próxima…

    use_synth :tb303
    use_debug false

    with_fx :reverb, room: 0.8 do
      live_loop :space_scanner do
        with_fx :slicer, phase: 0.25, amp: 1.5 do
          co = (line 70, 130, steps: 8).tick
          play :e1, cutoff: co, release: 7, attack: 1, cutoff_attack: 4, cutoff_release: 4
          sleep 8
        end
      end

      live_loop :squelch do
        use_random_seed 3000
        16.times do
          n = (ring :e1, :e2, :e3).tick
          play n, release: 0.125, cutoff: rrand(70, 130), res: 0.9, wave: 1, amp: 0.8
          sleep 0.125
        end
      end
    end

# - Minecraft Musical

Minecraft Pi

¡Hola y bienvenid@ de nuevo! En tutoriales anteriores, nos hemos centrado sólamente en las posibilidades musicales de Sonic Pi - (convirtiendo tu Raspberry Pi en un instrumento musical preparado para tu concierto). Hasta ahora hemos aprendido cómo:

- Hacer Live Coding - cambiar sonidos al vuelo,
- Programar unos beats muy salvajes,
- Generar sintetizadores lead potentes,
- Re-crear el famoso sonido acid bass del TB-303.

Hay mucho más por ver (que exploraremos en futuras ediciones). Sin embargo, este mes vamos a centrarnos en algo que Sonic Pi hace y que de lo que probablemente no te has dado cuenta: controlar Minecraft.

## Hola Mundo Minecraft

Vale, allá vamos. Enciende tu Raspberry Pi, abre Minecraft Pi y crea un nuevo mundo. Ahora inicia Sonic Pi, y mueve y cambia el tamaño de ambas ventanas, para que puedas ver Sonic Pi y Minecraft Pi al mismo tiempo.

Escribe lo siguiente en un búfer vacío:

    mc_message "Hola Minecraft desde Sonic Pi!"

Ahora, dale a Ejecutar. ¡Boom! ¡Tu mensaje apareció en Minecraft! ¿A que ha sido fácil? Ahora, deja de leer esto por un momento y prueba a poner tus propios mensajes. ¡Que te diviertas!

## Teletransportador Sonoro

Ahora vamos a explorar el mundo. La opción estándar es coger el teclado y el ratón y empezar a moverte alrededor. Esto funciona, pero es bastante lento y aburrido. Sería mucho mejor si tuviésemos una especie de máquina de teletransporte. Bueno, tenemos una, gracias a Sonic Pi. Prueba esto:

    mc_teleport 80, 40, 100

¡Vaya! Eso ha sido una subida. Si no estuvieses en modo vuelo habrías caído toda esa distancia hasta el suelo. Si pulsas dos veces la tecla espacio para entrar en el modo vuelo y teletransportarte de nuevo, te quedarás flotando en el lugar al que has volado a toda pastilla.

¿Y qué significan esos números? Tenemos tres números que indican las coordenadas del lugar del mundo donde te encuentras. Le damos un nombre a cada número: x, y, z:

- x - cómo de lejos estás a la derecha o a la izquierda (80 en nuestro ejemplo)
- y - cómo de alto queremos estar (40 en nuestro ejemplo)
- z - cómo de lejos hacia delante o hacia atrás (100 en nuestro ejemplo)

Al escoger distintos valores de x, y y z, podemos teletransportarnos a cualquier lugar en nuestro mundo. ¡Pruébalo! Escoge distintos números y mira dónde puedes acabar. Si la pantalla se vuelve negra es porque te has teletransportado debajo del suelo o dentro de una montaña. Sencillamente pon un valor más alto de y, para volver a estar por encima de la tierra. Sigue explorando hasta que encuentres algo que te guste…

Usando estas ideas, vamos a construir un Teletransportador Sonoro que haga un sonido de teletransporte divertido mientras nos hace pasar zumbando por el mundo de Minecraft:

    mc_message "Preparing to teleport...."
    sample :ambi_lunar_land, rate: -1
    sleep 1
    mc_message "3"
    sleep 1
    mc_message "2"
    sleep 1
    mc_message "1"
    sleep 1
    mc_teleport 90, 20, 10
    mc_message "Whoooosh!"

## Bloques Mágicos

Ahora que has encontrado un sitio que te guste, ¡empecemos a construir!. Podrías hacer lo que sueles hacer y empezar a hacer click con el ratón una y otra vez (furiosamente) para poner bloques debajo del cursor. O podrías usar la magia de Sonic Pi. Prueba esto:

    x, y, z = mc_location
    mc_set_block :melon, x, y + 5, z

¿Lo ves? ¡Hay un melón en el cielo! Tómate un momento para mirar el código. ¿Qué hemos hecho? En la línea uno, hemos cogido nuestra localización actual de Steve con las variables x, y, z. Éstas corresponden a nuestras coordenadas descritas anteriormente. Usamos esas coordenadas en la función `mc_set_block`, que deja el bloque que queramos en las coordenadas especificadas. Para hacer algo más alto en el cielo, sólo tenemos que subir el valor de y, que es el motivo por el cual le hemos añadido 5. Vamos a hacer una tira de melones:

    live_loop :melon_trail do
      x, y, z = mc_location
      mc_set_block :melon, x, y-1, z
      sleep 0.125
    end

Ahora, vuelve a Minecraft, asegúrate de que estás en modo vuelo (si no, pulsa la tecla espacio dos veces), y vuelva por el mundo. Mira detrás tuya para ver… ¡una preciosa tira de bloques de melón! A ver qué patrones puedes hacer en el cielo.

## Haciendo Live Coding con Minecraft

Aquell@s que hayáis seguido este tutorial durante los últimos meses estaréis flipando en colores. La tira de melones está muy chula, pero la parte más increíble de este ejemplo es que ¡podéis usar `live_loop` con Minecraft! Para quienes no lo sepáis, `live_loop` es una habilidad mágica de Sonic Pi que no tiene ningún otro lenguaje de programación. Te permite ejecutar varios bucles al mismo tiempo y cambiarlos mientras tanto. Son increíblemente potentes y divertidos. Yo uso los `live_loop`s para dar conciertos de música en discotecas con Sonic Pi - los DJs usan discos y yo uso `live_loop`s :-) Sin embargo, hoy vamos a hacer live coding con música y con Minecraft.

Empecemos. Ejecuta el código de arriba y empieza a hacer tu propia tira de melones de nuevo. Ahora, sin parar el código, cambia `:melon` por `:brick` y dale a Ejecutar. ¡Abracadabra!, estás haciendo una tira de ladrillos. ¡A que es fácil! ¿Y si le ponemos música chula de fondo? Pan comido. Prueba esto:

    live_loop :bass_trail do
      tick
      x, y, z = mc_location
      b = (ring :melon, :brick, :glass).look
      mc_set_block b, x, y -1, z
      note = (ring :e1, :e2, :e3).look
      use_synth :tb303
      play note, release: 0.1, cutoff: 70
      sleep 0.125
    end

Ahora, mientras suena, empieza a cambiar el código. Cambia los tipos de bloques - prueba `:water`, `:grass` o tu tipo de bloque favorito. Prueba también a cambiar el valor de cutoff de `70` a `80` y así hasta `100`. ¿Divertido, eh?

## Juntándolo todo

Vamos a combinar todo lo que hemos visto hasta ahora con un poco de magia extra. Vamos a combinar nuestra habilidad de teletransporte con moviminto de bloques y música, para crear un Videoclip de Minecraft. No te preocupes si no lo entiendes todo, tú dale y prueba a cambiar algunos valores mientras se ejecuta. Pásatelo bien y hasta la próxima…

    live_loop :note_blocks do
      mc_message "This is Sonic Minecraft"
      with_fx :reverb do
        with_fx :echo, phase: 0.125, reps: 32 do
          tick
          x = (range 30, 90, step: 0.1).look
          y = 20
          z = -10
          mc_teleport x, y, z
          ns = (scale :e3, :minor_pentatonic)
          n = ns.shuffle.choose
          bs = (knit :glass, 3, :sand, 1)
          b = bs.look
          synth :beep, note: n, release: 0.1
          mc_set_block b, x+20, n-60+y, z+10
          mc_set_block b, x+20, n-60+y, z-10
          sleep 0.25
        end
      end
    end
    live_loop :beats do
      sample :bd_haus, cutoff: 100
      sleep 0.5
    end

# - Bizet Beats

Tras nuestra pequeña excursión por el mundo fantástico de Minecraft programando con Sonic Pi este último mes, vamos a hacer música de nuevo. Hoy vamos a traer una pieza ópera clásica al siglo 21, usando el poder alucinante de la programación.

## Atroz y Disruptivo

Viajemos atrás en el tiempo, al año 1875. Un compositor llamado Bizet ha acabado su última ópera, Carmen. Por desgracia, como ocurre con las piezas de música más disruptivas, no le gustó a la gente porque era demasiado expererimental y diferente. Tristemente, Bizet murió diez años antes de que la ópera se hiciese conocida internacionalmente y se convirtiese en una de las óperas más famosas y más tocadas de todos los tiempos. En un acto de simpatía con este genio y su tragedia, vamos a coger uno de los temas principales de Carmen y a convertirlo a un formato moderno de música que también es muy atroz y diferente para la mayoría de la gente de nuestra época - ¡la música con live coding!

## Descifrando la Habanera

Intentar hacer live coding con la ópera entera sería todo un desafío para este tutorial, así que vamos a centrarnos en una de las partes más conocidas - la línea de bajo de la Habanera:

Esto te puede parecer extremadamente ilegible si nunca has estudiado notación musical. No obstante, l@s programador@s vemos la notación musical como otra forma de código - sólo representa instrucciones para un/a músic@ en vez de un ordenador. Por tanto necesitamos encontrar una forma de descifrarlo.

## Notas

Las notas están colocadas de izquierda a derecha como las palabras en esta revista, pero tienen distintas alturas. La altura en la partitura representa la altura de la nota. Cuanto más alta sea la nota en la partitura, mayor será la altura de la nota.

En Sonic Pi ya sabemos cómo cambiar la altura de una nota - usamos números más o menos altos como `play 75` y `play 80`, o usamos los nombres de las notas: `play :E` y `play :F`. Por suerte, cada una de las posiciones verticales de la partitura representa el nombre de una nota específica. Échale un vistazo a esta tabla, es bastante útil:

## Silencios

Las partituras musicales son un tipo de código extremadamente rico y expresivo capaz de comunicar muchas cosas. Por tanto, no debería sorprenderte que las partituras no sólo te muestran cuándo tocar notas, sino también cuándo no tocarlas. En programación, esto es bastante parecido al concepto de `nil` o `null` - la ausencia de valor. En otras palabras, no tocar una nota es como la ausencia de una nota.

Si has mirado de cerca la partitura, verás que en realidad es una combinación de puntos negros, con líneas que representan las notas a tocar, y con cosas con forma de garrapata que representan silencios. Afortunadamente, Sonic Pi tiene una representación muy útil para el silencio: `:r`, así que si ejecutamos: `play :r`, en realidad, ¡está tocando silencio! También podríamos escribir `play :rest`, `play nil` o `play false`, que son formas equivalentes de representar silencios.

## Ritmo

Finalmente, hay una última cosa que debemos aprender para descifrar la notación - los ritmos de las notas. En la notación original puedes ver que las notas están conectadas con líneas gruesas, llamadas barras. La segunda nota tiene dos de estas barras, que significa que dura la dieciseisava parte de un compás (lo que se llama beat en Sonic Pi). Las otras notas tienen una sola barra, que significa que duran la octava parte de un compás. El silencio tiene dos barras con forma de garrapata, que significa que también representa un dieciseisavo de un compás.

Cuando intentamos descifrar y explorar cosas nuevas, un truco muy útil es hacer todo lo más parecido posible, y buscar relaciones o patrones comunes. Por ejemplo, cuando reescribimos nuestra notación sólo con semicorcheas, vemos una secuencia muy sencilla de notas y silencios.

## Re-programando la Habanera

Ahora podemos empezar a traducir esta línea de bajo en Sonic Pi. Vamos a codificar estas notas y silencios en un anillo:

    (ring :d, :r, :r, :a, :f5, :r, :a, :r)

Veamos cómo suena. Ponlo en un live loop y haz tick sobre el mismo:

    live_loop :habanera do
      play (ring :d, :r, :r, :a, :f5, :r, :a, :r).tick
      sleep 0.25
    end

¡Fabuloso! La famosa melodía cobra vida a través de tus altavoces. Costó un poquitín llegar hasta aquí, pero ha merecido la pena - ¡choca los cinco!

## Sintetizadores Enfadados

Ahora que tenemos la línea de bajo, vamos a recrear parte de la atmósfera de esta escena de ópera. Un sintetizador que podríamos probar es `:blade`, que es un sintetizador lead con tono enfadado de los 80s. Vamos a probarlo con la nota inicial `:d`, que vamos a pasar por un slicer y un efecto de reverberación:

    live_loop :habanera do
      use_synth :fm
      use_transpose -12
      play (ring :d, :r, :r, :a, :f5, :r, :a, :r).tick
      sleep 0.25
    end
    with_fx :reverb do
      live_loop :space_light do
        with_fx :slicer, phase: 0.25 do
          synth :blade, note: :d, release: 8, cutoff: 100, amp: 2
        end
        sleep 8
      end
    end

Ahora, prueba con otras notas en la línea de bajo: `:a` y `:f5`. Recuerda, no tienes por qué parar, puedes modificar el código mientras suena la música y darle a Ejecutar de nuevo. Además, puedes probar distintos valores para el opt `phase:` del slicer, como `0.5`, `0.75` y `1`.

## Juntándolo todo

Finalmente, vamos a combinar todas las ideas que hemos visto hasta ahora en un nuevo remix de la Habanera. Habrás visto que he incluido otra parte de la línea de bajo como comentario. Una vez hayas escrito todo en un búfer vacío, dale a Ejecutar para escuchar la composición. Ahora, sin parar el progama, descomenta la segunda línea borrando el `#` y dándole a Ejecutar de nuevo - ¿a que suena genial? Ahora, empieza a mezclarlo tú mism@ y diviértete.

    use_debug false
    bizet_bass = (ring :d, :r, :r, :a, :f5, :r, :a, :r)
    #bizet_bass = (ring :d, :r, :r, :Bb, :g5, :r, :Bb, :r)

    with_fx :reverb, room: 1, mix: 0.3 do
      live_loop :bizet do
        with_fx :slicer, phase: 0.125 do
          synth :blade, note: :d4, release: 8,
            cutoff: 100, amp: 1.5
        end
        16.times do
          tick
          play bizet_bass.look, release: 0.1
          play bizet_bass.look - 12, release: 0.3
          sleep 0.125
        end
      end
    end

    live_loop :ind do
      sample :loop_industrial, beat_stretch: 1,
        cutoff: 100, rate: 1
      sleep 1
    end

    live_loop :drums do
      sample :bd_haus, cutoff: 110
      synth :beep, note: 49, attack: 0,
        release: 0.1
      sleep 0.5
    end

# - Conviértete en un VJ de Minecraft

Minecraft Pi

Todo el mundo ha jugado a Minecraft. Seguro que tod@s vosotr@s habéis construido estructuras increíbles, habéis diseñado trampas ingeniosas, e incluso habéis creado complejas líneas de carros con interruptores de roca roja. ¿Cuánt@s habéis hecho una actuación con Minecraft? Apuesto a que no sabíais que se puede usar Minecraft para crear efectos visuales alucinantes, como un/a VJ profesional.

Si tu única forma de cambiar Minecraft era con el ratón, te habrá costado cambiar cosas rápidamente. Por suerte, Raspberry Pi contiene una versión de Minecraft que se puede controlar con código. También tiene una app llamada Sonic Pi que no sólo hace fácil programar Minecraft, sino que lo hace increíblemente divertido.

En el artículo de hoy, vamos a enseñarte algunos consejos y trucos que hemos usado para dar conciertos en discotecas y escenarios por todo el mundo.

Empecemos…

## Manos a la Obra

Vamos a empezar con un ejercicio fácil de calentamiento, para refrescar los conceptos básicos. Primero, enciende tu Raspberry Pi e inicia Minecraft y Sonic Pi. En Minecraft, crea un nuevo mundo, y en Sonic Pi, escoge un búfer vacío y escribe este código:

    mc_message "Comencemos..."

Dale al botón de Ejecutar y verás el mensaje en la ventana de Minecraft. Vale, ya estamos en marcha, ahora vamos a divertirnos…

## Tormentas de Arena

Cuando usamos Minecraft para crear efectos visuales, intentamos pensar en algo que sea interesante y que al mismo tiempo sea fácil de generar con código. Un truco muy chulo es crear una tormenta de arena, dejando caer bloques de arena del cielo. Para ello necesitamos algunas funciones básicas:

- `sleep` - para insertar una pausa entre acciones
- `mc_location` - para conocer nuestra posición actual
- `mc_set_block` - para colocar bloques de arena en un sitio en concreto
- `rrand` - para generar valores aleatorios dentro de un rango
- `live_loop` - para hacer que llueva arena constantemente

Si no estás familiarizad@ con funciones como `rrand`, sólo tienes que escribir la palabra en tu búfer, hacer click en ella, y teclear el atajo de teclado `Control-i` para mostrar la documentación incluida en Sonic Pi. También puedes navegar por la pestaña lang en el sistema de Ayuda y mirar las funciones directamente, entre otras cosas alucinantes que puedes hacer.

Vamos a hacer que llueva un poco antes de desatar completamente el poder de la tormenta. Mira tu posición actual y úsala para crear unos cuantos bloques de arena en el cielo, cerca de ti:

    x, y, z = mc_location
    mc_set_block :sand, x, y + 20, z + 5
    sleep 2
    mc_set_block :sand, x, y + 20, z + 6
    sleep 2
    mc_set_block :sand, x, y + 20, z + 7
    sleep 2
    mc_set_block :sand, x, y + 20, z + 8

Cuando le des a Ejecutar, puedes mirar a tu alrededor, ya que los bloques pueden empezar a caer detrás tuya, dependiendo de a dónde estés mirando ahora mismo. No te preocupes; si no los has llegado a ver, sólo tienes que darle a Ejecutar de nuevo para tener otra ronda de lluvia de arena - ¡asegúrate de que miras en la dirección adecuada!

Vamos a hacer un repaso rápido lo que está pasando. En la primera línea hemos usado la posición de Steve en coordenadas con la función `mc_location`, y las hemos puesto en las variables `x`, `y` y `z`. En las siguientes líneas hemos usado la función `mc_set_block` para colocar unos cuantos bloques de arena en las mismas coordenadas que Steve, pero con algunas modificaciones. Escogimos la misma coordenada x, una coordenada y 20 bloques más alta, y coordenadas z cada vez más grandes, para que la arena caiga en una línea que se aleja de Steve.

¿Por qué no coges el código y empiezas a trastear tú mism@? Prueba a añadir más líneas, cambia las pausas, mezcla `:sand` con `:gravel` (gravilla), y escoge distintas coordenadas. ¡Experimenta y diviértete!

## Live Loops Desatados

Vale, es hora de tener la ira de la tormenta… Para ello vamos a desatar todo el poder del `live_loop`, la habilidad mágica de Soni Pi que desencadena el verdadero poder del live coding - ¡cambiar el código al vuelo mientras se ejecuta!

    live_loop :sand_storm do
      x, y, z = mc_location
      xd = rrand(-10, 10)
      zd = rrand(-10, 10)
      co = rrand(70, 130)
      synth :cnoise, attack: 0, release: 0.125, cutoff: co
      mc_set_block :sand, x + xd, y+20, z+zd
      sleep 0.125
    end

¡A que mola! Estamos dando vueltas muy rápido (8 veces por segundo), y en cada segundo estamos encontrando la posición de Steve igual que antes, pero después generamos 3 valores aleatorios:

- `xd` - la diferencia de x, entre -10 y 10
- `zd` - la diferencia de z, también entre -10 y 10
- `co` - un valor de cutoff para el filtro de paso bajo, entre 70 y 130

Después usamos esos valores aleatorios en las funciones `synth` y `mc_set_block`, con lo que tenemos arena cayendo en posiciones aleatorias alrededor de Steve, al mismo tiempo que se oye un sonido percusivo de lluvia, que viene del sintetizador `:cnoise`.

Para aquell@s que no conozcáis los live loops, son la parte donde empieza la diversión en Sonic Pi. Mientras el código se ejecuta y diluvia la arena, prueba a cambiar uno de los valores, tal vez el tiempo de pausa (sleep) a `0.25`, o el tipo de bloque de `:sand` a `:gravel` (gravilla). Ahora dale a Ejecutar de nuevo. ¡Abracadabra! Las cosas han cambiado sin tener que parar el código. Esto te abre las puertas a actuar como un/a verdader@ VJ. Sigue practicando y cambiando cosas. ¿De cuántas formas puedes cambiar los efectos visuales sin parar el código?

## Patrones de Bloques Épicos

Finalmente, otra forma excelente de generar efectos visuales interesantes es crear paredes con patrones, y volar alrededor para verlas de cerca. Para este efecto, necesitamos pasar de colocar los bloques aleatoriamente a colocarlos de forma ordenada. Podemos hacer esto anidando dos iteraciones (dale al botón de Ejecutar y navega por la sección 5.2 del tutorial “Iteración y Bucles” para tener más información sobre las iteraciones). El divertido `|xd|` después del `do` significa que `xd` va a cambiar en cada iteración. La primera vez será 0, luego 1, luego 2… etc. Al anidar dos bloques de iteración juntos como hemos hecho, podemos generar las coordenadas de un cuadrado. Después podemos escoger tipos de bloques aleatoriamente, con un anillo de bloques, para obtener un efecto interesante:

    x, y, z = mc_location
    bs = (ring :gold, :diamond, :glass)
    10.times do |xd|
      10.times do |yd|
        mc_set_block bs.choose, x + xd, y + yd, z
      end
    end

¡Genial! Mientras nos lo pasamos pipa por aquí, prueba a cambiar `bs.choose` a `bs.tick` para pasar de un patrón aleatorio a uno más regular. Prueba a cambiar los tipos de bloque. Para l@s más atrevid@s, podéis probar a meter este cambio en un `live_loop`, para que los patrones sigan cambiando automáticamente.

Y para el final apoteósico - cambia los dos `10.times` a `100.times` y dale a Ejecutar. ¡Kaboom! Una pared ENORME con bloques puestos aleatoriamente. ¡Imagina cuánto tiempo te habría llevado construirlo a mano con el ratón! Pulsa la tecla Espacio dos veces para activar el modo vuelo, y baja en picado para ver efectos visuales alucinantes. No pares todavía - usa tu imaginación para darle rienda suelta a tus ideas, y usa el poder de Sonic Pi para hacerlas realidad. Cuando hayas practicado, apaga las luces y ¡muéstrale tu show de VJ a tus amig@s!

# - Navegando por Flujos Aleatorios

En el episodio 4 de esta serie de tutoriales, vimos brevemente la aleatoriedad al programar unos chispeantes riffs de sintertizador. Ya que la aleatoriedad es una parte tan importante de mis conciertos de live coding, pensé que sería útil enseñarte los fundamentos en mayor detalle. Así pues, vamos manos a la obra, ¡a navegar por los flujos aleatorios!

## No existe lo aleatorio

Lo primero que debes aprender y que probablemente te sorprenda cuando empieces a tocar con las funciones aleatorias de Sonic Pi, es que en realidad no son aleatorias. ¿Qué significa esto? Vamos a hacer unas cuantas pruebas. Primero, imagínate un número en tu cabeza de 0 a 1. Recuérdalo y no me lo digas. Ahora déjame adivinar… era `0.321567`? Bah, esto no se me da bien. Déjame intentarlo de nuevo, pero ahora le vamos a pedir a Sonic Pi que escoja el número. Abre Sonic Pi v2.7+ (versión 2.7 o posterior) y pídele un número aleatorio, pero de nuevo, no me digas cuál es:

    print rand

Veamos… ¿es `0.75006103515625`? ¡Sí! Ja ja, veo que no te lo crees. Bueno, tal vez tuve suerte. Probemos de nuevo. Dale al botón de Ejecutar y mira qué te sale… ¿Cómo? ¿Otra vez `0.75006103515625`? ¡Esto no puede ser aleatorio! Tienes razón, no lo es.

¿Qué está pasando? En estos casos l@s informátic@s usamos el palabrejo determinismo. Sencillamente, esta palabra significa que nada ocurre al azar y que todo está predestinado. Tu versión de Sonic Pi está destinada a devolver siempre `0.75006103515625` en el programa de arriba. Esto puede parecerte inútil, pero voy a intentar convencerte de que es una de las partes más potentes de Sonic Pi. Si me sigues, aprenderás cómo confiar en la naturaleza determinista de la aleatoriedad de Sonic Pi, y la usarás como un bloque de construcción fundamental para tus composiciones y conciertos de live coding.

## Una melodía aleatoria

Cuando abres Sonic Pi, éste carga en memoria una secuencia de 441.000 valores aleatorios generados previamente. Cuando llamas a una función aleatoria como `rand` o `rrand`, se usa esta lista de valores aleatorios para generar tu resultado. Cada llamada a una función aleatoria consume un valor de esta lista. Por tanto, la décima llamada a una función aleatoria usará el décimo valor de la lista. Además, cada vez que pulsas el botón de Ejecutar, la lista se resetea para esa ejecución. Por eso pude adivinar el resultado de `rand`, y por eso la melodía ‘aleatoria’ era siempre la misma. La versión de Sonic Pi de todo el mundo usa exactamente la misma lista aleatoria, lo que es muy importante cuando empezamos a compartir nuestras canciones con otras personas.

Vamos a usar lo que hemos aprendido para generar una melodía aleatoria que se repita:

    8.times do
     play rrand_i(50, 95)
     sleep 0.125
    end

Escribe esto en un búfer vacío y dale a Ejecutar. Escucharás una melodía hecha con notas ‘aleatorias’ entre 50 y 95. Cuando haya acabado, dale a Ejecutar de nuevo y escucharás exactamente la misma melodía.

## Funciones Aleatorias Útiles

Sonic Pi contiene un montón de funciones para trabajar con la lista de valores aleatorios. Aquí tienes una lista de las más útiles:

- `rand` - Sencillamente devuelve el siguiente valor de la lista aleatoria
- `rrand` - Devuelve un valor aleatorio dentro de un rango
- `rrand_i` - Devuelve un número entero aleatorio dentro de un rango
- `one_in` - Devuelve verdadero o falso dependiendo con una probabilidad determinada
- `dice` - Imita el lanzar un dado, devolviendo un valor entre 1 y 6
- `choose` - Elige un valor aleatorio de una lista

Mira la documentación en el sistema de Ayuda para más información y ejemplos.

## Reseteando la Lista

Aunque poder repetir una secuencia de notas es esencial para poder reproducir tu riff en el concierto, puede que no sea exactamente lo que buscas. ¿No sería genial poder probar con distintos riffs y escoger el que mśa te guste? Aquí es donde empieza la magia.

Podemos ajustar la lista de valores aleatorios manualmente, con la función `use_random_seed`. En informática, una semilla aleatoria (random seed) es el punto de partida desde el cual una nueva lista de valores aleatorios puede brotar y florecer. Vamos a probarlo:

    use_random_seed 0
    3.times do
      play rrand_i(50, 95)
      sleep 0.125
    end

¡Genial!, tenemos las tres primeras notas de nuestra melodía aleatoria de arriba: `84`, `83` y `71`. Ahora podemos cambiar la semilla a un valor distinto. A ver qué te parece así:

    use_random_seed 1
    3.times do
      play rrand_i(50, 95)
      sleep 0.125
    end

Interesante, obtenemos `83`, `71` y `61`. Puede que te hayas fijado en que los dos primeros números son los mismos que los dos últimos números de antes… no es una coincidencia.

Recuerda que la lista de valores es sencillamente una lista gigante de valores previamente calculados. Usar una semilla aleatoria sólo nos hace saltar a un punto dentro de la lista. Otra forma de verlo: imagínate una baraja de cartas gigante que ha sido barajada previamente. Usar una semilla aleatoria es como cortar la baraja en un punto. Lo mejor de esto es precisamente que puedes saltar por la lista de valores, lo que nos da un gran poder cuando hacemos música.

Vamos a visitar de nuevo nuestra melodía aleatoria de 8 notas con nuestra nueva habilidad para resetear la lista aleatoria, pero ahora vamos a meter un live loop, para poder probar cosas mientras suena:

    live_loop :random_riff do
      use_random_seed 0
      8.times do
        play rrand_i(50, 95), release: 0.1
        sleep 0.125
      end
    end

Ahora, mientras sigue sonando, cambia el valor de la semilla de `0` a algo distinto. Prueba `100`, o `999`. Prueba con tus propios valores, experimenta y juega con ello: a ver qué semilla genera el riff que más te guste.

## Juntándolo todo

El tutorial de este mes ha sido una inmersión un poco técnica en el sistema de aleatoriedad de Sonic Pi. Con suerte, te habrá servido para entender cómo funciona y cómo puedes usar la aleatoriedad con seguridad, creando patrones reproducibles en tu música. Es importante recalcar que puedes usar dicha aleatoriedad reproducible donde quieras. Por ejemplo, puedes hacer aleatorios la amplitud de las notas, el ritmo, la cantidad de reverberación, el sintetizador actual, la cantidad de mezcla de un efecto, etc. En el futuro veremos de cerca alguna de estas aplicaciones, pero de momento, déjame enseñarte un ejemplo corto.

Escribe el siguiente código en un búfer vacío, dale a Ejecutar, y empieza a cambiar las semillas, dale a Ejecutar de nuevo (mientras suena) y explora distintos sonidos, ritmos y melodías que puedes hacer. Cuando hayas encontrado algo que te guste, recuerda el valor de la semilla para que puedas usarla más tarde. Finalmente, cuando hayas encontrado unas cuantas semillas que te gusten, márcate un concierto de live coding para tus amig@s; sólo tienes que cambiar entre tus semillas favoritas, creando una pieza completa.

    live_loop :random_riff do
      use_random_seed 10300
      use_synth :prophet
      s = [0.125, 0.25, 0.5].choose
      8.times do
        r = [0.125, 0.25, 1, 2].choose
        n = (scale :e3, :minor).choose
        co = rrand(30, 100)
        play n, release: r, cutoff: co
        sleep s
      end
    end
    live_loop :drums do
      use_random_seed 2001
      16.times do
        r = rrand(0.5, 10)
        sample :drum_bass_hard, rate: r, amp: rand
        sleep 0.125
      end
    end

# - Controlando tu sonido

Hasta ahora en esta serie, nos hemos centrado en usar sonidos disparándolos. Hemos descubierto que podemos disparar los distintos sintetizadores de Sonic Pi con `play` o `synth`, y hemos aprendido cómo lanzar samples pregrabados con `sample`. También hemos visto cómo podemos pasar estos sonidos por efectos de estudio, como reverberación y distorsión, usando el comando `with_fx`. Combina esto con el sistema de tiempo increíblemente preciso de Sonic Pi, y puedes producir una cantidad enorme de sonidos, beats y riffs. Sin embargo, una vez has seleccionado las opciones de un sonido y lo has disparado, no hay forma de cambiar dichas opciones mientras suena, ¿verdad? ¡Pues no! Hoy vas a aprender algo muy potente: cómo controlar sintetizadores en ejecución.

## Un sonido básico

Hagamos un sonido simple. Arranca Sonic Pi y en un buffer libre escribe lo siguiente:

    synth :prophet, note: :e1, release: 8, cutoff: 100

Ahora pulsa el botón de Ejecutar (arriba a la izquierda) para escuchar un adorable y estruendoso sintetizador. No pares, ejecútalo varias veces para que tengas una primera impresión. Vale, ¿lo tienes? Entonces, ¡vamos a empezar a controlarlo!

## Synth Nodes

Una funcionalidad poco conocida de Sonic Pi es que las funciones `play`, `synth` y `sample` devuelven algo llamado `SynthNode` (nodo de sintetizador), que representa un sonido en ejecución. Puedes capturar un `SynthNode` usando una variable normal y corriente, y luego controlarlo más tarde. Por ejemplo, vamos a cambiar la opción `cutoff:` después de 1 beat:

    sn = synth :prophet, note: :e1, release: 8, cutoff: 100
    sleep 1
    control sn, cutoff: 130

Veamos cada línea una por una:

En primer lugar tenemos el sintetizador `:prophet` que usa la función `synth` como de costumbre. Sin embargo, hemos capturado el resultado en una variable llamada `sn`. Podríamos haber llamado a esta variable de cualquier forma, como `synth_node` o `jane` - el nombre no importa. Lo que sí es importante es escoger un nombre que tenga sentido para ti cuando des tu concierto, o para otras personas que quieran leer tu código. Yo he usado `sn` porque es una abreviatura de synth node.

En la línea 2 hemos usado un comando `sleep` normal y corriente. Esto no hace nada especial; sencillamente, le pide al ordenador que espere 1 beat antes de moverse a la siguiente línea.

En la línea 3 empieza la diversión con el tema del control. Aquí hemos usado la función `control` para decirle a nuestro `SynthNode` en ejecución que cambie su valor de cutoff a `130`. Si le das al botón de Ejecutar, escucharás el sintetizador que empieza a tocar como antes, pero después de 1 beat verás que cambia a un sonido mucho más brillante.

Opciones Modulables

La mayoría de las opciones para sintetizadores y efectos de Sonic Pi se pueden cambiar después de haber sido disparadas. Sin embargo, esto no pasa con todas. Por ejemplo, las opciones de envolvente en `attack:`, `decay:`, `sustain:` y `release:` sólo se pueden controlar cuando disparas el sintetizador. Es fácil saber qué opts puedes cambiar y cuáles no puedes cambiar; busca el sintetizador o efecto que quieras en la documentación, baja hasta la documentación de las opts, y busca las frases “Puede ser cambiado mientras se toca” o “No se puede cambiar una vez iniciado”. Por ejemplo, la documentación para la opción `attack:` del sintetizador `:beep` nos deja claro que no se puede cambiar esa opción después de disparar el sintetizador:

- Default: 0
- Debe ser cero o mayor
- No se puede cambiar una vez disparado
- Escalado con el valor actual de BPM

## Cambios múltiples

Mientras un sintetizador está en ejecución, no estás limitado a cambiarlo sólo una vez: puedes cambiarlo tantas veces como quieras. Por ejemplo, podemos convertir nuestro `:prophet` en un mini arpegiador con el siguiente código:

    notes = (scale :e3, :minor_pentatonic)
    sn = synth :prophet, note: :e1, release: 8, cutoff: 100
    sleep 1
    16.times do
      control sn, note: notes.tick
      sleep 0.125
    end

Hemos añadido unas cosillas extra en este fragmento de código. Primero, hemos definido una nueva variable llamada `notes` que contiene las notas por las que nos gustaría pasar (por cierto, arpegiador sólo es un palabrejo para algo que da vueltas sobre una lista de notas en orden). Segundo, hemos reemplazado nuestra llamada a `control` por una iteración que la llama 16 veces. En cada llamada a `control`, hacemos `.tick` sobre nuestro anillo de notas (`notes`), que se repite automáticamente cuando llegamos al final (gracias al fabuloso poder de los anillos de Sonic Pi). Para tener algo más de variedad, prueba a reemplazar `.tick` por `.choose`, a ver si puedes escuchar la diferencia.

Fíjate en que podemos cambiar varios opts a la vez. Prueba a cambiar la línea de control por la siguiente, y escucha la diferencia:

    control sn, note: notes.tick, cutoff: rrand(70, 130)

## Sliding

Cuando controlamos un `SynthNode`, éste responde exactamente a tiempo y cambia al instante el valor del opt por uno nuevo, como si hubieras presionado un botón o hubieras accionado un interruptor. Esto puede sonar rítmico y percusivo - especialmente si el opt controla un aspecto del timbre, como `cutoff:`. Sin embargo, a veces no quieres que el cambio sea instantáneo. Tal vez quieras moverte suavemente del valor actual al nuevo, como si estuvieras moviendo un deslizador o un dial. Por supuesto, Sonic Pi también puede hacer esto, usando los opts `_slide:`.

Cada opción que puede ser modificada también tiene una opción `_slide:` correspondiente, que permite especificar el tiempo de deslizamiento (slide). Por ejemplo, `amp:` tiene `amp_slide:`, y `cutoff:` tiene `cutoff_slide:`. Estas slide opts son muy distintas al resto de opts, ya que le dicen a la nota del sintetizador cómo comportarse la siguiente vez que sean controladas. Vamos a echarle un vistazo:

    sn = synth :prophet, note: :e1, release: 8, cutoff: 70, cutoff_slide: 2
    sleep 1
    control sn, cutoff: 130

Fíjate en que este ejemplo es exactamente igual que el de antes, excepto por el `cutoff_slide:`. Esto le dice al sintetizador que, para la próxima vez que controle su opción `cutoff:`, tiene que usar 2 beats para deslizarse desde el valor actual hasta el nuevo valor. Por eso puedes escuchar el cutoff moverse de 70 a 130 cuando usas `control`. Esto le da al sonido un toque dinámico muy interesante. Ahoa prueba a cambiar el tiempo de `cutoff_slide:` a un valor más corto, como 0.5, o un valor más largo, como 4, para ver cómo cambia el sonido. Recuerda, puedes hacer slide entre cualquiera de las opciones modificables de esta forma, y cada valor de `_slide:` puede ser totalmente distinto. Puedes hacer que el cutoff cambie lentamente, que el amp cambie rápido y que el pan cambie a un ritmo intermedio; configúralo a tu gusto, como estés pensando para tu nueva creación…

## Juntándolo todo

Veamos un breve ejemplo que demuestra el poder de controlar sintetizadores después de haberlos disparado. Fíjate en que también puedes hacer slide con los efectos igual que con los sintetizadores, aunque con una sintaxis ligeramente distinta. Mira la sección 7.2 del tutorial incluido en Sonic Pi para más información sobre el control de los FX (efectos).

Copia el código en un búfer separado y escúchalo unos instantes. No dejes que se acabe ahí: juega con el código. Cambia los tiempos de slide, cambia las notas, el sintetizador, los FX y los tiempos de pausa, ¡a ver si puedes convertirlo en algo totalmente distinto!

    live_loop :moon_rise do
      with_fx :echo, mix: 0, mix_slide: 8 do |fx|
        control fx, mix: 1
        notes = (scale :e3, :minor_pentatonic, num_octaves: 2).shuffle
        sn = synth :prophet , sustain: 8, note: :e1, cutoff: 70, cutoff_slide: 8
        control sn, cutoff: 130
        sleep 2
        32.times do
          control sn, note: notes.tick, pan: rrand(-1, 1)
          sleep 0.125
        end
      end
    end

# - Siguiendo el Beat

El último mes hicimos una inmersión técnica en el sistema de aleatoriedad de Sonic Pi. Exploramos cómo podemos usarlo para añadir nuevos niveles de control dinámico en nuestro código, de forma determinista. Este mes vamos a continuar con nuestra inmersión técnica, para enseñarte el sistema de tick único en Sonic Pi. Al final del artículo, podrás recorrer tus ritmos y riffs con total facilidad, avanzando en tu camino para ser un/a DJ de live coding.

## Contando Beats

Normalmente, cuando hacemos música, queremos hacer distintas cosas dependiendo de cómo sea nuestro beat. Sonic Pi tiene un sistema especial para contar beats llamado `tick` que te proporciona un control muy preciso sobre cuándo ocurre un beat, e incluso permite usar distintos beats con sus propios tempos.

Vamos a tocar un poco. Para hacer avanzar el beat sólo tenemos que llamar a `tick`. Abre un búfer nuevo, escribe el siguiente código y dale a Ejecutar:

    puts tick #=> 0

Esto devuelve el beat actual: `0`. Fíjate en que aunque presiones el botón de Ejecutar varias veces, siempre va a devolver `0`. Esto pasa porque cada ejecución empieza un beat nuevo, empezando a contar desde 0. Sin embargo, mientras la ejecución siga activa, podemos hacer avanzar el beat tantas veces como queramos:

    puts tick #=> 0
    puts tick #=> 1
    puts tick #=> 2

Cuando veas el símbolo `#=>` al final de una línea de código, significa que esa línea va a escribir el texto que queda al lado derecho. Por ejemplo, `puts foo #=> 0` significa que el código `puts foo` imprime`0` en el log en ese momento de la ejecución.

## Comprobando el Beat

Hemos visto que `tick` hace dos cosas. Tick incrementa (añade uno) y devuelve el beat actual. A veces sólo queremos ver el beat actual sin tener que incrementarlo, lo que podemos hacer con `look`:

    puts tick #=> 0
    puts tick #=> 1
    puts look #=> 1
    puts look #=> 1

En este código incrementamos el beat dos veces haciendo tick y entonces llamamos `look` dos veces. Veremos los siguientes valores en el log: `0`, `1`, `1`, `1`. Los dos primeros `tick`s han devuelto `0`, después `1` como esperábamos, finalmente los dos `look`s simplemente devolvieron el ultimo valor del beat dos veces, lo cual ha sido `1`.

## Anillos

Así que ahora podemos avanzar el beat con `tick`, y comprobar el beat con `look`. ¿Y ahora qué? Necesitamos algo sobre lo que hacer tick. Sonic Pi utiliza anillos para representar riffs, melodías y ritmos, y el sistema de ticking ha sido diseñado específicamente para trabajar con anillos. De hecho, los anillos tienen su propia versión de `tick` (`.tick`, con punto) que hace dos cosas. Primero, actúa como un tick normal e incrementa el beat. Segundo, obtiene el valor del anillo usando el beat como índice (posición dentro del anillo). Veamos:

    puts (ring :a, :b, :c).tick #=> :a

`.tick` es una versión especial (con un punto delante) de `tick`, que devuelve el primer valor del anillo `:a`. Podemos coger cada uno de los valores del anillo llamando `.tick` varias veces:

    puts (ring :a, :b, :c).tick #=> :a
    puts (ring :a, :b, :c).tick #=> :b
    puts (ring :a, :b, :c).tick #=> :c
    puts (ring :a, :b, :c).tick #=> :a
    puts look                   #=> 3

Mira el log y allí verás `:a`, `:b`, `:c` y de nuevo `:a`. Fíjate que `look` devuelve `3`. Las llamadas a `.tick` funcionan como si fueran llamadas normales a `tick`- incrementan el beat local.

## Un Arpegiador de Live Loop

El poder read viene cuando mezclas `tick` con rings y `live_loop`s. Cuando están combinados tenemos todas las herramientas necesarias para construir y también entender un simple arpegiador. Solo necesitamos cuatro cosas:

1. Un ring que contiene las notas que queremos repetir.
2. Una forma de incrementar y obtener el beat.
3. La capacidad de tocar una nota en función del beat actual.
4. Una bucle para mantener al arpegiador repitiéndose.

Estos conceptos pueden ser comprobados en el siguiente código:

    notes = (ring 57, 62, 55, 59, 64)
    live_loop :arp do
      use_synth :dpulse
      play notes.tick, release: 0.2
      sleep 0.125
    end

Veamos cada una de estas líneas. Primero definimos nuestro ring de notas que reproduciremos continuamente. Entonces creamos un `live_loop` llamado `:arp` que hace loop a nuestro alrededor. Cada vuelta en el `live_loop` ponemos nuestro synth en `:dpulse` y entonces tocamos la siguiente nota usando`.tick`. Recuerda que esto incrementará nuestro contador de beats y usará el último valor del beat como el índice para nuestro ring de notas. Finalmente, esperamos un octavo de beat antes de volver a empezar el loop.

## Múltiples Ritmos Simultáneos

Una cosa que hay que saber es que los `tick`s son locales al `live_loop`. Esto quiere decir que cada `live_loop` tiene su propio contador de beats independiente. Esto es mucho más potente que tener un metrónomo y ritmo global . Veamos como funciona esto:

    notes = (ring 57, 62, 55, 59, 64)
    with_fx :reverb do
      live_loop :arp do
        use_synth :dpulse
        play notes.tick + 12, release: 0.1
        sleep 0.125
      end
    end
    live_loop :arp2 do
      use_synth :dsaw
      play notes.tick - 12, release: 0.2
      sleep 0.75
    end

## Ritmos que chocan

Una causa de confusiones habituales con el sistema de tick de Sonic Pi es cuando la gente quiere hacer tick en varios rings dentro del mismo `live_loop`:

    use_bpm 300
    use_synth :blade
    live_loop :foo do
      play (ring :e1, :e2, :e3).tick
      play (scale :e3, :minor_pentatonic).tick
      sleep 1
    end

Aunque cada `live_loop` tiene su propio contador de beat (independiente del resto), estamos llamando a `.tick` dos veces dentro del mismo `live_loop`. Esto significa que el beat se incrementa dos veces en cada vuelta. Esto puede generar polirritmos interesantes, pero normalmente no es lo que queremos. Hay dos soluciones para este problema. Una opción es llamar a `tick` manualmente al principio del `live_loop`, y usar `.look` para mirar el beat actual en cada `live_loop`. Otra opción es pasarle un nombre único a cada llamada a `.tick`, como `.tick(:foo)`. De esta forma, Sonic Pi crea un contador de beat separado para cada tick que has nombrado, y realiza su seguimiento. De esta forma, ¡puedes trabajar con tantos beats como necesites! Mira la sección 9.4 (ticks con nombre) del manual incluido en Sonic Pi para más información.

## Juntándolo todo

Juntemos todo este conocimiento de los `tick`s, `ring`s y `live_loop`s en un ejemplo final. Como de costumbre, no consideres esto como una pieza acabada. Empieza cambiando cosas y jugando con ellos a ver en que puedes transformarlo. Nos vemos…

    use_bpm 240
    notes = (scale :e3, :minor_pentatonic).shuffle
    live_loop :foo do
      use_synth :blade
      with_fx :reverb, reps: 8, room: 1 do
        tick
        co = (line 70, 130, steps: 32).tick(:cutoff)
        play (octs :e3, 3).look, cutoff: co, amp: 2
        play notes.look, amp: 4
        sleep 1
      end
    end
    live_loop :bar do
      tick
      sample :bd_ada if (spread 1, 4).look
      use_synth :tb303
      co = (line 70, 130, steps: 16).look
      r = (line 0.1, 0.5, steps: 64).mirror.look
      play notes.look, release: r, cutoff: co
      sleep 0.5
    end

# - Cortando Samples

Cuando la gente descubre Sonic Pi, una de las primeras cosas que aprenden es lo fácil que resulta tocar sonidos pre-grabados usando la función `sample`. Por ejemplo, puedes tocar un loop de batería con sonido de tecno industrial, escuchar el sonido de un coro, o incluso oír un tocadiscos… todo con una sola línea de código. Sin embargo, mucha gente no se da cuenta de que puedes cambiar la velocidad del sample que estás tocando, consiguiendo efectos muy chulos y un logrando un nuevo nivel de control de tus sonidos grabados. Ahora, abre Sonic Pi y, ¡vamos a estirar samples!

## Sampleos

Para cambiar la velocidad a la que suena un sample (playback rate), usamos la opción `rate:`:

    sample :guit_em9, rate: 0.5

Si escribimos un `rate:` de `1`, el sample suena a la velocidad normal. Si queremos tocarlo a la mitad de velocidad, sólo tenemos que usar un `rate:` de `0.5`:

    sample :guit_em9, rate: 0.5

Observa que esto tiene dos efectos en el audio. En primer lugar, la muestra suena con un tono más bajo y, en segundo lugar, tarda el doble de tiempo en reproducirse (véase la barra lateral para una explicación de por qué esto es así). Incluso podemos elegir tasas cada vez más bajas acercándonos a `0`, de modo que una `rate:` de `0.25` es un cuarto de velocidad, `0.1` es un décimo de la velocidad, etc. Prueba a jugar con algunas tasas bajas y comprueba si puedes convertir el sonido en un estruendo bajo.

## Acelerando las muestras

Además de hacer el sonido más largo y más grave usando una velocidad baja, podemos usar velocidades altas para hacer el sonido más corto y más agudo. Ahora vamos a tocar con un loop de batería. Primero, escucha cómo suena con la velocidad por defecto de `1`:

    sample :loop_amen, rate: 1

Ahora, vamos a acelerarlo un poco:

    sample :loop_amen, rate: 1.5

¡Ja! Acabamos de pasar de tecno de la vieja escuela al jungle. Fíjate en cómo aumenta la altura de cada nota, y también en cómo se acelera el ritmo. Ahora, prueba con velocidades todavía más altas, y averigua cómo de alto y de corto puedes hacer el loop de batería. Por ejemplo, si usas una velocidad de `100`, ¡el loop se convierte en un click!

## Al Revés

Seguro que much@s estáis pensando en lo mismo ahora… “¿y qué pasa si usas un número negativo para la velocidad? ¡Muy buena pregunta! Vamos a pensar un momento. Si nuestra opt `rate:` representa la velocidad a la que se reproduce nuestro sample, `1` es velocidad normal, `2` es el doble de velocidad, y `0.5` es la mitad de velocidad, entonces, ¡con `-1` debe sonar al revés! Vamos a probar con una caja de batería. Primero, toca el sample a la velocidad normal:

    sample :elec_filt_snare, rate: 1

Ahora, ejecutado al revés:

    sample :elec_filt_snare, rate: -1

Por supuesto, puedes tocarlo al revés y al doble de velocidad con una velocidad de `-2`, o puedes tocarlo al revés a la mitad de velocidad con un `rate:` de `-0.5`. Prueba con distintos valores negativos y diviértete. ¡Suena especialmente curioso con el sample `:misc_burp`!

## Sample, Velocidad y Altura [Barra lateral]

Uno de los efectos de modificar la velocidad en los samples es que cuanta mayor es la velocidad, más agudo suena el sample en altura; a menor velocidad, más grave suena. Puede que hayas escuchado este efecto en tu día a día, cuando vas en bicicleta o en coche y pasas un paso de cebra con pitido; a medida que te acercas a la fuente del sonido, la altura es mayor que cuando estabas más lejos del paso de cebra. Esto se conoce como efecto Doppler. ¿Por qué ocurre?

Veamos un pitido sencillo (beep) representado con una onda de seno. Si usamos un osciloscopio para generar una gráfica del beep, veremos algo parecido a la Figura A. Si dibujamos un beep una octava más agudo, veremos la Figura B, y con una octava más se vería como en la Figura C. Fíjate en que las ondas de notas más agudas son más compactas, y que las notas más graves están más separadas.

El sample de un beep sólo es un montón de números (coordenadas x,y) que dibujan las curvas originales del sonido que se grabó. Mira la Figura D, donde cada círculo representa una coordenada. Para convertir las coordenadas a audio, el ordenador coge cada valor x y le envía su correspondiente valor y a los altavoces. El truco está en que el ordenador no tiene por qué procesar los valores de x y guardarlos al mismo tiempo. O sea, el hueco (la cantidad de tiempo) entre cada círculo se puede estirar o comprimir. Si el ordenador lee los valores de x más rápido que como sonaban en la vida real, los círculos se harán más pequeños y el beep sonará más agudo. También hará el beep más corto, porque pasamos por los círculos más rápido. Puedes ver este efecto en la Figura E.

Por último, tal vez te interese saber que un matemático llamado Fourier demostró que cualquier sonido es en realidad muchas ondas de seno juntas. Por eso, cuando comprimimos y estiramos cualquier sonido grabado, lo que estamos haciendo en realidad es comprimir y estirar muchas ondas de seno al mismo tiempo.

## Pitch Bending

Hemos visto que con una velocidad (rate) más alta, el sonido suena más agudo; y que con una velocidad más baja, el sonido suena más grave. Hay un truco muy fácil y útil que tiene que ver con esto. Cuando duplicas la velocidad, el sonido suena una octava más alto; y al revés, si divides la velocidad por dos, el sonido suena una octava más bajo. Esto quiere decir que si duplicas / divides por dos la velocidad de un sample melódico, va a seguir sonando bastante bien:

    sample :bass_trance_c, rate: 1
    sample :bass_trance_c, rate: 2
    sample :bass_trance_c, rate: 0.5

Pero, ¿y si queremos cambiar el rate para que el sample sólo suene un semitono (una tecla más arriba en el piano) más agudo, en vez de una octava entera? Podemos hacerlo fácilmente con Sonic Pi usando la opción `rpich:`:

    sample :bass_trance_c
    sample :bass_trance_c, rpitch: 3
    sample :bass_trance_c, rpitch: 7

Si miras los mensajes del registro (log) a la derecha, verás que un `rpitch:` de `3` se corresponde con un rate de `1.1892`, y un `rpitch` de `7` se corresponde con un rate de `1.4983`. Por último, podemos combinar los opts `rate:` y `rpitch:`:

    sample :ambi_choir, rate: 0.25, rpitch: 3
    sleep 3
    sample :ambi_choir, rate: 0.25, rpitch: 5
    sleep 2
    sample :ambi_choir, rate: 0.25, rpitch: 6
    sleep 1
    sample :ambi_choir, rate: 0.25, rpitch: 1

## Juntándolo todo

Vamos a echarle un vistazo a una pieza sencilla que combina estas ideas. Cópiala en un búfer vacío de Sonic Pi, dale a Ejecutar, escúchala un rato y úsala para empezar tu propia pieza. ¿Has visto qué divertido es jugar con el rate de los samples? Y aquí tienes un ejercicio extra: prueba a grabar tus propios sonidos y a cambiar la velocidad de reproducción para ver qué sonidos locos puedes hacer.

    live_loop :beats do
      sample :guit_em9, rate: [0.25, 0.5, -1].choose, amp: 2
      sample :loop_garzul, rate: [0.5, 1].choose
      sleep 8
    end

    live_loop :melody do
      oct = [-1, 1, 2].choose * 12
      with_fx :reverb, amp: 2 do
        16.times do
          n = (scale 0, :minor_pentatonic).choose
          sample :bass_voxy_hit_c, rpitch: n + 4 + oct
          sleep 0.125
        end
      end
    end

# - Programando un Secuenciador Probabilístico

En un episodio anterior de esta serie Sonic Pi exploramos el poder de la aleatoriedad para introducir variedad, sorpresa y cambio en nuestras pistas y actuaciones codificadas en directo. Por ejemplo, elegimos al azar notas de una escala para crear melodías interminables. Hoy vamos a aprender una nueva técnica que utiliza la aleatoriedad para el ritmo: ¡los ritmos probabilísticos!

## Portabilidad

Antes de empezar a crear nuevos ritmos y sintetizadores, tenemos que hacer una rápida inmersión en los fundamentos de la probabilidad. Esto puede sonar desalentador y complicado, pero en realidad es tan sencillo como tirar un dado, ¡de verdad! Cuando coges un dado de tablero normal de 6 caras y lo tiras, ¿qué ocurre en realidad? Bueno, en primer lugar, sacas un 1, 2, 3, 4, 5 o 6 con exactamente la misma probabilidad de obtener cualquiera de los números. De hecho, dado que es un dado de 6 caras, por término medio (si tiras muchas veces) sacarás un 1 cada 6 tiradas. Esto significa que tienes una probabilidad de 1 entre 6 de sacar un 1. Podemos emular las tiradas de dados en Sonic Pi con el fn `dice`. Tiremos uno 8 veces:

    8.times do
      puts dice
      sleep 1
    end

Fíjate en que el registro imprime los valores entre 1 y 6 como si hubiéramos tirado un dado real nosotros mismos.

## Semillas aleatorias

Escuchemos como suena:

    live_loop :random_beat do
      sample :drum_snare_hard if dice == 1
      sleep 0.125
    end

Vamos a repasar rápidamente cada línea para asegurarnos de que todo está muy claro. Primero creamos un nuevo `live_loop` llamado `:random_beat` que repetirá continuamente las dos líneas entre `do` y `end`. La primera de estas líneas es una llamada a `sample` que reproducirá un sonido pregrabado (el sonido `:drum_snare_hard` en este caso). Sin embargo, esta línea tiene un final condicional especial `if`. Esto significa que la línea sólo se ejecutará si la declaración a la derecha del `if` es `true` (verdadero). La sentencia en este caso es `dice == 1`. Esto llama a nuestra función `dice` que, como hemos visto, devuelve un valor entre 1 y 6. A continuación, utilizamos el operador de igualdad `==` para comprobar si este valor es `1`. Si es `1`, la sentencia se resuelve en `true` y nuestro tambor suena, si no es `1` la sentencia se resuelve en `false` y el tambor se salta. La segunda línea simplemente espera durante `0.125` segundos antes de volver a tirar los dados.

## Cambiando las Probabilidades

Los que hayan jugado a juegos de rol estarán familiarizados con un montón de dados de formas extrañas con diferentes rangos. Por ejemplo, está el dado con forma de tetraedro que tiene 4 caras e incluso un dado de 20 caras con forma de icosaedro. El número de caras de los dados cambia la posibilidad, o probabilidad, de sacar un 1. Cuantas menos caras, más probabilidades hay de sacar un 1 y cuantas más caras, menos probabilidades. Por ejemplo, con un dado de 4 caras, hay una posibilidad entre 4 de sacar un 1 y con un dado de 20 caras hay una posibilidad entre 20. Por suerte, Sonic Pi tiene el práctico fn `one_in` para describir exactamente esto. Vamos a jugar:

    live_loop :different_probabilities do
      sample :drum_snare_hard if one_in(6)
      sleep 0.125
    end

Inicia el bucle en vivo de arriba y escucharás el conocido ritmo aleatorio. Sin embargo, no detengas la ejecución del código. En su lugar, cambia el `6` a un valor diferente como `2` o `20` y pulsa el botón `Run` de nuevo. Observa que los números más bajos significan que el redoblante suena con más frecuencia y los números más altos significan que el redoblante se dispara menos veces. ¡Estás haciendo música con probabilidades!

## Combinando las Probabilidades

Las cosas se ponen interesantes cuando combinas varios samples que se disparan con distintas probabilidades. Por ejemplo:

    live_loop :multi_beat do
      sample :elec_hi_snare if one_in(6)
      sample :drum_cymbal_closed if one_in(2)
      sample :drum_cymbal_pedal if one_in(3)
      sample :bd_haus if one_in(4)
      sleep 0.125
    end

De nuevo, ejecuta el código de arriba y empieza a cambiar las probabilidades para modificar el ritmo. También puedes cambiar los samples para crear una sensación completamente nueva. Por ejemplo, ¡prueba a cambiar `:drum_cymbal_closed` por `:bass_hit_c` si quieres una sobredosis de bajo!

## Ritmos Repetibles

A continuación, podemos utilizar nuestro viejo amigo `use_random_seed` para reiniciar el flujo aleatorio después de 8 iteraciones para crear un ritmo regular. Escribe el siguiente código para escuchar un ritmo mucho más regular y repetitivo. Una vez que escuches el ritmo, intenta cambiar el valor de la semilla de `1000` a otro número. Observa cómo diferentes números generan diferentes ritmos.

    live_loop :multi_beat do
      use_random_seed 1000
      8.times do
        sample :elec_hi_snare if one_in(6)
        sample :drum_cymbal_closed if one_in(2)
        sample :drum_cymbal_pedal if one_in(3)
        sample :bd_haus if one_in(4)
        sleep 0.125
      end
    end

Una cosa que suelo hacer con este tipo de estructura es recordar qué semillas suenan bien y apuntarlas. De esta forma, puedo recrear fácilmente mis ritmos cuando vuelva a practicar la canción, o cuando la toque en un concierto en el futuro.

## Juntándolo todo

Por último, podemos añadir unos bajos aleatorios para darle un buen contenido melódico. Fíjate en que también podemos utilizar nuestro recién descubierto método de secuenciación probabilística tanto en sintetizadores como en samples. Pero no te quedes ahí: ¡ajusta los números y crea tu propia pista con el poder de las probabilidades!

    live_loop :multi_beat do
      use_random_seed 2000
      8.times do
        c = rrand(70, 130)
        n = (scale :e1, :minor_pentatonic).take(3).choose
        synth :tb303, note: n, release: 0.1, cutoff: c if rand < 0.9
        sample :elec_hi_snare if one_in(6)
        sample :drum_cymbal_closed if one_in(2)
        sample :drum_cymbal_pedal if one_in(3)
        sample :bd_haus, amp: 1.5 if one_in(4)
        sleep 0.125
      end
    end

# - Amplitud

Este mes vamos a sumergirnos en uno de los efectos más potentes y flexibles de Sonic Pi: el `:slicer`. Al final de este artículo, habrás aprendido cómo manipular el volumen de nuevas formas muy interesantes. Esto te permitirá crear nuevos ritmos y estructuras rítmicas, ampliando tus posibilidades sonoras.

## Rebana ese Amp

Entonces, ¿qué hace realmente el FX `:slicer`? Una forma de pensar en ello es como si alguien jugara con el control de volumen de tu televisor o equipo de música. Echemos un vistazo, pero primero, escucha el profundo gruñido del siguiente código que activa el sintetizador `:prophet`:

    synth :prophet, note: :e1, release: 8, cutoff: 70
    synth :prophet, note: :e1 + 4, release: 8, cutoff: 80

Ahora, vamos a pasarlo por el efecto `:slicer`:

    with_fx :slicer do
      synth :prophet, note: :e1, release: 8, cutoff: 70
      synth :prophet, note: :e1 + 4, release: 8, cutoff: 80
    end

Escucha cómo el slicer le pone y le quita volumen al audio, con un beat regular. Fíjate también en cómo el `:slicer` afecta a todo el audio generado entre los bloques `do`/`end`. Puedes controlar la velocidad a la que se enciende y apaga el audio con la opción `phase:`, que es una abreviatura de duración de fase (phase duration en inglés). Su valor por defecto es `0.25`, que significa 4 veces por segundo usando el BPM por defecto de 60. Hagámoslo más rápido:

    with_fx :slicer, phase: 0.125 do
      synth :prophet, note: :e1, release: 8, cutoff: 70
      synth :prophet, note: :e1 + 4, release: 8, cutoff: 80
    end

Ahora, juega tú mismo con diferentes duraciones de `phase:`. Prueba con valores más largos y más cortos. Mira lo que ocurre cuando eliges un valor realmente corto. Prueba también con diferentes sintetizadores como `:beep` o `:dsaw` y diferentes notas. Echa un vistazo al siguiente diagrama para ver cómo los diferentes valores de `phase:` cambian el número de cambios de amplitud por compás.

Duración

La duración de fase (phase duration) es la longitud de tiempo para un ciclo de encendido/apagado del volumen. Por tanto, valores más bajos harán al efecto cambiar entre encendido y apagado mucho más rápido que valores más altos. Puedes empezar jugando con valores como `0.125`, `0.25`, `0.5` y `1`.

## Ondas de Control

Por defecto, el efecto `:slicer` utiliza una onda cuadrada para manipular la amplitud a lo largo del tiempo. Por eso escuchamos la amplitud encendida durante un periodo de tiempo, luego inmediatamente apagada por otro periodo, y encendida de nuevo. Podemos ver que la onda cuadrada sólo es una de las 4 ondas de control distintas que permite usar `:slicer`. Las otras son la onda de sierra, la onda triangular la onda de (co)seno. Échale un vistazo al diagrama de arriba para ver qué forma tienen estas ondas. También podemos escuchar cómo suenan. Por ejemplo, el siguiente código utiliza el (co)seno como onda de control. Escucha cómo el sonido no se enciende y apaga de forma abrupta, sino que aparece y desaparece gradualmente:

    with_fx :slicer, phase: 0.5, wave: 3 do
      synth :dsaw, note: :e3, release: 8, cutoff: 120
      synth :dsaw, note: :e2, release: 8, cutoff: 100
    end

Juega con las siguientes formas de onda cambiando la opción `wave:` a `0` para onda de sierra, `1` para onda cuadrada, `2` para onda triangular, y `3` para onda de seno. Prueba también cómo suenan ondas distintas con valores de `phase:` distintos.

Cada una de estas ondas se pueden invertir con la opción `invert_wave:`, que les da la vuelta en torno al eje y. Por ejemplo, en una misma fase, una onda cuadrada suele empezar alto y va bajando gradualmente antes de volver a subir. Con `invert_wave:1`, la onda empieza bajo y va subiendo gradualmente antes de volver a bajar. Además, la onda de control puede empezar en puntos distintos con la opción `phase_offset:`, que debería tener un valor entre `0` y `1`. Jugando con las opciones `phase:`, `wave:`, `invert_wave:` y `phase_offset` puedes cambiar drásticamente cómo se modifica la amplitud a lo largo del tiempo.

Duración

## Configurando tus niveles

Por defecto, `:slicer` cambia entre los valores de amplitud `1` (totalmente alto) y `0` (silenciado). Esto se puede cambiar con las opciones `amp_min:` y `amp_max`. Puedes usarlas con la onda de seno, creando un efecto de tremolo muy sencillo:

    with_fx :slicer, amp_min: 0.25, amp_max: 0.75, wave: 3, phase: 0.25 do
      synth :saw, release: 8
    end

Es como si cogieses la rueda de volumen en tu altavoz y lo movieses arriba y abajo ligeramente, con lo que el sonido ‘tiembla’.

## Probabilidades

Una de las potentes características de `:slicer` es su capacidad de utilizar la probabilidad para elegir si se activa o desactiva el slicer. Antes de que el `:slicer` FX comience una nueva fase, lanza un dado y, en función del resultado, utiliza la onda de control seleccionada o mantiene la amplitud desactivada. Vamos a escucharlo:

    with_fx :slicer, phase: 0.125, probability: 0.6  do
      synth :tb303, note: :e1, cutoff_attack: 8, release: 8
      synth :tb303, note: :e2, cutoff_attack: 4, release: 8
      synth :tb303, note: :e3, cutoff_attack: 2, release: 8
    end

Escucha el interesante ritmo de pulsos que hemos conseguido. Prueba a cambiar la opción `probability:` (probabilidad) a un valor distinto entre `0` y `1`. Valores más cercanos a `0` generarán más espacio entre cada sonido, porque la probabilidad de que el sonido se dispare es mucho menor.

Otra cosa que hay que notar es que el sistema de probabilidad en el FX es igual que el sistema de aleatoriedad accesible a través de fns como `rand` y `shuffle`. Ambos son completamente deterministas. Esto significa que cada vez que pulses Run escucharás exactamente el mismo ritmo de pulsos para una probabilidad determinada. Si quieres cambiar las cosas, puedes usar la opción `seed:` para seleccionar una semilla diferente. Esto funciona exactamente igual que `use_random_seed` pero sólo afecta a ese FX en particular.

Finalmente, puedes probar a cambiar la posición de ‘reposo’ de la onda de control cuando los tests de probabilidad fallen de `0` a cualquier otra posición, con la opción `prob_pos:`:

    with_fx :slicer, phase: 0.125, probability: 0.6, prob_pos: 1  do
      synth :tb303, note: :e1, cutoff_attack: 8, release: 8
      synth :tb303, note: :e2, cutoff_attack: 4, release: 8
      synth :tb303, note: :e3, cutoff_attack: 2, release: 8
    end

## Ritmos que chocan

Algo muy divertido que puedes probar es usar el `:slicer` para cortar un beat de batería:

    with_fx :slicer, phase: 0.125 do
      sample :loop_mika
    end

Esto nos permite coger cualquier sample y crear nuevas posibilidades rítmicas, lo cual es súper divertido. Sin embargo, debes tener cuidado y asegurarte de que el tempo del sample coincida con el BPM actual de Sonic Pi; de lo contrario, el slicing sonará fatal. Por ejemplo, prueba a cambiar el `:loop_mika` con el sample `loop_amen` y escucha cómo de mal puede llegar a sonar cuando los tempos no están alineados.

## ¡Cambiandolo al vuelo!

Como ya hemos visto, cambiar el BPM por defecto con `use_bpm` alarga o comprime los tiempos de silencio y duraciones de envolventes de sintetizadores para que el tempo coincida. El efecto `:slicer` también necesita esto, ya que la opción `phase:` se mide en beats, en vez de segundos. Por tanto, podemos arreglar el problema que tiene `loop_amen` arriba, cambiando el BPM para que coincida con el del sample:

    use_sample_bpm :loop_amen
    with_fx :slicer, phase: 0.125 do
      sample :loop_amen
    end

## Juntándolo todo

Vamos a aplicar todas estas ideas en un ejemplo final que, usando el efecto `:slicer`, crea una combinación muy interesante. Adelante, empieza a cambiarlo y ¡conviértelo en tu propia pieza!

    live_loop :dark_mist do
      co = (line 70, 130, steps: 8).tick
      with_fx :slicer, probability: 0.7, prob_pos: 1 do
        synth :prophet, note: :e1, release: 8, cutoff: co
      end

      with_fx :slicer, phase: [0.125, 0.25].choose do
        sample :guit_em9, rate: 0.5
      end
      sleep 8
    end
    live_loop :crashing_waves do
      with_fx :slicer, wave: 0, phase: 0.25 do
        sample :loop_mika, rate: 0.5
      end
      sleep 16
    end

# - Programación en directo (Live Coding)

El último mes le echamos un vistazo a cinco técnicas importantes para manejar bien el live coding; en otras palabras, exploramos cómo podemos usar Sonic Pi para hacer código, igual que usaríamos un instrumento musical. Uno de los conceptos que mencionamos es el de la práctica. Este mes vamos a sumergirnos en más código, y vamos a entender por qué practicar live coding es importante, y cómo podrías empezar.

## Practica regularmente

El mejor consejo que te puedo dar es que te asegures de practicar de forma regular. Por norma, suelo practicar 1 o 2 horas cada día, pero con 20 minutos es suficiente para empezar. Estamos buscando practicar poquito pero cada día; así que si sólo puedes dedicarle 10 minutos, sigue siendo un buen comienzo.

Consejo de práctica nº 1 - empieza a desarrollar una rutina de práctica. Encuentra un buen momento del día que funcione bien para ti, y practica en ese tiempo tantos días de la semana como puedas. Pronto estarás contando las horas para tu sesión de práctica diaria.

## Aprende Mecanografía Táctil

Si ves tocar a un/a músic@ profesional tocando en directo, probablemente te darás cuenta de varias cosas. En primer lugar, cuando tocan no miran su instrumento. Sus dedos, brazos y su cuerpo entero saben qué teclas pulsar, qué cuerdas rasguear o qué tambores percutir, sin tener que pensarlo mucho. Esto se conoce como “memoria muscular” y, aunque suene como algo que sólo hacen l@s profesionales, es igual que cuando aprendiste a andar o a montar en bicicleta; práctica a través de la repetición. L@s live coders usan su memoria muscular para liberar sus mentes; no tienen que pensar dónde mover sus dedos, así que pueden centrarse en la música. Esto se conoce como touch typing o mecanografía táctil - escribir sin mirar al teclado.

Consejo de práctica nº 2 - aprende mecanografía táctil. Hay muchas apps, páginas web e incluso juegos que te pueden ayudar a conseguirlo. Encuentra uno que te guste, y úsalo de forma regular hasta que puedas programar sin mirar al teclado.

## Programa de pie

El cuerpo de un/a músic@ está acondicionado para tocar su instrumento. Por ejemplo, un/a trompetista necesita soplar fuerte, un/a guitarrista necesita agarrar el mástil con fuerza, y un/a baterista necesita golpear la batería durante largos periodos de tiempo. ¿Y qué hay de corporal en el live coding? Como l@s DJs, l@s live coders suelen tocar de pie; ¡algun@s incluso bailan mientras programan! Si practicas live coding sentad@ en tu mesa y luego tienes que estar de pie cuando llegues al concierto, vas a notar la diferencia, y se te va a hacer difícil y frustrante.

Consejo de práctica nº 3 - ponte de pie mientras practicas. La forma más fácil de hacerlo es usar un escritorio de altura regulable. No obstante, si eres como yo y no tienes uno en casa, hay varios apaños que puedes hacer. Lo que suelo hacer yo es usar una tabla de planchar, que funciona bastante bien. También puedes apilar varias cajas o libros grandes en un escritorio normal, y poner tu teclado encima. Asegúrate también de estirarte cuando antes de empezar a practicar, e intenta moverte (o bailar) un poco durante la sesión. Recuerda, nadie te está mirando, así que diviértete, y te sentirás mucho más natural en el escenario.

## Montando tu práctica

La mayoría de los instrumentos necesitan ser montados y afinados antes de tocar. A no ser que seas una estrella del rock con un autobús lleno de encargad@s de equipo, serás tú quien monte su instrumento antes de cada concierto. El momento de montar el instrumento suele ser estresante, y es fácil que ocurra algún problema. Una forma de suavizar esta situación en los conciertos es que incluyas el proceso de puesta a punto en tus sesiones de práctica.

Consejo de práctica nº 4 - montar tu equipo también forma parte de tu práctica. Por ejemplo, encuentra una caja o una bolsa donde puedas dejar tu Raspberry Pi, tu teclado, etc. Antes de cada sesión de práctica, saca todas las partes, conecta todo, enciende tu Raspberry Pi… así hasta que tengas Sonic Pi encendido y puedas hacer música. Cuando hayas acabado de tocar, tómate tu tiempo para guardar todo en su sitio. Esto te puede llevar algo de tiempo al principio, pero antes de que te des cuenta, serás capaz de montar y desmontar tu equipo muy rápido, sin pensar.

## Experimenta Musicalmente

Una vez hayas montado todo y estés list@ para empezar a tocar, puede que te cueste ver por dónde empezar. Un problema que suele tener la gente es que imaginan qué música quieren hacer pero no saben cómo tocarla, lo que les frustra. ¡Hay gente que no sabe qué música quiere hacer! En primer lugar, no te preocupes; es muy normal y le pasa a cualquier músic@ (incluso si llevan practicando mucho tiempo). Es mucho mejor hacer música que no te gusta exactamente, que no hacer música.

Consejo de práctica nº 5 - dedica parte de tu tiempo a hacer música que no te guste. Tómate tu tiempo para explorar nuevos sonidos e ideas. No te preocupes porque pueda sonar mal si no es el estilo que te gusta. Cuando experimentas de esta forma, ¡aumentas la probabilidad de encontrarte con música que te encante! Aunque el 99% de la música que hagas suene mal, ese 1% restante puede ser el riff o la introducción de tu nueva canción. Olvídate de las partes que no te gusten, y recuerda las que sí te hayan gustado. Cuando haces música con código es todavía más fácil: ¡sólo tienes que darle a Guardar!

## Escucha el Código

Muchos músicos pueden mirar una partitura y escuchar la música en su cabeza sin tener que tocarla. Es una habilidad muy útil y merece la pena incorporarla a tus sesiones de práctica de codificación en directo. Lo importante es ser capaz de entender cómo va a sonar el código. No es necesario que puedas oírlo exactamente en tu cabeza, pero sí es útil saber si el código va a ser rápido, lento, fuerte, rítmico, melódico, aleatorio, etc. El objetivo final es ser capaz de invertir este proceso: ser capaz de escuchar música en tu cabeza y saber qué código escribir para hacerla. Puede que te lleve mucho tiempo dominar esto, pero una vez que lo hagas, serás capaz de improvisar en el escenario y expresar tus ideas con fluidez.

Consejo de práctica nº 5 - escribe código en Sonic Pi, pero no le des todavía a Ejecutar. Intenta imaginarte qué va a sonar con ese código. Cuando lo tengas, dale a Ejecutar, escucha, y piensa en qué acertaste y en qué te equivocaste. Repite este proceso hasta que se convierta en una parte natural de tu proceso creativo. Yo cuando practico suelo tener una idea bastante clara de cómo va a sonar mi código. Sin embargo, hay veces en las que me sorprendo con lo que suena; en ese momento paro y pienso en dónde me he equivocado. Cada vez que pasa esto, aprendo nuevos trucos que me permiten expresarme de nuevas formas.

## Elimina todas las distracciones

Un problema muy común al practicar es distraerte con otras cosas. Practicar es duro y requiere disciplina, da igual el estilo que toques - desde jazz hasta clásica o electrónica. Si te cuesta empezar a tocar o progresar con lo que tienes, es fácil que te pongas a ver las redes sociales, que mires cosas en Internet, etc. Si te has planificado para practicar 20 minutos, es importante que intentes dedicar ese tiempo de forma productiva.

Consejo de práctica nº 7 - antes de empezar a practicar, intenta deshacerte de todas las distracciones que puedas. Por ejemplo, desconéctate de Internet, deja tu móvil en otro cuarto, e intenta practicar en un sitio en silencio, donde no te vayan a molestar. Intenta concentrarte en escribir tu música; siempre puedes a tus distracciones cuando acabes.

## Escribe un diario de práctica

Cuando practiques, tu mente estará llena de ideas nuevas: nuevas direcciones en tu estilo musical, nuevos sonidos que quieres probar, nuevas funciones para escribir, etc. Estas ideas suelen ser tan interesantes que puede que dejes de hacer lo que estés haciendo, para ponerte a trabajar en esas ideas. ¡Esta es otra forma de distracción!

Consejo de práctica nº 8 - escribe un diario de práctica con tu teclado. Cuando tengas una nueva idea, para tu sesión de práctica unos segundos, escribe la idea rápidamente, y olvídate de ella y sigue practicando. Así puedes dedicar tiempo más tarde para pensar en tus ideas, cuando hayas acabado de practicar.

## Juntándolo todo

Intenta establecer una rutina de práctica que incorpore todas las ideas nuevas que puedas. Intenta que las sesiones sean divertidas, pero ten en cuenta que la práctica puede ser dura y requerir bastante trabajo en ocasiones. Sin embargo, todo esto merecerá la pena cuando hayas creado tu primera pieza, o cuando hayas tocado tu primer concierto. Recuerda, ¡la práctica es la clave del éxito!

# - Síntesis Aditiva

Esta es la primera parte de una miniserie de artículos donde veremos cómo usar Sonic Pi para hacer diseño sonoro. Haremos un recorrido por las distintas técnicas que tienes para fabricar tu propio sonido. La primera técnica que vamos a ver se llama síntesis aditiva. Puede sonarte complicado, pero el significado se entiende muy fácil si vemos cada palabra por separado. Primero, aditivo significa combinar cosas; segundo, síntesis significa crear sonido. Por tanto, síntesis aditiva no es más que combinar sonidos que tienes para crear sonidos nuevos. Esta técnica de síntesis se usa desde hace mucho tiempo; por ejemplo, los órganos de la edad media tienen un montón de tubos con sonidos muy variados, que puedes controlar con unas palancas. Si tiras de la palanca de un tubo, lo estás ‘añadiendo a la mezcla’, haciendo el sonido mucho más rico y complejo. Vamos a ver ahora cómo podemos tirar de todas las palancas en Sonic Pi.

## Combinaciones Sencillas

Empecemos con el sonido más sencillo - la humilde y pura onda de seno:

    synth :sine, note: :d3

Ahora, veamos cómo estos sonidos se combinan con una onda cuadrada:

    synth :sine, note: :d3
    synth :square, note: :d3

¿Has visto cómo se han juntado los dos sonidos para formar uno más rico? Y no hay por qué parar ahí; podemos añadir tantos sonidos como queramos. En cualquier caso, hay que tener cuidado con cuántos sonidos juntamos. Cuando mezclamos muchos pigmentos para crear nuevos colores, acabamos con un color marrón muy feo; del mismo modo, mezclar muchos sonidos genera un sonido muy sucio.

## Mezclando

Vamos a añadir algo al sonido que tenemos para hacerlo un poco más brillante. Podríamos usar una onda triangular una octava por encima (para obtener ese sonido brillante), y ponerle sólo `0.4` de amplitud (amp) para que añada al sonido en vez de taparlo:

    synth :sine, note: :d3
    synth :square, note: :d3
    synth :tri, note: :d4, amp: 0.4

Ahora, prueba a crear tus propios sonidos combinando 2 o más sintetizadores, con distintas octavas y amplitudes. Fíjate también en que puedes jugar con las opciones de cada sintetizador para modificar cada fuente de sonido antes de mezclarla con el resto; así puedes conseguir más combinaciones de sonidos.

## Desafinación (detuning)

Hasta ahora, al combinar nuestros sintetizadores, sólo hemos usado la misma altura o hemos cambiado alguno de octava. ¿Cómo sonaría si en vez de restringirnos a octavas, usáramos notas un poco más agudas o un poco más graves? Vamos a probarlo:

    detune = 0.7
    synth :square, note: :e3
    synth :square, note: :e3 + detune

Si desafinamos nuestras ondas cuadradas 0.7 notas, podemos escuchar que suenan ‘mal’. Sin embargo, a medida que nos acercamos a 0, sonará cada vez mejor, ya que la altura de las dos ondas se parece cada vez más. ¡Pruébalo! Cambia el valor del opt `detune:` de `0.7` a `0.5` y escucha el nuevo sonido. Prueba con `0.2`, `0.1`, `0.05`, `0`. Cada vez que cambies el valor, dale a Ejecutar y comprueba cómo cambia el sonido. Fíjate en que los valores bajos de desafinación (detune) como `0.1` producen un sonido ‘grueso’ muy agradable; las alturas de las ondas interactúan de formas muy interesantes, y a menudo sorprendentes.

Algunos de los sintes incorporados ya incluyen una opción de desafinación que hace exactamente esto en un sinte. Prueba a jugar con la opción `detune:` de `:dsaw`, `:dpulse` y `:dtri`.

## Amplitud

También podemos pulir nuestro sonido usando distintas opciones y envolventes (envelope) para el disparador de cada sintetizador. Con esto puedes, por ejemplo, hacer que parte del sonido sea percusiva, y que otra parte resuene durante un rato.

    detune = 0.1
    synth :square, note: :e1, release: 2
    synth :square, note: :e1 + detune, amp: 2, release: 2
    synth :gnoise, release: 2, amp: 1, cutoff: 60
    synth :gnoise, release: 0.5, amp: 1, cutoff: 100
    synth :noise, release: 0.2, amp: 1, cutoff: 90

En el ejemplo de arriba, le he añadido un elemento percusivo y ruidoso al sonido; además, le he puesto un poco de ruido de fondo que dura un rato. Para ello, primero he usado dos sintetizadores de ruido con valores de corte (cutoff) normales (`90` y `100`) y con tiempos para soltar (release) cortos; además, he usado un sintetizador de ruido con un tiempo de release mayor pero con un valor de cutoff bajo (lo que hace al ruido menos brillante y más resonante.)

## Juntándolo todo

Vamos a combinar todas estas técnicas; vamos usar síntesis aditiva para recrear un sonido sencillo de campana. He dividido este ejemplo en cuatro secciones. En primer lugar, tenemos la sección ‘hit’ (golpe), que es la parte inicial del sonido de la campana, así que usa un envolvente corto (por ejemplo, un `release:` alrededor de `0.1`). Después tenemos la parte del timbre largo de la campana, en la que estoy usando el sonido puro de una onda de seno. Fíjate en que suelo aumentar la nota en `12` y `24`, que es el número de notas en una y dos octavas, respectivamente. También le he metido unos cuantos sintetizadores de onda de seno graves, para darle al sonido un poco de bajo y de profundidad. Por último, he usado `define` para guardar mi código en una función que puedo usar para tocar una melodía. ¡Prueba a tocar tu propia melodía, y juega con los contenidos de la función `:bell` hasta que tengas un sonido muy loco que te guste!

    define :bell do |n|
      # Triangle waves for the 'hit'
      synth :tri, note: n - 12, release: 0.1
      synth :tri, note: n + 0.1, release: 0.1
      synth :tri, note: n - 0.1, release: 0.1
      synth :tri, note: n, release: 0.2
      # Sine waves for the 'ringing'
      synth :sine, note: n + 24, release: 2
      synth :sine, note: n + 24.1, release: 2
      synth :sine, note: n + 24.2, release: 0.5
      synth :sine, note: n + 11.8, release: 2
      synth :sine, note: n, release: 2
      # Low sine waves for the bass
      synth :sine, note: n - 11.8, release: 2
      synth :sine, note: n - 12, release: 2
    end
    # Play a melody with our new bell!
    bell :e3
    sleep 1
    bell :c2
    sleep 1
    bell :d3
    sleep 1
    bell :g2

# - Síntesis Sustractiva

Este ese el segundo artículo de la serie, en la que veremos cómo usar Sonic Pi para hacer diseño sonoro. El último mes vimos la síntesis aditiva, y descubrimos que no es más que juntar muchos sonidos a la vez para crear un nuevo sonido combinado. Por ejemplo, podíamos combinar distintos sintetizadores, o incluso el mismo sintetizador con distinta altura, para crear un sonido muy complejo a partir de ingredientes sencillos. Este mes vamos a ver una nueva técnica conocida como síntesis substractiva, que es sencillamente coger un sonido complejo y quitarle partes para crear algo nuevo. Esta técnica está asociada al sonido de los sintetizadores analógicos de los 60 y los 70; también tuvo que ver con el renacimiento de los sintetizadores analógicos modulares, con estándares muy populares como el Eurorack.

Aunque parezca una técnica complicada o avanzada, Sonic Pi lo hace increíblemente fácil y sencillo… así que vamos a ello.

## Señal Fuente Compleja

Para que un sonido quede bien con síntesis sustractiva, debe ser bastante rico e interesante. Esto no significa que necesitemos algo enormemente complejo; de hecho, nos vale con una onda cuadrada (`:square`) o de sierra (`:saw`):

    synth :saw, note: :e2, release: 4

Note que este sonido ya es más interesante y contiene muchas frecuencias diferentes `:e2`(el segundo Mi del piano) que se añade para crear el timbre. Si esto no tiene mucho sentido para usted, intente compararlo con `:beep`:

    synth :beep, note: :e2, release: 4

Como el sintetizador `:beep` es sólo una onda de seno, escucharás un tono mucho más puro, con la nota `:e2` muy clara, y ningún otro ruido que la emborrone (lo que sí escucharías con una onda `:saw`). El zumbido y la variación de la onda pura de seno es lo que nos permite jugar cuando usamos síntesis sustractiva.

## Filtros

Ahora que tenemos nuestra señal fuente en bruto, el siguiente paso es pasarla por un filtro de algún tipo, que modifica el sonido quitando (o reduciendo) partes del mismo. Uno de los filtros de síntesis sustractiva más conocidos es el filtro de paso bajo (low pass filter). Este filtro deja pasar las partes graves del sonido, pero reduce o borra las partes agudas. Sonic Pi tiene un sistema de efectos sencillo y potente, que incluye un filtro de paso bajo llamado `:lpf` (de sus siglas en inglés, low pass filter). Vamos a probarlo:

    with_fx :lpf, cutoff: 100 do
      synth :saw, note: :e2, release: 4
    end

Si te fijas escucharás cómo se ha quitado parte del zumbido del sonido. De hecho, todas las frecuencias del sonido por encima de la nota `100` han sido reducidas o borradas; sólo se han dejado las frecuencias agudas. Prueba a cambiar el valor del `cutoff:` a notas más bajas, por ejemplo `70` y luego `50`; compara los sonidos que producen.

Por supuesto, `:lpf` no es el único filtro que tienes para manipular la señal fuente. Otro efecto importante es el filtro de paso alto, llamado `:hpf` (por sus siglas en inglés, high pass filter) en Sonic Pi. Este hace lo contrario a `:lpf`, ya que deja pasar los agudos y corta los graves.

    with_fx :hpf, cutoff: 90 do
      synth :saw, note: :e2, release: 4
    end

Fíjate en cómo suena mucho más brillante y áspero ahora que has borrado las frecuencias bajas. Experimenta con los valores de cutoff: escucha cómo se dejan pasar cada vez más bajos cuantos más bajos sean los valores del filtro, y cómo los agudos van sonando cada vez más pequeños y callados.

## Low Pass Filter

El filtro de paso bajo es una parte tan importante de todo kit de herramientas de síntesis sustractiva que merece la pena profundizar en su funcionamiento. Este diagrama muestra la misma onda de sonido (el sintetizador `:prophet`) con distintas cantidades de filtrado. En la parte superior, la sección A muestra la onda de audio sin filtro. Fíjate en que la forma de la onda es muy puntiaguda y contiene muchos bordes afilados. Son estos ángulos duros y afilados los que producen las partes altas y crujientes del sonido. La sección B muestra el filtro de paso bajo en acción: observe que es menos puntiagudo y más redondeado que la forma de onda anterior. Esto significa que el sonido tendrá menos frecuencias altas, dándole una sensación más suave y redondeada. La sección C muestra el filtro de paso bajo con un valor de corte bastante bajo, lo que significa que se han eliminado aún más frecuencias altas de la señal, lo que da lugar a una forma de onda aún más suave y redondeada. Por último, observe cómo el tamaño de la forma de onda, que representa la amplitud, disminuye a medida que pasamos de A a C. La síntesis sustractiva funciona eliminando partes de la señal, lo que significa que la amplitud general se reduce a medida que aumenta la cantidad de filtrado que se realiza.

## Modulación del filtro

Hasta ahora sólo hemos producido sonidos estáticos. En otras palabras, el sonido no cambia a lo largo de su duración. Normalmente querrás algo de movimiento en tu sonido para darle más vida a su timbre. Una forma de conseguir esto es con la modulación de filtros (cambiar las opciones del filtro a lo largo del tiempo). Por suerte, Sonic Pi te ofrece herramientas muy potentes para modificar las opciones de un efecto a lo largo del tiempo. Por ejemplo, puedes ponerle un tiempo de deslizamiento a la opción del sintetizador que quieras, siempre y cuando ésta permita modulación; esto le dice a la opción cuánto tarda su valor actual en desplazarse hasta un nuevo valor:

    with_fx :lpf, cutoff: 50 do |fx|
      control fx, cutoff_slide: 3, cutoff: 130
      synth :prophet, note: :e2, sustain: 3.5
    end

Vamos a echarle un vistazo a lo que está pasando. Primero, empezamos un bloque de efecto `:lpf` normal y corriente, con un valor de `cutoff:` de `20` (muy bajo). Sin embargo, la primera línea acaba con un `|fx|` un poco raro al final. Eso es una parte opcional de la sintaxis `with_fx`, que te permite nombrar y controlar el sintetizador del efecto manualmente. La línea 2 hace justo esto, y controla el efecto para cambiar el opt `cutoff_slide:` a 4, y el nuevo `cutoff:` a `130`. Con esto, el efecto empezará a deslizar el valor del `cutoff:` de `50` a `130` a lo largo de 3 beats. Por último, lanzamos un sintetizador con la señal fuente, para que podamos escuchar el efecto del filtro de paso bajo modulado.

## Juntándolo todo

Esto es sólo una pequeña muestra de lo que puedes hacer con filtros. Juega con los distintos efectos de Sonic Pi para ver qué clase de sonidos puedes diseñar. Si tu sonido te parece demasiado estático, recuerda que puedes empezar modulando las opciones para crear más movimiento.

Terminemos diseñando una función que ejecutará un nuevo sonido creado con síntesis sustractiva. Intente descubrir qué es lo que sucede - y para aquellos usuarios avanzados de Sonic Pi- vean si pueden descubrir por qué empaqueté todo en la llamada a `at` (por favor envíen sus respuestas a @samaaron en Twiter).

    define :subt_synth do |note, sus|
      at do
        with_fx :lpf, cutoff: 40, amp: 2 do |fx|
          control fx, cutoff_slide: 6, cutoff: 100
          synth :prophet, note: note, sustain: sus
        end
        with_fx :hpf, cutoff_slide: 0.01 do |fx|
          synth :dsaw, note: note + 12, sustain: sus
          (sus * 8).times do
            control fx, cutoff: rrand(70, 110)
            sleep 0.125
          end
        end
      end
    end
    subt_synth :e1, 8
    sleep 8
    subt_synth :e1 - 4, 8

# - Creative coding in the classroom with Sonic Pi

(Este artículo se publicó en el número 9 de la revista Hello World)

Code is one of the most creative media that humans have created. The initially obscure symbols of parentheses and lambdas are not just deeply rooted in science and mathematics, they are the closest we have managed to get to casting the same kind of magical spells as Gandalf and Harry Potter. I believe that this provides a powerful means of engagement in our learning spaces. Through the magic of code we are able to conjure up individually meaningful stories and learning experiences.

We are surrounded by magical experiences. From the sleight of hand of a stage magician making the ball disappear into thin air, to the wonder of seeing your favourite band perform on a big stage. It is these “wow” moments that inspire us to pick up a magic book and learn the French Drop or to start jamming power chords on an old guitar. How might we create similarly deep and lasting senses of wonder that will motivate people to practice and learn the fundamentals of programming?

## Musical Engines and Notation

The histories of music and computers have been intricately woven together since the inception of computing machines, or “engines” as Charles Babbage’s powerful analytical engine was called. Back in 1842 the Mathematician Ada Lovelace, who worked very closely with Babbage, saw the creative potential of these engines. Whilst these first engines had originally been designed to accurately solve hard maths problems, Ada dreamt about making music with them:

”..the engine might compose elaborate and scientific pieces of music of any degree of complexity or extent.” Ada Lovelace, 1842.

Of course, today in 2019 much of our music, regardless of genre, has either been composed, produced or mastered with a digital computer. Ada’s dream came true. It is even possible to trace the history back even further. If you see coding as the art of writing sequences of special symbols that instruct a computer to do specific things, then musical composition is a very similar practice. In Western music, the symbols are black dots positioned on a stave of lines that tell the musician which notes to play and when. Intriguingly, if we trace the roots of Western music notation back to the Italian Benedictine monk, Guido d’Arezzo, we find that the dots and lines system that modern orchestras use is just one of a number of notation systems he worked on. Some of the others were much closer to what we might now see as code.

En el ámbito de la educación, las experiencias mágicas y significativas con los ordenadores y los lenguajes de programación se vienen explorando desde finales de los años 60. Los pioneros de la educación informática Seymour Papert, Marvin Minsky y Cynthia Solomon exploraron lenguajes sencillos basados en Lisp que movían bolígrafos sobre grandes trozos de papel. Con unos pocos y sencillos comandos era posible programar el ordenador para que hiciera cualquier dibujo. Incluso experimentaron ampliando su lenguaje Logo del dibujo a la música. Papert escribió sobre el aprendizaje a través de la experiencia de la reconstrucción del conocimiento en lugar de su transmisión. Conseguir que la gente jugara directamente con las cosas era una parte importante del trabajo de su grupo.

## Sonic Pi Performances

Jylda y Sam Aaron actúan en la Conferencia Thinking Digital en el Sage Gateshead. Fotografía: TyneSight Photos.

Sonic Pi has been used to perform in a wide range of venues such as school halls, nightclubs, outdoor stages at musical festivals, college chapels and prestigious music venues. For example the amazing Convo project which brought 1000 children together in the Royal Albert Hall to perform an ambitious new composition by composer Charlotte Harding. The piece was written for traditional instruments, choirs, percussion and Sonic Pi code. The pop-artist Jylda also performed with Sonic Pi in the Sage Gateshead for the Thinking Digital Conference, where she created a unique live-coded improvised remix of her song Reeled.

Sonic Pi utilizado como uno de los instrumentos en el ámbito de Convo en el Royal Albert Hall. Foto: Pete Jones.

## Live coding in the classroom

Sonic Pi is a code-based music creation and performance tool that builds on all of these ideas. Unlike the majority of computing education software, it is both simple enough to use for education and also powerful enough for professionals. It has been used to perform in international music festivals, used to compose in a range of styles from classical, EDM and heavy metal, and was even reviewed in the Rolling Stone magazine. It has a diverse community of over 1.5 million live coders with a variety of backgrounds all learning and sharing their ideas and thoughts through the medium of code. It is free to download for Mac, PC and Raspberry Pi and includes a friendly tutorial that assumes you know nothing about either code or music.

Sonic Pi was initially conceived as a response to the UK’s newly released Computing curriculum in 2014. The goal was to find a motivating and fun way to teach the fundamentals of programming. It turns out that there is a lot in common and it’s huge fun to explain sequencing as melody, iteration as rhythm, conditionals as musical variety. I developed the initial designs and first iterations of the platform with Carrie Anne Philbin, who brought a teacher’s perspective to the project. Since then, Sonic Pi has undergone iterative improvements thanks to the feedback gained from observing learners and collaborating directly with educators in the classroom. A core design philosophy was to never add a feature that couldn’t be easily taught to a 10 year old child. This meant that most ideas had to be heavily refined and reworked until they were simple enough. Making things simple whilst keeping them powerful continues to be the hardest part of the project.

In order to provide the magical motivation, Sonic Pi’s design was never limited to a pure focus on education. Ideally there would be famous musicians and performers using Sonic Pi as a standard instrument alongside guitars, drums, vocals, synths, violins, etc. These performers would then act as motivational role models demonstrating the creative potential of code. For this to be possible sufficient focus and effort therefore had to be placed on making it a powerful instrument whilst still keeping it simple enough for 10 year olds to pick up. In addition to educators, I also worked directly with a variety of different artists in classrooms, art galleries, studios and venues in the early stages of Sonic Pi’s development. This provided essential feedback which enabled Sonic Pi to grow and ultimately flourish as a tool for creative expression.

There were a number of exciting and unexpected side effects of this dual focus on education and professional musicians. Many of the features are beneficial to both groups. For example, a lot of effort has been put into making error messages more friendly and useful (rather than being a huge complicated mess of jargon). This turns out to be very useful when you write a bug while performing in front of thousands of people. Additionally, functionality such as playing studio quality audio samples, adding audio effects, providing access to live audio from the microphone all turn out to make the learning experience more fun, rewarding and ultimately meaningful.

The Sonic Pi community continues to grow and share amazing code compositions, lesson plans, musical algorithms, and much more. Much of this happens on our friendly forum in_thread (in-thread.sonic-pi.net) which is home to a very diverse group of people that includes educators, musicians, programmers, artists and makers. It is a real joy to see people learn to use code to express themselves in new ways and for that in turn to inspire others to do the same.

# - Some fun capabilities

From a Computer Science perspective, Sonic Pi provides you with the building blocks to teach you the basics as found in the UK’s curriculum such as sequencing, iteration, conditionals, functions, data structures, algorithms, etc. However, it also builds on a number of important and relevant concepts which have become adopted in mainstream industry such as concurrency, events, pattern matching, distributed computing and determinism - all whilst keeping things simple enough to explain to a 10 year old child.

Empezar es tan sencillo como:

    play 70

A melody can be constructed with one more command, sleep:

    play 72
    sleep 0.5
    play 75
    sleep 0.5
    play 79

In this example, we play the note 70 (roughly the 70th note on a piano), wait for 1 second, play note 72, wait for half a second and then play note 75. What’s interesting here is that with just two commands we have access to pretty much all of Western notation (which notes to play and when) and learners can code any melody they’ve ever heard. This leads to huge variety in expressive outcomes whilst focussing on the same computing concept: sequencing in this case.

Taking ideas from the professional music world, we can also play back any recorded sound. Sonic Pi can play any audio file on your computer but also has a number of sounds built-in to make things easy to get started:

    sample :loop_amen

This code will play back the drum break which was a pillarstone to early hip-hop, Drum and Bass and Jungle. For example, a number of early hip-hop artists played this drum break back at half speed to give it a more laid-back feeling:

    sample :loop_amen, rate: 0.5

In the 90s a number of music scenes burst out of new technology which enabled artists to take drum breaks like this apart and reassemble in a different order. For example:

    live_loop :jungle do
     sample :loop_amen, onset: pick
     sleep 0.125
    end

En este ejemplo introducimos un bucle básico llamado :jungle que elige un golpe de batería aleatorio de nuestra muestra de audio, espera un octavo de segundo y luego elige otro golpe de batería. El resultado es un flujo interminable de golpes de batería aleatorios para bailar mientras experimentas lo que es un bucle.

# - Conocimiento Esencial

Esta sección cubre algo muy útil - de hecho esencial - Conocimiento para sacar el mayor partido a tu experiencia con Sonic Pi.

Cubriremos como sacar provecho de muchos atajos disponibles para tí, como compartir tu trabajo y algunos trucos de ejecución con Sonic Pi.

# 10.1 - Usando atajos

Sonic Pi es tanto un instrumento como un ambiente de código. Los atajos te hacen tocar Sonic Pi de una manera mucho más eficiente y natural. Especialmente si tocas en frente de una audiencia en vivo.

Mucho de Sonic Pi puede ser controlado a través del teclado. Mientras te familiarizas trabajando con Sonic Pi, probablemente usarás más y más atajos. personalmente soy del tipo toca-teclea (lo que recomiendo aprender) y me frustra el tener que ir al ratón, ya que me ralentiza. Por ello es que utilizo estos atajos regularmente.

Por tanto, si te aprendes los atajos, utilizarás tu teclado de manera eficiente y codificarás como un profesional en poco tiempo.

Sin embargo no intentes aprender todo al mismo tiempo, sólo intenta recordar los que más utilizas y continua añadiendo otros a tú práctica.

## Consistencia a través de las plataformas

Imagina que estás aprendiendo el clarinete. Esperarás que todos los clarinetes de cada constructor tenga controles y digitalizaciones similares. Si no fuese así, sería complicado cambiar de clarinetes y tendrías que usar sólo uno.

Desafortunadamente los tres principales sistemas operativos (Linux, Mac OS X y Windows) vienen con acciones como cortar y pegar determinadas. Sonic Pi intentará honrar estos estándares. Sin embargo priorizaremos consistencia a través de las plataformas dentro de Sonic Pi. Esto significa que te sentirás cómodo y en casa ya sea que toques con la Raspberry Pi, Mac o PC.

## Control y Meta

Parte de la noción de consistencia es el nombramiento de los atajos. En Sonic Pi usamos los nombre Control y Meta para referirnos a las dos principales combinaciones de teclas. En todas las plataformas Control es igual. Sin embargo, en Linux y Windows, Meta es la tecla Alt, mientras que en Mac es la tecla Command. Por consistencia, utilizaremos el término Meta - sólo recuerda mapear la tecla apropiada a tu OS.

## Abreviaciones

Para mantener las cosas simples y legibles, utilizaremos la abreviación C- para Control más otra tecla y M- por Meta más otra tecla. Por ejemplo, si un atajo te requiere que mantengas apretadas ambas Meta y r, escribiremos elso, así `M-r`. El - significa que es al mismo tiempo.

Los siguientes son los atajos que encuentro más útiles.

## Para y comenzar

En vez de comenzar tu código conel ratón, puedes simplemente presionar `M-r`. Similarmente puedes pararlo con `M-s`.

## Navegación

Sin los atajos de navegación estaría perdido. Así que recomiendo que los aprendas. Estos atajos funcional fenomenalmente cuando hayas aprendido a tocar y teclear, ya que usan letras estándar, en vez de requerir que vayas al ratón o las flechas del teclado.

Puedes moverte al inicio de una línea con `C-a`, al final de la línea con `C-e`, una línea arriba con `C-p`, abajo con `C-n`, un carácter adelante con `C-f`, y atrás un carácter con `C-b`. puedes borrar todos los caracteres desde el cursor hasta el final de la línea con `C-k`.

## Código legibles

Para auto-alinear el código, simplemete presiona `M-m`.

## Sistema de ayuda

Para aparecer el sistema de ayuda, presiona `M-i`. Sin embargo, un atajo mucho más útil es `C-i` que buscará la palabra debajo del cursor y mostrará los documentos si encuentra algo. ¡Ayuda instantánea!

Para una lista completa, mira la sección 10.2 Tabla de Atajos.

# 10.2 - Tabla de Atajos

Este es un resumen de los atajos principales dentro de Sonic Pi. Te remito a la sección 10.1 para motivación.

## Convenciones

En esta lista, usaremos la siguiente convención (donde Meta es uno de los Alt en Windows/Linux o Cmd en Mac):

- `C-a` mantén presionado Control y presiona a al mismo tiempo, después suelta.
- `M-r` mantén presionado Meta y presiona r al mismo tiempo, después suelta.
- `S-M-z` mantén presionado Shift y presiona la tecla Meta, después la tecla z al mismo tiempo, después suelta.
- `C-M-f` mantén presionado Control, después presiona Meta, finalmente la tecla f, después suelta.

## Manipulación de la aplicación principal

- `M-r` - ejecuta el código
- `M-s` - para el código
- `M-i` - muestra el sistema de Ayuda
- `M-p` - muestra las Preferencias
- `M-{` - Va al buffer de la izquierda
- `M-}` - Va al buffer de la derecha
- `S-M-0` - Switch to buffer 0
- `S-M-1` - Switch to buffer 1
- …
- `S-M-9` - Switch to buffer 9
- `M-+` - Incrementa el tamaño del texto del buffer actual
- `M--` - Decrementa el tamaño del texto del buffer actual

## Seleccionar/Copiar/Pegar

- `M-a` - Selecciona todo
- `M-c` - Copia lo seleccionado al buffer de pegado
- `M-]` - Copia lo seleccionado al buffer de pegado
- `M-x` - Corta lo seleccionado al buffer de pegado
- `C-]` - Corta lo seleccionado al buffer de pegado
- `C-k` - Corta hasta el final de la línea
- `M-v` - Pega del buffer de pegado al editor
- `C-y` - Pega del buffer de pegado al editor
- `C-SPACE` - Establece marca. La navegación manipulará ahora la región resaltada. Usa `C-g` para escapar.

## Manipulación de Texto

- `M-m` - Alinea todo el texto
- `Tab` - Alinea la línea/selección actual (o lista completa)
- `C-l` - Centra el editor
- `M-/` - Comenta la línea actual
- `C-t` - Transpone/cambia caracteres
- `M-u` - Convierte la siguiente palabra (o selección) a mayúscula.
- `M-l` - Convierte la siguiente palabra (o selección) a minúscula.

## Navegación

- `C-a` - Mueve al inicio de la línea
- `C-e` - Mueve al final de la línea
- `C-p` - Mueve a la línea anterior
- `C-n` - Mueve a la línea posterior
- `C-f` - Mueve adelante un caracter
- `C-b` - Mueve atrás un caracter
- `M-f` - Mueve adelante una palabra
- `M-b` - Mueve atrás una palabra
- `C-M-n` - Mueve abajo la línea o selección
- `C-M-p` - Mueve arriba la línea o selección
- `S-M-u` - Mueve arriba 10 líneas
- `S-M-d` - Mueve abajo 10 líneas
- `M-<` - Mueve al inicio del buffer
- `M->` - Mueve al final del buffer

## Borrado

- `C-h` - Borra el caracter previo
- `C-d` - Borra el caracter posterior

## Características avanzadas del Editor

- `C-i` - Muestra documentos para la palabra bajo el cursor
- `M-z` - Deshace
- `S-M-z` - Rehace
- `C-g` - Escapa
- `S-M-f` - Cambia al modo de pantalla completa
- `S-M-b` - Cambia la visibilidad de los botones
- `S-M-l` - Cambia la visibilidad de la bitácora
- `S-M-m` - Cambia entre los modos luminoso/Obscuro de pantalla
- `S-M-s` - Guarda los contenidos del búfer en un archivo
- `S-M-o` - Carga los contenidos de un archivo en el búfer

# 10.3 - Compartiendo

Sonic Pi se trata de compartir y aprender de todos.

Cuando hayas aprendido a codificar música, compartir tus composiciones es tan sencillo como enviar un correo conteniendo tu código. Por favor comparte tu código con los demás, para que ellos puedan aprender de tu trabajo e inclusive utilizar partes del mismo en nuevas obras.

Si tienes dudas de cuál es la mejor manera de compartir tu trabajo con otros, te recomiendo ponerlo en GitHub y tu música en SoundCloud. Así podrás llegar a mayores audiencias.

## Código -> GitHub

GitHub es un sitio para compartir código, utilizado por desarrolladores profesionales y artistas para compartir y colaborar con código. La manera más sencilla de compartir una nueva pieza de código (inclusive de obras no terminadas) es creando un Gist. Un Gist es una manera simple de subir tu código para ser visto por los demás para ver, copiar y compartir.

## Audio -> SoundCloud

Otra manera de compartir es grabando el audio y subiéndolo a SoundCloud. Una vez subido, otros pueden comentar y discutir tu obra.También recomiendo poner un enlace al Gist de tu código en la descripción de la pista.

Para grabar tu trabajo, presiona el botón `Rec` y comenzará inmediatamente. Dale a `Run` para comenzar tu código si no está ya en ejecución. Cuando estes listo con tu grabación, vuelve a presional el parpadeante botón `Rec` y te pedirá un nombre para el archivo, que será guardado como WAV, el cual puede ser editado y convertido a MP3 por muchos programas libres (prueba Audacity, por ejemplo).

## Esperanza

Te invito a compartir tu trabajo y espero realmente que todos nos enseñemos mutuamente nuevos trucos y movimientos con Sonic Pi. Realmente me interesa ver qué es lo que me mostrarás.

# 10.4 - Ejecutando

Uno de los aspectos más excitantes de Sonic Pi es que usa código como un instrumento musical. Lo que significa que escribir código puede ser visto como una nueva manera de ejecutar música.

Que es lo que llamamos Live Coding.

## Muestra tú pantalla

Cuando hagas código en vivo, te recomiendo que muestres tu pantalla a la audiencia. De otra manera es como tocar guitarra escondiendo tus dedos y cuerdas. Cuando practico en casa, uso una Raspberry Pi y un mini proyector en el muro de mi sala. Puedes usar tu TV o uno de los proyectores de tu escuela/trabajo para dar una muestra. ¡Inténtalo que es muy divertido!

## Forma una banda

Don’t just play on your own - form a live coding band! It’s a lot of fun jamming with others. One person could do beats, another ambient background, etc. Use the `live_audio` functionality to combine code with traditional instruments such as a guitar or a microphone.

See what interesting combinations of sounds you can create with code.

## TOPLAP

Live coding no es completamente nuevo - un puñado de gente lleva haciéndolo por años, típicamente utilizando equipo hecho por ellos mismos. Un buen lugar para encontrar otros live coders es TOPLAP.

## Algorave

Otra fuente importante a explorar el mundo de live coding es Algorave. Aqui puedes encontrar todo lo relacionado a música con live codign para nightclubs.