Sonic Pi - en to fr translation catalogue (1608 entries)

en: 1 Welcome to Sonic Pi
fr: 1 Bienvenue dans Sonic Pi

en: Welcome friend :-)
fr: Cher ami, bienvenue :-)

en: Welcome to Sonic Pi. Hopefully you're as excited to get started making your own sounds as I am to show you. It's going to be a really *fun* ride where you'll learn all about music, synthesis, programming, composition, performance and more.
fr: Bienvenue dans Sonic Pi. J'espère que vous êtes aussi enthousiasmé à l'idée de commencer à créer vos propres sons délirants que je le suis. Ce sera un parcours vraiment *amusant* où vous allez tout apprendre de la musique, de la synthèse, de la programmation, de la composition, de l'interprétation et plus encore.

en: But wait, how rude of me! Let me introduce myself - I'm [Sam Aaron](https://twitter.com/samaaron) - the chap that created Sonic Pi. You can find me at [@samaaron](http://twitter.com/samaaron) on Twitter and I'd be more than happy to say hello to you. You might also be interested in finding out more about my [Live Coding Performances](https://youtube.com/samaaron) where I code with Sonic Pi live in front of audiences.
fr: Mais attendez, comme je suis impoli ! Je me présente, je suis [Sam Aaron](http://twitter.com/samaaron), le gars qui a créé Sonic Pi. Vous pouvez me trouver sur Twitter à [@samaaron](http://twitter.com/samaaron) et je serai plus qu'heureux de vous saluer. Vous pourriez aussi être intéressé par mes [performances de « Live Coding »](https://youtube.com/samaaron) où je progamme en direct avec Sonic Pi devant un public.

en: If you have any thoughts, or ideas for improving Sonic Pi - please pass them on - feedback is so helpful. You never know, your idea might be the next big feature!
fr: Si vous avez des observations ou des idées pour améliorer Sonic Pi, faites m'en part s'il vous plaît, les retours sont tellement utiles. On ne sait jamais, votre idée pourrait être la prochaine fonctionnalité importante !

en: This tutorial is divided up into sections grouped by category. Whilst I've written it to have an easy learning progression from start to finish, feel very free just to dip in and out of sections as you see fit. If you feel that there's something missing, do let me know and I'll consider it for a future version.
fr: Ce didacticiel est divisé en sections groupées par catégories. Même si je l'ai écrit pour avoir une progression d'apprentissage facile du début jusqu'à la fin, sentez-vous vraiment libre de plonger dans l'une ou l'autre section comme cela vous convient. Si vous pensez qu'il manque quelque chose, n'hésitez pas à me le faire savoir et j'y penserai pour une prochaine version.

en: Finally, watching others live code is a really great way to learn. I regularly stream live on [https://youtube.com/samaaron](http://youtube.com/samaaron) so please do drop by, say hi and ask me lots of questions :-)
fr: Enfin, regarder d'autres faire du live-coding est une excellente façon d'apprendre, je diffuse régulièrement des lives sur [http://youtube.com/samaaron](http://youtube.com/samaaron), n'hésitez pas à me rendre visite pour un bonjour ou pour me poser des questions :-)

en: OK, let's get started...
fr: OK, démarrons…

en: 1.1 Live Coding
fr: 1.1 Codage en 'live'

en: Live Coding
fr: Programmation interactive (Live Coding)

en: One of the most exciting aspects of Sonic Pi is that it enables you to write and *modify code live* to make music, just like you might perform live with a guitar. This means that given some practice you can take Sonic Pi on stage and gig with it.
fr: Un des aspects les plus passionnants de Sonic Pi est qu'il vous permet d'écrire et de *modifier du code en "live"* pour faire de la musique, comme on peut le faire avec une guitare par exemple. Cela veut dire qu'avec un peu de pratique, vous pourrez jouer avec Sonic Pi sur scène et vous amuser avec.

en: Free your mind
fr: Libérez votre créativité

en: Before we get into the real details of how Sonic Pi works in the rest of this tutorial, I'd like to give you an experience of what it's like to live code. Don't worry if you don't understand much (or any) of this. Just try to hold onto your seats and enjoy...
fr: Avant que vous ne plongiez dans les détails réels du fonctionnement de Sonic Pi dans la suite de ce tutoriel, j'aimerais vous faire vivre l'expérience de à quoi ça ressemble de coder en "live". Ne vous inquiétez pas si vous ne comprenez pas beaucoup ou rien de ceci. Essayez juste de rester assis sur votre siège et de profiter…

en: A live loop
fr: Une boucle live

en: Let's get started, copy the following code into an empty buffer:
fr: Commençons, copiez le code suivant dans un "buffer" libre :

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

en: Now, press the `Run` button and you'll hear a nice fast bass drum beating away. If at any time you wish to stop the sound just hit the `Stop` button. Although don't hit it just yet... Instead, follow these steps:
fr: Maintenant, appuyez sur le bouton `Run` et vous entendrez un joli battement de grosse caisse. Si vous souhaitez arrêter le son à un moment quelconque, pressez simplement le bouton `Stop`. Mais pas tout de suite... suivez ces instructions plutôt :

en: Make sure the bass drum sound is still running
fr: Assurez-vous que le son de la grosse caisse est encore présent

en: Change the `sleep` value from `0.5` to something higher like `1`.
fr: Changez la valeur de `sleep` de `0.5` à quelque chose de plus élevé comme `1`.

en: Press the `Run` button again
fr: Pressez à nouveau le bouton `Run`

en: Notice how the drum speed has changed.
fr: Remarquez le changement de vitesse de la batterie.

en: Finally, *remember this moment*, this is the first time you've live coded with Sonic Pi and it's unlikely to be your last...
fr: Finalement, *rappelez-vous de cet instant*, c'est la première fois que vous avez codé en "live" avec Sonic Pi et ce n'est certainement pas la dernière...

en: Ok, that was simple enough. Let's add something else into the mix. Above `sample :bd_haus` add the line `sample :ambi_choir, rate: 0.3`. Your code should look like this:
fr: Ok, c'était assez simple. Ajoutons quelque chose au mixage. Au dessus de `sample :bd_haus` ajoutez la ligne `sample :ambi_choir, rate: 0.3`. Votre code devrait ressembler à ceci :

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

en: Now, play around. Change the rates - what happens when you use high values, or small values or negative values? See what happens when you change the `rate:` value for the `:ambi_choir` sample just slightly (say to `0.29`). What happens if you choose a really small `sleep` value? See if you can make it go so fast your computer will stop with an error because it can't keep up (if that happens, just choose a bigger `sleep` time and hit `Run` again).
fr: Maintenant, amusez-vous à modifier le code. Changez la valeur du `rate` - Que se passe-t-il lorsque vous utilisez des grandes valeurs , des petites ou même des négatives ? Regardez ce qui se passe quand vous changez légèrement la valeur de `rate:` pour l'échantillon `:ambi_choir` (disons 0.29). Que se passe-t-il lorsque vous choisissez une valeur vraiment petite de `sleep` ? Regardez si vous arrivez à le faire aller tellement vite que votre ordinateur s'arrêtera avec une erreur parce qu'il ne peut plus continuer comme cela (si cela arrive, choisissez juste une durée `sleep` plus grande et pressez `Run` à nouveau).

en: Try commenting one of the `sample` lines out by adding a `#` to the beginning:
fr: Essayez de commenter une des lignes `sample` en ajoutant un `#` au début :

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

en: Notice how it tells the computer to ignore it, so we don't hear it. This is called a comment. In Sonic Pi we can use comments to remove and add things into the mix.
fr: Remarquez comment cela indique à l'ordinateur de l'ignorer, ainsi nous ne l'entendons pas. On appelle ça un commentaire. Dans Sonic Pi, nous pouvons utilisez des commentaires pour enlever ou ajouter des choses au mixage.

en: Finally, let me leave you something fun to play with. Take the code below, and copy it into a spare buffer. Now, don't try to understand it too much other than see that there are two loops - so two things going round at the same time. Now, do what you do best - experiment and play around. Here are some suggestions:
fr: Finalement, je vous laisse avec quelque chose de sympa à jouer. Prenez le code ci-dessous et copiez-le dans un autre "buffer". Maintenant n'essayez pas trop de le comprendre, remarquez juste qu'il y a deux boucles - ainsi deux choses marchent en même temps. Maintenant, faites ce que vous faites le mieux : expérimentez et jouez. Voici quelques suggestions :

en: Try changing the blue `rate:` values to hear the sample sound change.
fr: Essayez de modifier les valeurs en bleu du `rate:` pour entendre comme le son de l'échantillon change.

en: Try changing the `sleep` times and hear that both loops can spin round at different rates.
fr: Essayez de changer les durées de `sleep` et découvrez que les deux boucles peuvent tourner à différentes cadences.

en: Try uncommenting the sample line (remove the `#`) and enjoy the sound of the guitar played backwards.
fr: Essayez de décommenter la ligne "sample" (enlevez le `#`) et appréciez le son de la guitare joué à l'envers.

en: Try changing any of the blue `mix:` values to numbers between `0` (not in the mix) and `1` (fully in the mix).
fr: Essayez de changer une des valeurs en bleu de `mix:` avec des nombres entre `0` (pas dans le mixage) et `1` (entièrement dans le mixage).

en: Remember to press `Run` and you'll hear the change next time the loop goes round. If you end up in a pickle, don't worry - hit `Stop`, delete the code in the buffer and paste a fresh copy in and you're ready to jam again. Making mistakes is how you'll learn the quickest...
fr: Rappelez-vous de presser `Run` et vous entendrez le changement la fois suivante où la boucle tournera. Si vous êtes dans le pétrin, ne vous inquiétez pas : pressez `Stop`, effacez le code dans le "buffer", collez une copie originale et vous serez prêt à improviser à nouveau. C'est en faisant des fautes que vous apprendrez le plus vite...

en: 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
fr: 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

en: Now, keep playing and experimenting until your curiosity about how this all actually works kicks in and you start wondering what else you can do with this. You're now ready to read the rest of the tutorial.
fr: Maintenant, continuez à jouer et à expérimenter jusqu'à ce que votre curiosité s'avive réellement et vous commencerez à vous demander ce que vous pouvez faire d'autre. Vous êtes maintenant prêt à lire le reste du tutoriel.

en: So what are you waiting for...
fr: Alors, qu'attendez-vous...

en: 1.2 Exploring the Interface
fr: 1.2 Découverte de l'interface

en: The Sonic Pi Interface
fr: L'Interface de Sonic Pi

en: Sonic Pi has a very simple interface for coding music. Let's spend a little time exploring it.
fr: Sonic Pi a une interface très simple pour coder de la musique. Passons un peu de temps à l'explorer.

en: ![Sonic Pi Interface](../../../etc/doc/images/tutorial/GUI.png)
fr: ![Interface de Sonic Pi](../../../etc/doc/images/tutorial/GUI.png)

en: *A* - Play Controls
fr: *A* - Contrôles de jeu

en: *B* - Editor Controls
fr: *B* - Contrôles d'édition

en: *C* - Info and Help
fr: *C* - Info et aide

en: *D* - Code Editor
fr: *D* - Éditeur de code

en: *E* - Prefs Panel
fr: *E* - Panneau des préférences

en: *F* - Log Viewer
fr: *F* - Visualisateur de la trace

en: *G* - Help System
fr: *G* - Système d'aide

en: *H* - Scope Viewer
fr: *H* - Visualisateur de la portée

en: *I* - Cue Viewer
fr: *F* - Visualiseur des Signaux (Cue)

en: A. Play Controls
fr: A. Contrôles de jeu

en: These pink buttons are the main controls for starting and stopping sounds. There's the *Run* button for running the code in the editor, *Stop* for stopping all running code, *Save* for saving the code to an external file and *Record* to create a recording (a WAV file) of the sound playing.
fr: Ces boutons roses sont les principaux contrôles pour démarrer et arrêter les sons. Il y a le bouton *Run* pour exécuter le code présent dans l'éditeur, *Stop* pour arrêter tous les codes en cours d'exécution, *Save* pour sauvegarder le code dans un fichier externe et *Record* pour créer un enregistrement du son (un fichier WAV) en cours de jeu.

en: B. Editor Controls
fr: B. Contrôles d'édition

en: These orange buttons allow you to manipulate the code editor. The *Size +* and *Size -* buttons allow you to make the text bigger and smaller.
fr: Ces boutons orange vous permettent de manipuler l'éditeur de code. Les boutons *Taille +* et *Taille -* vous permettent de rendre le texte plus grand et plus petit.

en: C. Info and Help
fr: C. Info et Aide

en: These blue buttons give you access to information, help and preferences. The *Info* button will open up the information window which contains information about Sonic Pi itself - the core team, history, contributors and community. The *Help* button toggles the help system (*G*) and the *Prefs* button toggles the preferences window which allows you to control some basic system parameters.
fr: Ces boutons bleus vous donnent accès à l'information, à l'aide et aux préférences. Le bouton *Info* ouvre la fenêtre d'information qui contient de l'information sur Sonic Pi lui-même - le noyau de l'équipe, l'historique, les contributeurs, et la communauté. Le bouton *Aide* active le système d'aide (*G*) et le bouton *Prefs* active la fenêtre des préférences qui vous permet de contrôler quelques paramètres systèmes basiques.

en: D. Code Editor
fr: D. Éditeur de code

en: This is the area where you'll write your code and compose/perform music. It's a simple text editor where you can write code, delete it, cut and paste, etc. Think of it like a very basic version of Word or Google Docs. The editor will automatically colour words based on their meaning in the code. This may seem strange at first, but you'll soon find it very useful. For example, you'll know something is a number because it is blue.
fr: C'est la zone dans laquelle vous écrirez votre code et composerez / interpréterez de la musique. C'est un simple éditeur de texte où vous pourrez écrire votre code, l'effacer, couper et coller, etc. Voyez-le comme une version très basique de Word ou de Google Docs. L'éditeur coloriera automatiquement les mots selon leur signification dans le code. Ceci peut paraître étrange au début, mais vous trouverez vite cela très utile. Par exemple, vous saurez que quelque chose est un nombre parce qu'il sera bleu.

en: E. Prefs Panel
fr: E. Panneau des préférences

en: Sonic Pi supports a number of tweakable preferences which can be accessed by toggling the *prefs* button in the Info and Help button set. This will toggle the visibility of the Prefs Panel which includes a number of options to be changed. Examples are forcing mono mode, inverting stereo, toggling log output verbosity and also a volume slider and audio selector on the Raspberry Pi.
fr: Sonic Pi supporte quelques préférences ajustables auxquelles on peut accéder en pressant le bouton *Prefs* à droite des boutons Info et Help. Cela activera l'affichage du panneau des préférences qui inclut un nombre d'options modifiables. Par exemple pour forcer le mode mono, inverser la stéréo, activer le mode verbeux de la trace et aussi régler un curseur de volume et le sélecteur audio du Raspberry Pi.

en: F. Log Viewer
fr: F. Visualisateur de la trace

en: When you run your code, information about what the program is doing will be displayed in the log viewer. By default, you'll see a message for every sound you create with the exact time the sound was triggered. This is very useful for debugging your code and understanding what your code is doing.
fr: Quand vous exécutez votre code, l'information sur ce que le programme est en train de faire est affichée dans le visualiseur de la trace. Par défaut, vous verrez un message pour chaque son que vous créez avec l'heure exacte à laquelle le son a été déclenché. C'est très utile pour déboguer votre code et comprendre ce qu'il fait.

en: G. Help System
fr: G. Système d'aide

en: One of the most important parts of the Sonic Pi interface is the help system which appears at the bottom of the window. This can be toggled on and off by clicking on the blue *Help* button. The help system contains help and information about all aspects of Sonic Pi including this tutorial, a list of available synths, samples, examples, FX and a full list of all the functions Sonic Pi provides for coding music.
fr: Enfin, un des aspects les plus importants de l'interface de Sonic Pi est le système d'aide qui apparaît au bas de la fenêtre. Il peut être activé ou désactivé en cliquant sur le bouton *Help* bleu. Le système d'aide contient de l'aide et de l'information sur tous les aspects de Sonic Pi, y compris ce tutoriel, une liste des synthétiseurs, des échantillons ("samples"), des exemples, des effets ("FX") disponibles, et une liste complète de toutes les fonctions que Sonic Pi fournit pour coder de la musique.

en: H. Scope Viewer
fr: H. Visualiseur de la portée

en: The scope viewer allows you to see the sound you're hearing. You can easily see that the saw wave looks like a saw and that the basic beep is a curvey sine wave. You can also see the difference between loud and quiet sounds by the size of the lines. There are 3 scopes to play with - the default is a combined scope for the left and right channels, there is a stereo scope which draws a separate scope for each channel. Finally there is a Lissajous curve scope which will show the phase relationship between the left and right channels and allows you to draw pretty pictures with sound (https://en.wikipedia.org/wiki/Lissajous_curve).
fr: Le visualiseur d'oscillo vous permet de voir le son que vous entendez. Vous pouvez facilement voir que l'onde en dent de scie ressemble à une scie et que le bip basique est une onde sinusoïdale courbe. Vous pouvez voir aussi la différence entre les sons forts et légers à la taille des lignes. Il y a 3 oscilloscopes avec lesquels jouer - celui par défaut est un oscilloscope combiné pour les canaux gauche et droit, il y a un oscilloscope stéréo qui affiche un graphique différent pour chaque canal. Enfin, il y a l'oscilloscope Lissajous qui montre la relation de phase entre les canaux gauche et droit et vous permet de faire de jolis dessins avec du son (https://en.wikipedia.org/wiki/Lissajous_curve).

en: I. Cue Viewer
fr: I. Visualiseur de signal (cue)

en: All internal and external events (called cues in Sonic Pi) are automatically logged in the Cue Viewer. For example, if you have a MIDI controller connected and press one of its buttons, you'll see a new cue event in the Cue Viewer telling you the name of the controller and which button you pressed. Once you've mastered the basics of making and producing sounds, you'll start to want to cue sounds or whole sections of sounds based on events such as these. A cue event is just an indication that something happened. For example, every time a live loop spins round, it sends a cue event out which is logged in the Cue Viewer. Also, external events such as MIDI messages from connected MIDI equipment and OSC messages from other programs or computers are also displayed in the Cue Viewer. It is also possible to directly generate cue events using the `cue` function. Anything that appears in the Cue Viewer can be used to trigger something happening. This is covered in more detail in Sections 10 to 12 of this tutorial.
fr: Tous les événements internes et externes (appelés cues dans Sonic Pi) sont automatiquement enregistrés dans le Cue Viewer. Par exemple, si vous avez un contrôleur MIDI connecté et que vous appuyez sur l'un de ses boutons, vous verrez un nouvel événement dans le Cue Viewer vous indiquant le nom du contrôleur et le bouton sur lequel vous avez appuyé. Une fois que vous aurez maîtrisé les bases de la création et de la production de sons, vous commencerez à vouloir marquer des sons ou des sections entières de sons en fonction d'événements tels que ceux-ci. Un signal sonore n'est qu'une indication que quelque chose s'est produit. Par exemple, chaque fois qu'une boucle en direct tourne, elle envoie un signal qui est enregistré dans le Cue Viewer. De plus, des événements externes tels que des messages MIDI provenant d'un équipement MIDI connecté et des messages OSC provenant d'autres programmes ou ordinateurs sont également affichés dans le Cue Viewer. Il est également possible de générer directement des événements de cue en utilisant la fonction "rescue". Tout ce qui apparaît dans le Cue Viewer peut être utilisé pour déclencher un événement. Ce point est traité plus en détail dans les sections 10 à 12 de ce tutoriel.

en: 1.3 Learning through Play
fr: 1.3 Apprendre en jouant

en: Learning through Play
fr: Apprendre en jouant

en: Sonic Pi encourages you to learn about both computing and music through play and experimentation. The most important thing is that you're having fun, and before you know it you'll have accidentally learned how to code, compose and perform.
fr: Sonic Pi vous encourage à en apprendre à la fois sur la programmation et sur la musique au travers du jeu et de l'expérimentation. La plus importante chose est que vous vous amusiez, et avant que vous vous en rendiez compte, vous aurez appris comment coder, composer et interpréter sans le faire exprès.

en: There are no mistakes
fr: Il n'y a pas de fautes

en: Whilst we're on this subject, let me just give you one piece of advice I've learned over my years of live coding with music - *there are no mistakes, only opportunities*. This is something I've often heard in relation to jazz but it works equally well with live coding. No matter how experienced you are - from a complete beginner to a seasoned live coder, you'll run some code that has a completely unexpected outcome. It might sound insanely cool - in which case run with it. However, it might sound totally jarring and out of place. It doesn't matter that it happened - what matters is what you do next with it. Take the sound, manipulate it and morph it into something awesome. The crowd will go *wild*.
fr: Alors que nous abordons ce sujet, laissez-moi vous donner un petit conseil que j'ai appris pendant des années à coder de la musique en "live" : *il n'y a pas de fautes, seulement des opportunités*. C'est ce que j'ai souvent entendu à propos du jazz mais cela fonctionne aussi avec le codage en "live". Peu importe votre niveau d'expérience - du débutant complet jusqu'à "l'algoraver" (codeur de musique) chevronné, vous exécuterez un jour un code qui aura un résultat totalement inattendu. Cela pourrait sonner extrêmement "cool" : auquel cas continuez avec. Toutefois, cela pourrait aussi sonner discordant et à côté de la plaque. Peu importe ce qui se passe - ce qui importe est ce que vous allez faire avec ensuite. Prenez le son, manipulez-le et transformez-le en quelque chose de génial. Le public deviendra *déchaîné*.

en: Start Simple
fr: Commencez simple

en: When you're learning, it's tempting to want to do amazing things *now*. However, just hold that thought and see it as a distant goal to reach *later*. For now, instead think of the *simplest* thing you could write which would be fun and rewarding that's a small step towards the amazing thing you have in your head. Once you have an idea about that simple step, then try and build it, play with it and then see what new ideas it gives you. Before long you'll be too busy having fun and making real progress.
fr: Quand vous apprenez, il est tentant de vouloir faire des choses géniales *immédiatement*. Cependant, conservez cette idée et voyez-la comme un but distant à atteindre *plus tard*. Pour l'instant, pensez à la chose la plus simple que vous pourriez écrire qui serait amusante et gratifiante, c'est un petit pas vers la chose géniale que vous avez en tête. Une fois que vous avez une idée pour cette étape simple, essayez de la construire, jouez avec et voyez quelles nouvelles idées cela vous donne. Sous peu, vous serez trop occupé à vous amuser et à faire de réels progrès.

en: Just make sure to share your work with others!
fr: Assurez-vous simplement de partager votre travail avec les autres !

en: 2 Synths
fr: 2 Synthés

en: Synths
fr: Synthétiseurs

en: OK, enough of the intros - let's get into some sound.
fr: OK, assez d'introduction, plongeons dans les sons.

en: In this section we'll cover the basics of triggering and manipulating synths. Synth is short for synthesiser which is a fancy word for something which creates sounds. Typically synths are quite complicated to use - especially analog synths such as Eurorack modules connected together by a mess of wires. However, Sonic Pi gives you much of that power in a very simple and approachable manner.
fr: Dans cette section, nous allons couvrir les bases du déclenchement et de la manipulation des synthés. "Synthé" est l'abréviation de synthétiseur, qui est un mot savant pour quelque chose qui crée des sons. Typiquement, les synthétiseurs sont assez compliqués à utiliser - particulièrement les synthés analogiques comme les modules Eurorack qui sont connectés ensemble par un fouilli de fils. Toutefois, Sonic Pi vous offre beaucoup de cette puissance d'une manière très simple et abordable.

en: Don't be fooled by the immediate simplicity of Sonic Pi's interface. You can get very deep into very sophisticated sound manipulation if that's your thing. Hold on to your hats...
fr: Ne soyez pas dupé par la simplicité apparente de l'interface de Sonic Pi. Vous pouvez aller très en profondeur dans une manipulation très sophistiquée des sons si c'est votre dada. Tenez bien vos chapeaux...

en: 2.1 Your First Beeps
fr: 2.1 Vos premiers Beeps

en: Your First Beeps
fr: Vos premiers Beeps

en: Take a look at the following code:
fr: Jetez un œil sur le code suivant :

en: This is where it all starts. Go ahead, copy and paste it into the code window at the top of the app (the big white space under the Run button). Now, press Run...
fr: C'est là que tout commence. Allez de l'avant, copiez et collez-le dans la fenêtre de code en haut de l'application (le grand espace blanc en dessous du bouton Exécuter). Maintenant, pressez Exécuter...

en: Beep!
fr: Beep !

en: Intense. Press it again. And again. *And again...*
fr: Intense. Appuyez encore une fois. Et encore. *Et encore...*

en: Woah, fun! I'm sure you could keep doing that all day. But wait, before you lose yourself in an infinite stream of beeps, try changing the number:
fr: Waouh, c'est fou ! Je suis sûr que vous pourriez continuer à faire cela toute la journée. Mais attendez, avant que vous ne vous perdiez dans un flot infini de bips, essayez de changer le nombre :

en: Can you hear the difference? Try a lower number:
fr: Entendez-vous la différence ? Essayez un nombre plus petit :

en: So, lower numbers make lower pitched beeps and higher numbers make higher pitched beeps. Just like on a piano, the keys at the lower part of the piano (the left hand side) play lower notes and the keys on the higher part of the piano (the right hand side) play higher notes.
fr: Ainsi, les petits nombres font des bips plus graves et les nombres les plus élevés font des bips plus aigus. Tout comme sur un piano, les touches de la partie inférieure du piano (côté gauche) jouent les notes graves et les touches de la partie supérieure du piano (côté droit) jouent les notes aiguës.

en: It turns out that the C of the 4th octave (C in English notation) is identified by the number 60. `play 60` therefore plays the C of the 4th octave. To play the next piano key to the right, you have to add 1 to 60 and then type `play 61`, which in this case is the black key of the C sharp. To play the D, the next key to the right, `play 62`.
fr: Il s'avère que le Do de la quatrième octave (C en notation anglaise) est identifié par le nombre 60. `play 60` joue donc le Do de la 4ème octave. Pour jouer la touche suivante vers la droite sur un piano, vous devez ajouter 1 à 60 et donc tapez `play 61`, qui correspond alors à la touche noire du Do dièse. Pour jouer le Ré, la prochaine touche à droite, on ajoute 1 donc `play 62`.

en: *Don't worry* if this means nothing to you - it didn't to me when I first started. All that matters right now is that you know that *low numbers make lower beeps* and *high numbers make higher beeps*.
fr: *Ne vous inquiétez pas* si cela ne signifie rien pour vous - c'était le cas pour moi au début quand j'ai commencé. Tout ce qui importe pour le moment est que vous sachiez que *les petits nombres font des beeps graves* et que *les grands nombres font des beeps aigus*.

en: Chords
fr: Accords

en: Playing a note is quite fun, but playing many at the same time can be even better. Try it:
fr: Jouer une note est assez plaisant, mais en jouer plusieurs en même temps est encore mieux. Essayez-le :

en: Jazzy! So, when you write multiple `play`s, they all play at the same time. Try it for yourself - which numbers sound good together? Which sound terrible? Experiment, explore and find out for yourself.
fr: Jazzy ! Ainsi quand vous écrivez plusieurs `play`s, ils sont tous joués en même temps. Essayez-le vous-même : quels sont les nombres qui sonnent bien ensemble ? Lesquels sonnent terrible ? Expérimentez, explorez et trouvez ce qui sonne bien pour vous.

en: Melody
fr: Mélodie

en: So, playing notes and chords is fun - but how about a melody? What if you wanted to play one note after another and not at the same time? Well, that's easy, you just need to `sleep` between the notes:
fr: Ainsi, jouer des notes et des accords est plaisant - mais comment jouer une mélodie ? Que faire si vous voulez jouer une note après une autre et pas en même temps ? Eh bien, c'est facile, vous avez juste besoin de `sleep` entre les notes :

en: How lovely, a little arpeggio. So what does the `1` mean in `sleep 1`? Well it means the *duration of the sleep*. It actually means sleep for one beat, but for now we can think about it as sleeping for 1 second. So, what if we wanted to make our arpeggio a little faster? Well, we need to use shorter sleep values. What about a half i.e. `0.5`:
fr: Comme c'est charmant, un petit arpège. Alors que signifie le `1` dans `sleep 1` ? Eh bien, cela représente la *durée du sleep*. Ça signifie réellement "dors pendant un temps musical", mais pour l'instant nous pouvons penser qu'il s'agit de dormir pendant 1 seconde. Alors que faire si nous voulons que notre arpège soit un peu plus rapide ? Eh bien, nous devons utiliser des valeurs de sleep plus petites. Pourquoi pas la moitié, c'est-à-dire `0.5` :

en: Notice how it plays faster. Now, try for yourself, change the times - use different times and notes.
fr: Remarquez comment ça joue plus rapidement. Maintenant, essayez vous-même, changez les durées - utilisez différentes durées et différentes notes.

en: One thing to try is in-between notes such as `play 52.3` and `play 52.63`. There's absolutely no need to stick to standard whole notes. Play around and have fun.
fr: Une chose à essayer est les notes intermédiaires comme `play 52.3` et `play 52.63`. Il n'est absolument pas nécessaire de coller aux notes standardisées. Jouez et faites-vous plaisir.

en: Traditional Note Names
fr: Les noms classiques des notes

en: For those of you that already know some musical notation (don't worry if you don't - you don't need it to have fun) you might want to write a melody using note names such as C and F# rather than numbers. Sonic Pi has you covered. You can do the following:
fr: Ceux qui connaissent déjà la notation musicale (ne vous inquiétez pas si ce n'est pas votre cas : vous n'en n'avez pas besoin pour vous amuser) pourraient aimer écrire une mélodie en utilisant les noms des notes comme "Do" ou "Fa#" plutôt que des nombres. Sonic Pi a ce qu'il faut, mais en notation anglaise (`A` pour "La", `B` pour "Si", `C` pour "Do", `D` pour "Ré", `E` pour "Mi", `F` pour "Fa", `G` pour "Sol"). Vous pouvez faire la chose suivante :

en: play :C
    sleep 0.5
    play :D
    sleep 0.5
    play :E
fr: play :C
    sleep 0.5
    play :D
    sleep 0.5
    play :E

en: Remember to put the colon `:` in front of your note name so that it goes pink. Also, you can specify the octave by adding a number after the note name:
fr: Notez de mettre des deux-points `:` devant votre nom de note de manière qu'elle apparaisse en rose. Vous pouvez également spécifier l'octave en ajoutant un nombre derrière le nom de la note :

en: play :C3
    sleep 0.5
    play :D3
    sleep 0.5
    play :E4
fr: play :C3
    sleep 0.5
    play :D3
    sleep 0.5
    play :E4

en: If you want to make a note sharp, add an `s` after the note name such as `play :Fs3` and if you want to make a note flat, add a `b` such as `play :Eb3`.
fr: Si vous voulez jouer un dièse, ajoutez un `s` (pour "sharp") derrière le nom de la note, comme `play :Fs3` et si vous voulez jouer un bémol, ajoutez un `b` (pour bemol) comme `play :Eb3`.

en: There's also a handy shortcut for a rest (a musical way of saying not to play anything instead of a note) using `:r`, `:rest` or `nil`.
fr: Il y a aussi un raccourci pratique pour un repos (une façon musicale de dire de ne rien jouer à la place d'une note) en utilisant `:r`, `:rest` ou `nil`.

en: Now go *wild* and have fun making your own tunes.
fr: Maintenant *défoulez-vous* et faites-vous plaisir en faisant vos propres morceaux.

en: 2.2 Synth Options
fr: 2.2 Paramètres des synthés

en: Synth Options: Amp and Pan
fr: Paramètres des synthés : Amp et Pan

en: As well as allowing you to control which note to play or which sample to trigger, Sonic Pi provides a whole range of options to craft and control the sounds. We'll be covering many of these in this tutorial and there's extensive documentation for each in the help system. However, for now we'll introduce two of the most useful: *amplitude* and *pan*. First, let's look at what options actually are.
fr: De la même manière qu'il vous permet de contrôler chaque note ou chaque échantillon à jouer, Sonic Pi fournit un large éventail d'options pour confectionner ou contrôler les sons. Nous couvrirons beaucoup d'entre eux dans ce tutoriel et il y a une documentation exhaustive pour chacun d'eux dans le système d'aide. Toutefois pour l'instant, nous allons introduire deux des plus utiles : *amplitude* et *pan*. Regardons en premier ce que les options sont réellement.

en: Sonic Pi supports the notion of options (or opts for short) for its synths. Opts are controls you pass to `play` which modify and control aspects of the sound you hear. Each synth has its own set of opts for finely tuning its sound. However, there are common sets of opts shared by many sounds such as `amp:` and envelope opts (covered in another section).
fr: Sonic Pi supporte la notion d'options pour ses synthés. Les options sont des informations de contrôle que vous indiquez à `play` et qui modifient et contrôlent les aspects du son que vous entendez. Chaque synthé a son propre jeu d'options pour ajuster finement ses sons. Cependant, il y a un ensemble commun d'options partagé par beaucoup de sons comme `amp:` et les options d'enveloppe (couvertes dans une autre section).

en: Opts have two major parts, their name (the name of the control) and their value (the value you want to set the control at). For example, you might have an opt called `cheese:` and want to set it with a value of `1`.
fr: Les options ont deux parties principales, leur nom (le nom du contrôle) et leur valeur (la valeur que vous voulez affecter au contrôle). Par exemple, vous pourriez avoir une option appelée `cheese:` et vouloir lui affecter la valeur `1`.

en: Opts are passed to calls to `play` by using a comma `,` and then the name of the opt such as `amp:` (don't forget the colon `:`) and then a space and the value of the opt. For example:
fr: Les options sont passées aux appels à `play` en utilisant une virgule `,` et ensuite le nom de l'option comme `amp:` (n'oubliez pas les deux-points `:`) et ensuite un espace et la valeur de l'option. Par exemple :

en: (Note that `cheese:` isn't a valid opt, we're just using it as an example).
fr: (Notez que `cheese:` n'est pas une option valide, elle est juste utilisée pour l'exemple).

en: You can pass multiple opts by separating them with a comma:
fr: Vous pouvez passer plusieurs options en les séparant par une virgule :

en: The order of the opts doesn't matter, so the following is identical:
fr: L'ordre des options n'est pas imposé, ainsi, ce qui suit est identique :

en: Opts that aren't recognised by the synth are just ignored (like `cheese` and `beans` which are clearly ridiculous opt names!)
fr: Les options qui ne sont pas reconnues par le synthé sont simplement ignorées (comme `cheese` et `beans` qui sont clairement des noms de paramètres ridicules !)

en: If you accidentally use the same opt twice with different values, the last one wins. For example, `beans:` here will have the value 2 rather than 0.5:
fr: Si vous utilisez accidentellement 2 fois la même option avec des valeurs différentes, la dernière gagne. Par exemple, `beans:` aura ici la valeur 2 plutôt que 0.5 :

en: Many things in Sonic Pi accept opts, so just spend a little time learning how to use them and you'll be set! Let's play with our first opt: `amp:`.
fr: Beaucoup de choses dans Sonic Pi acceptent des options, aussi passez un peu de temps à apprendre comment les utiliser et vous serez au point ! Jouons avec notre première option : `amp:`.

en: Amplitude is a computer representation of the loudness of a sound. A *high amplitude produces a loud sound* and a *low amplitude produces a quiet sound*. Just as Sonic Pi uses numbers to represent time and notes, it uses numbers to represent amplitude. An amplitude of 0 is silent (you'll hear nothing) whereas an amplitude of 1 is normal volume. You can even crank up the amplitude higher to 2, 10, 100. However, you should note that when the overall amplitude of all the sounds gets too high, Sonic Pi uses what's called a compressor to squash them all to make sure things aren't too loud for your ears. This can often make the sound muddy and strange. So try to use low amplitudes, i.e. in the range 0 to 0.5 to avoid compression.
fr: L'amplitude est la représentation informatique du volume d'un son. Une *amplitude élevée produit un son fort* et une *amplitude basse produit un son faible*. A la manière dont Sonic Pi utilise des nombres pour représenter les durées et les notes, des nombres sont aussi utilisés pour représenter l'amplitude. Une amplitude 0 est le silence (vous n'entendez rien) tandis qu'une amplitude de 1 désigne le volume normal. Vous pouvez même monter l'amplitude à 2, 10, 100. Toutefois, vous devez noter que lorsque l'amplitude globale de tous les sons devient trop élevée, Sonic Pi utilise ce qui est appelé un compresseur pour l'aplatir, de manière à s'assurer que le volume ne soit pas trop fort pour vos oreilles. Cela peut fréquemment rendre le son distordu et étrange. Aussi essayez d'utiliser des amplitudes basses, c'est-à-dire dans l'intervalle 0 à 0.5 pour éviter la compression.

en: Amp it up
fr: Amp-ez le

en: To change the amplitude of a sound, you can use the `amp:` opt. For example, to play at half amplitude pass 0.5:
fr: Pour changer l'amplitude d'un son, vous pouvez utiliser l'option `amp:`. Par exemple, pour jouer à amplitude moitié, passez 0.5 :

en: To play at double amplitude pass 2:
fr: Pour doubler l'amplitude, passez 2 :

en: The `amp:` opt only modifies the call to `play` it's associated with. So, in this example, the first call to play is at half volume and the second is back to the default (1):
fr: L'option `amp:` ne modifie que l'appel au `play` auquel il est associé. Aussi, dans l'exemple suivant, le premier appel à play est à moitié volume et le second revient à la valeur par défaut (1) :

en: Of course, you can use different `amp:` values for each call to play:
fr: Bien entendu, vous pouvez utiliser différentes valeurs de `amp:` pour chaque appel à play :

en: Panning
fr: Balance stéréo

en: Another fun opt to use is `pan:` which controls the panning of a sound in stereo. Panning a sound to the left means that you hear it out of the left speaker, and panning it to the right means you hear it out of your right speaker. For our values, we use a -1 to represent fully left, 0 to represent center and 1 to represent fully right in the stereo field. Of course, we're free to use any value between -1 and 1 to control the exact positioning of our sound.
fr: Une autre option agréable à utiliser est `pan:` qui contrôle la balance du son en stéréo. Balancer un son vers la gauche signifie que votre oreille va l'entendre sortir du haut-parleur de gauche, et le balancer vers la droite que vous l'entendrez sortir par le haut-parleur de droite. Pour nos valeurs, nous utilisons -1 pour représenter complètement à gauche, 0 pour représenter le centre et 1 pour représenter complètement à droite dans le champ stéréo. Bien entendu, vous êtes libre d'utiliser toute valeur entre -1 et 1 pour contrôler le positionnement précis de votre son.

en: Let's play a beep out of the left speaker:
fr: Jouons un beep à destination du haut-parleur de gauche :

en: Now, let's play it out of the right speaker:
fr: Maintenant, jouons-le à destination du haut-parleur de droite :

en: Finally let's play it back out of the center of both (the default position):
fr: Finalement, jouons-le à destination du centre des deux (la position par défaut) :

en: Now, go and have fun changing the amplitude and panning of your sounds!
fr: Maintenant, allez et prenez plaisir à changer l'amplitude et la balance de vos sons !

en: 2.3 Switching Synths
fr: 2.3 Changement de synthés

en: Switching Synths
fr: Changement de synthés

en: So far we've had quite a lot of fun making beeps. However, you're probably starting to get bored of the basic beep noise. Is that all Sonic Pi has to offer? Surely there's more to live coding than just playing beeps? Yes there is, and in this section we'll explore some of the exciting range of sounds that Sonic Pi has to offer.
fr: Jusqu'à maintenant, nous nous sommes bien amusés à faire des beeps. Cependant, vous commencez probablement à être fatigué par le bruit basique du beep. Sonic Pi ne peut pas m'en offrir plus ? Il y a certainement plus dans le codage en "live" que de jouer seulement des beeps ? Oui, et dans cette section, nous allons explorer l'étendue des sons que Sonic Pi vous propose.

en: Sonic Pi has a number of different instruments it calls synths (which is *short for synthesisers*). Whereas samples represent pre-recorded sounds, synths are capable of generating new sounds depending on how you control them (which we'll explore later in this tutorial). Sonic Pi's synths are very powerful and expressive and you'll have a lot of fun exploring and playing with them. First, let's learn how to select the current synth to use.
fr: Sonic Pi dispose d'instruments appelés synthés (*raccourci pour synthétiseurs*). Tandis que les échantillons (samples) représentent des sons pré-enregistrés, les synthés (synths) sont capables de générer des nouveaux sons en fonction de la façon dont vous les contrôlez (ce que nous explorerons plus tard dans ce tutoriel). Les synthés de Sonic Pi sont très puissants et expressifs, et vous prendrez du plaisir à les explorer et jouer avec. Avant tout, apprenons à sélectionner le synthé qui sera utilisé.

en: Buzzy saws and prophets
fr: Dents de scie vibrantes et prophètes

en: A fun sound is the *saw wave* - let's give it a try:
fr: Un son sympathique est l'*onde en dent de scie (saw)*. Essayons-le :

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

en: Let's try another sound - the *prophet*:
fr: Essayons un autre son, le *prophet* :

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

en: How about combining two sounds. First one after another:
fr: Et si on combinait deux sons ? D'abord l'un après l'autre :

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

en: Now multiple sounds at the same time (by not sleeping between successive calls to `play`):
fr: Maintenant plusieurs sons en même temps (en ne mettant pas d'instructions `sleep` entre les `play` successifs) :

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

en: Notice that the `use_synth` command only affects the following calls to `play`. Think of it like a *big switch* - new calls to `play` will play whatever synth it's currently pointing to. You can move the switch to a new synth with `use_synth`.
fr: Notez que la commande `use_synth` n'agit que sur les appels suivants à `play`. Pensez à elle comme un *gros commutateur* : les nouveaux appels à `play` vont jouer tout synthé qui est désigné "en cours". Vous pouvez enclencher le commutateur sur un nouveau synthé avec `use_synth`.

en: Discovering Synths
fr: Découverte des synthés

en: To see which synths Sonic Pi has for you to play with take a look at the Synths option in the menu at the bottom of this help screen (between Examples & Fx). There are over 20 to choose from. Here are a few of my favourites:
fr: Pour lister les synthés que Sonic Pi propose, jetez un œil sur les options de Synths dans le menu horizontal tout à fait en bas (à gauche de Fx). Il y en a plus de 20 au choix. Voici mes préférés :

en: Now play around with *switching synths during your music*. Have fun combining synths to make new sounds as well as using different synths for different sections of your music.
fr: Maintenant jouez en *commutant les synthés au cours de votre jeu*. Prenez plaisir à combiner des synthés pour faire de nouveaux sons et aussi en utilisant différents synthés selon les sections de votre musique.

en: 2.4 Duration with Envelopes
fr: 2.4 Durées avec enveloppes

en: Duration with Envelopes
fr: Durées avec enveloppes

en: In an earlier section, we looked at how we can use the `sleep` command to control when to trigger our sounds. However, we haven't yet been able to control the duration of our sounds.
fr: Dans une section précédente, nous avons vu comment nous pouvions utiliser la commande sleep pour contrôler le moment du déclenchement de nos sons. Toutefois, nous n'avons pas encore été capables de contrôler la durée des sons.

en: In order to give us a simple, yet powerful means of *controlling the duration* of our sounds, Sonic Pi provides the notion of an *ADSR amplitude envelope* (we'll cover what ADSR means later in this section). An amplitude envelope offers two useful aspects of control:
fr: Dans le but de nous offrir des moyens simples mais puissants de *contrôle de durée* de nos sons, Sonic Pi fournit la technique d'*enveloppe d'amplitude ADSR* (nous expliquerons ce que ADSR signifie plus loin dans cette section). Une enveloppe d'amplitude offre deux moyens utiles de contrôle :

en: control over the duration of a sound
fr: contrôle sur la durée d'un son

en: control over the amplitude of a sound
fr: contrôle sur l'amplitude d'un son

en: Duration
fr: Durée

en: The duration is the length the sound lasts for. A longer duration means that you hear the sound for longer. Sonic Pi's sounds all have a controllable amplitude envelope, and the total duration of that envelope is the duration of the sound. Therefore, by controlling the envelope you control the duration.
fr: La durée est le temps pendant lequel le son se maintient. Une longue durée signifie que vous entendez le son plus longtemps. Les sons de Sonic Pi ont tous une enveloppe d'amplitude, et la durée totale de cette enveloppe est la durée du son. Ainsi, en contrôlant l'enveloppe, vous contrôlez la durée.

en: The ADSR envelope not only controls duration, it also gives you *fine control over the amplitude of the sound*. All audible sounds start and end silent and contain some non-silent part in-between. Envelopes allow you to slide and hold the amplitude of non-silent parts of the sound. It's like giving someone instructions on how to turn up and down the volume of a guitar amplifier. For example you might ask someone to "start at silence, slowly move up to full volume, hold it for a bit, then quickly fall back to silence." Sonic Pi allows you to program exactly this behaviour with envelopes.
fr: L'enveloppe ADSR non seulement contrôle la durée, mais vous donne aussi *un contrôle fin sur l'amplitude du son*. Tous les sons commencent et finissent par le silence, avec une part non silencieuse entre. Les enveloppes vous permettent de faire évoluer ou de maintenir l'amplitude des parties non-silencieuses du son. C'est comme si vous donniez à quelqu'un des instructions sur comment augmenter ou diminuer le volume d'un ampli de guitare. Par exemple, vous pourriez demander à quelqu'un de "commencer en silence, d'augmenter lentement le volume jusqu'au maximum, le maintenir un moment, puis revenir rapidement au silence". Sonic Pi vous permet de programmer ceci avec les enveloppes.

en: Just to recap, as we have seen before, an amplitude of 0 is silence and an amplitude of 1 is normal volume.
fr: Juste pour se remémorer, une amplitude de 0 est le silence et une amplitude de 1 est le volume normal.

en: Now, let us look at each of the parts of the envelopes in turn.
fr: Maintenant, regardons chaque partie de l'enveloppe tour à tour.

en: Release Phase
fr: Durée d'extinction (Release)

en: The only part of the envelope that's used by default is the release time. This is the time it takes for the synth's sound to fade out. All synths have a release time of 1 which means that by default they have a duration of 1 beat (which at the default BPM of 60 is 1 second):
fr: La seul partie de l'enveloppe qui est utilisée par défaut est la durée d'extinction. C'est la durée qu'il faut pour que le son du synthé se termine. Tous les synthés ont une durée de "release" de 1, ce qui signifie qu'ils ont une durée d'un temps musical (qui par défaut est 1 seconde) avant extinction :

en: The note will be audible for 1 second. Go ahead and time it :-) This is short hand for the longer more explicit version:
fr: Cette note va être audible pendant 1 seconde. Vous pouvez chronométrer :-) C'est la version abrégée de la version longue plus explicite :

en: Notice how this sounds exactly the same (the sound lasts for one second). However, it's now very easy to change the duration by modifying the value of the `release:` opt:
fr: Observez comme cela sonne exactement pareil (le son dure pendant une seconde). Néanmoins, c'est désormais très simple de changer la durée en modifiant la valeur de l'option `release:` :

en: We can make the synth sound for a very short amount of time by using a very small release time:
fr: Nous pouvons faire jouer un synthé pendant une très courte durée en utilisant une durée de "release" très petite :

en: The duration of the release of the sound is called the *release phase* and by default is a linear transition (i.e. a straight line). The following diagram illustrates this transition:
fr: La durée d'extinction du son est appelée "phase d'extinction" et est par défaut une transition linéaire (c'est-à-dire une ligne droite). Le schéma suivant illustre cette transition :

en: ![release envelope](../../../etc/doc/images/tutorial/env-release.png)
fr: ![enveloppe de relâche](../../../etc/doc/images/tutorial/env-release.png)

en: The vertical line at the far left of the diagram shows that the sound starts at 0 amplitude, but goes up to full amplitude immediately (this is the attack phase which we'll cover next). Once at full amplitude it then moves in a straight line down to zero taking the amount of time specified by `release:`. *Longer release times produce longer synth fade outs.*
fr: La ligne verticale tout à gauche du schéma montre que le son démarre de l'amplitude 0, mais monte jusqu'à l'amplitude totale immédiatement (c'est la phase d'attaque que nous couvrirons ensuite). Une fois à l'amplitude totale, il redescend en ligne droite jusqu'à zéro en prenant le temps spécifié par `release:`. *Des durées de "release" plus longues produisent des fondus à la fermeture de synthé plus longs.*

en: You can therefore change the duration of your sound by changing the release time. Have a play adding release times to your music.
fr: Vous pouvez ainsi changer la durée de vos sons en changeant la durée d'extinction. Jouez un moment en ajoutant des durées de "release" à votre musique.

en: Attack Phase
fr: Phase d'attaque

en: By default, the *attack phase* is 0 for all synths which means they move from 0 amplitude to 1 immediately. This gives the synth an initial percussive sound. However, you may wish to fade your sound in. This can be achieved with the `attack:` opt. Try fading in some sounds:
fr: Par défaut, la phase d'attaque est fixée à 0 pour tous les synthés, ce qui signifie qu'ils évoluent de l'amplitude 0 à l'amplitude 1 immédiatement. Cela donne initialement au synthé un son percussif. Toutefois, vous pouvez souhaiter une montée progressive de votre son. Ceci peut être obtenu avec l'option `attack:`. Essayez des montées progressives de quelques sons :

en: You may use multiple opts at the same time. For example for a short attack and a long release try:
fr: Vous pouvez utiliser des options multiples en même temps. Par exemple, pour une attaque courte et une extinction lente, essayez :

en: This short attack and long release envelope is illustrated in the following diagram:
fr: Cette attaque courte et cette extinction lente sont illustrées dans le schéma suivant :

en: ![attack release envelope](../../../etc/doc/images/tutorial/env-attack-release.png)
fr: ![enveloppe avec attaque et relâche](../../../etc/doc/images/tutorial/env-attack-release.png)

en: Of course, you may switch things around. Try a long attack and a short release:
fr: Bien entendu, vous pouvez inverser les choses. Essayez une attaque longue et une extinction rapide :

en: ![long attack short release envelope](../../../etc/doc/images/tutorial/env-long-attack-short-release.png)
fr: ![enveloppe avec attaque longue et relâche courte](../../../etc/doc/images/tutorial/env-long-attack-short-release.png)

en: Finally, you can also have both short attack and release times for shorter sounds.
fr: Finalement, vous pouvez aussi avoir à la fois une attaque et une extinction rapides pour des sons plus courts.

en: ![short attack short release envelope](../../../etc/doc/images/tutorial/env-short-attack-short-release.png)
fr: ![enveloppe avec attaque courte et relâche courte](../../../etc/doc/images/tutorial/env-short-attack-short-release.png)

en: Sustain Phase
fr: Durée de soutien ("Sustain")

en: In addition to specifying attack and release times, you may also specify a sustain time to control the *sustain phase*. This is the time for which the sound is maintained at full amplitude between the attack and release phases.
fr: En plus de spécifier des durées d'attaque et d'extinction, vous pouvez aussi spécifier une durée de soutien. C'est la durée pendant laquelle le son est maintenu à l'amplitude maximale entre les phases d'attaque et d'extinction.

en: ![ASR envelope](../../../etc/doc/images/tutorial/env-attack-sustain-release.png)
fr: ![enveloppe ASR](../../../etc/doc/images/tutorial/env-attack-sustain-release.png)

en: The sustain time is useful for important sounds you wish to give full presence in the mix before entering an optional release phase. Of course, it's totally valid to set both the `attack:` and `release:` opts to 0 and just use the sustain to have absolutely no fade in or fade out to the sound. However, be warned, a release of 0 can produce clicks in the audio and it's often better to use a very small value such as 0.2.
fr: La durée de soutien est utile pour des sons importants auxquels vous voulez donner une présence permanente dans le mixage avant d'entrer dans une phase optionnelle d'extinction. Bien entendu, c'est entièrement valide de fixer à la fois les options d'attaque et d'extinction à 0 et d'utiliser seulement le soutien pour n'avoir absolument pas de montée et d'extinction progressives. Cependant, faites attention, une durée d'extinction de 0 peut produire des clics dans l'écoute et c'est souvent mieux d'utiliser une très petite valeur comme 0.2.

en: Decay Phase
fr: Phase de déclin ("Decay")

en: For an extra level of control, you can also specify a decay time. This is a phase of the envelope that fits between the attack and sustain phases and specifies a time where the amplitude will drop from the `attack_level:` to the `decay_level:` (which unless you explicitly set it will be set to the `sustain_level:`). By default, the `decay:` opt is 0 and both the attack and sustain levels are 1 so you'll need to specify them for the decay time to have any effect:
fr: Finalement, pour les cas où vous aurez besoin d'un niveau de contrôle supplémentaire, vous pourrez aussi spécifier une durée de déclin. C'est la phase de l'enveloppe qui s'intercale entre les phases d'attaque et de soutien et qui spécifie la durée pendant laquelle l'amplitude va descendre du niveau `attack_level:` jusqu'au niveau `decay_level:` (qui si on ne le définit pas explicitement sera égal au `sustain_level:`). Par défaut, l'option `decay:` est à 0 et à la fois les niveaux "attack" et "sustain" sont à 1. Ainsi vous aurez besoin de les spécifier en plus de la durée de déclin pour obtenir un effet :

en: ![ADSR envelope](../../../etc/doc/images/tutorial/env-attack-decay-sustain-release.png)
fr: ![enveloppe ADSR](../../../etc/doc/images/tutorial/env-attack-decay-sustain-release.png)

en: Decay Level
fr: Niveau de chute

en: One last trick is that although the `decay_level:` opt defaults to be the same value as `sustain_level:` you can explicitly set them to different values for full control over the envelope. This allows you to to create envelopes such as the following:
fr: Une dernière astuce est que même si l'option `decay_level:` a par défaut la même valeur que `sustain_level:`, on peut leur donner explicitement des valeurs différentes pour un contrôle complet de l'enveloppe. Cela nous permet de créer des enveloppes comme ceci :

en: ![ASR envelope](../../../etc/doc/images/tutorial/env-decay-level.png)
fr: ![enveloppe ASR](../../../etc/doc/images/tutorial/env-decay-level.png)

en: It's also possible to set the `decay_level:` to be higher than `sustain_level:`:
fr: Il est aussi possible de choisir un `decay_level:` plus haut que le `sustain_level:` :

en: ![ASR envelope](../../../etc/doc/images/tutorial/env-decay-level-2.png)
fr: ![enveloppe ASR](../../../etc/doc/images/tutorial/env-decay-level-2.png)

en: ADSR Envelopes
fr: Enveloppes ADSR

en: So to summarise, Sonic Pi's ADSR envelopes have the following phases:
fr: Ainsi pour résumer, les enveloppes de Sonic Pi ont les phases suivantes :

en: *attack* - time from 0 amplitude to the `attack_level`,
fr: *attack* - durée de passage de l'amplitude 0 jusqu'au niveau `attack_level`,

en: *decay* - time to move amplitude from `attack_level` to `decay_level`,
fr: *decay* - durée pour passer l'amplitude du niveau `attack_level` jusqu'au niveau `decay_level `,

en: *sustain* - time to move the amplitude from `decay_level` to `sustain_level`,
fr: *sustain* - durée pour faire passer l'amplitude du niveau `decay_level` au niveau `sustain_level`,

en: *release* - time to move amplitude from `sustain_level` to 0
fr: *release* - durée pour passer l'amplitude du niveau `sustain_level` au niveau 0

en: It's important to note that the duration of a sound is the summation of the times of each of these phases. Therefore the following sound will have a duration of 0.5 + 1 + 2 + 0.5 = 4 beats:
fr: Il est important de noter que la durée d'un son est la somme des durées de chacune de ces phases. Ainsi le son suivant aura une durée de 0.5 + 1 + 2 + 0.5 = 4 temps musicaux :

en: Now go and have a play adding envelopes to your sounds...
fr: Maintenant, allez et jouez un moment en ajoutant des enveloppes à vos sons.

en: 3 Samples
fr: 3 Échantillons

en: Samples
fr: Échantillons ("Samples")

en: Another great way to develop your music is to use pre-recorded sounds. In great hip-hop tradition, we call these pre-recorded sounds *samples*. So, if you take a microphone outside, go and record the gentle sound of rain hitting canvas, you've just created a sample.
fr: Un autre grand moyen de développer votre musique est d'utiliser des sons pré-enregistrés. Dans la grande tradition hip-hop, on appelle ces sons pré-enregistrés *samples*. Aussi, si vous prenez un micro à l'extérieur, et allez enregistrer le son de la pluie frappant une toile, vous avez tout simplement créé un "sample".

en: Sonic Pi lets you do lots of fun things with samples. Not only does it ship with 130 public domain samples ready for you to jam with, it lets you play and manipulate your own. Let's get to it...
fr: Sonic Pi vous offre des tas de choses amusantes à faire avec les "samples". Non seulement il est livré avec 130 échantillons du domaine public, prêts pour faire un boeuf, mais il vous permet de jouer et de manipuler les vôtres propres. Allons voir...

en: 3.1 Triggering Samples
fr: 3.1 Lecture des échantillons

en: Triggering Samples
fr: Lecture des échantillons

en: Playing beeps is only the beginning. Something that's a lot of fun is triggering pre-recorded samples. Try it:
fr: Jouer des beeps est seulement un début. Une chose qui est très plaisante est de déclencher des échantillons pré-enregistrés. Essayez-le :

en: sample :ambi_lunar_land
fr: sample :ambi_lunar_land

en: Sonic Pi includes many samples for you to play with. You can use them just like you use the `play` command. To play multiple samples and notes just write them one after another:
fr: Sonic Pi inclut beaucoup d'échantillons à jouer. Vous pouvez les utiliser juste comme vous utilisez la commande `play`. Pour jouer des échantillons et des notes multiples, écrivez-les simplement les uns après les autres :

en: play 36
    play 48
    sample :ambi_lunar_land
    sample :ambi_drone
fr: play 36
    play 48
    sample :ambi_lunar_land
    sample :ambi_drone

en: If you want to space them out in time, use the `sleep` command:
fr: Si vous voulez les espacer dans le temps, utilisez la commande `sleep` :

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

en: Notice how Sonic Pi doesn't wait for a sound to finish before starting the next sound. The `sleep` command only describes the separation of the *triggering* of the sounds. This allows you to easily layer sounds together creating interesting overlap effects.
fr: Notez que Sonic Pi n'attend pas la fin d'un son pour démarrer le suivant. La commande `sleep` décrit uniquement la séparation du *déclenchement* des sons. Ceci vous permet de superposer les sons en couches en créant d'intéressants effets de chevauchement. Plus tard dans ce tutoriel, nous jetterons un œil sur le contrôle de la durée de ces sons avec des enveloppes.

en: Discovering Samples
fr: Découverte des échantillons

en: There are two ways to discover the range of samples provided in Sonic Pi. First, you can use this help system. Click on Samples in the menu at the bottom of this help screen, choose your category and then you'll see a list of available sounds.
fr: Il y a deux manière de découvrir l'étendue des échantillons fournis par Sonic Pi. En premier lieu, on peut utiliser le système d'aide. Cliquez sur "Échantillons" dans le menu horizontal du bas, choisissez votre catégorie et vous verrez une liste des sons disponibles.

en: Alternatively you can use the *auto-completion system*. Simply type the start of a sample group such as: `sample :ambi_` and you'll see a drop-down of sample names appear for you to select. Try the following category prefixes:
fr: Alternativement, vous pouvez utiliser le *système d'auto-complétion*. Tapez simplement le début d'un groupe d'échantillons comme : `sample :ambi_` et vous verrez apparaître une liste de noms d'échantillons qui vous permettra d'en sélectionner un. Essayez les préfixes de catégorie suivants :

en: Now start mixing samples into your compositions!
fr: Maintenant commencez à introduire des échantillons dans vos compositions !

en: 3.2 Sample Parameters
fr: 3.2 Paramètres des échantillons

en: Sample Parameters: Amp and Pan
fr: Paramètres des échantillons : Amp et Pan

en: As we saw with synths, we can easily control our sounds with parameters. Samples support exactly the same parameterisation mechanism. Let's revisit our friends `amp:` and `pan:`.
fr: Comme nous l'avons vu avec les synthés, nous pouvons aisément contrôler nos sons avec des paramètres. Les "Samples" supportent exactement le même mécanisme de paramètrage. Revisitons nos amis `amp:` et `pan:`.

en: Amping samples
fr: Amplitude des échantillons

en: You can change the amplitude of samples with exactly the same approach you used for synths:
fr: Vous pouvez changer l'amplitude des échantillons avec exactement la même approche que vous avez utilisée pour les synthés :

en: Panning samples
fr: Balance des échantillons

en: We're also able to use the `pan:` parameter on samples. For example, here's how we'd play the amen break in the left ear and then half way through play it again through the right ear:
fr: Nous pouvons aussi utiliser le paramètre `pan:` avec les échantillons. Par exemple, voici comment nous jouerions le break amen au début vers la gauche, puis à mi-parcours, vers la droite :

en: Note that 0.877 is half the duration of the `:loop_amen` sample in seconds.
fr: Notez que 0.877 est la moitié de la durée en secondes de l'échantillon `:loop_amen`.

en: Finally, note that if you set some synth defaults with `use_synth_defaults` (which we will discuss later), these will be ignored by `sample`.
fr: Finalement, notez que si vous fixez des valeurs par défaut avec `use_synth_defaults` (que nous détaillerons plus tard), elles seront ignorées par `sample`.

en: 3.3 Stretching Samples
fr: 3.3 Étirement des échantillons

en: Stretching Samples
fr: Étirement des échantillons

en: Now that we can play a variety of synths and samples to create some music, it's time to learn how to modify both the synths and samples to make the music even more unique and interesting. First, let's explore the ability to *stretch* and *squash* samples.
fr: Maintenant que nous pouvons jouer une variété de synthés et d'échantillons pour créer une musique, il est temps d'apprendre comment modifier à la fois les synthés et les échantillons pour faire de la musique encore plus originale et intéressante. En premier, explorons la faculté d'*étirer* et de *compresser* les échantillons.

en: Sample Representation
fr: Représentation des échantillons

en: Samples are pre-recorded sounds stored as numbers which represent how to move the speaker cone to reproduce the sound. The speaker cone can move in and out, and so the numbers just need to represent how far in and out the cone needs to be for each moment in time. To be able to faithfully reproduce a recorded sound the sample typically needs to store many thousands of numbers per second! Sonic Pi takes this list of numbers and feeds them at the right speed to move your computer's speaker in and out in just the right way to reproduce the sound. However, it's also fun to change the speed with which the numbers are fed to the speaker to change the sound.
fr: Les échantillons ("samples") sont des sons pré-enregistrés stockés à l'aide de nombres qui représentent comment se déplace la membrane du haut-parleur pour reproduire le son. La membrane du haut-parleur peut avancer et reculer, et ainsi les nombres ont juste besoin de représenter la distance d'avancée ou de recul que la membrane doit avoir pour chaque moment dans le temps. Pour être capable de reproduire fidèlement un son enregistré, un échantillon a typiquement besoin de stocker des milliers de nombres par seconde ! Sonic Pi prend cette liste de nombres et en alimente à la bonne vitesse l'ordinateur pour faire avancer et reculer comme il le faut la membrane de son haut-parleur pour reproduire le son. Cependant, c'est aussi amusant de changer la vitesse à laquelle est alimenté le haut-parleur pour changer le son.

en: Changing Rate
fr: Changement de vitesse ("Rate")

en: Let's play with one of the ambient sounds: `:ambi_choir`. To play it with the default rate, you can pass a `rate:` opt to `sample`:
fr: Jouons avec un des sons d'ambiance : `:ambi_choir`. Pour le jouer avec la vitesse par défaut, vous pouvez passer une option `rate:` au `sample` :

en: This plays it at normal rate (1), so nothing special yet. However, we're free to change that number to something else. How about `0.5`:
fr: Ceci le joue à la vitesse normale (1), aussi rien de spécial pour l'instant. Cependant, vous êtes libre de changer ce nombre pour une autre valeur. Essayons `0.5` :

en: Woah! What's going on here? Well, two things. Firstly, the sample takes twice as long to play, secondly the sound is an octave lower. Let's explore these things in a little more detail.
fr: Wow ! Que se passe-t-il ici ? Eh bien, deux choses. Premièrement, l'échantillon est joué pendant 2 fois plus de temps, deuxièmement le son est à une octave en-dessous. Explorons ces choses un peu plus en détails.

en: Let's stretch
fr: Étirons

en: A sample that's fun to stretch and compress is the Amen Break. At normal rate, we might imagine throwing it into a *drum 'n' bass* track:
fr: Un échantillon qui est amusant à étirer ou à compresser est le break Amen. A vitesse normale, on pourrait imaginer de l'insérer dans une piste de *drum 'n' bass* :

en: However by changing the rate we can switch up genres. Try half speed for *old school hip-hop*:
fr: Toutefois en modifiant la vitesse on peut changer de genre. Essayez de réduire de moitié la vitesse pour un *hip-hop old school* :

en: If we speed it up, we enter *jungle* territory:
fr: Si nous l'accélérons, nous entrons dans le territoire de la *jungle* :

en: Now for our final party trick - let's see what happens if we use a negative rate:
fr: Maintenant pour notre astuce finale - voyons ce qui se passe lorsque nous utilisons un "rate" négatif :

en: Woah! It plays it *backwards*! Now try playing with lots of different samples at different rates. Try very fast rates. Try really slow rates. See what interesting sounds you can produce.
fr: Ouhaou ! Il le joue à *l'envers* ! Maintenant, essayez de jouer avec des tas d'échantillons différents avec des vitesses différentes. Essayez des vitesses très rapides et des vitesses vraiment lentes. Voyez quels sons intéressants vous pouvez produire.

en: A Simple Explanation of Sample Rate
fr: Une simple explication de la vitesse d'échantillon ("sample rate")

en: A useful way to think of samples is as springs. Playback rate is like squashing and stretching the spring. If you play the sample at rate 2, you're *squashing the spring* to half its normal length. The sample therefore takes half the amount of time to play as it's shorter. If you play the sample at half rate, you're *stretching the spring* to double its length. The sample therefore takes twice the amount of time to play as it's longer. The more you squash (higher rate), the shorter it gets, the more you stretch (lower rate), the longer it gets.
fr: Un moyen imagé d'assimiler les échantillons est de penser aux ressorts. La vitesse de lecture est comme l'étirement et la compression du ressort. Si vous jouez l'échantillon à la vitesse 2, vous compressez le ressort à la moitié de sa longueur normale. Ainsi l'échantillon met la moitié du temps à être joué puisqu'il est plus court. Si vous jouez l'échantillon à la moitié de la vitesse, vous *étirez le ressort* au double de sa longueur. Ainsi l'échantillon met deux fois plus de temps à être joué puisqu'il est plus long. Plus vous compressez (vitesse plus élevée), plus il devient court, plus vous étirez (vitesse plus lente), plus il devient long.

en: Compressing a spring increases its density (the number of coils per cm) - this is similar to the sample sounding *higher pitched*. Stretching the spring decreases its density and is similar to the sound having a *lower pitch*.
fr: Compresser un ressort augmente sa densité (le nombre de spires par cm) : ceci est similaire à l'échantillon sonnant *plus aigu*. Étirer le ressort diminue sa densité, c'est similaire à un son *plus grave*.

en: The Maths Behind Sample Rate
fr: Les maths derrière la vitesse d'échantillon

en: (This section is provided for those that are interested in the details. Please feel free to skip it...)
fr: (Cette section est fournie pour ceux que les détails intéressent. Soyez libre de la sauter...)

en: As we saw above, a sample is represented by a big long list of numbers representing where the speaker should be through time. We can take this list of numbers and use it to draw a graph which would look similar to this:
fr: Comme nous l'avons vu ci-dessus, un échantillon est représenté par une longue liste de nombres qui représentent la position où devrait être la membrane du haut-parleur dans le temps. Nous pouvons prendre cette liste de nombres et l'utiliser pour tracer un graphique qui ressemblerait à ceci :

en: ![sample graph](../../../etc/doc/images/tutorial/sample.png)
fr: ![graphique d'échantillon](../../../etc/doc/images/tutorial/sample.png)

en: You might have seen pictures like this before. It's called the *waveform* of a sample. It's just a graph of numbers. Typically a waveform like this will have 44100 points of data per second (this is due to the Nyquist-Shannon sampling theorem). So, if the sample lasts for 2 seconds, the waveform will be represented by 88200 numbers which we would feed to the speaker at a rate of 44100 points per second. Of course, we could feed it at double rate which would be 88200 points per second. This would therefore take only 1 second to play back. We could also play it back at half rate which would be 22050 points per second taking 4 seconds to play back.
fr: Vous avez peut-être déjà vu des images comme cela. C'est appelé la *forme d'onde* d'un échantillon. C'est juste un graphique de nombres. Typiquement, une forme d'onde comme cela aura 44100 points de données par seconde (en application du théorème d'échantillonnage de Nyquist-Shannon). Ainsi, si l'échantillon dure 2 secondes, la forme d'onde sera représentée par 88200 nombres qui alimenteront le haut-parleur à la vitesse de 44100 points par seconde. Bien sûr, nous pouvons l'alimenter à une vitesse double qui serait de 88200 points par seconde. Ceci prendrait ainsi une seconde seulement à être joué. Nous pourrions aussi le jouer à la moitié de la vitesse qui serait donc de 22050 points par seconde, en prenant 4 secondes pour être joué.

en: The duration of the sample is affected by the playback rate:
fr: La durée d'un échantillon est affectée par la vitesse de jeu :

en: Doubling the playback rate halves the playback time,
fr: Doubler la vitesse de jeu diminue de moitié la durée du jeu,

en: Halving the playback rate doubles the playback time,
fr: Diminuer de moitié la vitesse de jeu double la durée de jeu,

en: Using a playback rate of one fourth quadruples the playback time,
fr: Utiliser une vitesse de jeu d'un quart quadruple la durée du jeu,

en: Using a playback rate of 1/10 makes playback last 10 times longer.
fr: Utiliser une vitesse de jeu de 1/10 fait durer le jeu 10 fois plus longtemps.

en: We can represent this with the formula:
fr: On peut représenter ceci avec la formule :

en: new_sample_duration = (1 / rate) * sample_duration
fr: nouvelle_durée = (1 / rate) * durée_normale

en: Changing the playback rate also affects the pitch of the sample. The frequency or pitch of a waveform is determined by how fast it moves up and down. Our brains somehow turn fast movement of speakers into high notes and slow movement of speakers into low notes. This is why you can sometimes even see a big bass speaker move as it pumps out super low bass - it's actually moving a lot slower in and out than a speaker producing higher notes.
fr: Changer la vitesse de jeu affecte aussi la hauteur du son. La fréquence ou le ton d'une forme d'onde est déterminé par la vitesse à laquelle elle monte et descend. Notre cerveau curieusement change le mouvement rapide de la membrane du haut-parleur en notes hautes et le mouvement lent en notes basses. C'est pourquoi vous pouvez quelquefois voir un gros haut-parleur de basse bouger en émettant une super basse - il va et vient beaucoup moins vite qu'un haut-parleur produisant des notes plus aiguës.

en: If you take a waveform and squash it it will move up and down more times per second. This will make it sound higher pitched. It turns out that doubling the amount of up and down movements (oscillations) doubles the frequency. So, *playing your sample at double rate will double the frequency you hear it*. Also, *halving the rate will halve the frequency*. Other rates will affect the frequency accordingly.
fr: Si vous prenez une forme d'onde et que vous la compressez, elle va monter et descendre plus de fois par seconde. Ceci va faire un son plus aigu. On en déduit que doubler le montant des mouvements de montée et descente (oscillations) double la fréquence. Ainsi, *jouer votre échantillon à double vitesse double la fréquence que vous entendez*. De même, *diminuer de moitié la vitesse va diminuer de moitié la fréquence*. D'autres vitesses affecteront la fréquence dans le même sens.

en: 3.4 Enveloped Samples
fr: 3.4 Échantillons enveloppés

en: Enveloped Samples
fr: Échantillons enveloppés

en: It is also possible to modify the *duration* and *amplitude* of a sample using an ADSR envelope. However, this works slightly differently to the ADSR envelope available on synths. Sample envelopes only allow you to reduce the amplitude and duration of a sample - and never to increase it. The sample will stop when either the sample has finished playing or the envelope has completed - whichever is first. So, if you use a very long `release:`, it won't extend the duration of the sample.
fr: Il est aussi possible de modifier la *durée* et l'*amplitude* d'un échantillon en utilisant une enveloppe ADSR. Toutefois, ceci fonctionne d'une manière légèrement différente de l'enveloppe ADSR applicable aux synthés. Les enveloppes d'échantillon permettent uniquement de réduire l'amplitude et la durée de l'échantillon - et jamais de les augmenter. Le jeu de l'échantillon s'arrêtera soit quand l'échantillon arrivera à sa fin, soit quand la fin l'enveloppe sera atteinte. Donc si vous utilisez une phase de `release:` très longue, cela n'allongera pas la durée de l'échantillon.

en: Amen Envelopes
fr: Des enveloppes pour Amen

en: Let's return to our trusty friend the Amen Break:
fr: Retournons à notre fidèle ami le break Amen :

en: With no opts, we hear the full sample at full amplitude. If we want to fade this in over 1 second we can use the `attack:` param:
fr: Sans options, nous entendons la totalité de l'échantillon à son amplitude totale. Si nous voulons une attaque progressive sur une seconde, nous pouvons utiliser le paramètre `attack:` :

en: For a shorter fade in, choose a shorter attack value:
fr: Pour une attaque plus courte, choisissez une valeur `attack:` plus petite :

en: Auto Sustain
fr: Soutien automatique ("Auto Sustain")

en: Where the ADSR envelope's behaviour differs from the standard synth envelope is in the *sustain* value. In the standard synth envelope, the sustain defaulted to 0 unless you set it manually. With samples, the sustain value defaults to an *automagical* value - the time left to play the rest of the sample. This is why we hear the full sample when we pass no defaults. If the attack, decay, sustain and release values were all 0 we'd never hear a peep. Sonic Pi therefore calculates how long the sample is, deducts any attack, decay and release times and uses the result as your sustain time. If the attack, decay and release values add up to more than the duration of the sample, the sustain is simply set to 0.
fr: Le comportement de l'enveloppe ADSR diffère de l'enveloppe standard des synthés pour la valeur de *sustain*. Dans l'enveloppe standard des synthés, la valeur par défaut du soutien est 0 à moins que vous ne la fixiez manuellement. Avec les échantillons, la valeur par défaut du soutien est une valeur *auto-magique* - le temps qu'il reste pour finir l'échantillon. C'est pour cela que nous entendons l'échantillon en entier quand une valeur n'est pas spécifiée. Si les valeurs de l'attaque, du déclin, du soutien et de l'extinction étaient toutes à 0, nous n'entendrions pas le moindre gazouillis. Donc, de la longueur de l'échantillon, Sonic Pi déduit les éventuelles durées d'attaque, de déclin et d'extinction et utilise le résultat pour votre durée de soutien. Si la somme des durées d'attaque, de déclin et d'extinction est supérieure à la durée de l'échantillon, le soutien est simplement fixé à 0.

en: Fade Outs
fr: Extinctions progressives

en: To explore this, let's consider our Amen break in more detail. If we ask Sonic Pi how long the sample is:
fr: Pour explorer ceci, regardons notre Amen de manière plus détaillée. Si nous demandons à Sonic Pi quelle est la longueur de l'échantillon :

en: It will print out `1.753310657596372` which is the length of the sample in seconds. Let's just round that to `1.75` for convenience here. Now, if we set the release to `0.75`, something surprising will happen:
fr: Il affichera `1.753310657596372`, ce qui est la longueur de l'échantillon en secondes. Arrondissons-le ici à `1.75` par commodité. Maintenant si nous fixons l'extinction à `0.75`, quelque chose de surprenant va se passer :

en: It will play the first second of the sample at full amplitude before then fading out over a period of 0.75 seconds. This is the *auto sustain* in action. By default, the release always works from the end of the sample. If our sample was 10.75 seconds long, it would play the first 10 seconds at full amplitude before fading out over 0.75s.
fr: La première seconde de l'échantillon va être jouée à l'amplitude totale avant de s'estomper progressivement sur une durée de 0.75 secondes. C'est l'*auto-soutien* en action. Par défaut, la phase d'extinction fonctionne de manière à s'achever à la fin de l'échantillon. Si notre échantillon avait 10.75 secondes de longueur, il serait joué 10 secondes à l'amplitude totale avant de s'estomper progressivement pendant 0.75 secondes.

en: Remember: by default, `release:` fades out at the end of a sample.
fr: Rappelez-vous : par défaut, la phase `release:` amène à l'extinction complète à la fin de l'échantillon.

en: Fade In and Out
fr: Attaque et extinction progressives

en: We can use both `attack:` and `release:` together with the auto sustain behaviour to fade both in and out over the duration of the sample:
fr: On peut utiliser à la fois les paramètres `attack:` et `release:` ensemble grâce au comportement du soutien automatique pour des attaques et des extinctions progressives :

en: As the full duration of the sample is 1.75s and our attack and release phases add up to 1.5s, the sustain is automatically set to 0.25s. This allows us to easily fade the sample in and out.
fr: Comme la durée totale de l'échantillon est de 1.75 s et que la somme des phases d'attaque et d'extinction fait 1.5 s, le soutien est automatiquement ajusté à 0.25 s. Ceci nous permet de programmer facilement une attaque et une extinction progressives de l'échantillon.

en: Explicit sustain
fr: Soutien explicite

en: We can easily get back to our normal synth ADSR behaviour by manually setting `sustain:` to a value such as 0:
fr: Nous pouvons facilement revenir au comportement normal de l'enveloppe ADSR des synthés en fixant manuellement `sustain:` à une valeur comme 0 :

en: Now, our sample only plays for 0.75 seconds in total. With the default for `attack:` and `decay:` at 0, the sample jumps straight to full amplitude, sustains there for 0s then releases back down to 0 amplitude over the release period - 0.75s.
fr: Maintenant, notre échantillon n'est joué que pendant 0.75 s au total. Avec les valeurs 0 par défaut pour `attack:` et `decay:` , l'échantillon monte directement à l'amplitude totale, se maintient là pendant 0 s et redescend progressivement à l'amplitude 0 pendant la phase d'extinction : 0.75 s.

en: Percussive cymbals
fr: Cymbales percussives

en: We can use this behaviour to good effect to turn longer sounding samples into shorter, more percussive versions. Consider the sample `:drum_cymbal_open`:
fr: Nous pouvons utiliser ce comportement pour obtenir de bons effets en transformant un échantillon qui sonne longtemps en versions plus percussives. Intéressons-nous à l'échantillon `:drum_cymbal_open` :

en: You can hear the cymbal sound ringing out over a period of time. However, we can use our envelope to make it more percussive:
fr: Vous pouvez entendre la cymbale sonnant pendant une certaine durée. Toutefois, nous pouvons utiliser notre enveloppe pour la rendre plus percussive :

en: You can then emulate hitting the cymbal and then dampening it by increasing the sustain period:
fr: Vous pouvez émuler la frappe de la cymbale suivie d'un étouffement en augmentant la phase de soutien :

en: Now go and have fun putting envelopes over the samples. Try changing the rate too for really interesting results.
fr: Maintenant allez et prenez plaisir à mettre des enveloppes sur vos échantillons. Essayez aussi de changer la vitesse pour des résultats vraiment intéressants.

en: 3.5 Partial Samples
fr: 3.5 Échantillons partiels

en: Partial Samples
fr: Échantillons partiels

en: This section will conclude our exploration of Sonic Pi's sample player. Let's do a quick recap. So far we've looked at how we can trigger samples:
fr: Cette section va conclure notre exploration du lecteur d'échantillons de Sonic Pi. Faisons un rapide résumé. Jusqu'à maintenant nous avons vu comment lire des échantillons :

en: We then looked at how we can change the rate of samples such as playing them at half speed:
fr: Nous avons ensuite vu comment changer la vitesse de lecture des échantillons en les jouant par exemple deux fois moins vite :

en: Next, we looked at how we could fade a sample in (let's do it at half speed):
fr: Ensuite, nous avons vu comment nous pouvions obtenir une attaque progressive (faisons-le à vitesse moitié) :

en: We also looked at how we could use the start of a sample percussively by giving `sustain:` an explicit value and setting both the attack and release to be short values:
fr: Nous avons aussi vu comment nous pouvions utiliser le début d'un échantillon en percussion en donnant à `sustain:` une valeur explicite et en assignant des valeurs faibles à la fois à `attack:` et à `release:` :

en: However, wouldn't it be nice if we didn't have to always start at the beginning of the sample? Wouldn't it also be nice if we didn't have to always finish at the end of the sample?
fr: Toutefois ne serait-il pas sympathique de ne pas avoir à toujours démarrer au début de l'échantillon ? Ne serait-ce pas également sympathique de ne pas avoir à finir toujours à la fin de l'échantillon ?

en: Choosing a starting point
fr: Choix d'un point de départ

en: It is possible to choose an arbitrary starting point in the sample as a value between 0 and 1 where 0 is the start of the sample, 1 is the end and 0.5 is half way through the sample. Let's try playing only the last half of the amen break:
fr: Il est possible de choisir un point arbitraire de départ dans l'échantillon au moyen d'une valeur comprise entre 0 et 1 où 0 est le début de l'échantillon, 1 est la fin et 0.5 le milieu. Essayons de jouer seulement la dernière moitié du break "Amen" :

en: How about the last quarter of the sample:
fr: Ou pour le dernier quart de l'échantillon :

en: Choosing a finish point
fr: Choix d'un point de terminaison

en: Similarly, it is possible to choose an arbitrary finish point in the sample as a value between 0 and 1. Let's finish the amen break half way through:
fr: De manière similaire, il est possible de choisir un point de terminaison arbitraire au moyen d'une valeur comprise entre 0 et 1. Terminons le break "Amen" à la moitié de son parcours :

en: Specifying start and finish
fr: Spécification du départ et de la terminaison

en: Of course, we can combine these two to play arbitrary segments of the audio file. How about only a small section in the middle:
fr: Bien sûr, nous pouvons combiner ces deux paramètres pour jouer des segments arbitraires du fichier audio. Comment jouer uniquement une petite section au milieu :

en: What happens if we choose a start position after the finish position?
fr: Que se passe-t-il si nous choisissons une position de départ postérieure au point de terminaison ?

en: Cool! It plays it backwards!
fr: Cool ! Ça joue à l'envers !

en: Combining with rate
fr: Combinaison avec la vitesse

en: We can combine this new ability to play arbitrary segments of audio with our friend `rate:`. For example, we can play a very small section of the middle of the amen break very slowly:
fr: Nous pouvons combiner cette nouvelle possibilité de jouer des segments arbitraires avec notre ami `rate:`. Par exemple, nous pouvons jouer une très petite section du break "Amen" très lentement :

en: Combining with envelopes
fr: Combinaison avec les enveloppes

en: Finally, we can combine all of this with our ADSR envelopes to produce interesting results:
fr: Finalement, nous pouvons combiner tout ceci avec nos enveloppes ADSR pour produire des résultats intéressants :

en: Now go and have a play mashing up samples with all of this fun stuff...
fr: Maintenant allez et jouez un moment en triturant les échantillons avec ces choses amusantes...

en: 3.6 External Samples
fr: 3.6 Échantillons externes

en: External Samples
fr: Échantillons externes

en: Whilst the built-in samples can get you up and started quickly, you might wish to experiment with other recorded sounds in your music. Sonic Pi totally supports this. First though, let's have a quick discussion on the portability of your piece.
fr: Bien que les échantillons fournis en interne puissent vous motiver et vous faire démarrer rapidement, vous pourriez souhaiter d'expérimenter d'autres sons pré-enregistrés dans votre musique. Sonic Pi supporte complètement cela. En premier lieu toutefois ayons une rapide discussion sur la portabilité de votre œuvre.

en: Portability
fr: Portabilité

en: When you compose your piece purely with built-in synths and samples, the code is all you need to faithfully reproduce your music. Think about that for a moment - that's amazing! A simple piece of text you can email around or stick in a [Gist](https://gist.github.com) represents everything you need to reproduce your sounds. That makes it *really easy to share* with your friends as they just need to get hold of the code.
fr: Quand vous composez votre morceau uniquement avec des synthés et des échantillons internes, le code est tout ce dont vous avez besoin pour reproduire fidèlement votre musique. Pensez à cela un instant – c'est génial ! Un simple morceau de texte que vous pouvez envoyer par courriel ou coller dans un [Gist](https://gist.github.com) représente tout ce dont vous avez besoin pour reproduire vos sons. Cela le rend *vraiment facile à partager* avec vos amis puisqu'ils ont juste besoin de se procurer le code.

en: However, if you start using your own pre-recorded samples, you lose this portability. This is because to reproduce your music other people not only need your code, they need your samples too. This limits the ability for others to manipulate, mash-up and experiment with your work. Of course this shouldn't stop you from using your own samples, it's just something to consider.
fr: Toutefois, si vous commencez à utiliser vos propres échantillons pré-enregistrés, vous perdez cette portabilité. C'est parce que pour reproduire votre musique les autres ont besoin non seulement de votre code, mais aussi de vos échantillons. Ceci limite la capacité pour les autres de manipuler, triturer et expérimenter avec votre oeuvre. Bien entendu, ceci ne doit pas vous empêcher d'utiliser vos propres échantillons, c'est juste quelque chose à prendre en compte.

en: Local Samples
fr: Échantillons locaux

en: So how do you play any arbitrary WAV, AIFF, OGG, OGA, FLAC or MP3 file on your computer? All you need to do is pass the path of that file to `sample`:
fr: Alors comment faire pour jouer n'importe quel fichier WAV, AIFF, OGG, OGA, FLAC ou MP3 sur votre ordinateur ? Tout ce dont vous avez besoin est de renseigner le chemin de ce fichier à `sample` :

en: Sonic Pi will automatically load and play the sample. You can also pass all the standard params you're used to passing `sample`:
fr: Sonic Pi chargera automatiquement et jouera votre échantillon. Vous pouvez aussi passer tous les paramètres que vous avez l'habitude de passer à `sample` :

en: 3.7 Sample Packs
fr: 3.7 Paquets de samples

en: Sample Packs
fr: Paquets de samples

en: **Note: this section of the tutorial covers the advanced topic of working with large directories of your own samples. This will be the case if you've downloaded or bought your own sample packs and wish to use them within Sonic Pi.**
fr: **Note : cette section du tutoriel couvre le sujet avancé de travailler avec des grands dossiers de vos propres samples. Ce sera le cas si vous avez téléchargé ou acheté vos propre paquets de samples et souhaitez les utiliser dans Sonic Pi.**

en: **Feel free to skip this if you're happy working with the built-in samples.**
fr: **N'hésitez pas à sauter cette section si vous vous contentez des samples fournis dans Sonic Pi.**

en: When working with large folders of external samples it can be cumbersome to have to type the whole path every time to trigger an individual sample.
fr: Quand on travaille avec de grands dossiers de samples externes il peut être ennuyeux de taper le chemin entier chaque fois qu'on veut déclencher un sample particulier.

en: For example, say you have the following folder on your machine:
fr: Par exemple, imaginons que vous avez le dossier suivant sur votre machine :

en: When we look inside that folder we find the following samples:
fr: Quand on regarde dans ce dossier on voit les samples suivants :

en: Typically in order to play the piano sample we can use the full path:
fr: Typiquement pour jouer le sample de piano on peut utiliser le chemin complet :

en: If we want to then play the guitar sample we can use its full path too:
fr: Si on veut jouer le sample de guitare on peut aussi utiliser son chemin complet :

en: However, both of these calls to sample requires us to *know* the names of the samples within our directory. What if we just want to listen to each sample in turn quickly?
fr: Cependant ces deux appels de `sample` nous forcent à *connaître* le nom de chacun des samples de notre dossier. Et si on voulait juste écouter chaque sample à son tour rapidement ?

en: Indexing Sample Packs
fr: Indexer les paquets de samples

en: If we want to play the first sample in a directory we just need to pass the directory's name to `sample` and the index `0` as follows:
fr: Si on veut jouer le premier sample d'un dossier on peut juste passer le nom du dossier à `sample` et l'index `0` comme suit :

en: We can even make a shortcut to our directory path using a variable:
fr: On peut même construire un raccourci vers notre chemin de dossier en utilisant une variable :

en: Now, if we want to play the second sample in our directory, we just need to add 1 to our index:
fr: Maintenant, si on veut jouer le deuxième sample de notre dossier, on peut juste incrémenter notre index :

en: Notice that we no longer need to know the names of the samples in the directory - we just need to know the directory itself (or have a shortcut to it). If we ask for an index which is larger than the number of samples, it simply wraps round just like Rings. Therefore, whatever number we use we're guaranteed to get one of the samples in that directory.
fr: Remarquez qu'on n'a plus besoin de connaître le nom des samples du dossier : on doit juste connaître le dossier lui-même (ou avoir un raccourci vers lui). Si on demande un index qui est plus grand que le nombre de samples, il va juste boucler comme pour les anneaux. Ainsi, quel que soit le nombre qu'on utilise on a la garantie de récupérer un des samples de ce dossier.

en: Filtering Sample Packs
fr: Filtrer des paquets de samples

en: Usually indexing is enough, but sometimes we need more power to sort and organise our samples. Luckily many sample packs add useful information in the filenames. Let's take another look at the sample file names in our directory:
fr: D'habitude indexer suffit, mais parfois on a besoin de plus de puissance pour trier et organiser nos échantillons. Heureusement de nombreux paquets d'échantillons ajoutent des informations utiles dans les noms de fichiers. Jetons un autre œil aux noms de fichier des échantillons de notre dossier :

en: Notice that in these filenames we have quite a bit of information. Firstly, we have the BPM of the sample (beats per minute) at the start. So, the piano sample is at 120 BPM and our first three melodies are at 100 BPM. Also, our sample names contain the key. So the guitar sample is in Bb and the melodies are in A#. This information is very useful for mixing in these samples with our other code. For example, we know we can only play the piano sample with code that's in 120 BPM and in the key of Bb.
fr: Remarquez que dans ces noms de fichier nous avons pas mal d'informations. On a le BPM du sample (nombre de battements par minute) au début. Donc le sample de piano est à 120 BPM et nos trois premières mélodies sont à 100 BPM. Nos noms de samples contiennent aussi la clef. Donc le sample de guitare est en Bb (Si bémol) et les mélodies sont en A# (La dièse). Cette information est très utile pour mélanger ces samples avec le reste de notre code. Par exemple, on sait qu'on ne peut jouer le sample de piano que dans du code qui est à 120 BPM et dans la clef de Bb.

en: It turns out that we can use this particular naming convention of our sample sets in the code to help us filter out the ones we want. For example, if we're working at 120 BPM, we can filter down to all the samples that contain the string `"120"` with the following:
fr: Il se trouve qu'on peut utiliser cette convention de nommage particulière de nos ensembles de samples dans le code pour nous aider à ne garder que ceux qu'on veut. Par exemple, si nous travaillons à 120 BPM, on peut ne garder que les samples qui contiennent la chaîne `"120"` avec le code suivant :

en: This will play us the first match. If we want the second match we just need to use the index:
fr: Cela jouera le premier sample qui correspond. Si on veut le deuxième, il suffit d'utiliser l'index :

en: We can even use multiple filters at the same time. For example, if we want a sample whose filename contains both the substrings `"120"` and `"A#"` we can find it easily with the following code:
fr: On peut même utiliser de multiples filtres en même temps. Par exemple, si on veut un sample dont le nom de fichier contient à la fois les sous-chaînes "120" et "A#", on peut le trouver facilement avec le code suivant :

en: Finally, we're still free to add our usual opts to the call to `sample`:
fr: Enfin, on a toujours la possibilité d'ajouter nos options habituelles lors de l'appel à `sample` :

en: The sample filter pre-arg system understands two types of information: *sources* and *filters*. Sources are information used to create the list of potential candidates. A source can take two forms:
fr: Le système de pré-argument de filtre de samples comprend deux types d'information : les sources et les filtres. Les sources sont des informations utilisées pour créer la liste des candidats potentiels. Une source peut prendre deux formes :

en: `"/path/to/samples"` - a string representing a valid path to a directory
fr: "/path/to/samples" : une chaîne représentant un chemin valide vers un dossier

en: `"/path/to/samples/foo.wav"` - a string representing a valid path to a sample
fr: "/path/to/samples/foo.wav" : une chaîne représentant un chemin valide vers un fichier sample

en: The `sample` fn will first gather all sources and use them to create a large list of candidates. This list is constructed by first adding all valid paths and then by adding all the valid `.flac`, `.aif`, `.aiff`, `.wav`, `.wave`, `.mp3` files contained within the directories.
fr: La fonction `sample` va d'abord rassembler toutes les sources et les utiliser pour créer une grande liste de candidats. Cette liste est construite en ajoutant d'abord tous les chemins valides puis en ajoutant tous les fichiers valides `.flac`, `.aif`, `.aiff`, `.wav`, `.wave`, et `.mp3` contenus dans les dossiers.

en: For example, take a look at the following code:
fr: Par exemple, regardez le code suivant :

en: Here, we're combining the contents of the samples within two directories and adding a specific sample. If `"/path/to/my/samples/"` contained 3 samples and `"/path/to/my/samples2/"` contained 12, we'd have 16 potential samples to index and filter (3 + 12 + 1).
fr: Ici nous combinons les contenus des samples de deux dossiers en y ajoutant un sample en particulier. Si `"/path/to/my/samples/"` contient trois samples et `"/path/to/my/samples2/"` en contient douze, on aurait seize samples potentiels à indexer et filtrer (3 + 12 + 1).

en: By default, only the sample files within a directory are gathered into the candidate list. Sometimes you might have a number of nested folders of samples you wish to search and filter within. You can therefore do a recursive search for all samples within all subfolders of a particular folder by adding `**` to the end of the path:
fr: Par défaut, seuls les fichiers de samples d'un dossier sont rassemblés dans la liste de candidats. Parfois vous pourriez avoir un certain nombre de dossiers imbriqués dans lesquels vous aimeriez chercher et filtrer. Vous pouvez faire une recherche récursive dans tous les samples de tous les sous-dossiers d'un dossier en particulier en ajoutant `**` à la fin du chemin :

en: Take care though as searching through a very large set of folders may take a long time. However, the contents of all folder sources are cached, so the delay will only happen the first time.
fr: Attention parce que chercher dans un très grand ensemble de dossiers peut prendre beaucoup de temps. Cela dit, le contenu des dossiers sources est mis en cache, donc le retard n'arrivera que la première fois.

en: Finally, note that the sources *must go first*. If no source is given, then the set of built-in samples will be selected as the default list of candidates to work with.
fr: Enfin, notez que les sources doivent *être en premier*. Si aucune source n'est donnée, alors l'ensemble de samples fourni par défaut sera pris comme liste des candidats.

en: Filters
fr: Filtres

en: Once you have a list of candidates you may use the following filtering types to further reduce the selection:
fr: Une fois qu'on a une liste de candidats on peut utiliser les types de filtres suivants pour réduire la sélection :

en: `"foo"` Strings will filter on substring occurrence within file name (minus directory path and extension).
fr: `"foo"` : les chaînes vont filtrer sur les occurrences de sous-chaîne dans le nom du fichier (moins le chemin du dossier et l'extension).

en: `/fo[oO]/` Regular Expressions will filter on pattern matching of file name (minus directory path and extension).
fr: `/fo[oO]/` : les expressions régulières filtrent sur des motifs du nom du fichier (moins le chemin du dossier et l'extension).

en: `:foo` - Keywords will filter candidates on whether the keyword is a direct match of the filename (minus directory path and extension).
fr: `:foo` : les mots-clefs filtrent les candidats si le mot-clef correspond exactement au nom du fichier (moins le chemin du dossier et l'extension).

en: `lambda{|a| ... }` - Procs with one argument will be treated as a candidate filter or generator function. It will be passed the list of current candidates and must return a new list of candidates (a list of valid paths to sample files).
fr: `lambda{|a| ... }` : les procédures avec un argument seront traitées comme un filtre de candidat ou une fonction génératrice. On lui passera la liste des candidats actuels et elle doit retourner une nouvelle liste de candidats (une liste de chemins valides vers des fichiers de samples).

en: `1` - Numbers will select the candidate with that index (wrapping round like a ring if necessary).
fr: `1` : Les nombres sélectionnent le candidat avec cet index (en bouclant comme un anneau si nécessaire).

en: For example, we can filter over all the samples in a directory containing the string `"foo"` and play the first matching sample at half speed:
fr: Par exemple on peut filtrer tous les samples d'un dossier qui contiennent la chaîne `"foo"` et jouer le premier sample correspondant deux fois moins vite :

en: See the help for `sample` for many detailed usage examples. Note that the ordering of the filters is honoured.
fr: Regardez l'aide pour `sample`, elle contient plusieurs exemples détaillés d'utilisation. Notez que l'ordre des filtres est respecté.

en: Finally, you may use lists wherever you may place a source or filter. The list will be automatically flattened and the contents will be treated as regular sources and filters. Therefore the following calls to `sample` are semantically equivalent:
fr: Enfin vous pouvez utiliser des listes partout où on peut placer une source ou un filtre. La liste sera automatiquement aplatie et son contenu sera traité comme des sources et filtres. Ainsi les appels suivants à `sample` sont sémantiquement équivalents :

en: Wrapping Up
fr: Résumé

en: This was an advanced section for people that need real power to manipulate and use sample packs. If most of this section didn't make too much sense, don't worry. It's likely you don't need any of this functionality just yet. However, you'll know when you do need it and you can come back and re-read this when you start working with large directories of samples.
fr: C'était une section avancée pour les gens qui ont besoin de vraie puissance pour manipuler et utiliser des paquets de samples. Si la plupart de cette section n'avait pas trop de sens pour vous, ne vous inquiétez pas. Vous n'avez probablement pas encore besoin de cette fonctionnalité. Mais vous vous rendrez compte quand vous en aurez besoin et vous pourrez revenir et relire ceci quand vous commencerez à travailler avec de grands dossiers de samples.

en: 4 Randomisation
fr: 4 Aléatoire

en: Randomisation
fr: Aléatoire

en: A great way to add some interest into your music is using some random numbers. Sonic Pi has some great functionality for adding randomness to your music, but before we start we need to learn a shocking truth: in Sonic Pi *random is not truly random*. What on earth does this mean? Well, let's see.
fr: Un grand moyen d'ajouter de l'intérêt à votre musique est d'utiliser des nombres aléatoires ("random"). Sonic Pi a des fonctions remarquables pour ajouter de l'aléatoire à votre musique, mais avant de commencer, nous devons apprendre une vérité choquante : dans Sonic Pi *l'aléatoire n'est pas vraiment aléatoire*. Qu'est-ce que cela signifie ? Eh bien, voyons-le.

en: Repeatability
fr: Répétabilité

en: A really useful random function is `rrand` which will give you a random value between two numbers - a *min* and a *max*. (`rrand` is short for ranged random). Let's try playing a random note:
fr: Une fonction vraiment utile est `rrand` qui vous donnera une valeur aléatoire comprise entre deux nombres : un *min* et un *max*. (`rrand` est l'abréviation de "ranged random"). Essayons de jouer une note aléatoire :

en: Ooh, it played a random note. It played note `83.7527`. A nice random note between 50 and 95. Woah, wait, did I just predict the exact random note you got too? Something fishy is going on here. Try running the code again. What? It chose `83.7527` again? That can't be random!
fr: Oh, une note aléatoire a été jouée. La note `83.7527 ` a été jouée. Une note aléatoire sympathique entre 50 et 95. Wow , attendez, est-ce que je viens juste de prédire exactement la note que vous avez obtenue ? Quelque chose de louche se passe ici. Essayez d'exécuter le code une nouvelle fois. Comment ? `83.7527` a encore été choisie ? Ce ne peut être aléatoire !

en: The answer is that it is not truly random, it's pseudo-random. Sonic Pi will give you random-like numbers in a repeatable manner. This is very useful for ensuring that the music you create on your machine sounds identical on everybody else's machine - even if you use some randomness in your composition.
fr: La réponse est que ce n'est pas vraiment aléatoire, c'est pseudo-aléatoire. Sonic Pi vous donne une suite d'un semblant de nombres aléatoires de manière reproductible. C'est très utile pour s'assurer que la musique que vous avez créée sur votre machine sonnera de façon identique sur n'importe quelle autre machine - même si vous utilisez de l'aléatoire dans votre composition.

en: Of course, in a given piece of music, if it 'randomly' chose `83.7527` every time, then it wouldn't be very interesting. However, it doesn't. Try the following:
fr: Bien sûr, dans un morceau de musique donné, si `83.7527 ` était choisi 'aléatoirement' à chaque fois, ce ne serait pas très intéressant. Ce n'est cependant pas le cas. Essayez ce qui suit :

en: Yes! It finally sounds random. Within a given *run* subsequent calls to random functions will return random values. However, the next run will produce exactly the same sequence of random values and sound exactly the same. It's as if all Sonic Pi code went back in time to exactly the same point every time the Run button was pressed. It's the Groundhog Day of music synthesis!
fr: Oui ! Ca sonne enfin aléatoire. A l'intérieur d'un *run* donné, des appels successifs à des fonction aléatoires retournent des valeurs aléatoires. Cependant, une nouvelle exécution produira exactement la même séquence de valeurs aléatoires et sonnera exactement pareil. C'est comme si tout le code de Sonic Pi revenait en arrière exactement au même point de départ chaque fois que le bouton "Run" était pressé. C'est le "Un jour sans fin" de la synthèse musicale !

en: Haunted Bells
fr: Cloches hantées

en: A lovely illustration of randomisation in action is the haunted bells example which loops the `:perc_bell` sample with a random rate and sleep time between bell sounds:
fr: Une agréable illustration de l'aléatoire en action est l'exemple des cloches hantées qui fait boucler l'échantillon `:perc_bell` avec une vitesse et un temps de repos aléatoires entre les sons de cloche :

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

en: Random cutoff
fr: Limite ("cutoff") aléatoire

en: Another fun example of randomisation is to modify the cutoff of a synth randomly. A great synth to try this out on is the `:tb303` emulator:
fr: Un autre exemple sympathique d'aléatoire est de modifier la limite d'un son de synthé aléatoirement. Un synthé super pour essayer cela est l'émulateur du `:tb303` :

en: Random seeds
fr: Tête de série aléatoire

en: So, what if you don't like this particular sequence of random numbers Sonic Pi provides? Well it's totally possible to choose a different starting point via `use_random_seed`. The default seed happens to be 0, so choose a different seed for a different random experience!
fr: Alors que faire si vous n'aimez pas cette particulière séquence de nombres aléatoires que fournit Sonic Pi ? Eh bien, c'est tout à fait possible de choisir un autre point de départ via `use_random_seed`. La tête de série par défaut est 0, aussi choisissez une autre tête de série pour une expérience aléatoire différente !

en: Consider the following:
fr: Envisagez ce qui suit :

en: Every time you run this code, you'll hear the same sequence of 5 notes. To get a different sequence simply change the seed:
fr: Chaque fois que vous exécuterez ce code, vous entendrez la même séquence de 5 notes. Pour obtenir une séquence différente, changez simplement la tête de série :

en: This will produce a different sequence of 5 notes. By changing the seed and listening to the results you can find something that you like - and when you share it with others, they will hear exactly what you heard too.
fr: Ceci va produire une séquence différente de 5 notes. En changeant le tête de série et en écoutant les résultats, vous pouvez trouver quelque chose que vous aimez - et quand vous le partagerez avec d'autres, ils entendront exactement ce que vous avez aussi entendu.

en: Let's have a look at some other useful random functions.
fr: Jetons un œil sur d'autres fonctions aléatoires utiles.

en: choose
fr: Choix ("choose")

en: A very common thing to do is to choose an item randomly from a list of known items. For example, I may want to play one note from the following: 60, 65 or 72. I can achieve this with `choose` which lets me choose an item from a list. First, I need to put my numbers in a list which is done by wrapping them in square brackets and separating them with commas: `[60, 65, 72]`. Next I just need to pass them to `choose`:
fr: Une chose très commune est de choisir un item aléatoirement dans une liste d'items connus. Par exemple, je peux vouloir jouer une note parmi les suivantes : 60, 65 ou 72. Je peux y arriver avec `choose` qui me choisit un item dans une liste. En premier, je dois mettre mes nombres dans une liste, ce qui est réalisé en les encadrant entre crochets et en les séparant avec des virgules : `[60, 65, 72]`. Ensuite, j'ai juste besoin de leur passer `choose` :

en: Let's hear what that sounds like:
fr: Écoutons comment cela sonne :

en: We've already seen `rrand`, but let's run over it again. It returns a random number between two values exclusively. That means it will never return either the top or bottom number - always something in between the two. The number will always be a float - meaning it's not a whole number but a fraction of a number. Examples of floats returned by `rrand(20, 110)`:
fr: Nous avons déjà vu `rrand`, mais examinons-le encore. Il retourne un nombre aléatoire entre deux valeurs exclues. Cela signifie qu'il ne retournera jamais soit la borne basse, soit la borne haute - toujours quelque chose entre les deux. Le nombre sera toujours un nombre flottant - ce qui signifie que ce n'est pas un nombre entier, mais une fraction de nombre. Exemple de flottants retournés par `rrand(20, 110)` :

en: Occasionally you'll want a whole random number, not a float. This is where `rrand_i` comes to the rescue. It works similarly to `rrand` except it may return the min and max values as potential random values (which means it's inclusive rather than exclusive of the range). Examples of numbers returned by `rrand_i(20, 110)` are:
fr: Occasionnellement, vous désirez un nombre entier aléatoire, pas un flottant. C'est là que `rrand_i` arrive à la rescousse. Il fonctionne de façon similaire à `rrand` sauf qu'il peut retourner potentiellement les valeurs minimales et maximales comme valeurs aléatoires (ce qui signifie que c'est inclusif plutôt qu'exclusif des bornes). Exemple de nombres retournés par `rrand_i(20, 110)` :

en: This will return a random float between 0 (inclusive) and the max value you specify (exclusive). By default it will return a value between 0 and one. It's therefore useful for choosing random `amp:` values:
fr: Cette fonction va retourner un flottant aléatoire entre 0 (inclus) et la valeur maximale que vous spécifiez (exclue). Par défaut, elle retourne une valeur entre 0 et 1. C'est par conséquent utile pour choisir une valeur de `amp:` aléatoire :

en: Similar to the relationship between `rrand_i` and `rrand`, `rand_i` will return a random whole number between 0 and the max value you specify.
fr: Similaire à la relation entre `rrand_i` et `rrand`, `rand_i` retournera un nombre entier compris entre 0 et la valeur maximale que vous spécifierez.

en: dice
fr: dice (dé)

en: Sometimes you want to emulate a dice throw - this is a special case of `rrand_i` where the lower value is always 1. A call to `dice` requires you to specify the number of sides on the dice. A standard dice has 6 sides, so `dice(6)` will act very similarly - returning values of either 1, 2, 3, 4, 5, or 6. However, just like fantasy role-play games, you might find value in a 4 sided dice, or a 12 sided dice, or a 20 sided dice - perhaps even a 120 sided dice!
fr: Quelquefois, vous souhaitez émuler un jet de dé - c'est un cas particulier de `rrand_i` où la valeur minimale est toujours 1. Un appel à `dice` nécessite que vous spécifiez le nombre de faces du dé. Un dé standard a 6 faces, donc `dice(6)` agira de manière très similaire - retournant l'une des valeurs 1, 2, 3, 4, 5, ou 6. Cependant, juste comme dans des jeux de rôle, vous pourriez trouver des dés à 4 faces, ou à 12 faces, peut-être même à 120 faces !

en: Finally you may wish to emulate throwing the top score of a dice such as a 6 in a standard dice. `one_in` therefore returns true with a probability of one in the number of sides on the dice. Therefore `one_in(6)` will return true with a probability of 1 in 6 or false otherwise. True and false values are very useful for `if` statements which we will cover in a subsequent section of this tutorial.
fr: Finalement, vous pouvez souhaiter simuler la chance que vous avez de tomber sur le nombre le plus élevé d'un dé, soit 6 pour un dé standard. Ainsi `one_in` retourne vrai ("true") avec une probabilité de 1 sur le nombre de faces du dé. Par conséquent `one_in(6)` retournera vrai avec une probabilité de 1 sur 6 ou faux ("false") autrement. Les valeurs `true` et `false` sont très utiles pour les ordres `if` que nous couvrirons dans une section suivante de ce tutoriel.

en: Now, go and jumble up your code with some randomness!
fr: Maintenant allez et introduisez de l'aléatoire dans votre code !

en: 5 Programming Structures
fr: 5 Structures de programmation

en: Programming Structures
fr: Structures de programmation

en: Now that you've learned the basics of creating sounds with `play` and `sample` and creating simple melodies and rhythms by `sleep`ing between sounds, you might be wondering what else the world of code can offer you...
fr: Maintenant que vous avez appris les bases de la création des sons avec `play` et `sample` et la création de mélodies simples et de rythmes en utilisant `sleep` entre les sons, vous vous demandez peut-être ce que le monde du code peut vous offrir en plus...

en: Well, you're in for an exciting treat! It turns out that basic programming structures such as looping, conditionals, functions and threads give you amazingly powerful tools to express your musical ideas.
fr: Eh bien, vous êtes prêts pour un voyage passionnant ! Il ressort que les structures de programmation de base telles les boucles, les conditionnels, les fonctions et les fils ("threads") vont vous procurer des outils puissants et étonnants pour exprimer vos idées musicales.

en: Let's get stuck in with the basics...
fr: Plongeons dans les bases...

en: 5.1 Blocks
fr: 5.1 Blocs

en: Blocks
fr: Blocs

en: A structure you'll see a lot in Sonic Pi is the block. Blocks allow us to do useful things with large chunks of code. For example, with synth and sample parameters we were able to change something that happened on a single line. However, sometimes we want to do something meaningful to a number of lines of code. For example, we may wish to loop it, to add reverb to it, to only run it 1 time out of 5, etc. Consider the following code:
fr: Une structure que vous verrez souvent dans Sonic Pi est le bloc. Les blocs vous permettent de faire des choses utiles avec de grands morceaux de code. Par exemple, avec les paramètres des synthés et des échantillons, nous sommes capables de changer quelque chose qui se passe sur une seule ligne. Cependant, nous souhaitons parfois faire quelque chose de significatif sur un certain nombre de lignes de code. Par exemple, nous souhaiterions les faire boucler, leur ajouter de la réverbération, les exécuter seulement une fois sur 5, etc. Considérez le code suivant :

en: To do something with a chunk of code, we need to tell Sonic Pi where the code block *starts* and where it *ends*. We use `do` for start and `end` for end. For example:
fr: Pour faire quelque chose avec un morceau de code, nous devons dire à Sonic Pi où *commence* le bloc et où il *finit*. Nous utilisons `do` pour le début et `end` pour la fin. Par exemple :

en: However, this isn't yet complete and won't work (try it and you'll get an error) as we haven't told Sonic Pi what we want to do with this *do/end block*. We tell Sonic Pi this by writing some special code before the `do`. We'll see a number of these special pieces of code later on in this tutorial. For now, it's important to know that wrapping your code within `do` and `end` tells Sonic Pi you wish to do something special with that chunk of code.
fr: Toutefois, ce n'est pas encore complet et ne fonctionnera pas (essayez-le et vous obtiendrez une erreur) puisque nous n'avons pas dit à Sonic Pi ce que nous voulions faire avec ce *bloc do/end*. On le dit à Sonic Pi en écrivant du code spécial avant le `do`. Nous verrons un certain nombre de ces bouts de code spéciaux plus tard dans ce tutoriel. Pour l'instant, il est important de savoir que d'encadrer votre code entre `do` et `end` dit à Sonic Pi que vous voulez faire quelque chose de spécial avec ce morceau de code.

en: 5.2 Iteration and Loops
fr: 5.2 Itérations et boucles

en: Iteration and Loops
fr: Itérations et boucles

en: So far we've spent a lot of time looking at the different sounds you can make with `play` and `sample` blocks. We've also learned how to trigger these sounds through time using `sleep`.
fr: Jusqu'à maintenant nous avons passé beaucoup de temps à rechercher les différents sons que vous pouvez faire avec des blocs de `play` et de `sample`. Nous avons aussi appris comment déclencher ces sons dans le temps en utilisant `sleep`.

en: As you've probably found out, there's a *lot* of fun you can have with these basic building blocks. However, a whole new dimension of fun opens up when you start using the power of code to structure your music and compositions. In the next few sections we'll explore some of these powerful new tools. First up is iteration and loops.
fr: Comme vous vous en êtes probablement rendu compte, on peut prendre *beaucoup* de plaisir avec la construction de ces blocs de base. Toutefois, une dimension totalement nouvelle de plaisir se découvre quand on commence à utiliser la puissance du code pour structurer sa musique et ses compositions. Dans les quelques sections suivantes, nous allons explorer quelques uns de ces nouveaux outils puissants. En premier, découvrons l'itération et les boucles.

en: Repetition
fr: Répétition

en: Have you written some code you'd like to repeat a few times? For example, you might have something like this:
fr: Avez-vous écrit du code que vous aimeriez répéter quelques fois ? Par exemple, vous pourriez avoir quelque chose comme ceci :

en: What if we wished to repeat this 3 times? Well, we could do something simple and just copy and paste it three times:
fr: Et si nous voulons répéter ceci 3 fois ? Eh bien, nous pourrions faire simple et juste le copier et le coller trois fois :

en: Now that's a lot of code! What happens if you want to change the sample to `:elec_plip`? You're going to have to find all the places with the original `:elec_blup` and switch them over. More importantly, what if you wanted to repeat the original piece of code 50 times or 1000? Now that would be a lot of code, and a lot of lines of code to alter if you wanted to make a change.
fr: Maintenant, ça fait beaucoup de code ! Que se passe-t-il si nous voulions changer l'échantillon en `:elec_plip` ? Vous aller devoir trouver tous les endroits avec l'original `:elec_blup` et les modifier un par un. De façon plus importante, que faire si vous voulez répéter le bout de code original 50 fois ou 1000 fois ? Ça ferait alors vraiment beaucoup de code, et beaucoup de lignes de code à modifier si vous vouliez faire un changement.

en: Iteration
fr: Itération

en: In fact, repeating the code should be as easy as saying *do this three times*. Well, it pretty much is. Remember our old friend the code block? We can use it to mark the start and end of the code we'd like to repeat three times. We then use the special code `3.times`. So, instead of writing *do this three times*, we write `3.times do` - that's not too hard. Just remember to write `end` at the end of the code you'd like to repeat:
fr: En fait, répéter le code devrait être aussi facile que de dire *fais ceci trois fois*. Eh bien, c'est presque cela. Souvenez-vous de notre vieil ami le bloc de code. Nous pouvons l'utiliser pour marquer le début et la fin du code que nous aimerions répéter trois fois. Nous utilisons alors le code spécial `3.times`. Ainsi, à la place d'écrire *fais cela trois fois*, nous écrivons `3.times do` - ce n'est pas trop dur. Rappelez-vous juste d'écrire `end` à la fin du code que vous devez répéter :

en: Now isn't that much neater than cutting and pasting! We can use this to create lots of nice repeating structures:
fr: Alors, est-ce que ce n'est pas plus propre que de copier-coller ! Nous pouvons l'utiliser pour créer beaucoup de chouettes structures répétitives :

en: Nesting Iterations
fr: Imbrication d'itérations

en: We can put iterations inside other iterations to create interesting patterns. For example:
fr: Nous pouvons mettre des itérations à l'intérieur d'autres itérations pour créer des motifs intéressants. Par exemple :

en: Looping
fr: Boucles

en: If you want something to repeat a lot of times, you might find yourself using really large numbers such as `1000.times do`. In this case, you're probably better off asking Sonic Pi to repeat forever (at least until you press the stop button!). Let's loop the amen break forever:
fr: Si vous voulez répéter quelque chose un grand nombre de fois, vous pourriez vous trouvez en situation d'utiliser des nombres vraiment grands comme `1000.times do`. Dans ce cas, vous feriez probablement mieux de demander à Sonic Pi de répéter à l'infini (au moins jusqu'à ce que vous pressiez le bouton stop !). Bouclons l'échantillon break amen à l'infini :

en: The important thing to know about loops is that they act like black holes for code. Once the code enters a loop it can never leave until you press stop - it will just go round and round the loop forever. This means if you have code after the loop you will *never* hear it. For example, the cymbal after this loop will never play:
fr: La chose importante à savoir à propos des boucles est qu'elles se comportent comme des trous noirs pour le code. Une fois que le code est entré dans une boucle, il ne peut pas en sortir tant que vous n'avez pas pressé stop - il va juste tourner en rond dans la boucle à jamais. Ce qui signifie que si vous avez du code après la boucle, vous ne l'entendrez *jamais*. Par exemple, la cymbale suivant cette boucle ne sera jamais jouée :

en: Now, get structuring your code with iteration and loops!
fr: Maintenant, structurez votre code avec des itérations et des boucles !

en: 5.3 Conditionals
fr: 5.3 Conditionnels

en: Conditionals
fr: Conditionnels

en: A common thing you'll likely find yourself wanting to do is to not only play a random note (see the previous section on randomness) but also make a random decision and based on the outcome run some code or some other code. For example, you might want to randomly play a drum or a cymbal. We can achieve this with an `if` statement.
fr: Une situation commune dans laquelle vous vous trouverez probablement est de non seulement jouer une note aléatoire (voir la précédente section sur l'aléatoire) mais de prendre une décision aléatoire et en fonction du résultat exécuter un code ou un autre. Par exemple, vous pourriez vouloir jouer aléatoirement un tambour ou une cymbale. Nous pouvons y parvenir avec un ordre `if` (si).

en: Flipping a Coin
fr: Pile ou face

en: So, let's flip a coin: if it's heads, play a drum, if it's tails, play a cymbal. Easy. We can emulate a coin flip with our `one_in` function (introduced in the section on randomness) specifying a probability of 1 in 2: `one_in(2)`. We can then use the result of this to decide between two pieces of code, the code to play the drum and the code to play the cymbal:
fr: Ainsi, faisons sauter une pièce : si c'est pile, joue un tambour, si c'est face, joue une cymbale. Facile. Nous pouvons émuler le saut d'une pièce avec notre fonction `one_in` (introduite dans la section traitant de l'aléatoire) en spécifiant une probabilité de 1 sur 2 : `one_in(2)`. Nous pouvons alors en utiliser le résultat pour décider entre deux bouts de code, le code pour jouer le tambour et le code pour jouer la cymbale :

en: Notice that `if` statements have three parts:
fr: Notez que les ordres `if` ont trois parties :

en: The question to ask
fr: La question à poser

en: The first choice of code to run (if the answer to the question is yes)
fr: Le premier choix de code à exécuter (si la réponse à la question est oui)

en: The second choice of code to run (if the answer to the question is no)
fr: Le second choix de code à exécuter (si la réponse à la question est non)

en: Typically in programming languages, the notion of yes is represented by the term `true` and the notion of no is represented by the term `false`. So we need to find a question that will give us a `true` or `false` answer which is exactly what `one_in` does.
fr: Typiquement, dans les langages de programmation, la notion de oui est représenté par le terme `true` (vrai) et la notion de non par le terme `false` (faux). Nous avons donc besoin de trouver une question qui nous donnera une réponse `true` ("vraie") ou `false` ("fausse"), ce qui est exactement ce que fait `one_in`.

en: Notice how the first choice is wrapped between the `if` and the `else` and the second choice is wrapped between the `else` and the `end`. Just like do/end blocks you can put multiple lines of code in either place. For example:
fr: Notez comment le premier choix est encadré entre le `if` et le `else`, et le second choix est encadré entre le `else` et le `end`. Exactement comme pour les blocs do/end, vous pouvez mettre plusieurs lignes dans chacun de ces endroits. Par exemple :

en: This time we're sleeping for a different amount of time depending on which choice we make.
fr: Cette fois nous "dormons" pour une durée différente en fonction du choix qui est fait.

en: Simple if
fr: If simple

en: Sometimes you want to optionally execute just one line of code. This is possible by placing `if` and then the question at the end. For example:
fr: Quelquefois, nous voulons exécuter seulement une ligne de code de manière optionnelle. C'est possible en plaçant `if` à la fin et la question à la suite. Par exemple :

en: This will play chords of different numbers with the chance of each note playing having a different probability.
fr: Ceci va jouer des accords de différents nombres avec la chance pour chaque note d'être jouée avec une probabilité différente.

en: So you've made your killer bassline and a phat beat. How do you play them at the same time? One solution is to weave them together manually - play some bass, then a bit of drums, then more bass... However, the timing soon gets hard to think about, especially when you start weaving in more elements.
fr: ("Thread" = terme technique intraduisible et dont la traduction la plus proche est "fil".) Ainsi vous avez fait votre ligne de basse géniale et un super motif de batterie. Comment les jouer en même temps ? Une solution est de les intercaler manuellement - jouer un peu de basse, puis quelques sons de batterie, puis encore un peu de basse... Cependant, la synchronisation devient rapidement dure à concevoir, en particulier quand vous commencez à intercaler plus d'éléments.

en: What if Sonic Pi could weave things for you automatically? Well, it can, and you do it with a special thing called a *thread*.
fr: Et si Sonic Pi pouvait vous synchroniser les choses automatiquement ? Eh bien, il le peut, et ça se fait avec une chose spéciale appelée *thread*.

en: Infinite Loops
fr: Boucles infinies

en: To keep this example simple, you'll have to imagine that this is a phat beat and a killer bassline:
fr: Pour garder cet exemple simple, vous devez imaginer que ceci est un super motif de batterie et une ligne de basse géniale :

en: As we've discussed previously, loops are like *black holes* for the program. Once you enter a loop you can never exit from it until you hit stop. How do we play both loops at the same time? We have to tell Sonic Pi that we want to start something at the same time as the rest of the code. This is where threads come to the rescue.
fr: Comme nous en avons parlé précédemment, les boucles sont comme des *trous noirs* pour un programme. Dès que vous êtes entré dans une boucle, vous ne pouvez jamais en sortir à moins de presser stop. Comment pouvons-nous jouer les deux boucles en même temps ? Nous devons dire à Sonic Pi que nous voulons démarrer quelque chose en même temps que le reste du code. C'est là que les threads arrivent à la rescousse.

en: Threads to the Rescue
fr: Threads à la rescousse

en: By wrapping the first loop in an `in_thread` do/end block we tell Sonic Pi to run the contents of the do/end block at *exactly* the same time as the next statement after the do/end block (which happens to be the second loop). Try it and you'll hear both the drums and the bassline weaved together!
fr: En encadrant la première boucle dans un bloc do/end `in_thread`, nous disons à Sonic Pi d'exécuter le contenu du bloc do/end *exactement* en même temps que l'ordre suivant le bloc do/end (qui se trouve être la seconde boucle). Essayez-le et vous entendrez à la fois la batterie et la ligne de basse synchronisées !

en: Now, what if we wanted to add a synth on top. Something like:
fr: Maintenant, que faire si nous voulons ajouter un synthé par-dessus. Quelque chose comme :

en: Now we have the same problem as before. The first loop is played at the same time as the second loop due to the `in_thread`. However, *the third loop is never reached*. We therefore need another thread:
fr: Maintenant, nous avons le même problème qu'avant. La première boucle est jouée en même temps que la seconde grâce au `in_thread`. Toutefois, *la troisième boucle n'est jamais atteinte*. Nous avons donc besoin d'un nouveau thread :

en: Runs as threads
fr: Les exécutions sont des threads

en: What may surprise you is that when you press the Run button, you're actually creating a new thread for the code to run. This is why pressing it multiple times will layer sounds over each other. As the runs themselves are threads, they will automatically weave the sounds together for you.
fr: Ce qui peut vous surprendre est que quand vous pressez le bouton Run, vous êtes réellement en train de créer un nouveau thread pour l'exécution du code. C'est pour cela qu'en le pressant de multiples fois, vous superposerez des couches de sons les unes sur les autres. Comme les "runs" sont eux-même des threads, ils intercaleront les sons automatiquement pour vous.

en: Scope
fr: Portée

en: As you learn how to master Sonic Pi, you'll learn that threads are the most important building blocks for your music. One of the important jobs they have is to isolate the notion of *current settings* from other threads. What does this mean? Well, when you switch synths using `use_synth` you're actually just switching the synth in the *current thread* - no other thread will have their synth switched. Let's see this in action:
fr: Etudiant comment maîtriser Sonic Pi, vous apprendrez que les threads sont les composants les plus importants de votre musique. L'une des responsabilités importantes qu'ils ont est d'isoler la notion de *paramètres courants* vis à vis des autres threads. Qu'est-ce que cela signifie ? Eh bien, quand vous commutez les synthés avec `use_synth`, vous ne commutez réellement que le synthé dans le *thread courant* - aucun autre thread n'aura son synthé commuté. Voyons cela en action :

en: Notice how the middle sound was different to the others? The `use_synth` statement only affected the thread it was in and not the outer main run thread.
fr: Avez-vous remarqué que le son du milieu était différent des autres ? L'ordre `use_synth` affecte uniquement le thread dans lequel il était et pas le thread extérieur principal.

en: Inheritance
fr: Héritage

en: When you create a new thread with `in_thread`, the new thread will automatically inherit all of the current settings from the current thread. Let's see that:
fr: Quand vous créez un nouveau thread avec `in_thread`, le nouveau thread hérite automatiquement de tous les paramètres courants du thread courant. Voyons cela :

en: Notice how the second note is played with the `:tb303` synth even though it was played from a separate thread? Any of the settings modified with the various `use_*` functions will behave in the same way.
fr: Notez que la seconde note est jouée avec le synthé `:tb303` bien qu'elle soit jouée depuis un thread distinct. Chacun des paramètres modifiés avec les différentes fonctions `use_*` se comportera exactement de la même manière.

en: When threads are created, they inherit all the settings from their parent but they don't share any changes back.
fr: Quand les threads sont créés, ils héritent de tous les paramètres de leur parent mais par la suite ils ne partagent plus aucun changement avec leur parent.

en: Naming Threads
fr: Nommage des threads

en: Finally, we can give our threads names:
fr: Enfin nous pouvons donner des noms à nos threads :

en: Look at the log pane when you run this code. See how the log reports the name of the thread with the message?
fr: Regardez le panneau "trace" quand vous exécutez ce code. Voyez-vous comment la "trace" rapporte le nom du thread avec le message ?

en: Only One Thread per Name Allowed
fr: Seulement un thread autorisé par nom

en: One last thing to know about named threads is that only one thread of a given name may be running at the same time. Let's explore this. Consider the following code:
fr: Une dernière chose à savoir au sujet des threads nommés est que seul un thread d'un nom donné peut être en cours d'exécution au même moment. Explorons ceci. Considérez le code suivant :

en: Go ahead and paste that into a buffer and press the Run button. Press it again a couple of times. Listen to the cacophony of multiple amen breaks looping out of time with each other. Ok, you can press Stop now.
fr: Allez-y et collez cela dans un tampon puis pressez le bouton "Exécuter". Pressez-le encore quelques fois. Écoutez la cacophonie des breaks amen multiples qui bouclent les uns sur les autres de façon désynchronisée. D'accord, vous pouvez maintenant presser "Arrêter".

en: This is the behaviour we've seen again and again - if you press the Run button, sound layers on top of any existing sound. Therefore if you have a loop and press the Run button three times, you'll have three layers of loops playing simultaneously.
fr: C'est le comportement que nous avons vu encore et encore - si vous pressez le bouton "Run", le son s'étend au dessus de tout son existant. Donc, si vous avez une boucle et que vous pressez le bouton "Run" trois fois, vous aurez trois couches de boucles jouant simultanément.

en: However, with named threads it is different:
fr: Cependant, avec les threads nommés, c'est différent :

en: Try pressing the Run button multiple times with this code. You'll only ever hear one amen break loop. You'll also see this in the log:
fr: Essayez de presser le bouton "Run" plusieurs fois avec ce code. Vous n'entendrez qu'une boucle du break amen. Vous allez aussi voir ceci dans la trace :

en: ==> Skipping thread creation: thread with name :amen already exists.
fr: ==> Sautant la création d'un thread : le thread avec le nom :amen existe déjà.

en: Sonic Pi is telling you that a thread with the name `:amen` is already playing, so it's not creating another.
fr: Sonic Pi vous dit qu'un thread avec le nom `:amen` est déjà en train d'être joué, donc il ne va pas en créer un autre.

en: This behaviour may not seem immediately useful to you now - but it will be very handy when we start to live code...
fr: Ce comportement peut ne pas vous sembler utile immédiatement - mais il sera très pratique quand nous commencerons à coder en "live"...

en: 5.5 Functions
fr: 5.5 Fonctions

en: Functions
fr: Fonctions

en: Once you start writing lots of code, you may wish to find a way to organise and structure things to make them tidier and easier to understand. Functions are a very powerful way to do this. They give us the ability to give a name to a bunch of code. Let's take a look.
fr: Une fois que vous commencez à écrire beaucoup de code, vous pouvez souhaiter trouver le moyen d'organiser et de structurer les choses pour les rendre plus ordonnées et faciles à comprendre. Les fonctions sont un moyen très puissant pour le faire. Elles vous donnent la capacité de donner un nom à un morceau de code. Jetons-y un œil.

en: Defining functions
fr: Definition des fonctions

en: Here, we've defined a new function called `foo`. We do this with our old friend the do/end block and the magic word `define` followed by the name we wish to give to our function. We didn't have to call it `foo`, we could have called it anything we want such as `bar`, `baz` or ideally something meaningful to you like `main_section` or `lead_riff`.
fr: Ici, nous avons défini une nouvelle fonction appelée `foo`. Nous faisons cela avec notre vieil ami, le bloc do/end et le mot magique `define` suivi par le nom que nous voulons donner à notre fonction. Nous ne sommes pas tenus de l'appeler `foo`, nous aurions pu l'appeler avec n'importe quel nom que nous voulions, comme `bar`, `baz` ou idéalement quelque chose de significatif pour vous comme `section_principale` ou `lead_riff`.

en: Remember to prepend a colon `:` to the name of your function when you define it. Function names should also start with a lower case letter, so use `:foo` rather than `:Foo`.
fr: Rappelez-vous d'ajouter un deux-points `:` devant le nom de votre fonction quand vous la définissez. Les noms de fonctions devraient également commencer par une lettre minuscule, donc utilisez `:foo` plutôt que `:Foo`.

en: Calling functions
fr: Appel des fonctions

en: Once we have defined our function we can call it by just writing its name:
fr: Une fois que nous avons défini notre fonction, nous pouvons l'appeler simplement en écrivant son nom :

en: We can even use `foo` inside iteration blocks or anywhere we may have written `play` or `sample`. This gives us a great way to express ourselves and to create new meaningful words for use in our compositions.
fr: Nous pouvons même utiliser `foo` à l'intérieur de blocs d'itération ou n'importe où nous aurions pu écrire `play` ou `sample`. Ceci nous donne un super moyen de nous exprimer et de créer de nouveaux mots significatifs à utiliser dans nos compositions.

en: Functions are remembered across runs
fr: Les fonctions sont mémorisées d'une exécution à l'autre

en: So far, every time you've pressed the Run button, Sonic Pi has started from a completely blank slate. It knows nothing except for what is in the buffer. You can't reference code in another buffer or another thread. However, functions change that. When you define a function, Sonic Pi *remembers* it. Let's try it. Delete all the code in your buffer and replace it with:
fr: Pour le moment, chaque fois que nous avons pressé le bouton Run, Sonic Pi a démarré d'un état complètement vierge. Il ne connait rien à part ce qui est dans le buffer. Vous ne pouvez pas référencer du code d'un autre buffer ou d'un autre thread. Toutefois, les fonctions changent cela. Quand vous définissez une fonction, Sonic Pi s'en *rappelle*. Essayons-le. Effacez tout le code dans votre buffer et remplacez-le par :

en: Press the Run button - and hear your function play. Where did the code go? How did Sonic Pi know what to play? Sonic Pi just remembered your function - so even after you deleted it from the buffer, it remembered what you had typed. This behaviour only works with functions created using `define` (and `defonce`).
fr: Pressez le bouton Run et écoutez votre fonction qui est jouée. Où le code est-il allé ? Comment Sonic Pi sait-il quoi jouer ? Sonic Pi s'est simplement souvenu de votre fonction - ainsi, même après l'avoir effacée de votre buffer, il se rappelle de ce que vous avez tapé. Ce comportement fonctionne uniquement avec les fonctions créées en utilisant `define` (et `defonce`).

en: Parameterised functions
fr: Fonctions paramétrées

en: You might be interested in knowing that just like you can pass min and max values to `rrand`, you can teach your functions to accept arguments. Let's take a look:
fr: Vous pourriez être intéressé à savoir que juste comme vous pouvez passer les valeurs min et max à `rrand`, vous pouvez apprendre à vos fonctions à accepter des arguments. Jetons-y un œil :

en: This isn't very exciting, but it illustrates the point. We've created our own version of `play` called `my_player` which is parameterised.
fr: Ce n'est pas très excitant, mais ça illustre le point. Nous avons créé notre propre version de `play` appelée `my_player` et qui est paramétrée.

en: The parameters need to go after the `do` of the `define` do/end block, surrounded by vertical goalposts `|` and separated by commas `,`. You may use any words you want for the parameter names.
fr: Les paramètres doivent être placés après le `do` du bloc do/end de `define`, entourés par des barres verticales `|` et séparés par des virgules `,`. Vous pouvez utiliser le mot de votre choix pour les noms de paramètres.

en: The magic happens inside the `define` do/end block. You may use the parameter names as if they were real values. In this example I'm playing note `n`. You can consider the parameters as a kind of promise that when the code runs, they will be replaced with actual values. You do this by passing a parameter to the function when you call it. I do this with `my_player 80` to play note 80. Inside the function definition, `n` is now replaced with 80, so `play n` turns into `play 80`. When I call it again with `my_player 90`, `n` is now replaced with 90, so `play n` turns into `play 90`.
fr: La magie se passe à l'intérieur du bloc do/end de `define`. Vous pouvez utiliser les noms de paramètres comme si c'étaient des valeurs réelles. Dans cet exemple, je joue la note `n`. Vous pouvez considérer les paramètres comme une sorte de promesse qui fait que, lorsque le code s'exécute, ils sont remplacés par des valeurs réelles. Vous faites ceci en passant un argument à la fonction quand vous l'appelez. Je le fais avec `my_player 80` pour jouer la note 80. À l'intérieur de la définition de la fonction, `n` est alors remplacé par 80, donc `play n` est changé en `play 80`. Quand je l'appelle une nouvelle fois avec `my_player 90`, `n` est alors remplacé par 90, donc `play n` est changé en `play 90`.

en: Let's see a more interesting example:
fr: Voyons un exemple plus intéressant :

en: Here I used `repeats` as if it was a number in the line `repeats.times do`. I also used `root` as if it was a note name in my call to `play`.
fr: Ici j'ai utilisé `repeats` comme si c'était un nombre dans la ligne `repeats.times do`. J'ai aussi utilisé `root` comme si c'était un nom de note dans mon appel à `play`.

en: See how we're able to write something very expressive and easy to read by moving a lot of our logic into a function!
fr: Voyez comme nous sommes capables d'écrire quelque chose de très expressif et facile à lire en déplaçant beaucoup de notre logique à l'intérieur d'une fonction !

en: A useful thing to do in your code is to create names for things. Sonic Pi makes this very easy: you write the name you wish to use, an equal sign (`=`), then the thing you want to remember:
fr: Une chose utile à faire dans votre code est d'attribuer des noms aux choses. Sonic Pi rend cela très facile : vous écrivez le nom que vous voulez utiliser, un signe égal (`=`), puis la chose dont vous voulez vous rappeler :

en: Here, we've 'remembered' the symbol `:loop_amen` in the variable `sample_name`. We can now use `sample_name` everywhere we might have used `:loop_amen`. For example:
fr: Ici, nous nous sommes 'rappelés' du symbole `:loop_amen` dans la variable `sample_name`. Nous pouvons maintenant utiliser `sample_name` partout où nous aurions utilisé `:loop_amen`. Par exemple :

en: There are three main reasons for using variables in Sonic Pi: communicating meaning, managing repetition and capturing the results of things.
fr: Il y a trois raisons principales pour utiliser des variables dans Sonic Pi : communication de la signification, gestion de la répétition et capture des résultats des choses.

en: Communicating Meaning
fr: Communication de la signification

en: 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!
fr: Quand vous écrivez du code, c'est facile de ne penser qu'à dire à l'ordinateur comment faire le boulot - tant que l'ordinateur comprend, c'est OK. Toutefois, il est important de se rappeler qu'il n'y a pas que l'ordinateur qui lit le code. D'autres personnes peuvent aussi le lire et essayer de comprendre ce qu'il fait. En outre, il est probable que vous ayez à lire votre propre code dans le futur et à essayer de comprendre ce qui s'y passe. Bien que cela puisse vous sembler évident maintenant, ce pourrait ne pas être si évident pour les autres et pour vous-même dans le futur !

en: One way to help others understand what your code is doing is to write comments (as we saw in a previous section). Another is to use meaningful variable names. Look at this code:
fr: Un moyen d'aider les autres à comprendre ce que fait votre code est d'écrire des commentaires (comme nous l'avons vu dans une section précédente). Une autre façon est d'utiliser des noms de variables significatifs. Regardez ce code :

en: Why does it use the number `1.7533`? Where did this number come from? What does it mean? However, look at this code:
fr: Pourquoi utilise-t-il le nombre `1.7533` ? D'où est-il venu ? Qu'est-ce que cela signifie ? En revanche, regardez ce code :

en: Now, it's much clearer what `1.7533` means: it's the duration of the sample `:loop_amen`! Of course, you might say why not simply write:
fr: Maintenant, il est beaucoup plus clair que `1.7533` signifie la durée de l'échantillon `:loop_amen` ! Bien sûr, vous pourriez dire pourquoi ne pas simplement écrire :

en: Which, of course, is a very nice way of communicating the intent of the code.
fr: Qui, bien entendu, est un moyen très sympathique de communiquer l'intention du code.

en: Managing Repetition
fr: Gestion de la répétition

en: Often you see a lot of repetition in your code and when you want to change things, you have to change it in a lot of places. Take a look at this code:
fr: Vous voyez souvent beaucoup de répétitions dans votre code et quand vous voulez changer les choses, vous devez les changer à beaucoup d'endroits. Jetez un œil à ce code :

en: We're doing a lot of things with `:loop_amen`! What if we wanted to hear what it sounded like with another loop sample such as `:loop_garzul`? We'd have to find and replace all `:loop_amen`s with `:loop_garzul`. That might be fine if you have lots of time - but what if you're performing on stage? Sometimes you don't have the luxury of time - especially if you want to keep people dancing.
fr: Nous sommes en train de faire beaucoup de choses avec `:loop_amen` ! Que faire si nous voulons écouter comment ça sonne avec un autre échantillon tel que `:loop_garzul` ? Nous aurons à trouver et remplacer tous les `:loop_amen` par `:loop_garzul`. Ce ne serait pas grave si vous disposiez de beaucoup de temps - mais que faire si vous œuvrez sur scène ? Quelquefois, vous n'aurez pas le luxe de temps disponible - en particulier si vous voulez que les gens continuent à danser.

en: What if you'd written your code like this:
fr: Et si vous aviez écrit votre code comme ceci :

en: Now, that does exactly the same as above (try it). It also gives us the ability to just change one line `sample_name = :loop_amen` to `sample_name = :loop_garzul` and we change it in many places through the magic of variables.
fr: Maintenant, ça fait exactement la même chose qu'au dessus (essayez-le). Ça nous procure aussi la capacité de changer juste une ligne : `sample_name = :loop_amen` en `sample_name = :loop_garzul` et la magie des variables nous le change dans beaucoup d'endroits.

en: Capturing Results
fr: Capture des résultats

en: Finally, a good motivation for using variables is to capture the results of things. For example, you may wish to do things with the duration of a sample:
fr: Finalement, une bonne motivation pour utiliser des variables est de capturer les résultats des choses. Par exemple, vous pouvez vouloir faire des choses avec la durée d'un échantillon :

en: We can now use `sd` anywhere we need the duration of the `:loop_amen` sample.
fr: Nous pouvons maintenant utiliser `sd` partout où nous avons besoin de la durée de l'échantillon `:loop_amen`.

en: Perhaps more importantly, a variable allows us to capture the result of a call to `play` or `sample`:
fr: Plus important peut-être, une variable nous permet de capturer le résultat d'un appel à `play` ou `sample` :

en: Now we have caught and remembered `s` as a variable, which allows us to control the synth as it is running:
fr: Maintenant, nous avons capturé et mémorisé `s` comme une variable, ce qui nous permet de contrôler le synthé pendant qu'il est actif :

en: We'll look into controlling synths in more detail in a later section.
fr: Nous verrons le contrôle des synthés plus en détail dans une prochaine section.

en: Warning: Variables and Threads
fr: Avertissement : variables et fils

en: Whilst variables are great for giving things names and capturing the results of things, it is important to know that they should typically only be used locally within a thread. For example, *don't do this*:
fr: Tandis que les variables sont géniales pour donner des noms et capturer les résultats des choses, il est important de savoir qu'elles ne doivent généralement être utilisées que localement au sein d'un fil d’exécution. Par exemple, *ne faites pas ceci* :

en: In the above example we assign a ring of numbers to a variable `a` and then used it within two separate `live_loop`s. In the first live loop every `0.5`s we sort the ring (to `(ring 1, 2, 3, 4, 5, 6)`) and then print it out to the log. If you run the code, you'll find that the printed list *is not always sorted!*. This may surprise you - especially that sometimes the list is printed as sorted, and sometimes it is not. This is called non-deterministic behaviour and is the result of a rather nasty problem called a race-condition. The problem is due to the fact that the second live loop is also manipulating the list (in this case shuffling it) and by the time the list is printed, sometimes it has just been sorted and sometimes it has just been shuffled. Both live loops are racing to do something different to the same variable and every time round a different loop 'wins'.
fr: Dans l'exemple ci-dessus, nous avons assigné un anneau de nombres à la variable `a` et nous l'avons utilisé dans deux `live_loop` séparées. Dans la première boucle en direct, toutes les `0.5`s, nous trions l'anneau (à `(ring 1, 2, 3, 4, 5, 6)`) et nous l'inscrivons dans le journal. Si vous exécutez le code, vous remarquerez que la liste imprimée *n'est pas toujours triée !*. Cela peut vous surprendre - surtout que des fois la liste est imprimée de façon triée, et d'autres fois non. Ceci s'appelle un comportement non-déterministe et est le résultat d'un méchant problème qui s'appelle la concurrence (NdT : `race-condition`). Le problème est dû au fait que la deuxième boucle en direct manipule également la liste (pour la mélanger dans ce cas) et, au moment où la liste est imprimée, parfois elle vient d'être triée, et d'autres fois, elle vient d'être mélangée. Les deux boucles en direct se font concurrence pour faire une manipulation différente à la même variable et, à chaque itération, une boucle différente "gagne".

en: There are two solutions to this. Firstly, *don't use the same variable in multiple live loops or threads*. For example, the following code will always print a sorted list as each live loop has its own separate variable:
fr: Il y a deux solutions à cela. Premièrement, *n'utilisez pas la même variable dans de multiples boucles en direct ou fil d'exécution*. Par exemple, le code suivant imprimera toujours une liste triée puisque chaque boucle en direct possède ses propres variables séparées :

en: However, sometimes we do want to share things across threads. For example, the current key, BPM, synth etc. In these cases, the solution is to use Sonic Pi's special thread-safe state system via the fns `get` and `set`. This is discussed later on in section 10.
fr: Par contre, parfois nous voulons partager des éléments entre plusieurs fils d'exécution. Par exemple, la clé courante, BPM, synthé etc. Dans ces cas, la solution est d'utiliser le système d'état de fil d'exécution sécurisé spécial de Sonic Pi par les fonctions `get` et `set`. Nous en reparlons dans la section 10.

en: 5.7 Thread Synchronisation
fr: 5.7 Synchronisation des threads

en: Thread Synchronisation
fr: Synchronisation des threads

en: Once you have become sufficiently advanced live coding with a number of functions and threads simultaneously, you've probably noticed that it's pretty easy to make a mistake in one of the threads which kills it. That's no big deal, because you can easily restart the thread by hitting Run. However, when you restart the thread it is now *out of time* with the original threads.
fr: Une fois que vous êtes suffisamment avancés en codage "live" avec un certain nombre de fonctions et de threads en simultanéité, vous avez probablement remarqué que c'est plutôt facile de faire une faute dans l'un des threads et qui lui met fin. Ce n'est pas un gros problème car vous pouvez facilement redémarrer le thread en pressant Run. Toutefois, quand vous redémarrez le thread, il se trouve alors *déphasé* avec les threads d'origine.

en: Inherited Time
fr: Temps hérité

en: As we discussed earlier, new threads created with `in_thread` inherit all of the settings from the parent thread. This includes the current time. This means that threads are always in time with each other when started simultaneously.
fr: Comme nous en avons discuté auparavant, les nouveaux threads créés avec `in_thread` héritent de tous les paramètres du thread parent. Ceci inclut l'heure actuelle. Ce qui signifie que les threads sont toujours en phase entre eux quand ils sont démarrés simultanément.

en: However, when you start a thread on its own it starts with its own time which is unlikely to be in sync with any of the other currently running threads.
fr: Toutefois quand vous démarrez un thread tout seul, il démarre avec sa propre heure qui n'est probablement en phase avec aucun des autres threads en cours d'exécution.

en: Cue and Sync
fr: Cue et sync

en: Sonic Pi provides a solution to this problem with the functions `cue` and `sync`.
fr: Sonic Pi fournit une solution à ce problème avec les fonctions `cue` et `sync`.

en: `cue` allows us to send out heartbeat messages to all other threads. By default the other threads aren't interested and ignore these heartbeat messages. However, you can easily register interest with the `sync` function.
fr: `cue` nous permet d'envoyer nos messages de battement de cœur à tous les autres threads. Par défaut, les autres threads ne sont pas intéressés et ignorent ces messages de battement de coeur. Cependant, vous pouvez leur déclarer de l'intérêt avec la fonction `sync`.

en: The important thing to be aware of is that `sync` is similar to `sleep` in that it stops the current thread from doing anything for a period of time. However, with `sleep` you specify how long you want to wait while with `sync` you don't know how long you will wait - as `sync` waits for the next `cue` from another thread which may be soon or a long time away.
fr: La chose importante à laquelle il faut être attentif est que `sync` est similaire à `sleep` dans le sens qu'elle arrête le thread courant et l'empêche de faire quoi que ce soit pendant un moment. Toutefois, avec `sleep`, vous spécifiez combien de temps vous voulez attendre tandis qu'avec `sync`, vous ne savez pas combien de temps vous allez attendre - étant donné que `sync` attend le `cue` suivant d'un autre thread, ce qui peut être court ou long.

en: Let's explore this in a little more detail:
fr: Explorons ceci en un peu plus de détail :

en: Here we have two threads - one acting like a metronome, not playing any sounds but sending out `:tick` heartbeat messages every beat. The second thread is synchronising on `tick` messages and when it receives one it inherits the time of the `cue` thread and continues running.
fr: Nous avons ici deux threads - l'un agissant comme un métronome, ne jouant aucun son mais envoyant des messages de battement de cœur `:tick` à chaque temps. Le second thread se synchronise sur les messages `tick` et quand il en reçoit un, il hérite de l'heure du thread `cue` et continue de jouer.

en: As a result, we will hear the `:drum_heavy_kick` sample exactly when the other thread sends the `:tick` message, even if the two threads didn't start their execution at the same time:
fr: Par conséquent, nous entendons l'échantillon `:drum_heavy_kick` exactement quand l'autre thread envoie le message `:tick`, même si les deux threads n'ont pas démarré leur exécution en même temps :

en: That naughty `sleep` call would typically make the second thread out of phase with the first. However, as we're using `cue` and `sync`, we automatically sync the threads bypassing any accidental timing offsets.
fr: Ce vilain appel à `sleep` mettrait typiquement le second thread en déphasage avec le premier. Cependant, comme nous utilisons `cue` et `sync`, nous synchronisons automatiquement les threads en évitant un décalage de temps accidentel.

en: Cue Names
fr: Noms des "cue"

en: You are free to use whatever name you'd like for your `cue` messages - not just `:tick`. You just need to ensure that any other threads are `sync`ing on the correct name - otherwise they'll be waiting for ever (or at least until you press the Stop button).
fr: Vous êtes libre d'utiliser n'importe quel nom que vous aimeriez pour vos messages `cue`, pas seulement `:tick`. Vous devez juste vous assurer que tout autre thread se synchronise sur le bon nom - autrement il attendrait à jamais (au moins jusqu'à ce que vous pressiez le bouton Stop).

en: Let's play with a few `cue` names:
fr: Jouons avec quelques noms de `cue` :

en: Here we have a main `cue` loop which is randomly sending one of the heartbeat names `:foo`, `:bar` or `:baz`. We then also have three loop threads syncing on each of those names independently and then playing a different sample. The net effect is that we hear a sound every 0.5 beats as each of the `sync` threads is randomly synced with the `cue` thread and plays its sample.
fr: Ici, nous avons une boucle principale `cue` qui envoie aléatoirement un des battements de cœur nommés `:foo`, `:bar` ou `:baz`. Nous avons aussi ensuite trois boucles en thread se synchronisant sur ces noms indépendamment et jouant un échantillon différent. Il est clair que nous entendons un son à chaque demi-temps puisque chacun des threads `sync` est aléatoirement synchronisé avec le thread `cue` et joue son échantillon.

en: This of course also works if you order the threads in reverse as the `sync` threads will simply sit and wait for the next `cue`.
fr: Ceci, bien entendu, marche aussi si vous ordonnez les threads en sens inverse puisque les threads `sync` restent en attente du `cue` suivant.

en: 6 FX
fr: 6 FX (effets)

en: Studio FX
fr: Studio FX (effets de studio)

en: One of the most rewarding and fun aspects of Sonic Pi is the ability to easily add studio effects to your sounds. For example, you may wish to add some reverb to parts of your piece, or some echo or perhaps even distort or wobble your basslines.
fr: Un des aspects les plus gratifiants et sympathiques de Sonic Pi est la capacité d'ajouter des effets de studio à vos sons. Par exemple, vous pouvez vouloir ajouter de la réverbération à des parties de votre œuvre, ou de l'écho ou peut-être même de la distorsion ou du trémolo à vos lignes de basse.

en: Sonic Pi provides a very simple yet powerful way of adding FX. It even allows you to chain them (so you can pass your sounds through distortion, then echo and then reverb) and also control each individual FX unit with opts (in a similar way to giving params to synths and samples). You can even modify the opts of the FX whilst it's still running. So, for example, you could increase the reverb on your bass throughout the track...
fr: Sonic Pi fournit un moyen très simple mais cependant puissant pour ajouter des effets (FX). Il vous autorise même à les chaîner (ainsi vous pouvez passer vos sons dans la distorsion, puis dans l'écho, puis dans la réverbération) et aussi à contrôler chaque unité FX individuellement avec des options (d'une façon similaire à la spécification des paramètres pour les synthés et les échantillons). Vous pouvez même modifier les options d'un FX pendant qu'il est encore en train d'agir. Ainsi, par exemple, vous pouvez augmenter la réverbération de vos basses tout au long de la piste...

en: Guitar Pedals
fr: Pédales de guitare

en: If all of this sounds a bit complicated, don't worry. Once you play around with it a little, it will all become quite clear. Before you do though, a simple analogy is that of guitar FX pedals. There are many kinds of FX pedals you can buy. Some add reverb, others distort etc. A guitarist will plug their guitar into one FX pedal - i.e. distortion -, then take another cable and connect (chain) a reverb pedal. The output of the reverb pedal can then be plugged into the amplifier:
fr: Si tout ceci paraît un tantinet compliqué, ne vous inquiétez pas. Une fois que vous aurez joué un peu avec, tout deviendra complètement clair. Avant qu'il en soit ainsi, faisons une simple analogie avec des pédales d'effets de guitare. Il y a des tas de sortes de pédales d'effets que vous pouvez acheter. Certaines ajoutent de la réverbération, d'autres de la distorsion, etc. Un guitariste va brancher sa guitare à une pédale d'effets - de distorsion par exemple - puis prendre un autre câble pour lui connecter (chaîner) une pédale de réverbération. La sortie de la pédale de réverbération pourra alors être branchée à l'amplificateur :

en: Guitar -> Distortion -> Reverb -> Amplifier
fr: Guitare -> Distorsion -> Réverbération -> Amplificateur

en: This is called FX chaining. Sonic Pi supports exactly this. Additionally, each pedal often has dials and sliders to allow you to control how much distortion, reverb, echo etc. to apply. Sonic Pi also supports this kind of control. Finally, imagine a guitarist jamming along whilst someone else changes and plays with the controls of their FX pedals. Sonic Pi also supports this - but instead of needing someone else to control things for you, that's where the computer steps in.
fr: Cela s'appelle le chaînage des effets. Sonic Pi supporte exactement cela. De plus, chaque pédale a souvent des molettes et des curseurs pour vous permettre de contrôler le niveau de la distorsion, de la réverbération, de l'écho, etc. à appliquer. Sonic Pi supporte aussi ce type de contrôle. Finalement, vous pouvez imaginer un guitariste qui joue pendant que quelqu'un d'autre modifie les contrôles d'effets de la pédale. Sonic Pi supporte aussi cela - mais au lieu d'avoir besoin de quelqu'un d'autre pour contrôler les choses pour vous, c'est l'ordinateur qui s'en charge.

en: Let's explore FX!
fr: Explorons les effets !

en: 6.1 Adding FX
fr: 6.1 Ajout d'effets

en: Adding FX
fr: Ajout d'effets (FX)

en: In this section we'll look at a couple of FX: reverb and echo. We'll see how to use them, how to control their opts and how to chain them.
fr: Dans cette section, nous allons regarder un couple d'effets : réverbération et écho. Nous allons voir comment les utiliser, comment contrôler leurs options et comment les chaîner.

en: Sonic Pi's FX system uses blocks. So if you haven't read section 5.1 you might want to take a quick look and then head back.
fr: Le système d'effets de Sonic Pi utilise les blocs. Donc, si vous n'avez pas lu la section 5.1, vous pourriez lui jeter un œil rapidement et puis revenir ici.

en: Reverb
fr: Réverbération

en: If we want to use reverb we write `with_fx :reverb` as the special code to our block like this:
fr: Si nous voulons utiliser la réverbération, nous écrivons `with_fx :reverb` en tant qu'entête particulière de notre bloc, comme ceci :

en: Now play this code and you'll hear it played with reverb. It sounds good, doesn't it! Everything sounds pretty nice with reverb.
fr: Maintenant exécutez ce code et vous l'entendrez joué avec réverbération. Ça sonne bien, n'est-ce pas ! Tout sonne plutôt agréablement avec de la réverbération.

en: Now let's look what happens if we have code outside the do/end block:
fr: Maintenant, voyons ce qui se passe si nous avons du code en dehors du bloc do/end :

en: Notice how the final `play 55` isn't played with reverb. This is because it is *outside* the do/end block, so it isn't captured by the reverb FX.
fr: Remarquez que le dernier `play 55` n'est pas joué avec de la réverbération. C'est parce qu'il est *en dehors* du bloc do/end, ainsi l'effet de réverbération n'agit pas sur lui.

en: Similarly, if you make sounds before the do/end block, they also won't be captured:
fr: De même, si vous placez des sons avant le bloc do/end, ils ne seront pas non plus affectés :

en: Echo
fr: Écho

en: There are many FX to choose from. How about some echo?
fr: Il y a beaucoup de choix d'effets. Et si on essayait un peu d'écho ?

en: One of the powerful aspects of Sonic Pi's FX blocks is that they may be passed opts similar to opts we've already seen with `play` and `sample`. For example a fun echo opt to play with is `phase:` which represents the duration of a given echo in beats. Let's make the echo slower:
fr: Un des puissants aspects des blocs d'effets de Sonic Pi est qu'on peut leur passer des options de manière similaire aux options que nous avons déjà vues avec `play` et `sample`. Par exemple, un paramètre sympa d'écho avec lequel jouer est `phase:`. Il représente la durée d'un écho en temps musicaux. Rendons l'écho plus lent :

en: Let's also make the echo faster:
fr: Rendons aussi l'écho plus rapide :

en: Let's make the echo take longer to fade away by setting the `decay:` time to 8 beats:
fr: Faisons décroître l'écho plus longuement en spécifiant la durée de `decay:` à 8 temps :

en: Nesting FX
fr: Imbrication des effets

en: One of the most powerful aspects of the FX blocks is that you can nest them. This allows you to very easily chain FX together. For example, what if you wanted to play some code with echo and then with reverb? Easy, just put one inside the other:
fr: Un des aspects les plus puissants des blocs d'effets est que vous pouvez les imbriquer. Ceci vous permet de chaîner facilement les effets entre eux. Par exemple, que faire si vous vouliez jouer du code avec de l'écho et ensuite de la réverbération ? Facile, mettez simplement l'un à l'intérieur de l'autre :

en: Think about the audio flowing from the inside out. The sound of all the code within the inner do/end block such as `play 50` is first sent to the echo FX and the sound of the echo FX is in turn sent out to the reverb FX.
fr: Pensez à du son provenant de l'intérieur et se propageant vers l'extérieur. Le son de tout le code situé dans le bloc intérieur dont `play 50` est d'abord envoyé vers l'effet d'écho et le son produit par l'effet d'écho est à son tour envoyé vers l'effet de réverbération.

en: We may use very deep nestings for a huge range of results. However, be warned, the FX can use a lot of resources and when you nest them you're effectively running multiple FX simultaneously. So be sparing with your use of FX especially on low powered platforms such as the Raspberry Pi.
fr: Nous pouvons utiliser des imbrications très profondes pour une large gamme de résultats délirants. Toutefois, soyez averti, les effets peuvent utiliser beaucoup de ressources et quand vous les imbriquez, vous allez effectivement faire agir de multiples effets simultanément. Donc soyez économe avec l'utilisation des FX, en particulier sur des plateformes peu puissantes telles que le Raspberry Pi.

en: Discovering FX
fr: À la découverte des effets

en: Sonic Pi ships with a large number of FX for you to play with. To find out which ones are available, click on FX in the far left of this help system and you'll see a list of available options. Here's a list of some of my favourites:
fr: Sonic Pi est livré avec un grand nombre d'effets avec lesquels vous pouvez jouer. Pour trouver ceux qui sont disponibles, cliquez sur "FX" dans le menu horizontal du système d'aide et vous verrez une liste des options disponibles. Voici une liste de mes préférés :

en: Now go wild and add FX everywhere for some amazing new sounds!
fr: Maintenant, défoulez-vous et ajoutez des effets partout pour obtenir d'étonnants sons nouveaux !

en: 6.2 FX in Practice
fr: 6.2 FX en Pratique

en: FX in Practice
fr: FX en pratique

en: Although they look deceptively simple on the outside, FX are actually quite complex beasts internally. Their simplicity often entices people to overuse them in their pieces. This may be fine if you have a powerful machine, but if - like me - you use a Raspberry Pi to jam with, you need to be careful about how much work you ask it to do if you want to ensure the beats keep flowing.
fr: Bien qu'ils paraissent trompeusement simples extérieurement, les FX sont en fait des bêtes plutôt complexes à l'intérieur. Leur simplicité incite souvent les gens à en abuser dans leurs morceaux. Cela ne sera peut-être pas gênant si vous avez une machine puissante, mais si - comme moi - vous utilisez un Raspberry Pi pour improviser, vous devez prendre garde à la somme de travail que vous lui demandez de faire si vous voulez vous assurer que la cadence reste fluide.

en: Consider this code:
fr: Considérez ce code :

en: In this code we're playing note 60 with a very short release time, so it's a short note. We also want reverb so we've wrapped it in a reverb block. All good so far. Except...
fr: Dans ce code, nous jouons la note 60 avec une durée d'extinction très courte, c'est donc une note courte. Nous voulons aussi de la réverbération, alors nous l'avons imbriqué dans un bloc de réverbération. Jusqu'à maintenant, tout est bon. Sauf que...

en: Let's look at what the code does. First we have a `loop` which means everything inside of it is repeated forever. Next we have a `with_fx` block. This means we will create a new reverb FX *every time we loop*. This is like having a separate FX reverb pedal for every time you pluck a string on a guitar. It's cool that you can do this, but it's not always what you want. For example, this code will struggle to run nicely on a Raspberry Pi. All the work of creating the reverb and then waiting until it needs to be stopped and removed is all handled by `with_fx` for you, but this takes CPU power which may be precious.
fr: Regardons ce que fait le code. En premier lieu, nous avons une boucle (`loop`), ce qui signifie que tout ce qui est à l'intérieur est répété sans fin. Ensuite, nous avons un bloc `with_fx`. Ceci veut dire que nous allons créer un nouvel FX de réverbération *chaque fois que nous bouclons*. C'est comme si nous disposions d'une pédale de réverbération distincte à chaque fois que nous pincions une corde sur une guitare. C'est super de pouvoir faire ça, mais ce n'est pas toujours ce que vous voulez. Par exemple, ce code va avoir du mal à s'exécuter comme il faut sur un Raspberry Pi. Tout le travail de création de la réverbération puis d'attente jusqu'à ce qu'elle doive être stoppée et enlevée est complètement pris en charge par `with_fx` pour vous, mais ceci prend de la puissance du microprocesseur (CPU) qui peut être précieuse.

en: How do we make it more similar to a traditional setup where our guitarist has just *one* reverb pedal which all sounds pass through? Simple:
fr: Comment le faire d'une manière plus proche d'une installation traditionnelle où notre guitariste n'a *qu'une* pédale de réverbération dans laquelle passent tous les sons ? Simple :

en: We put our loop *inside* the `with_fx` block. This way we only create a single reverb for all notes played in our loop. This code is a lot more efficient and would work fine on a Raspberry Pi.
fr: Nous mettons notre boucle *à l'intérieur* du bloc `with_fx`. De cette façon, nous créons seulement une unique réverbération pour toutes les notes jouées dans notre boucle. Ce code est beaucoup plus efficace et fonctionnerait bien sur un Raspberry Pi.

en: A compromise is to use `with_fx` over an iteration within a loop:
fr: Un compromis est d'utiliser `with_fx` sur une itération à l'intérieur d'une boucle :

en: This way we've lifted the `with_fx` out of the inner part of the `loop` and we're now creating a new reverb every 16 notes.
fr: De cette façon, nous avons remonté le `with_fx` en dehors de la partie la plus intérieure de la boucle, et nous créons maintenant une nouvelle réverbération toutes les 16 notes.

en: This is such a common pattern that `with_fx` supports an opt to do exactly this but without having to write the `16.times` block:
fr: C'est quelque chose que l'on fait si souvent que `with_fx` supporte une option pour faire exactement cela sans devoir écrire le bloc `16.times` :

en: Both the `reps: 16` and `16.times do` examples will behave identically. The `reps: 16` essentially repeats the code in the `do/end` block 16 times so you can use them both interchangeably and choose the one that feels best for you.
fr: Les deux exemples `reps: 16` et `16.times do` se comporteront de la même manière. L'exemple avec `reps: 16` répète en fait le code dans le bloc `do/end` seize fois donc vous pouvez choisir l'un ou l'autre en fonction de vos préférences.

en: Remember, there are no mistakes, just possibilities. However, some of these approaches will have a different sound and also different performance characteristics. So play around and use the approach that sounds best to you whilst also working within the performance constraints of your platform.
fr: Rappelez-vous, il n'y a pas de fautes, juste des possibilités. Toutefois, certaines de ces approches donneront un son différent et auront des caractéristiques de performance différentes. Donc, jouez et utilisez l'approche qui sonne le mieux pour vous tout en restant dans les contraintes de performance de votre plateforme.

en: 7 Control
fr: 7 Contrôle

en: Controlling running sounds
fr: Contrôle des sons en cours d'écoute

en: So far we've looked at how you can trigger synths and samples, and also how to change their default opts such as amplitude, pan, envelope settings and more. Each sound triggered is essentially its own sound with its own list of options set for the duration of the sound.
fr: Pour l'instant, nous avons regardé comment déclencher des sons de synthé et des échantillons, et aussi comment changer leurs paramètres par défaut comme l'amplitude, la balance, les paramètres d'enveloppe, et davantage. Chaque son émis est essentiellement son propre son avec son propre ensemble de paramètres fixés pour la durée du son.

en: Wouldn't it also be cool if you could change a sound's opts whilst it's still playing, just like you might bend a string of a guitar whilst it's still vibrating?
fr: Ne serait-ce pas sympathique si nous pouvions changer les paramètres d'un son pendant qu'il est encore en train d'être joué, tout comme vous pourriez tendre une corde de guitare pendant qu'elle est en train de vibrer ?

en: You're in luck - this section will show you how to do exactly this.
fr: Vous avez de la chance - cette section va vous montrer précisément comment le faire.

en: 7.1 Controlling Running Synths
fr: 7.1 Contrôler des synthés en cours de jeu

en: Controlling Running Synths
fr: Contrôler des synthés en train de jouer

en: So far we've only concerned ourselves with triggering new sounds and FX. However, Sonic Pi gives us the ability to manipulate and control currently running sounds. We do this by using a variable to capture a reference to a synth:
fr: Pour l'instant, nous nous sommes seulement préoccupés de déclencher de nouveaux sons et effets (FX). Toutefois, Sonic Pi nous offre la capacité de manipuler et de contrôler les sons pendant qu'il sont joués. Nous le faisons en utilisant une variable pour mémoriser la référence à un synthé :

en: Here, we have a run-local variable `s` which represents the synth playing note 60. Note that this is *run-local* - you can't access it from other runs like functions.
fr: Ici, nous avons une variable locale à l'exécution `s` qui représente le synthé jouant la note 60. Notez que c'est *local à l'exécution* - vous ne pouvez pas y accéder depuis d'autres exécutions comme les fonctions.

en: Once we have `s`, we can start controlling it via the `control` function:
fr: Une fois que nous avons `s`, nous pouvons commencer à la contrôler via la fonction `control` :

en: The thing to notice is that we're not triggering 4 different synths here - we're just triggering one synth and then change the pitch 3 times afterwards, while it's playing.
fr: La chose à remarquer est que nous ne sommes pas en train de déclencher 4 synthés différents ici - nous en déclenchons seulement un et puis nous changeons ensuite 3 fois la hauteur, pendant qu'il joue.

en: We can pass any of the standard opts to `control`, so you can control things like `amp:`, `cutoff:` or `pan:`.
fr: Nous pouvons passer n'importe quel paramètre standard à `control`, vous pouvez donc contrôler des choses telles que `amp:`, `cutoff:` ou `pan`.

en: Non-controllable Options
fr: Paramètres non contrôlables

en: Some of the opts can't be controlled once the synth has started. This is the case for all the ADSR envelope parameters. You can find out which opts are controllable by looking at their documentation in the help system. If the documentation says *Can not be changed once set*, you know it's not possible to control the opt after the synth has started.
fr: Quelques paramètres ne peuvent pas être contrôlés une fois que le synthé joue. C'est le cas pour tous les paramètres d'enveloppe ADSR. Vous pouvez trouver quels paramètres sont contrôlables en regardant leur documentation dans le système d'aide. Si la documentation dit *Can not be changed once set (ne peut être modifié une fois attribué)*, vous savez que ce n'est pas possible de contrôler le paramètre après que le synthé ait commencé à jouer.

en: 7.2 Controlling FX
fr: 7.2 Contrôle des effets (FX)

en: Controlling FX
fr: Contrôle des effets (FX)

en: It is also possible to control FX, although this is achieved in a slightly different way:
fr: Il est aussi possible de contrôler les FX, bien que ce soit accompli d'une manière légèrement différente :

en: Instead of using a variable, we use the goalpost parameters of the do/end block. Inside the `|` bars, we need to specify a unique name for our running FX which we then reference from the containing do/end block. This behaviour is identical to using parameterised functions.
fr: Au lieu d'utiliser une variable, nous utilisons le paramètre cible d'un bloc do/end. À l'intérieur des barres verticales `|`, nous devons attribuer un nom unique à notre FX en cours, nom que nous référençons alors depuis l'intérieur du bloc do/end. Ce comportement est identique à celui d'utiliser des fonctions paramétrées.

en: Now go and control some synths and FX!
fr: Maintenant, allez et contrôlez des synthés et des FX !

en: 7.3 Sliding Options
fr: 7.3 Paramètres à curseur glissant

en: Sliding Opts
fr: Paramètres à curseur glissant

en: Whilst exploring the synth and FX opts, you might have noticed that there are a number of opts ending with `_slide`. You might have even tried calling them and seeing no effect. This is because they're not normal parameters, they're special opts that only work when you control synths as introduced in the previous section.
fr: Pendant l'exploration des paramètres des synthés et des FX, vous pourriez avoir remarqué qu'il y a un certain nombre de paramètres finissant par `_slide`. Vous avez peut-être même essayé de les appeler et n'avez constaté aucun effet. C'est parce que ce ne sont pas des paramètres normaux, ce sont des paramètres spéciaux qui n'agissent que quand vous contrôlez les synthés comme cela est décrit dans la section précédente.

en: Consider the following example:
fr: Considérez l'exemple suivant :

en: Here, you can hear the synth pitch changing immediately on each `control` call. However, we might want the pitch to slide between changes. As we're controlling the `note:` parameter, to add slide, we need to set the `note_slide` parameter of the synth:
fr: Ici, vous pouvez entendre la hauteur du son changer instantanément après l'appel à `control`. Toutefois, nous pourrions souhaiter que la hauteur glisse entre les changements. Comme nous sommes en train de contrôler le paramètre `note:`, pour ajouter un glissement, nous devons fixer le paramètre `note_slide` du synthé :

en: Now we hear the notes being bent between the `control` calls. It sounds nice, doesn't it? You can speed up the slide by using a shorter time such as `note_slide: 0.2` or slow it down by using a longer slide time.
fr: Maintenant, nous entendons la hauteur des notes glisser entre les appels à `control`. Ça sonne agréable, n'est-ce pas ? Vous pouvez accélérer le glissement en utilisant une durée plus courte comme `note_slide: 0.2` ou le ralentir en utilisant une durée de glissement plus longue.

en: Every parameter that can be controlled has a corresponding `_slide` parameter for you to play with.
fr: Chaque paramètre qui peut être contrôlé a un paramètre correspondant avec `_slide` à votre disposition.

en: Sliding is sticky
fr: Le glissement est rémanent

en: Once you've set a `_slide` parameter on a running synth, it will be remembered and used every time you slide the corresponding parameter. To stop sliding you must set the `_slide` value to 0 before the next `control` call.
fr: Une fois que vous avez fixé un paramètre `_slide` à un synthé en cours de jeu, il sera mémorisé et appliqué à chaque fois que le paramètre correspondant sera utilisé. Pour arrêter le glissement, vous devez fixer la valeur de `_slide` à 0 avant l'appel suivant à `control`.

en: Sliding FX Opts
fr: Paramètres FX à curseur glissant

en: It is also possible to slide FX opts:
fr: Il est aussi possible de faire glisser les paramètres FX :

en: Now have fun sliding things around for smooth transitions and flowing control...
fr: Maintenant ayez du plaisir à faire glisser les choses pour obtenir des transitions douces et un contrôle fluide...

en: 8 Data Structures
fr: 8 Structures de données

en: Data Structures
fr: Structures de données

en: A very useful tool in a programmer's toolkit is a data structure.
fr: Un outil très utile dans la boîte à outils d'un programmeur est une structure de données.

en: Sometimes you may wish to represent and use more than one thing. For example, you may find it useful to have a series of notes to play one after another. Programming languages have data structures to allow you do exactly this.
fr: Quelque fois, vous souhaiteriez représenter et utiliser plus d'une seule chose à la fois. Vous pourriez trouver utile de disposer d'une série de notes à jouer l'une après l'autre. Les langages de programmation offrent des structures de données pour autoriser précisément ceci.

en: There are many exciting and exotic data structures available to programmers - and people are always inventing new ones. However, for now we only really need to consider a very simple data structure - the list.
fr: Il y a beaucoup de structures de données passionnantes et exotiques à la disposition des programmeurs - et on en invente toujours de nouvelles. Cependant, pour l'instant nous avons seulement réellement besoin de nous intéresser à une structure de données très simple - la liste.

en: Let's look at it in more detail. We'll cover its basic form and then also how lists can be used to represent scales and chords.
fr: Regardons-la de manière plus détaillée. Nous allons décrire sa forme basique et ensuite montrer comment l'utiliser pour représenter des gammes et des accords.

en: 8.1 Lists
fr: 8.1 Listes

en: Lists
fr: Listes

en: In this section we'll take a look at a data structure which is very useful - the list. We met it very briefly before in the section on randomisation when we randomly chose from a list of notes to play:
fr: Dans cette section, nous allons voir une structure de données qui est très utile - la liste. Nous l'avons rencontrée brièvement auparavant dans la section sur l'aléatoire quand nous choisissions aléatoirement des notes à jouer dans une liste :

en: In this section we'll explore using lists to also represent chords and scales. First let's recap how we might play a chord. Remember that if we don't use `sleep`, sounds all happen at the same time:
fr: Dans cette section, nous allons explorer l'utilisation des listes également pour représenter des accords et des gammes. En premier lieu, récapitulons comment nous jouerions un accord. Souvenez-vous que si nous n'utilisons pas `sleep`, les sons arrivent tous au même moment :

en: Let's look at other ways to represent this code.
fr: Regardons d'autres façons d'écrire ce code.

en: Playing a List
fr: Jeu d'une liste

en: One option is to place all the notes in a list: `[52, 55, 59]`. Our friendly `play` function is smart enough to know how to play a list of notes. Try it:
fr: Une option est de placer toutes les notes dans une liste : `[52, 55, 59]`. Notre sympathique fonction `play` est assez évoluée pour savoir comment jouer une liste de notes. Essayez-le :

en: Ooh, that's already nicer to read. Playing a list of notes doesn't stop you from using any of the parameters as normal:
fr: Ooh, c'est déjà plus agréable à lire. Jouer une liste de notes ne vous empêche pas d'utiliser normalement n'importe quel paramètre des spécifications :

en: Of course, you can also use the traditional note names instead of the MIDI numbers:
fr: Bien sûr, vous pouvez aussi utiliser les noms traditionnels des notes (en notation anglaise) à la place des nombres de la norme MIDI :

en: Now those of you lucky enough to have studied some music theory might recognise that chord as *E Minor* played in the 3rd octave.
fr: Maintenant, ceux qui sont assez chanceux pour avoir étudié quelques notions de solfège, pourraient reconnaître l'accord de *Mi mineur* joué à la 3ème octave.

en: Accessing a List
fr: Accès à une liste

en: Another very useful feature of a list is the ability to get information out of it. This may sound a bit strange, but it's no more complicated than someone asking you to turn a book to page 23. With a list, you'd say, what's the element at index 23? The only strange thing is that in programming indexes usually start at 0 not 1.
fr: Une autre caractéristique très utile d'une liste est d'en extraire de l'information. Ceci peut paraître étrange, mais ce n'est pas plus compliqué que de tourner les pages d'un livre jusqu'à la page 23. Avec une liste, vous diriez : quel est l'élément à l'index 23 ? La seule chose étrange est qu'en programmation, les index commencent généralement à 0 et non pas 1.

en: With list indexes we don't count 1, 2, 3... Instead we count 0, 1, 2...
fr: Avec les index d'une liste, nous ne comptons pas 1, 2, 3... mais 0, 1, 2...

en: Let's look at this in a little more detail. Take a look at this list:
fr: Regardons ceci en un peu plus de détails. Jetez un œil sur cette liste :

en: There's nothing especially scary about this. Now, what's the second element in that list? Yes, of course, it's `55`. That was easy. Let's see if we can get the computer to answer it for us too:
fr: Il n'y a rien là de particulièrement effrayant. Maintenant, quel est le second élément de la liste ? Oui, bien sûr, c'est `55`. C'était facile. Regardons si nous pouvons obtenir la réponse de l'ordinateur :

en: OK, that looks a bit weird if you've never seen anything like it before. Trust me though, it's not too hard. There are three parts to the line above: the word `puts` , our list `52, 55, 59` and our index `[1]`. Firstly we're saying `puts` because we want Sonic Pi to print the answer out for us in the log. Next, we're giving it our list, and finally our index is asking for the second element. We need to surround our index with square brackets and because counting starts at `0`, the index for the second element is `1`. Look:
fr: OK, ça semble un peu bizarre si vous n'avez jamais vu quelque chose de la sorte auparavant. Faites-moi confiance toutefois, ce n'est pas trop dur. Il y a trois parties dans la ligne ci-dessus : le mot `puts`, notre liste `52, 55, 59` et notre index `[1]`. En premier, nous disons `puts` parce que nous voulons que Sonic Pi nous affiche la réponse dans le panneau "trace". Ensuite, nous lui donnons notre liste, et enfin notre index qui demande le second élément. Nous devons encadrer notre index avec des crochets et parce que le compte commence à 0, l'index pour le second élément est `1`. Regardez :

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

en: Try running the code `puts [52, 55, 59][1]` and you'll see `55` pop up in the log. Change the index `1` to other indexes, try longer lists and think about how you might use a list in your next code jam. For example, what musical structures might be represented as a series of numbers...
fr: Essayez d'exécuter le code `puts [52, 55, 59][1]` et vous verrez `55` apparaître dans le panneau "trace". Changez l'index `1` par d'autres valeurs, essayez des listes plus longues et pensez à la façon dont vous pourriez utiliser une liste dans votre prochaine improvisation avec du code. Par exemple, quelles structures musicales pourraient être représentées par une série de nombres...

en: 8.2 Chords
fr: 8.2 Accords

en: Sonic Pi has built-in support for chord names which will return lists. Try it for yourself:
fr: Sonic Pi incorpore le support des noms d'accord, lequel retourne des listes. Essayez-le vous-même :

en: Now, we're really getting somewhere. That looks a lot more pretty than the raw lists (and is easier to read for other people). So what other chords does Sonic Pi support? Well, a *lot*. Try some of these:
fr: Maintenant, nous avons vraiment progressé. Ça parait beaucoup plus joli que les listes brutes (et c'est plus facile à lire pour les autres). Alors quels autres accords Sonic Pi supporte-t-il ? Eh bien, un *tas*. Essayez quelques-uns parmi ceux-ci :

en: Arpeggios
fr: Arpèges

en: We can easily turn chords into arpeggios with the function `play_pattern`:
fr: Nous pouvons facilement changer les accords en arpèges avec la fonction `play_pattern` :

en: 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:
fr: OK, ce n'est pas très marrant - ça le joue vraiment lentement. `play_pattern` va jouer chaque note de la liste avec un appel à `sleep 1` entre chaque appel à `play`. Nous pouvons utiliser une autre fonction `play_pattern_timed` pour spécifier nos propres durées et accélérer les choses :

en: We can even pass a list of times which it will treat as a circle of times:
fr: Nous pouvons même passer une liste de durées qui sera traitée de façon circulaire :

en: This is the equivalent to:
fr: Ceci est équivalent à :

en: Which would you prefer to write?
fr: Lequel préféreriez-vous écrire ?

en: 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`:
fr: Notez que `play_pattern` et `play_pattern_timed` modifient le sustain des notes pour remplir les temps. Vous pouvez supprimer ce comportement en paramétrant l'option `sustain:` à `0` :

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

en: 8.3 Scales
fr: 8.3 Gammes

en: Scales
fr: Gammes

en: Sonic Pi has support for a wide range of scales. How about playing a C3 major scale?
fr: Sonic Pi supporte un large éventail de gammes. Comment faire pour jouer une gamme majeure de Do3 (C3) ?

en: We can even ask for more octaves:
fr: Nous pouvons même demander davantage d'octaves :

en: How about all the notes in a pentatonic scale?
fr: Comment obtenir toutes les notes d'une gamme pentatonique ?

en: Random notes
fr: Notes aléatoires

en: Chords and scales are great ways of constraining a random choice to something meaningful. Have a play with this example which picks random notes from the chord E3 minor:
fr: Les accords et les gammes sont des bons moyens de contraindre un choix aléatoire à quelque chose de significatif. Jouez un instant avec cet exemple qui prend des notes aléatoirement dans l'accord mineur de Mi3 :

en: Try switching in different chord names and cutoff ranges.
fr: Essayez de modifier cet exemple avec quelques noms d'accords différents et des plages de "cutoff" différentes.

en: Discovering Chords and Scales
fr: Découverte des accords et des gammes

en: To find out which scales and chords are supported by Sonic Pi simply click the Lang button on the far left of this tutorial and then choose either chord or scale in the API list. In the information in the main panel, scroll down until you see a long list of chords or scales (depending on which you're looking at).
fr: Pour découvrir quelles gammes et quels accords sont supportés par Sonic Pi, cliquez sur le bouton "Lang" du menu horizontal à gauche de ce tutoriel, et choisissez soit "chord" (accord) ou "scale" (gamme) dans la liste du dessus. Dans le panneau d'information, faites défiler l'affichage vers le bas jusqu'à voir une longue liste d'accords ou de gammes (selon lequel des deux vous regardez).

en: Have fun and remember: there are no mistakes, only opportunities.
fr: Faites-vous plaisir et rappelez-vous : il n'y a pas de fautes, que des opportunités.

en: 8.4 Rings
fr: 8.4 Anneaux

en: Rings
fr: Anneaux

en: An interesting spin on standard lists are rings. If you know some programming, you might have come across ring buffers or ring arrays. Here, we'll just go for ring - it's short and simple.
fr: Les anneaux sont une variation intéressante des listes classiques. Si vous avez quelques connaissances en programmation, vous pouvez avoir eu affaire aux "ring buffers" ou aux "ring arrays". Ici, nous allons juste voir les "rings" - c'est court et simple.

en: In the previous section on lists we saw how we could fetch elements out of them by using the indexing mechanism:
fr: Dans la section précédente sur les listes, nous avons vu comment nous pouvions aller en chercher des éléments en utilisant le mécanisme d'indexage :

en: Now, what happens if you want index `100`? Well, there's clearly no element at index 100 as the list has only three elements in it. So Sonic Pi will return you `nil` which means nothing.
fr: Maintenant, qu'arrive-t-il si vous voulez l'index `100` ? Eh bien, c'est clair qu'il n'y a pas d'élément à l'index 100 puisque la liste ne contient que trois éléments. Alors Sonic Pi retournera `nil` ce qui veut dire "rien".

en: However, consider you have a counter such as the current beat which continually increases. Let's create our counter and our list:
fr: Maintenant, imaginons que nous ayons un compteur tel que celui des temps musicaux qui s'incrémente continuellement. Créons notre compteur et notre liste :

en: We can now use our counter to access a note in our list:
fr: Nous pouvons maintenant utiliser notre compteur pour accéder à une note de notre liste :

en: Great, we got `52`. Now, let's increment our counter and get another note:
fr: Super, nous avons obtenu `52`. Maintenant, incrémentons notre compteur et obtenons une autre note :

en: Super, we now get `55` and if we do it again we get `59`. However, if we do it again, we'll run out of numbers in our list and get `nil`. What if we wanted to just loop back round and start at the beginning of the list again? This is what rings are for.
fr: Super, nous obtenons maintenant `55` et si nous le faisons une nouvelle fois, nous obtenons `59`. Toutefois, si nous le faisons encore une nouvelle fois, nous allons nous trouver en dehors des nombres de notre liste et obtenir `nil`. Que faire si nous voulions juste boucler en revenant en arrière et recommencer au début de la liste ? C'est pour cela que les anneaux ("rings") sont faits.

en: Creating Rings
fr: Création des anneaux

en: We can create rings one of two ways. Either we use the `ring` function with the elements of the ring as parameters:
fr: Nous pouvons créer des anneaux de deux façons. Ou bien nous utilisons la fonction `ring` avec les éléments de l'anneau comme paramètres :

en: Or we can take a normal list and convert it to a ring by sending it the `.ring` message:
fr: Ou bien nous pouvons prendre une liste normale et la convertir en anneau en lui envoyant le message `.ring` :

en: Indexing Rings
fr: Indexation des anneaux

en: Once we have a ring, you can use it in exactly the same way you would use a normal list with the exception that you can use indexes that are negative or larger than the size of the ring and they'll wrap round to always point at one of the ring's elements:
fr: Une fois que nous avons un anneau, nous pouvons l'utiliser de la même manière que nous utiliserions une liste normale avec l'exception que nous pouvons utiliser des index négatifs ou des index qui sont plus grands que la taille de l'anneau, et ils vont boucler tout autour pour toujours pointer sur un des éléments de l'anneau :

en: Using Rings
fr: Utilisation des anneaux

en: Let's say we're using a variable to represent the current beat number. We can use this as an index into our ring to fetch notes to play, or release times or anything useful we've stored in our ring regardless of the beat number we're currently on.
fr: Supposons que nous utilisons une variable pour représenter le numéro de battement courant. Nous pouvons l'utiliser comme un index de notre anneau pour aller chercher les notes à jouer, ou les durées d'extinction ou n'importe quelle chose utile que nous avons mémorisée dans notre anneau sans se préoccuper de la valeur du numéro de battement en cours.

en: Scales and Chords are Rings
fr: Les gammes et les accords sont des anneaux

en: A useful thing to know is that the lists returned by `scale` and `chord` are also rings and allow you to access them with arbitrary indexes.
fr: Une chose utile à savoir est que les listes retournées par `scale` et `chord` sont aussi des anneaux et cela vous permet d'y accéder avec des valeurs d'index arbitraires.

en: Ring Constructors
fr: Constructeurs d'anneaux

en: In addition to `ring` there are a number of other functions which will construct a ring for us.
fr: En plus de `ring`, il y a un certain nombre de fonctions qui vous construiront un anneau.

en: `range` invites you specify a starting point, end point and step size.
fr: `range` vous invite à spécifier un point de départ, un point de fin, et la taille du pas.

en: `bools` allows you to use `1`s and `0`s to succinctly represent booleans.
fr: `bools` vous permet d'utiliser des `1` et des `0` pour représenter les booléens de manière condensée.

en: `knit` allows you to knit a sequence of repeated values.
fr: `knit` vous permet de créer une séquence de valeurs dupliquées.

en: `spread` creates a ring of bools with a Euclidean distribution.
fr: `spread` crée un anneau de booléens avec une distribution euclidienne.

en: Take a look at their respective documentation for more information.
fr: Jetez un œil à leur documentation respective pour plus d'informations.

en: 8.5 Ring Chains
fr: 8.5 Chaînes d'anneaux

en: Ring Chains
fr: Chaînes d'anneaux

en: In addition to the constructors such as `range` and `spread` another way of creating new rings is to manipulate existing rings.
fr: En plus des constructeurs comme `range` et `spread`, une autre façon de créer de nouveaux anneaux est de manipuler des anneaux existants.

en: Chain Commands
fr: Commandes de chaîne

en: To explore this, take a simple ring:
fr: Pour explorer ceci, prenons un anneau simple :

en: What if we wanted it backwards? Well we'd use the chain command `.reverse` to take the ring and turn it around:
fr: Et si on voulait son inverse ? Eh bien on utiliserait la commande de chaîne `.reverse` pour prendre l'anneau et l'inverser :

en: Now, what if we wanted the first three values from the ring?
fr: Et si on voulait les trois premières valeurs de l'anneau ?

en: Finally, what if we wanted to shuffle the ring?
fr: Finalement, et si on voulait mélanger l'anneau ?

en: Multiple Chains
fr: Chaînes multiples

en: This is already a powerful way of creating new rings. However, the *real* power comes when you chain a few of these commands together.
fr: C'est déjà une manière puissante de créer de nouveaux anneaux. Ceci dit la *vraie* puissance vient quand on enchaîne quelques-unes de ces commandes à la suite.

en: How about shuffling the ring, dropping 1 element and then taking the next 3?
fr: Et si on mélangeait l'anneau, on lâchait un élément puis on en prenait les trois suivants ?

en: Let's take this in stages:
fr: Regardons ceci par étapes :

en: `(ring 10, 20, 30, 40, 50)` - our initial ring
fr: `(ring 10, 20, 30, 40, 50)` - notre anneau initial

en: `(ring 10, 20, 30, 40, 50).shuffle` - shuffles - `(ring 40, 30, 10, 50, 20)`
fr: `(ring 10, 20, 30, 40, 50).shuffle` - mélange - `(ring 40, 30, 10, 50, 20)`

en: `(ring 10, 20, 30, 40, 50).shuffle.drop(1)` - drop 1 - `(ring 30, 10, 50, 20)`
fr: `(ring 10, 20, 30, 40, 50).shuffle.drop(1)` - en lâche un - `(ring 30, 10, 50, 20)`

en: `(ring 10, 20, 30, 40, 50).shuffle.drop(1).take(3)` - take 3 - `(ring 30, 10, 50)`
fr: `(ring 10, 20, 30, 40, 50).shuffle.drop(1).take(3)` - en prend trois - `(ring 30, 10, 50)`

en: Can you see how we can just create a long chain of these methods by just *sticking them together*. We can combine these in any order we want creating an extremely rich and powerful way of generating new rings from existing ones.
fr: Vous voyez comme on peut créer une longue chaîne de ces méthodes juste *en les collant à la suite*. On peut les combiner dans l'ordre qu'on veut, ce qui crée une manière extrêmement riche et puissante de générer de nouveaux anneaux à partir d'anneaux existants.

en: Immutability
fr: Immutabilité

en: These rings have a powerful and important property. They are immutable which means that they can not change. This means that the chaining methods described in this section *do not change rings* rather they *create new rings*. This means you're free to share rings across threads and start chaining them within a thread knowing you won't be affecting any other thread using the same ring.
fr: Ces anneaux ont une propriété puissante et importante. Ils sont immutables, ce qui veut dire qu'ils ne peuvent pas changer. Cela veut dire que les méthodes de chaînage décrites dans cette section *ne modifient pas les anneaux*, elles *en créent plutôt de nouveaux*. Cela veut dire que vous êtes libres de partager des anneaux entre les threads et de les chaîner dans un thread en sachant que vous n'affecterez aucun autre thread qui utilise le même anneau.

en: Available Chain Methods
fr: Méthodes de chaîne disponibles

en: Here's a list of the available chain methods for you to play with:
fr: Voici une liste des méthodes de chaîne disponibles :

en: `.reverse` - returns a reversed version of the ring
fr: `.reverse` - retourne une version inversée de l'anneau

en: `.sort` - creates a sorted version of the ring
fr: `.sort` - crée une version triée de l'anneau

en: `.shuffle` - creates a shuffled version of the ring
fr: `.shuffle` - crée une version mélangée de l'anneau

en: `.pick` - returns a ring with the results of calling `.choose` once
fr: `.pick` - retourne un anneau avec le résultat d'un appel à `.choose` une fois

en: `.pick(3)` - returns a ring with the results of calling `.choose` 3 times
fr: `.pick(3)` - retourne un anneau avec le résultat de trois appels à `.choose`

en: `.take(5)` - returns a new ring containing only the first 5 elements
fr: `.take(5)` - retourne un nouvel anneau contenant uniquement les cinq premiers éléments

en: `.drop(3)` - returns a new ring with everything but the first 3 elements
fr: `.drop(3)` - retourne un nouvel anneau avec tout sauf les trois premiers éléments

en: `.butlast` - returns a new ring with the last element missing
fr: `.butlast` - retourne un nouvel anneau sans le dernier élément

en: `.drop_last(3)` - returns a new ring with the last 3 elements missing
fr: `.drop_last(3)` - retourne un nouvel anneau sans les trois derniers éléments

en: `.take_last(6)`- returns a new ring with only the last 6 elements
fr: `.take_last(6)`- retourne un nouvel anneau avec les six derniers éléments seulement

en: `.stretch(2)` - repeats each element in the ring twice
fr: `.stretch(2)` - répète chaque élément dans l'anneau deux fois

en: `.repeat(3)` - repeats the entire ring 3 times
fr: `.repeat(3)` - répète l'anneau entier trois fois

en: `.mirror` - adds the ring to a reversed version of itself
fr: `.mirror` - ajoute l'anneau à une version inversée de lui-même

en: `.reflect` - same as mirror but doesn't duplicate middle value
fr: `.reflect` - comme `.mirror` mais sans dupliquer la valeur du milieu

en: `.scale(2)` - returns a new ring with all elements multiplied by 2 (assumes ring contains numbers only)
fr: `.scale(2)` - retourne un nouvel anneau avec tous les éléments multipliés par 2 (l'anneau doit contenir uniquement des nombres)

en: Of course, those chain methods that take numbers can take other numbers too! So feel free to call `.drop(5)` instead of `.drop(3)` if you want to drop the first 5 elements.
fr: Évidemment, les méthodes de chaîne qui prennent des nombres peuvent prendre d'autres nombres aussi ! N'hésitez donc pas à appeler `.drop(5)` au lieu de `.drop(3)` si vous voulez lâcher les cinq premiers éléments.

en: 9 Live Coding
fr: 9 Codage en direct

en: One of the most exciting aspects of Sonic Pi is that it enables you to write and modify code live to make music, just like you might perform live with a guitar. One advantage of this approach is to give you more feedback whilst composing (get a simple loop running and keep tweaking it till it sounds just perfect). However, the main advantage is that you can take Sonic Pi on stage and gig with it.
fr: Un des aspects les plus passionnants de Sonic Pi est qu'il vous permet d'écrire et de modifier du code en direct pour faire de la musique, juste comme vous le feriez avec une guitare. Un avantage de cette approche est qu'il vous procure plus de retour d'informations pendant que vous composez (avoir une simple boucle en cours d'exécution et continuer à l'ajuster jusqu'à qu'elle sonne parfaitement). Cependant, le principal avantage est que vous pouvez amener Sonic Pi sur scène et donner un concert avec.

en: In this section we'll cover the fundamentals of turning your static code compositions into dynamic performances.
fr: Dans cette section, nous allons couvrir les fondamentaux du changement de vos compositions avec du code statique en interprétations dynamiques.

en: Hold on to your seats...
fr: Tenez-vous bien...

en: 9.1 Live Coding Fundamentals
fr: 9.1 Fondamentaux du Codage en direct

en: Now we've learned enough to really start having some fun. In this section we'll draw from all the previous sections and show you how you can start making your music compositions live and turning them into a performance. For that we'll need 3 main ingredients:
fr: Maintenant nous en avons suffisamment appris pour commencer réellement à prendre du plaisir. Dans cette section, nous allons mettre en pratique toutes les sections précédentes et vous montrer comment commencer à faire vos compositions musicales en direct et les transformer en performance. Pour cela, nous aurons besoin de trois ingrédients principaux :

en: An ability to write code that makes sounds - CHECK!
fr: Une capacité à écrire du code qui produit des sons - C'est fait !

en: An ability to write functions - CHECK!
fr: Une capacité à écrire des fonctions - C'est fait !

en: An ability to use (named) threads - CHECK!
fr: Une capacité à utiliser des threads (nommés) - C'est fait !

en: Alrighty, let's get started. Let's live code our first sounds. We first need a function containing the code we want to play. Let's start simple. We also want to loop calls to that function in a thread:
fr: D'accord, allons-y. Codons en direct nos premiers sons. En premier lieu, nous avons besoin d'une fonction contenant le code que nous voulons jouer. Commençons simple. Nous voulons aussi une boucle d'appels à cette fonction dans un fil d'exécution :

en: If that looks a little too complicated to you, go back and re-read the sections on functions and threads. It's not too complicated if you've already wrapped your head around these things.
fr: Si ça vous semble un petit peu trop compliqué, revenez en arrière et relisez les sections sur les fonctions et les threads. Ce n'est pas trop compliqué si vous avez déjà emmagasiné ces choses dans votre tête.

en: What we have here is a function definition which just plays note 50 and sleeps for a beat. We then define a named thread called `:looper` which just loops around calling `my_sound` repeatedly.
fr: Ici nous avons une définition de fonction qui joue juste la note 50 et qui dort pendant un temps. Nous définissons ensuite un thread avec le nom `:looper` qui joue en boucle, il "boucle", en appelant `my_loop` de manière répétitive.

en: If you run this code, you'll hear note 50 repeating again and again...
fr: Si vous exécutez ce code, vous entendrez la note 50 répétée encore et encore...

en: Changing it up
fr: Modifions-le

en: Now, this is where the fun starts. Whilst the code is *still running* change 50 to another number, say 55, then press the Run button again. Woah! It changed! Live!
fr: Maintenant, c'est là que le plaisir commence. Pendant que le code est *encore en cours d'exécution* changez 50 en un autre nombre, disons 55, ensuite pressez le bouton Exécuter une nouvelle fois. Woah ! C'est modifié ! En direct !

en: It didn't add a new layer because we're using named threads which only allow one thread for each name. Also, the sound changed because we *redefined* the function. We gave `:my_sound` a new definition. When the `:looper` thread looped around it simply called the new definition.
fr: Une nouvelle couche n'a pas été ajoutée parce que nous utilisons des threads nommés et que seul un thread est permis pour chaque nom. De plus, le son a changé parce que nous *avons redéfini* la fonction. Nous avons donné à `:my_loop` une nouvelle définition. Quand le thread `:looper` a rebouclé, il a simplement appelé la nouvelle définition.

en: Try changing it again, change the note, change the sleep time. How about adding a `use_synth` statement? For example, change it to:
fr: Essayez de le modifier encore, changez la note, changer la durée de sommeil. Comment faire pour ajouter une instruction `use_synth` ? Par exemple, changez-le en :

en: define :my_sound do
      use_synth :tb303
      play 50, release: 0.3
      sleep 0.25
    end
fr: define :mon_son do
      use_synth :tb303
      play 50, release: 0.3
      sleep 0.25
    end

en: Now it sounds pretty interesting, but we can spice it up further. Instead of playing the same note again and again, try playing a chord:
fr: Maintenant, ça sonne plutôt intéressant, mais on peut le pimenter un peu plus. Au lieu de jouer la même note encore et encore, essayez de jouer un accord :

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

en: How about playing random notes from the chord:
fr: Comment faire pour jouer des notes de l'accord aléatoirement :

en: Or using a random cutoff value:
fr: Ou utiliser une valeur de cutoff aléatoire :

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

en: Finally, add some drums:
fr: Finalement, ajoutons quelques notes de batterie :

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

en: Now things are getting exciting!
fr: Maintenant, les choses commencent à devenir passionnantes !

en: However, before you jump up and start live coding with functions and threads, stop what you're doing and read the next section on `live_loop` which will change the way you code in Sonic Pi forever...
fr: Toutefois, avant que vous bondissiez et que vous vous lanciez dans le codage en direct avec des fonctions et des fils d'exécution, arrêtez ce que vous êtes en train de faire et lisez la section suivante sur `live_loop` qui va changer à jamais votre façon de coder dans Sonic Pi...

en: 9.2 Live Loops
fr: 9.2 Boucles en direct

en: Live Loops
fr: Boucles en direct

en: Ok, so this section of the tutorial is the real gem. If you only read one section, it should be this one. If you read the previous section on Live Coding Fundamentals, `live_loop` is a simple way of doing exactly that but without having to write so much.
fr: Ok, ainsi cette section du tutoriel est la véritable perle. Si vous ne lisez qu'une section, ce devrait être celle-ci. Si vous avez lu la section précédente sur les fondamentaux du codage en direct, `live_loop` est une manière simple de faire exactement la même chose mais sans avoir tant à écrire.

en: If you didn't read the previous section, `live_loop` is the best way to jam with Sonic Pi.
fr: Si vous n'avez pas lu la section précédente, `live_loop` est la meilleure façon d'improviser avec Sonic Pi.

en: Let's play. Write the following in a new buffer:
fr: Jouons. Écrivez le code suivant dans un tampon :

en: Now press the Run button. You hear a basic beep every beat. Nothing fun there. However, don't press Stop just yet. Change the `60` to `65` and press Run again.
fr: Maintenant pressez le bouton Exécuter. Vous entendez un bip basique à chaque temps. Rien de plaisant pour l'instant. Toutefois, ne pressez pas tout de suite le bouton Arrêter. Changez le `60` en `65` et pressez Exécuter à nouveau.

en: Woah! It changed *automatically* without missing a beat. This is live coding.
fr: Woah ! Ça a changé *automatiquement* sans manquer un temps. C'est du codage en direct.

en: Why not change it to be more bass like? Just update your code whilst it's playing:
fr: Pourquoi ne pas le modifier pour ressembler plus à une basse ? Modifiez juste votre code pendant que ça joue :

en: Then hit Run.
fr: Puis pressez Exécuter.

en: Let's make the cutoff move around:
fr: Faisons bouger le cutoff aléatoirement :

en: Hit Run again.
fr: Puis pressez Exécuter à nouveau.

en: Add some drums:
fr: Ajoutez de la batterie :

en: Change the note from `e1` to `c1`:
fr: Changez la note de `e1` en `c1` :

en: Now stop listening to me and play around yourself! Have fun!
fr: Maintenant, arrêtez de me suivre et jouez vous-même ! Ayez du plaisir !

en: 9.3 Multiple Live Loops
fr: 9.3 Boucles multiples en direct

en: Multiple Live Loops
fr: Boucles multiples en direct

en: Consider the following live loop:
fr: Considérez la boucle en direct suivante :

en: You may have wondered why it needs the name `:foo`. This name is important because it signifies that this live loop is different from all other live loops.
fr: Vous vous êtes peut-être demandé pourquoi elle avait besoin du nom `:foo`. Ce nom est important parce qu'il signifie que cette boucle est différente des autres boucles en direct.

en: *There can never be two live loops running with the same name*.
fr: *Il ne peut y avoir deux boucles en direct en cours d'exécution avec le même nom*.

en: This means that if we want multiple concurrently running live loops, we just need to give them different names:
fr: Ce qui signifie que si nous voulons de multiples boucles en direct s'exécutant en simultané, nous devons simplement leur donner des noms différents :

en: You can now update and change each live loop independently and it all just works.
fr: Vous pouvez maintenant modifier et changer chaque boucle indépendamment et tout fonctionne.

en: Syncing Live Loops
fr: Synchronisation des boucles en direct

en: One thing you might have already noticed is that live loops work automatically with the thread cue mechanism we explored previously. Every time the live loop loops, it generates a new `cue` event with the name of the live loop. We can therefore `sync` on these cues to ensure our loops are in sync without having to stop anything.
fr: Une chose que vous pourriez avoir déjà remarqué est que ces boucles en direct fonctionnent automatiquement avec le mécanisme de thread que nous avons exploré précédemment. Chaque fois qu'une boucle en direct boucle, elle génère un nouvel événement `cue` avec le même nom que la boucle. Par conséquent, nous pouvons nous `sync` sur ces repères pour garantir que ces boucles soient synchronisées sans avoir à arrêter quoi que ce soit.

en: Consider this badly synced code:
fr: Considérez ce code mal synchronisé :

en: Let's see if we can fix the timing and sync without stopping it. First, let's fix the `:foo` loop to make the sleep a factor of 1 - something like `0.5` will do:
fr: Voyons si nous pouvons corriger le timing et synchroniser sans arrêter l'exécution. Corrigeons la boucle `:foo` pour l'aligner sur le facteur de sleep de 1 - quelque chose comme `0.5` fera l'affaire :

en: We're not quite finished yet though - you'll notice that the beats don't quite line up correctly. This is because the loops are *out of phase*. Let's fix that by syncing one to the other:
fr: Cependant, nous n'avons pas encore tout à fait fini - vous remarquerez que les temps ne battent pas ensemble correctement. C'est parce que les boucles sont *déphasées*. Corrigeons cela en les synchronisant :

en: Wow, everything is now perfectly in time - all without stopping.
fr: Wow, tout est maintenant parfaitement en phase - tout cela sans arrêter.

en: Now, go forth and live code with live loops!
fr: Maintenant, allez de l'avant et codez en direct avec des boucles en direct !

en: 9.4 Ticking
fr: 9.4 Avance automatique

en: Ticking
fr: Avance automatique

en: Something you'll likely find yourself doing a lot when live coding is looping through rings. You'll be putting notes into rings for melodies, sleeps for rhythms, chord progressions, timbral variations, etc. etc.
fr: Quelque chose que vous vous retrouverez probablement à faire beaucoup en codant en direct est de boucler au travers d'anneaux. Vous mettrez des notes dans des anneaux pour les mélodies, des pauses pour les rythmes, des progressions d'accords, des variations de timbre, etc. etc.

en: Ticking Rings
fr: Parcours automatique des anneaux

en: Sonic Pi provides a *very* handy tool for working with rings within `live_loop`s. It's called the tick system. In the section about the rings we were talking about the counter that is constantly increasing, like a current beat number. Tick just implements this idea. It provides you with the ability to *tick through rings*. Let's look at an example:
fr: Sonic Pi fournit un outil *très* pratique pour travailler avec les anneaux à l'intérieur des `live_loop`s. Il s'agit du système d'avance automatique ("tick"). Dans la section sur les anneaux, on parlait d'un compteur qui augmente constamment, comme un nombre courant de battements. "Tick" implémente justement cette idée. Il vous fournit la capacité de *parcourir des anneaux*. Regardons un exemple :

en: This is equivalent to:
fr: C'est l'équivalent de :

en: Here, we're just grabbing the scale E3 minor pentatonic and ticking through each element. This is done by adding `.tick` to the end of the scale declaration. This tick is local to the live loop, so each live loop can have its own independent tick:
fr: Ici, nous prenons simplement la gamme mineure pentatonique de Mi3 et nous la parcourons élément par élément. C'est fait en ajoutant `.tick` à la fin de la déclaration de la gamme. Ce "tick" est local à la boucle en direct, ainsi chaque boucle en direct a son propre "tick" indépendant :

en: Tick
fr: Fonction Tick

en: You can also call `tick` as a standard fn and use the value as an index:
fr: Vous pouvez également appeler `tick` comme une fonction standard et utiliser sa valeur de retour comme un index :

en: However, it is much nicer to call `.tick` at the end. The `tick` fn is for when you want to do fancy things with the tick value and for when you want to use ticks for other things than indexing into rings.
fr: Cependant, c'est plus joli d'appeler `.tick` à la fin. La fonction `.tick` est faite pour les cas où vous voulez faire des fantaisies avec la valeur retournée ou utiliser les "ticks" pour autre chose que l'indexation des anneaux.

en: Look
fr: Fonction Look

en: The magical thing about tick is that not only does it return a new index (or the value of the ring at that index) it also makes sure that next time you call tick, it's the next value. Take a look at the examples in the docs for `tick` for many ways of working with this. However, for now, it's important to point out that sometimes you'll want to just look at the current tick value and *not increase* it. This is available via the `look` fn. You can call `look` as a standard fn or by adding `.look` to the end of a ring.
fr: La chose magique apportée par "tick" est que non seulement un nouvel index est retourné (ou la valeur de l'anneau à cet index), mais qu'il garantit que la fois suivante où vous l'appellerez, vous obtiendrez la valeur suivante. Jetez un œil aux exemples dans la documentation pour `.tick` pour voir les différentes façons de l'employer. Toutefois, pour le moment, il est important de souligner que quelquefois, vous voulez juste obtenir la valeur courante de "tick" sans l'*incrémenter*. Ceci est disponible via la fonction `look`. Vous pouvez appeler `look` comme une fonction standard ou ajouter `.look` à la fin d'un anneau.

en: Naming Ticks
fr: Nommage des Ticks

en: Finally, sometimes you'll need more than one tick per live loop. This is achieved by giving your tick a name:
fr: Finalement, vous avez quelques fois besoin de plus d'un "tick" par boucle en direct. C'est réalisé en donnant un nom à vos "ticks" :

en: Here we're using two ticks one for the note to play and another for the sleep time. As they're both in the same live loop, to keep them separate we need to give them unique names. This is exactly the same kind of thing as naming `live_loop`s - we just pass a symbol prefixed with a `:`. In the example above we called one tick `:foo` and the other `:bar`. If we want to `look` at these we also need to pass the name of the tick to `look`.
fr: Ici, nous utilisons deux "ticks", un pour la note à jouer et un autre pour la durée de sommeil. Comme ils sont tous deux dans la même boucle, pour les maintenir indépendants, nous devons leur donner des noms uniques. C'est exactement le même genre de solution que dans le cas du nommage des `live_loop`s - nous passons simplement un symbole précédé d'un `:`. Dans l'exemple ci-dessus, nous avons appelé un "tick" `:foo` et l'autre `:bar`. Si nous voulons juste connaître leur valeur, nous devons aussi passer le nom du "tick" à `look`.

en: Don't make it too complicated
fr: Ne faites pas de choses trop compliquées

en: Most of the power in the tick system isn't useful when you get started. Don't try and learn everything in this section. Just focus on ticking through a single ring. That'll give you most of the joy and simplicity of ticking through rings in your `live_loop`s.
fr: La plupart de la puissance du système des "ticks" n'est pas utile quand vous débutez. N'essayez pas et n'apprenez pas tout dans cette section. Concentrez-vous seulement sur le parcours d'un simple anneau. Cela vous procurera la plus grande part de la joie et de la simplicité du parcours des anneaux dans vos `live_loop`s.

en: Take a look at the documentation for `tick` where there are many useful examples and happy ticking!
fr: Jetez un œil à la documentation des `tick`s où se trouvent de nombreux exemples utiles, et joyeux parcours automatiques !

en: 10 Time State
fr: 10 État du temps

en: Time State
fr: État du temps

en: Often it is useful to have information that is *shared across multiple threads or live loops*. For example, you might want to share a notion of the current key, BPM or even more abstract concepts such as the current 'complexity' (which you'd potentially interpret in different ways across different threads). We also don't want to lose any of our existing determinism guarantees when doing this. In other words, we'd still like to be able to share code with others and know exactly what they'll hear when they run it. At the end of Section 5.6 of this tutorial we briefly discussed why we *should not use variables to share information across threads* due to a loss of determinism (in turn due to race conditions).
fr: Il est souvent utile d'avoir de l'information qui est *partagée à travers plusieurs fils d'exécution ou boucles en direct*. Par exemple, vous pourriez vouloir partager une notion de la clef courante, de BPM, ou des concepts encore plus abstraits comme la 'complexité' courante (que vous pourriez potentiellement interpréter de manière différente à travers divers fils). Nous ne voulons pas non plus perdre aucune nos garanties existantes de déterminisme en faisant cela. En d'autres mots, nous aimerions être toujours capable de partager du code avec d'autres, et savoir exactement ce qu'ils vont entendre en l'exécutant. À la fin de la Section 5.6 de ce tutoriel, nous avons discuté brièvement de pourquoi nous *ne devrions pas utiliser des variables pour partager l'information à travers les fils d'exécution* à cause d'une perte de déterminisme (ce qui est dû à la concurrence).

en: Sonic Pi's solution to the problem of easily working with global variables in a deterministic way is through a novel system it calls Time State. This might sound complex and difficult (in fact, in the UK, programming with multiple threads and shared memory is typically a university level subject). However, as you'll see, just like playing your first note, *Sonic Pi makes it incredibly simple to share state across threads* whilst still keeping your programs *thread-safe and deterministic*.
fr: La solution de Sonic Pi au problème de travailler facilement avec les variables globales d'une manière déterministe est un système novateur appelé l'État du Temps. Cela peut sembler complexe et difficile (en fait, au Royaume-Uni, la programmation avec plusieurs fils d'exécution et de la mémoire partagée est habituellement un sujet de niveau universitaire). Toutefois, comme vous allez le voir, tout comme jouer votre première note, *Sonic Pi rend incroyablement simple le partage d'état entre les fils d'exécution* tout en conservant vos programmes *avec des fils d'exécution sûrs et déterministes.*.

en: Meet `get` and `set`...
fr: Rencontrez `get` et `set`...

en: 10.1 Set and Get
fr: 10.1 Paramétrer et obtenir

en: Set and Get
fr: Paramétrer et obtenir

en: Sonic Pi has a global memory store called Time State. The two main things you do with it are to `set` information and `get` information. Let's dive deeper...
fr: Sonic Pi a un magasin de mémoire global appelé État du Temps. Les deux choses principales que vous faites avec sont de `set` de l'information et de `get` de l'information. Explorons plus en détails...

en: Set
fr: Paramétrer

en: To store information into the Time State we need two things:
fr: Pour stocker de l'information dans l'État du Temps, nous avons besoin de deux choses :

en: the information we want to store,
fr: l'information que nous voulons stocker,

en: a unique name (key) for the information.
fr: un nom unique (clé) pour l'information.

en: For example, we might want to store the number `3000` with the key `:intensity`. This is possible using the `set` function:
fr: Par exemple, nous voulons stocker le chiffre `3000` avec la clé `:intensity`. C'est possible en utilisant la fonction `set` :

en: We can use any name for our key. If information has already been stored with that key, our new `set` will override it:
fr: Nous pouvons utiliser n'importe quel nom pour notre clé. Si de l'information a déjà été stockée avec cette clé, notre nouveau `set` va l'écraser :

en: In the above example, as we stored both numbers under the same key, the last call to `set` 'wins', so the number associated with `:intensity` will be `3000` as the first call to `set` is effectively overridden.
fr: Dans l'exemple ci-dessus, étant donné que nous stockons deux nombres avec la même clé, le dernier appel à `set` "gagne", alors le nombre associé à `:intensity` sera `3000` étant donné que le premier appel à `set` est écrasé.

en: Get
fr: Obtenir

en: To fetch information from the Time State we just need the key we used to `set` it, which in our case is `:intensity`. We then just need to call `get[:intensity]` which we can see by printing out the result to the log:
fr: Pour obtenir de l'information de l'État du Temps, nous avons seulement besoin de la clé que nous avons utilisée pour la `set`, qui est dans notre cas `:intensity`. Nous avons alors seulement besoin d'appeler `get[:intensity]` que nous pouvons voir en affichant le résultat dans le journal :

en: Notice that calls to `get` can return information that was `set` in a previous run. Once a piece of information has been `set` it is available until either the information is overridden (just like we clobbered the `:intensity` value of `1000` to `3000` above) or Sonic Pi is closed.
fr: Notez que l'appel à `get` peut retourner de l'information qui a été `set` dans une exécution précédente. Une fois qu'une pièce d'information a été `set`, elle est disponible jusqu'à ce qu'elle soit écrasée (comme nous l'avons fait avec la valeur de `:intensity` passant de `1000` à `3000` ci-dessus) ou que Sonic Pi soit fermé.

en: Multiple Threads
fr: Fils multiples

en: The main benefit of the Time State system is that it can be safely used across threads or live loops. For example, you could have one live loop setting information and another one getting it:
fr: L'avantage principal du système d'État du Temps est qu'il peut être utilisé de façon sûre au travers des fils d'exécution ou des boucles en direct. Par exemple, vous pourriez avoir une boucle en direct qui affecte de l'information et une autre qui l'obtient :

en: The nice thing about using `get` and `set` across threads like this is that it will always produce the same result every time you hit run. Go on, try it. See if you get the following in your log:
fr: La chose plaisante avec l'utilisation de `get` et `set` au travers des fils d'exécution de cette façon est que ça produira toujours le même résultat à chaque fois que vous l'exécuterez. Allez-y, essayez-le. Regardez si vous obtenez le journal suivant :

en: Try running it a few times - see, it's the same every time. This is what we call deterministic behaviour and it's really very important when we want to share our music as code and know that the person playing the code is hearing exactly what we wanted them to hear (just like playing an MP3 or internet stream sounds the same for all listeners).
fr: Essayez de l'exécuter quelques fois - vous voyez, c'est toujours la même chose. C'est ce qu'on appelle un comportement déterministe et c'est très important quand nous voulons partager notre musique sous forme de code et que nous savons que la personne qui exécute le code entend exactement ce que nous voulions qu'elle entende (tout comme jouer un MP3 ou flux d'internet sonne de la même façon pour tout ceux qui écoutent).

en: A Simple Deterministic State System
fr: Un système d'état simple et déterministe

en: Back in Section 5.6 we discussed why using variables across threads can lead to random behaviour. This stops us from being able to reliably reproduce code such as this:
fr: À la Section 5.6, nous avons discuté de pourquoi l'utilisation des variables à travers les fils peut entraîner des comportements hasardeux. Ceci nous empêche de pouvoir, de façon sûre, reproduire du code comme ceci :

en: ## 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
fr: ## Un exemple de comportement non-déterministe
    ## (du à la concurrence causée pas de multiple
    ## boucles en direct qui manipule la même variable
    ## au même moment).
    ##  
    ## Si vous exécutez ce code, vous remarquerez
    ## que la liste qui est imprimée
    ## n'est pas toujours triée!
    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

en: Let's take a look at how this might look using `get` and `set`:
fr: Regardons à quoi cela peut ressembler en utilisant `get` and `set` :

en: ## 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
fr: ## Un exemple de comportement déterministe
    ## (malgré l'accès avec concurrence de l'état partagé)
    ## en utilisant le nouveau système d'État du Temps de Sonic Pi.
    ##
    ## Quand ce code est exécuté, la liste qui est
    ## imprimée est toujours triée!
    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

en: Notice how this code is pretty much identical to the version using a variable before it. However when you run the code, it behaves as you would expect with any typical Sonic Pi code - *it does the same thing every time* in this case thanks to the Time State system.
fr: Remarquez comment le code est pratiquement identique à la version qui utilisait la variable auparavant. Cependant, quand vous exécutez votre code, il agit de la façon que vous vous attendez comme avec n'importe lequel code de Sonic Pi typique - *il fait la même chose chaque fois* dans ce cas grâce au système d'État du Temps.

en: Therefore, when sharing information across live loops and threads, use `get` and `set` instead of variables for deterministic, reproducible behaviour.
fr: Donc, lorsque vous partagez de l'information au travers de boucles en direct et de fils d'exécution, utilisez `get` et `set` au lieu de variables pour un comportement déterministe et reproductible.

en: Section 5.7 introduced the functions `cue` and `sync` when dealing with the issue of synchronising threads. What it didn't explain was that it is the Time State system which provides this functionality. It just so happens that `set` is actually a variation of `cue` and is built on top of the same core functionality which is to insert information into the Time State system. Additionally, `sync` is also designed in such a way that it works seamlessly with Time State - any information that we plan to store in Time State we can sync on. In other words - *we `sync` on events yet to be inserted into Time State*.
fr: La section 5.7 a introduit les fonctions `cue` et `sync` lorsque nous rencontrons des problèmes de synchronisation de fils d'exécution. Ce qui n'y était pas expliqué était qu'il s'agit du système d'État du Temps qui permet cette fonctionnalité. Enfaite, la fonction `set` est une variation de `cue` et est construite sur la même fonctionnalité de base qui est d'insérer de l'information dans le système d'État du Temps. De plus, `sync` a été créé d'une façon qui lui permet de travailler parfaitement avec l'État du Temps - toute information que nous prévoyons stocker dans l'État du Temps, nous pouvons la synchroniser.

en: Waiting for Events
fr: Attendre pour les événements

en: Let's take a quick look at how to use `sync` to wait for new events to be added to Time State:
fr: Regardons rapidement comment utiliser `sync` pour attendre que de nouveaux événements soient ajoutés à l'État du Temps :

en: In this example first we create a thread which waits for a `:foo` event to be added to the Time State. After this thread declaration we sleep for 2 beats and then `set` `:foo` to be `1`. This then releases the `sync` which then moves to the next line which is to trigger the `:ambi_lunar_land` sample.
fr: Dans cet exemple, nous commençons par créer un fil d'exécution qui attend pour qu'un événement `:foo` soit ajouté à l'État du Temps. Après la déclaration du fil d'exécution, nous dormons pour deux rythmes et nous `set` `:foo` à `1`. Cela relâche ensuite le `sync` qui se rend ensuite à la prochaine ligne qui est de déclencher l'exemple `:ambi_lunar_land`.

en: Note that `sync` always waits for *future events* and that it will block the current thread waiting for a new event. Also, it will inherit the logical time of the thread which triggered it via `set` or `cue` so it may also be used to sync time.
fr: Noter que `sync` attend toujours pour *des événements futurs* et qu'il bloque le fil d'exécution actuel en attendant ce nouvel événement. Également, il va hériter du temps logique du fil d'exécution qui est déclenché par `set` ou `cue`, donc il peut être utilisé également pour synchroniser le temps.

en: Passing values into the Future
fr: Transférer des valeurs dans le Futur

en: In the example above we set `:foo` to `1` which we did nothing with. We can actually get this value from the thread calling `sync`:
fr: Dans l'exemple ci-dessus, nous avons affecté `1` à `:foo` et en avons rien fait. Nous pouvons obtenir cette valeur à partir du fil d'exécution en appelant `sync` :

en: 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.
fr: Notez que les valeurs transférées au travers de `set` et `cue` doivent être protégées des fils d'exécution - c'est-à-dire des anneaux immuables, des nombres, des symboles ou des chaînes de caractères fixes. Sonic Pi lancera une erreur si la valeur que vous essayez de stocker dans l'État du Temps n'est pas valide.

en: 10.3 Pattern Matching
fr: 10.3 Correspondance de motif

en: Pattern Matching
fr: Correspondance de motif

en: When getting and setting information into the Time State, it's possible to use more complex keys than basic symbols such as `:foo` and `:bar`. You can also use URL style strings called paths such as `"/foo/bar/baz"`. Once we start working with paths, we can then start taking advantage of Sonic Pi's sophisticated pattern matching system to `get` and `sync` with 'similar' rather than 'identical' paths. Let's take a look.
fr: Quand vous obtenez et affectez de l'information dans l'État du Temps, il est possible d'utiliser des clés plus complexes que les symboles basiques comme `:foo`et `:bar`. Vous pouvez également utiliser des chaînes de caractères de format URL appelées chemin comme `"/foo/bar/baz"`. Lorsque nous avons commencé à travailler avec les chemins, nous pouvons commencer à prendre avantage du système sophistiqué de correspondance de motif de Sonic Pi pour `get` et `sync` des chemins "similaires" au lieu "d'identiques". Étudions cela de plus près.

en: Match any path segment
fr: Faire correspondre n'importe quel segment de chemin

en: Let's assume we want to wait for the next event that has three path segments:
fr: Assumons que nous voulons attendre pour le prochain événement qui a trois segments de chemin :

en: This will match any Time State event with exactly three path segments, regardless of their names. For example:
fr: Ceci va faire une correspondance avec tout événement d'État du Temps avec exactement trois segments de chemin, et ce, peu importe leur nom. Par exemple :

en: However, it will *not* match paths with fewer or more path segments. The following will not match:
fr: Toutefois, ça *ne* correspondra *pas* avec des chemins qui ont plus ou moins de segments. L'élément suivant n'aura pas de correspondance :

en: Each `*` means *any content*. So we could match paths with just one segment with `/*` or paths with five segments with `/*/*/*/*/*`
fr: Chaque `*` signifie *n'importe quel contenu*. Donc, nous pourrions trouver des correspondance avec des chemins d'un seul segment avec `/*` ou des chemins avec cinq segments avec `/*/*/*/*/*`

en: Matching partial segments
fr: Faire des correspondances de segments partiels

en: If we know what the segment is going to start or finish with, we can use a `*` in addition to a partial segment name. For example: `"/foo/b*/baz"` will match any path that has three segments, the first of which is `foo`, the last `baz` and the middle segment can be anything that starts with `b`. So, it would match:
fr: Si nous savons par quoi le segment va commencer ou finir, nous pouvons utiliser un `*` en plus d'un nom de segment partiel. Par exemple : `"/foo/b*/baz"` correspondra à tout chemin possédant trois segments, le premier étant `foo`, le dernier `baz`, et celui du milieu pouvant être n'importe quoi commençant par un `b`. Il correspondra alors à :

en: However, it wouldn't match the following:
fr: Cependant, cela ne correspondrait pas avec ceci :

en: You can also place the `*` at the start of the segment to specify the last characters of a segment: `"/foo/*zz/baz"` which will match any 3 segment `cue` or `set` where the first segment is `foo`, the last is `baz` and the middle segment ends with `zz` such as `"cue "/foo/whizz/baz"`.
fr: Vous pouvez également placer le `*` au début du segment pour spécifier les derniers caractères d'un segment : `"/foo/*zz/baz"` ce qui correspondra à n'importe quel triple segment `cue` ou `set` où le premier segment est `foo`, le dernier est `baz` et celui du milieu fini avec `zz` comme `"cue "/foo/whizz/baz"`.

en: Matching Nested Path Segments
fr: Faire correspondre des segments de chemins imbriqués

en: Sometimes you don't know how many path segments you want to match. In these cases you can use the powerful double star: `**` such as `"/foo/**/baz"` which will match:
fr: Parfois, vous ne connaissez pas le nombre de segments de chemin devant correspondre. Dans ce cas, vous pouvez utiliser la puissante double-étoile : `**` et ainsi `"/foo/**/baz"` correspondra à :

en: Matching Single Letters
fr: Faire correspondre des lettres

en: You can use the `?` character to match against a single char such as `"/?oo/bar/baz"` which will match:
fr: Vous pouvez utiliser le caractère `?` pour faire une correspondance sur un seul caractère comme `"/?oo/bar/baz"` ce qui correspondra avec :

en: Matching Multiple Words
fr: Faire correspondre plusieurs mots

en: If you know that a segment may be one of a select number of words, you can use the `{` and `}` matchers to specify a list of choices such as `"/foo/{bar,beans,eggs}/quux"` which will only match the following:
fr: Si vous savez qu'un segment pourrait être un parmi un ensemble particulier de mots, vous pouvez utiliser les correspondances `{` et `}` pour spécifier une liste de choix tel que `"/foo/{bar,beans,eggs}/quux"` qui correspondra uniquement à ceci :

en: Matching Multiple Letters
fr: Faire correspondre plusieurs lettres

en: Finally, you can match against a selection of letters if you use the `[` and `]` matchers to specify a list of choices such as `"/foo/[abc]ux/baz"` which will match only:
fr: Finalement, vous pouvez faire correspondre à une sélection de lettres si vous utilisez les correspondances `[` et `]` pour spécifier une liste de choix tel que `"/foo/[abc]ux/baz"` qui correspondra uniquement à :

en: You can also use the `-` character to specify ranges of letters. For example `"/foo/[a-e]ux/baz"` which will match only:
fr: Vous pouvez également utiliser le caractère `-` pour spécifier un ensemble de lettres. Par exemple `"/foo/[a-e]ux/baz"` qui correspondra uniquement à :

en: Combining Matchers
fr: Combiner des correspondances

en: When calling `sync` or `get` you are free to combine matchers in any order you see fit to powerfully match any Time State event created by `cue` or `set`. Let's look at a far-fetched example:
fr: En appelant `sync` ou `get`, vous êtes libre de combiner des correspondances dans n'importe quel ordre qui vous convient pour faire correspondre des événements d'état du Temps créés par `cue` ou `set`. Regardons un exemple fou :

en: OSC Pattern Matching
fr: Correspondance de motif OSC

en: 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
fr: Pour les curieux, ces règles de correspondance sont basées sur la spécification de correspondance de motif Open Sound Control, qui est expliquée en détail ici : https://opensoundcontrol.stanford.edu/spec-1_0.html

en: 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:
fr: Une fois que vous avez maîtrise la conversion du code en musique, vous vous demandez peut-être : quel est la suite ? Parfois les contraintes de travailler purement dans la syntaxe de Sonic Pi et d'un système de son peut paraître excitant et vous placez dans une nouvelle position créative. Toutefois, parfois il est essentiel de sortir du code pour aller dans le vrai monde. Nous voulons deux choses supplémentaires :

en: To be able to convert actions in the real world into Sonic Pi events to code with
fr: Pour être capable de convertir des actions du vrai monde en événements de Sonic Pi avec lesquels coder

en: To be able to use Sonic Pi's strong timing model and semantics to control and manipulate objects in the real world
fr: Pour être capable d'utiliser le model fort de timing de Sonic Pi et ses sémantiques pour contrôler et manipuler les objets dans le vrai monde

en: 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.
fr: Heureusement, il existe un protocole depuis les années 80 qui permet exactement ce genre d'interactions : MIDI. Il y a un nombre incroyable de périphériques externes en incluant les claviers, les contrôleurs, les séquenceurs et des logiciels d'audio professionnels qui supportent tous le MIDI. Nous pouvons utiliser le MIDI pour recevoir des données et en envoyer.

en: 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...
fr: Sonic Pi supporte entièrement le protocole MIDI ce qui vous permet de connecter votre code au vrai monde. Explorons-le plus en détails ...

en: 11.1 MIDI In
fr: 11.1 MIDI Entrée

en: MIDI In
fr: MIDI Entrée

en: 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!
fr: Dans cette section, nous allons apprendre comment connecter un contrôleur MIDI pour envoyer des événements dans Sonic Pi pour contrôler nos synthés et nos sons. Allez chercher un contrôleur MIDI comme un clavier ou une surface de contrôle et devenons physique !

en: Connecting a MIDI Controller
fr: Connecter un contrôleur MIDI

en: In order to get information from an external MIDI device into Sonic Pi we first need to connect it to our computer. Typically this will be via a USB connection, although older equipment will have a 5-pin DIN connector for which you'll need hardware support for your computer (for example, some sound cards have MIDI DIN connectors). Once you've connected your device, launch Sonic Pi and take a look at the IO section of the Preferences panel. You should see your device listed there. If not, try hitting the 'Reset MIDI' button and see if it appears. If you're still not seeing anything, the next thing to try is to consult your operating system's MIDI config to see if it sees your device. Failing all that, feel free to ask questions in our friendly forums: https://in-thread.sonic-pi.net
fr: Afin d'obtenir des informations de la part d'un périphérique MIDI externe dans Sonic Pi, nous devons d'abord le connecter à notre ordinateur. Le plus souvent, ce sera par une connexion USB, quoi que les vieux équipements auront des connecteurs 5-pins nécessitant que votre ordinateur le supporte physiquement (par exemple, certaines cartes sons internes ont des connecteurs MIDI DIN). Une fois que votre périphérique est connecté, démarrez Sonic Pi et jetez un coup d’œil à la section IO du panneau Préférences. Vous devriez voir le nom de votre périphérique. Si ce n'est pas le cas, essayez de presser le bouton 'Reset MIDI' et regarder s'il apparaît. Si vous ne voyez toujours rien, la prochaine chose à essayer est de consulter la configuration MIDI de votre système d'exploitation pour vérifier si votre périphérique est reconnu. Si tout ça ne marche pas, n'hésitez pas à demander de l'aide sur notre forum amical : https://in-thread.sonic-pi.net

en: Receiving MIDI Events
fr: Recevoir des événements MIDI

en: Once your device is connected, Sonic Pi will automatically receive events. You can see for yourself by manipulating your MIDI device and looking at the cue logger in the bottom right of the application window below the log (if this isn't visible go to Preferences->Editor->Show & Hide and enable the 'Show cue log' tickbox). You'll see a stream of events such as:
fr: Une fois que votre périphérique est connecté, Sonic Pi recevra automatiquement les événements. Vous pouvez le voir par vous-même en manipulation votre périphérique MIDI et en regardant la queue de journalisation dans le secteur inférieur droit de votre fenêtre d'application en-dessous du journal ( si ce n'est pas visible allez dans Préférences->Éditeur->Afficher & Cacher et activer le "Afficher la queue de journalisation"). Vous verrez un flux d'événements comme :

en: 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!
fr: Une fois que vous pouvez voir un flux de messages comme cela, vous avez connecté avec succès votre périphérique MIDI. Félicitations, voyons ce que nous pouvons faire avec !

en: MIDI Time State
fr: État du Temps MIDI

en: These events are broken into two sections. Firstly there's the name of the event such as `/midi:nanokey2_keyboard:0:1/note_on` and secondly there's the values of the event such as `[18, 62]`. Interestingly, these are the two things we need to store information in Time State. *Sonic Pi automatically inserts incoming MIDI events into Time State*. This means you can `get` the latest MIDI value and also `sync` waiting for the next MIDI value using everything we learned in section 10 of this tutorial.
fr: Ces événements sont divisés en deux sections. Premièrement, il y a le nom de l'événement comme `/midi:nanokey2_keyboard:0:1/note_on`. Deuxièmement, il y a les valeurs de l'événement comme `[18, 62]`. Fait intéressant, ce sont deux choses dont nous avons besoin pour stocker de l'information dans l'État du temps. *Sonic Pi insère automatiquement les événements MIDI entrants dans l'État du Temps*. Cela veut dire que vous pouvez `get` la dernière valeur MIDI et aussi `sync` pour attendre la prochaine valeur MIDI en utilisant tout ce que nous avons appris dans la section 10 de ce tutoriel.

en: Controlling Code
fr: Code de contrôle

en: 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:
fr: Maintenant que nous avons connecté un périphérique MIDI, vu ses événements dans la queue du journal et découvert que notre connaissance de l'État du Temps est tout ce dont nous avons besoin pour travailler avec les événements, nous pouvons maintenant commencer à avoir du plaisir. Construisons un piano MIDI simple :

en: 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.
fr: Il y a quelques éléments qui se passent dans le code ci-dessus, incluant certains problèmes. Premièrement, nous avons une `live_loop` simple qui se répétera éternellement en exécutant le code entre le bloc `do`/`end`. Cela a été introduit dans la section 9.2. Deuxièmement, nous appelons `sync` pour attendre le prochain événement de l'État du Temps correspondant. Nous utilisons une chaîne de caractères qui représente le message MIDI que nous recherchons (qui est le même que celui affiché dans la queue du journal). Notez que cette longue chaîne de caractères vous est fournie par le système d’auto-complétion de Sonic Pi pour que vous n'ayez pas à la taper en entier manuellement. Dans le journal, nous avons vu qu'il y avait deux valeurs pour chaque événement de note MIDI, donc nous assignons le résultat à deux variables séparées `note` et `velocity`. Finalement, nous déclenchons le synthé `:piano` en passant notre note.

en: 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:
fr: Maintenant, essayez-le. Tapez le code ci-dessus, remplacez la clé de synchronisation avec une chaîne de caractères qui correspond à votre périphérique MIDI spécifique et pressez Exécuter. Hey presto, vous avez un piano qui fonctionne ! Par contre, vous remarquerez probablement quelques problèmes : premièrement, toutes les notes sont au même volume, et ce, peu importe à quelle force vous pressez sur le clavier. Cela peut être réglé facilement en utilisant la valeur de vélocité MIDI et en la convertissant à une amplitude. Étant donné que MIDI a un intervalle de 0->127, pour convertir ce nombre en une valeur entre 0 et 1, nous pouvons simplement le diviser par 127 :

en: Update the code and hit Run again. Now the velocity of the keyboard is honoured. Next, let's get rid of that pesky pause.
fr: Mettez à jour le code et pressez Exécuter de nouveau. Maintenant la vélocité du clavier est respectée. Ensuite, débarrassons-nous de cette pause casse-pieds.

en: Removing Latency
fr: Enlever la latence

en: 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:
fr: Avant que nous puissions enlever la pause, nous devons savoir pourquoi elle est là. Dans le but de conserver les synthés et les effets bien synchronisés au travers une variété de processeurs différents, Sonic Pi prévoit l'audio *en avance* de 0.5s par défaut. (Notez que cette latence ajoutée peut être configurée via les fonctions `set_sched_ahead_time!` et `use_sched_ahead_time`). Cette latence de 0.5s est ajoutée à nos déclencheurs de synthé `:piano` puisqu'elle est ajoutée à tous les synthés déclenchés par Sonic Pi. Habituellement, nous voulons réellement cette latence ajoutée puisque cela signifie que tout les synthés seront bien synchronisés. Par contre, cela fait seulement du sens pour les synthés déclenchés par le code en utilisant `play` et `sleep`. Dans ce cas-ci, nous déclenchons le synthé `:piano` avec notre périphérique MIDI externe et nous ne voulons donc pas que Sonic Pi contrôle la synchronisation pour nous. Nous pouvons fermer cette latence avec la commande `use_real_time` ce qui désactive la latence pour le fil d'exécution courant. Cela veut dire que vous pouvez utiliser le mode temps réel pour les boucles en direct qui ont leur synchronisation contrôlée par `sync` avec des périphériques externes, et conserver la latence par défaut pour toutes les autres boucles en direct. Voyons cela de plus près :

en: 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!
fr: Modifiez votre code pour correspondre avec le code ci-dessus et pressez Exécuter de nouveau. Maintenant, nous avons un piano basse latence avec une vélocité variable codée en seulement 5 lignes. N'était-ce pas facile ?

en: Getting Values
fr: Obtenir des valeurs

en: 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...
fr: Finalement, étant donné que nos événements MIDI vont directement dans l'État du Temps, nous pouvons également utiliser la fonction `get` pour récupérer la dernière valeur vue. Cela ne bloque pas le fil d'exécution courant et retourne `nil` s'il n'y a aucune valeur trouvée ( que vous pouvez outrepasser en passant une valeur par défaut - regarder la documentation pour `get`). Rappelez-vous que vous pouvez appeler `get` dans n'importe quel fil d'exécution à n'importe quel moment pour voir la dernière valeur correspondante d'État du Temps. Vous pouvez même utiliser `time_warp` pour retourner dans le temps et appeler `get` pour voir les événements du passé...

en: Now You are in Control
fr: Maintenant vous êtes en contrôle

en: The exciting thing now is that you can now use the same code structures to `sync` and `get` MIDI information from any MIDI device and do whatever you want with the values. You can now choose what your MIDI device will do!
fr: Le truc génial maintenant est que vous pouvez à présent utiliser les même structures de code pour synchroniser (`sync`) et obtenir (`get`) des information MIDI depuis tout périphérique MIDI et faire tout ce que vous voulez avec ces valeurs. Vous pouvez maintenant choisir ce que votre périphérique MIDI fera !

en: 11.2 MIDI Out
fr: 11.2 Sortie MIDI

en: MIDI Out
fr: Sortie MIDI

en: 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:
fr: En plus de recevoir des événements MIDI, nous pouvons également envoyer des événements MIDI pour déclencher et contrôler des équipements externes comme les synthés, claviers et autres périphériques. Sonic Pi propose un ensemble complet de fonctions pour envoyer des messages MIDI variés comme :

en: Note on - `midi_note_on`
fr: Note activée - `midi_note_on`

en: Note off - `midi_note_off`
fr: Note désactivée - `midi_note_off`

en: Control change - `midi_cc`
fr: Contrôler le changement - `midi_cc`

en: Pitch bend - `midi_pitch_bend`
fr: Amplitude courbée - `midi_pitch_bend`

en: Clock ticks - `midi_clock_tick`
fr: Tic d'horloge - `midi_clock_tick`

en: There are many other supported MIDI messages too - check out the API documentation for all the other fns that start with `midi_`.
fr: Il y a plein d'autres messages MIDI supportés également - jetez un coup d’œil à la documentation de l'API pour toutes les autres fonctions qui débutent par `midi_`.

en: Connecting to a MIDI Device
fr: Se connecter à un périphérique MIDI

en: 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.
fr: Dans le but d'envoyer un message MIDI à un périphérique externe, nous devons commencer par le connecter. Regardez la sous-section 'Se connecter à un contrôleur MIDI' dans la section 11.1 pour plus de détails. Notez que si vous utilisez l'USB, connecter un périphérique à lequel vous envoyez (au lieu de recevoir) est la même procédure. Cependant, si vous utilisez les connecteurs DIN classiques, assurez-vous de connecter le port de sortie MIDI à votre ordinateur. Vous devriez voir votre périphérique MIDI listé dans le panneau des préférences.

en: Sending MIDI events
fr: Envoyer des événements MIDI

en: 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:
fr: Les nombreuses fonctions `midi_*` fonctionnent comme `play`, `sample` et `synth` puisqu'elles envoient un message au temps (logique) actuel. Par exemple, pour étaler des appels aux fonctions `midi_*`, vous devez utiliser `sleep` tout comme vous l'avez fait avec `play`. Jetons un coup d'oeil :

en: 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.)
fr: Cela va envoyer une note MIDI sur l'événement au périphérique MIDI connecté avec une vélocité de 50. ( Notez que Sonic Pi va convertir automatiquement les notes dans le format `:e3` à leur nombre MIDI correspondant comme 52 dans ce cas-ci.)

en: 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`:
fr: Si votre périphérique MIDI connecté est un synthétiseur, vous devriez être capable de l'entendre jouer une note. Pour le désactiver, utiliser `midi_note_off` :

en: Selecting a MIDI device
fr: Sélectionner un périphérique MIDI

en: 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.
fr: Par défaut, Sonic Pi va envoyer chaque message MIDI à tout les périphériques connectés sur tous les canaux MIDI. Cela est fait dans le but de rendre facile le travail avec un périphérique connecté sans avoir à configurer quoi que ce soit. Cependant, parfois un périphérique MIDI va traiter les canaux MIDI d'une manière particulière ( peut-être que chaque note a un canal séparé) et vous pourriez également vouloir connecter plus d'un périphérique MIDI en même temps. Dans des configurations plus compliquées, vous pouvez vouloir être plus sélectif sur quel périphérique MIDI reçoit quel(s) message(s) et sur quel canal.

en: We can specify which device to send to using the `port:` opt, using the device name as displayed in the preferences:
fr: On peut spécifier à quel périphérique on veut envoyer en utilisant l'option `port:`, en utilisant le nom du périphérique comme affiché dans les préférences :

en: We can also specify which channel to send to using the `channel:` opt (using a value in the range 1-16):
fr: On peut également spécifier quel canal on veut envoyer en utilisant l'option `channel:` (en utilisant une valeur dans l'intervalle de 1 à 16) :

en: Of course we can also specify both at the same time to send to a specific device on a specific channel:
fr: Évidemment, nous pouvons aussi spécifier les deux en même temps pour envoyer à un périphérique spécifique sur un canal spécifique :

en: MIDI Studio
fr: Studio MIDI

en: 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:
fr: Finalement, une chose très amusante à faire est de connecter la sortie audio de votre synthétiseur MIDI à l'une des entrées audio de votre carte de son. Vous pouvez alors contrôler votre synthé avec du code en utilisant les fonctions `midi_*` et également manipuler l'audio en utilisant `live_audio` et FX :

en: 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
fr: with_fx :reverb, room: 1 do
      live_audio :moog
    end
    live_loop :moog_trigger do
      use_real_time
      midi (octs :e1, 3).tick, sustain : 0.1
      sleep 0.125
    end

en: (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).
fr: (La fonction `midi` est disponible en tant que raccourci pratique pour envoyer les événements de notes ouvertes et fermées avec une simple commande. Regarder sa documentation pour davantage d'informations).

en: 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.
fr: En plus du MIDI, une autre façon d'obtenir de l'information entrante et sortante de Sonic Pi est via un réseau en utilisant un protocole simple appelé OSC - Open Sound Control. Cela va vous laisser envoyer et recevoir des messages de programmes externes ( s'exécutant sur votre ordinateur et sur des ordinateurs externes) ce qui augmente le potentiel de contrôle bien plus haut que le MIDI qui a des limitations dues à son design des années 80.

en: 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.
fr: Par exemple, vous pourriez écrire un programme dans un autre langage de programmation qui envoie et reçoit OSC (il existe des librairies OSC pour presque tous les langages communs) et travailler directement avec Sonic Pi. Les possibilités d'utilisation de cela sont seulement limitées par votre imagination.

en: 12.1 Receiving OSC
fr: 12.1 Réception OSC

en: Receiving OSC
fr: Réception OSC

en: By default when Sonic Pi is launched it listens to port 4560 for incoming OSC messages from programs on the same computer. This means that without any configuration, you can send Sonic Pi an OSC message and it will be displayed in the cue log just like incoming MIDI messages. This also means that any incoming OSC message is also automatically added to the Time State which means you can also use `get` and `sync` to work with the incoming data - just like with MIDI and synchronising `live_loops` - see sections 5.7 and 10.2 to recap how this works.
fr: Par défaut, lorsque Sonic Pi est lancé, il écoute sur le port 4560 pour des messages OSC entrant de programmes sur le même ordinateur. Cela veut dire que sans aucune configuration, vous pouvez envoyer à Sonic Pi un message OSC et il sera affiché dans la queue du journal tout comme les messages MIDI entrants. Cela veut également dire que tout message OSC entrant est aussi automatiquement ajouté à l'État du Temps, ce qui veut dire que vous pouvez aussi utiliser `get` et `sync` pour travailler avec l'information entrante, comme avec le MIDI, et synchroniser `live_loops` - voir les sections 5.7 et 10.2 pour récapituler comment cela fonctionne.

en: A Basic OSC Listener
fr: Un écouteur OSC basique

en: Let's build a basic OSC listener:
fr: Construisons un écouteur OSC basique :

en: 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.
fr: Dans cet exemple, nous décrivons un chemin OSC `"/osc*/trigger/prophet"` sur lequel nous nous synchronisons. Cela peut être n'importe quel chemin OSC valide (toutes les lettres et chiffres sont supportés et le `/` est utilisé comme dans une URL pour diviser le chemin en plusieurs mots). Le préfixe `/osc` est ajouté par Sonic Pi à tous les messages OSC entrants, alors nous devons envoyer un message OSC avec le chemin `/trigger/prophet` pour que notre `sync` cesse de bloquer et que le synthé prophet soit déclenché.

en: Sending OSC to Sonic Pi
fr: Envoyer du OSC à Sonic Pi

en: 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:
fr: Nous pouvons envoyer du OSC à Sonic Pi à partir de n'importe lequel langage de programmation qui a une librairie OSC. Par exemple, si nous envoyons du OSC à partir de Python, nous allons faire quelque chose ressemblant à ceci :

en: Or, if we're sending OSC from Clojure we might do something like this from the REPL:
fr: Ou si nous envoyons du OSC à partir de Clojure, nous allons faire quelque chose qui ressemble à ceci à partir de la REPL :

en: Receiving from External Machines
fr: Recevoir des machines externes

en: 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).
fr: Pour des raisons de sécurité, par défaut Sonic Pi ne laisse pas les machines distantes lui envoyer des messages OSC. Cependant, vous pouvez activer le support des machines distantes dans Préférences->IO->Réseau->Recevoir des messages OSC distants. Une fois que vous l'avez activé, vous pouvez recevoir les messages OSC de n'importe quel ordinateur sur votre réseau. Habituellement, la machine expéditrice a besoin de connaître votre adresse IP (un identificateur unique de ton ordinateur sur ton réseau – comme un numéro de téléphone ou une adresse courriel). Vous pouvez découvrir l'adresse IP de votre ordinateur en regardant la section IO de votre panneau de préférences. (Si votre machine a plus d'une adresse IP, placer votre souris sur l'adresse listée fera apparaître une liste de toutes les adresses connues).

en: 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.
fr: Prenez note, des programmes comme TouchOSC pour iPhone et Android supportent l'envoi de OSC comme fonctionnalité standard. Alors, une fois que vous écoutez les machines distantes et que vous connaissez votre adresse IP, vous pouvez commencer instantanément l'envoi de messages à partir d'applications comme TouchOSC ce qui vous permet de construire vos propres contrôles tactiles personnalisés avec glisseurs, boutons, cadrans, etc. Cela vous fournit un grand éventail de possibilités d'entrée.

en: 12.2 Sending OSC
fr: 12.2 Envoyer du OSC

en: Sending OSC
fr: Envoyer du OSC

en: 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:
fr: En plus de recevoir du OSC et de travailler avec en utilisant l'État du Temps, nous pouvons également envoyer des messages OSC en synchronisation avec notre musique (tout comme nous pouvons envoyer des messages MIDI en synchronisation avec notre musique). Nous devons seulement savoir à quelle adresse IP et port nous envoyons. Essayons-le :

en: 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.)
fr: Si vous exécutez le code ci-dessus, vous allez remarquer que Sonic Pi s'envoie lui-même un message OSC ! Ceci parce que nous avons configuré l'adresse IP et le port de la machine courante au port par défaut pour OSC. C'est essentiellement la même chose que de se poster une lettre à soi-même - le paquet OSC est créé, quitte Sonic Pi, se rend à la pile réseau du système d'exploitation qui va retourner le paquet à Sonic Pi et est reçu ensuite comme un message OSC standard qui est visible dans la queue du journal en tant que message entrant `"/osc:127.0.0.1:4560/hello/world`. (Remarquez comment Sonic Pi préfixe automatiquement tous les messages OSC entrants avec `/osc` puis le nom d'hôte et le port de l'expéditeur.)

en: Sending OSC to other programs
fr: Envoyer du OSC à d'autres programmes

en: 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:
fr: Évidemment, envoyer des messages OSC à nous-mêmes peut être amusant, mais pas très utile. Le vrai bénéfice commence quand nous envoyons des messages à d'autres programmes :

en: 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.
fr: Dans ce cas, nous assumons qu'il existe un autre programme sur la même machine qui écoute sur le port 123456. Si c'est le cas, il va recevoir un message OSC `"/hello/world` avec lequel il peut faire ce qu'il veut.

en: If our program is running on another machine, we need to know its IP address which we use instead of `"localhost"`:
fr: Si votre programme s'exécute sur une autre machine, nous avons besoin de savoir son adresse IP que nous allons utiliser au lieu de `"localhost"` :

en: Now we can send OSC messages to any device reachable to us via our local networks and even the internet!
fr: Maintenant, nous pouvons envoyer des messages OSC à n'importe quel périphérique accessible via nos réseaux locaux et même l'internet !

en: 13 Multichannel Audio
fr: 13 Audio multi-canaux

en: Multichannel Audio
fr: Audio multi-canaux

en: 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.
fr: Jusqu'à maintenant, en terme de production de son, nous avons exploré le déclenchement des synthés et des sons enregistrés avec les fonctions `play`, `synth` et `sample`. Celles-ci ont généré de l'audio qui a été joué au travers de notre système de son stéréo. Cependant, plusieurs ordinateurs offrent également la possibilité de recevoir du son, par exemple avec un microphone, en plus d'avoir la possibilité d'envoyer le son à plus de deux haut-parleurs. Souvent, cette possibilité existe par l'utilisation d'une carte de son externe - celles-ci sont disponibles pour toutes les plateformes. Dans cette section du tutoriel, nous allons regarder comment nous pouvons prendre avantage de ces cartes de sons externes et travailler sans effort avec de multiples canaux d'audio entrants et sortants de Sonic Pi.

en: 13.1 Sound In
fr: 13.1 Son entrant

en: Sound In
fr: Son entrant

en: One simple (and perhaps familiar) way of accessing sound inputs is using our friend `synth` by specifying the `:sound_in` synth:
fr: Une façon simple (et peut-être familière) d'accéder les sons entrants est en utilisant notre ami `synth` en spécifiant le synthé `:sound_in` :

en: 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.
fr: Cela va fonctionner comme n'importe quel synthé comme par exemple `synth :dsaw` à l'exception que l'audio généré sera lu directement de la première entrée de votre carte de son système. Sur les portables, c'est typiquement le microphone intégré, mais si vous avez une carte de son externe, vous pouvez brancher n'importe quel audio entrant dans la première entrée.

en: Increasing the Duration
fr: Augmenter la durée

en: 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:
fr: Une chose que vous pourriez remarquer est que tout comme `synth :dsaw`, le synthé `:sound_in` dure seulement pour 1 rythme puisqu'il a une enveloppe standard. Si vous voulez le garder ouvert pour un peu plus longtemps, changez les paramètres d'enveloppe ADSR. L'exemple suivant va conserver le synthé ouvert pour 8 rythmes avant de fermer la connexion :

en: Of course, just like any normal synth, you can easily layer on effects with the FX block:
fr: Bien sûr, tout comme n'importe quel synthé normal, vous pouvez facilement ajouter des couches d'effets avec le bloc FX :

en: 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.
fr: Si vous avez connecté une guitare dans votre première entrée, vous devriez être capable de l'entendre avec de la distorsion et de la réverbération jusqu'à ce que le synthé se termine comme prévu.

en: 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:
fr: Vous êtes libre d'utiliser le synthé `:sound_in` aussi souvent que vous le voulez de façon concurrente (tout comme vous le faites avec n'importe lequel synthé normal). L'exemple suivant va jouer deux synthés `:sound_in` en même temps - l'un via la distorsion et l'autre via la réverbération :

en: Multiple Inputs
fr: Entrées multiples

en: 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:
fr: Vous pouvez sélectionner quelle entrée audio vous voulez jouer avec l'option `input:`. Vous pouvez également spécifier une entrée stéréo (deux entrées consécutives) en utilisant le synthé `:sound_in_stereo`. Par exemple, si vous avez une carte de son avec au moins trois entrées, vous pouvez traiter les deux premières en tant que flux stéréo et y ajouter de la distorsion et la troisième en tant que flux mono et y ajouter une réverbération avec le code suivant :

en: Potential Issues
fr: Problèmes potentiels

en: 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`.
fr: Cependant, même s'il s'agit d'une technique utile, il y a quelques limitations à cette approche. Premièrement, cela fonctionne seulement pour une durée déterminée (étant donné qu'il a une enveloppe ASDR) et deuxièmement, il n'existe pas de façon de changer le FX une fois que le synthé a été déclenché. Ces deux choses sont des requêtes typiques lorsqu'on travaille avec des flux audio externes comme les microphones, les guitares et les synthétiseurs externes. Par conséquent, nous allons regarder la solution de Sonic Pi au problème de manipuler une (potentielle) infinité de flux d'entrée audio en direct : `live_audio`.

en: 13.2 Live Audio
fr: 13.2 Audio en direct

en: Live Audio
fr: Audio en direct

en: 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`.
fr: Le synthé `:sound_in`, comme décrit dans la section précédente, fournit une méthode très flexible et familière pour travailler avec les entrées audio. Toutefois, comme nous en avons discuté, elle a quelques problématiques lorsque nous travaillons avec une seule entrée audio comme un seul instrument (comme la voix ou une guitare). La meilleure approche pour travailler avec un seul flux d'audio en continu, et de loin, est d'utiliser `live_audio`.

en: A Named Audio Input
fr: Une entrée audio nommée

en: `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:
fr: `live_audio` partage quelques contraintes de design interne avec `live_loop` (d'où le nom similaire). Premièrement, il doit avoir un nom unique et deuxièmement, un seul flux `live_audio` avec ce nom peut exister à tout moment. Jetons un coup d'œil :

en: 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.
fr: Ce code va réagir d'une façon similaire à `synth :sound_in` avec quelques différences clés : il tourne pour toujours (jusqu'à ce que vous le stoppiez explicitement) et vous pouvez le *bouger* vers de nouveaux contextes FX dynamiquement.

en: Working with FX
fr: Travailler avec des FX

en: 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:
fr: A son déclenchement initial, `live_audio` fonctionne exactement de la façon que vous pensez qu'il fonctionne avec FX. Par exemple, pour démarrer un flux audio en direct avec des réverbérations ajoutées, utiliser simplement un bloc FX `:reverb` :

en: 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.
fr: Toutefois, considérant que ce `live_audio` tourne pour toujours (au moins jusqu'à ce que vous l'arrêtiez), ce serait assez contraignant si, comme les synthés typiques, l'audio en direct était lié à l'intérieur du FX `:reverb` pour son existence entière. Heureusement, ce n'est pas le cas et cela a été conçu pour être facile à déplacer entre des FX différents. Essayons-le. Exécutez le code ci-dessus pour entendre l'audio en direct venir directement de la première entrée de votre carte de son. À noter, si vous utilisez un portable, cela correspondra habituellement à votre microphone intégré, alors il est recommandé d'utiliser des écouteurs pour arrêter le retour d'informations.

en: Now, whilst you're still hearing the audio live from the sound card with reverb, change the code to the following:
fr: Maintenant, pendant que vous entendez l'audio live depuis votre carte son avec de la réverbération, modifiez le code ainsi :

en: 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:
fr: Maintenant, pressez Exécuter, et vous entendrez immédiatement l'audio joué au travers de l'écho FX et plus via la réverbération. Si vous voulez les deux, modifiez le code à nouveau et pressez Exécuter :

en: It's important to point out that you can call `live_audio :foo` from any thread or live loop and it will move the live audio synth to *that* thread's current FX context. You could therefore easily have multiple live loops calling `live_audio :foo` at different times resulting in the FX context being automatically swapped around for some interesting results.
fr: Il est important de préciser que vous pouvez appeler `live_audio :foo` depuis tout thread ou tout boucle live, et il déplacera le synthé audio live de *ce* contexte actuel de thread. Vous pouvez donc facilement avoir plusieurs boucles live qui appellent `live_audio :foo` à différent moments faisant en sorte que le contexte d'effet soit automatiquement changé, ceci donnant des résultats intéressants.

en: Stopping live audio
fr: Arrêter l'audio en direct

en: 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:
fr: Contrairement aux synthés standards, étant donné que `live_audio` n'a pas d'enveloppe, il va continuer de s'exécuter pour toujours (même si vous supprimez le code, une fonction demeure définie en mémoire même si vous supprimez le code dans l'éditeur). Pour l'arrêter, vous devez utiliser l'argument `:stop` :

en: It can easily be restarted by calling it without the `:stop` arg again:
fr: Cela peut être facilement redémarré en l'appelant sans l'argument `:stop` de nouveau :

en: Additionally all running live audio synths are stopped when you hit the global Stop button (as with all other running synths and FX).
fr: De plus, tous les synthés d'audio en direct qui s'exécutent sont arrêtés quand vous pressez sur le bouton Stop global (de même que pour tous les autres synthés et FX qui s'exécutent).

en: Stereo input
fr: Entrée stéréo

en: 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:
fr: Pour ce qui est des canaux audio, par défaut `live_audio` agit similairement au synthé `:sound_in` dans le fait qu'il prend un simple flux d'entrée mono d'audio et le convertit en flux stéréo en utilisant le panoramique spécifié. Cependant, tout comme `:sound_in_stereo`, il est également possible de dire à `live_audio` de lire deux entrées audio consécutivement et de les traiter en tant que canaux de droite et de gauche directement. Cela est possible via l'option `:stereo`. Par exemple, pour traiter l'entrée 2 en tant que signal de gauche et l'entrée 3 en tant que signal de droite, vous avez besoin de configurer l'option `input:` à 2 et d'activer le mode stéréo comme suit :

en: 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.
fr: Notez qu'une fois que vous avez démarré un flux d'audio en direct en mode stéréo, vous ne pouvez pas le changer en mono sans l'arrêter et le démarrer. Similairement, si vous le démarrez dans le mode mono par défaut, vous ne pouvez pas changer en stéréo sans arrêter et démarrer le flux.

en: 13.3 Sound Out
fr: 13.3 Son sortant

en: Sound Out
fr: Son sortant

en: 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.
fr: Jusqu'à maintenant dans cette section nous avons regardé comment avoir plusieurs flux d'audio dans Sonic Pi - soit par l'utilisation du synthé `:sound_in` ou par le système puissant `live_audio`. En plus de pouvoir travailler avec de multiples flux d'entrée audio, Sonic Pi peut également faire sortir plusieurs flux d'audio. Cela est possible via le FX `:sound_out`.

en: Output contexts
fr: Contextes de sortie

en: 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:
fr: Récapitulons rapidement comment les synthés et les FX de Sonic Pi sortent leur audio à leur contexte FX courant. Par exemple, considérant ceci :

en: 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.
fr: La façon la plus simple de comprendre ce qui se passe avec le flux audio est de commencer au niveau le plus interne du contexte audio et de remonter. Dans ce cas, le contexte le plus interne est étiqueté `A` et il s'agit de l'échantillon `:bd_haus` qui est déclenché. L'audio pour cela va directement dans son contexte qui est `B` - l'effet `:echo`. Cela ajoute de l'écho à l'audio entrant et l'émet en sortie à son contexte qui est `C` - l'effet `:reverb`. Cela ajoute ensuite de la réverbération à l'audio entrant et l'émet en sortie à son contexte qui est le niveau le plus haut - les haut-parleurs de gauche et droite (sortie 1 et 2 de votre carte audio). L'audio sort avec un signal stéréo via ces derniers.

en: Sound Out FX
fr: Effet de son sortant

en: 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:
fr: Le comportement ci-dessus est vrai pour tous les synthés (incluant `live_audio`) et la majorité des FX, à l'exception de `:sound_out`. L'effet `:sound_out` accomplit deux choses. Premièrement, il émet en sortie son audio au contexte externe comme décrit ci-dessus. Deuxièmement, il émet *aussi* en sortie son audio directement à une sortie sur votre carte son. Jetons un coup d'œil :

en: 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.
fr: Dans cet exemple, notre échantillon `:bd_haus` sort son audio à son contexte externe qui est l'effet `:sound_out`. À son tour, il sort son audio à son contexte externe qui est l'effet `:reverb` (comme attendu). Cependant, il sort *aussi* un mélange mono à la troisième sortie de la carte de son système. L'audio généré dans `:sound_out` a donc deux destinations - l'effet `:reverb` et la sortie 3 de la carte audio.

en: Mono and Stereo out
fr: Sortie mono et stéréo

en: As we've seen, by default, the `:sound_out` FX outputs a mono mix of the stereo input to a specific channel in addition to passing the stereo feed to the outer context (as expected). If outputting a mono mix isn't precisely what you want to do, there are a number of alternative options. Firstly, by using the `mode:` opt you can choose to output just the left or just the right input signal to the audio card. Or you can use the `:sound_out_stereo` FX to output to two consecutive sound card outputs. See the function documentation for more information and examples.
fr: Comme nous l'avons vu, par défaut, l'effet `:sound_out` ressort un mix mono d'une entrée stéréo vers un canal spécifique en addition de passer le flux stéréo vers le contexte de sortie (comme prévu). Si le fait de sortir un mix mono n'est pas précisément ce que vous voulez faire, il y a plusieurs options alternatives. Premièrement, en utilisant l'option `mode:`, vous pouvez choisir de ressortir uniquement le signal d'entrée de gauche ou celui de droite vers la carte-son. Ou vous pouvez utiliser l'effet `:sound_out_stereo` pour ressortir vers les sorties de deux cartes-son consécutives. Consultez la documentation de la fonction pour davantage d'informations et des exemples.

en: Direct Out
fr: Sortie directe

en: 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:
fr: Comme nous l'avons également vu, le comportement par défaut pour `:sound_out` et `:sound_out_stereo` pour les deux est d'envoyer leur audio à leur contexte externe (ce qui est typique de tous les FX) *et* à la sortie spécifiée de la carte de son. Cependant, vous pourriez occasionnellement vouloir *seulement* envoyer à la sortie de la carte de son et pas le contexte externe ( et donc ne pas avoir la possibilité que le son soit mélangé et envoyé aux canaux de sorties standards 1 et 2). Cela est possible en utilisation l'option standard FX `amp:` qui s'applique sur l'audio *après* que le FX ait manipulé l'audio :

en: 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.
fr: Dans l'exemple ci-dessus, l'échantillon `:loop_amen` est envoyé à son contexte extérieur, le FX `:sound_out`. Ensuite, cela envoie un mélange mono à la sortie 3 de la carte audio et multiplie l'audio par 0 ce qui le rend silencieux essentiellement. C'est le signal silencieux qui est par la suite envoyé au contexte extérieur de `:sound_out` qui est la sortie standard. Par conséquent, les canaux de sorties par défaut ne recevront aucun audio et le canal 3 recevra un mélange mono de tambours d'Amen Break.

en: This concludes the Sonic Pi introductory tutorial. Hopefully you've learned something along the way. Don't worry if you feel you didn't understand everything - just play and have fun and you'll pick things up in your own time. Feel free to dive back in when you have a question that might be covered in one of the sections.
fr: Ceci conclut ce tutoriel d'introduction à Sonic Pi. Nous espérons que vous avez appris quelque chose en cours de route. Ne vous inquiétez pas si vous pensez ne pas avoir tout compris - jouez simplement et prenez du plaisir, vous vous approprierez les choses à votre rythme. N'hésitez pas à replonger en arrière quand vous avez une question qui pourrait être couverte par une des sections.

en: If you have any questions that haven't been covered in the tutorial, then please jump onto the [Sonic Pi community forums](https://in-thread.sonic-pi.net/) and ask your question there. You'll find someone friendly and willing to lend a hand.
fr: Si vous avez des questions qui n'ont pas été couvertes dans le tutoriel, alors allez S.V.P. sur [le forum de la communauté de Sonic Pi](https://in-thread.sonic-pi.net/) et posez vos questions là. Vous trouverez quelqu'un d'amical qui vous donnera un coup de main.

en: Finally, I also invite you to take a deeper look at the rest of the documentation in this help system. There are a number of features that haven't been covered in this tutorial that are waiting for your discovery.
fr: Enfin, je vous invite aussi à regarder en profondeur le reste de la documentation de ce système d'aide. Il y a un nombre de fonctionnalités qui n'ont pas été couvertes dans ce tutoriel et qui sont en attente de votre découverte.

en: So play, have fun, share your code, perform for your friends, show your screens and remember:
fr: Alors jouez, ayez du plaisir, partagez votre code, produisez-vous devant vos amis, montrez vos écrans et rappelez-vous :

en: *There are no mistakes, only opportunities.*
fr: *Il n'y a pas d'erreurs, que des opportunités*

en: A Appendix A - MagPi Articles
fr: A Appendice A - Articles MagPi

en: MagPi Articles
fr: Articles MagPi

en: Appendix A collects all the Sonic Pi articles written for the MagPi magazine.
fr: L'appendice A rassemble tous les articles Sonic Pi écrits pour le magazine MagPi.

en: Dive into Topics
fr: Plongez dans les sujets

en: These articles aren't meant to be read in any strict order and contain a lot of cross-over material from the tutorial itself. Rather than try and teach you all of Sonic Pi, they instead each focus on a specific aspect of Sonic Pi and cover it in a fun and accessible way.
fr: Ces articles ne sont pas destinés à être lus dans un ordre particulier et contiennent beaucoup de choses qui sont aussi dans le tutoriel. Plutôt que d'essayer de vous apprendre tout Sonic Pi, chacun se focalise plutôt sur un aspect particulier de Sonic Pi et le couvre d'une manière amusante et accessible.

en: Read the MagPi
fr: Lisez le MagPi

en: You can see them in their glorious professionally typeset form in the free PDF downloads of The MagPi here: https://www.raspberrypi.org/magpi/
fr: Vous les trouverez avec leur glorieuse présentation professionnelle dans les PDFs gratuits en téléchargement du MagPi ici : https://www.raspberrypi.org/magpi/

en: Suggest a Topic
fr: Suggérez un sujet

en: If you don't see a topic that interests you covered in these articles - why not suggest one? The easiest way to do that is to tweet your suggestion to [@Sonic_Pi](http://twitter.com/sonic_pi). You never know - your suggestion might be the subject of the next article!
fr: Si vous ne trouvez pas de sujet qui vous intéresse parmi ceux couverts dans ces articles, pourquoi ne pas en suggérer un ? La manière la plus simple de faire cela est de tweeter votre suggestion à [@Sonic_Pi](http://twitter.com/sonic_pi). On ne sait jamais, votre suggestion sera peut-être le sujet du prochain article !

en: A.1 Tips for Sonic Pi
fr: A.1 Conseils pour Sonic Pi

en: Five Top Tips
fr: Les cinq meilleurs conseils

en: 1. There are no mistakes
fr: 1. Il n'y a pas d'erreur

en: The most important lesson to learn with Sonic Pi is that there really are no mistakes. The best way to learn is to just try and try and try. Try lots of different things out, stop worrying whether your code sounds good or not and start experimenting with as many different synths, notes, FX and opts as possible. You'll discover a lot of things that make you laugh because they sound just awful and some real gems that sound truly amazing. Simply drop the things you don't like and keep the things you do. The more 'mistakes' you allow yourself to make the quicker you'll learn and discover your personal coding sound.
fr: La plus importante leçon à apprendre avec Sonic Pi, c'est qu'il n'y a pas vraiment d'erreur. La meilleure façon d'apprendre, c'est juste d'essayer, essayer, et essayer. Essayez beaucoup de choses différentes, ne vous inquiétez pas de savoir si votre code sonne bien ou pas, et commencez par expérimenter avec le plus de synthés, de notes, d'effets et d'options possibles. Vous découvrirez beaucoup de choses qui vous feront rire parce qu'elles ne sonnent pas bien du tout et aussi quelques joyaux qui sonnent magnifiquement bien. Débarrassez-vous ensuite de ce que vous n'aimez pas et gardez les choses qui vous plaisent. Plus vous vous permettrez de faire des 'erreurs' et plus vite vous apprendrez et découvrirez votre son personnel de programmation interactive.

en: 2. Use the FX
fr: 2. Utilisez les effets

en: Say you've already mastered the Sonic Pi basics of making sounds with `sample`, `play`? What's next? Did you know that Sonic Pi supports over 27 studio FX to change the sound of your code? FX are like fancy image filters in drawing programs except that instead of blurring or making something black and white, you can add things like reverb, distortion and echo to your sound. Think of it like sticking the cable from your guitar to an effects pedal of your choice and then into the amplifier. Luckily, Sonic Pi makes using FX really easy and requires no cables! All you need to do is to choose which section of your code you'd like the FX added to and wrap it with the FX code. Let's look at an example. Say you had the following code:
fr: Disons que vous maîtrisez déjà les bases de Sonic Pi pour créer des sons avec `sample` et `play`. Qu'est-ce qui vient ensuite ? Savez-vous que Sonic Pi supporte plus de 27 effets studio pour modifier le son de votre code ? Les effets sont comme des filtres pour images dans les programmes de dessin, mais à la place de rendre l'image floue ou noir et blanc, on peut ajouter de la réverbération, de la distorsion ou de l'écho à votre son. On peut voir ça comme brancher le câble d'une guitare dans une pédale d'effet de votre choix puis dans un ampli. Heureusement, Sonic Pi rend l'utilisation d'effets très simple et n'a pas besoin de câble ! Tout ce dont vous avez besoin c'est de choisir à quelle section de votre code ajouter l'effet puis de l'emballer avec le code de l'effet. Prenons un exemple. Disons que vous avez le code suivant :

en: If you wanted to add FX to the `:loop_garzul` sample, you'd just tuck it inside a `with_fx` block like this:
fr: Si vous voulez ajouter un effet à l'échantillon `:loop_garzul`, il suffit de le mettre dans un bloc `with_fx` comme ceci :

en: Now, if you wanted to add FX to the bass drum, go and wrap that with `with_fx` too:
fr: Maintenant, si voulez ajouter un effet au tambour basse, enveloppez-le aussi dans un `with_fx` :

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

en: Remember, you can wrap *any* code within `with_fx` and any sounds created will pass through that FX.
fr: Rappelez-vous, vous pouvez entourer *n'importe quel* code dans `with_fx` et tous les sons créés passeront dans cet effet.

en: 3. Parameterise your synths
fr: 3. Paramétrez vos synthés

en: In order to really discover your coding sound you'll soon want to know how to modify and control synths and FX. For example, you might want to change the duration of a note, add more reverb, or change the time between echoes. Luckily, Sonic Pi gives you an amazing level of control to do exactly this with special things called optional parameters or opts for short. Let's take a quick look. Copy this code into a workspace and hit run:
fr: Pour découvrir vraiment le son de votre code, vous voudrez bientôt savoir comment modifier et contrôler les synthés et effets. Par exemple, vous voudrez peut-être changer la durée d'une note, ajouter plus de réverb, ou changer la durée entre les échos. Heureusement, Sonic Pi vous donne un niveau de contrôle incroyable pour faire exactement cela avec des trucs appelés des paramètres optionnels ou opts pour faire court. Jetons-y un coup d'œil rapide. Copiez ce code dans un espace de travail et exécutez-le :

en: Ooh, a lovely guitar sound! Now, let's start playing with it. How about changing its rate?
fr: Oh, un joli son de guitare ! Commençons à jouer un peu avec. Et si on changeait son taux ?

en: Hey, what's that `rate: 0.5` bit I just added at the end? That's called an opt. All of Sonic Pi's synths and FX support them and there's loads to play around with. They're also available for FX too. Try this:
fr: Hé, qu'est-ce que ce `rate: 0.5` que j'ai ajouté à la fin ? C'est ce qu'on appelle une opt. Tous les synthés et effets de Sonic Pi les supportent et il y en a beaucoup avec lesquels on peut jouer. Ils sont disponibles pour les effets aussi. Essayez ceci :

en: Now, try increasing that feedback to 1 to hear some fun sounds! Read the docs for full details on all the many opts available to you.
fr: Maintenant, essayez d'augmenter ce feedback à 1 pour entendre des sons de dingue ! Lisez la documentation pour des détails complets sur les nombreuses options à votre disposition.

en: 4. Live Code
fr: 4. Coder en direct

en: The best way to quickly experiment and explore Sonic Pi is to live code. This allows you to start off some code and continually change and tweak it whilst it's still playing. For example, if you don't know what the cutoff parameter does to a sample, just play around. Let's have a try! Copy this code into one of your Sonic Pi workspaces:
fr: La meilleure manière d'expérimenter rapidement et d'explorer Sonic Pi est de coder de manière interactive. Cela vous permet de partir d'un peu de code et de le changer de manière continue pendant qu'il est en train de s'exécuter. Par exemple, si vous ne savez pas ce que le paramètre cutoff fait à un échantillon, jouez avec. Essayons ! Copiez ce code dans un de vos espaces de travail Sonic Pi :

en: Now, hit run and you'll hear a slightly muffled drum break. Now, change the `cutoff:` value to `80` and hit run again. Can you hear the difference? Try `90`, `100`, `110`...
fr: Maintenant, cliquez sur 'Run' et vous entendrez un rythme de batterie un peu étouffé. Maintenant, changez la valeur de `cutoff:` pour `80` et cliquez à nouveau sur 'Run'. Entendez-vous la différence ? Essayez `90`, `100`, `110`...

en: Once you get the hang of using `live_loop`s you'll not turn back. Whenever I do a live coding gig I rely on `live_loop` as much as a drummer relies on their sticks. For more information about live coding check out Section 9 of the built-in tutorial.
fr: Quand vous aurez pris la main à utiliser des `live_loop`, vous ne pourrez plus vous en passer. À chaque fois que je donne un concert de programmation interactive, je m'appuie autant sur `live_loop` qu'un batteur sur ses baguettes. Pour plus d'informations à propos de la programmation interactive, regardez la section 9 du tutoriel inclus.

en: 5. Surf the random streams
fr: 5. Surfez sur les flux aléatoires

en: Finally, one thing I love doing is cheating by getting Sonic Pi to compose things for me. A really great way to do this is using randomisation. It might sound complicated but it really isn't. Let's take a look. Copy this into a spare workspace:
fr: Enfin, une chose que j'adore faire est de tricher en faisant en sorte que Sonic Pi compose des choses pour moi. Une manière géniale de faire ça est d'utiliser l'aléation. Cela peut paraître compliqué, mais ça ne l'est pas du tout. Regardons. Copiez ceci dans un espace de travail :

en: Now, when you play this, you'll hear a constant stream of random notes from the scale `:e2 :minor_pentatonic` played with the `:dsaw` synth. "Wait, wait! That's not a melody", I hear you shout! Well, here's the first part of the magic trick. Every time we go round the `live_loop` we can tell Sonic Pi to reset the random stream to a known point. This is a bit like going back in time in the TARDIS with the Doctor to a particular point in time and space. Let's try it - add the line `use_random_seed 1` to the `live_loop`:
fr: Maintenant, quand vous jouez ceci, vous entendrez une suite continue de notes aléatoires de la gamme `:e2 :minor_pentatonic` jouée avec le synthé `:dsaw`. "Attendez, attendez ! Ce n'est pas une mélodie", vous entends-je crier ! Eh bien, voici la première partie du tour de magie. Chaque fois que l'on recommence le `live_loop` on peut dire à Sonic Pi de réinitialiser la suite aléatoire à un point connu. C'est un peu comme voyager dans le temps dans le TARDIS avec le Docteur vers un point particulier du temps et de l'espace. Essayons ceci : ajoutez la ligne `use_random_seed 1` au `live_loop`:

en: Now, every time the `live_loop` loops around, the random stream is reset. This means it chooses the same 16 notes every time. Hey presto! An instant melody. Now, here's the really exciting bit. Change the seed value from `1` to another number. Say `4923`. Wow! Another melody! So, just by changing one number (the random seed), you can explore as many melodic combinations as you can imagine! Now, that's the magic of code.
fr: Maintenant, chaque fois que la boucle `live_loop` tourne, la suite aléatoire est réinitialisée. Ceci signifie qu'elle contient exactement les même 16 notes à chaque fois. Et voilà ! Une mélodie de composée. Et maintenant, voici la partie vraiment excitante. Changez la valeur de graine de `1` pour un autre nombre. Par exemple `4923`. Ouaouh, une autre mélodie ! Donc, en changeant uniquement un nombre (la graine aléatoire), on peut explorer autant de combinaisons mélodiques qu'on peut imaginer ! C'est ça la magie du code.

en: A.2 Live Coding
fr: A.2 Programmation interactive

en: The laser beams sliced through the wafts of smoke as the subwoofer pumped bass deep into the bodies of the crowd. The atmosphere was ripe with a heady mix of synths and dancing. However something wasn't quite right in this nightclub. Projected in bright colours above the DJ booth was futuristic text, moving, dancing, flashing. This wasn't fancy visuals, it was merely a projection of Sonic Pi running on a Raspberry Pi. The occupant of the DJ booth wasn't spinning disks, they wrote, edited and evaluated code. Live. This is Live Coding.
fr: Les rayons lasers perçaient à travers les bouffées de fumée et les baffles transmettaient des basses profondes dans les corps de la foule. L'atmosphère était remplie d'un mélange de synthés et de danse. Il y avait pourtant quelque chose d'étrange dans cette boîte de nuit. Du texte futuriste était projeté au dessus de la cabine du DJ, bougeant, dansant, clignotant. Ce n'étaient pas de belles visualisations, c'était juste une projection de Sonic Pi tournant sur un Raspberry Pi. La personne dans la cabine de DJ n'était pas en train de tourner des disques, elle écrivait, éditait et évaluait du code. En direct. C'est ça le Live Coding.

en: ![Sam Aaron Live Coding](../../../etc/doc/images/tutorial/articles/A.02-live-coding/sam-aaron-live-coding.png)
fr: ![Programmation interactive de Sam Aaron](../../../etc/doc/images/tutorial/articles/A.02-live-coding/sam-aaron-live-coding.png)

en: This may sound like a far fetched story from a futuristic night club but coding music like this is a growing trend and is often described as Live Coding (http://toplap.org). One of the recent directions this approach to music making has taken is the Algorave (http://algorave.com) - events where artists like myself code music for people to dance to. However, you don't need to be in a nightclub to Live Code - with Sonic Pi v2.6+ you can do it anywhere you can take your Raspberry Pi and a pair of headphones or some speakers. Once you reach the end of this article, you'll be programming your own beats and modifying them live. Where you go afterwards will only be constrained by your imagination.
fr: Cela peut sonner comme une histoire tirée par les cheveux dans une boîte de nuit futuriste mais coder de la musique comme cela est une tendance qui se développe et qu'on appelle souvent Live Coding (programmation interactive) (http://toplap.org). Une des directions récentes que cette approche de la musique a prise est l'Algorave (http://algorave.com) : des événements où des artistes comme moi codent de la musique pour que les gens dansent. Cependant vous n'avez pas besoin d'une boîte de nuit pour coder en live : avec Sonic Pi version 2.6 et plus vous pouvez le faire dans n'importe quel endroit où vous pouvez prendre votre Raspberry Pi et un casque ou des haut-parleurs. Quand vous aurez atteint la fin de cet article, vous saurez programmez vos rythmes et les modifier en direct. Où vous irez ensuite ne sera limité que par votre imagination.

en: Live Loop
fr: Boucle interactive

en: The key to live coding with Sonic Pi is mastering the `live_loop`. Let's look at one:
fr: La clef de la programmation interactive avec Sonic Pi est la maîtrise de la `live_loop`. En voici une :

en: There are 4 core ingredients to a `live_loop`. The first is its name. Our `live_loop` above is called `:beats`. You're free to call your `live_loop` anything you want. Go wild. Be creative. I often use names that communicate something about the music they're making to the audience. The second ingredient is the `do` word which marks where the `live_loop` starts. The third is the `end` word which marks where the `live_loop` finishes, and finally there is the body of the `live_loop` which describes what the loop is going to repeat - that's the bit between the `do` and `end`. In this case we're repeatedly playing a bass drum sample and waiting for half a beat. This produces a nice regular bass beat. Go ahead, copy it into an empty Sonic Pi buffer and hit run. Boom, Boom, Boom!.
fr: Il y a quatre ingrédients principaux dans une `live_loop`. Le premier est son nom. Notre `live_loop` s'appelle ici `:beats`. Vous pouvez donner le nom que vous voulez à votre `live_loop`. Défoulez-vous. Soyez créatifs. J'utilise souvent des noms qui communiquent sur ce que la musique va donner à l'audience. Le deuxième ingrédient est le mot `do` qui marque l'endroit où la `live_loop` commence. Le troisième est le mot `end` qui marque celui où la `live_loop` s'arrête, et enfin il y a le corps de la `live_loop` qui décrit ce que la boucle va répéter : c'est la partie entre `do` et `end`. Dans ce cas on joue en boucle un sample de tambour basse et on attend un demi temps. Cela produit un beau rythme régulier de basse. Allez-y, copiez-le dans un buffer vide de Sonic Pi et cliquez sur 'Run'. Boum, boum, boum !.

en: Redefining On-the-fly
fr: Redéfinir à la volée

en: Ok, so what's so special about the `live_loop`? So far it just seems like a glorified `loop`! Well, the beauty of `live_loop`s is that you can redefine them on-the-fly. This means that whilst they're still running, you can change what they do. This is the secret to live coding with Sonic Pi. Let's have a play:
fr: OK, qu'est-ce qu'elle a de si spécial, cette `live_loop` ? Jusqu'ici, on dirait que c'est juste une boucle idéalisée ! Eh bien, la beauté des `live_loop`, c'est qu'on peut les redéfinir à la volée. Ceci signifie que, pendant qu'elles sont en train de tourner, on peut changer ce qu'elles font. C'est le secret de la programmation interactive avec Sonic Pi. Essayons :

en: Now press the Run button or hit `Meta-r`. You're now listening to some gorgeous choir sounds. Now, whilst it's still playing, change the rate from `0.4` to `0.38`. Hit run again. Woah! Did you hear the choir change note? Change it back up to `0.4` to return back to how it was. Now, drop it to `0.2`, down to `0.19` and then back up to `0.4`. See how changing just one parameter on the fly can give you real control of the music? Now play around with the rate yourself - choose your own values. Try negative numbers, really small numbers and large numbers. Have fun!
fr: Maintenant cliquez le bouton 'Run' ou tapez 'alt-r'. Vous entendez maintenant de beaux sons de chœurs . Ensuite, alors qu'il est encore en train de jouer, changez la fréquence de `0.4` en `0.38`. Cliquez à nouveau sur 'Run'. Whaou ! Vous avez entendu le chœur changer de note ? Ecrivez à nouveau `0.4` pour revenir comme avant. Puis `0.2`, puis `0.19`, puis à nouveau `0.4`. Voyez-vous que juste en changeant un paramètre à la volée permet de contrôler la musique ? Maintenant jouez vous-même avec la fréquence, choisissez vos propres valeurs. Essayez des nombres négatifs, de très petits nombres et de grands nombres. Amusez-vous !

en: Sleeping is important
fr: Il est important de dormir

en: One of the most important lessons about `live_loop`s is that they need rest. Consider the following `live_loop`:
fr: Une des leçons les plus importantes avec les `live_loop`, c'est qu'elles ont besoin de se reposer. Prenons par exemple cette `live_loop` :

en: If you try running this code, you'll immediately see Sonic Pi complaining that the `live_loop` did not sleep. This is a safety system kicking in! Take a moment to think about what this code is asking the computer to do. That's right, it's asking the computer to play an infinite amount of choir samples in zero time. Without the safety system the poor computer will try and do this and crash and burn in the process. So remember, your `live_loop`s must contain a `sleep`.
fr: Si vous essayez d'exécuter ce code, vous verrez immédiatement que Sonic Pi se plaint que la `live_loop` n'a pas dormi. C'est un mécanisme de sécurité qui se met en place. Prenons un moment pour penser à ce que ce code demande à l'ordinateur de faire. C'est cela, on demande à l'ordinateur de jouer un nombre infini de samples de chorale dans un temps nul. Sans le mécanisme de sécurité le pauvre ordinateur essaierait de faire ça et exploserait. Souvenez-vous en bien : vos `live_loop`s doivent contenir un appel à `sleep`.

en: Combining Sounds
fr: Combiner des sons

en: Music is full of things happening at the same time. Drums at the same time as bass at the same time as vocals at the same time as guitars... In computing we call this concurrency and Sonic Pi provides us with an amazingly simple way of playing things at the same time. Simply use more than one `live_loop`!
fr: La musique est pleine de choses qui arrivent en même temps. La batterie en même temps que la basse, en même temps que du chant, en même temps que des guitares... En informatique on appelle ça la concurrence et Sonic Pi nous donne une manière étonnamment simple de jouer des choses en même temps. Il suffit d'utiliser plus qu'une `live_loop` !

en: Here, we have two `live_loop`s, one looping quickly making beats and another looping slowly making a wild bass sound.
fr: Ici nous avons deux `live_loop`s, une qui tourne rapidement pour faire un rythme, et une autre qui boucle lentement pour faire un son de basse de fou.

en: One of the interesting things about using multiple `live_loop`s is that they each manage their own time. This means it's really easy to create interesting polyrhythmical structures and even play with phasing Steve Reich style. Check this out:
fr: Une des choses intéressantes quand on utilise plusieurs `live_loop`, c'est que chacune gère son propre temps. Cela signifie qu'il est très facile de créer des structures polyrythmiques intéressantes et même de jouer avec la phase, style Steve Reich. Par exemple :

en: # 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
fr: # La phase de piano de Steve Reich
    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

en: Bringing it all together
fr: Rassemblons tout

en: In each of these tutorials, we'll end with a final example in the form of a new piece of music which draws from all of the ideas introduced. Read this code and see if you can imagine what it's doing. Then, copy it into a fresh Sonic Pi buffer and hit Run and actually hear what it sounds like. Finally, change one of the numbers or comment and uncomment things out. See if you can use this as a starting point for a new performance, and most of all have fun! See you next time...
fr: Dans chacun de ces tutoriels, nous finirons avec un exemple qui montre un nouveau morceau de musique qui utilise toutes les idées introduites. Lisez ce code et essayez d'imaginer ce qu'il fait. Ensuite, copiez-le dans un buffer frais de Sonic Pi et cliquez 'Run' pour entendre comment il sonne. Enfin changez un des nombres ou commentez / décommentez des parties. Voyez si vous pouvez prendre ça comme point de départ d'une nouvelle performance, et surtout amusez-vous ! A la prochaine...

en: A.3 Coded Beats
fr: A.3 Rythmes codés

en: Coded Beats
fr: Rythmes codés

en: One of the most exciting and disrupting technical developments in modern music was the invention of samplers. These were boxes that allowed you to record any sound into them and then manipulate and play back those sounds in many interesting ways. For example, you could take an old record, find a drum solo (or break), record it into your sampler and then play it back on repeat at half-speed to provide the foundation for your latest beats. This is how early hip-hop music was born and today it's almost impossible to find electronic music that doesn't incorporate samples of some kind. Using samples is a really great way of easily introducing new and interesting elements into your live coded performances.
fr: Une des évolutions techniques les plus excitantes et disruptives dans la musique moderne a été l'invention des samplers. C'étaient des boîtes qui permettaient d'enregistrer n'importe quels sons dedans et de les manipuler et jouer de nombreuses manières intéressantes. Par exemple, on pouvait prendre un vieux disque, trouver un solo de batterie (ou un break), l'enregistrer dans le sampler et ensuite le jouer deux fois moins vite pour créer la fondation de vos derniers rythmes. C'est ainsi que la musique hip-hop est née et aujourd'hui il est presque impossible de trouver de la musique électronique qui n'incorpore pas de samples. Utiliser des samples est une très bonne manière d'introduire facilement des éléments nouveaux et intéressants dans vos performances de live coding.

en: So where can you get a sampler? Well you already have one - it's your Raspberry Pi! The built-in live coding app Sonic Pi has an extremely powerful sampler built into its core. Let's play with it!
fr: Comment pouvez-vous vous procurer un sampler ? Eh bien, vous en avez déjà un : c'est votre Raspberry Pi ! L'application de live coding Sonic Pi comprend un sampler très puissant. Jouons avec !

en: The Amen Break
fr: Le break Amen

en: One of the most classic and recognisable drum break samples is called the Amen Break. It was first performed in 1969 in the song "Amen Brother" by the Winstons as part of a drum break. However, it was when it was discovered by early hip-hop musicians in the 80s and used in samplers that it started being heavily used in a wide variety of other styles such as drum and bass, breakbeat, hardcore techno and breakcore.
fr: Un des samples de break de batterie les plus classiques et reconnaissables s'appelle le break Amen. Il a été joué pour la première fois en 1969 dans la chanson "Amen Brother" des Winstons dans un break de batterie. Cependant c'est quand il a été découvert par les premiers musiciens de hip-hop dans les années 80 et utilisé dans des samplers qu'il a commencé à être très utilisé dans des styles aussi variés que le drum and bass, le breakbeat, la techno hardcore et le breakcore.

en: I'm sure you're excited to hear that it's also built right into Sonic Pi. Clear up a buffer and throw in the following code:
fr: Je suis sûr que vous êtes ravis d'entendre qu'il est aussi inclus dans Sonic Pi. Choisissez un tampon vide et copiez-y ce code :

en: Hit *Run* and boom! You're listening to one of the most influential drum breaks in the history of dance music. However, this sample wasn't famous for being played as a one-shot, it was built for being looped.
fr: Cliquez sur *Run* et boum ! Vous entendez l'un des breaks de batterie les plus influents de l'histoire de la musique dance. Ceci dit, cet échantillon n'a pas été célèbre pour être joué juste une seule fois, il a été fait pour être joué en boucle.

en: Beat Stretching
fr: Étirer des rythmes

en: Let's loop the Amen Break by using our old friend the `live_loop` introduced in this tutorial last month:
fr: Jouons le break Amen en boucle en utilisant notre vieille amie la `live_loop`, introduite dans le tutoriel du mois dernier :

en: OK, so it is looping, but there's an annoying pause every time round. That is because we asked it to sleep for `2` beats and with the default BPM of 60 the `:loop_amen` sample only lasts for `1.753` beats. We therefore have a silence of `2 - 1.753 = 0.247` beats. Even though it's short, it's still noticeable.
fr: OK, ça boucle, mais il y a une pause ennuyeuse à chaque fois. C'est parce qu'on a demandé d'attendre `2` temps et avec le nombre par défaut de 60 BPM (battements par minute), le sample `:loop_amen` ne dure que `1.753` temps. Nous avons donc un silence de `2 - 1.753 = 0.247` temps. Même s'il est court, c'est notable.

en: To fix this issue we can use the `beat_stretch:` opt to ask Sonic Pi to stretch (or shrink) the sample to match the specified number of beats.
fr: Pour corriger ce problème, on peut utiliser l'option `beat_stretch:` pour demander à Sonic Pi d'étirer (ou de rétrécir) l'échantillon pour correspondre au nombre de beat spécifié.

en: Sonic Pi's `sample` and `synth` fns give you a lot of control via optional parameters such as `amp:`, `cutoff:` and `release:`. However, the term optional parameter is a real mouthful so we just call them *opts* to keep things nice and simple.
fr: Les fonctions `sample` et `synth` de Sonic Pi vous donnent beaucoup de contrôle via des paramètres optionnels comme `amp:`, `cutoff:` et `release:`. Cela dit le terme `paramètre optionnel` est très long à dire donc on les appelle juste *opts* pour rester simple.

en: Now we're dancing! Although, perhaps we want to speed it up or slow it down to suit the mood.
fr: Maintenant on peut danser ! Quoique, peut-être qu'on veut l'accélérer ou le ralentir en fonction de l'ambiance.

en: Playing with Time
fr: Jouer avec le temps

en: OK, so what if we want to change styles to old school hip hop or breakcore? One simple way of doing this is to play with time - or in other words mess with the tempo. This is super easy in Sonic Pi - just throw in a `use_bpm` into your live loop:
fr: OK, et si on voulait changer de style pour faire du hip hop old school ou du breakcore ? Une manière simple de faire ça est de jouer avec le temps : ou en d'autres mots jouer avec le tempo. C'est très facile avec Sonic Pi : il suffit d'appeler `use_bpm` dans votre boucle interactive :

en: Whilst you're rapping over those slow beats, notice that we're still sleeping for 2 and our BPM is 30, yet everything is in time. The `beat_stretch` opt works with the current BPM to make sure everything just works.
fr: Pendant que vous rappez sur ces rythmes lents, remarquez que nous avons toujours un repos de 2 et que notre BPM vaut 30, mais tout est bien synchronisé. L'option `beat_stretch` fonctionne avec le BPM courant pour s'assurer que tout fonctionne bien.

en: Now, here's the fun part. Whilst the loop is still live, change the `30` in the `use_bpm 30` line to `50`. Woah, everything just got faster yet *kept in time*! Try going faster - up to 80, to 120, now go wild and punch in 200!
fr: Maintenant, voici la partie amusante. Pendant que la boucle est en train de tourner, changez le `30` dans la ligne `use_bpm 30` en `50`. Waouh, tout est devenu plus rapide, mais *reste synchronisé* - Essayer encore d'accélérer jusqu'à 80, jusqu'à 120, ou même, soyons fous, 200 !

en: Filtering
fr: Filtrage

en: Now we can live loop samples, let's look at some of the most fun opts provided by the `sample` synth. First up is `cutoff:` which controls the cutoff filter of the sampler. By default this is disabled but you can easily turn it on:
fr: Maintenant qu'on peut jouer des échantillons en boucle de manière interactive, jetons un œil aux options les plus amusantes proposées par le synthé `sample`. La première est le `cutoff:` qui contrôle le filtre de coupure de l'échantillonneur. Par défaut, il est désactivé mais on peut facilement l'activer :

en: Go ahead and change the `cutoff:` opt. For example, increase it to 100, hit *Run* and wait for the loop to cycle round to hear the change in the sound. Notice that low values like 50 sound mellow and bassy and high values like 100 and 120 are more full-sounding and raspy. This is because the `cutoff:` opt will chop out the high frequency parts of the sound just like a lawn-mower chops off the top of the grass. The `cutoff:` opt is like the length setting - determining how much grass is left over.
fr: Allez-y, changez la valeur de l'option `cutoff:`. Par exemple, montez-la à 100, cliquez sur *Run*, et attendez que la prochaine boucle arrive pour entendre la différence dans le son. Remarquez que des valeurs basses comme 50 sonnent plus doux et bas, et que des hautes valeurs comme 100 ou 120 sonnent plus rempli et râpeux. C'est parce que l'option `cutoff:` va couper les parties de haute-fréquence du son tout comme une tondeuse coupe le haut de la pelouse. L'option `cutoff:` est comme le réglage de la longueur : cela détermine combien il reste d'herbe.

en: Slicing
fr: Découpage/tranchage

en: Another great tool to play with is the slicer FX. This will chop (slice) the sound up. Wrap the `sample` line with the FX code like this:
fr: Un autre super outil avec lequel on peut jouer est l'effet slicer. Il va découper le son en tranches. Encadrez la ligne `sample` avec le code de l'effet ainsi :

en: Notice how the sound bounces up and down a little more. (You can hear the original sound without the FX by changing the `mix:` opt to `0`.) Now, try playing around with the `phase:` opt. This is the rate (in beats) of the slicing effect. A smaller value like `0.125` will slice faster and larger values like `0.5` will slice more slowly. Notice that successively halving or doubling the `phase:` opts val tends to always sound good. Finally, change the `wave:` opt to one of 0, 1, or 2 and hear how it changes the sound. These are the various wave shapes. 0 is a saw wave, (hard in, fade out) 1 is a square wave (hard in, hard out) and 2 is a triangle wave (fade in, fade out).
fr: Remarquez comme le son bondit un peu plus de haut en bas. (Vous pouvez entendre le son original sans l'effet en changeant l'option `mix:` en `0`.) Maintenant essayez de modifier la valeur de l'option `phase:`. C'est la fréquence (en battements) de l'effet de coupe. Une plus petite valeur comme `0.125` va couper plus rapidement et une plus grande valeur comme `0.5` va couper plus lentement. Remarquez que si on divise ou multiplie successivement par deux l'option `phase:` cela sonne généralement bien. Enfin, choisissez une valeur pour l'option `wave:` entre 0, 1 et 2 et écoutez comment le son change. Ce sont différentes formes d'onde. 0 est une onde scie (elle commence fort et finit en fondu), 1 est une onde carrée (commence fort et finit fort) et 2 est une onde en triangle (commence en fondu, finit en fondu).

en: Finally, let's go back in time and revisit the early Bristol drum and bass scene with this month's example. Don't worry too much about what all this means, just type it in, hit Run, then start live coding it by changing opt numbers and see where you can take it. Please do share what you create! See you next time...
fr: Enfin, revenons dans le temps et revisitons la jeune scène de drum and bass de Bristol avec l'exemple du mois. Ne vous inquiétez pas trop de tout ce que cela signifie, tapez le, cliquez sur Run, puis commencez à coder interactivement en changeant les valeurs des options et voyez où cela vous amène. Partagez ce que vous créez ! À la prochaine...

en: A.4 Synth Riffs
fr: A.4 Riffs de synthés

en: Synth Riffs
fr: Riffs de synthés

en: Whether it's the haunting drift of rumbling oscillators or the detuned punch of saw waves piercing through the mix, the lead synth plays an essential role on any electronic track. In last month's edition of this tutorial series we covered how to code our beats. In this tutorial we'll cover how to code up the three core components of a synth riff - the timbre, melody and rhythm.
fr: Que ce soit la dérive hantée d'oscillateurs grondants ou le coup de poing désaccordé des ondes scies perçant à travers le mix, le synthétiseur principal joue un rôle essentiel dans chaque piste électronique. Dans l'édition du mois dernier de cette série de tutoriels nous avons couvert comment coder nos rythmes. Dans ce tutoriel nous verrons comment coder les trois composants principaux d'un riff de synthétiseur : le timbre, la mélodie et le rythme.

en: OK, so power up your Raspberry Pi, crack open Sonic Pi v2.6+ and let's make some noise!
fr: OK, allumez votre Raspberry Pi, ouvrez Sonic Pi (version 2.6 ou ultérieure) et faisons du bruit !

en: Timbral Possibilities
fr: Les possibilités de timbres

en: An essential part of any synth riff is changing and playing with the timbre of the sounds. We can control the timbre in Sonic Pi in two ways - choosing different synths for a dramatic change and setting the various synth opts for more subtle modifications. We can also use FX, but that's for another tutorial...
fr: Une partie essentielle de n'importe quel riff de synthétiseur est de changer et de jouer avec le timbre des sons. On peut contrôler le timbre dans Sonic Pi de deux manières : en choisissant différents synthétiseurs pour un changement dramatique et en définissant les diverses options des synthétiseurs pour des modifications plus subtiles. On peut aussi utiliser des effets, mais ce sera pour un autre tutoriel...

en: Let's create a simple live loop where we continually change the current synth:
fr: Créons une boucle interactive simple où l'on modifiera en continu le synthé courant :

en: Take a look at the code. We're simply ticking through a ring of synth names (this will cycle through each of these in turn repeating the list over and over). We pass this synth name to the `use_synth` fn (function) which will change the `live_loop`'s current synth. We also play note `:e2` (E at the second octave), with a release time of 0.5 beats (half a second at the default BPM of 60) and with the `cutoff:` opt set to 100.
fr: Regardez ce code. On ne fait que parcourir (avec `tick`) un anneau de noms de synthétiseurs (on boucle sur chacun d'eux à leur tour ce qui répète la liste encore et encore). On passe le nom de ce synthétiseur à la fn (fonction) `use_synth`, ce qui changera le synthétiseur courant de la `live_loop`. On joue aussi la note `:e2` (E (ou Mi) à la deuxième octave), avec un temps de relâche de 0.5 battement (une demi seconde au BPM par défaut , qui est de 60) et avec l'option `:cutoff` fixée à 100.

en: Hear how the different synths have very different sounds even though they're all playing the same note. Now experiment and have a play. Change the release time to bigger and smaller values. For example, change the `attack:` and `release:` opts to see how different fade in/out times have a huge impact on the sound. Finally change the `cutoff:` opt to see how different cutoff values also massively influence the timbre (values between 60 and 130 are good). See how many different sounds you can create by just changing a few values. Once you've mastered that, just head to the Synths tab in the Help system for a full list of all the synths and all the available opts each individual synth supports to see just how much power you have under your coding fingertips.
fr: Écoutez comme les différents synthétiseurs font des sons très différents même s'ils jouent tous la même note. Maintenant expérimentez et amusez-vous. Changez le temps de relâche en lui donnant des valeurs plus grandes et plus petites. Par exemple, changez les options `attack:` et `release:` pour voir comme des temps différents de fondu d'entrée et de sortie ont un grand effet sur le son. Enfin changez l'option `cutoff:` pour voir comment différentes valeurs de coupure ont une influence massive sur le timbre (des valeurs entre 60 et 130 sont bonnes). Voyez combien de sons vous pouvez créer juste en changeant quelques valeurs. Une fois que vous maîtrisez cela, allez dans l'onglet Synthés dans le système d'aide pour voir la liste entière des synthétiseurs et des options que chacun d'eux supporte pour voir l'étendue du pouvoir que vous avez au bouts de vos doigts de codeur.

en: Timbre is just a fancy word describing the sound of a sound. If you play the same note with different instruments such as a violin, guitar, or piano, the pitch (how high or low it sounds) would be the same, but the sound quality would be different. That sound quality - the thing which allows you to tell the difference between a piano and a guitar is the timbre.
fr: Le timbre est juste un mot savant pour décrire comment sonne un son. Si vous jouez la même note avec différents instruments comme un violon, une guitare, ou un piano, la fréquence (si elle sonne haut ou bas) sera la même, mais la qualité du son sera différente. La qualité du son, ce qui fait qu'on peut différencier un piano et une guitare, c'est le timbre.

en: Melodic Composition
fr: Composition mélodique

en: Another important aspect to our lead synth is the choice of notes we want to play. If you already have a good idea, then you can simply create a ring with your notes in and tick through them:
fr: Un autre aspect important de notre synthé principal est le choix de notes que l'on veut jouer. Si vous avez déjà une idée précise, alors vous pouvez simplement créer un anneau avec vos notes et les parcourir :

en: Here, we've defined our melody with a ring which includes both notes such as `:e3` and rests represented by `:r`. We're then using `.tick` to cycle through each note to give us a repeating riff.
fr: Ici nous avons défini notre mélodie avec un anneau qui inclut des notes comme `:e3` et des silences représentés par `:r`. Nous utiliserons ensuite `.tick` pour jouer chaque note à son tour, ce qui nous donne un riff qui se répète.

en: Auto Melody
fr: Mélodie automatique

en: It's not always easy to come up with a nice riff from scratch. Instead it's often easier to ask Sonic Pi for a selection of random riffs and to choose the one you like the best. To do that we need to combine three things: rings, randomisation and random seeds. Let's look at an example:
fr: Ce n'est pas toujours facile d'inventer un riff sympa. C'est souvent plus simple de demander à Sonic Pi une sélection de riffs aléatoires et de choisir celui que l'on préfère. Pour faire cela on doit combiner trois choses : des anneaux, de l'aléatoire et des graines aléatoires. Regardons un exemple :

en: There's a few things going on - let's look at them in turn. First, we specify that we're using random seed 3. What does this mean? Well, the useful thing is that when we set the seed, we can predict what the next random value is going to be - it's the same as it was last time we set the seed to 3! Another useful thing to know is that shuffling a ring of notes works in the same way. In the example above we're essentially asking for the 'third shuffle' in the standard list of shuffles - which is also the same every time as we're always setting the random seed to the same value right before the shuffle. Finally we're just ticking through our shuffled notes to play the riff.
fr: Plusieurs choses se passent ; regardons les une par une. Tout d'abord, nous spécifions que nous utilisons la graine aléatoire 3. Qu'est-ce que cela signifie ? Et bien, ce qui est utile, c'est que lorsque nous paramétrons la graine, nous pouvons prédire quelle sera la prochaine valeur aléatoire ; c'est la même que la dernière fois que nous avons paramétré la graine à 3 ! Une autre chose utile à savoir est que le mélange d'un anneau de notes fonctionne de la même façon. Dans l'exemple ci-dessus, c'est comme si on demandait le 'troisième mélange' dans la liste standard de mélanges ; qui est aussi le même chaque fois que nous paramétrons toujours la même valeur de la graine aléatoire avant le mélange. Enfin, nous ne faisons que passer les notes mélangées pour jouer le riff.

en: Now, here's where the fun starts. If we change the random seed value to another number, say 3000, we get an entirely different shuffling of the notes. So now it's extremely easy to explore new melodies. Simply choose the list of notes we want to shuffle (scales are a great starting point) and then choose the seed we want to shuffle with. If we don't like the melody, just change one of those two things and try again. Repeat until you like what you hear!
fr: Maintenant, c'est ici que nous commençons à nous amuser. Si nous changeons la valeur aléatoire de la graine pour un autre nombre, disons 3000, nous obtenons un mélange entièrement différent des notes. Il est donc maintenant extrêmement facile d'explorer de nouvelles mélodies. Il suffit de choisir la liste de notes que l'on veut mélanger (les gammes sont un excellent point de départ) et ensuite de choisir la graine avec laquelle nous voulons les mélanger. Si nous n'aimons pas la mélodie, changez simplement l'une de ces deux choses et essayer à nouveau. Répétez jusqu'à ce que vous aimiez ce que vous entendez !

en: Pseudo Randomisation
fr: Pseudo aléatoire

en: Sonic Pi's randomisation is not actually random it's what's called pseudo random. Imagine if you were to roll a dice 100 times and write down the result of each roll onto a piece of paper. Sonic Pi has the equivalent of this list of results which it uses when you ask for a random value. Instead of rolling an actual dice, it just picks the next value from the list. Setting the random seed is just jumping to a specific point in that list.
fr: L'aléatoire de Sonic Pi n'est pas vraiment aléatoire, on appelle ça du pseudo aléatoire. Imaginez que vous jetez un dé 100 fois et que vous écrivez le résultat de chaque jet sur une feuille de papier. Sonic Pi a l'équivalent de cette liste de résultats qu'il utilise quand on demande une valeur aléatoire. Au lieu de jeter un vrai dé, il prend juste la valeur suivante dans la liste. Définir la graine aléatoire revient à sauter à un endroit particulier de cette liste.

en: Finding your Rhythm
fr: Trouver votre rythme

en: Another important aspect to our riff is the rhythm - when to play a note and when not to. As we saw above we can use `:r` in our rings to insert rests. Another very powerful way is to use spreads which we'll cover in a future tutorial. Today we'll use randomisation to help us find our rhythm. Instead of playing every note we can use a conditional to play a note with a given probability. Let's take a look:
fr: Un autre aspect important de notre riff est le rythme ; quand jouer une note et quand ne pas jouer. Comme nous l'avons vu plus haut, nous pouvons utiliser `:r` dans nos anneaux pour insérer des silences. Une autre manière très puissante consiste à utiliser des 'spreads' que nous aborderons dans un prochain tutoriel. Aujourd'hui, nous allons utiliser l'aléation pour nous aider à trouver notre rythme. Au lieu de jouer chaque note, nous pouvons utiliser un conditionnel pour jouer une note avec une probabilité donnée. Jetons un coup d’œil :

en: A really useful fn to know is `one_in` which will give us a `true` or `false` value with the specified probability. Here, we're using a value of 2 so on average one time every two calls to `one_in` it will return `true`. In other words, 50% of the time it will return `true`. Using higher values will make it return `false` more often introducing more space into the riff.
fr: Une fonction vraiment utile à connaître est `one_in` qui nous donnera une valeur `true` ou `false` (vrai ou faux) avec la probabilité spécifiée. Ici, nous utilisons une valeur de 2, donc en moyenne un appel sur deux à `one_in` retournera `true`. En d'autres termes, 50% du temps elle retournera `true`. Si on choisit des valeurs plus grandes, elle retournera `false` plus souvent ce qui mettra plus d'espace dans notre riff.

en: Notice that we've added some iteration in here with `16.times`. This is because we only want to reset our random seed value every 16 notes so our rhythm repeats every 16 times. This doesn't affect the shuffling as that is still done immediately after the seed is set. We can use the iteration size to alter the length of the riff. Try changing the 16 to 8 or even 4 or 3 and see how it affects the rhythm of the riff.
fr: Remarquez que nous avons ajouté quelques itérations ici avec `16.times`. C'est parce que nous voulons seulement réinitialiser notre valeur de graine aléatoire toutes les 16 notes afin que notre rythme se répète toutes les 16 fois. Cela n'affecte pas le mélange puisqu'il est toujours fait immédiatement après avoir défini la graine. Nous pouvons utiliser la taille d'itération pour modifier la longueur du riff. Essayez de changer le 16 en 8, ou même en 4, ou 3, et voyez comment cela affecte le rythme du riff.

en: OK, so let's combine everything we've learned together into one final example. See you next time!
fr: OK, combinons tout ce que nous avons appris dans un dernier exemple. À la prochaine !

en: A.5 Acid Bass
fr: A.5 Basse acide

en: It's impossible to look through the history of electronic dance music without seeing the enormous impact of the tiny Roland TB-303 synthesiser. It's the secret sauce behind the original acid bass sound. Those classic squealing and squelching TB-303 bass riffs can be heard from the early Chicago House scene through to more recent electronic artists such as Plastikman, Squarepusher and Aphex Twin.
fr: Il est impossible de parcourir l'histoire de la musique de danse électronique sans voir l'énorme impact du minuscule synthétiseur Roland TB-303. C'est la sauce secrète derrière le son de basse acide original. Ces riffs de basse TB-303 qui grincent et étouffent peuvent être entendus depuis la première scène de Chicago House jusqu'aux artistes électroniques plus récents tels que Plastikman, Squarepusher et Aphex Twin.

en: Interestingly, Roland never intended for the TB-303 to be used in dance music. It was originally created as a practice aid for guitarists. They imagined that people would program them to play bass lines to jam along to. Unfortunately there were a number of problems: they were a little fiddly to program, didn't sound particularly good as a bass-guitar replacement and were pretty expensive to buy. Deciding to cut their losses, Roland stopped making them after 10,000 units were sold and after a number of years sitting on guitarist's shelves, they soon could be found in the windows of second hand shops. These lonely discarded TB-303s were waiting to be discovered by a new generation of experimenters who started using them in ways that Roland didn't imagine to create wild new sounds. Acid House was born.
fr: Il est intéressant de noter que Roland n'a jamais eu l'intention d'utiliser le TB-303 dans la musique de danse. Il a été créé à l'origine pour aider les guitaristes à s'exercer. Ils imaginaient que les gens les programmeraient pour qu'ils jouent des lignes de basse d'accompagnement pour jammer. Malheureusement, il y avait un certain nombre de problèmes : ils étaient un peu compliqués à programmer, ne sonnaient pas particulièrement bien pour remplacer une guitare basse et étaient assez chers à l'achat. Décidant d'arrêter les frais, Roland a cessé de les fabriquer après la vente de 10000 unités et, après quelques années passées sur les étagères des guitaristes, ils se sont rapidement retrouvés dans les vitrines des magasins d'occasion. Ces TB-303 solitaires et abandonnés attendaient d'être découverts par une nouvelle génération d'expérimentateurs qui ont commencé à les utiliser d'une manière que Roland n'avait pas imaginée pour créer de nouveaux sons fous. La Acid House était née.

en: Although getting your hands on an original TB-303 is not so easy you will be pleased to know that you can turn your Raspberry Pi into one using the power of Sonic Pi. Behold, fire up Sonic Pi and throw this code into an empty buffer and hit Run:
fr: Bien que mettre la main sur un TB-303 original ne soit pas si facile, vous serez heureux d'apprendre que vous pouvez transformer votre Raspberry Pi en TB-303 en utilisant la puissance de Sonic Pi. Lancez Sonic Pi, copiez ce code dans un tampon vide, et cliquez sur 'Run' :

en: Instant acid bass! Let's play around...
fr: De l'Acid Bass instantané ! Jouons un peu...

en: Squelch that Bass
fr: Écrasez cette basse

en: First, let's build a live arpeggiator to make things fun. In the last tutorial we looked at how riffs can just be a ring of notes that we tick through one after another, repeating when we get to the end. Let's create a live loop that does exactly that:
fr: Commençons par construire un arpégiateur interactif pour rendre les choses amusantes. Dans le dernier tutoriel, nous avons vu comment des mélodies peuvent n'être qu'un anneau de notes que nous parcourons les unes après les autres, en répétant quand nous arrivons à la fin. Créons une boucle interactive qui fait exactement cela :

en: Take a look at each line.
fr: Jetez un œil à chaque ligne.

en: On the first line we set the default synth to be `tb303` with the `use_synth` fn.
fr: À la première ligne, choisissons `tb303` comme synthé par défaut avec la fonction `use_synth`.

en: On line two we create a live loop called `:squelch` which will just loop round and round.
fr: À la deuxième ligne, créons une boucle interactive du nom de `:squelch` qui va juste boucler encore et encore.

en: Line three is where we create our riff - a ring of notes (E in octaves 1, 2, and 3) which we simply tick through with `.tick`. We define `n` to represent the current note in the riff. The equals sign just means to assign the value on the right to the name on the left. This will be different every time round the loop. The first time round, `n` will be set to `:e1`. The second time round it will be `:e2`, followed by `:e3`, and then back to `:e1`, cycling round forever.
fr: La troisième ligne est l'endroit où nous créons notre riff : un anneau de notes (Mi dans les octaves 1, 2, et 3) que nous parcourons simplement avec `.tick'. Nous définissons `n' pour représenter la note courante dans le riff. Le signe égal signifie qu'il suffit d'assigner la valeur à droite au nom à gauche. Ce sera différent à chaque boucle. La première fois, `n' sera réglé sur `:e1`. La deuxième fois, ce sera `:e2`, suivi de `:e3`, puis retour à `:e1`, en bouclant à l'infini.

en: Line four is where we actually trigger our `:tb303` synth. We're passing a few interesting opts here: `release:`, `cutoff:`, `res:` and `wave:` which we'll discuss below.
fr: La ligne quatre est l'endroit où l'on déclenche notre synthé `:tb303`. On lui passe quelques options intéressantes : `release:`, `cutoff:`, `res:` et `wave:` que l'on décrira plus bas.

en: Line five is our `sleep` - we're asking the live loop to loop round every `0.125`s or 8 times a second at the default BPM of 60.
fr: La ligne cinq est notre `sleep` : on demande à la boucle interactive de boucler toutes les `0.125`secondes ou 8 fois par seconde au BPM par défaut de 60.

en: Line six is the `end` to the live loop. This just tells Sonic Pi where the end of the live loop is.
fr: La ligne six est la fin (NdT : `end`) de la boucle interactive. Le mot `end` indique précisément à Sonic Pi où se termine la boucle interactive.

en: Whilst you're still figuring out what's going on, type in the code above and hit the Run button. You should hear the `:tb303` kick into action. Now, this is where the action is: let's start live coding.
fr: Alors que vous êtes encore en train de vous familiariser avec ce qui se passe, tapez le code ci-dessous et cliquez sur le bouton 'Run'. Vous devriez entendre le `:tb303` entrer en action. C'est ici le cœur de l'action : commençons la programmation interactive.

en: Whilst the loop is still live, change the `cutoff:` opt to `110`. Now hit the Run button again. You should hear the sound become a little harsher and more squelchy. Dial in `120` and hit run. Now `130`. Listen how higher cutoff values make it sound more piercing and intense. Finally, drop it down to `80` when you feel like a rest. Then repeat as many times as you want. Don't worry, I'll still be here...
fr: Pendant que la boucle tourne, changez l'option `cutoff:` pour `110`. Puis cliquez à nouveau sur le bouton 'Run'. Vous devriez entendre le son devenir un peu plus dur et sec. Montez à `120` et cliquez sur 'Run'. Puis `130`. Écoutez comme les valeurs hautes de coupure (NdT : `cutoff`) rendent le son plus perçant et intense. Enfin, descendez à `80` quand vous sentirez qu'il vous faut un peu de repos. Puis répétez ça autant que vous voulez. Pas d'inquiétude, je serai toujours là...

en: Another opt worth playing with is `res:`. This controls the level of resonance of the filter. A high resonance is characteristic of acid bass sounds. We currently have our `res:` set to `0.8`. Try cranking it up to `0.85`, then `0.9`, and finally `0.95`. You might find that a cutoff such as `110` or higher will make the differences easier to hear. Finally go wild and dial in `0.999` for some insane sounds. At a `res` this high, you're hearing the cutoff filter resonate so much it starts to make sounds of its own!
fr: Une autre option avec laquelle ça vaut le coup de jouer est `res:`. Elle contrôle le niveau de résonance du filtre. Une résonance haute est caractéristique des sons de basse acide. Nous avons pour le moment une `res:` de `0.8`. Essayez de la monter à `0.85`, puis `0.9`, et enfin `0.95`. Vous pourriez trouver qu'un filtre de coupure à `110` ou plus haut peut permettre d'entendre plus facilement les différences. Enfin défoulez-vous et montez jusque `0.999` pour avoir des sons déments. Avec une `res` aussi haute, vous entendez tellement le filtre de coupure résonner qu'il commencera à faire ses propres sons !

en: Finally, for a big impact on the timbre try changing the `wave:` opt to `1`. This is the choice of source oscillator. The default is `0` which is a sawtooth wave. `1` is a pulse wave and `2` is a triangle wave.
fr: Enfin, pour avoir un grand impact sur le timbre, essayez de mettre l'option `wave:` à `1`. C'est le choix de l'oscillateur source. La valeur par défaut est `0` ce qui est une onde en dents de scie. `1` est une onde pulsée, et `2` est une onde en triangle.

en: Of course, try different riffs by changing the notes in the ring or even picking notes from scales or chords. Have fun with your first acid bass synth.
fr: Bien sûr, essayez différentes mélodies en changeant les notes dans l'anneau ou même en choisissant des notes de gammes ou d'accords. Amusez-vous bien avec votre premier synthé de basse acide.

en: Deconstructing the TB-303
fr: Déconstruisons le TB-303

en: The design of the original TB-303 is actually pretty simple. As you can see from the following diagram there's only 4 core parts.
fr: Le design du TB-303 original était en fait assez simple. Comme vous pouvez le voir sur le diagramme suivant, il n'y a que quatre parties principales.

en: ![TB-303 Design](../../../etc/doc/images/tutorial/articles/A.05-acid-bass/tb303-design.png)
fr: ![Design du TB-303](../../../etc/doc/images/tutorial/articles/A.05-acid-bass/tb303-design.png)

en: First is the oscillator wave - the raw ingredients of the sound. In this case we have a square wave. Next there's the oscillator's amplitude envelope which controls the amp of the square wave through time. These are accessed in Sonic Pi by the `attack:`, `decay:`, `sustain:` and `release:` opts along with their level counterparts. For more information read Section 2.4 'Duration with Envelopes' in the built-in tutorial. We then pass our enveloped square wave through a resonant low pass filter. This chops off the higher frequencies as well as having that nice resonance effect. Now this is where the fun starts. The cutoff value of this filter is also controlled by its own envelope! This means we have amazing control over the timbre of the sound by playing with both of these envelopes. Let's take a look:
fr: Tout d'abord, il y a l'onde oscillatoire - les ingrédients de base du son. Dans ce cas, nous avons une onde carrée. Ensuite, il y a l'enveloppe d'amplitude de l'oscillateur qui contrôle l'amplitude de l'onde carrée au cours du temps. On peut y accéder dans Sonic Pi avec les options `attack:`, `decay:`, `sustain:` et `release:` ainsi qu'à leurs niveaux correspondant. Pour plus d'informations, lisez la Section 2.4 'Durée avec les enveloppes' dans le tutoriel intégré. Nous passons ensuite notre onde carrée enveloppée à travers un filtre passe-bas résonant. Cela coupe les hautes fréquences tout en ayant un bel effet de résonance. C'est ici que le plaisir commence. La valeur de coupure de ce filtre est également contrôlée par sa propre enveloppe ! Cela signifie que nous avons un contrôle incroyable sur le timbre du son en jouant avec ces deux enveloppes. Jetons un coup d’œil :

en: For each standard envelope opt, there's a `cutoff_` equivalent opt in the `:tb303` synth. So, to change the cutoff attack time we can use the `cutoff_attack:` opt. Copy the code above into an empty buffer and hit Run. You'll hear a strange sound warble in and out. Now start to play. Try changing the `cutoff_attack:` time to `1` and then `0.5`. Now try `8`.
fr: Pour chaque option d'enveloppe standard, il y a une option équivalente `cutoff_' dans le synthétiseur `:tb303'. Donc, pour changer le temps d'attaque de coupure, nous pouvons utiliser l'option `cutoff_attack:`. Copiez le code ci-dessus dans un tampon vide et cliquez sur 'Run'. Vous entendrez un bruit de gazouillis fou qui rentre et qui sort. Maintenant, commencez à jouer. Essayez de changer la durée de `cutoff_attack:` en `1' puis `0.5'. Maintenant, essayez `8`.

en: Notice that I've passed everything through a `:reverb` FX for extra atmosphere - try other FX to see what works!
fr: Remarquez que j'ai passé tout cela à travers un effet `:reverb` pour plus d'atmosphère - essayez d'autres effets pour voir ce qui fonctionne !

en: Finally, here's a piece I composed using the ideas in this tutorial. Copy it into an empty buffer, listen for a while and then start live coding your own changes. See what wild sounds you can make with it! See you next time...
fr: Enfin, voici un morceau que j'ai composé en utilisant les idées de ce tutoriel. Copiez-le dans un tampon vide, écoutez-le pendant un moment, puis commencez à coder interactivement vos propres modifications. Voyez quels sons fous vous pouvez en faire ! À la prochaine....

en: A.6 Musical Minecraft
fr: A.6 Minecraft musical

en: Musical Minecraft
fr: Minecraft musical

en: **Deprecation Warning** *Apologies but this article was written back when Minecraft Pi Edition was still part of Raspberry Pi OS and Sonic Pi had built-in support to control it with code. Unfortunately this is no longer the case and the minecraft specific code (`mc_*` functions) are no longer available in Sonic Pi. However, this article is left here as a memory of what was once possible.*
fr: **Avertissement d'obsolescence** *Désolé mais cet article avait été réécrit quand l’Édition Minecraft Pi faisait encore partie du Système d'Exploitation Raspberry Pi et que Sonic Pi avait construit un support pour le contrôler avec du code. Malheureusement ce n'est plus le cas et le code spécifique à minecraft (les fonctions `mc_*`) n'est plus disponible dans Sonic Pi. Cependant, cet article est laissé ici comme un souvenir de ce qui était autrefois possible.*

en: Hello and welcome back! In the previous tutorials we've focussed purely on the music possibilities of Sonic Pi - (turning your Raspberry Pi into a performance ready musical instrument). So far we've learned how to:
fr: Bonjour et bon retour parmi nous ! Dans les tutoriels précédents, nous nous sommes concentrés uniquement sur les possibilités musicales de Sonic Pi, en transformant votre Raspberry Pi en un instrument de musique prêt à jouer. Jusqu'à présent, nous avons appris comment :

en: Live Code - changing the sounds on-the-fly,
fr: Programmation interactive - en changeant les sons à la volée,

en: Code some huge beats,
fr: Coder des rythmes imposants,

en: Generate powerful synth leads,
fr: Générer des mélodies de synthé puissantes,

en: Re-create the famous TB-303 acid-bass sound.
fr: Recréer le fameux son de basse acide TB-303.

en: There's so much more to show you (which we will explore in future editions). However, this month, let's look at something Sonic Pi can do that you probably didn't realise: control Minecraft.
fr: Il y a tant d'autres choses à vous montrer (que nous explorerons dans les prochaines éditions). Cependant, ce mois-ci, regardons quelque chose que Sonic Pi peut faire que vous n'avez probablement pas remarqué : contrôler Minecraft.

en: Hello Minecraft World
fr: Bonjour, monde de Minecraft

en: OK, let's get started. Boot up your Raspberry Pi, fire up Minecraft Pi and create a new world. Now start up Sonic Pi and re-size and move your windows so you can see both Sonic Pi and Minecraft Pi at the same time.
fr: D'accord, commençons. Démarrez votre Raspberry Pi, lancez Minecraft Pi et créez un nouveau monde. Maintenant, démarrez Sonic Pi, redimensionnez et déplacez vos fenêtres de manière à pouvoir voir Sonic Pi et Minecraft Pi en même temps.

en: In a fresh buffer type the following:
fr: Dans un tampon disponible, tapez ce qui suit :

en: Now, hit Run. Boom! Your message appeared in Minecraft! How easy was that? Now, stop reading this for a moment and play about with your own messages. Have fun!
fr: Maintenant, cliquez sur 'Run'. Boum ! Votre message est apparu dans Minecraft ! C'était facile, non ? Maintenant, arrêtez un moment de lire ceci et jouez un peu avec vos propres messages. Amusez-vous !

en: ![Screen 0](../../../etc/doc/images/tutorial/articles/A.06-minecraft/Musical-Minecraft-0-small.png)
fr: ![Écran 0](../../../etc/doc/images/tutorial/articles/A.06-minecraft/Musical-Minecraft-0-small.png)

en: Sonic Teleporter
fr: Téléportation sonique

en: Now let's do some exploring. The standard option is to reach for the mouse and keyboard and start walking around. That works, but it's pretty slow and boring. It would be far better if we had some sort of teleport machine. Well, thanks to Sonic Pi, we have one. Try this:
fr: Maintenant, faisons un peu d'exploration. L'option standard est d'attraper la souris et le clavier et de commencer à se promener. Ça fonctionne, mais c'est plutôt lent et ennuyeux. Il vaudrait mieux qu'on ait une sorte de téléporteur. Eh bien, grâce à Sonic Pi, nous en avons un. Essayez ceci :

en: Crikey! That was a long way up. If you weren't in flying-mode then you would have fallen back down all the way to the ground. If you double-tap space to enter flying-mode and teleport again, you'll stay hovering at the location you zap to.
fr: Oh ! C'était une longue ascension. Si vous n'étiez pas en mode de vol, vous seriez retombé jusqu'au sol. Si vous tapez deux fois sur la touche Espace pour entrer en mode vol et vous téléporter à nouveau, vous resterez en vol stationnaire à l'endroit où vous vous êtes déplacés.

en: Now, what do those numbers mean? We have three numbers which describe the coordinates of where in the world we want to go. We give each number a name - x, y and z:
fr: Que signifient ces chiffres ? Nous avons trois nombres qui décrivent les coordonnées de l'endroit du monde où nous voulons nous déplacer. Nous donnons un nom à chacun de ces numéros - x, y et z :

en: x - how far left and right (80 in our example)
fr: x - la distance à gauche et à droite (80 dans notre exemple)

en: y - how high we want to be (40 in our example)
fr: y - la hauteur que nous voulons atteindre (40 dans notre exemple)

en: z - how far forward and back (100 in our example)
fr: z - la distance avant et arrière (100 dans notre exemple)

en: By choosing different values for x, y and z we can teleport *anywhere* in our world. Try it! Choose different numbers and see where you can end up. If the screen goes black it's because you've teleported yourself under the ground or into a mountain. Just choose a higher y value to get back out above land. Keep on exploring until you find somewhere you like...
fr: En choisissant des valeurs différentes pour x, y et z, nous pouvons nous téléporter *n'importe où* dans notre monde. Essayez ! Choisissez différents nombres et voyez où vous pouvez vous retrouver. Si l'écran devient noir, c'est que vous vous êtes téléporté sous terre ou dans une montagne. Il suffit de choisir une valeur y plus élevée pour revenir au dessus de la terre. Continuez à explorer jusqu'à ce que vous trouviez un endroit qui vous plaise....

en: Using the ideas so far, let's build a Sonic Teleporter which makes a fun teleport sound whilst it whizzes us across the Minecraft world:
fr: En utilisant les idées vues jusqu'ici, construisons un téléporteur sonique qui fera un son de téléportation amusant pendant qu'il nous propulsera à travers le monde de Minecraft :

en: ![Screen 1](../../../etc/doc/images/tutorial/articles/A.06-minecraft/Musical-Minecraft-1-small.png)
fr: ![Écran 1](../../../etc/doc/images/tutorial/articles/A.06-minecraft/Musical-Minecraft-1-small.png)

en: Magic Blocks
fr: Blocs magiques

en: Now you've found a nice spot, let's start building. You could do what you're used to and start clicking the mouse furiously to place blocks under the cursor. Or you could use the magic of Sonic Pi. Try this:
fr: Maintenant que vous avez trouvé un bel endroit, commençons à construire. Vous pourriez faire comme vous en avez l'habitude et commencer à cliquer furieusement avec la souris pour placer des blocs sous le curseur. Ou vous pouvez employer la magie de Sonic Pi. Essayez ceci :

en: Now look up! There's a melon in the sky! Take a moment to look at the code. What did we do? On line one we grabbed the current location of Steve as the variables x, y and z. These correspond to our coordinates described above. We use these coordinates in the fn `mc_set_block` which will place the block of your choosing at the specified coordinates. In order to make something higher up in the sky we just need to increase the y value which is why we add 5 to it. Let's make a long trail of them:
fr: Maintenant, regardez en l'air ! Il y a un melon dans le ciel ! Prenez un moment pour regarder le code. Qu'est-ce qu'on a fait ? Sur la première ligne, nous avons saisi l'emplacement actuel de Steve dans les variables x, y et z. Celles-ci correspondent à nos coordonnées décrites ci-dessus. Nous utilisons ces coordonnées dans le bloc fn `mc_set_block` qui placera le bloc de votre choix aux coordonnées spécifiées. Pour placer quelque chose plus haut dans le ciel, il suffit d'augmenter la valeur y, et c'est pourquoi nous y ajoutons 5. Faisons-en une longue traînée :

en: Now, jump over to Minecraft, make sure you're in flying-mode (double tap space if not) and fly all around the world. Look behind you to see a pretty trail of melon blocks! See what kind of twisty patterns you can make in the sky.
fr: Maintenant, passez à Minecraft, assurez-vous que vous êtes en mode vol (tapez deux fois sur Espace sinon) et volez autour du monde. Regardez derrière vous pour voir une jolie traînée de blocs de melon ! Voyez quelles sortes de motifs tortueux vous pouvez faire dans le ciel.

en: Live Coding Minecraft
fr: Programmation interactive de Minecraft

en: Those of you that have been following this tutorial over the last few months will probably have your minds blown at this point. The trail of melons is pretty cool, but the most exciting part of the previous example is that you can use `live_loop` with Minecraft! For those that don't know, `live_loop` is Sonic Pi's special magic ability that no other programming language has. It lets you run multiple loops at the same time and allows you to change them whilst they run. They are incredibly powerful and amazing fun. I use `live_loop`s to perform music in nightclubs with Sonic Pi - DJs use discs and I use `live_loop`s :-) However, today we're going to live code both music and Minecraft.
fr: Ceux d'entre vous qui ont suivi ce tutoriel au cours des derniers mois seront probablement bien étonnés ici. La chemin de melons est plutôt chouette, mais la partie la plus excitante de l'exemple précédent est que vous pouvez utiliser `live_loop` avec Minecraft ! Pour ceux qui ne savent pas, `live_loop` est la faculté magique spéciale de Sonic Pi qu'aucun autre langage de programmation ne possède. Elle vous permet d'exécuter plusieurs boucles en même temps et vous permet de les modifier pendant qu'elles s'exécutent. Elles sont incroyablement puissantes et formidablement amusantes. J'utilise des `live_loop` pour jouer de la musique dans les boîtes de nuit avec Sonic Pi - les DJ utilisent des disques et j'utilise des `live_loop` :-) Cependant, aujourd'hui, nous allons programmer de manière interactive la musique et Minecraft.

en: Let's get started. Run the code above and start making your melon trail again. Now, without stopping the code, just simply change `:melon` to `:brick` and hit run. Hey presto, you're now making a brick trail. How simple was that! Fancy some music to go with it? Easy. Try this:
fr: Commençons tout de suite. Exécutez le code ci-dessus et recommencez à faire votre chemin de melons. Maintenant, sans arrêter le code, changez simplement `:melon` en `:brick` et cliquez sur `Run`. Et voilà, vous construisez maintenant un chemin en briques. Comme c'est simple ! Envie d'un peu de musique pour l'accompagner ? Facile. Essayez ceci :

en: Now, whilst that's playing start changing the code. Change the block types - try `:water`, `:grass` or your favourite block type. Also, try changing the cutoff value from `70` to `80` and then up to `100`. Isn't this fun?
fr: Maintenant, pendant que ça joue, commencez à modifier le code. Changez les types de blocs - essayez `:water`, `:grass` ou votre type de bloc préféré. Essayez aussi de changer la valeur de coupure de `70` à `80` et puis jusqu'à `100`. C'est amusant, non ?

en: ![Screen 2](../../../etc/doc/images/tutorial/articles/A.06-minecraft/Musical-Minecraft-2-small.png)
fr: ![Écran 2](../../../etc/doc/images/tutorial/articles/A.06-minecraft/Musical-Minecraft-2-small.png)

en: Let's combine everything we've seen so far with a little extra magic. Let's combine our teleportation ability with block placing and music to make a Minecraft Music Video. Don't worry if you don't understand it all, just type it in and have a play by changing some of the values whilst it's running live. Have fun and see you next time...
fr: Combinons tout ce qu'on a vu jusqu'ici avec un peu plus de magie. Combinons notre capacité de téléportation avec le placement des blocs et la musique pour créer une vidéo musicale Minecraft. Ne vous inquiétez pas si vous ne comprenez pas tout, tapez simplement le code et jouez en modifiant certaines des valeurs en cours d'exécution. Amusez-vous bien et à la prochaine fois....

en: A.7 Bizet Beats
fr: A.7 Battements de Bizet

en: Bizet Beats
fr: Battements de Bizet

en: After our brief excursion to the fantastic world of coding Minecraft with Sonic Pi last month, let's get musical again. Today we're going to bring a classical operatic dance piece straight into the 21st century using the awesome power of code.
fr: Après notre brève excursion dans le monde fantastique de la programmation Minecraft avec Sonic Pi le mois dernier, penchons-nous à nouveau sur la musique. Aujourd'hui nous allons amener un morceau classique de danse d'opéra droit dans le 21ème siècle en utilisant la puissance impressionnante du code.

en: Outrageous and Disruptive
fr: Scandaleux et Perturbateur

en: Let's jump into a time machine back to the year 1875. A composer called Bizet had just finished his latest opera Carmen. Unfortunately like many exciting and disruptive new pieces of music people initially didn't like it at all because it was too outrageous and different. Sadly Bizet died ten years before the opera gained huge international success and became one of the most famous and frequently performed operas of all time. In sympathy with this tragedy let's take one of the main themes from Carmen and convert it to a modern format of music that is also too outrageous and different for most people in our time - live coded music!
fr: Sautons dans une machine à remonter le temps jusqu'en 1875. Un compositeur nommé Bizet avait juste terminé son dernier opéra : Carmen. Malheureusement comme beaucoup de nouveaux morceaux innovants et perturbateurs, les gens ne les aimaient pas du tout puisqu'ils les trouvaient trop choquants et différents. Malheureusement Bizet est mort dix ans avant que l'opéra ne connaisse un succès international et ne devienne l'un des opéras les plus connus et les plus fréquemment interprétés de tous les temps. Par sympathie pour cette tragédie, nous allons prendre un des thèmes principaux de Carmen et nous allons le convertir dans un format moderne de musique qui est aussi trop innovant et pertubateur pour la plupart des gens de notre époque : la musique codée interactive !

en: Decoding the Habanera
fr: La Habanera décryptée

en: Trying to live code the whole opera would be a bit of a challenge for this tutorial, so let's focus on one of the most famous parts - the bass line to the Habanera:
fr: Essayer de programmer un opéra entier de manière interactive serait un peu trop ambitieux pour ce tutoriel. Concentrons nous plutôt sur une des ses plus célèbres parties : la ligne de basse de la Habanera :

en: ![Habanera Riff](../../../etc/doc/images/tutorial/articles/A.07-bizet/habanera.png)
fr: ![Riff Habanera](../../../etc/doc/images/tutorial/articles/A.07-bizet/habanera.png)

en: This may look extremely unreadable to you if you haven't yet studied music notation. However, as programmers we see music notation as just another form of code - only it represents instructions to a musician instead of a computer. We therefore need to figure out a way of decoding it.
fr: Cela peut vous sembler complètement illisible si vous n'avez pas étudié la notation musicale. Cependant, en tant que programmeurs nous voyons la notation musicale comme juste une autre forme de code, elle représente juste des instructions pour un musicien au lieu d'un ordinateur. C'est pourquoi nous devons trouver un moyen de la décoder.

en: The notes are arranged from left to right like the words in this magazine but also have different heights. *The height on the score represents the pitch of the note.* The higher the note on the score, the higher the pitch of the note.
fr: Les notes sont arrangées de gauche à droite comme les mots dans ce magazine mais elles ont aussi des hauteurs différentes. *La position verticale en hauteur sur la partition représente la hauteur d'une note.* Plus haute est la note sur la partition, plus la hauteur de la note est élevée.

en: In Sonic Pi we already know how to change the pitch of a note - we either use high or low numbers such as `play 75` and `play 80` or we use the note names: `play :E` and `play :F`. Luckily each of the vertical positions of the musical score represents a specific note name. Take a look at this handy look up table:
fr: Dans Sonic Pi nous savons déjà comment changer la hauteur d'une note : on peut utiliser des grands ou petits nombres comme `play 75` et `play 80` ou on peut utiliser les noms des notes : `play :E` et `play :F`. Heureusement chacune des positions verticales sur la partition représente un nom de note en particulier. Jetez un œil à cette table de correspondance bien pratique :

en: Rests
fr: Silences

en: Music scores are an extremely rich and expressive kind of code capable of communicating many things. It therefore shouldn't come as much of a surprise that musical scores can not only tell you what notes to play but also when *not* to play notes. In programming this is pretty much equivalent to the idea of `nil` or `null` - the absence of a value. In other words not playing a note is like the absence of a note.
fr: Les partitions sont une sorte de code extrêmement riche et expressif capable de communiquer de nombreuses choses. Cela ne devrait donc pas nous surprendre que les partitions peuvent non seulement nous dire quelles notes jouer mais aussi quand *ne pas* jouer de note. En programmation c'est à peu près l'équivalent de l'idée de `nil` ou `null` : l'absence de valeur. En d'autres termes, ne pas jouer une note, c'est comme une absence de note.

en: If you look closely at the score you'll see that it's actually a combination of black dots with lines which represent notes to play and squiggly things which represent the rests. Luckily Sonic Pi has a very handy representation for a rest: `:r`, so if we run: `play :r` it actually plays silence! We could also write `play :rest`, `play nil` or `play false` which are all equivalent ways of representing rests.
fr: Si vous regardez de près la partition, vous verrez que c'est en fait une combinaison de ronds noirs avec des barres qui représentent les notes à jouer et des choses ondulées qui représentent les silences. Heureusement, Sonic Pi a une notation très pratique pour un silence : `:r`, donc si on exécute `play :r` il jouera en fait un silence ! On pourrait aussi écrire `play :rest`, `play nil` ou `play false` qui sont autant de manières équivalentes de représenter un silence.

en: Rhythm
fr: Rythme

en: Finally, there's one last thing to learn how to decode in the notation - the timings of the notes. In the original notation you'll see that the notes are connected with thick lines called beams. The second note has two of these beams which means it lasts for a 16th of a beat. The other notes have a single beam which means they last for an 8th of a beat. The rest has two squiggly beams which means it also represents a 16th of the beat.
fr: Enfin, il y a une dernière chose à apprendre à décoder dans la notation : la notion de durée des notes. Dans la notation originale vous verrez que les notes sont liées par des traits épais. La deuxième note a deux de ces traits ce qui veut dire qu'elle dure un 16ème de temps. Les autres notes ont un seul trait ce qui veut dire qu'elles durent un 8ème de temps. Le silence a aussi deux traits ondulés ce qui veut dire qu'il représente aussi un 16ème de temps.

en: When we attempt to decode and explore new things a very handy trick is to make everything as similar as possible to try and see any relationships or patterns. For example, when we re-write our notation purely in 16ths you can see that our notation just turns into a nice sequence of notes and rests.
fr: Quand on essaie de décoder et d'explorer de nouvelles choses, un truc très pratique est de faire en sorte que tout se ressemble le plus possible pour essayer de voir des relations ou des modèles. Par exemple, lorsqu'on réécrit notre notation uniquement en double-croches, vous pouvez voir que notre notation se transforme en une belle séquence de notes et de silences.

en: ![Habanera Riff 2](../../../etc/doc/images/tutorial/articles/A.07-bizet/habanera2.png)
fr: ![Riff Habanera 2](../../../etc/doc/images/tutorial/articles/A.07-bizet/habanera2.png)

en: Re-coding the Habanera
fr: Recodage de la Habanera

en: We're now in a position to start translating this bass line to Sonic Pi. Let's encode these notes and rests in a ring:
fr: Nous sommes maintenant prêt à commencer la traduction de cette ligne de basse en Sonic Pi. Encodons ces notes et silences dans un anneau :

en: Let's see what this sounds like. Throw it in a live loop and tick through it:
fr: Voyons comment ça sonne. Jetons ça dans une boucle interactive et parcourons-là :

en: Fabulous, that instantly recognisable riff springs to life through your speakers. It took a lot of effort to get here, but it was worth it - high five!
fr: Fabuleux, cette mélodie qu'on reconnaît immédiatement prend vie dans vos haut-parleurs. On a fait de gros efforts pour en arriver là, mais ça valait la peine, bien joué !

en: Moody Synths
fr: Synthés grincheux

en: Now we have the bass line, let's re-create some of the ambience of the operatic scene. One synth to try out is `:blade` which is a moody 80s style synth lead. Let's try it with the starting note `:d` passed through a slicer and reverb:
fr: Maintenant qu'on a la ligne de basse, essayons de recréer une partie de l'ambiance de la scène d'opéra. Un synthé à essayer est `:blade` qui est un synthé style années 80. Essayons-le avec la note de départ `:d` passée dans un slicer et de la réverb :

en: Now, try the other notes in the bass line: `:a` and `:f5`. Remember, you don't need to hit stop, just modify the code whilst the music is playing and hit run again. Also, try different values for the slicer's `phase:` opt such as `0.5`, `0.75` and `1`.
fr: Maintenant essayez les autres notes de la ligne de basse : `:a` et `:f5`. Souvenez-vous que vous n'avez pas besoin de cliquer sur 'Stop', vous pouvez juste modifier le code pendant que la musique tourne et ensuite cliquer sur 'Run' à nouveau. Aussi essayez différentes valeurs pour l'option `phase:` du slicer comme `0.5`, `0.75` et `1`.

en: Finally, let's combine all the ideas so far into a new remix of the Habanera. You might notice that I've included another part of the bass line as a comment. Once you've typed it all into a fresh buffer hit Run to hear the composition. Now, without hitting stop, *uncomment* the second line by removing the `#` and hit run again - how marvellous is that! Now, start mashing it around yourself and have fun.
fr: Enfin, combinons toutes les idées vues jusqu'ici dans un nouveau remix de la Habanera. Vous remarquerez peut-être que j'ai inclus une autre partie de la ligne de basse en commentaire. Quand vous aurez tout tapé dans un tampon de libre, cliquez sur 'Run' pour entendre la composition. Maintenant, sans cliquer sur 'Stop', *décommentez* la seconde ligne en enlevant le `#` et cliquez sur 'Run' à nouveau : c'est merveilleux, non ? Maintenant amusez-vous à le modifier vous-même.

en: A.8 Become a Minecraft VJ
fr: A.8 Devenez un VJ Minecraft

en: Become a Minecraft VJ
fr: Devenez un VJ Minecraft

en: ![Screen 0](../../../etc/doc/images/tutorial/articles/A.08-minecraft-vj/minecraft-vj-0-small.png)
fr: ![Écran 0](../../../etc/doc/images/tutorial/articles/A.08-minecraft-vj/minecraft-vj-0-small.png)

en: Everyone has played Minecraft. You will all have built amazing structures, designed cunning traps and even created elaborate cart lines controlled by redstone switches. How many of you have performed with Minecraft? We bet you didn't know that you could use Minecraft to create amazing visuals just like a professional VJ.
fr: Tout le monde a joué à Minecraft. Vous aurez tous construit des structures incroyables, conçu des pièges rusés et même créé des lignes de chariots raffinées contrôlées par des interrupteurs de pierre rouge. Mais qui parmi vous a fait une performance vidéo avec Minecraft ? On parie que vous ne saviez pas que vous pouvez utiliser Minecraft pour créer des animations visuelles incroyables tout comme un VJ professionnel.

en: If your only way of modifying Minecraft was with the mouse, you'd have a tough time changing things fast enough. Luckily for you your Raspberry Pi comes with a version of Minecraft that can be controlled with code. It also comes with an app called Sonic Pi which makes coding Minecraft not only easy but also incredibly fun.
fr: Si votre seule possibilité de modifier Minecraft était d'utiliser la souris, vous auriez du mal à changer les choses suffisamment vite. Heureusement pour vous,votre Raspberry Pi a une version de Minecraft qui peut être contrôlée avec du code. Il contient aussi une application nommée Sonic Pi qui rend la programmation Minecraft non seulement facile mais aussi incroyablement amusante.

en: In today's article we'll be showing you some of the tips and tricks that we've used to create performances in night clubs and music venues around the world.
fr: Dans l'article d'aujourd'hui, nous allons vous montrer quelques trucs et astuces que nous avons utilisés pour créer des concerts, des performances dans des boîtes de nuit et salles de concert autour du monde.

en: Let's get started...
fr: Premiers pas...

en: Getting Started
fr: Commencer

en: Let's start with a simple warm up exercise to refresh ourselves with the basics. First up, crack open your Raspberry Pi and then fire up both Minecraft and Sonic Pi. In Minecraft, create a new world, and in Sonic Pi choose a fresh buffer and write in this code:
fr: Commençons avec un simple exercice d'échauffement pour nous rappeler les bases. Commencez par allumer votre Raspberry Pi et lancer Minecraft et Sonic Pi. Dans Minecraft, créez un nouveau monde, et dans Sonic Pi choisissez un tampon de libre et écrivez-y ce code :

en: mc_message "Let's get started..."
fr: mc_message "Commençons..."

en: Hit the Run button and you'll see the message over in the Minecraft window. OK, we're ready to start, let's have some fun......
fr: Cliquez sur le bouton 'Run' et vous verrez le message dans la fenêtre Minecraft. OK, on est prêt à démarrer, on va s'amuser...

en: Sand Storms
fr: Tempêtes de sable

en: When we're using Minecraft to create visuals we try and think about what will both look interesting and also be easy to generate from code. One nice trick is to create a sand storm by dropping sand blocks from the sky. For that all we need are a few basic fns:
fr: Quand on utilise Minecraft pour créer des visuels on essaie de penser à des choses qui auront l'air intéressantes et qui seront aussi faciles à générer avec du code. Un truc sympa est de créer une tempête de sable en laissant tomber des bloc de sable du ciel. Pour cela, on a juste besoin de quelques fonctions simples :

en: `sleep` - for inserting a delay between actions
fr: `sleep`- pour insérer un délai entre des actions

en: `mc_location` - to find our current location
fr: `mc_location`- pour trouver notre emplacement courant

en: `mc_set_block`- to place sand blocks at a specific location
fr: `mc_set_block`- pour positionner des blocs de sable à un endroit particulier

en: `rrand` - to allow us to generate random values within a range
fr: `rrand`- pour nous permettre de générer des valeurs aléatoires dans un intervalle

en: `live_loop` - to allow us to continually make it rain sand
fr: `live_loop`- pour nous permettre de faire pleuvoir du sable en continu

en: If you're unfamiliar with any of the built-in fns such as `rrand`, just type the word into your buffer, click on it and then hit the keyboard combo `Control-i` to bring up the built-in documentation. Alternatively you can navigate to the *lang* tab in the Help system and then look up the fns directly along with all the other exciting things you can do.
fr: Si vous ne connaissez pas une des ces fonctions comme `rrand`, vous pouvez juste taper le mot dans votre tampon, cliquer dessus, puis taper `Control-i` sur le clavier pour ouvrir la documentation. Vous pouvez aussi aller dans l'onglet *lang* du système d'aide puis y chercher directement les fonctions et toutes sortes d'autres choses excitantes que vous pouvez faire.

en: Let's make it rain a little first before unleashing the full power of the storm. Grab your current location and use it to create a few sand blocks up in the sky nearby:
fr: Commençons par faire tomber un peu de pluie avant de laisser la tempête complète éclater. Récupérez votre emplacement courant et utilisez-la pour créer quelques blocs de sable dans le ciel pas loin :

en: When you hit Run, you might have to look around a little as the blocks may start falling down behind you depending on which direction you're currently facing. Don't worry, if you missed them just hit Run again for another batch of sand rain - just make sure you're looking the right way!
fr: Après avoir cliqué sur 'Run', vous devrez peut-être un peu regarder autour de vous car les blocs peuvent commencer par tomber derrière vous, suivant dans quelle direction vous êtes pour le moment. N'ayez pas peur, si vous les avez ratés, cliquez à nouveau sur 'Run' pour créer encore un peu de pluie de sable, assurez-vous juste de regarder dans la bonne direction !

en: Let's quickly review what's going on here. On the first line we grabbed Steve's location as coordinates with the fn `mc_location` and placed them into the vars `x`, `y`, and `z`. Then on the next lines we used the `mc_set_block` fn to place some sand at the same coordinates as Steve but with some modifications. We chose the same x coordinate, a y coordinate 20 blocks higher and then successively larger z coordinates so the sand dropped in a line away from Steve.
fr: Parcourons rapidement ce qui se passe ici. Sur la première ligne nous avons récupéré l'emplacement Steve en coordonnées avec la fonction `mc_location` et les avons placées dans les variables `x`, `y` et `z`. Puis sur les lignes suivantes, nous avons utilisé la fonction `mc_set_block` pour placer un peu de sable aux mêmes coordonnées que Steve mais avec quelques modifications. On a utilisé la même coordonnée x, une coordonnée y 20 blocs plus haut et des coordonnées z successivement plus larges pour que le sable tombe dans une ligne en s'éloignant de Steve.

en: Why don't you take that code and start playing around with it yourself? Try adding more lines, changing the sleep times, try mixing `:sand` with `:gravel` and choose different coordinates. Just experiment and have fun!
fr: Et si vous preniez ce code et commenciez à jouer avec ? Essayez d'ajouter plus de lignes, de changer la durée d'attente, essayez de mélanger du `:sand` avec du `:gravel` et choisissez différentes coordonnées. Expérimentez et amusez-vous !

en: Live Loops Unleashed
fr: Boucles interactives déchaînées

en: OK, it's time to get the storm raging by unleashing the full power of the `live_loop` - Sonic Pi's magical ability which unleashes the full power of live coding - changing code on-the-fly whilst it's running!
fr: OK, il est l'heure de lancer la tempête en déchaînant la puissance complète de la `live_loop`- le pouvoir magique de Sonic Pi qui révèle la pleine puissance de la programmation interactive - changer le code à la volée pendant qu'il est en train de s'exécuter !

en: What fun! We're looping round pretty quickly (8 times a second) and during each loop we're finding Steve's location like before but then generating 3 random values:
fr: Qu'est-ce que c'est amusant ! On boucle assez vite (8 fois par seconde) et pendant chaque boucle, on trouve l'emplacement de Steve comme avant mais on génère ensuite trois valeurs aléatoires :

en: `xd` - the difference for x which will be between -10 and 10
fr: `xd` : la différence pour x, qui sera entre -10 et 10

en: `zd` - the difference for z also between -10 and 10
fr: `zd` : la différence pour z, aussi entre -10 et 10

en: `co` - a cutoff value for the low pass filter between 70 and 130
fr: `co` : une valeur de coupure pour le filtre passe-bas, entre 70 et 130

en: We then use those random values in the fns `synth` and `mc_set_block` giving us sand falling in random locations around Steve along with a percussive rain-like sound from the `:cnoise` synth.
fr: On utilise ensuite ces valeurs aléatoires dans les fonctions `synth` et `mc_set_block` ce qui nous donne du sable qui tombe dans des endroits aléatoires autour de Steve ainsi qu'un son percussif semblable à de la pluie, joué le synthé `:cnoise`.

en: For those of you new to live loops - this is where the fun really starts with Sonic Pi. Whilst the code is running and the sand is pouring down, try changing one of the values, perhaps the sleep time to `0.25` or the `:sand` block type to `:gravel`. Now hit run *again*. Hey Presto! Things changed without the code stopping. This is your gateway to performing like a real VJ. Keep practising and changing things around. How different can you make the visuals without stopping the code?
fr: Pour ceux d'entre vous qui ne connaissaient pas les boucles interactives : c'est là qu'on commence vraiment à s'amuser avec Sonic Pi. Pendant que le code tourne et que le sable pleut, essayez de changer une des valeurs, peut-être la valeur d'attente à `0.25` ou le type de bloc `:sand` en `:gravel`. Ensuite cliquez sur 'Run' à nouveau. Et voilà ! Les choses changent sans que le code ne s'arrête. C'est le chemin pour vous produire comme un vrai VJ. Continuez à vous exercer à changer des choses. Jusqu'où arrivez-vous à modifier les visuels sans arrêter le code ?

en: Epic Block Patterns
fr: Des motifs de blocs épiques

en: ![Screensman 1](../../../etc/doc/images/tutorial/articles/A.08-minecraft-vj/minecraft-vj-1-small.png)
fr: ![Écran 1](../../../etc/doc/images/tutorial/articles/A.08-minecraft-vj/minecraft-vj-1-small.png)

en: Finally, another great way of generating interesting visuals is to generate huge patterned walls to fly towards and close by. For this effect we'll need to move from placing the blocks randomly to placing them in an ordered manner. We can do this by nesting two sets of iteration (hit the Help button and navigate to section 5.2 of the tutorial "Iteration and Loops" for more background on iteration). The funny `|xd|` after the do means that `xd` will be set for each value of the iteration. So the first time it will be 0, then 1, then 2... etc. By nesting two lots of iteration together like this we can generate all the coordinates for a square. We can then randomly choose block types from a ring of blocks for an interesting effect:
fr: Enfin une autre façon géniale de générer des visuels intéressants est de créer des énormes murs de motifs vers lesquels voler. Pour cet effet nous allons devoir passer d'un placement aléatoire de blocs à un placement de manière ordonnée. On peut faire cela en imbriquant deux itérations (cliquez sur le bouton 'Aide' et allez dans la section 5.2 du tutoriel "Itération et boucles" pour plus d'informations sur l'itération). L'étrange `|xd|` après le `do` veut dire que `xd` prendra une valeur à chaque boucle de l'itération. La première fois il vaudra `0`, puis `1`, puis `2`, etc. En imbriquant deux itérations comme cela on peut générer toutes les coordonnées d'un carré. On peut ensuite choisir aléatoirement des types de blocs d'un anneau de blocs pour obtenir un effet intéressant :

en: Pretty neat. Whilst we're having fun here, try changing `bs.choose` to `bs.tick` to move from a random pattern to a more regular one. Try changing the block types and the more adventurous of you might want to try sticking this within a `live_loop` so that the patterns keep changing automatically.
fr: Pas mal. Puisqu'on s'amuse, essayez de changer `bs.choose` en `bs.tick` pour passer d'un motif aléatoire à un motif plus régulier. Essayez de changer les types de blocs et les plus aventureux parmi vous voudrons peut-être mettre ce code dans une `live_loop` pour que les modifs continuent à changer automatiquement.

en: Now, for the VJ finale - change the two `10.times` to `100.times` and hit Run. Kaboom! A Huge gigantic wall of randomly placed bricks. Imagine how long it would take you to build that manually with your mouse! Double-tap space to enter fly-mode and start swooping by for some great visual effects. Don't stop here though - use your imagination to conjure up some cool ideas and then use the coding power of Sonic Pi to make it real. When you've practised enough dim the lights and put on a VJ show for your friends!
fr: Enfin, pour la fin du set du VJ, changez les deux `10.times` en `100.times` et cliquez sur 'Run'. Boum ! Un énorme mur géant de briques aléatoires. Imaginez combien de temps ça vous aurait pris de construire ça avec votre souris ! Double-tapez la touche Espace pour entrer en mode volant et commencez à planer pour obtenir de super effets visuels. Ne vous arrêtez pas là, utilisez votre imagination pour trouver des idées sympa et utilisez ensuite la puissance de programmation de Sonic Pi pour le réaliser. Quand vous vous serez suffisamment exercés, baissez la lumière et donnez un spectacle de VJ pour vos amis !

en: A.9 Randomisation
fr: A.9 L'aléation

en: Surfing Random Streams
fr: Surfer sur des flux aléatoires

en: Back in episode 4 of this tutorial series we took a brief look at randomisation whilst coding up some sizzling synth riffs. Given that randomisation is such an important part of my live coding DJ sets I thought it would be useful to cover the fundamentals in much greater detail. So, get your lucky hat on and let's surf some random streams!
fr: Dans le quatrième épisode de cette série de tutoriels, nous avons brièvement jeté un œil à l'aléation en codant des riffs grésillants de synthé. Vu comme l'aléation est une partie très importante de mes performances de DJ codeur en live, j'ai pensé qu'il serait utile d'en couvrir les bases plus en détail. Mettez votre casquette et surfons sur des flux aléatoires !

en: There is no random
fr: Il n'y a pas d'aléation

en: The first thing to learn which might really surprise you when playing with Sonic Pi's randomisation functions is that they're not actually really random. What does this actually mean? Well, let's try a couple of tests. First, imagine a number in your head between 0 and 1. Keep it there and don't tell me. Now let me guess... was it `0.321567`? No? Bah, I'm clearly no good at this. Let me have another go, but let's ask Sonic Pi to choose a number this time. Fire up Sonic Pi v2.7+ and ask it for a random number but again don't tell me:
fr: La première chose à savoir et qui pourrait vraiment vous surprendre en jouant avec les fonctions aléatoires de Sonic Pi, c'est qu'elles ne sont en fait pas vraiment aléatoires. Qu'est-ce que cela signifie ? Eh bien, faisons quelques essais. Commencez par imaginer un nombre dans votre tête entre 0 et 1. Gardez-le en tête et ne me le dîtes pas. Maintenant, laissez-moi deviner... est-ce que c'était `0.321567` ? Non ? Bah, je ne suis clairement pas bon à ce jeu. Essayons encore une fois, mais demandons à Sonic Pi de choisir un nombre cette fois. Lancez Sonic Pi version 2.7 ou plus et demandez lui un nombre aléatoire mais de nouveau ne me dites pas le résultat :

en: Now for the reveal... was it `0.75006103515625`? Yes! Ha, I can see you're a little sceptical. Perhaps it was just a lucky guess. Let's try again. Press the Run button again and see what we get... What? `0.75006103515625` again? This clearly can't be random! You're right, it's not.
fr: Et maintenant pour le truc... est-ce que c'était `0.75006103515625` ? Oui ! Ha, je vois que vous êtes un peu sceptique. C'était peut-être juste de la chance. Essayons encore. Cliquez sur 'Run' à nouveau et regardons ce qu'on obtient... Quoi ? Encore `0.75006103515625` ? Ca ne peut clairement pas être aléatoire ! Vous avez raison, ça ne l'est pas.

en: What's going on here? The fancy computer science word here is determinism. This just means that nothing is by chance and everything is destined to be. Your version of Sonic Pi is destined to always return `0.75006103515625` in the program above. This might sound pretty useless, but let me assure you that it's one of the most powerful parts of Sonic Pi. If you stick at it you'll learn how to rely on the deterministic nature of Sonic Pi's randomisation as a fundamental building block for your compositions and live coded DJ sets.
fr: Qu'est-ce qui se passe ? En informatique, on appelle cela le déterminisme. Cela veut juste dire que rien n'a lieu par hasard et que tout a sa destinée. Votre version de Sonic Pi a le destin de toujours retourner `0.75006103515625` dans le programme ci-dessus. Cela peut sembler plutôt inutile, mais laissez-moi vous assurer, c'est une des parties les plus puissantes de Sonic Pi. Si vous persévérez, vous apprendrez comment compter sur la nature déterministe de Sonic Pi en ce qui concerne l'aléatoire et vous vous en servirez comme fondation dans vos compositions et performances de live coding.

en: A Random Melody
fr: Une mélodie aléatoire

en: When Sonic Pi boots it actually loads into memory a sequence of 441,000 pre-generated random values. When you call a random function such as `rand` or `rrand`, this random stream is used to generate your result. Each call to a random function consumes a value from this stream. Therefore the 10th call to a random function will use the 10th value from the stream. Also, every time you press the Run button, the stream is reset for that run. This is why I could predict the result to `rand` and why the 'random' melody was the same every time. Everybody's version of Sonic Pi uses the exact same random stream which is very important when we start sharing our pieces with each other.
fr: Quand Sonic Pi démarre, il charge en fait en mémoire une séquence de 441 000 valeurs aléatoires pré-générées. Quand vous appelez une fonction aléatoire comme `rand` ou `rrand`, ce flux aléatoire est utilisé pour générer votre résultat. Chaque appel à une fonction aléatoire consomme une valeur de ce flux. Ainsi le dixième appel à une fonction aléatoire utilisera la dixième valeur du flux. Aussi, chaque fois que vous cliquez sur le bouton 'Run', le flux est réinitialisé pour cette exécution. C'est pour cela que j'ai pu prédire le résultat de `rand` et pourquoi la mélodie 'aléatoire' était la même à chaque fois. La version de Sonic Pi de chacun utilise exactement le même flux aléatoire ce qui est très important quand on commence à partager nos morceaux.

en: Let's use this knowledge to generate a repeatable random melody:
fr: Utilisons cette connaissance pour générer une mélodie aléatoire répétable :

en: Type this into a spare buffer and hit Run. You'll hear a melody consisting of 'random' notes between 50 and 95. When it's finished, hit Run again to hear exactly the same melody again.
fr: Tapez ceci dans un tampon étant libre et cliquez sur 'Run'. Vous entendrez une mélodie de notes 'aléatoires' entre 50 et 95. Quand elle aura fini, cliquez sur 'Run' à nouveau pour entendre exactement la même mélodie à nouveau.

en: Handy Randomisation Functions
fr: Des fonctions d'aléation pratiques

en: Sonic Pi comes with a number of useful functions for working with the random stream. Here's a list of some of the most useful:
fr: Sonic Pi contient un certain nombre de fonctions utiles pour travailler avec le flux aléatoire. Voici une liste de certaines des plus utiles :

en: `rand` - Simply returns the next value in the random stream
fr: `rand` : retourne simplement la prochaine valeur dans le flux aléatoire

en: `rrand` - Returns a random value within a range
fr: `rrand` : retourne une valeur aléatoire dans un intervalle

en: `rrand_i` - Returns a random whole number within a range
fr: `rrand_i` : retourne une valeur entière aléatoire dans un intervalle

en: `one_in` - Returns true or false with the given probability
fr: `one_in` : retourne vrai ou faux pour une probabilité donnée

en: `dice` - Imitates rolling a dice and returns a value between 1 and 6
fr: `dice` : imite un jet de dé et retourne une valeur entre 1 et 6

en: `choose` - Chooses a random value from a list
fr: `choose` : choisit une valeur aléatoire dans une liste

en: Check out their documentation in the Help system for detailed information and examples.
fr: Regardez leur documentation dans le système d'aide pour des informations détaillées et des exemples.

en: Resetting the Stream
fr: Réinitialiser le flux

en: Whilst the ability to repeat a sequence of chosen notes is essential to allow you to replay a riff on the dance floor, it might not be exactly the riff you want. Wouldn't it be great if we could try a number of different riffs and choose the one we liked best? This is where the real magic starts.
fr: Même si la capacité de répéter une séquence de notes choisies est essentielle pour vous permettre de rejouer une mélodie sur la piste de danse, ça pourrait ne pas être exactement la mélodie que vous souhaitez. Ne serait-ce pas génial si on pouvait essayez différentes mélodies et choisir celle qu'on préfère ? C'est ici que la vraie magie commence.

en: We can manually set the stream with the fn `use_random_seed`. In Computer Science, a random seed is the starting point from which a new stream of random values can sprout out and blossom. Let's try it:
fr: On peut régler le flux manuellement avec la fonction `use_random_seed`. En informatique, une graine aléatoire est le point de départ à partir duquel un nouveau flux de valeurs aléatoires peut fleurir. Essayons-le :

en: Great, we get the first three notes of our random melody above: `84`, `83` and `71`. However, we can now change the seed to something else. How about this:
fr: Super, on récupère les trois premières notes de notre mélodie aléatoire ci-dessus : `84`, `83` et `71`. Cependant on peut maintenant changer la graine. Par exemple :

en: Interesting, we get `83`, `71` and `61` . You might notice that the first two numbers here are the same as the last two numbers before - this isn't a coincidence.
fr: Intéressant, on obtient `83`, `71` et `61`. Vous avez peut-être remarqué que les deux premiers nombres ici sont les mêmes que les deux derniers nombres d'avant : ce n'est pas une coïncidence.

en: Remember that the random stream is just a giant list of 'pre-rolled' values. Using a random seed simply jumps us to a point in that list. Another way of thinking about it is to imagine a huge deck of pre-shuffled cards. Using a random seed is cutting the deck at a particular point. The fabulous part of this is that it's precisely this ability to jump around the random stream which gives us huge power when making music.
fr: Rappelez-vous que le flux aléatoire est juste une liste géante de valeurs pré-choisies. Choisir une graine aléatoire nous déplace juste en un point de la liste. Une autre manière de voir ça est d'imaginer un énorme jeu de cartes pré-mélangées. Utiliser une graine aléatoire, c'est couper le jeu en un point particulier. Ce qui est fabuleux avec ça c'est qu'on peut se déplacer dans le flux aléatoire, ce qui nous donne un énorme pouvoir quand on fait de la musique.

en: Let's revisit our random melody of 8 notes with this new stream resetting power, but let's also throw in a live loop so we can experiment live whilst it's playing:
fr: Revisitons notre mélodie aléatoire de huit notes avec cette nouvelle capacité de réinitialiser le flux, et mettons là dans une boucle interactive pour pouvoir expérimenter pendant qu'elle joue :

en: Now, whilst it's still playing, change the seed value from `0` to something else. Try `100`, what about `999`. Try your own values, experiment and play around - see which seed generates the riff you like best.
fr: Maintenant, pendant qu'elle est en train de jouer, changez la valeur de la graine de `0` en quelque chose d'autre. Essayez `100`, ou pourquoi pas `999`. Essayez vos propres valeurs, expérimentez et amusez-vous : voyez quelle graine génère la mélodie que vous préférez.

en: This month's tutorial has been quite a technical dive into the workings of Sonic Pi's randomisation functionality. Hopefully it has given you some insight into how it works and how you can start using randomisation in a reliable way to create repeatable patterns within your music. It's important to stress that you can use repeatable randomisation *anywhere* you want. For example, you can randomise the amplitude of notes, the timing of the rhythm, the amount of reverb, the current synth, the mix of an FX, etc. etc. In the future we'll take a close look at some of these applications, but for now let me leave you with a short example.
fr: Le tutoriel de ce mois a été un plongeon bien technique dans les entrailles de la fonctionnalité aléatoire de Sonic Pi. J'espère que cela vous a montré un peu comment elle marche et comment vous pouvez commencer à utiliser de l'aléatoire de manière fiable pour créer des motifs reproductibles dans votre musique. Il est important de souligner qu'on peut utiliser de l'aléatoire reproductible *où* on veut. Par exemple, on peut rendre aléatoire l'amplitude des notes, le mix d'un effet, etc. Dans l'avenir nous regarderons de plus près certaines de ces applications, mais pour le moment je vais vous laisser avec un exemple court.

en: Type the following into a spare buffer, hit Run, and then start changing the seeds around, hit Run again (whilst it's still playing) and explore the different sounds, rhythms and melodies you can make. When you find a nice one, remember the seed number so you can get back to it. Finally, when you've found a few seeds you like, put on a live coded performance for your friends by simply switching between your favourite seeds to create a full piece.
fr: Tapez le code suivant dans un buffer disponible, cliquez sur 'Run' et commencez à modifier les graines, cliquez sur 'Run' de nouveau (pendant que le code tourne) et explorez les différents sons, rythmes et mélodies que vous pouvez créer. Quand vous en trouvez une qui sonne bien, notez la graine pour pouvoir y revenir plus tard. Enfin, quand vous aurez trouvé quelques graines qui vous plaisent, donnez un concert de live coding à vos amis en changeant simplement entre vos graines préférées pour créer un morceau entier.

en: A.10 Control
fr: A.10 Contrôle

en: Controlling Your Sound
fr: Contrôler votre son

en: So far during this series we've focussed on triggering sounds. We've discovered that we can trigger the many synths built into Sonic Pi with `play` or `synth` and how to trigger pre-recorded samples with `sample`. We've also looked at how we can wrap these triggered sounds within studio FX such as reverb and distortion using the `with_fx` command. Combine this with Sonic Pi's incredibly accurate timing system and you can produce a vast array of sounds, beats and riffs. However, once you've carefully selected a particular sound's options and triggered it, there's no ability to mess with it whilst it's playing right? Wrong! Today you're going to learn something very powerful - how to control running synths.
fr: Jusqu'ici dans cette série nous nous sommes concentrés sur le déclenchement de sons. Nous avons découvert qu'on pouvait déclencher les nombreux synthés présents dans Sonic Pi avec `play` ou `synth` et comment déclencher des samples pré-enregistrés avec `sample`. Nous avons aussi vu comment on pouvait entourer ces sons dans des effets studio tels que la reverb et la distorsion en utilisant la commande `with_fx`. En combinant cela avec le système de chronométrage incroyablement précis de Sonic Pi on peut produire un vaste ensemble de sons, rythmes et mélodies. Cependant, une fois qu'on a soigneusement sélectionné les options d'un son en particulier et qu'on l'a déclenché, on ne peut plus le modifier pendant qu'il est joué, c'est ça ? Non ! Aujourd'hui vous allez apprendre quelque chose de très puissant : comment contrôler des synthés qui sont en train d'être joués.

en: A Basic Sound
fr: Un son de base

en: Let's create a nice simple sound. Fire up Sonic Pi and in a fresh buffer type the following:
fr: Créons un simple son agréable. Lancez Sonic Pi et tapez le code suivant dans un buffer disponible :

en: Now press the Run button at the top left to hear a lovely rumbling synth sound. Go ahead, press it again a few times to get a feel for it. OK, done? Let's start controlling it!
fr: Maintenant cliquez sur le bouton 'Run' en haut à gauche pour entendre un beau son de synthé grondant. Allez-y, cliquez à nouveau dessus quelques fois pour vous habituer. OK, fini ? Commençons à le contrôler !

en: Synth Nodes
fr: Nœuds de synthé

en: A little known feature in Sonic Pi is that the fns `play`, `synth` and `sample`, return something called a `SynthNode` which represents a running sound. You can capture one of these `SynthNode`s using a standard variable and then **control** it at a later point in time. For example, let's change the value of the `cutoff:` opt after 1 beat:
fr: Une fonctionnalité peu connue de Sonic Pi est que les fonctions `play`, `synth` et `sample` retournent ce qu'on appelle un `SynthNode` qui représente un son en train d'être joué. Vous pouvez capturer un de ces `SynthNode`s en utilisant une variable standard et le *contrôler* ensuite dans le futur. Par exemple, changeons la valeur de l'option `cutoff:` après un battement :

en: Let's look at each line in turn:
fr: Regardons chaque ligne une par une :

en: Firstly we trigger the `:prophet` synth using the `synth` fn as normal. However we also capture the result in a variable called `sn`. We could have called this variable something completely different such as `synth_node` or `jane` - the name doesn't matter. However, it's important to choose a name that's meaningful to you for your performances and for people reading your code. I chose `sn` as it's a nice short mnemonic for synth node.
fr: On commence par déclencher le synthé `:prophet` en utilisant la fonction `synth` habituelle. Cependant on capture aussi le résultat dans une variable nommée `sn`. On aurait pu appeler cette variable complètement différemment comme par exemple `synth_node` ou `jane` : le nom n'a pas d'importance. Enfin il est important de choisir un nom qui a du sens pour vous pour vos performances et pour les gens qui lisent votre code. J'ai choisi `sn` parce que c'est un bon petit moyen mnémotechnique pour 'synth node'.

en: On line 2 we have a standard `sleep` command. This does nothing special - it just asks the computer to wait for 1 beat before moving onto the next line.
fr: A la ligne 2 on a une commande `sleep` standard. Ca ne fait rien de spécial : ça demande juste à l'ordinateur d'attendre un battement, un temps, avant de passer à la ligne suivante.

en: Line 3 is where the control fun starts. Here, we use the `control` fn to tell our running `SynthNode` to change the cutoff value to `130`. If you hit the **Run** button, you'll hear the `:prophet` synth start playing as before, but after 1 beat it will shift to sound a lot brighter.
fr: C'est à la ligne 3 qu'on commence à s'amuser. Ici on utilise la fonction `control` pour dire à notre `SynthNode` courant de changer la valeur de coupure en `130`. Si vous cliquez sur le bouton 'Run', vous entendrez le synthé `:prophet` commencer à jouer comme avant, mais après un battement il changera et sonnera beaucoup plus clair.

en: Modulatable Options
fr: Options modulables

en: Most of Sonic Pi's synths and FX opts may be changed after being triggered. However, this isn't the case for all of them. For example, the envelope opts `attack:`, `decay:`, `sustain:` and `release:` can only be set when triggering the synth. Figuring out which opts can and can't be changed is simple - just head to the documentation for a given synth or FX and then scroll down to the individual option documentation and look for the phrases "May be changed whilst playing" or "Can not be changed once set". For example, the documentation for the `:beep` synth's `attack:` opt makes it clear that it's not possible to change it:
fr: La plupart des options des synthés et des effets inclus dans Sonic Pi peuvent être modifiés après avoir été déclenchés. Cependant, ce n'est pas le cas pour tous. Par exemple, les options d'enveloppe `attack:`, `decay:`, `sustain:` et `release:` ne peuvent être définies que quand on déclenche le synthé. Pour savoir quelles options peuvent être modifiées ou non, c'est simple : allez voir la documentation d'un synthé ou effet et regardez la documentation des options individuelles et cherchez les phrases "May be changed whilst playing" (Peut être modifiée en jouant) ou "Can not be changed once set" (ne peut pas être modifiée une fois définie). Par exemple, la documentation de l'option `attack:` du synthé `:beep` indique clairement qu'on ne peut pas la modifier ultérieurement :

en: Default: 0
fr: Valeur par défaut : 0

en: Must be zero or greater
fr: Doit être supérieur ou égal à 0

en: Can not be changed once set
fr: Ne peut pas être modifiée après sa définition

en: Scaled with current BPM value
fr: Mise à l'échelle avec la valeur courante de BPM

en: Multiple Changes
fr: Modifications multiples

en: Whilst a synth is running you're not limited to changing it only once - you're free to change it as many times as you like. For example, we can turn our `:prophet` into a mini arpeggiator with the following:
fr: Pendant qu'un synthé est joué vous n'êtes pas limité à ne le changer qu'une fois : vous êtes libre de le modifier autant que vous le souhaitez. Par exemple, on peut transformer notre `:prophet` en petit arpégiateur avec le code suivant :

en: In this snippet of code we just added a couple of extra things. First we defined a new variable called `notes` which contains the notes we'd like to cycle through (an arpeggiator is just a fancy name for something that cycles through a list of notes in order). Secondly we replaced our single call to `control` with an iteration calling it 16 times. In each call to `control` we `.tick` through our ring of `notes` which will automatically repeat once we get to the end (thanks to the fabulous power of Sonic Pi's rings). For a bit of variety try replacing `.tick` with `.choose` and see if you can hear the difference.
fr: Dans cet extrait de code, nous avons juste ajouté des petites choses en plus. On commence par définir une nouvelle variable appelée `notes` qui contient les notes qu'on aimerait parcourir en boucle (un arpégiateur est juste un mot savant pour quelque chose qui parcourt en boucle une liste de notes dans un ordre donné). Ensuite on déplace notre appel à `control` dans une itération en l'appelant 16 fois. A chaque appel à `control`, on parcourt notre anneau de `notes` qui va se répéter automatiquement quand on arrivera à sa fin (grâce à la puissance fabuleuse des anneaux de Sonic Pi). Pour varier un peu, essayez de remplacer `.tick` par `.choose` et tentez d'entendre la différence.

en: Note that we can change multiple opts simultaneously. Try changing the control line to the following and listen for the difference:
fr: Notez qu'on peut modifier plusieurs options en même temps. Essayez de changer la ligne de contrôle en la suivante et écoutez la différence :

en: Sliding
fr: Transitions

en: When we control a `SynthNode`, it responds exactly on time and instantly changes the value of the opt to the new one as if you'd pressed a button or flicked a switch requesting the change. This can sound rhythmical and percussive - especially if the opt controls an aspect of the timbre such as `cutoff:`. However, sometimes you don't want the change to happen instantaneously. Instead, you might want to smoothly move from the current value to the new one as if you'd moved a slider or dial. Of course, Sonic Pi can also do this too using the `_slide:` opts.
fr: Quand on contrôle un `SynthNode`, il répond exactement à ce moment-là et change immédiatement la valeur de l'option comme si vous aviez pressé un bouton ou actionné un interrupteur pour demander la modification. Cela peut sonner rythmique et percussif, notamment si l'option contrôle un aspect du timbre comme `cutoff:`. Cependant, on n'a pas toujours envie que la modification arrive immédiatement. On a parfois envie de se déplacer en douceur de la valeur courante à la nouvelle, comme si on avait déplacé un curseur. Bien sûr, Sonic Pi sait aussi faire cela en utilisant les options `_slide:`.

en: Each opt that can be modified also has a special corresponding `_slide:` opt that allows you to specify a slide time. For example, `amp:` has `amp_slide:` and `cutoff:` has `cutoff_slide:`. These slide opts work slightly differently than all the other opts in that they tell the synth note how to behave **next time they are controlled**. Let's take a look:
fr: Chaque option qui peut être modifiée a aussi une option spéciale correspondante `_slide:` qui vous permet de définir un temps de transition. Par exemple, `amp:` a `amp_slide:` et `cutoff:` a `cutoff_slide:`. Ces options de transition marchent un peu différemment de toutes les autres options parce qu'elles disent à la note de synthé comment se comporter *la prochaine fois qu'elle seront contrôlées*. Voyons ça :

en: Notice how this example is exactly the same as before except with the addition of `cutoff_slide:`. This is saying that next time this synth has its `cutoff:` opt controlled, it will take 2 beats to slide from the current value to the new one. Therefore, when we use `control` you can hear the cutoff slide from 70 to 130. It creates an interesting dynamic feel to the sound. Now, try changing the `cutoff_slide:` time to a shorter value such as 0.5 or a longer value such as 4 to see how it changes the sound. Remember, you can slide any of the modifiable opts in exactly this way and each `_slide:` value can be totally different so you can have the cutoff sliding slowly, the amp sliding fast and the pan sliding somewhere in between if that's what you're looking to create...
fr: Remarquez que cet exemple est exactement le même qu'avant sauf qu'on a ajouté `cutoff_slide:`. Ceci indique que la prochaine fois que l'option `cutoff:` de ce synthé sera contrôlée, il mettra deux battements pour passer de sa valeur courante à la nouvelle valeur. Par conséquent, quand on utilise `control` vous pouvez entendre la coupure changer graduellement de 70 à 130. Cela crée une sensation dynamique intéressante pour le son. Maintenant essayez de changer la durée de `cutoff_slide:` en une valeur plus courte comme 0.5 ou une valeur plus longue comme 4 pour voir comment ça change le son. Souvenez-vous que vous pouvez effectuer une transition pour chacune des options modifiables de cette même manière, et chaque valeur de `_slide:` peut être complètement différente donc vous pouvez avoir une transition lente de la coupure, une transition rapide de l'amplitude, et une transition de la stéréo un peu entre les deux si c'est ce que vous avez envie de créer.

en: Let's look at a short example which demonstrates the power of controlling synths after they've been triggered. Notice that you can also slide FX just like synths although with a slightly different syntax. Check out section 7.2 of the built-in tutorial for more information on controlling FX.
fr: Regardons un court exemple qui montre la puissance du contrôle des synthés après leur déclenchement. Remarquez que vous pouvez aussi effectuer des transitions sur les effets, comme vous l'avez fait avec les synthés mais avec une syntaxe légèrement différente. Regardez la section 7.2 du tutoriel inclus dans Sonic Pi pour plus d'informations sur le contrôle des effets.

en: Copy the code into a spare buffer and take a listen. Don't stop there though - play around with the code. Change the slide times, change the notes, the synth, the FX and the sleep times and see if you can turn it into something completely different!
fr: Copiez le code dans un tampon de libre et écoutez. Ne vous arrêtez pas là : jouez à modifier le code. Changez les durées de transition, changez les notes, le synthé, l'effet et les durées d'attente et voyez si vous pouvez le transformer en quelque chose de complètement différent !

en: A.11 Tick Tock
fr: A.11 Tic Tac

en: Tracking the Beat
fr: Suivre le rythme

en: Last month in this series we took a deep technical dive into the randomisation system underpinning Sonic Pi. We explored how we can use it to deterministically add new levels of dynamic control over our code. This month we're going to continue our technical dive and turn our attention to Sonic Pi's unique tick system. By the end of this article you'll be ticking your way through rhythms and riffs on your way to being a live coding DJ.
fr: Le mois dernier dans cette série nous avons regardé en détail comment fonctionne le système de gestion de l'aléatoire de Sonic Pi. On a exploré comment on peut l'utiliser de manière déterministe pour avoir de nouveaux niveaux de contrôle dynamique sur notre code. Ce mois-ci nous allons continuer notre exploration technique et regarder le système unique de 'tick' de Sonic Pi. A la fin de cet article, vous saurez parcourir les rythmes et les mélodies à votre manière et devenir à votre façon DJ en live coding.

en: Beat Counting
fr: Comptage du temps

en: When making music we often want to do a different thing depending on which beat it is. Sonic Pi has a special beat counting system called `tick` to give you precise control over when a beat actually occurs and even supports multiple beats with their own tempos.
fr: Quand on fait de la musique on a souvent envie de faire quelque chose de différent en fonction du temps sur lequel on est. Sonic Pi a un système spécial pour compter les temps appelé `tick` pour vous donner un contrôle précis sur quand est-ce qu'un battement arrive réellement et il supporte même des battements multiples avec leur propre tempo.

en: Let's have a play - to advance the beat we just need to call `tick`. Open up a fresh buffer, type in the following and hit Run:
fr: Amusons-nous : pour avancer le temps on a juste besoin d'appeler `tick`. Ouvrez un tampon libre, tapez le code suivant et cliquez sur le bouton 'Run' :

en: This will return the current beat: `0`. Notice that even if you press the Run button a few times it will always return `0`. This is because each run starts a fresh beat counting from 0. However, whilst the run is still active, we can advance the beat as many times as we want:
fr: Cela retournera le battement courant : `0`. Remarquez que même si vous cliquez plusieurs fois sur le bouton 'Run', il retournera toujours `0`. Cela parce que chaque exécution commence avec un compteur qui part de 0. Cependant, pendant que le programme tourne, on peut avancer le compteur autant qu'on veut :

en: Whenever you see the symbol `#=>` at the end of a line of code it means that that line will log the text on the right-hand-side. For example, `puts foo #=> 0` means the code `puts foo` prints `0` to the log at that point in the program.
fr: Quand vous voyez le symbole `#=>` à la fin d'une ligne de code cela veut dire que cette ligne va noter ce texte dans la partie de droite de Sonic Pi. Par exemple, `puts foo #=> 0` veut dire que le code `puts foo` affiche `0` dans le log à cet endroit du programme.

en: Checking the Beat
fr: Vérification du rythme

en: We've seen that `tick` does two things. It increments (adds one) and returns the current beat. Sometimes we just want to look at the current beat without having to increment it which we can do via `look`:
fr: On a vu que `tick` fait deux choses. Il incrémente (ajoute un) et retourne le compteur courant. Parfois on veut juste connaître la valeur du compteur courant sans l'incrémenter et on peut faire cela avec `look` :

en: In this code we tick the beat up twice and then call `look` twice. We'll see the following values in the log: `0`, `1`, `1`, `1`. The first two `tick`s returned `0`, then `1` as expected, then the two `look`s just returned the last beat value twice which was `1`.
fr: Dans ce code on incrémente le compteur deux fois puis on appelle `look` deux fois. On verra les valeurs suivantes dans le log : `0`, `1`, `1`, `1`. Les deux premiers `tick`s ont retourné `0` et `1`, comme attendu, puis les deux `look`s ont juste retourné la dernière valeur du compteur deux fois, donc `1`.

en: So now we can advance the beat with `tick` and check the beat with `look`. What next? We need something to tick over. Sonic Pi uses rings for representing riffs, melodies and rhythms and the tick system has been specifically designed to work very closely with them. In fact, rings have their own dot version of `tick` which does two things. Firstly, it acts like a regular tick and increments the beat. Secondly it looks up the ring value using the beat as the index. Let's take a look:
fr: On peut donc avancer le compteur avec `tick` et en connaître la valeur avec `look`. Qu'est-ce qui vient ensuite ? On a besoin de quelque chose à parcourir. Sonic Pi utilise les anneaux pour représenter les mélodies et les rythmes ; le système de tick a été conçu spécialement pour fonctionner avec eux ! En fait, les anneaux ont leur propre version de `tick` qui fait deux choses. D'un côté, elle agit comme un tick normal et incrémente le compteur. De l'autre, elle donne une valeur de l'anneau en utilisant le compteur comme index. Voyons cela :

en: `.tick` is a special dot version of `tick` which will return the first value of the ring `:a`. We can grab each of the values in the ring by calling `.tick` multiple times:
fr: `.tick` est une version spéciale avec un point de `tick` qui nous retourne la première valeur de l'anneau : `:a`. On peut récupérer chacune des notes de l'anneau en appelant `:tick` plusieurs fois :

en: Take a look at the log and you'll see `:a`, `:b`, `:c` and then `:a` again. Notice that `look` returns `3`. Calls to `.tick` act just like they are regular calls to `tick` - they increment the local beat.
fr: Regardez le log et vous verrez `:a`, `:b`, `:c` et puis de nouveau `:a`. Remarquez que `look` retourne `3`. Les appels à `.tick` se comportent comme les appels à `tick` : ils incrémentent le compteur local.

en: A Live Loop Arpeggiator
fr: Un arpégiateur dans une boucle interactive

en: The real power comes when you mix `tick` with rings and `live_loop`s. When combined we have all the tools we need to both build and understand a simple arpegiator. We need just four things:
fr: La véritable puissance vient quand on mélange `tick` avec des anneaux et des `live_loop`s. En les combinant on a tous les outils dont on a besoin pour construire et comprendre un arpégiateur simple. On a juste besoin de quatre choses :

en: A ring containing the notes we want to loop over.
fr: Une boucle contenant les notes que l'on veut boucler.

en: A means of incrementing and obtaining the beat.
fr: Une manière d'incrémenter et de lire le rythme.

en: The ability to play a note based on the current beat.
fr: La possibilité de jouer une note basée sur le rythme actuel.

en: A loop structure to keep the arpegiator repeating.
fr: Une structure en boucle pour que l'arpégiateur se répète.

en: These concepts can all be found in the following code:
fr: Ces concepts se retrouvent tous dans le code suivant :

en: Let's look at each of these lines. First we define our ring of notes which we'll continually play. We then create a `live_loop` called `:arp` which loops round for us. Each time round the `live_loop` we set our synth to `:dpulse` and then play the next note in our ring using `.tick`. Remember that this will increment our beat counter and use the latest beat value as an index into our notes ring. Finally, we wait for an eighth of a beat before looping round again.
fr: Regardons chacune de ces lignes. On commence par définir notre anneau de notes que nous allons jouer en continu. On crée ensuite une `live_loop` nommée `:arp` qui va boucler pour nous. A chaque itération de la `live_loop` on choisit un synthé `:dpulse` et on joue ensuite la note suivante de notre anneau en utilisant `.tick`. Souvenez-vous que cela va incrémenter notre compteur de temps et en utiliser la valeur comme index dans notre anneau de notes. Enfin on attend un huitième de temps avant de recommencer la boucle.

en: Multiple Simultaneous Beats
fr: Rythmes multiples simultanés

en: A really important thing to know is that `tick`s are local to the `live_loop`. This means that each `live_loop` has its own independent beat counter. This is much more powerful than having a global metronome and beat. Let's take a look at this in action:
fr: Une chose très importante à savoir est que les `tick`s sont liés à la `live_loop`. Cela veut dire que chaque `live_loop` a son propre compteur indépendant. C'est beaucoup plus puissant que d'avoir un métronome et battement global. Regardons ce que cela donne :

en: Clashing Beats
fr: Collisions de rythmes

en: A big cause of confusion with Sonic Pi's tick system is when people want to tick over multiple rings in the same `live_loop`:
fr: Une grande source de confusion dans le système de tick de Sonic Pi est quand on veut parcourir plusieurs anneaux dans le même `live_loop` :

en: Even though each `live_loop` has its own independent beat counter, we're calling `.tick` twice within the same `live_loop`. This means that the beat will be incremented twice every time round. This can produce some interesting polyrhythms but is often not what you want. There are two solutions to this problem. One option is to manually call `tick` at the start of the `live_loop` and then use `.look` to look up the current beat in each `live_loop`. The second solution is to pass a unique name to each call to `.tick` such as `.tick(:foo)`. Sonic Pi will then create and track a separate beat counter for each named tick you use. That way you can work with as many beats as you need! See the section on named ticks in 9.4 of the built-in tutorial for more information.
fr: Même si chaque `live_loop` a son compteur indépendant, ici on appelle `.tick` deux fois dans la même `live_loop`. Cela veut dire que le compteur sera incrémenté deux fois à chaque boucle. Cela peut produire de la polyrythmie intéressante mais ce n'est pas souvent ce que l'on souhaite. Il y a deux solutions à ce problème. Une option est d'appeler `tick` manuellement au début de la `live_loop` puis d'utiliser `look` pour chercher la valeur courante du compteur dans chaque `live_loop`. La seconde solution est de passer un nom unique à chaque appel à `.tick`, comme par exemple `.tick(:foo)`. Sonic Pi créera alors un compteur séparé pour chaque tick nommé que vous utiliserez. Ainsi on peut travailler avec autant de compteurs que nécessaire ! Lisez le section 9.4 sur les ticks nommés dans le tutoriel inclus dans Sonic Pi pour plus d'informations.

en: Let's bring all this knowledge of `tick`s, `ring`s and `live_loop`s together for a final fun example. As usual, don't treat this as a finished piece. Start changing things and play around with it and see what you can turn it into. See you next time...
fr: Combinons nos connaissances sur les `tick`s, `ring`s (anneaux) et `live_loop`s pour un dernier exemple amusant. Comme d'habitude, ne prenez pas ça pour un morceau terminé. Commencez à changer des choses et amusez-vous avec et voyez en quoi vous pouvez le transformer. A la prochaine...

en: A.12 Sample Slicing
fr: A.12 Tranchage d'échantillon

en: Sample Slicing
fr: Tranchage d'échantillon

en: Way back in episode 3 of this Sonic Pi series we looked at how to loop, stretch and filter one of the most famous drum breaks of all time - the Amen Break. In this tutorial we're going to take this one step further and learn how to slice it up, shuffle the slices and glue it back together in a completely new order. If that sounds a bit wild to you, don't worry, it will all become clear and you'll soon master a powerful new tool for your live coded sets.
fr: Dans l’épisode 3 de cette série sur Sonic Pi, nous avons regardé comment boucler, étirer et filtrer un des breaks de batterie les plus connus de tous les temps - l'Amen Break. Dans ce tutoriel, nous allons faire un pas de plus et apprendre comment le découper, mélanger les bouts et les recoller ensemble dans un agencement complètement nouveau. Si cela vous paraît un peu fou, ne vous inquiétez pas, tout va s'éclaircir et vous maîtriserez bientôt un nouvel outil puissant pour vos sessions de Live Coding.

en: Sound as Data
fr: Le son en tant que données

en: Before we get started let's just take a brief moment to understand how to work with samples. By now, you've all hopefully played with Sonic Pi's powerful sampler. If not, there's no time like the present! Boot up your Raspberry Pi, launch Sonic Pi from the Programming menu, type the following into a fresh buffer and then hit the Run button to hear a pre-recorded drum beat:
fr: Avant de démarrer, prenons juste un petit moment pour comprendre comment travailler avec les échantillons. Maintenant, vous devriez tous avoir manipulé le puissant échantillonneur de Sonic Pi. Si ce n'est pas le cas, c'est le moment ! Démarrez votre Raspberry Pi, lancez Sonic Pi depuis le menu Programmation, tapez ce qui suit dans un tampon vide et appuyez sur le bouton Run pour entendre un rythme de batterie préenregistré :

en: A recording of a sound is simply represented as data - lots of numbers between -1 and 1 which represent the peaks and troughs of the sound wave. If we play those numbers back in order, we get the original sound. However, what's to stop us from playing them back in a different order and creating a new sound?
fr: L'enregistrement d'un son est simplement représenté comme de la donnée - un tas de nombres entre -1 et 1 qui représentent les pics et creux de l'onde sonore. Si nous rejouons ces nombres dans l'ordre, nous obtenons le son original. Cependant, qu'est-ce qui nous empêche de les jouer dans un ordre différent pour créer un nouveau son ?

en: How are samples actually recorded? It's actually pretty simple once you understand the basic physics of sound. When you make a sound - for example by hitting a drum, the noise travels through the air in a similar fashion to how the surface of a lake ripples when you throw a pebble into it. When those ripples reach your ears, your eardrum moves sympathetically and converts those movements into the sound you hear. If we wish to record and play back the sound, we therefore need a way of capturing, storing and reproducing those ripples. One way is to use a microphone which acts like an eardrum and moves back and forth as the sound ripples hit it. The microphone then converts its position into a tiny electric signal which is then measured many times a second. These measurements are then represented as a series of numbers between -1 and 1.
fr: Comment sont réellement enregistrés les échantillons ? C'est en fait assez simple une fois que vous comprenez les bases physiques du son. Quand vous produisez un son - par exemple en frappant sur une batterie, le bruit voyage dans l'air d'une façon proche de celle des petites ondes dans un lac quand vous y jetez un caillou. Quand ces ondes atteignent vos oreilles, votre tympan bouge de façon synchrone et convertit ces mouvements en son que vous entendez. Si nous souhaitons enregistrer et rejouer le son, nous avons donc besoin d'un moyen de capturer, stocker et reproduire ces ondes. Une des méthodes est d'utiliser un microphone qui se comporte comme un tympan et effectue un va-et-vient lorsque les ondes sonores le touchent. Le microphone convertit ensuite sa position en un petit signal électrique qui est ensuite mesuré de nombreuses fois par seconde. Ces mesures sont ensuite représentées par une série de nombres compris entre -1 et 1.

en: If we were to plot a visualisation of the sound it would be a simple graph of data with time on the x axis and microphone/speaker position as a value between -1 and 1 on the y axis. You can see an example of such a graph at the top of the diagram.
fr: Si nous devions tracer point par point une représentation visuelle du son, ce serait un simple graphique de données avec le temps sur l'axe x et la position du microphone/de l'enceinte comme une valeur entre -1 et 1 sur l'axe y. Vous pouvez voir un exemple d'un tel graphique en haut du diagramme.

en: Playing Part of a Sample
fr: Jouer une partie d'un échantillon

en: So, how do we code Sonic Pi to play a sample back in a different order? To answer this question we need to take a look at the `start:` and `finish:` opts for `sample`. These let us control the start and finish positions of our playback of the numbers which represent the sound. The values for both of these opts are represented as a number between `0` and `1` where `0` represents the start of the sample and `1` is the end. So, to play the first half of the Amen Break, we just need to specify a `finish:` of `0.5`:
fr: Donc, comment coder dans Sonic Pi la lecture d'un échantillon dans un ordre différent ? Pour répondre à cette question, nous devons jeter un oeil sur les options `start:` et `finish:` de `sample`. Celles-ci nous permettent de contrôler les position de début et de fin de notre lecture des nombres qui représentent le son. Les valeurs de ces deux options sont représentées par un nombre entre `0` et `1` où `0` représente le début de l'échantillon et `1` en est la fin. Donc, pour jouer la première partie de l'Amen Break, nous devons simplement spécifier un `finish:` à `0.5` :

en: We can add in a `start:` value to play an even smaller section of the sample:
fr: Nous pouvons ajouter une valeur `start:` pour jouer une partie encore plus petite de l'échantillon :

en: For fun, you can even have the `finish:` opt's value be *before* `start:` and it will play the section backwards:
fr: Pour le plaisir, vous pouvez même avoir la valeur `finish:` inférieure à la valeur `start:` et il jouera la section à l'envers :

en: Re-ordering Sample Playback
fr: Réordonner la lecture des échantillons

en: Now that we know that a sample is simply a list of numbers that can be played back in any order and also how to play a specific part of a sample we can now start having fun playing a sample back in the 'wrong' order.
fr: Maintenant que nous savons d'une part qu'un échantillon est simplement une liste de nombres qui peuvent être joués dans n'importe quel ordre et que d'autre part, nous savons comment jouer une partie spécifique d'un échantillon, nous pouvons désormais nous amuser à jouer un échantillon dans le 'mauvais' ordre.

en: Let's take our Amen Break and chop it up into 8 equally-sized slices and then shuffle the pieces around. Take a look at the diagram: at the top A) represents the graph of our original sample data. Chopping it into 8 slices gives us B) - notice that we've given each slice a different colour to help distinguish them. You can see each slice's start and finish values at the top. Finally C) is one possible re-ordering of the slices. We can then play this back to create a new beat. Take a look at the code to do this:
fr: Prenons notre Amen Break et découpons-le en 8 tranches égales et mélangeons ensuite les morceaux. Regardez le diagramme : en haut A) représente le graphe des données originales de l'échantillon. Le découper en 8 tranches nous donne B) - notez que nous avons donné à chaque tranche une couleur différente pour aider à les distinguer. Vous pouvez voir les valeurs de début (`start`) et de fin (`finish`) en haut. Enfin C) est une réorganisation des tranches. Nous pouvons ensuite jouer ceci pour créer un nouveau rythme. Jetez un coup d’œil sur le code utilisé pour faire cela :

en: we choose a random slice to play which should be a random number between 0 and 7 (remember that we start counting at 0). Sonic Pi has a handy function for exactly this: `rand_i(8)`. We then store this random slice index in the variable `slice_idx`.
fr: Nous choisissons une tranche aléatoire à jouer, qui doit être un nombre aléatoire entre 0 et 7 (souvenez-vous que nous commençons à compter à partir de 0). Sonic Pi a une fonction pratique pour faire exactement cela : `rand_i(8)`. Nous stockons ensuite l'index de cette tranche aléatoire dans la variable `slice_idx`.

en: We define our `slice_size` which is 1/8 or 0.125. The `slice_size` is necessary for us to convert our `slice_idx` into a value between 0 and 1 so we can use it as our `start:` opt.
fr: Nous définissons la taille notre tranche, `slice_size` à 1/8 soit 0.125. `slice_size` nous est nécessaire pour convertir l'index `slice_idx` en une valeur comprise entre 0 et 1 pour l'utiliser dans l'option `start:`.

en: We calculate the start position `s` by multiplying the `slice_idx` by the `slice_size`.
fr: Nous calculons la position de départ `s` en multipliant l'index `slice_idx` par la taille de la tranche `slice_size`.

en: We calculate the finish position `f` by adding the `slice_size` to the start position `s`.
fr: Nous pouvons calculer la position finale de 'f' en ajoutant la 'slice_size' à la position de départ 's'.

en: We can now play the sample slice by plugging in the `s` and `f` values into the `start:` and `finish:` opts for `sample`.
fr: Nous pouvons maintenant jouer la tranche d'échantillon en associant les valeurs `s` et `f` aux options `start:` et `finish:` de `sample`.

en: Before we play the next slice we need to know how long to `sleep` which should be the duration of the sample slice. Luckily, Sonic Pi has us covered with `sample_duration` which accepts all the same opts as `sample` and simply returns the duration. Therefore, by passing `sample_duration` our `start:` and `finish:` opts, we can find out the duration of a single slice.
fr: Avant de jouer la prochaine tranche, nous devons savoir pendant combien de temps faire une pause avec `sleep`, ce qui doit correspondre à la durée de la tranche d'échantillon. Heureusement, Sonic Pi s'en occupe avec la fonction `sample_duration`, qui accepte les mêmes options que `sample` et retourne simplement la durée. Par conséquent, en fournissant à `sample_duration` nos options `start:` et `finish:`, nous pouvons trouver la durée d'une tranche.

en: We wrap all of this code in a `live_loop` so that we continue to pick new random slices to play.
fr: Nous enveloppons tout ce code dans une boucle `live_loop` pour que nous puissions continuer à choisir de nouvelles tranches à jouer.

en: Let's combine everything we've seen so far into a final example which demonstrates how we can take a similar approach to combine randomly sliced beats with some bass to create the start of an interesting track. Now it's your turn - take the code below as a starting point and see if you can take it in your own direction and create something new...
fr: Combinons tout ce que nous avons vu jusqu'à maintenant dans un dernier exemple, qui démontre comment nous pouvons utiliser une approche similaire pour combiner aléatoirement des morceaux de rythmes avec de la basse pour créer le début d'une piste intéressante. Maintenant c'est votre tour - prenez le code suivant comme point de départ et voyez si vous pouvez le modifier à votre façon pour créer quelque chose de nouveau...

en: A.13 Code a Probabilistic Sequencer
fr: A.13 Coder un séquenceur probabiliste

en: Code a Probabilistic Sequencer
fr: Coder un séquenceur probabiliste

en: In a previous episode of this Sonic Pi series we explored the power of randomisation to introduce variety, surprise and change into our live coded tracks and performances. For example, we randomly picked notes from a scale to create never-ending melodies. Today we're going to learn a new technique which uses randomisation for rhythm - probabilistic beats!
fr: Dans les épisodes précédents de cette série sur Sonic PI, nous avons exploré la puissance de l'aléatoire pour introduire de la variété, de la surprise et du changement dans nos pistes et nos représentations de Live Coding. Par exemple, nous avons choisi aléatoirement des notes d'une gamme pour créer des mélodies sans fin. Aujourd'hui, nous allons apprendre une nouvelle technique qui utilise l'aléatoire pour le rythme - les rythmes probabilistes !

en: Probability
fr: Probabilité

en: Before we can start making new beats and synth rhythms we need to take a quick dive into the basics of probability. This might sound daunting and complicated, but really it's just as simple as rolling a dice - honestly! When you take a regular 6 sided board game dice and roll it what's actually happening? Well, firstly you'll roll either a 1, 2, 3, 4, 5 or 6 with exactly the same chance of getting any of the numbers. In fact, given that it's a 6 sided dice, on average (if you roll lots and lots of times) you'll throw a 1 every 6 throws. This means you have a 1 in 6 chance of throwing a 1. We can emulate dice rolls in Sonic Pi with the fn `dice`. Let's roll one 8 times:
fr: Avant de pouvoir commencer à faire de nouveaux rythmes et des rythmes de synthé, nous devons faire un plongeon rapide dans les bases de la probabilité. Cela peut sembler intimidant et compliqué, mais vraiment c'est aussi simple que de lancer un dé - honnêtement ! Lorsque vous prenez un dé régulier à 6 faces d'un jeu de société et le lancez, que se passe-t'il réellement ? Eh bien, tout d'abord, vous allez tomber sur 1, 2, 3, 4, 5 ou 6 avec exactement la même chance d'obtenir l'un des numéros. En fait, étant donné que c'est un dé à 6 côtés, en moyenne (si vous lancez de nombreuses fois), vous allez tomber sur un 1 tous les 6 lancers. Cela signifie que vous avez une chance sur 6 de lancer un 1. Nous pouvons émuler le lancement de dés dans Sonic Pi avec le fn 'dice'. Jetons-en un 8 fois :

en: Notice how the log prints values between 1 and 6 just as if we'd rolled a real dice ourselves.
fr: Remarquez comme le journal affiche des valeurs entre 1 et 6 comme si nous avions lancé nous-même un dé.

en: Random Beats
fr: Rythmes aléatoires

en: Now imagine you had a drum and every time you were about to hit it you rolled a dice. If you rolled a 1, you hit the drum and if you rolled any other number you didn't. You now have a probabilistic drum machine working with a probability of 1/6! Let's hear what that sounds like:
fr: Maintenant, imaginez vous avez un tambour et chaque fois que vous êtes sur le point de le frapper, vous lancez un dé. Si vous tirez un 1, vous frappez le tambour sinon, autre valeur que 1, vous ne frappez pas. Vous avez maintenant une boîte à rythmes probabiliste qui fonctionne avec une probabilité de 1/6 ! Écoutons à quoi ça ressemble :

en: Let's quickly go over each line to make sure everything is very clear. First we create a new `live_loop` called `:random_beat` which will continually repeat the two lines between `do` and `end`. The first of these lines is a call to `sample` which will play a pre-recorded sound (the `:drum_snare_hard` sound in this case). However, this line has a special conditional `if` ending. This means that the line will only be executed if the statement on the right hand side of the `if` is `true`. The statement in this case is `dice == 1`. This calls our `dice` function which, as we have seen, returns a value between 1 and 6. We then use the equality operator `==` to check to see if this value is `1`. If it is `1`, then the statement resolves to `true` and our snare drum sounds, if it isn't `1` then the statement resolves to `false` and the snare is skipped. The second line simply waits for `0.125` seconds before rolling the dice again.
fr: Passons en revue rapidement chaque ligne pour nous assurer que tout est parfaitement clair. Tout d'abord, nous créons une nouvelle `live_loop` appelée `:random_beat` qui va continuellement répéter les deux lignes entre `do` et `end`. La première de ces lignes est un appel à `sample` qui jouera un son préenregistré (le son `:drum_snare_hard` dans ce cas). Cependant, cette ligne a une fin conditionnelle spéciale `if`. Cela signifie que la ligne ne sera exécutée que si la déclaration située à droite du `if` («si») est `true` («vraie»). Dans ce cas, la déclaration est `dice == 1`. C'est ce qu'on appelle notre fonction `dice` qui, comme nous l'avons vu, renvoie une valeur comprise entre 1 et 6. Nous utilisons ensuite l'opérateur d'égalité `==` pour vérifier si cette valeur est `1`. Si c'est `1`, alors le test d'égalité est vrai, `true`, et notre caisse claire sonne. Si ce n'est pas `1` alors le test d'égalité n'est pas vérifié, il est faux, `false`, et la caisse claire est ignorée. La deuxième ligne attend simplement `0.125` secondes avant de lancer à nouveau les dés.

en: Changing Probabilities
fr: Changer les probabilités

en: Those of you that have played role play games will be familiar with lots of strangely shaped dice with different ranges. For example there is the tetrahedron shaped dice which has 4 sides and even a 20 sided dice in the shape of a icosahedron. The number of sides on the dice changes the chance, or probability of rolling a 1. The fewer sides, the more likely you are to roll a 1 and the more sides the less likely. For example, with a 4 sided dice, there's a one in 4 chance of rolling a 1 and with a 20 sided dice there's a one in 20 chance. Luckily, Sonic Pi has the handy `one_in` fn for describing exactly this. Let's play:
fr: Ceux d'entre vous qui ont joué des jeux de rôle seront familiers avec beaucoup de dés de forme étrange avec différentes étendues de numéros. Par exemple, il y a le dé en tétraèdre qui a 4 côtés ou encore un dé de 20 côtés en forme d'icosaèdre. Le nombre de côtés sur les dés change la chance, ou la probabilité de tomber sur un 1. Moins il y a de côtés, plus vous avez de chances d'afficher un 1 et plus il y a de côtés, moins c'est probable. Par exemple, avec un dé à 4 côtés, il y a une chance sur 4 de lancer un 1 et avec un dé de 20 côtés il y a une chance sur 20. Heureusement, Sonic Pi a le très pratique «one_in» fn pour décrire exactement cela. Jouons :

en: Start the live loop above and you'll hear the familiar random rhythm. However, don't stop the code running. Instead, change the `6` to a different value such as `2` or `20` and hit the `Run` button again. Notice that lower numbers mean the snare drum sounds more frequently and higher numbers mean the snare triggers fewer times. You're making music with probabilities!
fr: Lancez la boucle ci-dessus et vous pourrez entendre un rythme aléatoire familier. Cependant, n'arrêtez pas l'exécution du code. Au lieu de cela, changez le `6` pour une valeur différente comme `2` ou `20` et appuyez de nouveau sur le bouton `Run`. Constatez que des nombres inférieurs signifient que le son de caisse claire sera plus fréquent et que des nombres supérieurs signifie que la caisse clair est jouée moins fréquemment. Vous faites de la musique avec des probabilités !

en: Combining Probabilities
fr: Combiner les probabilités

en: Things get really exciting when you combine multiple samples being triggered with different probabilities. For example:
fr: Les choses deviennent vraiment excitantes quand plusieurs échantillons sont joués avec des probabilités différentes. Par exemple :

en: Again, run the code above and then start changing the probabilities to modify the rhythm. Also, try changing the samples to create an entirely new feel. For example try changing `:drum_cymbal_closed` to `:bass_hit_c` for extra bass!
fr: De nouveau, exécutez le code ci-dessus et commencez à changer les probabilités pour modifier le rythme. De plus, essayez de changer les échantillons pour créer une sensation entièrement nouvelle. Par exemple, essayez de changer `:drum_cymbal_closed` par `:bass_hit_c` pour obtenir plus de basse !

en: Repeatable Rhythms
fr: Rythmes répétables

en: Next, we can use our old friend `use_random_seed` to reset the random stream after 8 iterations to create a regular beat. Type the following code to hear a much more regular and repeating rhythm. Once you hear the beat, try changing the seed value from `1000` to another number. Notice how different numbers generate different beats.
fr: Ensuite, nous pouvons utilisez notre vieil ami `use_random_seed` pour réinitialiser le générateur aléatoire après 8 itérations pour créer un rythme régulier. Tapez le code suivant pour entendre un rythme beaucoup plus régulier et répétitif. Une fois que vous entendez le rythme, essayez de remplacer la valeur `1000` par un autre nombre. Remarquez comme des nombres différents génèrent des rythmes différents.

en: One thing I tend to do with this kind of structure is to remember which seeds sound good and make a note of them. That way I can easily re-create my rhythms in future practice sessions or performances.
fr: Une chose que j'ai tendance à faire avec ce genre de structures, c'est de me rappeler quelles graines aléatoires sonnent bien et de les noter. De cette manière, je peux facilement recréer mes rythmes dans des sessions d'entrainement ou des représentations futures.

en: Finally, we can throw in some random bass to give it some nice melodic content. Notice that we can also use our newly discovered probabilistic sequencing method on synths just as well as samples. Don't leave it at that though - tweak the numbers and make your own track with the power of probabilities!
fr: Finalement, nous pouvons ajouter un peu de basse aléatoire pour lui donner un contenu mélodique sympa. Vous pourrez remarquer que nous pouvons aussi utiliser notre méthode de séquençage probabiliste récemment découverte sur les synthés comme sur les échantillons. Nous vous arrêtez pas là pour autant - ajuster les nombres et faites votre propre piste grâce au pouvoir des probabilités !

en: A.14 Amplitude Modulation
fr: A.14 Modulation d'amplitude

en: Amplitude Modulation
fr: Modulation d'amplitude

en: This month we're going to take a deep dive into one of Sonic Pi's most powerful and flexible audio FX - the `:slicer`. By the end of this article you will have learned how to manipulate the overall volume of parts of our live coded sound in powerful new ways. This will allow you to create new rhythmic and timbral structures and broaden your sonic possibilities.
fr: Ce mois-ci nous allons plonger en profondeur dans l'un des effets les plus puissants et les plus flexibles de Sonic Pi - le `:slicer`. D'ici la fin de cet article, vous aurez appris comment manipuler le volume global de certaines parties de notre son codé en live de façons nouvelles et puissantes.

en: Slice that Amp
fr: Trancher cet ampli

en: So, what does the `:slicer` FX actually do? One way to think about it is that it's just like having someone play around with the volume control on your TV or home hi-fi. Let's take a look but first, listen to the deep growl of the following code which triggers the `:prophet` synth:
fr: Alors, que fait réellement l'effet `:slicer` ? Une façon de se le représenter est simplement comme quelqu'un qui joue avec le contrôle du volume de votre TV ou de votre chaîne hi-fi. Voyons cela, mais d'abord, écoutez le grognement profond produit par le code suivant qui utilise le synthé `:prophet` :

en: Now, let's pipe it through the `:slicer` FX:
fr: Maintenant, passons le à travers l'effet `:slicer` :

en: Hear how the slicer acts like it's muting and unmuting the audio with a regular beat. Also, notice how the `:slicer` affects all the audio generated between the `do`/`end` blocks. You can control the speed at which it turns the audio on and off with the `phase:` opt which is short for phase duration. Its default value is `0.25` which means 4 times a second at the default BPM of 60. Let's make it faster:
fr: Écoutez comme le `:slicer` fait comme s'il coupait puis rétablissait le son à un rythme régulier. Observez aussi comme le `:slicer` affecte tout le son généré entre les blocs `do` et `end`. Vous pouvez contrôler la vitesse à laquelle il coupe et rétablit le son avec l'option `phase:` qui est l'abréviation de "durée de phase". Sa valeur par défaut est `0.25` ce qui signifie 4 fois par seconde au rythme par défaut de 60 BPM. Accélérons le :

en: Now, play with different `phase:` durations yourself. Try longer and shorter values. See what happens when you choose a really short value. Also, try different synths such as `:beep` or `:dsaw` and different notes. Take a look at the following diagram to see how different `phase:` values change the number of amplitude changes per beat.
fr: Maintenant, jouez avec différentes durées `phase :` vous-même. Essayez des valeurs de plus en plus courtes. Voyez ce qui se passe lorsque vous choisissez une valeur vraiment courte. Essayez également différents synthés tels que `:beep` ou`:dsaw` et différentes notes. Jetez un œil au diagramme suivant pour voir comment les différentes valeurs de `phase :` changent le nombre de changements d'amplitude par battement.

en: ![Phase Durations](../../../etc/doc/images/tutorial/articles/A.14-amplitude-modulation/slicer_phase_durations.png)
fr: ![Durée de Phase](../../../etc/doc/images/tutorial/articles/A.14-amplitude-modulation/slicer_phase_durations.png)

en: Phase duration is the length of time for one on/off cycle. Therefore smaller values will make the FX switch on and off much faster than larger values. Good values to start playing with are `0.125`, `0.25`, `0.5` and `1`.
fr: La durée de phase est la durée d'un cycle on/off. De ce fait, des valeurs plus petites feront que l'effet alternera entre on et off beaucoup plus rapidement qu'avec des valeurs plus grandes. De bonnes valeurs pour commencer à jouer sont `0.125`, `0.25`, `0.5` et `1`.

en: Control Waves
fr: Ondes de contrôle

en: By default, the `:slicer` FX uses a square wave to manipulate the amplitude through time. This is why we hear the amplitude on for a period, then immediately off for a period, then back on again. It turns out that the square wave is just one of 4 different control waves that are supported by `:slicer`. The others are saw, triangle and (co)sine. Take a look at the diagram below to see what these look like. We can also hear what they sound like. For example, the following code uses (co)sine as the control wave. Hear how the sound doesn't turn on and off abruptly but instead smoothly fades in and out:
fr: Par défaut, l'effet `:slicer` utilise une onde carrée pour manipuler l'amplitude au fil du temps. C'est pour cela que l'on entend l'amplitude pendant une période, puis elle est immédiatement coupée pendant une période, puis remise en marche. Il se trouve que l'onde carrée est juste l'une des 4 différentes ondes de contrôle supportée par le `:slicer`. Les autres sont l'onde en dent de scie (saw), l'onde triangle et l'onde (co)sinus. Regardez le diagramme ci-dessous pour voir à quoi elles ressemblent. On peut aussi entendre comment elles sonnent. Par exemple, le code suivant utilise l'onde (co)sinus comme onde de contrôle. Remarquez comme le son n'est pas coupé puis remis brusquement, mais au lieu de cela, augmente et diminue doucement :

en: Have a play with the different wave forms by changing the `wave:` opt to `0` for saw, `1` for square, `2` for triangle and `3` for sine. See how different waves sound with different `phase:` opts too.
fr: Jouez avec les différentes formes d'ondes en changeant l'option `wave:` à `0` pour la dent de scie, `1` pour l'onde carrée, `2` pour l'onde triangle et `3` pour la sinusoïde. Voyez aussi comme les différentes ondes sonnent avec des options `phase:` différentes.

en: Each of these waves can be inverted with the `invert_wave:` opt which flips it on the y axis. For example, in a single phase the saw wave typically starts high, and slowly goes down before jumping back to the top. With `invert_wave: 1` it will start low and slowly go up before jumping back down again. Additionally, the control wave can be started at different points with the `phase_offset:` opt which should be a value between `0` and `1`. By playing around with `phase:`, `wave:`, `invert_wave:` and `phase_offset` opts you can dramatically change how the amplitude is modified through time.
fr: Chacune de ces ondes peut être inversée avec l'option `invert_wave:` qui la retourne sur l'axe y. Par exemple, lors d'une phase, l'onde en dent de scie commence typiquement à l'état haut puis descend doucement avant de sauter d'un coup à l'état haut. Avec `invert_wave: 1`, elle va commencer à l'état bas, puis monter doucement avant de sauter de nouveau à l'état bas. De plus, l'onde de contrôle peut démarrer à différents points avec l'option `phase_offset:` qui prend une valeur entre `0` et `1`. En jouant avec les options `phase:`, `wave:`, `invert_wave:` et `phase_offset`, vous pouvez changer drastiquement la façon dont l'amplitude est modulée au cours du temps.

en: ![Phase Durations](../../../etc/doc/images/tutorial/articles/A.14-amplitude-modulation/slicer_control_waves.png)
fr: ![Durées de Phase](../../../etc/doc/images/tutorial/articles/A.14-amplitude-modulation/slicer_control_waves.png)

en: Setting your levels
fr: Régler vos niveaux

en: By default, `:slicer` switches between amplitude values `1` (fully loud) and `0` (silent). This can be changed with the `amp_min:` and `amp_max:` opts. You can use this alongside the sine wave setting to create a simple tremolo effect:
fr: Par défaut, le `:slicer` alterne entre les valeurs d'amplitude `1` (volume max nominal) et `0` (silencieux). Ceci peut être changé avec les options `amp_min:` et `amp_max:`. Vous pouvez utiliser ceci en parallèle du réglage d'onde sinusoïdale pour créer un effet de trémolo simple :

en: This is just like grabbing the volume knob on your hi-fi and moving it up and down just a little so the sound 'wobbles' in and out.
fr: C'est comme attraper le bouton de volume de votre chaîne hi-fi et le bouger légèrement de haut en bas pour que le volume oscille.

en: Probabilities
fr: Probabilités

en: One of `:slicer`'s powerful features is its ability to use probability to choose whether or not to turn the slicer on or off. Before the `:slicer` FX starts a new phase it rolls a dice and based on the result either uses the selected control wave or keeps the amplitude off. Let's take a listen:
fr: L'une des fonctionnalités puissantes de `:slicer` est sa capacité à utiliser la probabilité pour choisir d'activer ou pas le slicer. Avant que le FX `:slicer` ne commence une nouvelle phase, il lance un dé et, en fonction du résultat, utilise l'onde de contrôle sélectionnée ou maintient l'amplitude désactivée. Écoutons :

en: Hear how we now have an interesting rhythm of pulses. Try changing the `probability:` opt to a different value between `0` and `1`. Values closer to `0` will have more space between each sound due to the likelihood of the sound being triggered being much lower.
fr: Ecoutez comme nous avons maintenant un rythme de pulsations intéressant. Essayez de changer l'option `probability:` vers une valeur différente entre `0` et `1`. Les valeurs plus proches de `0` provoqueront plus d'espacement entre les sons, dû à la probabilité beaucoup plus basse que le son soit déclenché.

en: Another thing to notice is that the probability system in the FX is just like the randomisation system accessible via fns such as `rand` and `shuffle`. They are both completely deterministic. This means that each time you hit Run you'll hear exactly the same rhythm of pulses for a given probability. If you would like to change things around you can use the `seed:` opt to select a different starting seed. This works exactly the same as `use_random_seed` but only affects that particular FX.
fr: Une autre chose à remarquer, est que le système de probabilités dans l'effet FX est identique à celui qui est accessible via les fonctions comme `rand` et `shuffle`. Ils sont tous les deux complètement déterministes. Cela signifie qu'à chaque fois que vous appuyez sur le bouton `executer`, vous entendrez exactement le même rythme de pulsations pour une probabilité donnée. Si vous voulez changer les choses, vous pouvez utiliser l'option `seed:` pour sélectionner une graine de départ différente. Cela fonctionne exactement comme `use_random_seed` mais affecte uniquement cet effet particulier.

en: Finally, you can change the 'resting' position of the control wave when the probability test fails from `0` to any other position with the `prob_pos:` opt:
fr: Enfin, vous pouvez changer la "position de repos" de l'onde de contrôle quand le test de probabilité échoue, de `0` à n'importe quelle autre position avec l'option `prob_pos:` :

en: Slicing Beats
fr: Tranchage de rtythmes

en: One really fun thing to do is to use `:slicer` to chop a drum beat in and out:
fr: Une chose très amusante à faire est d'utiliser le `:slicer` pour découper un rythme de batterie :

en: This allows us to take any sample and create new rhythmical possibilities which is a lot of fun. However, one thing to be careful about is to make sure that the tempo of the sample matches the current BPM in Sonic Pi otherwise the slicing will sound totally off. For example, try swapping `:loop_mika` with the `loop_amen` sample to hear how bad this can sound when the tempos don't align.
fr: Ceci nous permet de prendre n'importe quel échantillon et de créer de nouvelles possibilités rythmiques, ce qui est très amusant. Cependant, une chose pour laquelle il faut être prudent est de s'assurer que le tempo de l'échantillon correspond au rythme actuel dans Sonic Pi, sinon la découpe sonnera totalement décalée. Par exemple, essayez de remplacer `:loop_mika` avec l'échantillon `loop_amen` pour entendre comme cela sonne mal quand les tempo ne s'alignent pas.

en: Changing tempo
fr: Modifier le tempo

en: As we have already seen, changing the default BPM with `use_bpm` will make all the sleep times and synth envelope durations grow or shrink to match the beat. The `:slicer` FX honours this too, as the `phase:` opt is actually measured in beats not seconds. We can therefore fix the issue with `loop_amen` above by changing the BPM to match the sample:
fr: Comme vous avez pu le voir, changer le BPM par défaut avec `use_bpm` fera s'accroitre ou se réduire les temps de pause et les durées d'enveloppe des synthés pour correspondre avec le tempo. L'effet `:slicer` honorera cela aussi, car l'option `phase:` est en fait mesurée en pulsation et non en secondes. Nous pouvons donc régler le problème avec `loop_amen` en changeant le BPM pour qu'il corresponde à l'échantillon :

en: Let's apply all these ideas into a final example that only uses the `:slicer` FX to create an interesting combination. Go ahead, start changing it and make it into your own piece!
fr: Appliquons ces idées dans un dernier exemple qui utilise uniquement l'effet `:slicer` pour créer une combinaison intéressante. Allez-y, commencez à le modifier et à en faire votre propre morceau !

en: A.15 Five Live Coding Techniques
fr: A. 15 techniques de codage en "Live"

en: Five Live Coding Techniques
fr: Cinq techniques de Live Coding

en: In this month's Sonic Pi tutorial we're going to take a look at how you can start treating Sonic Pi like a real instrument. We therefore need to start thinking of code in a completely different way. Live coders think of code in a similar way to how violinists think of their bow. In fact, just like a violinist can apply various bowing techniques to create different sounds (long slow motions vs short fast hits) we will explore five of the basic live coding techniques that Sonic Pi enables. By the end of this article you'll be able to start practicing for your own live coded performances.
fr: Dans le tutoriel Sonic Pi de ce mois-ci, nous allons regarder comment vous allez pouvoir commencer à traiter Sonic Pi comme un véritable instrument. Nous allons donc devoir commencer à penser au code d'une façon complètement différente. Les live coders voient le code de la même façon que les violonistes voient leur archet. En fait, tout comme un violoniste peut appliquer différentes méthodes d'archet pour créer des sons différents (des mouvements lents et amples ou des touches rapides et courtes) nous allons explorer cinq des techniques de base de live coding que permet Sonic Pi. À la fin de cet article, vous serez capables de commencer à vous entrainer pour vos propres représentations de live coding.

en: 1. Memorise the Shortcuts
fr: 1. Mémoriser les raccourcis

en: The first tip to live coding with Sonic Pi is to start using the shortcuts. For example, instead of wasting valuable time reaching for the mouse, moving it over to the Run button and clicking, you can simply press `alt` and `r` at the same time which is much faster and keeps your fingers at the keyboard ready for the next edit. You can find out the shortcuts for the main buttons at the top by hovering the mouse over them. See section 10.2 of the built-in tutorial for the full list of shortcuts.
fr: Le premier truc pour live coder avec Sonic Pi est de commencer à utiliser les raccourcis. Par exemple, au lieu de perdre un temps précieux à atteindre la souris, la déplacer sur le bouton d'exécution et cliquer dessus, vous pouvez simplement appuyer simultanément sur `alt` et `r`, ce qui est beaucoup plus rapide et garde vos doigts sur le clavier, prêts pour la prochaine édition. Vous pouvez trouver les raccourcis pour les principaux boutons en haut, en passant la souris au dessus d'eux. Voyez la section 10.2 du tutoriel inclus pour la liste complète des raccourcis.

en: When performing, one fun thing to do is to add a bit of flair with your arm motion when hitting shortcuts. For example, it's often good to communicate to the audience when you're about to make a change - so embellish your movement when hitting `alt-r` just like a guitarist would do when hitting a big power chord.
fr: Lorsque vous jouez, une chose amusante à faire est d'ajouter un peu de style à votre mouvement de bras lorsque vous utilisez des raccourcis. Par exemple, il est souvent bien de communiquer avec votre public quand vous êtes sur le point de faire un changement. Embellissez donc votre mouvement quand vous appuyez sur `alt-r` comme le ferait un guitariste lorsqu'il joue un puissant accord.

en: 2. Manually Layer your Sounds
fr: 2. Superposer manuellement vos sons

en: Now you can trigger code instantly with the keyboard, you can instantly apply this skill for our second technique which is to layer your sounds manually. Instead of 'composing' using lots of calls to `play`, and `sample` separated by calls to `sleep` we will have one call to `play` which we will manually trigger using `alt-r`. Let's try it. Type the following code into a fresh buffer:
fr: Maintenant que vous pouvez déclencher le code instantanément avec le clavier, vous pouvez instantanément utiliser cette compétence pour notre seconde technique qui est de calquer vos sons manuellement. Au lieu de "composer" en utilisant beaucoup d'appels de "jouer" et "échantillon" séparés par des appels de "dormir", nous allons avoir un appel de "jouer" que nous allons manuellement déclencher en utilisant "alt-r". Essayons-le. Taper le code suivant dans un nouveau tampon :

en: Now, hit `Run` and whilst the sound is playing, modify the code in order to drop down four notes by changing it to the following:
fr: Maintenant, cliquez sur "Exécuter". Pendant que le son joue, modifiez le code afin de décrémenter quatre notes en effectuant ce qui suit :

en: Now, hit `Run` again, to hear both sounds playing at the same time. This is because Sonic Pi's `Run` button doesn't wait for any previous code to finish, but instead starts the code running at the same time. This means you can easily layer lots of sounds manually with minor or major modifications between each trigger. For example, try changing both the `note:` and the `cutoff:` opts and then re-trigger.
fr: Maintenant, pressez `Run` de nouveau, pour entendre les deux sons jouer en même temps. Ceci se produit puisque le bouton `Run` de Sonic Pi n'attend pas qu'un code précédent ne se termine et donc le code s'exécute en même temps. Ceci veut dire que vous pouvez facilement superposer plusieurs sons manuellement avec des modifications mineures ou majeures entre chaque déclenchement. Par exemple, essayez de changer la `note:` et l'option de `cutoff:` et de déclencher de nouveau.

en: You can also try this technique with long abstract samples. For example:
fr: Vous pouvez également essayer cette technique avec de longs échantillons abstraits. Par exemple :

en: Try starting the sample off, and then progressively halving the `rate:` opt between hitting `Run` from `1` to `0.5` to `0.25` to `0.125` and then even try some negative values such as `-0.5`. Layer the sounds together and see where you can take it. Finally, try adding some FX.
fr: Essayer de démarrer l'échantillon, et puis progressivement couper de moitié l'option de `rate:` entre les clics de `Run` de `1` à `0.5` à `0.25` à `0.125`. Ensuite, essayez même des valeurs négatives comme `-0.5`. Superposez les sons ensemble et découvrez ce que vous pouvez faire. Finalement, essayez d'ajouter quelques FX.

en: When performing, working with simple lines of code in this way means that an audience new to Sonic Pi has a good chance to follow what you're doing and relate the code that they can read to the sounds they are hearing.
fr: En direct, travailler ainsi avec des lignes de code simples permet à un public découvrant Sonic Pi de suivre ce que vous faites et de faire le lien entre le code lu et le son entendu, le résultat du code.

en: 3. Master Live Loops
fr: 3. Boucles maîtresses en "live"

en: When working with more rhythmic music, it can often be hard to manually trigger everything and keep good time. Instead, it is often better to use a `live_loop`. This provides repetition for your code whilst also giving the ability to edit the code for the next time round the loop. They also will run at the same time as other `live_loop`s which means you can layer them together both with each other and manual code triggers. Take a look at section 9.2 of the built-in tutorial for more information about working with live loops.
fr: Lorsque vous travaillez avec une musique plus rythmée, il est souvent difficile de déclencher tout manuellement et de conserver le bon tempo. A la place, il est souvent mieux d'utiliser une `live_loop`. Cela fournit une répétition de votre code en plus de vous donner la possibilité de modifier le code pour la prochaine itération de la boucle. Ces "boucles en direct", live loops, vont également être exécutées en même temps que les autres `live_loop`s ce qui signifie que vous pouvez jouer les deux ensemble l'une avec l'autre et programmer manuellement les déclencheurs. Jetez un coup d’œil à la section 9.2 du tutoriel inclus pour plus d'informations à propos du travail avec les boucles en direct.

en: When performing, remember to make use of `live_loop`'s `sync:` opt to allow you to recover from accidental runtime mistakes which stop the live loop running due to an error. If you already have the `sync:` opt pointing to another valid `live_loop`, then you can quickly fix the error and re-run the code to re-start things without missing a beat.
fr: En direct, pensez à utiliser l'option `live_loop`'s `sync:` pour récupérer des erreurs d'exécution accidentelles qui stoppent la boucle en direct à cause d'une erreur de votre part, erreur de syntaxe par exemple. Si vous avez l'option `sync:` qui pointe vers une autre `live_loop` valide alors vous pouvez rapidement réparer votre erreur de syntaxe et ré-exécuter le code corrigé pour redémarrer les choses sans l'arrêt du morceau complet.

en: 4. Use the Main Mixer
fr: 4. Utiliser le mixer général

en: One of Sonic Pi's best kept secrets is that it has a main mixer through which all sound flows. This mixer has both a low pass filter and a high pass filter built-in, so you can easily perform global modifications to the sound. The main mixer's functionality can be accessed via the fn `set_mixer_control!`. For example, whilst some code is running and making sound, enter this into a spare buffer and hit `Run`:
fr: L'un des secrets les mieux gardés de Sonic Pi est qu'il a un mixeur maître par lequel passent tous les flux de sons. Ce mixeur a un filtre de passe basse et un filtre de passe élevé inclus, afin que vous puissiez facilement effectuer des modifications globales au son. La fonctionnalité du mixeur maître est accessible via la fonction `set_mixer_control!`. Par exemple, pendant que du code s'exécute et fait du son, entrez ceci dans un tampon supplémentaire et pressez `Run` :

en: After you run this code, all existing and new sounds will have a low pass filter applied to them and will therefore sound more muffled. Note that this means that the new mixer values stick until they are changed again. However, if you want, you can always reset the mixer back to its default state with `reset_mixer!`. Some of the currently supported opts are: `pre_amp:`, `lpf:` `hpf:`, and `amp:`. For the full list, see the built-in docs for `set_mixer_control!`.
fr: Ce code une fois exécuté, tous les sons existants et les nouveaux auront un filtre passe-bas qui leur sera appliqué : ils sonneront donc plus étouffés. Notez que cela veut dire que les nouvelles valeurs du mixeur demeurent les mêmes tant qu'elles ne sont pas changées de nouveau. Cependant, si vous le voulez, vous pouvez toujours remettre le mixeur à son état par défaut avec `reset_mixer!`. Quelques unes des options supportées actuellement sont : `pre_amp:`, `lpf:` `hpf:`, et `amp:`. Pour la liste complète, voir la documentation incluse pour `set_mixer_control!`.

en: Use the mixer's `*_slide` opts to slide one or many opts values over time. For example, to slowly slide the mixer's low pass filter down from the current value to 30, use the following:
fr: Utilisez les options `*_slide` du mixeur pour faire varier, glisser une ou plusieurs valeurs d'option au fil du temps. Par exemple, pour glisser lentement le filtre de passe-bas du mixeur de la valeur courante à 30, utilisez ceci :

en: You can then slide quickly back to a high value with:
fr: Vous pouvez désormais glisser rapidement de nouveau vers une valeur haute avec :

en: When performing, it's often useful to keep a buffer free for working with the mixer like this.
fr: Lorsque vous jouez, il est souvent utile de conserver un tampon libre pour travailler avec le mixeur comme cela.

en: 5. Practice
fr: 5. Entraînement

en: The most important technique for live coding is practice. The most common attribute across professional musicians of all kinds is that they practice playing with their instruments - often for many hours a day. Practice is just as important for a live coder as a guitarist. Practice allows your fingers to memorise certain patterns and common edits so you can type and work with them more fluently. Practice also gives you opportunities to explore new sounds and code constructs.
fr: La technique la plus importante pour la programmation en direct est la pratique. Le trait le plus commun au travers des musiciens professionnels de tous les types est qu'ils s'entraînent à jouer avec leur instrument - souvent plusieurs heures par jour. La pratique est aussi importante pour un programmeur en direct qu'un guitariste. La pratique permet à vos doigts de mémoriser certains schémas et éditions communes afin que vous puissiez les tapez et travailler avec eux de manière plus fluide. La pratique vous donne également des opportunités d'explorer des nouveaux sons et des nouvelles constructions de code.

en: When performing, you'll find the more practice you do, the easier it will be for you to relax into the gig. Practice will also give you a wealth of experience to draw from. This can help you understand which kinds of modifications will be interesting and also work well with the current sounds.
fr: En performant, vous découvrirez que plus vous pratiquez, plus il sera facile pour vous de vous relaxer pendant une séance. La pratique vous donne également une richesse d'expérience de laquelle apprendre. Cela peut vous aider à comprendre quel types de modifications seraient intéressants et également ce qui fonctionne bien avec les sons courants.

en: This month, instead of giving you a final example that combines all the things discussed, let's part by setting down a challenge. See if you can spend a week practicing one of these ideas every day. For example, one day practice manual triggers, the next do some basic `live_loop` work and the following day play around with the main mixer. Then repeat. Don't worry if things feel slow and clunky at first - just keep practicing and before you know it you'll be live coding for a real audience.
fr: Ce mois-ci, au lieu de vous donner un exemple final qui combine toutes les choses dont nous avons discuté, essayons plutôt de poser un défi. Voyez si vous pouvez passer une semaine à pratiquer l'une de ces idées tous les jours. Par exemple, une journée pratiquez les déclencheurs manuels, la suivante faites du travail basique de `live_loop` et avant que vous ne vous en rendiez compte, vous serez en train de coder en direct pour un vrai public.

en: A.16 How to Practice Live Coding
fr: A.16 Comment pratiquer le codage en direct

en: 8 Tips for Live Coding Practice
fr: 8 astuces pour la pratique du codage en direct

en: Last month we took a look at five important techniques for mastering live coding - in other words, we explored how we could use Sonic Pi to approach code in the same way we would approach a musical instrument. One of the important concepts that we discussed was practice. This month we're going to take a deeper dive into understanding why live coding practice is important and how you might start.
fr: Le mois dernier, nous avons étudié cinq techniques importantes pour maitriser le codage en direct - en d'autres mots, nous avons exploré comment nous pouvions utiliser Sonic Pi pour approcher le code de la même façon que nous le ferions avec un instrument de musique. L'un des concepts importants dont nous avons discuté est la pratique. Ce mois-ci, nous allons approfondir notre compréhension de pourquoi la pratique du codage en direct est importante et comment vous pouvez commencer à le faire.

en: Practice regularly
fr: Pratiquer régulièrement

en: The most important piece of advice is to make sure you practice regularly. As a rule I typically practice for 1-2 hours a day, but 20 mins is just fine when you're starting out. Little but often is what you're aiming for - so if you can only manage 10 minutes, that's a great start.
fr: Le conseil le plus important est de vous assurer de pratiquer régulièrement. Par discipline, je pratique normalement 1-2 heures par jour, mais 20 minutes est correct quand vous débutez. Un petit peu mais souvent est ce que vous visez - donc si vous ne pouvez effectuer que 10 minutes, c'est un bon début.

en: Practice tip #1 - start to develop a practice routine. Find a nice time in the day that works for you and try and practice at that time as many days of the week as you can. Before long you'll be looking forward to your regular session.
fr: Astuce de pratique #1 - commencer à développer une routine de pratique. Trouvez un bon moment dans la journée qui vous convient et essayer de pratiquer à ce moment le plus grand nombre de jours dans une semaine que vous pouvez. Vous allez rapidement avoir hâte de faire votre session quotidienne.

en: Learn to Touch Type
fr: Apprenez à taper sans regarder le clavier

en: If you watch a professional musician performing on stage you'll likely notice a few things. Firstly, when they play they don't stare at their instrument. Their fingers, arms and bodies know which keys to press, strings to pluck or drums to hit without them having to think about it too much. This is known as "muscle memory" and although it might sound like something only professionals can do - it's just the same as when you first learned to walk or ride a bike - practicing through repetition. Live coders use muscle memory to free their minds from having to think about where to move their fingers so they can focus on the music. This is called touch-typing - typing without having to look at the keyboard.
fr: Si vous observez un musicien professionnel qui performe sur scène, vous remarquez certainement quelques éléments. Premièrement, ils ne fixent pas leur instrument lorsqu'ils jouent. Leurs doigts, bras et corps savent quelles sont les touches à appuyer, cordes à gratter ou les tambours à frapper sans avoir trop à y penser. Ceci est connu comme la "mémoire musculaire" et même si cela peut ressembler à quelque chose qu'uniquement les professionnels peuvent faire, c'est la même chose que lorsque vous avez appris à marcher ou à faire de la bicyclette, la pratique par répétition. Les codeurs en direct utilisent leur mémoire musculaire pour libérer leur esprit d'avoir à penser à quel endroit placer leurs doigts afin qu'ils puissent se concentrer sur la musique. Cela s'appelle du tape-touche - taper sans avoir besoin de regarder le clavier.

en: Practice tip #2 - learn how to touch type. There are many apps, websites and even games which can help you achieve this. Find one you like the look of and stick at it until you can code without looking down.
fr: Astuce de pratique #2 - apprenez comment taper sans regarder le clavier. Il y a plusieurs applications, sites web et même des jeux qui peuvent vous aider à réussir. Trouvez-en un dont vous aimez l'allure et tenez vous en à lui jusqu'à ce que vous soyez capable de programmer sans regarder le clavier.

en: Code whilst standing
fr: Coder en position debout

en: The body of a musician is conditioned for playing their instrument. For example, a trumpet player needs to be able to blow hard, a guitar player needs to be able to grip the fretboard with strength and a drummer needs to be able to continually hit the drums for long periods of time. So, what's physical about live coding? Just like DJs, live coders typically perform whilst standing up and some even dance whilst they code! If you practice live coding whilst sitting at a desk and then have to get up and stand at a gig, you'll likely find the difference very difficult and frustrating.
fr: Le corps d'un musicien est conditionné pour jouer son instrument. Par exemple, un trompettiste doit être capable de souffler fort, un guitariste doit être capable de tenir le manche avec force et un batteur doit être capable de frapper continuellement les tambours pour de longues périodes de temps. Alors, qu'est-ce qui est physique à propos du codage en direct ? Tout comme les DJs, les codeurs en direct performent habituellement debout et certains dansent même en codant ! Si vous pratiquez votre codage en direct assis à un bureau et que vous avez à vous levez pour jouer pour un concert, vous trouverez probablement cette différence difficile et frustrante.

en: Practice tip #3 - stand whilst you practice. The easiest way to do this is to use a standing height desk. However, if like me you don't have one at home, there's a couple of low-fi options. The approach I take is to use an ironing board which happens to work rather well. Another is to stack some boxes or large books on a normal desk and place your keyboard on top of that. Also, make sure you stretch before you start practicing and try and dance a little during the session. Remember, nobody is watching you, so have fun and you'll feel much more natural on stage.
fr: Astuce de pratique #3 - tenez vous debout en pratiquant. La façon la plus facile de faire cela est en utilisant un bureau à usage debout. Par contre, si comme moi vous n'en n'avez pas à la maison, il existe quelques options à faible coût. L'approche que je prends est d'utiliser une table à repasser, ce qui fonctionne assez bien. Une autre façon est d'empiler quelques boites ou de gros livres sur un bureau normal et placer votre clavier sur le dessus. De plus, n'oubliez pas de vous étirez avant de commencer votre pratique et essayez de danser un peu durant votre session. Rappelez-vous, personne ne vous regarde, donc ayez du plaisir et vous vous sentirez beaucoup plus naturel sur scène.

en: Practice setting up
fr: Mise en place de la pratique

en: Most instruments require some assembly and tuning before they can be played. Unless you're a rockstar with a bus full of roadies, you'll have to set up your own instrument before your gig. This is often a stressful time and it is easy for problems to occur. One way to help with this is to incorporate the setup process into your practice sessions.
fr: La majorité des instruments nécessitent de l'assemblage et des ajustements avant que vous puissiez en jouer. À moins que vous soyez une étoile du rock avec un autobus rempli de techniciens, vous aurez à mettre en place votre propre instrument avant votre concert. C'est souvent un moment stressant et des problèmes peuvent arriver facilement. Une façon de vous aider avec cela est d'incorporer le processus de mise en place dans vos sessions d'entraînement.

en: Practice tip #4 - treat setting up as an important part of your practice. For example, have a box or bag that you can keep your Raspberry Pi and keyboard in etc. Before each practice session, take out all the parts, connect everything, and work through the boot process until you have Sonic Pi running and can make sounds. Once you've finished practicing, take the time to carefully pack everything away afterwards. This may take some time at first, but before long you'll be able to setup and pack everything away incredibly quickly without having to think about it.
fr: Astuce de pratique #4 - traiter la mise en place comme une partie importante de votre pratique. Par exemple, ayez une boite ou un sac dans lequel vous pouvez conserver votre Raspberry Pi et votre clavier etc. Avant chaque session de pratique, sortez toutes les pièces, connectez tout et aller dans le processus de démarrage jusqu'à ce que vous ayez Sonic Pi qui s'exécute et que vous puissiez faire des sons. A la fin de votre entraînement, prenez le temps de tout remballer minutieusement. Cela peut prendre du temps au départ, mais en peu de temps vous serez capable de mettre en place et emballer tout incroyablement rapidement sans que vous ayez besoin d'y penser.

en: Experiment Musically
fr: Expérimenter musicalement

en: Once you've set up and are ready to start making music, you might find yourself struggling to know where to start. One problem many people face is that they might have a good idea of the kinds of sounds they want to make, but are frustrated that they can't produce them. Some people don't even know what kind of sounds they want to make! The first thing to do is not to worry - this is very common and happens to every musician - even if they've been practicing for a long time. It is much more important to be making sounds you don't like than not making any sounds at all.
fr: Une fois que tout est mis en place et que vous êtes prêt à faire de la musique, il se peut que vous ayez de la difficulté à savoir par où commencer. Un problème que plusieurs personnes rencontrent est qu'elles ont une bonne idée du type de sons qu'elles veulent produire, mais elles sont frustrées de ne pas être capable de les produire. Certaines personnes ne savent même pas quel type de sons elles veulent produire ! La première chose à faire est de ne pas s'inquiéter - c'est très commun et ça arrive à tous les musiciens - même s'ils pratiquent depuis longtemps. C'est beaucoup plus important de faire des sons que vous n'aimez pas que de ne pas faire de sons du tout.

en: Practice tip #5 - spend time making sounds and music you don't like. Try to make time to explore new sounds and ideas. Don't worry that it might sound terrible if it's not the style you're looking for. When you're experimenting like this you increase the chance of stumbling over a sound or combination of sounds which you love! Even if 99% of the sounds you make are bad, that 1% might be the riff or intro to your new track. Forget the things you don't like and remember the parts you do. This is even easier when you're making music with code - just hit save!
fr: Astuce de pratique #5 - passez du temps à faire des sons et de la musique que vous n'aimez pas. Essayez de conserver du temps pour explorer des nouveaux sons et des idées. Ne vous inquiétez pas que cela puisse sonner terrible si ce n'est pas le style que vous recherchez. Quand vous expérimentez de cette manière, vous augmentez les chances de tomber sur un son ou une combinaison de sons que vous aimez ! Même si 99% des sons que vous faites sont mauvais, ce 1% peut être le riff ou l'intro de votre nouvelle piste. Oubliez les choses que vous n'aimez pas et rappelez-vous de celles que vous aimez. C'est encore plus facile quand vous faites de la musique avec du code - vous n'avez qu'à presser sauvegarder !

en: Hear the Code
fr: Entendre le code

en: Many musicians can look at a musical score and hear the music in their head without having to play it. This is a very useful skill and it's well worth incorporating into your live coding practice sessions. The important point is to be able to have some understanding of what the code is going to sound like. You don't need to be able to hear it exactly in your head, but instead it's useful to know if the code is going to be fast, slow, loud, rhythmic, melodic, random, etc. The final goal is then to be able to reverse this process - to be able to hear music in your head and know what code to write to make it. It may take you a long time to master this, but once you do, you'll be able to improvise on stage and express your ideas fluently.
fr: Plusieurs musiciens peuvent regarder une partition de musique et entendre la musique dans leur tête sans avoir à la jouer. C'est une compétence très utile et ça vaut la peine de l'incorporer dans vos sessions de pratique de codage en direct. L'important est d'être capable d'avoir une certaine compréhension de comment va sonner le code. Vous n'avez pas besoin d'être capable de l'entendre exactement dans votre tête, mais il est utile de savoir si le code sera rapide, lent, fort, rythmé, mélodieux, aléatoire, etc. Le but final est d'être capable d'inverser le processus par la suite - être capable d'entendre de la musique dans votre tête et savoir comment la coder. Cela peut vous prendre beaucoup de temps à maîtriser, mais quand c'est le cas, vous serez capable d'improviser sur scène et exprimer vos idées de manière fluide.

en: Practice tip #6 - write some code into Sonic Pi but don't hit the Run button. Instead, try to imagine what sound it is going to produce. Then, hit Run, listen, and think about what you got right and what you didn't. Keep repeating this until it become a natural part of your coding process. When I practice I normally have a good idea of what the code will sound like. However, I still am occasionally surprised, and then I'll stop and spend some time thinking about why I was wrong. Each time this happens, I learn new tricks which allow me to express myself in new ways.
fr: Astuce de pratique #6 - écrivez un peu de code dans Sonic Pi, mais ne pressez pas sur le bouton Exécuter. Au lieu de cela, essayez d'imaginer quel son ça va produire. Puis, pressez Exécuter, écoutez, et pensez sur quoi vous aviez raison et sur quoi vous aviez tort. Continuez de répéter cela jusqu'à ce que ça devienne une partie naturelle de votre processus de codage. Quand je pratique, j'ai normalement une bonne idée de comment va sonner le code. Cependant, je suis encore parfois surpris, et alors j'arrête et prends du temps pour penser à propos de quoi j'avais tort. À chaque fois que cela se produit, j'apprends de nouveaux trucs qui me permettent de m'exprimer de nouvelles façons.

en: Remove all distractions
fr: Enlevez toutes les distractions

en: A common problem when practicing is to become distracted with other things. Practicing is hard and requires real discipline regardless of the kind of music you're making - from jazz to classical to EDM. If you're struggling to get started or make progress, it's often too easy to hop on social media, or look something up on the internet etc. If you've set yourself a target of 20 minutes of practice, it's important to try and spend all that time being as productive as possible.
fr: Un problème courant en pratiquant est de devenir distrait par d'autres choses. La pratique est difficile et demande une réelle discipline peu importe le type de musique que vous jouez - du jazz au EDM en passant par le classique. Si vous avez de la difficulté à commencer ou faire des progrès, c'est souvent trop facile d'aller sur un réseau social, ou de regarder quelque chose sur internet etc. Si vous vous êtes fixé un objectif d'une pratique d'une durée de 20 minutes, c'est important d'essayer de prendre tout ce temps en étant le plus productif possible.

en: Practice tip #7 - before you start practicing remove as many distractions as possible. For example, disconnect from the internet, put your phone in another room and try to practice in a quiet place where you're unlikely to be disturbed. Try to focus on coding music and you can return to your distractions when you've finished.
fr: Astuce de pratique #7 - avant de commencer votre pratique, enlevez le plus de distractions possible. Par exemple, déconnectez-vous d'internet, laissez votre téléphone dans une autre pièce et essayez de pratiquer dans un endroit tranquille où il est peu probable que vous soyez dérangé. Essayez de vous concentrer sur le codage de la musique et vous pourrez retourner à vos distractions quand vous aurez terminé.

en: Keep a practice diary
fr: Tenir un journal d'entraînement

en: When you are practicing, you'll often find your mind is full of new exciting ideas - new musical directions, new sounds to try out, new functions to write, etc. These ideas are often so interesting that you might stop what you're doing and start working on the idea. This is another form of distraction!
fr: Quand vous pratiquez, vous ressentirez souvent que votre esprit est plein de nouvelles idées enthousiasmantes - nouvelles directions musicales, nouveaux sons à essayer, nouvelles fonctions à écrire, etc. Ces idées sont souvent tellement intéressantes que vous allez peut-être interrompre ce que vous faisiez pour commencer à travailler sur l'idée. Il s'agit d'une autre forme de distraction !

en: Practice tip #8 - keep a practice diary by your keyboard. When you get an exciting new idea, temporarily pause your practice session, quickly jot the idea down, then forget about it and carry on practicing. You can then spend some quality time thinking about and working on your ideas after you've finished practicing.
fr: Astuce de pratique #8 - conservez un journal de pratique près de votre clavier. Quand vous avez une nouvelle idée excitante, arrêtez temporairement votre session, notez rapidement l'idée, et puis oubliez la pour continuer à pratiquer. Vous pouvez par la suite passer du temps de qualité à penser et à travailler vos idées une fois que vous avez terminé de pratiquer.

en: Try to establish a practice routine which incorporates as many of these ideas as possible. Try to keep the sessions as fun as possible but be aware that some practice sessions will be hard and feel a little like work. However, it will all be worth it once you've created your first piece or given your first performance. Remember, practice is the key to success!
fr: Essayez d'établir une routine de pratique qui inclut autant de ces idées que possible. Essayez de rendre les sessions aussi plaisantes que possible, mais soyez prévenus que certaines sessions de pratiques seront difficiles et auront l'apparence d'un travail. Toutefois, tout cela aura valu la peine lorsque vous aurez créé votre première pièce ou que vous aurez donné votre première performance. Rappelez-vous, la pratique est la clé du succès !

en: A.17 Sample Stretching
fr: A.17 Étirement de l'échantillon

en: Sample Stretching
fr: Étirement de l'échantillon

en: When people discover Sonic Pi, one of the first things they learn is how simple it is to play pre-recorded sounds using the `sample` function. For example, you can play an industrial drum loop, hear the sound of a choir or even listen to a vinyl scratch all via a single line of code. However, many people don't realise that you can actually vary the speed that the sample is played back at for some powerful effects and a whole new level of control over your recorded sounds. So, fire up a copy of Sonic Pi and let's get started stretching some samples!
fr: Lorsque les personnes découvrent Sonic Pi, l'une des premières choses qu'ils apprennent est combien il est facile de jouer des sons pré-enregistrés en utilisant la fonction `sample`. Par exemple, vous pouvez faire jouer une boucle de batterie industrielle, entendre le bruit d'une chorale ou même écouter le "scratch" d'un vinyle, tout ça via une seule ligne de code. Cependant, plusieurs personnes ne réalisent pas que vous pouvez varier la vitesse à laquelle l'échantillon est joué pour ajouter des effets puissants et un tout nouveau niveau de contrôle sur vos sons enregistrés. Alors, lancez une copie de Sonic Pi et commençons à étirer quelques échantillons !

en: Slowing Samples Down
fr: Ralentissement des échantillons

en: To modify the playback rate of a sample we need to use the `rate:` opt:
fr: Pour modifier la vitesse à laquelle joue un échantillon, nous devons utiliser l'option `rate:` :

en: If we specify a `rate:` of `1` then the sample is played back at the normal rate. If we want to play it back at half speed we simply use a `rate:` of `0.5`:
fr: Si nous spécifions un `rate:` de `1`, alors l'échantillon sera joué à une vitesse normale. Si nous voulons le jouer à une vitesse réduite de moitié, nous utilisons tout simplement un `rate:` de `0.5` :

en: Notice that this has two effects on the audio. Firstly the sample sounds lower in pitch and secondly it takes twice as long to play back (see the sidebar for an explanation of why this is the case). We can even choose lower and lower rates moving towards `0`, so a `rate:` of `0.25` is a quarter speed, `0.1` is a tenth of the speed, etc. Try playing with some low rates and see if you can turn the sound into a low rumble.
fr: Notez comme cela a deux effets sur l'audio. Premièrement l'échantillon sonne plus bas et deuxièmement il prend deux fois plus de temps à jouer (voir la barre latérale pour une explication). Nous pouvons même choisir des vitesses de plus en plus basses jusqu'à `0`, donc un `rate:` de `0.25` est un quart de la vitesse, `0.1` un dixième de la vitesse, etc. Essayez de jouer avec des vitesses lentes et de voir si vous pouvez transformer le son en un grondement.

en: Speeding Samples Up
fr: Accélération des échantillons

en: In addition to making the sound longer and lower using a small rate, we can use higher rates to make the sound shorter and higher. Let's play with a drum loop this time. First, take a listen to how it sounds at the default rate of `1`:
fr: En plus de rendre le son plus long et grave en utilisant une petite vitesse, nous pouvons utiliser des vitesses plus rapides pour rendre le son plus court et aigu. Jouons avec une boucle de batterie pour cette fois-ci. Premièrement, écoutez comment cela sonne à la vitesse par défaut de `1` :

en: Now, let's speed it up a little:
fr: Maintenant, accélérons un peu les choses :

en: Ha! We just moved musical genres from old-skool techno to jungle. Notice how the pitch of each drum hit is higher as well as how the whole rhythm speeds up. Now, try even higher rates and see how high and short you can make the drum loop. For example, if you use a rate of `100`, the drum loop turns into a click!
fr: Ah ! Nous venons de passer du genre music techno vieille école à la jungle. Remarquer comment la fréquence de chaque coup de tambour est plus grande ainsi que le rythme complet qui est accéléré. Maintenant, essayer des taux encore plus grands et voyez comment haut et court vous pouvez modifier la boucle de batterie. Par exemple, si vous utilisez le taux de `100`, la boucle de batterie tourne en un clic !

en: Reverse Gear
fr: Marche arrière

en: Now, I'm sure many of you are thinking the same thing right now... "what if you use a negative number for the rate?". Great question! Let's think about this for a moment. If our `rate:` opt signifies the speed with which the sample is played back, `1` being normal speed, `2` being double speed, `0.5` being half speed, `-1` must mean backwards! Let's try it on a snare. First, play it back at the normal rate:
fr: A présent, je suis sûr que beaucoup d'entre vous pensent la même chose... "qu'est-ce qu'il se passe si j'utilise une valeur négative pour la vitesse ?". Excellente question ! Réfléchissons-y un court instant. Si notre `rate:` désigne la vitesse à laquelle l'échantillon est joué, `1` étant la vitesse normale, `2` étant deux fois plus rapide, `0.5` étant deux fois plus lent, `-1` doit vouloir dire à l'envers ! Essayons ça sur une caisse claire. Pour commencer, rejouez à la vitesse normale :

en: Now, play it backwards:
fr: Maintenant, jouez le à l'envers :

en: Of course, you can play it backwards twice as fast with a rate of `-2` or backwards at half speed with a rate of `-0.5`. Now, play around with different negative rates and have fun. It's particularly amusing with the `:misc_burp` sample!
fr: Bien entendu, vous pouvez le jouer à l'envers deux fois plus vite avec un `rate:` de `-2` ou à l'envers deux fois plus lentement avec un `rate:` de `-0.5`. Maintenant, amusez-vous à jouer avec différentes valeurs négatives. C'est particulièrement amusant avec l'échantillon `:misc_burp` !

en: Sample, Rate and Pitch
fr: Échantillon, Vitesse et Hauteur

en: One of the effects of rate modification on samples is that faster rates result in the sample sounding higher in pitch and slower rates result in the sample sounding lower in pitch. Another place you may have heard this effect in every day life is when you're cycling or driving past a beeping pedestrian crossing - as you're heading towards the sound source the pitch is higher than when you're moving away from the sound - the so-called Doppler effect. Why is this?
fr: L'un des effets de la modification de la vitesse sur les échantillons est que plus la vitesse est importante plus l'échantillon sonne aigu, et plus la vitesse est basse plus l'échantillon sonne grave. Un autre endroit où vous avez pu entendre cet effet est dans la vie de tous les jours lorsque vous faites du vélo ou que vous passez près d'un passage piéton qui émet un bip sonore - lorsque vous vous approchez de la source sonore le son est plus aigu que lorsque vous vous en éloignez - c'est ce que l'on appelle l'effet Doppler. Pourquoi cela ?

en: Let's consider a simple beep which is represented by a sine wave. If we use an oscilloscope to plot a beep, we'll see something like Figure A. If we plot a beep an octave higher, we'll see Figure B and an octave lower will look like Figure C. Notice that the waves of higher notes are more compact and the waves of lower notes are more spread out.
fr: Considérons un simple bip qui est représenté par une onde sinusoïdale. Si nous utilisons un oscilloscope pour tracer ce bip, nous verrons quelque chose comme la figure A. Si nous traçons le bip une octave plus aiguë, nous verrons la figure B et une octave plus grave ressemblera à la figure C. Remarquez que les ondes des notes aiguës sont plus compactes tandis que celles des notes graves sont plus étendues.

en: A sample of a beep is nothing more than a lot of numbers (x, y, coordinates) which when plotted onto a graph will re-draw the original curves. See figure D where each circle represents a coordinate. To turn the coordinates back into audio, the computer works through each x value and sends the corresponding y value to the speakers. The trick here is that the rate at which the computer works through the x numbers does not have to be the same as the rate with which they were recorded. In other words, the space (representing an amount of time) between each circle can be stretched or compressed. So, if the computer walks through the x values faster than the original rate, it will have the effect of squashing the circles closer together which will result in a higher sounding beep. It will also make the beep shorter as we will work through all the circles faster. This is shown in Figure E.
fr: Un échantillon d'un bip n'est rien de plus que beaucoup de nombres (x,y, coordonnées) qui, lorsque tracé point par point sur un graphique, dessinera de nouveau les courbes originales. Voyez la figure D où chaque cercle représente une coordonnée. Pour convertir de nouveau les coordonnées en audio, l'ordinateur travaille avec chaque valeur x et envoie chaque valeur y correspondante aux haut-parleurs. L'astuce ici est que la vitesse à laquelle l'ordinateur travaille avec les nombres x n'a pas besoin d'être la même que la vitesse à laquelle ils ont été enregistrés. En d'autres mots, l'espace (représentant une quantité de temps) entre chaque cercle peut être étiré ou compressé. Donc, si l'ordinateur travaille plus rapidement avec les valeurs x que la vitesse originale, cela aura l'effet d'écraser les cercles ensemble ce qui résultera en un bip sonnant plus aigu. Cela va également rendre le bip plus court étant donné que nous allons naviguer plus rapidement au travers des cercles. Cela est démontré dans la figure E.

en: Finally, one last thing to know is that a mathematician called Fourier proved that any sound is actually lots and lots of sine waves all combined together. Therefore, when we compress and stretch any recorded sound we're actually stretching and compressing many sine waves all at the same time in exactly this manner.
fr: Finalement, une dernière chose à savoir est qu'un mathématicien appelé Fourier a prouvé que tout son est beaucoup d'ondes sinusoïdales combinées toutes ensemble. Donc, quand nous compressons et étirons quelconque son enregistré, nous étirons et compressons plusieurs ondes sinusoïdales ensemble en même temps de cette manière exactement.

en: Pitch Bending
fr: Effet Pitch Bend

en: As we've seen, using a faster rate will make the sound higher in pitch and a slower rate will make the sound lower in pitch. A very simple and useful trick is to know that doubling the rate actually results in the pitch being an octave higher and inversely halving the rate results in the pitch being an octave lower. This means that for melodic samples, playing it alongside itself at double/half rates actually sounds rather nice:
fr: Comme nous l'avons vu, utiliser une vitesse plus rapide rendra le son plus aigu et une vitesse plus lente rendra le son plus grave. Une astuce très simple et utile est de savoir que doubler la vitesse résultera en un son qui est une octave plus aiguë et inversement, diminuer la vitesse de moitié rendra le son une octave plus grave. Cela veut dire que, pour les échantillons mélodiques, les faire jouer en même temps que lui-même à une vitesse doublée ou divisée de moitié sonne plutôt bien :

en: However, what if we just want to alter the rate such that the pitch goes up one semitone (one note up on a piano)? Sonic Pi makes this very easy via the `rpitch:` opt:
fr: Cependant, comment devons-nous faire si nous voulons modifier la vitesse afin que le son soit un demi-ton plus aigu (une note plus aiguë sur le piano) ? Sonic Pi rend cela très facile avec l'option `rpitch:` :

en: If you take a look at the log on the right, you'll notice that an `rpitch:` of `3` actually corresponds to a rate of `1.1892` and a `rpitch:` of `7` corresponds to a rate of `1.4983`. Finally, we can even combine `rate:` and `rpitch:` opts:
fr: Si vous regardez le journal à droite, vous remarquerez qu'un `rpitch:` de `3` correspond en fait à un rythme de `1.1892` et qu'un `rpitch:` de `7` correspond à un rythme de `1.4983`. Finalement, nous pouvons même combiner les options `rate:` et `rpitch:` :

en: Let's take a look at a simple piece which combines these ideas. Copy it into an empty Sonic Pi buffer, hit play, listen to it for a while and then use it as a starting point for your own piece. See how much fun it is to manipulate the playback rate of samples. As an added exercise try recording your own sounds and play around with the rate to see what wild sounds you can make.
fr: Jetons un coup d’œil à un morceau simple qui combine ces idées. Copiez-le dans un tampon Sonic Pi vide, pressez jouer, écoutez-le un moment et ensuite utilisez-le comme point de départ pour votre propre morceau. Voyez comment c'est plaisant de manipuler la vitesse de lecture des échantillons. En tant qu'exercice supplémentaire, essayez d'enregistrer vos propres sons et de jouer avec la vitesse pour voir quels sons fous vous pouvez faire.

en: A.18 Sound Design - Additive Synthesis
fr: A.18 Design du son - Synthèse additive

en: Additive Synthesis
fr: Synthèse additive

en: This is the first of a short series of articles on how to use Sonic Pi for sound design. We'll be taking a quick tour of a number of different techniques available for you to craft your own unique sound. The first technique we'll look at is called *additive synthesis*. This may sound complicated - but if we expand each word slightly the meaning pops right out. Firstly, additive means a combination of things and secondly synthesis means to create sound. Additive synthesis therefore means nothing more complicated than *combining existing sounds to create new ones*. This synthesis technique dates back a very long time - for example, pipe organs in the middle ages had lots of slightly different sounding pipes which you could enable or disable with stops. Pulling out the stop for a given pipe 'added it to the mix' making the sound richer and more complex. Now, let's see how we can pull out all the stops with Sonic Pi.
fr: Ceci est le premier d'une courte série d'articles sur comment utiliser Sonic Pi pour le design du son. Nous allons faire un tour rapide d'un nombre de techniques différentes disponibles pour fabriquer votre propre son unique. La première technique que nous allons regarder est appelée *synthèse additive*. Cela peut sembler compliqué - mais si nous développons chaque mot légèrement, la signification en ressort rapidement. Premièrement, additif signifie une combinaison de choses et deuxièmement, synthèse signifie de créer un son. Ainsi, la synthèse additive ne signifie rien de plus compliqué que *combiner des sons existants pour en créer des nouveaux*. Cette technique de synthèse date de très longtemps - par exemple, les orgues du Moyen Âge avaient beaucoup de tuyaux sonnant légèrement différents que vous pouviez activer ou désactiver avec des arrêts. Tirer sur l'arrêt pour un certain tuyau 'l'ajoutait au mélange' ce qui rendait le son plus riche et complexe. Maintenant, voyons comment nous pouvons tirer tous les arrêts avec Sonic Pi.

en: Simple Combinations
fr: Combinaisons simples

en: Let's start with the most basic sound there is - the humble pure-toned sine wave:
fr: Commençons avec le son le plus basique qu'il existe - l'humble onde sinusoïdale aux tons purs :

en: Now, let's see how this sounds combined with a square wave:
fr: Maintenant, voyons comment cela sonne combiné avec une onde carrée :

en: Notice how the two sounds combine to form a new, richer sound. Of course, we don't have to stop there, we can add as many sounds as we need. However, we need to be careful with how many sounds we add together. Just like when we mix paints to create new colours, adding too many colours will result in a messy brown, similarly - adding too many sounds together will result in a muddy sound.
fr: Remarquez comment les deux sons se combinent pour former un nouveau son plus riche. Bien sûr, nous n'avons pas à nous arrêter là, nous pouvons ajouter autant de sons que nous avons besoin. Cependant, nous devons être prudent avec combien de sons nous ajoutons ensemble. Tout comme lorsque nous mélangeons des peintures ensembles pour créer de nouvelles couleurs, ajouter trop de couleurs résultera en un brun laid, similairement - ajouter trop de sons ensemble résultera en un son boueux.

en: Blending
fr: Mélange

en: Let's add something to make it sound a little brighter. We could use a triangle wave at an octave higher (for that high bright sound) yet only play it at amp `0.4` so it adds something extra to the sound rather than taking it over:
fr: Ajoutons quelque chose pour le faire sonner un peu plus clair. Nous pourrions utiliser une onde triangulaire à une octave supérieure ( pour ce haut son clair) encore le jouer seulement à un amplificateur de `0.4` pour qu'il ajoute quelque chose d'extra au son au lieu de le remplacer :

en: Now, try creating your own sounds by combining 2 or more synths at different octaves and amplitudes. Also, note that you can play around with each synth's opts to modify each source sound before it is mixed in for even more combinations of sounds.
fr: Maintenant, essayez de créer vos propres sons en combinant 2 synthés ou plus à des octaves et des amplitudes différentes. Également, notez que vous pouvez jouer avec les options de chaque synthé en modifiant chaque source avant qu'elle soit mélangée pour encore plus de combinaisons de sons.

en: Detuning
fr: Désaccordage

en: So far, when combining our different synths we've used either the same pitch or switched octave. How might it sound if we didn't stick to octaves but instead chose a slightly higher or lower note? Let's try it:
fr: Jusqu'à maintenant, lorsque nous combinons nos différents synthés nous avons utilisé soit le même ton ou une octave changée. Comment cela peut-il sonner si nous ne nous n'en tenons pas qu'aux octaves et que nous choisissons à la place une note légèrement plus aiguë ou grave ? Essayons-le :

en: If we detune our square waves by 0.7 notes we hear something that perhaps doesn't sound in tune or correct - a 'bad' note. However, as we move closer to 0 it will sound less and less out of tune as the pitches of the two waves get closer and more similar. Try it for yourself! Change the `detune:` opt value from `0.7` to `0.5` and listen to the new sound. Try `0.2`, `0.1`, `0.05`, `0`. Each time you change the value, take a listen and see if you can hear how the sound is changing. Notice that low detune values such as `0.1` produce a really nice 'thick' sound, with both slightly different pitches interacting with each other in interesting, often surprising, ways.
fr: Si nous désaccordons nos ondes carrées par 0.7 note, nous entendrons quelque chose qui ne sonnera pas accordé ou correct - une 'mauvaise' note. Cependant, en se rapprochant de 0, cela va sonner de moins en moins en désaccord alors que les tons des deux ondes se rapprochent et sont plus similaires. Essayez-le par vous-même ! Changer la valeur de l'option `detune:` de `0.7` à `0.5` et écoutez le nouveau son. Essayer `0.2`, `0.1`, `0.05`, `0`. Chaque fois que vous changez la valeur, écoutez et voyez si vous êtes capables de déterminer comment le son change. Remarquez que les valeurs basses de désaccordage comme `0.1` produisent un très beau son `dense`, avec deux tons différents qui interagissent l'un avec l'autre de manière intéressante, parfois surprenante.

en: Some of the built-in synths already include a detune option that does exactly this in one synth. Try playing with the `detune:` opt of `:dsaw`, `:dpulse` and `:dtri`.
fr: Certains des synthés intégrés proposent déjà une option de "désaccord" qui fait exactement cela en un seul synthé. Essayer de jouer avec l'option de `detune:` de `:dsaw`, `:dpulse` et `:dtri`.

en: Amplitude shaping
fr: Façonner l'amplitude

en: Another way we can finely craft our sound is to use a different envelope and options for each synth trigger. For example this will allow you to make some aspects of the sound percussive and other aspects ring out for a period of time.
fr: Une autre manière de fabriquer notre son finement est d'utiliser une enveloppe différente et des options pour chaque déclenchement de synthé. Par exemple, cela vous permettra de rendre certains aspects du son percutant et d'autres aspects résonner pour une période de temps.

en: In the example above I have mixed in a noisy percussive element to the sound along with some more persistent background rumbling. This was achieved firstly by using two noise synths with middling cutoff values (`90` and `100`) using short release times along with a noise with a longer release time but with a low cutoff value (which makes the noise less crisp and more rumbly.)
fr: Dans l'exemple ci-dessus, j'ai mélangé un élément de bruit percutant dans le son avec quelques grondements de fond plus persistants. Cela a été réalisé en utilisant deux bruits de synthés avec des valeurs (`90` et `100`) de coupures de milieu en utilisant de courts repos avec un plus long temps de repos mais avec une basse valeur de coupure (ce qui rend le son moins impeccable et plus grondant.)

en: Let's combine all these techniques to see if we can use additive synthesis to re-create a basic bell sound. I've broken this example into four sections. Firstly we have the 'hit' section which is the initial onset part of the bell sound - so uses a short envelope (e.g. a `release:` of around `0.1`). Next we have the long ringing section in which I'm using the pure sound of the sine wave. Notice that I'm often increasing the note by roughly `12` and `24` which are the number of notes in one and two octaves. I have also thrown in a couple of low sine waves to give the sound some bass and depth. Finally, I used `define` to wrap my code in a function which I can then use to play a melody. Try playing your own melody and also messing around with the contents of the `:bell` function until you create your own fun sound to play with!
fr: Combinons toutes ces techniques pour voir si nous pouvons utiliser la synthèse additive pour recréer un son de cloche basique. J'ai découpé cet exemple en quatre sections. Premièrement, nous avons la section `hit` qui est la partie d'initialisation du son de cloche - alors utiliser une enveloppe courte (c.a.d une `release:` autour de `0.1`). Ensuite, nous avons la longue section de tintement dans laquelle j'utilise le son pur de l'onde sinusoïdale. Remarquez que j'augmente souvent la note par environ `12` et `24` qui sont les nombres des notes dans une et deux octaves. J'ai également mis quelques ondes sinusoïdales graves pour donner plus de basses et de profondeur au son. Finalement, j'ai utilisé `define` pour regrouper mon code dans une fonction que je peux utiliser pour jouer une mélodie. Essayer de jouer votre propre mélodie et également de vous amuser avec le contenu de la fonction `:bell` jusqu'à ce que vous ayez créé votre propre son de délire avec lequel jouer !

en: 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
fr: define :bell do |n|
      # Ondes en triangle pour la "percussion"
      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
      # Ondes en forme sinusoïdales pour le "tintement"
      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
      # Ondes sinusoïdales lentes pour les basses
      synth :sine, note : n - 11.8, release : 2
      synth :sine, note : n - 12, release : 2
    end
    # joue une melodie avec notre nouvelle cloche
    bell :e3
    sleep 1
    bell :c2
    sleep 1
    bell :d3
    sleep 1
    bell :g2

en: A.19 Sound Design - Subtractive Synthesis
fr: A.19 Design du son - Synthèse soustractive

en: Subtractive Synthesis
fr: Synthèse soustractive

en: This is the second in a series of articles on how to use Sonic Pi for sound design. Last month we looked at additive synthesis which we discovered was the simple act of playing multiple sounds at the same time to make a new combined sound. For example we could combine different sounding synths or even the same synth at different pitches to build a new complex sound from simple ingredients. This month we'll look at a new technique commonly called *subtractive synthesis* which is simply the act of taking an existing complex sound and removing parts of it to create something new. This is a technique which is commonly associated with the sound of analog synthesisers of the 1960s and 1970s but also with the recent renaissance of modular analog synths through popular standards such as Eurorack.
fr: Ceci est le deuxième d'une série d'articles sur comment utiliser Sonic Pi pour le design du son. Le mois dernier, nous avons étudié la synthèse additive dont nous avons découvert qu'il s'agissait simplement de jouer de multiples sons en même temps pour fabriquer un nouveau son combiné. Par exemple, nous pourrions combiner des synthés qui sonnent différemment ou même reprendre le même synthé avec plusieurs hauteurs pour construire un nouveau son complexe à partir d'ingrédients simples. Ce mois-ci, nous allons étudier une nouvelle technique communément appelée "synthèse soustractive" qui est le fait de prendre un son existant complexe et d'en retirer certaines parties pour créer quelque chose de nouveau. Il s'agit d'une technique qui est associée couramment avec le son des synthétiseurs analogiques des années 1960 et 1970, mais également avec la renaissance récente des synthétiseurs analogiques modulaires à travers des standards populaires comme Eurorack.

en: Despite this sounding like a particularly complicated and advanced technique, Sonic Pi makes it surprisingly simple and easy - so let's dive right in.
fr: Même si cela semble être une technique particulièrement compliquée et avancée, Sonic Pi rend cela étonnamment facile et simple - alors commençons dès maintenant.

en: Complex Source Signal
fr: Signal source complexe

en: For a sound to work well with subtractive synthesis, it typically needs to be fairly rich and interesting. This doesn't mean we need something hugely complex - in fact, just a standard `:square` or `:saw` wave will do:
fr: Pour qu'un son se travaille bien avec la synthèse soustractive, il faut habituellement qu'il soit riche et intéressant. Cela ne veut pas dire que nous avons besoin de quelque chose d'extrêmement complexe - en fait, juste une onde standard `:square` ou `:saw` fonctionnera :

en: Notice that this sound is already pretty interesting and contains many different frequencies above `:e2` (the second E on a piano) which add to create the timbre. If that didn't make much sense to you, try comparing it with the `:beep`:
fr: Notez que ce son est déjà assez intéressant et contient plusieurs fréquences différentes au-dessus de `:e2` (le second E sur un piano) ce qui aide à créer le timbre. Si cela ne fait pas trop de sens pour vous, essayez de le comparer avec le `:beep` :

en: As the `:beep` synth is just a sine wave, you'll hear a much purer tone and only at `:e2` and none of the high crispy/buzzy sounds which you heard in the `:saw`. It's this buzziness and variation from a pure sine wave that we can play with when we use subtractive synthesis.
fr: Étant donné que le synthé `:beep` est seulement une onde sinusoïdale, vous entendrez une tonalité beaucoup plus pure, seulement `:e2`, et rien des sons hauts grinçants que vous avez entendu avec `:saw`. C'est cet effet et la variation d'une onde sinusoïdale pure avec lesquels nous pouvons jouer en utilisant la synthèse soustractive.

en: Once we have our raw source signal, the next step is to pass it through a filter of some kind which will modify the sound by removing or reducing parts of it. One of the most common filters used for subtractive synthesis is something called a low pass filter. This will allow all the low parts of the sound through but will reduce or remove the higher parts. Sonic Pi has a powerful yet simple to use FX system that includes a low pass filter, called `:lpf`. Let's play with it:
fr: Une fois que nous avons notre signal source, la prochaine étape est d'appliquer un filtre d'un type qui modifiera le son en retirant ou en réduisant des parties de celui-ci. L'un des filtres les plus communs utilisés pour la synthèse soustractive est celui appelé le filtre passe-bas. Cela permet à toutes les parties basses du son de passer, mais il va réduire ou retirer les parties plus hautes. Sonic Pi a un système d'effets puissant, mais simple, à utiliser qui inclut un filtre passe-bas, appelé `:lpf`. Jouons avec :

en: If you listen carefully you'll hear how some of that buzziness and crispiness has been removed. In fact, all the frequencies in the sound above note `100` have been reduced or removed and only the ones below are still present in the sound. Try changing that `cutoff:` point to lower notes, say `70` and then `50` and compare the sounds.
fr: Si vous écoutez attentivement, vous entendrez comment ces grincements ont été retirés. En fait, toutes les fréquences dans le son qui sont au-dessus de la note `100` ont été réduites ou retirées et seulement celles en dessous sont toujours présentes dans le son. Essayez de changer ce point `cutoff:` à des notes plus basses, disons `70` puis `50` et comparer les sons.

en: Of course, the `:lpf` isn't the only filter you can use to manipulate the source signal. Another important FX is the high pass filter referred to as `:hpf` in Sonic Pi. This does the opposite to `:lpf` in that it lets the high parts of the sound through and cuts off the low parts.
fr: Évidemment, le `:lpf` n'est pas le seul filtre que vous pouvez utiliser pour manipuler le signal source. Un autre effet important est le filtre passe-haut, dénommé `:hpf` dans Sonic Pi. Il fait le contraire de `:lpf` en laissant les parties hautes du son passées et en coupant les parties basses.

en: Notice how this sounds much more buzzy and raspy now that all the low frequency sounds have been removed. Play around with the cutoff value - notice how lower values let more of the original bass parts of the source signal through and higher values sound increasingly tinny and quiet.
fr: Notez comment ce son est beaucoup plus grinçant maintenant que toutes les fréquences basses du son ont été retirées. Jouez avec la valeur de coupure - remarquez comment des valeurs plus basses laissent plus de parties basses du son original source passer et que les valeurs plus hautes sonnent plus petites et silencieuses.

en: Low Pass Filter
fr: Filtre passe-bas

en: ![Varying amounts of low pass filtering](../../../etc/doc/images/tutorial/articles/A.19-subtractive-synthesis/subtractive-synthesis-waveforms.png)
fr: ![Variation les quantités de filtre passe-bas en cours](../../../etc/doc/images/tutorial/articles/A.19-subtractive-synthesis/subtractive-synthesis-waveforms.png)

en: The low pass filter is such an important part of every subtractive synthesis toolkit that it's worth taking a deeper look at how it works. This diagram shows the same sound wave (the `:prophet` synth) with varying amounts of filtering. At the top, section A shows the audio wave with no filtering. Notice how the wave form is very pointy and contains lots of sharp edges. It is these hard, sharp angles that produce the high crispy/buzzy parts of the sound. Section B shows the low pass filter in action - notice how it is less pointy and more rounded than the wave form above. This means that the sound will have fewer high frequencies giving it a more mellow rounded feel. Section C shows the low pass filter with a fairly low cutoff value - this means that even more of the high frequencies have been removed from the signal resulting in an even softer, rounder wave form. Finally, notice how the size of the wave form, which represents the amplitude, decreases as we move from A to C. Subtractive synthesis works by removing parts of the signal which means that the overall amplitude is reduced as the amount of filtering that is taking place increases.
fr: Le filtre passe-bas est une partie si importante de chaque boîte à outils de synthèse soustractive qu'il vaut la peine d'examiner de plus près comment il fonctionne. Ce diagramme montre la même onde sonore (le synthé `:prophet`) avec une quantité de filtrages variés. En haut, la section A montre l'onde audio sans filtrage. Remarquez comment la forme d'onde est très pointue et contient beaucoup d'arêtes vives. Ce sont ces angles durs et aigus qui produisent les composantes aiguës croustillantes / bourdonnantes du son. La section B montre le filtre passe-bas en action - remarquez comment il est moins pointu et plus arrondi que la forme d'onde ci-dessus. Cela signifie que le son aura moins de hautes fréquences, ce qui lui donnera une sensation arrondie plus douce. La section C montre le filtre passe-bas avec une valeur de coupure assez faible - cela signifie que davantage de hautes fréquences ont été supprimées du signal, ce qui donne une forme d'onde encore plus douce et plus ronde. Enfin, notez comment la taille de la forme d'onde, qui représente l'amplitude, diminue lorsque nous passons de A à C. La synthèse soustractive fonctionne en supprimant des parties du signal, ce qui signifie que l'amplitude globale est réduite en fonction de la quantité de filtrage appliquée.

en: Filter Modulation
fr: Filtre de modulation

en: So far we've just produced fairly static sounds. In other words, the sound doesn't change in any way for the entirety of its duration. Often you might want some movement in the sound to give the timbre some life. One way to achieve this is via filter modulation - changing the filter's options through time. Luckily Sonic Pi gives you powerful tools to manipulate an FX's opts through time. For example, you can set a slide time to each modulatable opt to specify how long it should take for the current value to linearly slide to the target value:
fr: Jusqu'à maintenant, nous avons produit des sons assez statiques. En d'autres mots, le son ne change en aucune façon pour toute sa durée. Souvent, vous voudrez peut-être donner du mouvement à un son afin de donner de la vie à son timbre. Une façon d'accomplir cela est avec le filtre de modulation - en changeant les options du filtre au travers du temps. Heureusement, Sonic Pi vous offre des outils puissants pour manipuler les options d'un FX au fil du temps. Par exemple, vous pouvez définir un temps de glissement à chaque option modulable pour spécifier combien de temps cela devrait-il prendre de glisser de la valeur actuelle vers la valeur cible :

en: Let's take a quick look at what's going on here. Firstly we start an `:lpf` FX block as normal with an initial `cutoff:` of a low `50`. However, the first line also finishes with the strange `|fx|` at the end. This is an optional part of the `with_fx` syntax which allows you to directly name and control the running FX synth. Line 2 does exactly this and controls the FX to set the `cutoff_slide:` opt to 3 and the new target `cutoff:` to be `130`. The FX will now start sliding the `cutoff:` opt's value from `50` to `130` over a period of 3 beats. Finally we also trigger a source signal synth so we can hear the effect of the modulated low pass filter.
fr: Jetons un coup d’œil rapide à ce qui se passe ici. Premièrement, nous commençons avec un bloc FX `:lpf` avec un `cutoff:` initial d'un très bas `20`. Cependant, la première ligne termine également avec l'étrange `|fx|` à la fin. C'est une partie optionnelle de la syntaxe `with_fx` qui vous permet de nommer directement et de contrôler le synthé FX qui s'exécute. La ligne 2 fait exactement cela et contrôle le FX pour définir la valeur de l'option `cutoff_slide:` à 4 et la nouvelle cible de `cutoff:` à `130`. Ce FX commencera donc à glisser la valeur de l'option `cutoff:` de `50` à `130` sur une période de trois temps. Finalement, nous déclenchons également un synthé de signal source pour que nous puissions entendre l'effet du filtre passe-bas modulé.

en: This is just a very basic taster of what's possible when you use filters to modify and change a source sound. Try playing with Sonic Pi's many built-in FX to see what fun sounds you can design. If your sound feels too static, remember you can start modulating the options to create some movement.
fr: Ceci est seulement un avant-goût très basique de ce qui est possible quand vous utilisez les filtres pour modifier et changer un son source. Essayez de jouer avec les nombreux effets inclus dans Sonic Pi pour voir quels sons fous vous pouvez concevoir. Si votre son semble trop statique, rappelez-vous que vous pouvez commencer à moduler les options pour créer du mouvement.

en: Let's finish by designing a function which will play a new sound created with subtractive synthesis. See if you can figure out what's going on here - and for the advanced Sonic Pi readers out there - see if you can work out why I wrapped everything inside a call to `at` (please send answers to @samaaron on Twitter).
fr: Terminons en créant une fonction qui jouera un nouveau son créé avec la synthèse soustractive. Voyez si vous pouvez déterminer ce qui se passe - et pour les lecteurs avancés de Sonic Pi - voyez si vous pouvez trouver pourquoi j'ai tout enveloppé à l'intérieur d'un appel `at` (s'il-vous-plait envoyez vos réponses à @samaaron sur Twitter).

en: A.20 Creative coding in the classroom with Sonic Pi
fr: A.20 Codage créatif en classe avec Sonic Pi

en: Creative coding in the classroom with Sonic Pi
fr: Codage créatif en classe avec Sonic Pi

en: (This article was published in [issue 9 of the Hello World Magazine](https://helloworld.raspberrypi.org/issues/9))
fr: (Cet article a été publié en anglais dans [le numéro 9 du magazine Hello World](https://helloworld.raspberrypi.org/issues/9))

en: 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.
fr: Le code est l'un des médias les plus créatifs que les humains aient créés. Les symboles initialement obscurs des parenthèses et des lambdas ne sont pas seulement profondément enracinés dans les sciences et les mathématiques, ils sont les plus proches que nous ayons réussi à obtenir pour jeter le même genre de sorts magiques que Gandalf et Harry Potter. Je crois que cela constitue un moyen puissant d'engagement dans nos espaces d'apprentissage. Grâce à la magie du code, nous sommes en mesure d'évoquer des histoires et des expériences d'apprentissage qui ont un sens pour chacun d'entre nous.

en: 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?
fr: Nous sommes entourés d'expériences magiques. Du tour de passe-passe d'un magicien de scène faisant disparaître le ballon dans les airs, à l'émerveillement de voir son groupe préféré se produire sur une grande scène. Ce sont ces moments magiques qui nous inspirent à prendre un livre de magie et apprendre le French Drop ou pour commencer à jouer des accords de puissance sur une vieille guitare. Comment pourrions-nous créer un sens de l'émerveillement aussi profond et durable qui motivera les gens à pratiquer et à apprendre les bases de la programmation ?

en: Musical Engines and Notation
fr: Moteurs musicaux et notation

en: 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:
fr: Les histoires de la musique et de l'informatique sont intimement liées depuis la création des machines informatiques, ou "moteurs", comme on appelait le puissant moteur analytique de Charles Babbage. En 1842, la mathématicienne Ada Lovelace, qui a travaillé en étroite collaboration avec Babbage, a vu le potentiel créatif de ces moteurs. Alors que ces premiers moteurs avaient été conçus à l'origine pour résoudre avec précision des problèmes mathématiques difficiles, Ada rêvait de faire de la musique avec eux :

en: "..the engine might compose elaborate and scientific pieces of music of any degree of complexity or extent." Ada Lovelace, 1842.
fr: "...le moteur pourrait composer des morceaux de musique élaborés et scientifiques de n'importe quel degré de complexité ou d'ampleur." Ada Lovelace, 1842.

en: 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.
fr: Bien sûr, aujourd'hui en 2019, une grande partie de notre musique, quel que soit le genre, a été composée, produite ou masterisée avec un ordinateur numérique. Le rêve d'Ada est devenu réalité. Il est même possible de remonter encore plus loin dans l'histoire. Si vous voyez le codage comme l'art d'écrire des séquences de symboles spéciaux qui ordonnent à un ordinateur de faire des choses spécifiques, alors la composition musicale est une pratique très similaire. Dans la musique occidentale, les symboles sont des points noirs placés sur une portée de lignes qui indiquent au musicien quelles notes jouer et quand. Il est intéressant de noter que si l'on remonte les racines de la notation musicale occidentale jusqu'au moine bénédictin italien Guido d'Arezzo, on constate que le système de points et de lignes utilisé par les orchestres modernes n'est qu'un des nombreux systèmes de notation sur lesquels il a travaillé. Certains des autres systèmes étaient beaucoup plus proches de ce que nous pourrions considérer aujourd'hui comme un code.

en: In education, magical meaningful experiences with computers and programming languages have been explored since the late '60s. Computer education pioneers Seymour Papert, Marvin Minsky and Cynthia Solomon explored simple Lisp-based languages that moved pens over large pieces of paper. With just a few simple commands it was possible to program the computer to draw any picture. They even experimented by extending their Logo language from drawing to music. Papert wrote about learning through experiencing the reconstruction of knowledge rather than its transmission. Getting people to play with things directly was an important part of his group's work.
fr: Dans le domaine de l'éducation, les expériences magiques et significatives avec les ordinateurs et les langages de programmation ont été explorées depuis la fin des années 60. Les pionniers de l'éducation informatique Seymour Papert, Marvin Minsky et Cynthia Solomon ont exploré des langages simples basés sur le langage Lisp qui permettaient de déplacer des stylos sur de grandes feuilles de papier. Avec quelques commandes simples, il était possible de programmer l'ordinateur pour qu'il dessine n'importe quelle image. Ils ont même expérimenté en étendant leur langage Logo du dessin à la musique. Papert a écrit sur l'apprentissage par l'expérience de la reconstruction du savoir plutôt que de sa transmission. Amener les gens à jouer directement avec les choses était une partie importante du travail de son groupe.

en: Sonic Pi Performances
fr: Performances Sonic Pi

en: ![Jylda Live Coding in the Sage Gateshead](../../../etc/doc/images/tutorial/articles/A.20-creative-coding-in-the-classroom/jylda-small.png) Jylda and Sam Aaron perform at the Thinking Digital Conference in the Sage Gateshead. Photo credit: TyneSight Photos.
fr: ![Jylda Live Coding dans le Sage Gateshead](../../../etc/doc/images/tutorial/articles/A.20-creative-coding-in-the-classroom/jylda-small.png) Jylda et Sam Aaron performant à la conférence "the Thinking Digital Conference" dans le "Sage Gateshead". Crédit photo : TyneSight Photos.

en: 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.
fr: Sonic Pi a été utilisé pour se produire dans un grand nombre de lieux tels que des salles d'école, des boîtes de nuit, sur des scènes extérieures de festivals de musique, des chapelles d'université et des lieux de musique prestigieux. Par exemple, l'étonnant projet Convo qui a réuni 1000 enfants dans le Royal Albert Hall pour interpréter une nouvelle composition ambitieuse de la compositrice Charlotte Harding. La pièce a été écrite pour les instruments traditionnels, les chœurs, les percussions et le code Sonic Pi. L'artiste pop Jylda a également joué avec Sonic Pi dans le Sage Gateshead pour la conférence Thinking Digital, où elle a créé un remix improvisé unique en direct de sa chanson Reeled.

en: ![Sonic Pi in the Royal Albert Hall](../../../etc/doc/images/tutorial/articles/A.20-creative-coding-in-the-classroom/convo-small.png) Sonic Pi used as one of the instruments as part of Convo at the Royal Albert Hall. Photo credit: Pete Jones.
fr: ![Sonic Pi dans le Royal Albert Hall](../../../etc/doc/images/tutorial/articles/A.20-creative-coding-in-the-classroom/convo-small.png Sonic Pi utilisé comme un des instruments pour le Convo au Royal Albert Hall. Crédit photo : Pete Jones.

en: Live coding in the classroom
fr: Codage en direct en classe

en: 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.
fr: Sonic Pi est un outil de création et de performance musicale basé sur le code qui s'appuie sur toutes ces idées. Contrairement à la majorité des logiciels éducatifs informatiques, il est à la fois assez simple à utiliser pour l'éducation et assez puissant pour les professionnels. Il a été utilisé pour se produire dans des festivals de musique internationaux, pour composer dans des styles variés allant du classique au métal lourd en passant par l'EDM, et a même fait l'objet d'une critique dans le magazine Rolling Stone. Il compte une communauté diversifiée de plus d'un million et demi de codeurs live, aux parcours variés, qui apprennent et partagent tous leurs idées et leurs pensées par le biais du code. Il est libre et gratuit à télécharger pour Mac, PC et Raspberry Pi et comprend un tutoriel convivial qui suppose que vous ne connaissez rien au code ou à la musique.

en: 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.
fr: Sonic Pi a été conçu à l'origine comme une réponse au nouveau programme d'informatique britannique publié en 2014. L'objectif était de trouver une manière motivante et amusante d'enseigner les bases de la programmation. Il s'avère qu'il y a beaucoup de points communs et qu'il est très amusant d'expliquer le séquençage comme une mélodie, l'itération comme un rythme, les conditionnels comme une variété musicale. J'ai développé les concepts initiaux et les premières itérations de la plateforme avec Carrie Anne Philbin, qui a apporté le point de vue d'un enseignant au projet. Depuis lors, Sonic Pi a connu des améliorations itératives grâce au retour d'information obtenu en observant les apprenants et en collaborant directement avec les éducateurs dans la classe. L'une des principales philosophies de conception était de ne jamais ajouter une caractéristique qui ne pourrait pas être facilement enseignée à un enfant de 10 ans. Cela signifiait que la plupart des idées devaient être fortement affinées et retravaillées jusqu'à ce qu'elles soient suffisamment simples. Rendre les choses simples tout en les gardant puissantes reste la partie la plus difficile du projet.

en: 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.
fr: Afin de fournir la motivation magique, la conception de Sonic Pi ne s'est jamais limitée à une pure focalisation sur l'éducation. L'idéal serait que des musiciens et des interprètes célèbres utilisent Sonic Pi comme instrument standard aux côtés des guitares, de la batterie, du chant, des synthés, des violons, etc. Ces interprètes serviraient alors de modèles de motivation démontrant le potentiel créatif du code. Pour que cela soit possible, il a donc fallu consacrer suffisamment d'attention et d'efforts pour en faire un instrument puissant tout en le gardant suffisamment simple pour que des enfants de 10 ans puissent s'en saisir. En plus des éducateurs, j'ai également travaillé directement avec différents artistes dans des classes, des galeries d'art, des studios et des lieux de travail au début du développement de Sonic Pi. Cela m'a permis d'obtenir un retour d'information essentiel qui a permis à Sonic Pi de grandir et, en fin de compte, de s'épanouir en tant qu'outil d'expression créative.

en: 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.
fr: Cette double orientation vers l'éducation et les musiciens professionnels a eu un certain nombre d'effets secondaires passionnants et inattendus. Plusieurs des fonctionnalités sont bénéfiques pour les deux groupes. Par exemple, beaucoup d'efforts ont été déployés pour rendre les messages d'erreur plus conviviaux et utiles (plutôt qu'un énorme fouillis de jargon compliqué). Cela s'avère très utile lorsque vous écrivez un bogue en vous produisant devant des milliers de personnes. De plus, des fonctionnalités telles que la lecture d'échantillons audio de qualité studio, l'ajout d'effets audio, l'accès à l'audio en direct depuis le microphone, tout cela s'avère rendre l'expérience d'apprentissage plus amusante, plus gratifiante et finalement plus significative.

en: 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.
fr: La communauté Sonic Pi continue de s'agrandir et de partager d'étonnantes compositions de code, des plans de cours, des algorithmes musicaux et bien plus encore. La plupart de ces échanges se font sur notre forum amical in_thread (in-thread.sonic-pi.net) qui accueille un groupe très diversifié de personnes comprenant des éducateurs, des musiciens, des programmeurs, des artistes et des fabricants. C'est une véritable joie de voir des gens apprendre à utiliser du code pour s'exprimer de manière nouvelle et inspirer en cela d'autres personnes à faire de même.

en: Some fun capabilities
fr: Quelques capacités amusantes

en: 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.
fr: Du point de vue de l'informatique, Sonic Pi vous fournit les éléments de base pour vous enseigner les notions de base telles qu'elles figurent dans le programme d'études britannique, comme le séquençage, l'itération, les conditionnels, les fonctions, les structures de données, les algorithmes, etc. Toutefois, il s'appuie également sur un certain nombre de concepts importants et pertinents qui ont été adoptés dans l'industrie courante, tels que la concurrence, les événements, la correspondance de modèles, l'informatique distribuée et le déterminisme - tout en gardant les choses suffisamment simples pour les expliquer à un enfant de 10 ans.

en: Getting started is as simple as:
fr: Débuter est aussi simple que cela :

en: A melody can be constructed with one more command, sleep:
fr: Une mélodie peut être construite avec une commande supplémentaire, sleep :

en: 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.
fr: Dans cet exemple, nous jouons la note 70 (environ la 70ème note d'un piano), nous attendons une seconde, nous jouons la note 72, nous attendons une demi-seconde et nous jouons ensuite la note 75. Ce qui est intéressant ici, c'est qu'avec seulement deux commandes, nous avons accès à presque toute la notation occidentale (quelles notes jouer et quand) et les apprenants peuvent coder n'importe quelle mélodie qu'ils ont déjà entendue. Cela conduit à une grande variété de résultats expressifs tout en se concentrant sur le même concept informatique : le séquençage dans ce cas.

en: 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:
fr: En s'inspirant du monde de la musique professionnelle, nous pouvons également reproduire n'importe quel son enregistré. Sonic Pi peut lire n'importe quel fichier audio sur votre ordinateur, mais possède également un certain nombre de sons intégrés pour faciliter la mise en route :

en: 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:
fr: Ce code permettra de rejouer le break de batterie qui était un pilier du hip-hop des origines, de la drum & bass et de la jungle. Par exemple, un certain nombre d'artistes des débuts du hip-hop ont joué ce break de batterie à mi-vitesse pour lui donner un sentiment plus décontracté :

en: 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:
fr: Dans les années 90, un certain nombre de scènes musicales ont éclaté grâce aux nouvelles technologies qui ont permis aux artistes de démonter des breaks de batteries comme celui-ci et de les remonter dans un ordre différent. Par exemple :

en: In this example we introduce a basic loop called :jungle which picks a random drum hit from our audio sample, waits for an eighth of a second and then picks another drum hit. This results in an endless stream of random drum beats to dance to whilst you experience what a loop is.
fr: Dans cet exemple, nous introduisons une boucle de base appelée : jungle qui prend un coup de batterie aléatoire dans notre échantillon audio, attend un huitième de seconde et prend ensuite un autre coup de batterie. Il en résulte un flux infini de coups de batterie aléatoires sur lesquels vous pouvez danser tout en découvrant ce qu'est une boucle.

en: B Essential Knowledge
fr: B Connaissances essentielles

en: Essential Knowledge
fr: Connaissances essentielles

en: This section will cover some very useful - in fact *essential* - knowledge for getting the most out of your Sonic Pi experience.
fr: Cette section va couvrir des connaissances très utiles - en vérité *essentielles* - pour obtenir le meilleur de votre expérience de Sonic Pi.

en: We'll cover how to take advantage of the many keyboard shortcuts available to you, how to share your work and some tips on performing with Sonic Pi.
fr: Nous couvrirons comment prendre avantage des nombreux raccourcis clavier mis à votre disposition, comment partager votre travail et quelques trucs sur l'interprétation musicale avec Sonic Pi.

en: B.1 Using Shortcuts
fr: B.1 Utilisation des raccourcis

en: Using Shortcuts
fr: Utilisation des raccourcis

en: Sonic Pi is as much an instrument as a coding environment. Shortcuts can therefore make playing Sonic Pi much more *efficient and natural* - especially when you're playing live in front of an audience.
fr: Sonic Pi est tout autant un instrument qu'un environnement de programmation. Les raccourcis peuvent cependant rendre votre jeu avec Sonic Pi plus *efficace et naturel* - particulièrement quand vous jouez en direct devant un auditoire.

en: Much of Sonic Pi can be controlled through the keyboard. As you gain more familiarity working and performing with Sonic Pi, you'll likely start using the shortcuts more and more. *I personally touch-type* (I recommend you consider learning too) and find myself frustrated whenever I need to reach for the mouse as it slows me down. I therefore use all of these shortcuts on a very regular basis!
fr: La plus grande part de Sonic Pi peut être contrôlée au moyen du clavier. Au fur et à mesure que vous deviendrez plus familier dans la pratique et l'interprétation avec Sonic Pi, vous commencerez probablement à utiliser de plus en plus de raccourcis. *Personnellement, je tape sans regarder le clavier* (je recommande que vous appreniez à le faire aussi) et je me sens frustré quand j'ai besoin d'attraper la souris parce que ça me retarde. J'utilise donc tous ces raccourcis très régulièrement !

en: Therefore, if you learn the shortcuts, you'll learn to use your keyboard effectively and you'll be live coding like a pro in no time.
fr: Par conséquent, si vous apprenez les raccourcis, vous saurez utiliser efficacement votre clavier et vous coderez en direct comme un pro en peu de temps.

en: However, *don't try and learn them all at once*, just try and remember the ones you use most and then keep adding more to your practice.
fr: Toutefois, *n'essayez pas de les apprendre tous à la fois*, essayez et souvenez-vous simplement de ceux que vous utilisez le plus et continuez à en ajouter en supplément à votre pratique.

en: Consistency across Platforms
fr: Compatibilité entre plateformes

en: Imagine you're learning the clarinet. You'd expect all clarinets of all makes to have similar controls and fingerings. If they didn't, you'd have a tough time switching between different clarinets and you'd be stuck to using just one make.
fr: Imaginez que vous appreniez la clarinette. Vous vous attendriez à ce que toutes les clarinettes aient les mêmes contrôles et le même doigté. Si elles ne l'avaient pas, vous passeriez un moment pénible à basculer entre différentes clarinettes et vous seriez pris à rester toujours avec la même.

en: Unfortunately the three major operating systems (Linux, Mac OS X and Windows) come with their own standard defaults for actions such as cut and paste etc. Sonic Pi will try and honour these standards. However *priority is placed on consistency across platforms* within Sonic Pi rather than attempting to conform to a given platform's standards. This means that when you learn the shortcuts whilst playing with Sonic Pi on your Raspberry Pi, you can move to the Mac or PC and feel right at home.
fr: Malheureusement, les trois systèmes d'exploitation principaux (Linux, Mac OS X et Windows) se présentent avec leurs propres standards par défaut pour des actions telles que copier/coller etc. Sonic Pi va essayer d'honorer ces standards. Toutefois *la priorité est de favoriser la compatibilité entre plateformes* avec Sonic Pi plutôt que de tenter de se conformer aux standards d'une plateforme donnée. Ceci signifie que quand vous apprenez les raccourcis de jeu avec Sonic Pi sur votre Raspberry Pi, vous pouvez passer au Mac ou au PC et vous retrouver en terre connue.

en: Control and Meta
fr: "Control" et "Meta"

en: Part of the notion of consistency is the naming of shortcuts. In Sonic Pi we use the names *Control* and *Meta* to refer to the two main combination keys. On all platforms *Control* is the same. However, on Linux and Windows, *Meta* is actually the *Alt* key while on Mac *Meta* is the *Command* key. For consistency we'll use the term *Meta* - just remember to map that to the appropriate key on your operating system.
fr: Une part de la notion de constance est l'appellation des raccourcis. Dans Sonic Pi, nous utilisons les termes *Control* et *Meta* pour se référer aux deux combinaisons de touches principales. Sur toutes les plateformes *Control* (Ctrl) est identique. Toutefois, sur Linux et Windows, *Meta* est en réalité la touche *Alt* alors que sur Mac, *Meta* est la touche *Command* (Cmd). Pour la constance, nous utiliserons le terme *Meta* - rappelez-vous juste de le faire correspondre à la touche appropriée sur votre système d'exploitation.

en: Abbreviations
fr: Abréviations

en: To help keep things simple and readable, we'll use the abbreviations *C-* for *Control* plus another key and *M-* for *Meta* plus another key. For example, if a shortcut requires you to hold down both *Meta* and *r* we'll write that as `M-r`. The *-* just means "at the same time as."
fr: Pour conserver les choses simples et lisibles, nous utiliserons les abréviations *C-* pour *Control* plus une autre touche et *M-* pour *Meta* plus une autre touche. Par exemple, si un raccourci consiste à maintenir enfoncées à la fois *meta* et *r*, nous l'écrirons *M-r*. Le *-* veut dire simplement "en même temps que."

en: The following are some of the shortcuts I find most useful.
fr: Voici ci-dessous les raccourcis que j'estime les plus utiles.

en: Stopping and starting
fr: Arrêter et démarrer

en: Instead of always reaching for the mouse to run your code, you can simply press `M-r`. Similarly, to stop running code you can press `M-s`.
fr: Au lieu de toujours attraper la souris pour exécuter votre code, vous pouvez simplement presser `M-r`. Similairement, pour stopper l'exécution de votre code, vous pouvez presser `M-s`.

en: I'm really lost without the navigation shortcuts. I therefore highly recommend you spend the time to learn them. These shortcuts also work extremely well when you've learned to touch type as they use the standard letters rather than requiring you to move your hand to the mouse or the arrow keys on your keyboard.
fr: Je suis vraiment perdu sans les raccourcis de navigation. Je recommande donc vivement que vous passiez du temps à les apprendre. Ces raccourcis fonctionnent aussi extrêmement bien quand vous apprenez à taper sans regarder le clavier parce qu'ils utilisent des lettres standards sans nécessiter de déplacer votre main jusqu'à la souris ou jusqu'aux touches flèches de votre clavier.

en: You can move to the beginning of the line with `C-a`, the end of the line with `C-e`, up a line with `C-p`, down a line with `C-n`, forward a character with `C-f`, and back a character with `C-b`. You can even delete all the characters from the cursor to the end of the line with `C-k`.
fr: Vous pouvez vous déplacer au début de la ligne avec `C-a`, à la fin de la ligne avec `C-e`, à la ligne du dessus avec `C-p`, à la ligne du dessous avec `C-n`, avancer d'un caractère avec `C-f` et reculer d'un caractère avec `C-b`. Vous pouvez même effacer tous les caractères depuis le curseur jusqu'à la fin de la ligne avec `C-k`.

en: Tidy Code
fr: Code ordonné

en: To auto-align your code simply press `M-m`.
fr: Pour aligner et indenter automatiquement vos lignes de code, pressez `M-m`.

en: Help System
fr: Système d'aide

en: To toggle the help system you can press `M-i`. However, a much more useful shortcut to know is `C-i` which will look up the word underneath the cursor and display the docs if it finds anything. Instant help!
fr: Pour afficher/cacher le système d'aide vous pouvez presser `M-i`. Toutefois, un raccourci plus utile à connaître est `C-i`. Il détecte le mot où se trouve le curseur et affiche la documentation le concernant s'il la trouve. Aide instantanée !

en: For a full list take a look at section B.2 Shortcut Cheatsheet.
fr: Pour une liste complète, jetez un œil à la section B.2 - Antisèche des raccourcis.

en: B.2 Shortcut Cheatsheet
fr: B.2 Antisèche des raccourcis

en: Shortcut Cheatsheet
fr: Antisèche des raccourcis

en: The following is a summary of the main shortcuts available within Sonic Pi. Please see Section B.1 for motivation and background.
fr: Ce qui suit est un récapitulatif des principaux raccourcis clavier disponibles avec Sonic Pi. Voyez svp la section B.1 pour la motivation et le contexte.

en: In this list, we use the following conventions (where *Meta* is one of *Alt* on Windows/Linux or *Cmd* on Mac):
fr: Dans cette liste, nous utilisons les conventions suivantes (où *Meta* est la touche *Alt* pour Windows/Linux et *Cmd* sur Mac) :

en: `C-a` means hold the *Control* key then press the *a* key whilst holding them both at the same time, then releasing.
fr: `C-a` signifie maintenir la touche *Control* enfoncée puis presser la touche *a* en les maintenant les deux en même temps, puis les relâcher.

en: `M-r` means hold the *Meta* key and then press the *r* key whilst holding them both at the same time, then releasing.
fr: `M-r` signifie maintenir la touche *Meta* enfoncée puis presser la touche *r* en les maintenant les deux en même temps, puis les relâcher.

en: `S-M-z` means hold the *Shift* key, then the *Meta* key, then finally the *z* key all at the same time, then releasing.
fr: `S-M-z` signifie maintenir les touches *Majuscule* et *Meta* enfoncées puis presser la touche *z* en les maintenant les deux en même temps, puis les relâcher.

en: `C-M-f` means hold the *Control* key, then press *Meta* key, finally the *f* key all at the same time, then releasing.
fr: `C-M-f` signifie maintenir les touches *Control* et *Meta* enfoncées puis presser la touche *f* en les maintenant les deux en même temps, puis les relâcher.

en: Main Application Manipulation
fr: Manipulation de l'application principale

en: `M-r` - Run code
fr: `M-r` - Exécute le code

en: `M-s` - Stop code
fr: `M-s` - Arrête le code

en: `M-i` - Toggle Help System
fr: `M-i` - Affiche/cache le système d'aide

en: `M-p` - Toggle Preferences
fr: `M-p` - Affiche/cache les préférences

en: `M-{` - Switch buffer to the left
fr: `M-{` - Bascule sur le buffer de gauche

en: `M-}` - Switch buffer to the right
fr: `M-}` - Bascule sur le buffer de droite

en: `S-M-0` - Switch to buffer 0
fr: `S-M-0` - Bascule vers le tampon 0

en: `S-M-1` - Switch to buffer 1
fr: `S-M-1` - Bascule vers le tampon 1

en: `S-M-9` - Switch to buffer 9
fr: `S-M-9` - Bascule vers le tampon 9

en: `M-+` - Increase text size of current buffer
fr: `M-+` - Augmente la taille du texte du buffer courant

en: `M--` - Decrease text size of current buffer
fr: `M--` - Diminue la taille du texte du buffer courant

en: Selection/Copy/Paste
fr: Sélection/Copier/Coller

en: `M-a` - Select all
fr: `M-a` - Sélectionner tout

en: `M-c` - Copy selection to paste buffer
fr: `M-c` - Copie la sélection dans le presse-papier

en: `M-]` - Copy selection to paste buffer
fr: `M-]` - Copie la sélection dans le presse-papier

en: `M-x` - Cut selection to paste buffer
fr: `M-x` - Coupe la sélection et la copie dans le presse-papier

en: `C-]` - Cut selection to paste buffer
fr: `C-]` - Coupe la sélection et la copie dans le presse-papier

en: `C-k` - Cut to the end of the line
fr: `C-k` - Coupe jusqu'à la fin de la ligne et le copie dans le presse-papier

en: `M-v` - Paste from paste buffer to editor
fr: `M-v` - Colle depuis le presse-papier

en: `C-y` - Paste from paste buffer to editor
fr: `C-y` - Colle depuis le presse-papier

en: `C-SPACE` - Set mark. Navigation will now manipulate highlighted region. Use `C-g` to escape.
fr: `C-SPACE` - Pose une marque. La navigation surligne et sélectionne la région depuis la marque. Utilisez `C-g` pour sortir.

en: Text Manipulation
fr: Manipulation du texte

en: `M-m` - Align all text
fr: `M-m` - Aligne et indente tout le texte

en: `Tab` - Align current line or selection (or select autocompletion)
fr: `Tab` - Aligne et indente la ligne courante ou la sélection (ou sélectionne l'auto-complétion)

en: `C-l` - Centre editor
fr: `C-l` - Centre l'éditeur

en: `M-/` - Comment/Uncomment current line or selection
fr: `M-/` - Commente/Décommente la ligne courante ou la sélection

en: `C-t` - Transpose/swap characters
fr: `C-t` - Intervertit les caractères sélectionnés

en: `M-u` - Convert next word (or selection) to upper case.
fr: `M-u` - Convertit le mot suivant (ou la sélection) en majuscule.

en: `M-l` - Convert next word (or selection) to lower case.
fr: `M-l` - Convertit le mot suivant (ou la sélection) en minuscule.

en: `C-a` - Move to beginning of line
fr: `C-a` - Déplace au début de la ligne

en: `C-e` - Move to end of line
fr: `C-e` - Déplace à la fin de la ligne

en: `C-p` - Move to previous line
fr: `C-p` - Déplace à la ligne précédente

en: `C-n` - Move to next line
fr: `C-n` - Déplace à la ligne suivante

en: `C-f` - Move forward one character
fr: `C-f` - Avance d'un caractère

en: `C-b` - Move backward one character
fr: `C-b` - Recule d'un caractère

en: `M-f` - Move forward one word
fr: `M-f` - Avance d'un mot

en: `M-b` - Move backward one word
fr: `M-b` - Recule d'un mot

en: `C-M-n` - Move line or selection down
fr: `C-M-n` - Déplace la ligne ou la sélection vers le bas

en: `C-M-p` - Move line or selection up
fr: `C-M-p` - Déplace la ligne ou la sélection vers le haut

en: `S-M-u` - Move up 10 lines
fr: `S-M-u` - Déplace 10 lignes vers le haut

en: `S-M-d` - Move down 10 lines
fr: `S-M-d` - Déplace 10 lignes vers le bas

en: `M-<` - Move to beginning of buffer
fr: `M-<` - Aller au début du tampon

en: `M->` - Move to end of buffer
fr: `M->` - Aller à la fin du tampon

en: Deletion
fr: Suppression

en: `C-h` - Delete previous character
fr: `C-h` - Supprime le caractère précédent

en: `C-d` - Delete next character
fr: `C-d` - Supprime le caractère suivant

en: Advanced Editor Features
fr: Fonctionnalités avancées de l'éditeur

en: `C-i` - Show docs for word under cursor
fr: `C-i` - Affiche la documentation du mot où se trouve le curseur

en: `M-z` - Undo
fr: `M-z` - Défait

en: `S-M-z` - Redo
fr: `S-M-z` - Refait

en: `C-g` - Escape
fr: `C-g` - Sortir

en: `S-M-f` - Toggle fullscreen mode
fr: `S-M-f` - Bascule en mode plein écran

en: `S-M-b` - Toggle visibility of buttons
fr: `S-M-b` - Affiche/cache les boutons

en: `S-M-l` - Toggle visibility of log
fr: `S-M-l` - Affiche/cache le panneau "trace"

en: `S-M-m` - Toggle between light/dark modes
fr: `S-M-m` - Bascule entre l'affichage clair et sombre

en: `S-M-s` - Save contents of buffer to a file
fr: `S-M-s` - Enregistrer le contenu du tampon dans un fichier

en: `S-M-o` - Load contents of buffer from a file
fr: `S-M-o` - Charger le contenu d'un tampon à partir d'un fichier

en: B.3 Sharing
fr: B.3 Partage

en: Sharing
fr: Partage

en: Sonic Pi is all about sharing and learning with each other.
fr: Sonic Pi a tout ce qu'il faut pour partager et apprendre avec les autres.

en: Once you've learned how to code music, sharing your compositions is as simple as sending an email containing your code. Please do *share* your code with others so they can *learn* from your work and even use parts in a new *mash-up*.
fr: Une fois que vous avez appris comment coder de la musique, partager vos compositions est aussi simple que d'envoyer un courriel contenant votre code. SVP *partagez* votre code avec les autres, ainsi ils pourront *apprendre* de votre travail et même en utiliser des parties dans un nouveau *"mashup"*.

en: If you're unsure of the best way to share your work with others I recommend putting your code on [GitHub](https://github.com) and your music on [SoundCloud](https://soundcloud.com). That way you'll be able to easily reach a large audience.
fr: Si vous n'êtes pas sûr de connaître le meilleur moyen de partager votre travail avec les autres, je vous recommande de mettre votre code sur [GitHub](https://github.com) et votre musique sur [SoundCloud](https://soundcloud.com). De cette manière vous pourrez atteindre facilement un grand auditoire.

en: [GitHub](https://github.com) is a site for sharing and working with code. It's used by professional developers as well as artists for sharing and collaborating with code. The simplest way to share a new piece of code (or even an unfinished piece) is to create a [Gist](https://gist.github.com). A [Gist](https://gist.github.com) is a simple way of uploading your code in a simple way that others can see, copy and share.
fr: [GitHub](https://github.com) est un site pour partager et travailler avec du code. Il est utilisé aussi bien par des développeurs professionnels que par des artistes pour partager et collaborer avec du code. La manière la plus simple pour partager un morceau de code (ou même un morceau non terminé) est de créer un [Gist](https://gist.github.com). Un [Gist](https://gist.github.com) est un moyen simple de déposer votre code afin que les autres y aient accès de manière simple : voir, copier et partager.

en: Another important way of sharing your work is to record the audio and upload it to [SoundCloud](https://soundcloud.com). Once you've uploaded your piece, other users can comment and discuss your work. I also recommend placing a link to a [Gist](https://gist.github.com) of your code in the track description.
fr: Une autre façon importante de partager votre travail est d'enregistrer l'audio et de déposer l'enregistrement sur [SoundCloud](https://soundcloud.com). Une fois que vous avez déposé votre morceau, les autres peuvent commenter et discuter de votre travail. Je vous recommande aussi de placer un lien vers le [Gist](https://gist.github.com) de votre code dans la description de la piste.

en: To record your work, hit the `Rec` button in the toolbar, and recording starts immediately. Hit `Run` to start your code if it isn't already in progress. When you're done recording, press the flashing `Rec` button again, and you'll be prompted to enter a filename. The recording will be saved as a WAV file, which can be edited and converted to MP3 by any number of free programs (try Audacity for instance).
fr: Pour enregistrer votre travail, pressez le bouton `Rec` de la barre d'outils, et l'enregistrement démarre immédiatement. Pressez `Run` pour lancer votre code s'il n'est pas encore démarré. Quand votre enregistrement devra être arrêté, pressez le bouton `Rec` clignotant à nouveau, et il vous sera demandé d'entrer un nom de fichier. L'enregistrement sera sauvegardé dans le format d'un fichier WAV, lequel peut être modifié et converti en MP3 par n'importe quel programme gratuit (essayez Audacity par exemple).

en: Hope
fr: Espoir

en: I encourage you to share your work and really hope that we'll all teach each other new tricks and moves with Sonic Pi. I'm really excited by what you'll have to show me.
fr: Je vous encourage à partager votre travail et j'espère vraiment que nous allons tous nous apprendre de nouvelles astuces et progresser avec Sonic Pi. Je suis très enthousiaste de ce que vous allez avoir à me montrer.

en: B.4 Performing
fr: B.4 Se produire

en: Performing
fr: Se produire

en: One of the most exciting aspects of Sonic Pi is that it enables you to use code as a *musical instrument*. This means that writing code live can now be seen as a new way of performing music.
fr: Un des aspects les plus passionnants de Sonic Pi est qu'il vous permet d'utiliser le code comme un *instrument de musique*. Cela signifie qu'écrire du code en direct peut maintenant être considéré comme une nouvelle manière d'interpréter de la musique.

en: We call this *Live Coding*.
fr: Nous appelons ceci *codage en direct*.

en: Show Your Screen
fr: Montrez votre écran

en: When you live code I recommend you *show your screen* to your audience. Otherwise it's like playing a guitar but hiding your fingers and the strings. When I practice at home I use a Raspberry Pi and a little mini projector on my living room wall. You could use your TV or one of your school/work projectors to give a show. Try it, it's a lot of fun.
fr: Quand vous codez en direct, je vous recommande de *montrer votre écran* à votre auditoire. Autrement, c'est comme jouer de la guitare, mais en cachant vos doigts et les cordes. Quand je pratique à la maison, j'utilise un Raspberry Pi et un mini projecteur sur le mur de mon salon. Vous pouvez utiliser votre TV ou l'un de vos projecteurs d'école/travail pour faire un spectacle. Essayez-le, c'est beaucoup de plaisir.

en: Form a Band
fr: Formez un groupe

en: 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.
fr: Ne vous contentez pas de jouer seul - formez un groupe de codage en direct ! C'est très amusant de jouer avec d'autres. Une personne peut faire des beats, une autre des ambiances de fond, etc. Utilisez la fonctionnalité `live_audio` pour combiner le code avec des instruments traditionnels tels qu'une guitare ou un microphone.

en: See what interesting combinations of sounds you can create with code.
fr: Voyez quelles combinaisons de sons intéressantes vous pouvez créer avec du code.

en: Live coding isn't completely new - a small number of people have been doing it for a few years now, typically using bespoke systems they've built for themselves. A great place to go and find out more about other live coders and systems is [TOPLAP](http://toplap.org).
fr: Le codage en direct n'est pas totalement nouveau - un petit nombre de personnes le font maintenant depuis quelques années, typiquement en utilisant des systèmes sur mesure qu'ils avaient élaborés eux-mêmes. Un super site à visiter pour trouver plus d'informations sur les autres codeurs en direct et leurs systèmes est [TOPLAP](http://toplap.org).

en: Another great resource for exploring the live coding world is [Algorave](http://algorave.com). Here you can find all about a specific strand of live coding for making music in nightclubs.
fr: Une autre bonne ressource pour explorer le monde du codage en direct est [Algorave](http://algorave.com). Vous trouverez là tout sur une branche spécifique du codage en direct pour faire de la musique dans les boîtes de nuit.
