Sonic Pi - en to pt translation catalogue (989 entries)

en: 1 Welcome to Sonic Pi
pt: Bem vindo ao Sonic Pi

en: Welcome friend :-)
pt: Bem-vindo amigo :-)

en: Welcome to Sonic Pi. Hopefully you're as excited to get started making crazy 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.
pt: Bem-vindo ao Sonic Pi. Espero que estejas tão ansioso para começar a criar sons malucos como eu para te mostrar. Vai ser uma viagem *muito* divertida onde vais aprender tudo sobre musica, síntese, programação, composição, desempenho e mais.

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.
pt: Mas espera, que maneiras! Deixa apresentar-me -- chamo-me [Sam Aaron](http://twitter.com/samaaron) -- o criador do Sonic Pi. Podes encontrar-me em [@samaaron](http://twitter.com/samaaron) no Twitter e terei todo o gosto em te dizer olá. Podes também estar interessado em saber mais sobre as minhas [*Live Coding Performances*](https://youtube.com/samaaron) onde programo com o Sonic Pi, ao vivo, para audiências.

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!
pt: Se tens ideias para melhorar o Sonic Pi - por favor diz-nos - comentários ajudam muito. Nunca se sabe, a tua ideia pode ser a próxima grande funcionalidade!

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.
pt: Este tutorial está dividido em secções agrupadas por categoria. Embora o tenha escrito para ter uma evolução de aprendizagem fácil desde o início até ao fim, fica à vontade para saltar entre secções. Se achas que está alguma coisa em falta, diz-me e vou considerar pôr-la numa versão futura.

en: OK, let's get started...
pt: Ok, vamos começar...

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.
pt: Um dos aspectos mais emocionantes do Sonic Pi é que podes escrever e *modificar o código em tempo real* para fazer música, tal como podes tocar numa guitarra ao vivo. Isto significa que após alguma prática podes levar o Sonic Pi para o palco e tocar.

en: Free your mind
pt: Liberta a tua mente

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...
pt: Antes de entrarmos nos detalhes de como o Sonic Pi funciona no resto deste tutorial, queria dar-te uma ideia de como é programar em tempo real. Não te preocupes se não perceberes muito (ou nada) disto. Tenta só segurar-te à cadeira e aproveita...

en: A live loop
pt: Um *Live Loop*

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:
pt: Agora, carrega no botão `Run` e vais ouvir uma boa e rápida batida de bombo. Se a qualquer momento quiseres parar o som basta carregar no botão `Stop`. Mas não carregues para já... Em vez disso, segue estes passos:

en: Make sure the bass drum sound is still running
pt: Certifica-te de que o som do bombo ainda está a tocar

en: Change the `sleep` value from `0.5` to something higher like `1`.
pt: Muda o valor do `sleep` de `0,5` para algo maior, como `1`.

en: Press the `Run` button again
pt: Carrega no botão `Run` outra vez

en: Notice how the drum speed has changed.
pt: Nota como a velocidade do bombo mudou.

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...
pt: Por fim, *lembra-te deste momento*, esta foi a primeira vez que programaste ao vivo com o Sonic Pi e é provável que não seja a última...

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:
pt: Ok, isso foi simples. Vamos adicionar algo mais à mistura. Acima de `sample :bd_haus` adiciona a linha `sample :ambi_choir, rate: 0.3`. O teu código deve estar algo parecido com o seguinte:

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).
pt: Sinta-se agora à vontade para testar aquilo que aprendeu. Mude parâmetros, como o rate - preste atenção no que acontece quando usa valores mais algos, valores mais baixos, ou até valores negativos. Repare no que acontece quando você muda o parâmetro 'rate' pelo sample ':ambi_choir' (para, por exemplo '0.29'). O que acontece quando você escolhe um valor pequeno para o `step`? Veja se você consegue fazer ele ir tão rápido que seu computador vai parar com um erro porque não consegue alcançá-lo (se isso acontecer, escolha um valor mais alto para o tempo de `sleep`, e aperte em `Run` de novo).

en: Try commenting one of the `sample` lines out by adding a `#` to the beginning:
pt: Experimenta comentar uma das linhas `sample` adicionando um `#` no início:

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.
pt: Nota como o computador ignora aquela linha, e por isso não a ouvimos. Isto chama-se um comentário. No Sonic Pi podemos usar comentários para adicionar ou remover coisas da música.

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:
pt: Finalmente, vou deixar-te uma coisa para brincar. Copia o código abaixo para um buffer vazio. Não tentes demasiado compreendê-lo, além de ver que existem dois loops (ciclos) -- duas coisas a tocar ao mesmo tempo. Agora, faz o que fazes melhor -- experimenta e brinca. Aqui estão algumas sugestões:

en: Try changing the blue `rate:` values to hear the sample sound change.
pt: Experimenta mudar os valores do `rate:` azul para ouvir o som a mudar.

en: Try changing the `sleep` times and hear that both loops can spin round at different rates.
pt: Experimenta mudar o valor de `sleep` e nota que os loops tocam a velocidades diferentes.

en: Try uncommenting the sample line (remove the `#`) and enjoy the sound of the guitar played backwards.
pt: Experimenta remover o comentário da linha `sample` (remover o `#`) e desfruta do som da guitarra tocado ao contrário.

en: Try changing any of the blue `mix:` values to numbers between `0` (not in the mix) and `1` (fully in the mix).
pt: Experimenta mudar um dos valores de `mix:` para números entre `0` (não entra na música) e `1` (entra na música com efeito completo).

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...
pt: Lembra-te de clicar em `Run` e ouvirás as mudanças da próxima vez que o loop tocar. Se ficares com o código estragado, não te preocupes -- carrega em `Stop`, apaga o código e cola uma cópia nova e estás de volta à ação. É a errar que aprendes mais rápido...

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.
pt: Agora, continua a tocar e a experimentar até a tua curiosidade sobre como tudo isto funciona entrar em cena e começares a questionar que mais podes fazer no Sonic Pi. Agora estás pronto para ler o resto do tutorial.

en: So what are you waiting for...
pt: Então de que estás à espera...

en: The Sonic Pi Interface
pt: A Interface do Sonic Pi

en: Sonic Pi has a very simple interface for coding music. Let's spend a little time exploring it.
pt: O Sonic Pi tem um interface muito simples para programar música. Vamos passar algum tempo a explorá-la.

en: *A* - Play Controls
pt: *A* - Controlos de Reprodução

en: *B* - Editor Controls
pt: *B* - Controlos do Editor

en: *C* - Info and Help
pt: *C* - Informação e Ajuda

en: *D* - Code Editor
pt: *D* - Editor (de código)

en: *E* - Prefs Panel
pt: *E* - Painel de Opções

en: *F* - Log Viewer
pt: *F* - Vizualizador de logs

en: *G* - Help System
pt: *G* - Sistema de Ajuda

en: *H* - Scope Viewer
pt: 'H' - Osciloscópio

en: A. Play Controls
pt: A. Controlos de Reprodução

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.
pt: Estes botões rosa são os controlos principais para reproduzir e parar sons. O botão *Run* serve para reproduzir o código no editor, *Stop* para parar todas as reproduções, *Save* para guardar o código num ficheiro externo e *Record* para gravar (num ficheiro WAV) o som que estiver a tocar.

en: B. Editor Controls
pt: B. Controlos do Editor

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.
pt: Estes butões laranja permitem manipular o editor de código. Os butões de *Tamanho +* e "Tamanho -"permitem fazer com que o texto seja maior e mais pequeno.

en: C. Info and Help
pt: C. Informação e Ajuda

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.
pt: Estes botões azuis dão-te acesso a informação, ajuda e opções. O botão *Info* abre a janela de informação que contém informação sobre o Sonic Pi em si -- a equipa, histórico de actualizações, contribuidores e a comunidade. O botão *Ajuda* abre e fecha o sistema de ajuda (*F*) e o botão *Opções* abre e fecha a janela das opções que te permitem controlar alguns parâmetros básicos do sistema.

en: D. Code Editor
pt: D. Editor (de código)

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.
pt: Esta é a área onde irá escrever o seu código e compor/tocar a sua música. Trata-se de um editor de texto simples onde pode escrever código, apagá-lo, ou modificá-lo. Pense no que é uma versão básica do Word ou do Google Docs. O editor irá mudar de cores automaticamente tendo em conta as propriedades do código. Pode parecer estranho em primeiro lugar, mas brevemente irá chegar à conclusão que isto é bastante útil. Por exemplo, irá ficar a saber que algo é um número, no instante, em que o caracter assumir a cor base azul

en: E. Prefs Panel
pt: E. Painel de Opções

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.
pt: O Sonic Pi suporta um número de preferências que podem ser acedidas ao carregar no botão *Prefs*. Isto abre o painel das opções que inclui várias opções alteráveis. Alguns exemplos são forçar o *mono mode*, inverter o *stereo*, activar/desactivar *logs* e também um slider para o volume e selector de audio no Raspberry Pi.

en: F. Log Viewer
pt: F. Visualizador de logs

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.
pt: Quando corres o teu código, vai ser mostrada informação sobre o que o programa está a fazer no Vizualizador do *log*. Por defeito, verás uma mensagem por cada som que crias com a hora exacta a que começou a tocar. Isto é útil para *debugging* e perceber o que o teu código está a fazer.

en: G. Help System
pt: G. Sistema de Ajuda

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.
pt: Uma das partes mais importantes da interface do Sonic Pi, é o sistema de ajuda que aparece por baixo da janela. Isto pode ser exibido através do botão azul intitulado "Help". O sistema contém informação de ajuda acerca de todos os aspectos do SOnic Pi, incluindo este tutorial, e uma lista dos sintetizadores e samples disponíveis, assim como efeitos e uma lista completa de todas as função que o Sonic Pi disponibiliza para fins de criação musical

en: H. Scope Viewer
pt: H. Osciloscópio

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).
pt: O osciloscópio permite visualizar a forma de onde do sinal de áudio reproduzido. É possível observar fcilmente a forma de uma onda triangular e constatar que o sinal se aproxima de parece uma forma de onda triangular e que um beep básico tem uma curva de sinosoidal. É também possível constatar a diferença entre um som alto e um som calmo através do tamanho das linhas. Existem três osciloscópios com os quais é possível trabalhar-se - o pré-definido é uma combinação do osciloscópio para o canal esquerdo e direito. Existe um osciloscópio estéreo que desenha um osciloscópio com linhas separadas para cada canal. Finalmente, existe um osciloscópio com curva Lissajous que permite ver a relação de fase entre o canal esquerdo e direito e permite desenhar imagens bonitas a partir da forma do som (https://en.wikipedia.org/wiki/Lissajous_curve).

en: 1.3 Learning through Play
pt: 1.3 Aprende interagindo

en: Learning through Play
pt: Aprender ao experimentar

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.
pt: O Sonic Pi incentiva-te a aprender tanto sobre computação como música ao tocar e experimentar. A coisa mais importante é que te estejas a divertir, e antes que te apercebas terás aprendido, consequentemente, como escrever código, compor e tocar.

en: There are no mistakes
pt: Não existem erros

en: Start Simple
pt: Começa pelo simples

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.
pt: Quando estás a aprender, é tentador querer fazer coisas espetaculares *imediatamente*. No entanto, aguenta essa vontade e vê-a como um objectivo distante para atingir mais *tarde*. Por agora, pensa no que seria mais simples, divertido e recompensador de escrever que te ajudará a chegar à coisa espetacular que tens em mente. Uma vez que tenhas uma ideia sobre esse simples passo, tenta e constrói-o, brinca com ele e vê que ideias novas te dá. Brevemente estarás ocupado a divertir e progredir.

en: Just make sure to share your work with others!
pt: Lembra-te de partilhar o teu trabalho com outros!

en: 2 Synths
pt: 2 Sintetizadores

en: Synths
pt: Sintetizadores

en: OK, enough of the intros - let's get into some sound.
pt: OK, chega de introduções -- vamos começar a escrever código e a ouvir resultados.

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.
pt: Nesta secção vamos cobrir a base de criar e manipular sintetizadores. *Synth* é uma abreviatura para sintetizador, que é uma palavra que soa bem para algo que cria sons. Os sintetizadores são normalmente bastante complicados de usar -- especialmente sintetizadores analógicos com muitos fios e módulos. No entanto, o Sonic Pi dá-te grande parte dessa capacidade de forma muito simples.

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...
pt: Não te deixes enganar pela simplicidade da interface do Sonic Pi. É possível ir bem longe com manipulação de som sofisticada se é disso que gostas. Segura-te bem...

en: 2.1 Your First Beeps
pt: 2.1 Os teus primeiros Beeps

en: Your First Beeps
pt: Os teus primeiros Beeps

en: Take a look at the following code:
pt: Dá uma olhadela no código que se segue:

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...
pt: É aqui que tudo começa. Copia e cola-o no editor (o espaço em branco por baixo do botão *Run*). Agora carrega em *Run*...

en: Intense. Press it again. And again. *And again...*
pt: Intenso. Carrega outra vez. E outra vez. *E outra vez...*

en: Woah, crazy, 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:
pt: Wow, espactualar, tenho a certeza que fazias isso o dia todo. Mas espera, antes que te percas com os beeps, experimenta mudar o número:

en: Can you hear the difference? Try a lower number:
pt: Consegues ouvir a diferença? Experimenta um número mais pequeno:

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.
pt: Portanto, os números mais pequenos produzirão beeps de sons com uma frequência mais baixa, e números mais altos farão beeps com um pitch mais alto. Tal como no piano, as teclas a parte baixa do piano (as da mão esquerda) tocarão notes e teclas na parte mais alta do piano (as do lado da mão direita), tocar notas mais altas

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*.
pt: *Não te preocupes* se nada disto fizer sentido para ti -- também não fazia para mim quando comecei. O que interessa é que *números pequenos fazem sons graves* e *números grandes fazem sons agudos*.

en: Chords
pt: Acordes

en: Playing a note is quite fun, but playing many at the same time can be even better. Try it:
pt: Tocar uma nota e divertido, mas tocar várias ao mesmo tempo pode ser ainda melhor. Experimenta:

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.
pt: *Jazzy!* Quando escreves vários `play`s, eles tocam todos ao mesmo tempo. Experimenta tu mesmo -- que números soam bem juntos? Quais soam mal? Experimenta, explora e descobre por próprio.

en: Melody
pt: Melodia

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:
pt: Tocar notas e acordes é divertido -- mas e a melodia? E se quisesses tocar uma nota depois da outra e não ao mesmo tempo? Bem, isso é fácil, só tens de usar `sleep` entre notas:

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`:
pt: Que bom, um pequeno arpeggio. Então o que significa o `1` em `sleep 1`? Bem, é a duração da pausa. Na realidade significa pausar durante uma batida (ou um tempo), mas para já podemos pensar como uma pausa de 1 segundo. Então e se quisessemos que o nosso arpeggio tocasse mais rápido? Bem, temos de diminuir o valor da pausa. E que tal metade, `0.5`:

en: Notice how it plays faster. Now, try for yourself, change the times - use different times and notes.
pt: Nota como toca mais rápido. Agora, tenta tu, muda as pausas -- usa pausas e notas diferentes.

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.
pt: Uma coisa para se experimentar são valores intermédios como `play 52.3` e `play 52.63`. Não há razão para ficarmos usando apenas valores inteiros. Experimente e se diverta.

en: Traditional Note Names
pt: Nomes das notas tradicionais

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:
pt: Para aqueles que já sabem de notação musical (não te preocupes se não souberes -- não precias para te divertires) podem querer escrever uma melodia usando os nomes das notas tal como Mi e La em vez de números. podem fazer o seguinte:

en: play :C
    sleep 0.5
    play :D
    sleep 0.5
    play :E
pt: # Do (A) | Re (B) | Mi (C) | Fa (D) | Sol (E) | La (F) | Si (G)
    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:
pt: Lembra-te de pôr um `:` antes do nome da nota para que esta fique côr-de-orsa. Também podes especificar a oitava adicionando um número à frente da nota:

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`.
pt: Se quiseres adicionar um sustenido, de modo a incrementar o pitch meio tom, adiciona um `s` depois da nota, como `play :Fs3`, e se quiseres adicionar um bemol, adiciona um `b`, como `play :Eb3`.

en: Now go *crazy* and have fun making your own tunes.
pt: Agora perde-te no código e diverte-te a fazer as tuas próprias músicas.

en: 2.2 Synth Options
pt: 2.2 Opções do Sintetizador

en: Synth Options: Amp and Pan
pt: Opções do Sintetizador: Amplitude and Panorâmica

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.
pt: Além de te permitir controlar que nota tocar ou qual o sample a tocar, o Sonic Pi dispõe de um conjunto de opções para criar e controlar os sons. Vamos cobrir algumas destas neste tutorial verifica que existe documentação detalhada para cada uma no sistema de ajuda. No entanto, para já vamos introduzir dois dos parâmetros mais úteis: *amplitude* e *panorâmica*. Primeiro, vamos ver quais são as nossas opções.

en: Options
pt: Opções

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).
pt: O Sonic Pi suporta a notação de opções (ou opts, abreviando) para os sintetizadores. Opts são controlos que podes passar ao `play` que modificam e controlam aspectos do som que ouves. Cada sintetizador tem as suas próprias opts para afinar o seu som. No entanto, existem conjuntos de opts comuns partilhados por muitos synths tal como `amp:` e opts *envelope* (para serem faladas noutra secção).

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 a opt called `cheese:` and want to set it with a value of `1`.
pt: Opts têm duas partes principais, o seu nome (o nome do controlo) e o seu valor (o valor que queres dar a essa opt). Por exemplo, podes ter uma opt chamada `queijo` e dar-lhe um valor de `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:
pt: Opts são passadas a comandos `play` ao usar uma virgula (`,`) e depois o nome da opt, como `amp:` (não te esqueças dos dois pontos `:`) e depois um espaço e o valor da opt. Por exemplo:

en: play 50, cheese: 1
pt: play 50, queijo: 1

en: (Note that `cheese:` isn't a valid opt, we're just using it as an example).
pt: (Nota que `queijo:` não existe mesmo, só estamos a usar como exemplo)

en: You can pass multiple opts by separating them with a comma:
pt: Podes dar várias opts separando-as por vírgulas:

en: play 50, cheese: 1, beans: 0.5
pt: play 50, queijo: 1, feijões: 0.5

en: The order of the opts doesn't matter, so the following is identical:
pt: A ordem das opts não interessa, por isso o seguinte é idêntico:

en: Opts that aren't recognised by the synth are just ignored (like `cheese` and `beans` which are clearly ridiculous opt names!)
pt: Opts que não são reconhecidas pelo sintetizado são simplesmente ignoradas (como `queijo` e `feijões`, que são claramente nomes ridículos para opts!)

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:
pt: Se usares a mesma opt mais de uma vez com valores diferentes, a última ganha. Por exemplo, `feijões:` vai ter o valor `2` em vez de `0.5`:

en: play 50, beans: 0.5, cheese: 3, eggs: 0.1, beans: 2
pt: play 50, feijões: 0.5, queijo: 3, ovos: 0.1, feijões: 2

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:`.
pt: Muitas coisas no Sonic Pi aceitam opts, portanto gasta algum tempo a aprender como usá-las e estarás preparado! Vamos brincar com a nossa primeira opt: `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.
pt: A amplitude é a representação numcomputador do volume de um som. Um nível mais elevador de amplitude conduz a um som com um nível de pressão sonora mais elevado, e consequentemente mais alto e uma amplitude baixa produz um som com um nível de pressão sonora mais baixo, e consequentemente mais suave. Da mesma forma que o Sonic Pi usa números para representar tempo e notas, também usa números para representar amplitude. Uma amplitude de 0 é silenciosa (não vais ouvir nada) enquanto uma amplitude 1 é de volume normal. Até podes aumentar a amplitude para 2, 10, 100 ou mais. No entanto, deve-se notar que quando a amplitude de todos os sons aumenta demasiado, o Sonic Pi usa uma coisa chamada compressor que os baixa para ter a certeza que o som não está demasiado alto para os teus ouvidos. Isto pode fazer o som ficar turvo e estrano. Por isso tenta usar amplitudes baixas, entre 0 e 0.5 para evitar compressão.

en: Amp it up
pt: Aumenta o volume

en: To change the amplitude of a sound, you can use the `amp:` opt. For example, to play at half amplitude pass 0.5:
pt: Para mudar a amplitude de um som, podes usar a opt `amp:`. Por exemplo, para tocar com metade do nível de pressão sonora dá-lhe o valor `0.5`:

en: To play at double amplitude pass 2:
pt: Para tocar com o dobro da pressão sonora, e consequentemente amplitude e intensidade, dá-lhe `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):
pt: A opt `amp:` só modifica a amplitude do `play` com que está associada. Então, neste exemplo, o primeiro `play` está a metade do volume e o segundo está no normal (`1`):

en: Of course, you can use different `amp:` values for each call to play:
pt: Claro, podes usar diferentes valores de `amp:` para cada `play`:

en: Panning
pt: Panorâmica

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.
pt: Outra opt divertida é a `pan:`, que controla o a panorâmica de um som stereo. Usar *panning* para a esquerda num som significa que só o vais ouvir pela coluna esquerda, e usar *panning* para a direita significa que que só o vais ouvir pela coluna da direita. Como valores, usamos `-1` para representar a esquerda, `0 ` para o centro e `1` para a direita, em stereo. Claro, estamos livres para usar qualquer valor entre `-1` e `1` para controlar a posição exacta do som.

en: Let's play a beep out of the left speaker:
pt: Vamos tocar um beep na coluna esquerda:

en: Now, let's play it out of the right speaker:
pt: Agora, vamos tocar um beep na coluna direita:

en: Finally let's play it back out of the center of both (the default position):
pt: Finalmente vamos tocar um beep no centro (posição predefinida):

en: Now, go and have fun changing the amplitude and panning of your sounds!
pt: Agora, diverte-te a mudar a amplitude e *panning* dos teus sons!

en: 2.3 Switching Synths
pt: 2.3 Alternar entre sintetizadores

en: Switching Synths
pt: Mudar Synths

en: Buzzy saws and prophets
pt: Ondas de dente de serra ruidosas e sons do sintetizador prophet da Roland

en: A fun sound is the *saw wave* - let's give it a try:
pt: Um som divertido é a (onda dentes de serra) -- vamos experimentar-lo:

en: Let's try another sound - the *prophet*:
pt: Vamos experimentar outro som -- o som do sintetizador prophet da Roland:

en: How about combining two sounds. First one after another:
pt: E que tal combinar dois sons. Um depois do outro:

en: Now multiple sounds at the same time (by not sleeping between successive calls to `play`):
pt: De seguida, iremos escutar sons com a mesma duração (por agora a dormir entre sucessivas chamadas para `tocar`):

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`.
pt: Nota que o comando usar_sintetizador só afecta as chamadas que se seguem do `play`. Pensa nele como um interruptor -- novos `play`s vão tocar o synth mais recente. Podes mudar o synth a usar com um novo `use_synth`.

en: Discovering Synths
pt: Decobrindo o Som dos Sintetizadores

en: `:prophet`
pt: ':prophet'

en: `:dsaw`
pt: ':dsaw'

en: `:fm`
pt: ':fm'

en: `:tb303`
pt: ':tb303'

en: `:pulse`
pt: ':pulse'

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.
pt: Agora vamos brincar experimentado trocar os sintetizadores durante a musica. Diverte-te a combinar sintetizadores para criar sons novos e usar synths diferentes em diferentes secções da tua música.

en: 2.4 Duration with Envelopes
pt: 2.4 Duração com Envolventes

en: Duration with Envelopes
pt: Duração com Envolventes

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.
pt: Numa secção anterior vimos como podemos usar o comando `sleep` para controlar quando tocar os nossos sons. Mas ainda não sabemos como controlar a duração dos nossos 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:
pt: Para termos um meio simples, mas eficaz, de controlar a duração dos nossos sons, o Sonic Pi possibilita o control de uma curva de envolvente do tipo ADSR (vamos falar sobre o que ADSR significa mais à frente nesta secção). Uma curva de envolvente de amplitude oferece dois aspectos úteis de controlo:

en: control over the duration of a sound
pt: controlo sobre a duração de um som

en: control over the amplitude of a sound
pt: controlo sobre a amplitude de um som

en: Duration
pt: Duração

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.
pt: Duração é o tempo que durante o qual conseguimos ouvir o som. Uma duração mais longa faz com que ouçamos o som durante mais tempo. Todos os sons no Sonic Pi têm uma envolvente de amplitude controlável, e a duração total dessa envolvente é a duração do som. Portanto, controlando a envolvente, controlas não só a sua duração, como a curva de forma de onde do som

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.
pt: Além de controlar a duração, a envolvente ADSR também oferece um *controlo excelente sobre a amplitude do som*. Todos os sons audíveis começam e acabam com silêncio e contêm uma parte não silenciosa no meio. Os envolventes permitem deslizar e manter a amplitude das partes não silenciosas do som. É como dar instruções de como aumentar e diminuir o volume de um amplificador de guitarra. Por exemplo, podes pedir a alguém para "começar com silêncio, aumentar o volume lentamente até ao máximo, manter durante um bocado e depois diminuir rapidamente até silêncio". O Sonic Pi permite programar este comportamento com curvas de envolvente.

en: Just to recap, as we have seen before, an amplitude of 0 is silence and an amplitude of 1 is normal volume.
pt: Para recapitular, como vimos antes, uma amplitude de 0 é silêncio e uma amplitude de 1 é volume normal.

en: Now, let us look at each of the parts of the envelopes in turn.
pt: Agora, vamos ver cada uma das partes das curvas de envolvente.

en: Release Phase
pt: fase de extinção

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):
pt: A única parte a envolvente que é usada por defeito é o tempo de extinsão do som (ou relaxamento). Isto é o tempo que o som de um sintetizador leva até desaparecer completamente. Todos os synths têm, por defeito, um tempo de extinsão de 1, o que significa que duram uma batida (que é 1 segundo, para BPM de 60):

en: The note will be audible for 1 second. Go ahead and time it :-) This is short hand for the longer more explicit version:
pt: Esta nota vai-se ouvir durante 1 segundo. Segue em frente e contabiliza a duração :-) Isto é a versão curta para a versão mais longa e explicita:

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:
pt: Nota como soam exactamente iguais (o som dura 1 segundo). No entanto, agora é muito fácil alterar a duração mudando o valor da opt `release:`:

en: We can make the synth sound for a very short amount of time by using a very small release time:
pt: Podemos fazer com que o som dure muito pouco tempo usando um valor mais baixo para `release:`:

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:
pt: A duração do repouso do som chama-se *fase de extinsão* (ou repouso) e por defeito é uma transição linear (isto é, uma linha recta). O diagrama seguinte ilustra esta transição:

en: You can therefore change the duration of your sound by changing the release time. Have a play adding release times to your music.
pt: Podes então mudar a duração do teu som ao mudar o tempo de repouso. Experimenta mudar os tempos de repouso da tua música.

en: Attack Phase
pt: Fase de Ataque

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:
pt: Por defeito, a *fase de ataque* é 0 para todos os synths, o que significa que a amplitude sobe de 0 para 1 imediatamente. Isto resulta num som inicialmente mais percursivo. No entanto, podes querer que o teu som tenha um *fade in*. Isto pode ser feito com a opt `attack:`. Experimenta usar fade in em alguns sons:

en: You may use multiple opts at the same time. For example for a short attack and a long release try:
pt: Pode querer usar váras opts ao mesmo tempo. Por exemplo, para um ataque curto e repouso longo, experimenta:

en: This short attack and long release envelope is illustrated in the following diagram:
pt: Esta ataque curto e repouso longo está ilustrado no diagrama seguinte:

en: Of course, you may switch things around. Try a long attack and a short release:
pt: Claro que podes é possível trocar. Tenta um ataque longo e repouso curto:

en: Finally, you can also have both short attack and release times for shorter sounds.
pt: Finalmente, também é possível tirar proveito tanto um tempo de ataque como de extinção curtos para sons curtos.

en: Sustain Phase
pt: Fase de Sustentação

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.
pt: Além de especificar os tempos de ataque e repouso, também podes mudar o tempo de sustentação para controlar a *fase de sustentação*. Isto é o tempo a que a amplitude se vai manter no máximo, entre as fases de ataque e repouso.

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.
pt: O tempo de sustentação é útil quando se pretende criar sons com mais presença na mistura, antes de entrar na fase de decaimento e extinção. Claro, é válido dar o valor de `0` às opts `attack:` e `release:` e usar só a sustentação para o som não ter nenhum fade in ou fade out. No entanto, deixamos o aviso, um tempo de repouso de 0 pode produzir *clicks* no som sendo melhor usar um valor muito baixo como `0.2`.

en: Decay Phase
pt: Fase de Decaimento

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:
pt: Para um nível extra de controlo, também é possível especificar um tempo de decaimento. Esta é a fase do envelope que fica entre as fases de ataque e sustentação e especifica o tempo em que a amplitude vai baixar do `attack_level:` para o `decay_level:` (que, a não ser que o mudes explicitamente, vai ser o mesmo que o `sustain_level:`). Por defeito, a opt `decay:` é 0 e tanto o ataque (`attack_leve:`) como a sustentação (`sustain_level:`) são 1, portanto precisas de especificá-los para o tempo de decaimento fazer efeito:

en: Decay Level
pt: Nível de Decaimento

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:
pt: Um último truque é que apesar da opt `decay_level:`, por defeito, ser igual ao `sustain_level:` podes dar-lhes valores diferentes para controlo total sobre o envelope. Isto permite-lhe criar envolventes como a seguinte:

en: It's also possible to set the `decay_level:` to be higher than `sustain_level:`:
pt: Também é possível  contar um `decay_level:`, com um valor superior ao do `sustain_level`

en: ADSR Envelopes
pt: Curvas de Envolvente ADSR

en: So to summarise, Sonic Pi's ADSR envelopes have the following phases:
pt: Em suma, curvas de envolvente do tipo ADSR no Sonic Pi têm as seguintes fases:

en: *attack* - time from 0 amplitude to the `attack_level`,
pt: *ataque* - tempo de amplitude 0 até ao `attack_level:`

en: *decay* - time to move amplitude from `attack_level` to `decay_level`,
pt: *decaimento* - tempo para mudar a amplitude de `attack_level:` até `sustain_level:`

en: *sustain* - time to move the amplitude from `decay_level` to `sustain_level`,
pt: *sustentação* - tempo para mudar a amplitude de `decay_level:` até `sustain_level:`

en: *release* - time to move amplitude from `sustain_level` to 0
pt: *extinção* - tempo para mudar a amplitude de `sustain_leve:` até 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:
pt: É importante notar que a duração de um som é a soma dos tempos de cada uma das fases. Portanto, o seguinte som vai durar 0.5 + 1 + 2 + 0.5 = 4 tempos:

en: Now go and have a play adding envelopes to your sounds...
pt: Agora vamos experimentar usar curvos de envolventes com os teus sons...

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.
pt: Outra boa maneira de criar a tua música é usar sons pré-gravados. Em hip-hop chamamos, tradicionalmente, estes sons de *samples*. Se levares um microfone para a rua, e gravares o som da chuva a bater nas lonas, acabaste de criar um sample, passível de ser usado neste contexto.

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...
pt: O Sonic Pi permite-te fazer coisas espectaculares com samples. Não só traz um banco de mais de 90 samples de domínio público prontos para serem usados, como te deixa tocar e manipular os teus. Vamos lá...

en: 3.1 Triggering Samples
pt: 3.1 Trigar Samples

en: Triggering Samples
pt: Trigar Samples

en: Playing beeps is only the beginning. Something that's a lot of fun is triggering pre-recorded samples. Try it:
pt: Tocar beeps é só o início. Uma coisa muito mais divertida é tocar samples pré-gravados. Experimenta:

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:
pt: O Sonic Pi traz muitos samples passíveis de serem usados. Podes usá-las usando o comando `play`. Para tocar vários samples e notas basta escreve-los de forma sequencial:

en: If you want to space them out in time, use the `sleep` command:
pt: Se quiseres separá-los temporalmente, usa o comando `sleep`:

en: Discovering Samples
pt: Descobrir Samples

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:
pt: Alternativamente, podes usar o sistema de auto-completação. Basta escreveres o início de um grupo de samples, como: `sample :ambi_` e vais ver um menu suspenso com nomes de samples. Experimenta os prefixos de categorias seguintes:

en: `:ambi_`
pt: ':ambi_'

en: Now start mixing samples into your compositions!
pt: Experimenta agora misturar samples nas tuas peças!

en: 3.2 Sample Parameters
pt: 3.2 Parâmetros dos Samples

en: Sample Parameters: Amp and Pan
pt: Parâmetros dos Samples: Amplitude e Panorâmica

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:`.
pt: Como vimos com sintetizadores, podemos, facilmente, controlar sons através do seu sistema de parametrização. Os samples suportam exactamente o mesmo mecanismo de parametrização. Vamos reexaminar os parâmetros  `amp:` e `pan:`.

en: Amping samples
pt: Usar Amplitude com samples

en: You can change the amplitude of samples with exactly the same approach you used for synths:
pt: Podes alterar a amplitude de samples com a mesma abordagem que usaste para os sintetizadores:

en: Panning samples
pt: Usar Panorâmica com Samples

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:
pt: Também podemos usar o parâmetro `pan:` com samples. Por exemplo, podemos repoduzir o *Amen Break* no ouvido esquerdo e depois, a meio, tocá-lo outra vez pelo ouvido direito:

en: Note that 0.877 is half the duration of the `:loop_amen` sample in seconds.
pt: Nota que 0.877 é metade da duração da sample `:loop_amen` em segundos.

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`.
pt: Finalmente, nota que se alterares algums valores pré-definidos dos sintetizadores com `use_synth_defaults` (vamos falar mais tarde), estes vão ser ignorados pelo `sample`

en: 3.3 Stretching Samples
pt: 3.3 Aplicar time stretching nos Samples

en: Stretching Samples
pt: Aplicar time stretching em Samples

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.
pt: Agora que sabemos como tocar uma variedade de sintetizadores e samples para criar música, está na hora de aprender a modificar tanto sintetizadores como samples para criar música com um som mais pessoal e  consequentemente interessante. Primeiro, vamos explorar a possibilidade de aplicar time-stretching em samples.

en: Sample Representation
pt: Representação de Samples

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.
pt: Samples são sons pré-gravados, guardados como números que representam como o diafragma da coluna em movimento com vista a gerar som. O diafragma da coluna pode mover-se para dentro ou fora, e então, os números representam o quão dentro ou fora tem de estar o cone para cada momento no tempo. Um sample normalmente tem de guardar vários milhares de números por segundo para para poder ser reproduzido com qualidade e precisão. O Sonic Pi pega nesses números e dá-os à velocidade certa para mover a coluna para dentro e fora e reproduzir o som. Mas também é divertido mudar a velocidade a que os números são alimentam o processo de conversão de sinal digital analógico para que as colunas gerem som.

en: Changing Rate
pt: Mudar a Velocidade (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`:
pt: Vamos brincar com um dos sons de ambiente: `:ambi_choir`. Para tocá-la à velocidade (rate) normal, podes passar a opt `rate:` com o valor `1`:

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`:
pt: Isto toca o sample à velocidade normal (1), nada de especial para já. Mas, podemos mudar esse valor para outro qualquer. Que tal `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.
pt: Wow! Que é que se passou aqui? Bem, duas coisas. Primeiro, o sample demora o dobro do tempo a ser reproduzido. segundo, o som está uma oitava abaixo. Vamos explorar estas coisas com um bocado mais de detalhe.

en: Let's stretch
pt: Vamos aplicar time-stretching ao som

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:
pt: Um sample que resulta muito bem com time-stretching é o "Amen Break". À velocidade normal, poderiamos pô-la numa música de *drum 'n' bass*:

en: However by changing the rate we can switch up genres. Try half speed for *old school hip-hop*:
pt: Contudo, ao mudar a velocidade podemos eventualmente entrar em domínios estéticos, e consequentemente géneros musicais diferentes. Tenta, transpor o sample para metade da velocidade, para obter uma espécie de "hip-hop old school":

en: If we speed it up, we enter *jungle* territory:
pt: Se aumentarmos a velocidade entramos no território *jungle*:

en: Now for our final party trick - let's see what happens if we use a negative rate:
pt: Agora para o nosso truque final -- vamos ver o que acontece se usarmos um valor de rate (velocidade) negativo:

en: Woah! It plays it *backwards*! Now try playing with lots of different samples at different rates. Try very fast rates. Try crazy slow rates. See what interesting sounds you can produce.
pt: Wow! Toca em sentido contrário! Agora experimenta samples diferentes com rates diferentes. Experimenta rates muito altas e muito lentas. Vê até que ponto consegues obter sons interessantes.

en: A Simple Explanation of Sample Rate
pt: Uma Explicação simples do Termo 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.
pt: Uma maneira de pensar em samples é como molas. Mudar a rate é como esticar ou encolher um mola. Se tocarmos a sample com `rate: 2`, estamos a encolher a mola para metade do seu comprimento normal, e então o sample demora metade do tempo a tocar por ser mais curta. Se tocarmos a sample com `rate: 0.5`, estamos a esticar a mola para o dobro do seu comprimento e, portanto, a sample demora o dobro do tempo a tocar por ser mais longa. Quanto a encolhermos (rate mais alta), esta fica mais curta, quanto mais a esticares (rate mais baixa), mais longa fica.

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*.
pt: Ao comprimir uma mola a sua densidade aumenta (número de voltas por cm) -- isto faz com que o sample soe *mais agudo*. Ao esticar a mola a sua densidade diminui e isso faz com que o sample acabe por soar *mais grave*.

en: The Maths Behind Sample Rate
pt: Vamos perceber o conceito de Sample Rate de um Ponto de Vista Matemático

en: (This section is provided for those that are interested in the details. Please feel free to skip it...)
pt: (Esta parte é para aqueles interessados nos detalhes. Podes passar à frente se não for o teu caso...)

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:
pt: Como vimos anteriormente, um sample é representada por uma lista grelha de representação de valores ao nível das suas coordenadas polares e cartesianas e consequentemente na sua representação através de pfft (fast Fourier transform) e que acabam por ter uma correlação com a fase do som e indicar-nos o ponto onde a coluna se deve encontrar ao longo do tempo. Podemos pegar nessa lista de números e usá-la para desenhar um gráfico que seria parecido com este:

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.
pt: Já deve ter visto imagens parecidas com esta anteriormente. Esta imagem consiste basicamente na forma de onda de um sample. É só uma gráfico de números. Normalmente, uma onda como esta terá 44100 pontos de informação por segundo (isto deve-se ao Teorema de Nyquist-Shannon), apesar de poder ter mais ou menos (48000, 96000, 192000, etc., resultando daí a necessidade de mais capacidade processamento, e consequentemente um nível superior de qualidade de audio, especialmente em processos de manipulação do áudio como time-stretching). Se o sample tiver a duração de 2 segundos, a onde vai ser representada por 88200 números, e iremos dar à coluna a uma velocidade de 44100 pontos por segundo. Claro, podíamos dá-los ao dobro da velocidade, que seria 88200 pontos por segundo. Levaria, portanto, apenas 1 segundo a tocar. Também podemos tocá-la a metade da velocidade, correspondente a 22050 pontos por segundo, demorando 4 segundos a tocar.

en: The duration of the sample is affected by the playback rate:
pt: A duração de um sample sample é afectada pela velocidade (rate):

en: Doubling the playback rate halves the playback time,
pt: O Dobro do rate diminui a duração para metade,

en: Halving the playback rate doubles the playback time,
pt: Metade do rate aumenta a duração para o dobro,

en: Using a playback rate of one fourth quadruples the playback time,
pt: Um rate de 1/4 multiplica a duração por quatro,

en: Using a playback rate of 1/10 makes playback last 10 times longer.
pt: Com um rate de 1/10 o sample acaba por durar 10 vezes mais.

en: We can represent this with the formula:
pt: Podemos representar isto com a seguinte fórmula:

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.
pt: Mudar o rate também afecta a altura (não confundir com volume!) da sample. A frequência, ou altura, de uma onda é determinada pela velocidade com que esta se move para cima ou para baixo. O nosso cérebro, de alguma forma, transforma o movimento rápido das colunas em notas agudas e movimento lento em notas graves. É por isso que às vezes conseguimos ver as colunas a mexer.

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.
pt: Se pegarmos numa onda e a encolhermos, ela vai mover-se para cima e para baixo mais vezes durante o nosso período de tempo, que corresponde  a um segundo (uma vibração por segundo corresponde. a um hz). Isto faz com que o som soe mais agudo. Acontece que  ao duplicar o número de oscilações (movimentos para cima e para baixo) duplica a frequência. Então, *tocar uma sample ao dobro do rate e isto duplica também a frequência a que esta é ouvida*. Do mesmo modo, *diminuir o rate para metade vai diminuir a frequência para metade*. Outros rates vão afectar a frequência da mesma maneira.

en: 3.4 Enveloped Samples
pt: 3.4 Samples controlados por curvas de envolvente

en: Enveloped Samples
pt: Samples controlados por curvas de envolvente

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.
pt: Também é possível modificar a *duração* e *amplitude* de um sample usando uma curva de envolvente do tipo ADSR. Contudo, isto funciona de forma ligeiramente diferente para curvas de envolvente ADSR disponíveis em sintetizadores. As curvas de envolvente dos samples apenas permitem reduzir a amplitude e duração de um sample - e acabam por não permitir aumenta-la. O sempre irá parar quando tanto o sample tiver terminado de tocar e a envolvente estiver concluída - que acaba por ser primeiro. Portanto, usa um valor de 'release' longo, e acabarás por não estender a duração do sample.

en: Amen Envelopes
pt: Curvas de Envolvente do Amen Sample

en: Let's return to our trusty friend the Amen Break:
pt: Vamos voltar ao nosso sample de eleição Amen Break:

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:
pt: Sem opts, ouvimos o sample completo, com toda a sua amplitude. Se quisermos fazer um fade durante 1 segundo usamos o parâmetro 'ataque':

en: For a shorter fade in, choose a shorter attack value:
pt: Para um fade in mais curto, escolha um valor de ataque mais curto:

en: Auto Sustain
pt: Sustain Automático

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.
pt: As curvas de envolvente do comportamento do ADSR difere da envolvente do sintetizar standard, ou pre-definido, no valor de *sustain*. Na envolvente do sintetizador pré-definida, o sustain é 0 por pré-definição a não ser que seja manualmente definido. Com samples, o valor de sustain é definido como default, para um valor automático - o tempo que demora a tocar o resto do sample. É por isto que nós ouvimos o sample completo quando passamos sem pré-definições. Se os valores de ataque, decay, sustain, e release forem todos 0 nós acabamos por nunca ouvir um peep. O Sonic Pi, acaba então por calcular a duração do sample que super-impõe qualquer ataque decay, e tempos de release e usa o resultado como valor de sustain. Se o valor de ataque, decay e release for superior à duração do sample, o sustain é simplesmente definido como 0.

en: To explore this, let's consider our Amen break in more detail. If we ask Sonic Pi how long the sample is:
pt: Para explorar isto, vamos considerar o Amen Break para mais detalhe. Se perguntarmos ao Sonic Pi durante quanto tempo sample se mantém activo

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:
pt: Isto irá imprimir o valor de `1.753310657596372` que possui a duração de um sample em segundos. Vamos agora arrendondá-lo para 1.75 para conveniência neste preciso momento. Agora, se definirmos a o valor do release para '0.75', also surpreendente acabará por acontecer:

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.
pt: Irá tocar durante o primeiro segundo do sample num nível de amplitude/pressão sonora/intensidade dinâmica/SPL total, antes de fazer um fade de um período de cerca de 0.75 segundos. Isto é o sustain automático, em acção. Por pré-definição, o tempo de release, outra extinção do som, funciona sempre a partir do fim do sample. Se o nosso sempre tiver 10.75 segundos de duração, este irá tocar durante os primeiro s dez segundos da sua execução em amplitude total antes de fazer um fade out durante cerca de. 0.75s.

en: Remember: by default, `release:` fades out at the end of a sample.
pt: Lembre-se: por pré-definição, o valor de 'release:' diminui até ao fim do sample.

en: Fade In and Out
pt: Fade In e Fade Out

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:
pt: Podemos usar tanto o valor de 'ataque:' e 'release:' juntos com o comportment de auto sustain para fazer tanto fade in como fade out durante a duração do sample:

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.
pt: Como a duração completamente do sample é 1.75s o nosso ataque e release (tempo de extinsão do som), demora cerca de 1.5s, sendo o sustain automaticamente definido para 0.25s. isto permite facilmente fazer fazer fade in e out do sample

en: Explicit sustain
pt: Sustain explicito

en: We can easily get back to our normal synth ADSR behaviour by manually setting `sustain:` to a value such as 0:
pt: Podemos facilmente voltar ao valor normal de ADSR do comportamento do sintetizador definindo manualmente o 'sustain' para um valor como 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.
pt: Agora, o nosso sample apenas reproduz durante 0.75 segundos no total. Por pré-definição o 'ataque:' e 'decay:' é 0, o sample salta automaticamente para a amplitude completa, adiciona ai os 0s e extinguindo-se então para 0 durante o perigo de release - 0.75s.

en: Percussive cymbals
pt: Címbalos percussivos

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`:
pt: É possível usar este comportamento para afectar positivamente e tornar sons mais longos em sons mais pequenos, e versões mais permissivas. Considere por exemplo o sample ':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:
pt: É possível ouvir o som dos pratos (cymbal), a tocar durante um determinado período de tempo. Contudo, podemos usar a nossa curva de envolvente para o tornar, enfim, mais percussivo:

en: You can then emulate hitting the cymbal and then dampening it by increasing the sustain period:
pt: É então possível emular o ataque de um prato (cymbal) e mantê-lo activo, aumentado o período de sustain

en: Now go and have fun putting envelopes over the samples. Try changing the rate too for really interesting results.
pt: Dedica-te agora a colocar curvas de envolvente nos samples. Tenta mudar a velocidade de sobremaneira para resultados realmente interessantes

en: 3.5 Partial Samples
pt: 3.5 Samples Parciais

en: Partial Samples
pt: Samples Parciais

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:
pt: Esta secção tem como propósito concluir a exploração do reprodutor de simples do Sonic Pi. Vamos fazer uma pequena recapitulação. Até agora foca-mo-nos em possíveis abordagens com vista a disparar samples:

en: We then looked at how we can change the rate of samples such as playing them at half speed:
pt: Observamos então formas de mudar a velocidade de samples tais como tocá-los a a metade da sua velocidade:

en: Next, we looked at how we could fade a sample in (let's do it at half speed):
pt: De seguida, ire-mo-nos focar em formas de introduzir um sample através de um fade in (vamos fazê-lo a metade da velocidade):

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:
pt: Também olhámos a formas que nos permitem usar o começo de um sample percursivamente dando-lhe 'sustain': um valor explícito e definir tanto o ataque como a release (extinção do som), para valores relativamente curtos:

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?
pt: Contudo, não seria interessante se nos não tivéssemos que começar no início do sample? Não também interessante se nós não tivesse que acabar sempre no fim do sample?

en: Choosing a starting point
pt: Escolhe um ponto de começo

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:
pt: É possível escolher um ponto de começo arbitrário no samples como um valor entre 0 e 1 onde 0 é o início do sample, 1 é o final, e 0.5 é metade da duração do sample. Vamos tentar tocar apenas a última parte do amen break:

en: How about the last quarter of the sample:
pt: E que tal um quarto do sample:

en: Choosing a finish point
pt: A escolher um ponto de conclusão

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:
pt: Do mesmo modo, é possível escolher um ponto arbitrário no sample como um valor entre 0 e 1. Vamos concluir a reprodução do amen break a metade da sua duração:

en: Specifying start and finish
pt: A especificar o início e o final

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:
pt: Claro está, podemos combinar estas duas formas de reproduzir segmentos arbitrários dos ficheiros de audio. E que tal uma pequena secção no meio:

en: What happens if we choose a start position after the finish position?
pt: O que acontece se escolhermos um ponto inicial depois da posição final?

en: Cool! It plays it backwards!
pt: Porreiro! Toca em sentido contrário!

en: Combining with rate
pt: A combinar com a velocidade

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:
pt: É possível combinar esta possibilidade de tocar arbitrariamente segmentos do audio com o nosso amigo 'velocidade:'. Por exemplo, podemos reproduzir um pequeno segmento do meio do amen break muito lentamente:

en: Combining with envelopes
pt: A combinar com curvas de envolvente

en: Finally, we can combine all of this with our ADSR envelopes to produce interesting results:
pt: Finalmente, podemos combinar tudo isto com as nossas curvas de envolvente de ADSR para produzir resultados interessantes:

en: Now go and have a play mashing up samples with all of this fun stuff...
pt: Agora vamos e temos um mash up de samples em reprodução com todas estas coisas interessantes...

en: 3.6 External Samples
pt: 3.6 Samples Externos

en: External Samples
pt: Samples Externos

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.
pt: Enquanto que os samples incorporados permitem a alguém iniciar o processo de interacção com a plataforma rapidamente, podes desejar experimentar com outros gravados na tua música. O Sonic Pi suporta isto de forma integral. Primeiro, deixa-me ter uma pequena discussão acerca da portabilidade da tua peça.

en: Portability
pt: Portabilidade

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.
pt: Quando compões uma peça apenas com samples e sintetizadores incorporados, o código é tudo o que precisas para reproduzir fielmente a tua música. Pensa nisto por um breve momento - é espetacular! Um pequeno excerto de texto permite-te enviar a música numa pen ou colocar o código no [Gist](https://gist.github.com)  representado tudo o que precisas para reproduzir os teus sons. Isto faz com que seja realmente simples partilhar com os teus amigos de forma a que eles precisem apenas do código para reproduzir a música

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.
pt: Contudo, se começares a usar os teus sons pré-gravados, perdes esta portabilidade. É por isso que ao reproduzir a tua música aos outras pessoas não precisem apenas do teu código, mas também precisem dos teus samples. Isto limita a possibilidade para outras pessoas manipularem, misturarem e experimentarem com o teu trabalho. É claro que não deves deixar de usar os teus samples, sendo apenas algo que deves considerar, decidindo então por ti a melhor forma para trabalhares.

en: Local Samples
pt: Samples Locais

en: Sonic Pi will automatically load and play the sample. You can also pass all the standard params you're used to passing `sample`:
pt: O Sonic Pir permite carregar automaticamente e tocar o sample. Também podes passar os parâmetros pré-definidos que costumas para passar como 'sample':

en: 3.7 Sample Packs
pt: 3.7 Pacotes de Samples

en: Sample Packs
pt: Pacotes 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.**
pt: **Nota: esta secção do tutorial cobre tópicos avançados de trabalho com grandes directórios dos teus próprios samples. Isto será o caso se tiveres feito download ou comprado o teu próprio pacote de samples e desejares usa-lo com o Sonic Pi.**

en: **Feel free to skip this if you're happy working with the built-in samples.**
pt: **Sente-te à vontade para saltar esta secção se estiveres contente com trabalhar com samples pré-incorporados**

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.
pt: Quando te encontrares a trabalhar com ficheiros grandes ou ficheiros externos também pode ser espectaculérrimo escrever o caminho completo para disparar um sample individual

en: For example, say you have the following folder on your machine:
pt: Por exemplo, vamos partir do princípio que tens a pasta abaixo na tua máquina:

en: When we look inside that folder we find the following samples:
pt: Quando olhamos para os conteúdos da pasta encontramos os seguintes samples:

en: `100_A#_melody1.wav`
pt: '100_A#_melody1.wav'

en: Typically in order to play the piano sample we can use the full path:
pt: Normalmente de modo a reproduzirmos o sample de piano apenas temo de usar o caminho completo:

en: If we want to then play the guitar sample we can use its full path too:
pt: Se quisermos tocar o sample de guitarra podemos usar este caminho, também

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?
pt: Contudo, ambas as evocação do sample exigem que saibamos os nomes dos samples dentro da nossa directoria. E que tal se quisermos apenas ouvir cada um dos samples individualmente de forma rápida?

en: Indexing Sample Packs
pt: A indexar as Bibliotecas 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:
pt: Se quisermos reproduzir o primeiro sample na directoria apenas precisamos de passar o nome do directório para 'sample' e o index a '0' tal como acontece abaixo

en: We can even make a shortcut to our directory path using a variable:
pt: Também podemos criar um atalho para a nossa directoria utilizando uma variável:

en: Now, if we want to play the second sample in our directory, we just need to add 1 to our index:
pt: Se agora quisermos reproduzir a segunda amostragem na nossa directoria, apenas é necessário adicionar 1 ao nosso índice:

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.
pt: Note-se que não mais é preciso conhecer os nomes das amostragens na directoria - apenas necessitamos de conhecer a própria directoria (ou ter um atalho para ela). Se pedirmos um índice que é maior do que o número de amostragens, simplesmente dará a volta da mesma foram que Rings. Portanto, qualquer que seja o número que for utilizado, é garantido que vamos obter uma das amostragens nessa directoria.

en: Filtering Sample Packs
pt: Como filtrar Pacotes de Amostragens

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:
pt: Geralmente indexar é o suficiente, mas algumas vezes precisamos de mais capacidade para organizar os samples. No entanto, muitos pacotes de samples contém informações úteis nos nomes dos arquivos. Vamos dar uma olhada nos nomes dos arquivos de sample em nosso diretório.

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.
pt: Note que há boas informações nos nomes dos arquivos. Primeiro, BPM (batidas por minuto)

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:
pt: Podemos usar essa convenção de nomeclatura apresentada nos exemplos para ajudar a filtrar o que queremos. Por exemplo, se estamos trabalhando em 120 BPM, podemos filtrar todos os exemplos que contenham '"120'" da seguinte maneira:

en: This will play us the first match. If we want the second match we just need to use the index:
pt: Isso tocará o primeiro resultado encontrado. Se quisermos o segundo, basta usar o índice:

en: Finally, we're still free to add our usual opts to the call to `sample`:
pt: Finalmente, podemos usar nossas próprias definições para chamar o 'sample':

en: Sources
pt: Código

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` files contained within the directories.
pt: `sample` fn  primeiro reunirá todos os códigos e os usará para criar uma grande lista de resultados possíveis. A lista é construída primeiro adicionando todos os caminhos de diretório válidos e depois todos os arquivos `.flac`, `.aif`, `.aiff`, `.wav`, `.wave`  encontrados nos diretórios.

en: For example, take a look at the following code:
pt: Por exemplo, dê uma olhada no seguinte código:

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).
pt: Aqui estamos combinando os samples encontrados em dois diretórios e adicionando um sample específico. Se  `"/path/to/my/samples/"` contém 3 samples e `"/path/to/my/samples2/"`  contém 12, temos 16 samples possíveis para indexar e filtrar ( 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:
pt: Por padrão, apenas os arquivos de sample dentro de um diretório são colhidos para a lista de resultados possíveis. Algumas vezes você pode querer pesquisar e filtrar em subdiretórios. Para isso, use a busca recursiva adicionando '**' ao final do diretório raiz.

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.
pt: Cuidado ao buscar em uma pasta com muitos subdiretórios porque poderá levar muito tempo.  Porém, os conteúdos serão guardados para utilização posterior e a demora acontecerá apenas na primeira vez.

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.
pt: Finalmente, note que as fontes precisam de ser definidas inicialmente. Se nenhuma fonte é indicada, os samples de origem serão usados como candidatos na lista padrão de trabalho.

en: Filters
pt: Filtros

en: Once you have a list of candidates you may use the following filtering types to further reduce the selection:
pt: Depois de teres uma lista de candidatos poderás usar os seguintes filtros para reduzir ainda mais a seleção:

en: `"foo"` Strings will filter on substring occurrence within file name (minus directory path and extension).
pt: `"foo"` As cadeias filtram ocorrências da sub-cadeia dentro do nome do ficheiro (menos o caminho da directoria e a sua extensão).

en: `/fo[oO]/` Regular Expressions will filter on pattern matching of file name (minus directory path and extension).
pt: `/fo[oO]/` Usando o padrão de "Expressões Regulares" para filtrar o nome do ficheiro (menos o caminho da directoria e a extensão do ficheiro).

en: `:foo` - Keywords will filter candidates on whether the keyword is a direct match of the filename (minus directory path and extension).
pt: `:foo` - Keywords filtra os candidatos com base na correspondência directa da palavra chave no nome do ficheiro (menos o caminho da directoria e a extensão do ficheiro).

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).
pt: `lambda{|a| ... }` - Função PROC com um argumento será tratada como um filtro de candidatos ou uma função geradora. Recebe uma lista de candidatos actuais e devolve uma nova lista de candidatos (uma lista de caminhos para os ficheiros de samples).

en: `1` - Numbers will select the candidate with that index (wrapping round like a ring if necessary).
pt: `1` - Números irão selecionar o candidato com esse índice (desdobrando o índice circularmente se necessário).

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:
pt: ,Por exemplo. podemos filtrar sobre todos os samples de uma directoria que contêm a cadeia `"foo"`e tocar o sample com a primeira correspondência a meia velocidade:

en: See the help for `sample` for many detailed usage examples. Note that the ordering of the filters is honoured.
pt: Consultar a ajuda para `sample` para exemplos mais detalhados de uso. Notar que a ordem dos filtros é honrada.

en: Composites
pt: Compósitos

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:
pt: Finalmente, poderá ser usadas listas sempre que se colocar uma fonte ou filtro. A lista será "achatada" e o seu conteúdo será tratado como uma fonte regular ou filtro. Assim as seguintes chamadas a `sample` são semanticamente equivalentes:

en: Wrapping Up
pt: Envolvendo

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.
pt: Esta é uma secção avançada para pessoas que necessitam  verdadeiro poder para manipular e usar pacotes de samples. Se muito desta secção não fizer sentido não se preocupe. É provável que não necessite de nenhuma da sua funcionalidade por agora. No entanto, saberá quando necessitar e poderá regressar e reler a secção quando começar a trabalhar com grandes directorias de samples.

en: 4 Randomisation
pt: 4 Randomização

en: Randomisation
pt: Randomização

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.
pt: Uma boa maneira de adicionar algum interesse à musica é usando números aleatórios. Sonic Pi apresenta uma excelente funcionalidade em adicionar aleatoriedade à sua musica, mas antes de começar temos que aprender a verdade chocante: no Sonic Pi *random não é verdadeiramente random*. O que raio quer isto dizer? Bem, vamos ver.

en: Repeatability
pt: Repetibilidade

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:
pt: Uma função verdadeiramente útil para gerar números aleatórios é `rrand` que devolve um número aleatório entre dois números - um *min* e um *max* (`rrand` é abreviatura de ranged random). Vamos tentar tocar uma nota aleatória:

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!
pt: Ooh, tocou uma nota aleatória. Tocou a nota `83.7527`. Um simpática nota entre 50 e 95. Espera, previ a mesma nota que tu? Algo estranho está a acontecer. Tenta correr o código novamente. O quê? Escolheu `83.7527` novamente? Isto não pode ser aleatório!

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.
pt: A resposta é que não é verdadeiramente aleatório, é pseudo-aleatório. Sonic Pi gera números pseudo-aleatórios de uma maneira repetível. Isto é bastante útil para assegurar que a musica que crias na tua maquina soa idêntica na maquina de qualquer pessoa - mesmo que use aleatoriedade na tua composição.

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:
pt: Claro que, numa dada peça de musica, se 'aleatoriamente' escolhe `83.7527`todas as vezes, não seria muito interessante. No entanto, não o faz. Experimente o seguinte:

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!
pt: Sim! Finalmente soa a aleatório. Numa dada *run* subsequentes chamadas à função random devolve valores aleatórios. No entanto, a próxima corrida ira produzir exactamente a mesma sequência de valores aleatórios e soa exactamente igual. É como se todo o código do Sonic Pi regressa-se no tempo exactamente ao mesmo ponto cada vez que se pressiona o botão Run. É o dia do Groundhog da síntese musical!

en: Haunted Bells
pt: Sinos amaldiçoados

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:
pt: Uma bonita ilustração da aleatoriedade em acção é o exemplo dos sinos amaldiçoados em que o loop do sample `:perc_bell` é tocado a uma velocidade e tempo de descanço aleatorio entre os sons de sinos.

en: Random cutoff
pt: Cutoff aleatório

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:
pt: Outro exemplo giro de aleatoriedade é a modificação do cutoff de um sintetizador de forma aleatória. Um bom sintetizador para experimentar isto é o emulador `:tb303`:

en: Random seeds
pt: Sementes para gerar números aleatórios

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!
pt: Então e se não gostares desta sequência em particular de números aleatórios que o Sonic Pi fornece? É totalmente possível escolher um diferente ponto de partida usando `use_random_seed` . A semente padrão usada para gerar números aleatórios é 0, escolhe uma semente diferente para uma diferente experiência aleatória!

en: Consider the following:
pt: Considera o seguinte:

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:
pt: Cada vez que corres este código, ouvirás a mesma sequência de 5 notas. Para ter uma diferente sequência simplesmente altera a semente:

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.
pt: Isto irá produzir uma sequência diferente de 5 notas. Ao alterar a semente e ouvindo o resultado poderás encontrar algo que gostes - e depois partilhar com outros, eles ouviram exactamente o que ouviste.

en: Let's have a look at some other useful random functions.
pt: Vamos ver algumas outras funções aleatórias úteis.

en: choose
pt: escolhe

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`:
pt: Algo bastante comum de se fazer é escolher um item aleatoriamente de uma determinada lista de itens conhecidos. Por exemplo, posso querer tocar uma nota da seguinte lista: 60, 65 ou 72. Posso conseguir isso com `choose`que me deixa escolher um item da lista. Primeiro coloco os meus números numa lista o que é feito envolvendo-os em parênteses rectos separados por virgulas: `[60, 65, 72]`. A seguir só temos que os passar ao `choose`:

en: Let's hear what that sounds like:
pt: Vamos ouvir como soa:

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)`:
pt: Já vimos `rrand`, mas voltando a ela. Ela devolve um número aleatório entre dois números exclusivamente. Isso significa que numa irá fornecer o máximo ou o mínimo - mas sim sempre algo entre os dois. O número será sempre um número flutuante - que não é um numero inteiro mas sim a fracção de um numero. Exemplo de números flutuantes devolvidos por `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:
pt: Ocasionalmente queremos um número inteiro e não um flutuante. É ai que a `rrand_i` nos vem ajudar. Trabalha da forma similar a ´rrand`excepto que pode devolver o min e o max como potencial número aleatório (o que significa que é inclusivo e não exclusivo nos limites). Exemplos de números devolvidos por `rrand_i(20,100)` são:

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:
pt: Isto devolve um número aleatório flutuante entre 0 (inclusive) e um valor máximo especificado (exclusivo). Por padrão irá devolver um valor entre 0 e 1. É assim útil para escolher valores aleatórios `amp:`:

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.
pt: Similarmente à relação entre `rrand_i` e `rrand`, `rand_i` irá devolver um número aleatório inteiro entre 0 e o valor máximo que especificaste.

en: dice
pt: Dado

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!
pt: Às vezes queres emular o lançamento de um dado - isto é um caso especial de `rrand_i` em que o valor mais baixo é 1. Chamar `dice` requer que especifiques o número de lados do dado. Um dado normal tem 6 lados, assim `dice(6)` irá se comportar de forma semelhante - devolvendo os valores 1, 2, 3, 4, 5 ou 6. No entanto, tal como nos jogos de role play, poderás encontrar dados de 4 lados, ou 12 ou 20, ou até mesmo uma dado de 120 lados.

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.
pt: Finalmente poderás querer emular o lançamento de uma pontuação máxima num dado tal como um 6 num dado normal. `one_in` devolve true com a probabilidade de um sobre o número de lados do dado. Assim `one_in(6)` irá devolver true com a probabilidade de 1 em 6 ou false em caso contrario. True e false são valores muito úteis nas declarações condicionais `if`, que serão descritas nas seguintes secções deste tutorial.

en: Now, go and jumble up your code with some randomness!
pt: Agora vai e enche o teu código de aleatoriedade!

en: 5 Programming Structures
pt: 5 estruturas de programação

en: Programming Structures
pt: Estruturas de programação

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...
pt: Agora que aprendemos o básico de como criar sons com `play` e `sample` e a criação de melodias simples e ritmos usando `sleep` entre os sons, perguntas-te o que mais o mundo do código te pode oferecer...

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.
pt: Vais ter uma agradável surpresa! Estruturas básicas de programação como looping, condicionais, funções e threads dão-te ferramentas extremamente poderosas para expressares as tuas ideias musicais.

en: Let's get stuck in with the basics...
pt: Vamos começar com o básico...

en: 5.1 Blocks
pt: 5.1 Blocos

en: Blocks
pt: Blocos

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:
pt: Uma estrutura que se vê bastante no Sonic Pi é um bloco. Um bloco permite-nos fazer coisas úteis com grandes pedaços de código. Podemos mudar algo que ocorre numa única linha de código com parâmetros de synth e sample. No entanto podemos querer fazer algo mais significativo a várias linhas de código. Por exemplo, podemos querer fazer um loop, adicionar reverb, apenas correr 1 vez a cada 5 vezes, etc. Considera o seguinte código:

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:
pt: Para fazer algo com um pedaço de código devemos dizer ao Sonic Pi onde o bloco *começa* e onde *acaba*. Usamos `do` para o começo e `end` para o fim. Por exemplo:

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.
pt: No entanto isto não está completo e não funcionará (tenta e terás um erro) uma vez que não dissemos ao Sonic Pi o que fazer com este *bloco do/end*. Dizemos isso aos Sonic Pi escrevendo um código especial antes do `do`. Iremos ver alguns destes pedaços especiais de código mais tarde neste tutorial. Por agora, é importante saber que envolvendo o teu código entre `do`e `end` diz ao Sonic Pi que queres fazer algo especial com esse pedaço de código.

en: 5.2 Iteration and Loops
pt: 5.2 Iteração e Loops

en: Iteration and Loops
pt: Iteração e Loops

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`.
pt: Até agora passamos imenso tempo a olhar para diferentes sons que podemos fazer com blocos `play` e `sample`. Também aprendemos como lançar esses sons no tempo usando `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.
pt: Como provavelmente descobriste, existe muito divertimento que se tem com estes blocos básicos de construção. No entanto, uma dimensão totalmente nova de divertimento abre-se quando começares a usar o poder do código para estruturar a tua musica e composições. Nas próximas secções iremos explorar essas novas poderosas ferramentas. Primeiro iteração e loops.

en: Repetition
pt: Repetição

en: Have you written some code you'd like to repeat a few times? For example, you might have something like this:
pt: Escreveste algum código e gostarias de o repetir algumas vezes? Por exemplo, podes ter algo como isto:

en: What if we wished to repeat this 3 times? Well, we could do something simple and just copy and paste it three times:
pt: Se quiseres repetir isto 3 vezes? O que podemos fazer é copiar e colar três vezes:

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.
pt: Isso é muito código! O que acontece se quiseres mudar o sample para `:elec_plip`? Terás de encontrar todos os locais onde aparece o `:elec_blup`original e os mudar. Mais importante, como repetir o código original 50 ou 1000 vezes? Isso é muito código, e muitas linhas de código para alterar se quiseres fazer uma mudança.

en: Iteration
pt: Iteração

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:
pt: De facto, alterar o código deverá ser fácil como dizer *faz isto 3 vezes*. Na verdade é isso. Lembraste do nosso velho amigo bloco de código? Podemos o usar para marcar o inicio e o fim do código que queremos repetir 3 vezes. Usamos então o código especial `3.times`. Assim, em vez de escrever *faz isto 3 vezes*, escrevemos `3.time do` - não é difícil. Não te podes esquecer de escrever `end` no final do código que queres repetir:

en: Now isn't that much neater than cutting and pasting! We can use this to create lots of nice repeating structures:
pt: Isto assim é bem mais limpo que cortar e colar. Podemos usar isto para criar elegantes estruturas repetitivas:

en: Nesting Iterations
pt: Iterações aninhadas

en: We can put iterations inside other iterations to create interesting patterns. For example:
pt: Podemos colocar iterações dentro de iterações e produzir padrões interessantes. Por exemplo:

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:
pt: Se quiseres que algo repita muitas vezes, poderás dar por ti a usar números grandes como `1000.times do`. Neste caso é provavelmente melhor pedir ao Sonic Pi para repetir para sempre (pelo menos até premires o botão stop). Vamos repetir o amen break para sempre:

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:
pt: a coisa importante a saber sobre loops é que eles actuam como buracos negros para o código. Uma vez que o código entra em loop nunca sairá até premires stop - irá repetir para sempre. Isso significa que se tiveres código após o loop nunca o irás ouvir. Por exemplo, o címbalo depois deste loop nunca será tocado:

en: Now, get structuring your code with iteration and loops!
pt: Agora podes estruturar o teu código com iterações e loops!

en: 5.3 Conditionals
pt: 5.3 Condicionais

en: Conditionals
pt: Condicionais

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.
pt: Uma coisa comum que certamente quererás fazer é não tocar só notas aleatórias (ver a secção anterior em aleatoriedade) mas também tomar decisões aleatórias baseadas no resultado do código que corre ou nalgum outro código. Por exemplo, poderás querer aleatoriamente tocar uma bateria ou címbalo. Podemos conseguir isso com uma declaração `if`.

en: Flipping a Coin
pt: Lançar uma moeda

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:
pt: Então, vamos lançar uma moeda: se for cara, toca a bateria, se for coroa, toca o címbalo. Podemos emular o lançamento da moeda com a nossa função `one_in` (introduzida na secção de aleatoriedade), especificando a probabilidade de 1 em 2: `one_in(2)`. Podemos usar esse resultado para decidir entre dois pedaços de código, o código que toca a bateria e o código que toca o címbalo.

en: Notice that `if` statements have three parts:
pt: Repara que a declaração `if` tem 3 partes:

en: The question to ask
pt: A questão a perguntar

en: The first choice of code to run (if the answer to the question is yes)
pt: A primeira escolha de código a executar (se a questão à pergunta for sim)

en: The second choice of code to run (if the answer to the question is no)
pt: A segunda escolha de código a executar (se a resposta à questão for não)

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.
pt: Tipicamente em linguagens de programação, a noção de sim é representada pelo termo `true` e a noção de não é representada pelo termo `false`. Assim temos que arranjar uma questão que nos dirá uma resposta `true` ou `false` o que é exactamente isso que o `one_in` faz.

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:
pt: Repara como a primeira escolha está envolvida entre o `if` e o `else` e a segunda escolha está envolvida entre o `else` e o `end`. Tal como os blocos do/end poderás colocar múltiplas linhas de código nesses espaços. Por exemplo:

en: This time we're sleeping for a different amount of time depending on which choice we make.
pt: Desta vez estamos a dormir por um determinado tempo diferente dependendo da escolha que fazemos.

en: Simple if
pt: if simples

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:
pt: Por vezes queremos opcionalmente executar apenas uma linha de código. Isto é possível colocando o `if` e depois a questão no final. Por exemplo:

en: This will play chords of different numbers with the chance of each note playing having a different probability.
pt: Isto irá tocar o acorde de diferentes números com a possibilidade de cada nota ter uma diferente probabilidade.

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.
pt: Fizeste uma killer bassline e um fat beat. Como os tocar ao mesmo tempo? Uma solução é interligar os dois manualmente - tocar algum baixo, depois um pouco de bateria, e mais algum baixo... No entanto, o tempo torna-se difícil de pensar, especialmente se começares a entrelaçar mais elementos.

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*.
pt: E se o Sonic Pi pode-se entrelaçar as coisas por ti automaticamente? Bem, ele pode, e fazes isso com algo chamado *thread*.

en: Infinite Loops
pt: Loops infinitos

en: To keep this example simple, you'll have to imagine that this is a phat beat and a killer bassline:
pt: Para manter este exemplo simples, terás que imaginar que isto é um fat beat e uma killer bassline:

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.
pt: Como discutimos previamente, loops são buracos negros para o programa. Uma vez neles nunca poderás sair até premires stop. Então como tocar ambos os loops ao mesmo tempo? Teremos que dizer ao Sonic Pi que queremos começar algo ao mesmo tempo que o resto do código. É ai que os threads vêm ao nosso auxilio.

en: Threads to the Rescue
pt: Threads ao auxilio

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!
pt: Envolvendo o primeiro loop num `in_thread` do bloco do/end dizemos aos Sonic Pi para correr o conteúdo do bloco *exactamente* ao mesmo tempo que a declaração seguinte ao bloco (que até é o segundo loop). Experimenta e ouvirás a bateria e o baixo entrelaçados.

en: Now, what if we wanted to add a synth on top. Something like:
pt: Agora e se queremos adicionar um synth por cima. Algo como:

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:
pt: Teremos o mesmo problema que anteriormente. O primeiro loop é tocado ao mesmo tempo que o segundo devido ao `in_thread`. No entanto, *o terceiro loop nunca é alcançado*. Assim necessitamos de outro thread:

en: Runs as threads
pt: Correr como 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.
pt: O que te pode supreender é que quando carregas no botão Run, está a criar um novo thread para o código correr. É por isso que carregando múltiplas vezes irá adicionar camadas de som umas sobre as outras. As próprias corridas são threads, elas irão entrelaçar automaticamente os sons por ti.

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:
pt: Quando aprenderes a conquistar o Sonic Pi, aprenderas que os threads são o bloco de construção mais importante da tua musica. Um dos importantes trabalhos que fazem é isolar a noção de *settings actuais* de outros threads.
    O que significa isso? Bem, quando trocas de synth usando o `use_synth` apenas estás a mudar de sintetizador na *thread actual* - nenhum outro thread terá a mudança de sintetizador. Vamos ver isto em pratica:

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.
pt: Repara como o som do meio foi diferente dos restantes? A declaração `use_synth` apenas afectou o thread onde estava e não o thread principal exterior que corre.

en: Inheritance
pt: Herança

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:
pt: Quando crias um novo thread com `in_thread`, o novo thread irá automaticamente herdar todas as settings actuais do thread corrente. Vamos ver isso:

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.
pt: Repara como a segunda nota foi tocada com o sintetizador `:tb303` apesar de ter sido tocada de uma thread separada? Todas as settings modificadas com as várias funções `use_*` irão se comportar da mesma maneira.

en: When threads are created, they inherit all the settings from their parent but they don't share any changes back.
pt: Quando os threads são criados eles herdam todas as settings dos seus pais mas não passam para eles qualquer mudança que tenham.

en: Naming Threads
pt: Nomeando threads

en: Finally, we can give our threads names:
pt: Finalmente, podemos dar nomes aos nossos 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?
pt: Vê o painel de registro quando corres este código. Vê como o regsitro reporta o nome do thread na mensagem?

en: Only One Thread per Name Allowed
pt: Apenas é permitido um Thread por nome

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:
pt: Uma ultima coisa sobre nomear threads é que apenas um thread de um determinado nome pode estar a correr ao mesmo tempo. Vamos explorar isto. Considera o seguinte código:

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.
pt: Vamos lá e cola isso num buffer e carrega o butão Run. Carrega-o uma série de vezes. Ouve a cacofonia de vários amen break looping fora de tempo entre eles. Ok, podes carregar o Stop agora.

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.
pt: Este é o comportamento que vemos sempre - se carregares o botão Run, as camadas de som sobrepõem-se às do som existente. Assim se tiveres um loop e carregares o botão Run 3 vezes, terás 3 camadas de loops a correr simultaneamente.

en: However, with named threads it is different:
pt: No entanto, com threads com nome é diferente:

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:
pt: Experimenta carregar o botão Run 3 vezes com este código. Apenas irás ouvir um amen break loop. Verás também isto no registro:

en: Sonic Pi is telling you that a thread with the name `:amen` is already playing, so it's not creating another.
pt: Sonic Pi diz que um thread com o nome `:amen`já está a tocar, e assim não irá criar outro.

en: This behaviour may not seem immediately useful to you now - but it will be very handy when we start to live code...
pt: Este comportamento pode não ser imediatamente útil para ti por enquanto - mas será muito quando começarmos com o live code...

en: 5.5 Functions
pt: 5.5 Funções

en: Functions
pt: Funções

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.
pt: Quando começares a escrever muito código, podes querer encontrar uma maneira de organizar e estruturar as coisas que forma elegante e de fácil compreensão. Funções são maneiras muito poderosas de conseguir isso. Elas dão-nos a habilidade de dar nome a uma serie de código. Vamos dar uma olhada.

en: Defining functions
pt: Definindo funções

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`.
pt: Aqui definimos uma nova função chamada `foo`. Fazemos isso com o nosso amigo bloco do/end e a palavra magica `define` seguida pelo nome que queremos dar à nossa função. Não temos que a chamar `foo`, podemos chamar-lhe o que quisermos como `bar`, `baz` ou idealmente algo com sentido para ti como `secção_principal`ou `lead_riff`.

en: Remember to prepend a colon `:` to the name of your function when you define it.
pt: Lembra-te de acrescentar dois pontos `:` ao nome da tua função quando a definires.

en: Calling functions
pt: Chamando funções

en: Once we have defined our function we can call it by just writing its name:
pt: Depois de definirmos a nossa função podemos a chamar escrevendo o seu nome:

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.
pt: Até podemos usar `foo` dentro de um bloco de iteração ou em qualquer lado que tenhamos escrito `play` ou `sample`. Isto dá-nos uma excelente maneira de nos expressar e cria palavras significativas para usar nas nossas composições.

en: Functions are remembered across runs
pt: As funções são recordadas ao longo das execuções

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:
pt: Até agora, cada vez que carregas no botão Run, o Sonic Pi começa completamente do zero. Ele não sabe nada excepto o que está no buffer. Não podes referir código noutro buffer ou noutra thread. No entanto as funções mudam isso. Quando defines a função, o Sonic Pi *lembra-se* dela. Vamos experimentar. Apaga todo o código na teu buffer e substitui por:

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`).
pt: Carrega no botão Run - ouve a tua função a tocar. Onde foi o código? Como é que o Sonic Pi sabe o que tocar? O Sonic Pi lembra-se da tua função - assim mesmo que apagues do buffer, ele lembra-se do que escreveste. Este comportamento apenas funciona com funções criadas usando o `define` (e `defonce`).

en: Parameterised functions
pt: Funções parametrizadas

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:
pt: Podes estar interessado em saber que tal como tu podes passar valores mínimos e máximos a `rrand`, tu também podes ensinar as tuas funções a aceitar argumentos. Vamos dar uma olhada:

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.
pt: Isto não é muito excitante, mas ilustra o ponto. Criamos a nossa versão de `play`chamada `my_player`que é parametrizada.

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.
pt: Os parâmetros devem vir a seguir ao `do` do bloco `define`, rodeados pela barra vertical `|` e separados por virgulas `,`. Podes usar qualquer palavra para o nome dos parâmetros.

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`.
pt: A magia acontece dentro do bloco `define`. Podes querer usar nomes de parâmetros como se fossem valores reais. Neste exemplo estou a tocar a nota `n`. Podes considerar que os parâmetros são uma espécie de promessa que quando o código corre serão substituídos por valores actuais. Fazes isso passando um parâmetro às função quando a chamas. Eu faço isso com `my_player 80` para tocar a nota 80. Dentro da definição da função, `n`é então substituído por 80, assim `play n`fica `play 80`. Quando a chamas novamente com `my_play 90`, o `n`é substituído por 90 e `play n`fica `play 90`.

en: Let's see a more interesting example:
pt: Vamos ver um exemplo mais interessante:

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`.
pt: Onde usei `repeat` como se fosse um número na linha `repeat.times do`. Também usei `root` como se fosse o nome de uma nota na minha chamada a `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!
pt: Vê como podemos escrever algo muito expressivo e facil à leitura movendo muito da nossa lógica para uma função!

en: 5.6 Variables
pt: 5.6 Variáveis

en: Variables
pt: Variáveis

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:
pt: Uma coisa útil a fazer no nosso código é dar nomes às coisas. Sonic Pi torna isto muito fácil: escreves o nome que queres usar, um sinal de igual (`=`), e a coisa que te queres lembrar:

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:
pt: Aqui "lembramo-nos" do símbolo `:loop_amen`na variável `sample_name`. Podemos agora usar `sample_name`em todo o lado que usaríamos `:loop_amen`. Por exemplo:

en: There are three main reasons for using variables in Sonic Pi: communicating meaning, managing repetition and capturing the results of things.
pt: Existem 3 razões principais para usar variáveis no Sonic Pi: comunicar significado, gerir repetições e capturar o resultado de coisas.

en: Communicating Meaning
pt: Comunicar sentido

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!
pt: Quando escreves código é fácil de pensar que estas a dizer ao computador como fazer coisas - desde que o computador perceba está Ok. No entanto é importante lembrar que não é só o computador que lê código. Outras pessoas podem o ler e tentar perceber o que se está a passar. Além disso, é provável que tenhas que ler o teu código no futuro e tentar perceber o que se passa. Apesar de poder parecer óbvio para ti agora - pode não o ser para outros ou o teu eu futuro!

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:
pt: Uma maneira de ajudar os outros a perceber o que o teu código está a fazer é adicionar comentários (como vimos na secção anterior). Outra coisa é usar nomes de variáveis com sentido. Vê este código:

en: Why does it use the number `1.7533`? Where did this number come from? What does it mean? However, look at this code:
pt: Porque usa o numero `1.7533`? De onde veio este número? O que significa? Vê agora este código:

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:
pt: Agora é muito mais claro o que `1.7533`significa: é a duração do sample `:loop_amen`! Claro, podes dizer porque não escrever simplesmente:

en: Which, of course, is a very nice way of communicating the intent of the code.
pt: Que, claro, é uma boa maneira de comunicar a intenção do código.

en: Managing Repetition
pt: Gerindo a repetição

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:
pt: Frequentemente vês muita repetição no teu código e quando queres mudar as coisas, tens que as mudar em muitos sítios. Vê este código:

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.
pt: Estamos a fazer muitas coisas com o `:loop_amen`! E se queremos ouvir como soa com outro loop sample como o `:loop_garzul`? Teremos de encontrar e substituir todos os `:loop_amen`s por `:loop_garzul`. Isso pode ser Ok se tiveres muito tempo - mas se tiveres a actuar em palco? As vezes não temos o luxo de tempo - especialmente se queres manter as pessoas a dançar.

en: What if you'd written your code like this:
pt: E se escreveres código como este:

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.
pt: Isto faz exactamente o mesmo que o anterior (experimenta). Também nos dá a habilidade de apenas mudar uma linha `sample_name = :loop_amen` para `sample_name = :loop_garzul`e mudamos em muitos sítios pela magia das variáveis.

en: Capturing Results
pt: Capturando resultados

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:
pt: Finalmente, uma boa motivação para usar variáveis é para capturar o resultados de coisas, podes querer fazer coisas com a duração do sample:

en: We can now use `sd` anywhere we need the duration of the `:loop_amen` sample.
pt: Agora podemos usar `sd` em qualquer lugar que necessitemos da duração do sample `:loop_amen`.

en: Perhaps more importantly, a variable allows us to capture the result of a call to `play` or `sample`:
pt: Talvez mais importante, a variável permite nos capturar o resultado da chamada a `play`ou a `sample`:

en: Now we have caught and remembered `s` as a variable, which allows us to control the synth as it is running:
pt: Agora capturamos e lembramos-nos de `s` como variável, que nos permite controlar o synth enquanto corre:

en: We'll look into controlling synths in more detail in a later section.
pt: Veremos como controlar os synths em mais detalhe numa secção posterior.

en: Warning: Variables and Threads
pt: Aviso: Variáveis and Threads

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*:
pt: Embora as variáveis sejam ótimas para dar nomes às coisas e capturar os resultados das coisas, é importante saber que elas normalmente só devem ser usadas localmente em um segmento. Por exemplo, *não faça isso*:

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:
pt: Há duas soluções para estes soluções. Primeiramente, não usar as mesmas variáveis em múltiplos loops em tempo real ou processos a correr concorrentemente. Por exemplo, o seguinte código  deverá sempre imprimir uma lista sorteada à medida que cada loop em tempo real tenha as suas variáveis separadas

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

en: 5.7 Thread Synchronisation
pt: 5.7 Sincronização de Threads

en: Thread Synchronisation
pt: Sincronização de 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.
pt: Quando te tornares suficientemente avançado em live coding com uma serie de funções e threads simultaneamente, irás notar que é bastante fácil fazer em erro num dos threads e o matar. Isso não é muito importante porque o podes reiniciar carregando no Run. No entanto, quando reinicias o thread ele está *fora de tempo* com os threads originais.

en: Inherited Time
pt: Herança de tempo

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.
pt: Como discutimos anteriormente, novos threads criados com `in_thread` herdam todas as definições do thread pai. Isto inclui o tempo corrente. Isto significa que os threads estarão sempre sincronizados uns com os outros quando começarem simultaneamente.

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.
pt: No entanto, quando começas um thread por si só, o seu tempo é improvável estar sincronizado com qualquer dos outros threads em execução.

en: Cue and Sync
pt: Fila e sincronização

en: Sonic Pi provides a solution to this problem with the functions `cue` and `sync`.
pt: O Sonic Pi oferece uma solução para este problema com as funções `cue`e `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.
pt: `cue`permite-nos enviar uma mensagem de "batimento cardiaco" para todos os outros threads. Por padrão os outro threads não estão interessados na mensagem. No entanto, podes registar interesse com a função `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.
pt: A coisa importante a saber é que `sync` é similar a `sleep`na medida que pára o thread corrente de fazer alguma coisa por um período de tempo. No entanto, com `sleep`especificas o tempo de espera enquanto com `sync`não sabes quanto tempo tens de esperar - uma vez que `sync`espera pelo próximo `cue`de outro thread que pode ser logo ou após um longo tempo.

en: Let's explore this in a little more detail:
pt: Vamos explorar isto em mais detalhe:

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.
pt: Aqui temos 2 threads - um actuando como um metronomo, não tocando nenhum som mas enviando a mensagem de batimento`:tick` a cada beat. O segundo thread está sincronizado na mensagem `tick` e quando recebe um herda o tempo do thread do `cue` e continua a correr.

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:
pt: Como resultado, ouviremos o sample `:drum_heavy_kick` exactamente quando o outro thread envia a mensagem `:tick`, mesmo que o dois threads não começaram o seu tempo de execução ao mesmo tempo:

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.
pt: A chamada maldosa `sleep`tipicamente faria o segundo thread fora de fase com o primeiro. No entanto, como estamos a usar `cue` e `sync`, automaticamente sincronizamos os threads evitando qualquer offset de tempo acidental.

en: Cue Names
pt: Nomes de Cues

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).
pt: És livre de usar qualquer nome que queiras para as tuas mensagens de `cue`- não apenas `:tick` . Só tens que assegurar que tal como os outros threads estão `sync`ronizados no nome correcto - ou então ficarão à espera para sempre (ou até carregares no botão Stop).

en: Let's play with a few `cue` names:
pt: Vamos jogar com alguns nomes de `cues`:

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.
pt: Aqui temos um `cue` loop principal que está aleatoriamente a enviar um batimento chamado `:foo`,`:bar` ou `:baz`. Temos também 3 loop threads sincronizando a cada um desses nomes independentemente e tocando um sample diferente. O efeito total é que ouvimos um som cada 0.5 batida porque cada `sync`thread é aleatoriamente sincronizado com a thread `cue` e toca o seu sample.

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`.
pt: Isto claro que também funciona se inverteres a ordem dos threads pois eles os threads `sync` simplesmente esperam pela próxima `cue`.

en: 6 FX
pt: 6 Efeitos

en: Studio FX
pt: Estudio de efeitos

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.
pt: Um dos mais gratificantes e divertidos aspectos do Sonic Pi é a habilidade de facilmente adicionar efeitos de estúdio aos nossos sons. Por exemplo, podes querer adicionar algum reverb a partes das tua peça, ou algum eco ou até distorção ou vibração à tua linha de baixo.

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...
pt: Sonic Pi fornece uma maneira simples mas poderosa de adicionar efeitos. Até permite o encadeamento deles (para que possas passar os teus sons pela distorção, depois echo e depois reverb) e além disso controlar individualmente cada unidade de efeito com opts (numa maneira similar a dar parâmetros a synths e samples). Podes até modificar as opts dos efeitos com ele a correr. Assim por exemplo, podes aumentar o reverb do teu baixo ao longo da faixa...

en: Guitar Pedals
pt: Pedais de guitarra

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 his or her 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:
pt: Se tudo isto soa complicado, não te preocupes. Uma vez que brinques um pouco com isto, tudo se tornará claro. Até lá uma simples analogia é a de pedais de efeitos de guitarra. Existem muitos tipos diferentes de pedais de efeitos que podes comprar. Alguns adicionam reverb, outros distorcem, etc. Um guitarrista liga a guitarra um um pedal, p. ex. distorção -, depois com outro cabo conecta (encadeia) a um pedal de reverb. A saída do pedal de reverb pode então ser ligada ao amplificador:

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, you can imagine a guitarist playing whilst someone plays with the FX controls whilst they're playing. Sonic Pi also supports this - but instead of needing someone else to control things for you, that's where the computer steps in.
pt: Isto é chamado encadeamento de efeitos. O Sonic Pi suporta exactamente isto. Adicionalmente, cada pedal tem dials e sliders que te permitem controlar a quantidade de distorção e reverb, eco, etc. a aplicar. Sonic Pi também suporta este tipo de controlo. Finalmente imagina um guitarrista a tocar enquanto alguém controla os efeitos enquanto toca. O sonic Pi também suporta isto - mas em vez de necessitares alguém para controlar as coisas por ti, usamos o computador.

en: Let's explore FX!
pt: Vamos explorar os efeitos!

en: 6.1 Adding FX
pt: 6.1 Adicionando efeitos

en: Adding FX
pt: Adicionando efeitos

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.
pt: Nesta secção iremos ver um par de efeitos: rever e eco. Veremos como os usar, como controlar as suas opts e como os podemos encadear.

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.
pt: O sistema de efeitos do Sonic Pi usa blocos. Se ainda não leste a secção 5.1 podes dar uma pequena mirada e depois regressar.

en: If we want to use reverb we write `with_fx :reverb` as the special code to our block like this:
pt: Se queremos usar reverb escrevemos `with_fx :reverb` como o código especial do nosso bloco desta forma:

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.
pt: Agora toca este código e ouviras a tocar com reverb. Soa bem, não soa! Tudo soa bem com reverb.

en: Now let's look what happens if we have code outside the do/end block:
pt: Agora vamos ver o que acontece se tivermos código fora do bloco 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.
pt: Repara que a nota final `play 55`não é tocada com reverb. Isto é porque está *fora* do bloco do/end, não sendo capturada pelo efeito reverb.

en: Similarly, if you make sounds before the do/end block, they also won't be captured:
pt: Similarmente, se fizeres sons antes do bloco do/end, também não serão capturados:

en: Echo
pt: Eco

en: There are many FX to choose from. How about some echo?
pt: Existem muitos efeitos para escolher. Que tal algum eco?

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:
pt: Um dos aspectos poderosos dos blocos de efeitos do Sonic Pi é que podem ser passadas opts similares às opts que já vimos com `play` e `sample`. Por exemplo uma opt divertida de se brincar é a `phase:` que representa a duração de um determinado eco em beats. Vamos tornar o eco mais lento:

en: Let's also make the echo faster:
pt: Vamos também ver o eco mais rápido:

en: Let's make the echo take longer to fade away by setting the `decay:` time to 8 beats:
pt: Vamos tornar o eco mais longo até desaparecer colocando o tempo de `decay:`para 8 beats:

en: Nesting FX
pt: Aninhando efeitos

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:
pt: Um dos mais poderosos aspectos dos blocos de efeitos é que podem ser aninhados. Isto permite facilmente encadear efeitos. Por exemplo, se quisermos tocar algum código com eco e a seguido de reverb? Fácil, basta colocar um dentro de outro:

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.
pt: Pensa no audio fluindo de dentro para fora. O som do código dentro no bloco do/end interior como o `play 50` é primeiro enviado para o efeito de eco e o som do efeito de eco é então enviado para o efeito de reverb.

en: We may use very deep nestings for crazy 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.
pt: Podemos usar aninhamentos muito profundos para resultados estranhos. No entanto, um aviso, os efeitos podem usar muitos recursos, e quando os aninhas efectivamente estas a usar múltiplos efeitos simultaneamente. Limita o uso de efeitos especialmente em plataformas com pouco poder como o Raspberry Pi.

en: Discovering FX
pt: Descobrindo efeitos

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:
pt: O Sonic Pi vem com um grande número de feitos para brincares com eles. Para descobrires quais estão disponíveis, clica no botão FX no lado esquerdo deste sistema de ajuda e verás uma listagem das opções disponíveis. Aqui vai uma lista dos meus favoritos:

en: wobble,
pt: Ondular,

en: echo,
pt: eco,

en: distortion,
pt: distorção,

en: slicer
pt: fatiador

en: Now go crazy and add FX everywhere for some amazing new sounds!
pt: Agora fica maluco e adiciona efeitos em todo lado para incríveis novos sons!

en: 6.2 FX in Practice
pt: 6.2 Efeitos na pratica

en: FX in Practice
pt: Efeitos na pratica

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.
pt: Apesar de parecerem relativamente simples exteriormente, os efeitos são uma besta realmente complexa internamente. A sua simplicidade faz com que as pessoas os usem demasiado nas suas peças. Isto pode não ter importância se tiverem uma maquina poderosa mas se - tal como eu - usares uma Rasperry Pi para tocar, terás de ter atenção à quantidade de trabalho que pedes para fazer de forma a garantir que a batida continue a correr.

en: Consider this code:
pt: Considera este código:

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...
pt: Neste código estamos a tocar a nota 60 com um muito pequeno tempo de release, é uma nota curta. Também queremos reverb assim embrulhamos num bloco de reverb. Até aqui tudo bem. Excepto...

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.
pt: Vamos ver o que este código faz. Primeiro temos um `loop` que significa que tudo dentro dele é repetido para sempre. A seguir temos um bloco `with_fx`. Isto significa que criamos um novo efeito de reverb *cada vez que repetimos*. Isto é como ter um pedal de reverb para cada vez que tocamos na corda da guitarra. É muito cool que se possa fazer isso, mas não é sempre o que queres fazer. Por exemplo, este código terá dificuldade em correr bem no Raspberry Pi. Todo o trabalho de criar o reverb e depois esperar até que tenha que ser parado e removido é tratado por `with_fx` por ti, mas isso requer poder de CPU que pode ser precioso.

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:
pt: Como o tornamos mais similar ao setup tradicional em que o guitarrista tem apenas *um* pedal de reverb e todo o som passa por ele? Simples:

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.
pt: Colocamos o nosso loop *dentro* do bloco `with_fx`. Desta forma apenas criamos um simples reverb para todas as notas do nosso loop. Este código é muito mais eficiente e executa bem num Raspberry Pi.

en: A compromise is to use `with_fx` over an iteration within a loop:
pt: Um compromisso é usar `with_fx`numa iteração dentro do loop:

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.
pt: Desta forma tiramos o `with_fx`fora da parte interior do `loop`e criamos um novo reverb a cada 16 notas.

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:
pt: Este é um padrão muitos comum que o `with_fx` suporta uma opção que faz exactamente isto mas sem ter de escrever o bloco `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.
pt: Tanto o exemplo `reps: 16` como o `16.times do` irão se comportar de forma idêntica. O `resp: 16` essencialmente repete o código no bloco `do/end` 16 vezes assim podes usar um ou outro conforme preferires.

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.
pt: Lembra-te não existem erros, apenas possibilidades. No entanto, algumas destas abordagens terão diferentes sons e características de performance diferentes. Brinca com isso e usa a abordagem que soa melhor para ti trabalhando na performance dentro dos constrangimentos da tua plataforma.

en: 7 Control
pt: 7 Controlo

en: Controlling running sounds
pt: Controlando sons que correm

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.
pt: Até agora vimos como podemos despoletar synths e samples, a como podemos mudar as suas opções padrão como a amplitude, panorâmica, envelope e entre outras. Cada som despoletado é essencialmente o seu próprio som com a sua lista de opções durante a sua duração.

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?
pt: Não seria porreiro se pudesse-mos mudar as opções de som quando ele esta a ser tocado, tal como dobramos a corda de uma guitarra enquanto ela ainda esta a vibrar?

en: You're in luck - this section will show you how to do exactly this.
pt: Estás com sorte - esta secção mostra-te como podes fazer exactamente isso.

en: 7.1 Controlling Running Synths
pt: 7.1 Controlando Synths em execução

en: Controlling Running Synths
pt: Controlando Synths em execução

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:
pt: Até agora apenas nos preocupamos em despoletar novos sons e efeitos. No entanto, o Sonic Pi dá-nos a habilidade de manipular e controlar sons em execução. Fazemos isso usando uma variável para capturar a referencia a um 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.
pt: Aqui temos uma variável de execução local `s` que representa o synth a tocar a nota 60. Nota que é *run-local* - não poderás aceder a ela a partir de outras corridas como as funções.

en: Once we have `s`, we can start controlling it via the `control` function:
pt: Depois de termos `s`, podemos começar a controlar-la via a função `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.
pt: A coisa a reparar é que não estamos a despoletar 4 synths diferentes - estamos apenas a despoletar um synth e posteriormente mudamos o pitch 3 vezes, enquanto é tocado.

en: We can pass any of the standard opts to `control`, so you can control things like `amp:`, `cutoff:` or `pan:`.
pt: Podemos passar qualquer das opções padrão ao `control`, assim podes controlar coisas como `amp:`, `cutoff:` ou `pan:`.

en: Non-controllable Options
pt: Opções não controláveis

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.
pt: Algumas das opções não podem ser controladas depois do synth ter começado. Este é o caso para todos os parâmetros dos envelopes ADSR. Podes descobrir que opções podem ser controlados vendo a documentação no sistema de ajuda. Se na documentação diz *Can not be changed once set*, saberás que não é possível controlar as opções depois do synth ter sido iniciado.

en: 7.2 Controlling FX
pt: 7.2 Controlando os efeitos

en: Controlling FX
pt: Controlando os efeitos

en: It is also possible to control FX, although this is achieved in a slightly different way:
pt: É também possível controlar os efeitos, apesar de isto ser feito de uma maneira ligeiramente diferente:

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.
pt: Em vez de usar uma variável, usamos um parâmetro de meta do bloco do/end. Dentro das barras `|`, necessitamos especificar um nome único para o nosso efeito em execução no qual então fazemos referencia no respectivo bloco do/end. Este comportamento é idêntico ao uso de funções parametrizadas.

en: Now go and control some synths and FX!
pt: Vai agora e controla alguns synths e efeitos!

en: 7.3 Sliding Options
pt: 7.3 Opções deslizantes

en: Sliding Opts
pt: Opções deslizantes

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.
pt: Enquanto exploravas as opções dos synth e efeitos, poderás ter reparado que existe um número de opções terminando com `_slide`. Podes até ter tentado as chamar e não veres nenhum efeito. Isto é porque eles não são parâmetros normais, eles são opções especiais que apenas funcionam quando controlares synths como introduzido na secção anterior.

en: Consider the following example:
pt: Considera o exemplo seguinte:

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:
pt: Aqui, podes ouvir o pitch do synth mudar imediatamente a cada chamada a `control`. No entanto, podemos querer que o pitch deslize entre as mudanças. Ao controlarmos o parâmetro `note:`, para adicionar o deslizamento, necessitamos de definir o parâmetros `note_slide` no 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.
pt: Agora podemos ouvir as notas a serem dobradas entre as chamadas a `control`. Soa bem ,não soa? Podes acelerar o deslizamento usando um tempo mais curto como `note_slide: 0.2` ou abrandar usando um tempo mais longo.

en: Every parameter that can be controlled has a corresponding `_slide` parameter for you to play with.
pt: Cada parâmetro pode ser controlado como um parâmetro `_slide` correspondente para tu brincares com ele.

en: Sliding is sticky
pt: Deslizamento é permanente

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.
pt: Uma vez definido um parâmetro `_slide` num synth em execução, ele será lembrado e usado cada vez que deslizes o parâmetro correspondente. Para parar o deslizamento, terás que definir o valor de `_slide` a 0 antes da próxima chamada a `control`.

en: Sliding FX Opts
pt: Deslizando opções de efeitos

en: It is also possible to slide FX opts:
pt: É também possível deslizar opções de efeitos:

en: Now have fun sliding things around for smooth transitions and flowing control...
pt: Agora diverte-te deslizando coisas para suavizar transições e controlo do fluxo...

en: 8 Data Structures
pt: 8 Estruturas de dados

en: Data Structures
pt: Estruturas de dados

en: A very useful tool in a programmer's toolkit is a data structure.
pt: Uma ferramenta muito útil na caixa de ferramentas de um programador é uma estrutura de dados.

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.
pt: As vezes podes querer representar e usar mais do que uma coisa. Por exemplo, pode ser útil teres uma serie de notas a tocar umas a seguir as outras. Linguagens de programação têm estruturas de dados que te permitem fazer exactamente isso.

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.
pt: Existem muitas estruturas de dados excitantes e exóticas disponíveis para os programadores - as pessoas estão sempre a inventar novas. No entanto, por enquanto precisamos apenas de considerar uma muito simples - a lista.

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.
pt: Vamos ver em mais detalhe. Descrevemos a forma básica e depois como as listas podem ser usadas para representar escalas e acordes.

en: 8.1 Lists
pt: 8.1 Listas

en: Lists
pt: Listas

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:
pt: Nesta secção vamos dar uma vista de olhos à estrutura de dados que é bastante útil - a lista. Já encontramos anteriormente na secção de aleatoriedade quando escolhíamos de uma lista de notas a tocar:

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:
pt: Nesta secção iremos explorar o uso de listas para representar acordes e escalas. Primeiro vamos recapitular em como poderemos querer tocar um acorde. Lembra-te que se não usarmos o `sleep`, o som acontece todo ao mesmo tempo:

en: Let's look at other ways to represent this code.
pt: Vamos ver outras maneiras de representar este código.

en: Playing a List
pt: Tocando uma lista

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:
pt: Uma das opções é colocar todas as notas numa lista: `[52, 55, 59]`. O nosso amigável `play` é suficientemente esperto para saber como tocar uma lista de notas. Tenta:

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:
pt: Ooh, já é bastante melhor de se ler. Tocar uma lista de notas não te impede de usar qualquer outro parâmetro normalmente:

en: Of course, you can also use the traditional note names instead of the MIDI numbers:
pt: Claro, que poderás usar o nome tradicional das notas em vez do seu número 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.
pt: Aqueles sortudos que estudaram teoria musical poderão reconhecer o acorde como *Mi Menor* tocado na terceira oitava.

en: Accessing a List
pt: Acedendo à lista

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.
pt: Uma outra característica bastante útil numa lista é a habilidade de receber informação dela. Isto pode soar estranho, mas não é mais complicado do que alguém pedir para abrir o livro na pagina 23. Com uma lista, dizes, qual é o elemento do índice 23? A única coisa estranha é que os índices na programação geralmente começam do 0 e não do 1.

en: With list indexes we don't count 1, 2, 3... Instead we count 0, 1, 2...
pt: Com os índices das listas não contamos 1, 2, 3... Em vez disso contamos 0, 1, 2...

en: Let's look at this in a little more detail. Take a look at this list:
pt: Vamos ver isto em mais detalhe. Vê esta lista:

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:
pt: Não existe nada assustador sobre isto. Agora, qual é o segundo elemento da lista? Sim , claro que é o `55`. É fácil. Vamos ver se o computador dá a mesma resposta que nós:

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:
pt: Ok, isto é um pouco esquisito se não tinhas visto algo assim anteriormente. Acredita em mim, não é difícil. Existe 3 partes na linha acima: a palavra `puts`, a nossa lista `52, 55, 59` e o nosso índice`[1]`. Primeiro estamos a dizer `puts` porque queremos que o Sonic Pi imprima a resposta no registo. Segundo, estamos a dar a nossa lista e finalmente o índice está a perguntar pelo segundo elemento. Necessitamos de rodear o nosso índice com parênteses rectos e como a contagem começa do `0`, o índice do segundo elemento é `1`. Olha:

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...
pt: Tenta correr o código `puts [52, 55, 59][1]`e verás `55` aparecer no registo. Muda o indice `1`para outros índices, tenta listas maiores e pensa em como podes usar uma lista na próxima sessão de jam. Por exemplo, que estruturas musicais podem ser representadas por uma serie de números...

en: 8.2 Chords
pt: 8.2 Acordes

en: Sonic Pi has built-in support for chord names which will return lists. Try it for yourself:
pt: O Sonic Pi tem suporte incluído para nomes de acordes que devolverão listas. Tenta por ti próprio:

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:
pt: Agora estamos a chegar a algum lado. Isso parece mais bonito que as listas em bruto (e são mais fáceis de ler para outras pessoas). Assim que outros acordes o Sonic Pi suporta? Bem, *muitos*. Tenta alguns destes:

en: Arpeggios
pt: Arpejos

en: We can easily turn chords into arpeggios with the function `play_pattern`:
pt: Podemos facilmente transformar acordes em arpejos com a função `play_pattern`:

en: Ok, that's not so fun - it played it really slowly. `play_pattern` will play each note in the list separated with a call to `sleep 1` between each call to `play`. We can use another function `play_pattern_timed` to specify our own timings and speed things up:
pt: Ok, isto não é tão divertido - tocou muito devagar. `play_pattern` irá tocar cada nota na lista separada com uma chamada a `sleep 1` entre cada chamada a `play`. Podemos usar outra função `play_pattern_timed` para especificar o nosso próprio tempo e acelerar as coisas:

en: We can even pass a list of times which it will treat as a circle of times:
pt: Podemos até passar uma lista de tempos que ira ser tratada como um circulo de tempos:

en: This is the equivalent to:
pt: Isto é equivalente a:

en: Which would you prefer to write?
pt: Qual preveres escrever?

en: 8.3 Scales
pt: 8.3 Escalas

en: Scales
pt: Escalas

en: Sonic Pi has support for a wide range of scales. How about playing a C3 major scale?
pt: O Sonic Pi suporta uma grande quantidade de escalas. Que tal tocar uma escala de Dó maior na 3 oitava?

en: We can even ask for more octaves:
pt: Podemos até pedir mais oitavas:

en: How about all the notes in a pentatonic scale?
pt: Que tal todas as notas de uma escala pentatónica?

en: Random notes
pt: Notas aleatórias

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:
pt: Acordes e escalas são óptimas maneiras de constranger as escolhas aleatórias em algo significativo. Brinca com este exemplo que escolhe notas aleatórias do acorde Mi3 menor:

en: Try switching in different chord names and cutoff ranges.
pt: Tenta diferentes acordes e distancias de corte.

en: Discovering Chords and Scales
pt: Descobrindo acordes e escalas

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).
pt: Para saber que escalas e acordes são suportados pelo Sonic Pi simplesmente clica no botão Lang na esquerda estrema a este tutorial e escolhe acorde ou escala na lista de API. Na informação do painel principal, no final verás uma longa lista de acordes e escalas (dependendo de qual estiveres a ver).

en: Have fun and remember: there are no mistakes, only opportunities.
pt: Diverte-te e lembra-te, não existem erros, apenas oportunidades.

en: 8.4 Rings
pt: 8.4 Anéis

en: Rings
pt: Anéis

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.
pt: Um variação interessante às listas padrão são os anéis. Se sabes alguma programação, poderás conhecer buffers em anel ou arrays em anel. Aqui chamam-se apenas anéis - é curto e simples.

en: In the previous section on lists we saw how we could fetch elements out of them by using the indexing mechanism:
pt: Na secção anterior sobre listas vimos que podíamos obter elementos dela usando o mecanismo de indexação:

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.
pt: O que acontece se queremos o índice `100`? Bem, claramente que não existe elemento no índice 100 porque a lista só tem 3 elementos. Assim o Sonic Pi devolve `nil` que significa nada.

en: However, consider you have a counter such as the current beat which continually increases. Let's create our counter and our list:
pt: No entanto, considera que temos um contador tal como a batida corrente que aumenta continuamente. Vamos criar o nosso contador e a nossa lista:

en: We can now use our counter to access a note in our list:
pt: Podemos usar o nosso contador para aceder a nota na nossa lista:

en: Great, we got `52`. Now, let's increment our counter and get another note:
pt: Boa, obtemos `52`. Agora, vamos aumentar o nosso contador e obter outra nota:

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.
pt: Fantástico, agora obtemos `55`e se o fizéssemos outra vez obteria-mos `59`. No entanto, se o fizéssemos outra vez, ficaríamos sem números na nossa lista e obteríamos `nil`. E se quiséssemos regressar ao inicio da lista novamente? É para isto que os anéis servem.

en: Creating Rings
pt: Criando anéis

en: We can create rings one of two ways. Either we use the `ring` function with the elements of the ring as parameters:
pt: Podemos criar anéis de duas maneiras. Ou usamos a função `ring` com os elementos do anel como parâmetros:

en: Or we can take a normal list and convert it to a ring by sending it the `.ring` message:
pt: Ou podemos usar uma lista normal e converter num anel enviando a mensagem `.ring`:

en: Indexing Rings
pt: Indexando anéis

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:
pt: Depois de termos um anel, podemos usar exactamente da mesma maneira que usaríamos uma lista normal com a excepção que podemos usar índices que são negativos ou maiores que o tamanho do anel e eles enrolam de forma a apontar sempre para um elemento do anel:

en: Using Rings
pt: Usando anéis

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.
pt: Imagina que estamos a usar uma variável que representa o número corrente do beat. Podemos usar isto como índice no nosso anel para buscar notas a tocar, ou tempos de release ou qualquer coisa útil que podemos armazenar no nosso anel independentemente do número de beat que estamos correntemente.

en: Scales and Chords are Rings
pt: Escalas e acordes são anéis

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.
pt: Uma coisa útil é que as listas devolvidas por `scale` e `chord` são também anéis e permitem que os acedas com índices arbitrários.

en: Ring Constructors
pt: Construtores de anéis

en: In addition to `ring` there are a number of other functions which will construct a ring for us.
pt: Além de `ring` existem algumas outras funções que constroem um anel por nós.

en: `range` invites you specify a starting point, end point and step size.
pt: `range` convida-te a especificar um ponto de inicio, um ponto final e um tamanho de passo.

en: `bools` allows you to use `1`s and `0`s to succinctly represent booleans.
pt: `bools` permite usar `1`s e `0`s para sucintamente representar booleans.

en: `knit` allows you to knit a sequence of repeated values.
pt: `knit`permite-te tricotar uma sequência de valores repetidos.

en: `spread` creates a ring of bools with a Euclidean distribution.
pt: `spread` cria um anel de bools com uma distribuição Euclidiana.

en: Take a look at their respective documentation for more information.
pt: Dá uma vista de olhos na documentação respectiva para mais informação.

en: 8.5 Ring Chains
pt: 8.5 Cadeia de anéis

en: Ring Chains
pt: Cadeia de anéis

en: In addition to the constructors such as `range` and `spread` another way of creating new rings is to manipulate existing rings.
pt: Para além de construtores como `range` e `spread` outra maneira de criar novos anéis é manipular anéis existentes.

en: Chain Commands
pt: Cadeia de comandos

en: To explore this, take a simple ring:
pt: Para explorar isto, vê este anel simples:

en: What if we wanted it backwards? Well we'd use the chain command `.reverse` to take the ring and turn it around:
pt: E se o quisermos ao contrario? Usamos a cadeia de comando `.reverse` para pegar no anel e o rodar:

en: Now, what if we wanted the first three values from the ring?
pt: Agora, e se quisermos os 3 primeiros valores do anel?

en: Finally, what if we wanted to shuffle the ring?
pt: Finalmente, e se quisermos baralhar o anel?

en: Multiple Chains
pt: Múltiplas cadeias

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.
pt: Isto já é uma maneira poderosa de criar novos anéis. No entanto, o poder *real* vem quando encadeias alguns destes comando em conjunto.

en: How about shuffling the ring, dropping 1 element and then taking the next 3?
pt: Que tal baralhar o anel, largar o 1 elemento e obter os 3 posteriores?

en: Let's take this in stages:
pt: Vamos fazer isso por etapas:

en: `(ring 10, 20, 30, 40, 50)` - our initial ring
pt: `(ring 10, 20, 30, 40, 50)` - o nosso anel inicial

en: `(ring 10, 20, 30, 40, 50).shuffle` - shuffles - `(ring 40, 30, 10, 50, 20)`
pt: `(ring 10, 20, 30, 40, 50).shuffle` - baralhar - `(ring 40, 30, 10, 50, 20)`

en: `(ring 10, 20, 30, 40, 50).shuffle.drop(1)` - drop 1 - `(ring 30, 10, 50, 20)`
pt: `(ring 10, 20, 30, 40, 50).shuffle.drop(1)` - retira 1 - `(ring 30, 10, 50, 20)`

en: `(ring 10, 20, 30, 40, 50).shuffle.drop(1).take(3)` - take 3 - `(ring 30, 10, 50)`
pt: `(ring 10, 20, 30, 40, 50).shuffle.drop(1).take(3)` - obtem 3 - `(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.
pt: Como podes ver acabamos de criar uma cadeia longa destes métodos *adicionando-os em conjunto*. Podemos combinar estes em qualquer ordem criando uma maneira extremamente rica e poderosa de gerar novos anéis a partir de existentes.

en: Immutability
pt: Imutabilidade

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.
pt: Estes anéis têm uma poderosa e importante propriedade. Eles são imutáveis o que significa que não podem mudar. o que quer dizer que encadeando estes métodos descritos nesta secção *não mudam os anéis* apenas *criam novos anéis*. Isto significa que estas livre de partilhar anéis entre threads e começar a encadear-los dentro de um thread sabendo que não irá afectar outros threads que estejam a usar o mesmo anel.

en: Available Chain Methods
pt: Cadeias de métodos disponíveis

en: Here's a list of the available chain methods for you to play with:
pt: Aqui está uma lista de cadeia de métodos disponíveis para brincares:

en: `.reverse` - returns a reversed version of the ring
pt: `.reverse` - devolve uma versão invertida do anel

en: `.sort` - creates a sorted version of the ring
pt: `.sort`- cria uma versão ordenada do anel

en: `.shuffle` - creates a shuffled version of the ring
pt: `.shuffle` - cria uma versão baralhada do anel

en: `.pick(3)` - returns a ring with the results of calling `.choose` 3 times
pt: `.pick(3)` - devolve um anel com o resultado de chamar `.choose` 3 vezes

en: `.take(5)` - returns a new ring containing only the first 5 elements
pt: `.take(5)`- devolve um novo anel contendo apenas os primeiros 5 elementos

en: `.drop(3)` - returns a new ring with everything but the first 3 elements
pt: `drop(3)`- devolve um novo anel com tudo excepto os 3 primeiros elementos

en: `.butlast` - returns a new ring with the last element missing
pt: `butlast` - devolve um novo anel sem o ultimo elemento do anel original

en: `.drop_last(3)` - returns a new ring with the last 3 elements missing
pt: `.drop_last(3)` - devolve um novo anel com os 3 últimos elementos originais em falta

en: `.take_last(6)`- returns a new ring with only the last 6 elements
pt: `take_last(6)` - devolve um novo anel com apenas os últimos 6 elementos originais

en: `.stretch(2)` - repeats each element in the ring twice
pt: `.stretch(2)` - repete 2 vezes cada elemento do anel original

en: `.repeat(3)` - repeats the entire ring 3 times
pt: `.repeat(3)` - repete todo o anel original 3 vezes

en: `.mirror` - adds the ring to a reversed version of itself
pt: `.mirror` - adiciona ao anel original uma versão revertida dele próprio

en: `.reflect` - same as mirror but doesn't duplicate middle value
pt: `.reflect`- o mesmo que mirror mas não duplica o valor do meio do anel

en: `.scale(2)` - returns a new ring with all elements multiplied by 2 (assumes ring contains numbers only)
pt: `.scale(2)` - devolve um novo anel com todos os elementos multiplicados por 2 (assumindo que o anel apenas contem números)

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.
pt: Claro que estes métodos em cadeia podem receber também outros números. És livre de chamar `.drop(5)` em vez de `.drop(3)`se quiseres largar os primeiros 5 elementos.

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.
pt: Um dos aspectos mais excitantes do Sonic Pi é que te permite escrever e modificar código ao vivo para criar musica, como uma performance ao vivo com uma guitarra. Uma vantagem desta abordagem é dar-te mais feedback enquanto compões (pôr um loop a correr enquanto ajustas o som até a perfeição). No entanto, a principal vantagem é que podes levar o Sonic Pi em palco e tocar com ele.

en: In this section we'll cover the fundamentals of turning your static code compositions into dynamic performances.
pt: Nesta secção cobrimos os fundamentos de tornar as tuas composições de código estático em performances dinâmicas.

en: Hold on to your seats...
pt: Agarrarem-se às cadeiras...

en: 9.1 Live Coding Fundamentals
pt: 9.1 Fundamentos do Live coding

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

en: An ability to write code that makes sounds - CHECK!
pt: A habilidade de escrever código que gera som - CHECK!

en: An ability to write functions - CHECK!
pt: Uma habilidade de escrever funções - CHECK!

en: An ability to use (named) threads - CHECK!
pt: A habilidade de usar threads (nomeados) - CHECK!

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

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.
pt: Se isto te parece muito complicado para ti, volta a trás e relê a secção sobre funções e threads. Não é muito complicado se já dominares estas coisas.

en: If you run this code, you'll hear note 50 repeating again and again...
pt: Se correres este código, ouvirás a nota 50 repetidamente uma e outra vez...

en: Changing it up
pt: Fazendo alterações

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!
pt: Agora é quando o divertimento começa. Enquanto o código *está a correr* muda o 50 para outro número, talvez 55, depois prime o botão Run outra vez. WOW! Mudou! Em directo!

en: Try changing it again, change the note, change the sleep time. How about adding a `use_synth` statement? For example, change it to:
pt: Experimenta mudar novamente, muda a nota, muda o tempo de descanso. Que tal adicionar uma definição `use_synth`? Por exemplo muda para:

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:
pt: Agora soa bastante interessante, mas podemos apimentar as coisas. Em vez de tocar a mesma nota uma e outra vez, tenta tocar um acorde:

en: How about playing random notes from the chord:
pt: Que tal tocar notas ao acaso do acorde:

en: Or using a random cutoff value:
pt: Ou usar um valor de cutoff aleatório:

en: Finally, add some drums:
pt: Finalmente, adiciona alguma bateria:

en: Now things are getting exciting!
pt: Agora as coisas estão a ficar excitantes!

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

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.
pt: Ok, esta secção do tutorial é uma verdadeira gema. Se apenas leres uma secção, deveria ser esta. Se leste as secções anteriores sobre os fundamentos de codificar ao vivo, `live_loop` é uma simples maneira de fazer isso mas sem ter que escrever muito código.

en: If you didn't read the previous section, `live_loop` is the best way to jam with Sonic Pi.
pt: Se não leste a secção anterior, `live_loop`é a melhor maneira de improvisar com o Sonic Pi.

en: Let's play. Write the following in a new buffer:
pt: Vamos tocar. Escreve o seguinte num buffer novo:

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.
pt: Agora prime o botão Run. Ouviras o beep básico. Nada de especial por aqui. No entanto, não primas Stop ainda. Muda o `60` para `65` e clica no Run outra vez.

en: Woah! It changed *automatically* without missing a beat. This is live coding.
pt: WOW! Mudou *automaticamente* sem perder a batida. Isto é Live coding.

en: Why not change it to be more bass like? Just update your code whilst it's playing:
pt: Porque não mudar para algo mais parecido com baixo? Actualiza o teu código enquanto corre:

en: Then hit Run.
pt: Depois prime Run.

en: Let's make the cutoff move around:
pt: Vamos fazer mudanças ao cutoff:

en: Hit Run again.
pt: Prime o botão Run outra vez.

en: Add some drums:
pt: Adiciona bateria:

en: Change the note from `e1` to `c1`:
pt: Muda a nota de `e1` para `c1`:

en: Now stop listening to me and play around yourself! Have fun!
pt: Agora pára de me ouvir tocar e brinca tu próprio! Diverte-te!

en: 9.3 Multiple Live Loops
pt: 9.3 Múltiplos Live Loops

en: Multiple Live Loops
pt: Múltiplos Live Loops

en: Consider the following live loop:
pt: Considera o seguinte live loop:

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.
pt: Podes ter-te perguntado porque necessita o nome `:foo`. O seu nome é importante porque significa que este live loop é diferente de todos os outros live loops.

en: *There can never be two live loops running with the same name*.
pt: *Nunca pode haver 2 live loops a correr com o mesmo nome*.

en: This means that if we want multiple concurrently running live loops, we just need to give them different names:
pt: Isso quer dizer que se quisermos múltiplos live loops concorrentes, teremos que dar diferentes nomes:

en: You can now update and change each live loop independently and it all just works.
pt: Podemos agora actualizar e mudar cada live loop independentemente e tudo funciona.

en: Syncing Live Loops
pt: Sincronizando live loops

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.
pt: Uma coisa que poderás já ter notado é que os live loops funcionam automaticamente com o mecanismo de cue do threaad que exploramos anteriormente. Cada vez que o live loop repete, ele gera um novo envento `cue` com o nome do live loop. Podemos então `sync` nestes cues para assegurar que os nossos loops estão sincronizados sem ter que parar alguma coisa.

en: Consider this badly synced code:
pt: Considera este código muito mal sincronizado:

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:
pt: Vamos ver se conseguimos reparar o timing e a sincronização sem parar. Primeiro, vamos arranjar o loop `:foo` para fazer parar pelo factor de 1 - algo como `0.5` serve:

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:
pt: Ainda não terminamos - notarás que os beats não se alinham correctamente. ISto é porque os loops estão *fora de fase*. Vamos resolver isso sincronizando um com o outro:

en: Wow, everything is now perfectly in time - all without stopping.
pt: Wow, agora tudo está perfeitamente a tempo - tudo sem ter que parar.

en: Now, go forth and live code with live loops!
pt: Agora avança e codifica ao vivo com live loops!

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.
pt: Algo que darás por ti a fazer muitas vezes quando codificas ao vivo é looping por anéis. Irás colocar notas em anéis para melodias, pausas para ritmos, progressões de acordes, variações tímbricas, etc, etc.

en: Ticking Rings
pt: Anéis tiquetantes

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:
pt: O Sonic Pi fornece uma ferramenta *muito* útil para trabalhar com anéis dentro de `live_loop`s. É chamado o sistema de tick. Na secção sobre anéis falamos algo sobre o contador que está constantemente a aumentar, como o número da batida corrente. Ticks apenas implementam a ideia. Fornece-te a habilidade de *tiquetaquear pelo anel*. Vamos ver este exemplo:

en: This is equivalent to:
pt: Isso é equivalente a:

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:
pt: Aqui, estamos a buscar a escala pentatónica de Mi3 menor e tiquetaquear por cada elemento. Isto é feito adicionando `.tick` ao fim da declaração da escala. Este tick é local ao live loop, assim cada live loop pode ter o seu próprio tick independente:

en: You can also call `tick` as a standard fn and use the value as an index:
pt: Podes também chamar `tick`como função padrão e usar o valor como índice:

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.
pt: No entanto, é muito melhor chamar `.tick` no final. A função `tick` é para quando queres fazer algo coisas mais bonitas com o valor de tick e para quando queres usar ticks com outras coisas que indexar em anéis.

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.
pt: A coisa mágica sobre tick é que não só devolve um novo índice (ou o valor do anel nesse índice) mas também garante que a próxima vez que chamares o tick, é um novo valor. Vê os exemplos na documentação para `tick` para as muitas maneiras que podes trabalhar com ele. No entanto, por agora, é importante apontar que algumas vezes apenas queres ver o valor corrente de tick e *não aumentar*. Isso é conseguido através da função `look`. Podes chamar `look` como função padrão ou adicionando `.look` ao final do anel.

en: Naming Ticks
pt: Nomeando ticks

en: Finally, sometimes you'll need more than one tick per live loop. This is achieved by giving your tick a name:
pt: Finalmente, algumas vezes necessitas de mais do que um tick por live loop. Isto é conseguindo dando nome a um tick:

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`.
pt: Aqui estamos a usar dois ticks, um para tocar as notas e outro para o tempo de pausa. Como ambos estão no mesmo live loop, para os manter separados necessitamos de lhes dar nomes únicos. Isto é exactamente a mesma coisa que nomear `live_loop`s - apenas passamos o símbolo com o prefixo `:`. No exemplo acima chamamos um dos ticks `:foo` e o outro `:bar`. Se quisermos os `look` temos que passar o nome do tick a `look`.

en: Don't make it too complicated
pt: Não o faças muito complicado

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.
pt: A maioria do poder do sistema de tick não é útil quando começas. Não tentes aprender tudo nesta secção. Foca-te no tiquetaque de um único anel. Isso dará a maioria da alegria da simplicidade do tiquetaque de anéis nos teus `live_loop`s.

en: Take a look at the documentation for `tick` where there are many useful examples and happy ticking!
pt: Dá uma vista de olhos na documentação sobre `tick` onde existe muitos exemplos úteis e tem um feliz tiquetaquear!

en: 10.1 Set and Get
pt: 10.1 Set e Get

en: Set and Get
pt: Set e Get

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
pt: ## Um exemplo de comportamento não-determinístico
    ## (devido a race conditions causadas por múltiplos
    ## loops manipulando a mesma variárvel ao mesmo tempo).
    ##  
    ## Se você executar este código você notará
    ## que a lista que é impressa
    ## nem sempre sai ordenada!
    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: ## 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
pt: ## Um exemplo de comportamento determinístico
    ## (apesar do acesso simultâneo ao estado compartilhado)
    ## usando o novo sistema Time State do Sonic Pi.
    ##
    ## Quando este código é executado, a lista
    ## sempre é impressa de forma ordenada!
    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: 10.2 Sync
pt: 10.2 Sincronização (Sync)

en: Sync
pt: Sincronização (Sync)

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*.
pt: A seção 5.7 introduziu as funções `cue` e `sync` para lidar com problemas de sincronização de threads. O que não foi explicado é que é o sistema de Time State que fornece esta funcionalidade. É de tal forma que `set` is na realidade uma variação de `cue`e foi construído de forma que que possa trabalhar perfeitamente com o Time State - qualquer informaçãoque nós planejamos armazenar no Time State nós podemos sincronizar. Em outras palavras - *nós sincronizamos `sync`eventos que ainda serão inseridos no Time State*.

en: Waiting for Events
pt: Aguardando por eventos

en: Let's take a quick look at how to use `sync` to wait for new events to be added to Time State:
pt: Vamos dar uma olhada em como usar `sync` para esperar por novos eventos que serão inseridos ao Time State:

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.
pt: Neste exemplo nós primeiro criamos uma thread que espera um evento `:foo` ser adicionado ao Time State. Após a declaração desta thread, nós esperamos por 2 batidas e então setamos (`set`) `:foo` para ser `1`. Isso libera a sincronização (`sync`) que então segue para a próxima linha que dispara a amostra `: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.
pt: Note que `sync` sempre espera por *eventos futuros* e isso irá bloquear a a thread atual esperando por um novo evento. Também, irá herdar o tempo lógico da thread que chamou a sincronização através de `set` ou `cue` então pode também ser usado para sincronizar tempo.

en: Passing values into the Future
pt: Passando valores para o Futuro

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`:
pt: No exemplo acima nós configuramos `:foo` igual a `1` e não fizemos nada com isso. Nós podemos, na verdade, recuperar este valor na thread chamando `sync`:

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

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.
pt: Note que valores que são passados através de `set` e `cue` devem ser seguros - i.e. Rings imutáveis, números, símbolos ou strings congeladas. O Sonic Pi irá gerar um erro se o valor que você está tentando armazenar no Time State não for válido.

en: 10.3 Pattern Matching
pt: 10.3 Correspondência de Padrões

en: Pattern Matching
pt: Correspondência de Padrões

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.
pt: Para passar e recuperar informações para o Time State, é possível usar chaves mais complexas que símbolos básicos como `:foo` e `:bar`. Você também pode usar strings no formato URL, chamadas de Paths (caminhos) como `"/foo/bar/baz"`. Depois que começãmos a usar paths, nós podemos começar a aproveitar o sofisticado sistema de correspondência de Padrões do Sonic Pi para usar `get` e `sync` com paths 'similares' em vez de 'idênticos'. Vamos dar uma olhada.

en: Match any path segment
pt: Correspondência com qualquer parte do caminho (path)

en: Let's assume we want to wait for the next event that has three path segments:
pt: Vamos assumir que nós queiramos esperar pelo próximo evento que tem três segmentos no path:

en: This will match any Time State event with exactly three path segments, regardless of their names. For example:
pt: Isto irá corresponder a qualquer evento Time State com exatamente três segmento, independente de seus nomes. Por exemplo:

en: However, it will *not* match paths with fewer or more path segments. The following will not match:
pt: Entretanto, *não* irá corresponder a paths com menos ou mais segmentos. Os seguintes paths não serão localizados:

en: Each `*` means *any content*. So we could match paths with just one segment with `/*` or paths with five segments with `/*/*/*/*/*`
pt: Cada `*` (asterisco) significa *qualquer conteúdo*. Então nós podemos encontrar paths com somente um segmento com `/*` ou paths com cinco segmentos com `/*/*/*/*/*`

en: Matching partial segments
pt: Encontrando segmentos parciais

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:
pt: Se soubermos como o segmento irá começar ou terminar, nós podemos usar um asterisco `*` junto com o nome parcial do segmento. Por exemplo: `"/foo/b*/baz"` irá corresponder a qualquer path com três segmentos, onde o primeiro é `foo`, o último é `baz` e o segmento do meio pode ser qualquer coisa que comece com `b`. Então irá corresponder a:

en: However, it wouldn't match the following:
pt: Mas não irá corresponder a:

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"`.
pt: Você pode colocar o `*` no início do segmento para especificar os últimos caracteres de um segmento: `"/foo/*zz/baz"` que iráo corresponder a quaisquer 3 segmentos `cue` ou `set` onde o primeiro segmento for `foo`, o último for `baz` e o segmento do meio termine com `zz`, como `"cue "/foo/whizz/baz"`.

en: Matching Nested Path Segments
pt: Encontrando correspondências em segmentos de paths aninhados

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:
pt: As vezes você não sabe quantos segmentos do path você quer achar a correspondência. Nestes casos, você pode usar os poderosos duplos asteriscos: `**` como em `"/foo/**/baz"` que irão corresponder a:

en: Matching Single Letters
pt: Correspondendo a Letras Sozinhas

en: You can use the `?` character to match against a single char such as `"/?oo/bar/baz"` which will match:
pt: Você pode usar o caracter `?` para comparar com um caracter apenas, como em `"/?oo/bar/baz"` que irá corresponder a:

en: Matching Multiple Words
pt: Correspondendo a Múltiplas Palavras

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:
pt: Se você sabe que um segmento pode ser uma palavra de um certo conjunto de palavras, você pode usar `{` e `}` para especificar uma lista de opções como em `"/foo/{bar,beans,eggs}/quux"` que irão corresponder aos seguintes padrões:

en: Matching Multiple Letters
pt: Correspondendo a Múltiplas Letras

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:
pt: Por fim, você pode comparar com uma seleção de letras se você usar `[` e `]` para especificar uma lista de possibilidades como em `"/foo/[abc]ux/baz"` que irá corresponder somente a:

en: You can also use the `-` character to specify ranges of letters. For example `"/foo/[a-e]ux/baz"` which will match only:
pt: Você também pode utilizar o caracter `-` para especificar sequências de letras. Por exemplo`"/foo/[a-e]ux/baz"` que irá corresponder somente a:

en: Combining Matchers
pt: Combinando Correspondências

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 crazy example:
pt: Ao chamar `sync` ou `get` você está livre para combinar localizadores de correspondência em qualquer ordem que você achar necessário para 
    encontrar qualquer evento Time State criado por `cue` ou `set`. Vamos ver um exemplo doido:

en: OSC Pattern Matching
pt: Correspondência de Padrões OSC

en: For those curious, these matching rules are based on the Open Sound Control pattern matching specification which is explained in detail here: http://opensoundcontrol.org/spec-1_0
pt: Para os curiosos, estas regras de correspondência são baseados na especificação de correspondência de padrões do Open Sound Control (controle de som aberto), que é explicado com detalhes em: http://opensoundcontrol.org/spec-1_0

en: 11 MIDI
pt: 11. MIDI

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:
pt: Uma vez que você tiver dominado a conversão de código em música, você pode pensar - o que vem depois? As vezes, as limitações de trabalhar puramente dentro da sintaxe e do sistema de som do Sonic Pi podem ser excitantes e te colocar em uma nova posição criativa. Entretanto, as vezes é essencial libertar o código para o mundo real. Não queremos duas coisas extras:

en: To be able to convert actions in the real world into Sonic Pi events to code with
pt: Sermos capazes de converter ações do mundo real em eventos codificáveis do Sonic Pi

en: To be able to use Sonic Pi's strong timing model and semantics to control and manipulate objects in the real world
pt: Sermos capazes de usar o forte modelo de temporização e semântica do Sonic Pi para controlar e manipular objetos no mundo real

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.
pt: Por sorte, existe um protocolo que está por aí desde os anos 80, que permite este tipo de interação - MIDI. Existe um número incrível de aparelhos externos, incluindo teclados, controladores, sequenciadores e software profissional que suportam MIDI. Nós podemos usar o MIDI para receber dados e também para enviar dados.

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...
pt: O Sonic Pi fornece suporte completo para o protocolo MIDI possibilitando que você conecte seu Código Ao Vivo com o mundo real. Vamos explorá-lo um pouco mais...

en: 11.1 MIDI In
pt: 11.1 Entrada MIDI

en: MIDI In
pt: Entrada MIDI

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!
pt: Nesta seção vamos aprender como conectar um controlador MIDI para enviar eventos para o Sonic Pi, para controlar nossos sintetizadores e sons. Vá e pegue um controlador MIDI, como um teclado ou tablet de controle e vamos começar!

en: Connecting a MIDI Controller
pt: Conectando um controlador MIDI

en: Receiving MIDI Events
pt: Recebendo eventos 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:
pt: Assim que seu aperelho esteja conectado, o Sonic Pi irá receber eventos automaticamente. Você mesmo pode confirmar manipulando seu aparelho MIDI e olhando no registro de Deixas (cue logger), na janela do app em baixo à direita, abaixo do registro (se isso não estiver visível, vá em Preferências > Editor > Mostrar & Ocultar e habilite a caixa 'Mostrar o registro de deixas'). Você verá um fluxo de eventos como:

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!
pt: Quando você ver um fluxo de mensagens desta forma, você terá conectado com sucesso seu aparelho MIDI. Parabéns, vamos ver o que você consegue fazer com ele!

en: Controlling Code
pt: Controlando o Código

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:
pt: Agora que você conectou seu aparelho MIDI, viu seus eventos no registro e descobriu que nosso conhecimento do Estado de Tempo (Time State) é tudo o que precisamos para trabalhar com eventos, podemos começar a nos divertir. Vamos construir um piano MIDI simples:

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.
pt: Temos algumas coisas acontecendo no código acima, incluindo alguns problemas. Primeiro, temos um `live_loop` simples, que irá se repetir para sempre, executando o código entre os blocos `do`/`end`. Isto foi apresentado na seção 9.2. Segundo, estamos chamando o comando `sync` para esperar pelo próximo evento  Time State correspondente. Usamos uma string representando a mensagem MIDI que estamos procurando (que é a mesma que foi exibida no registro). Note que esta string longa é fornecida pela função autocompletar do Sonic Pi, desta forma você não precisa digitar tudo a mão. No registro nós vemos que haviam dois valorespara cada nota MIDI no evento, então nós atribuímos o resultado a duas variáveis `note` e `velocity`. Por fim, nós disparamos o sintetizador `:piano` passando nossa nota.

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:
pt: Agora tente você. Digite o código acima, substitua a chave de sincronização com uma string correspondente ao seu aparelho MIDI e clique em Executar. Pronto, você tem um piano funcionando! Entretanto, você provavelmente notará alguns problemas: primeiro, todas as notas possuem o mesmo volume, independente da força que você usa no teclado. Isso pode ser consertado facilmente usando o valor velocity do MIDI e convertendo-o para amplitude. Dado que MIDI possui uma variação entre 0 e 127, para converter este número para um valor entre 0 e 1 nós só precisamos dividi-lo por 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.
pt: Atualize o código e clique em Executar novamente. Agora a força aplicada ao teclado é respeitada. Em seguida, vamos nos livrar desta pausa irritante.

en: Removing Latency
pt: Removendo a Latência

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:
pt: Antes de remover a pausa, nós precisamos entender porque ela acontece. Para manter todos os sintetizadores e Efeitos sincronizados através de uma variedade de CPUs com capacidades diferentes, o Sonic Pi agenda o áudio *antecipadamente* em 0.5s por padrão.  (Note que esta latência adicional pode ser configurada pelas funções `set_sched_ahead_time!` e `use_sched_ahead_time`). Estes 0.5s de latência estão sendo adicionados ao disparador do nosso sintetizador `:piano` assim como está sendo adicionado a todos os sintetizadores disparados pelo Sonic Pi. Tipicamente nós realmente queremos manter esta latência, já que isso significa que todos os sintetizadores estarão sincronizados. Entretanto, isso só faz sentindo para sintetizadores disparados por código, usando `play` e `sleep`. No nosso caso, na realidade estamos disparando o sintetizador `:piano` pelo nosso aparelho MIDI e portanto não queremos que o Sonic Pi controle o tempo por nós. Podemos desligar esta latência com o comando `use_real_time`, que desabilita a latência para a thread atual. Isto significa que você pode usar o modo Real Time para loops ao vivo controlado por `sync` com aparelhos externos, e manter a latência padrâo para todos os outros loops. Vejamos:

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!
pt: Atualize seu código para que ele corresponda ao código acima e clique em 'Executar' novamente. Agora nós temos um piano com baixa latência e sensibilidade variável, programado em apenas 5 linhas.

en: Getting Values
pt: Recuperando valores

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...
pt: Finalmente, como nossos eventos MIDI estão indo diretamente para o Time State, nós também podemos usar a função `get` para recuperar o último valor recebido. Isso não bloqueia a thread atual e retorna `nil` se não houver valor para ser recuperado (o que você pode sobrescrever passando um valor padrão - veja a ajuda para `get`). Lembre-se que você pode chamar `get` em qualquer thread a qualquer momento para ver o valor mais recente correspondente ao Time State. Você pode até usar `time_warp` para voltar no tempo e chamar `get` para ver eventos passados...

en: Now You are in Control
pt: Agora Você Está no Controle

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!
pt: O mais importante é que agora você pode usar as mesmas estruturas de código para sincronizar e recuperar (`sync` e `get`) informações MIDI de qualquer aparelho MIDI e fazer o que você quiser com os valores. Você pode agora escolher o que seu aparelho MIDI irá fazer!

en: 11.2 MIDI Out
pt: 11.2 Saída MIDI

en: MIDI Out
pt: Saída 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:
pt: Além de receber eventos MIDI nõs podemos também enviar eventos MIDI para disparar e controlar hardware de sintetizadores externos, teclados e outros aparelho. O Sonic Pi fornece um conjunto completo de funções para enviar várias mensagens MIDI como:

en: Note on - `midi_note_on`
pt: Ligar nota - `midi_note_on`

en: Note off - `midi_note_off`
pt: Desligar nota - `midi_note_off`

en: Control change - `midi_cc`
pt: Mudança de controle - `midi_cc`

en: Pitch bend - `midi_pitch_bend`
pt: Pitch bend  - `midi_pitch_bend`

en: Clock ticks - `midi_clock_tick`
pt: Tiques do relógio - `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_`.
pt: Também existem muitas outras mensagens MIDI suportadas - verifique a documentação da API para todas as outras funções que começam com `midi_`.

en: Connecting to a MIDI Device
pt: Conectando um aparelho MIDI

en: Sending MIDI events
pt: Enviando eventos MIDI

en: Selecting a MIDI device
pt: Selecionando um aparelho MIDI

en: Conclusions
pt: Conclusões

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.
pt: Isto conclui o tutorial introdutório do Sonic Pi. Espero que tenhas aprendido algo ao longo do caminho. Não te preocupes se sentires que não percebes tudo - apenas brinca e diverte-te e aprenderás ao teu tempo. Está a vontade de regressares se tiveres duvidas que poderão ser explicadas numa das secções.

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.
pt: Finalmente, Também te convido a dares uma vista aprofundada ao resto da documentação no sistema de ajuda. Existem uma serie de coisas que não foram apresentadas neste tutorial e estão a espera que as descubras.

en: So play, have fun, share your code, perform for your friends, show your screens and remember:
pt: Brinca, diverte-te, partilha o teu código, actua para os teus amigos, mostra o ecrã e lembra-te:

en: *There are no mistakes, only opportunities.*
pt: *Não existem erros, apenas oportunidades.*

en: A Appendix A - MagPi Articles
pt: A Apêndice  A - Artigos na MagPi

en: MagPi Articles
pt: Artigos na MagPi

en: Appendix A collects all the Sonic Pi articles written for the MagPi magazine.
pt: Apêndice A colecção de todos os artigo do Sonic Pi para a revista MagPi.

en: Dive into Topics
pt: Verifica os tópicos

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.
pt: Estes artigos não foram feitos para serem lidos numa ordem em particular e contêm muito material repetido do tutorial. Em vez de tentar e ensinar todo o Sonic Pi, eles estão focados num aspecto especifico do Sonic Pi e tentam explica-los de uma forma divertida e acessível.

en: Read the MagPi
pt: Lê a 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/
pt: Poderás ver o typeset glorioso e profissional na forma de PDF para download da MagPi aqui: https://www.raspberrypi.org/magpi/

en: Suggest a Topic
pt: Sugerir um tópico

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!
pt: Se não veres um tópico que tenhas curiosidade nestes artigos - porque não sugerir um? A maneira mais fácil é tweetares a tua sugestão para [@Sonic_Pi](http://twitter.com/sonic_pi). A tua sugestão poderá ser o tema do próximo artigo!

en: A.1 Tips for Sonic Pi
pt: A.1 Dicas para o Sonic Pi

en: Five Top Tips
pt: As cinco melhores dicas

en: 1. There are no mistakes
pt: 1. Não existem erros

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.
pt: A coisa mais importante lição a aprender com o Sonic Pi é que realmente não existem erros. A melhor maneira é tentar e tentar. Tenta coisas diferentes, pára de te preocupar se o teu código soa bem ou não e começa a experimentar com diferentes synths, notas, efeitos e opções o máximo possível. Descobrirás muitas coisas que te farão rir porque soam mal e algumas pérolas que soam realmente bem. Simplesmente retira o que não gostas e fica com as que gostas. Quantos mais 'erros' te permitires mais rápido aprenderás e descobrirás o teu som pessoal no código.

en: 2. Use the FX
pt: 2. Usa os efeitos

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:
pt: Digamos que já dominas o básico do Sonic Pi de fazer sons com `sample`, `play`? O que se segue? Sabias que o Sonic Pi suporta mais de 27 efeitos de estúdio para mudar o som do teu código? Efeitos são como filtros de imagens bonitos nos programas de desenho excepto que em vez de desfocar ou tornar algo a preto e branco, podes acrescentar reverb, distorção e eco ao teu som. Pensa que é como ligar o cabo de uma guitarra a um pedal de efeitos à tua escolha e depois ao amplificador. Felizmente, o Sonic Pi torna o uso de efeitos muito fácil e não requer cabos! Tudo o que tens que fazer é escolher que secção do código queres adicionar o efeito e embrulhares com o código do efeito. Vamos ver um exemplo. Imagina que tens o seguinte código:

en: If you wanted to add FX to the `:loop_garzul` sample, you'd just tuck it inside a `with_fx` block like this:
pt: Se quiseres acrescentar um efeito ao sample `:loop_garzul`, apenas tens que o colocar dentro de um bloco `with_fx` assim:

en: Now, if you wanted to add FX to the bass drum, go and wrap that with `with_fx` too:
pt: Agora, se quiseres adicionar um efeito à bass drum, vai e embrulha isso com o `with_fx` também:

en: Remember, you can wrap *any* code within `with_fx` and any sounds created will pass through that FX.
pt: Lembra-te, podes embrulhar *qualquer* código com o `with_fx` e qualquer som criado passará pelo efeito.

en: 3. Parameterise your synths
pt: 3. Paramatriza os teus synths

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:
pt: De forma a realmente descobrires o teu som no código em breve quererás saber como modificar e controlar os synth e efeitos. Por exemplo, poderás querer mudar a duração de uma nota, adicionar mais reverb, ou mudar o tempo entre os ecos. Felizmente, o Sonic Pi dá-te um incrível nível de controlo para fazer isso com uma coisa especial chamada parâmetros opcionais ou opts como abreviatura. Vamos dar uma vista de olhos. Copia este código para o espaço de trabalho e carrega run:

en: Ooh, a lovely guitar sound! Now, let's start playing with it. How about changing its rate?
pt: Ooh, um bonito som de guitarra! Agora, vamos começar a brincar com ele. Que tal mudar a sua rate?

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:
pt: Hey, o que é essa `rate: 0.5` que acrescentei no final? É chamada um opt. Todos os Synths do Sonic Py e efeitos suportam-no e existem muitos para brincar com eles. Eles também estão disponíveis para efeitos. Tenta isto:

en: Now, try increasing that feedback to 1 to hear some crazy sounds! Read the docs for full details on all the many opts available to you.
pt: Agora, tenta aumentar o feedback para 1 para ouvires alguns sons malucos! Lê a documentação para todos os detalhes de todas as opts disponíveis para ti.

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:
pt: A melhor maneira de experimentar e explorar o Sonic Pi é codificares ao vivo. Isto permite que comeces um código e o mudes e afines enquanto esta a ser tocado. Por exemplo, se não sabes o que o parâmetro cutoff faz a um sample, brinca com isso. Vamos experimentar! Copia este código para um espaço de trabalho do 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`...
pt: Agora, carrega run e ouvirás um drum break ligeiramente abafado. Agora, muda o valor de `cutoff:` para `80` e carrega outra vez em run. Consegues ouvir a diferença? Experimenta `90`, `100`, `110`...

en: A Live Loop Arpeggiator
pt: Um Live Loop Arpegiador

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:
pt: O poder real surge quando você mistura `tick` com anéis (rings) e `live_loop`s. Quando combinados nós temos todas as ferramentas que nós precisamos para tanto construir quanto entender um arpejador simples. Precisamos somente de 4 coisas:

en: A ring containing the notes we want to loop over.
pt: Um anel (ring) contendo as notas que queremos arpejar.

en: A means of incrementing and obtaining the beat.
pt: Uma forma de incrementar e obter a batida.

en: The ability to play a note based on the current beat.
pt: A habilidade de tocar uma nota baseada na batida atual.

en: A loop structure to keep the arpegiator repeating.
pt: Uma estrutura de loop para manter o arpejador repetindo.

en: These concepts can all be found in the following code:
pt: Todos estes conceitos podem ser encontrados no seguinte código:

en: A.12 Sample Slicing
pt: A.12 Cortando Amostras

en: Sample Slicing
pt: Cortando Amostras

en: Essential Knowledge
pt: Conhecimento essencial

en: This section will cover some very useful - in fact *essential* - knowledge for getting the most out of your Sonic Pi experience.
pt: Esta secção descreve algum conhecimento útil - aliás *essencial* para retirares o máximo da tua experiência com o 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.
pt: Falaremos de como podes tiras partido de muitos atalhos de teclado disponíveis para ti, como partilhar o teu trabalho e algumas dicas sobre performance no Sonic Pi.

en: Using Shortcuts
pt: Usando atalhos

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.
pt: O Sonic Pi é tanto um instrumento como um ambiente de codificação. Atalhos podem fazer com que tocar o Sonic Pi seja muito mais *eficiente e natural* - especialmente se estiveres a tocar em frente a uma audiência.

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!
pt: Muito do Sonic Pi pode ser controlado através do teclado. Quanto mais familiaridade tiveres trabalhando e actuando com o Sonic Pi mais tendência terás de usar atalhos. *Eu pessoalmente uso o teclado* (eu recomendo considerares aprenderes também) sinto-me frustrado quando tenho que alcançar o rato pois isso atrasa-me. Por isso uso todos estes atalhos de uma forma bastante regular!

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.
pt: Assim, se aprenderes os atalhos, aprenderás a usar o teclado de forma efectiva e estarás a fazer live coding como um profissional em tempo record.

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.
pt: No entanto, *não tentes aprende-los todos de uma só vez*, apenas tenta lembrar-te dos que mais usas e continua a adicionar mais à medida que os praticas.

en: Consistency across Platforms
pt: Consistência entre plataformas

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.
pt: Imagina que estas a aprender o clarinete. Esperas que todos os clarinetes tenham os mesmos controles e botões. Se não tiverem, terás um tempo difícil a mudar entre vários clarinetes ou ficaras retido em usar só um.

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.
pt: Infelizmente a maioria dos sistemas operativos (Linux, Mac OS X e Windows) vêm com os seus próprios padrões para acções como o copy e paste etc. Sonic Pi tenta honrar estes padrões. no entanto a *prioridade é colocada na consistência entre plataformas* dentro do Sonic Pi em vez de tentar adaptar-se aos padrões de uma determinada plataforma. Isto significa que quando aprenderes os atalhos enquanto tocas com o Sonic Pi no teu Raspberry Pi, podes mudar para um Mac ou um PC e sentires-te em casa.

en: Control and Meta
pt: Control e 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.
pt: Parte da noção de consistência é o nome dos atalhos. No Sonic Pi usamos o nome *Control* e *Meta* para referir as 2 principais teclas de combinações. Em todas as plataformas o *Control* é o mesmo. No entanto, no Linux e no Windows *Meta* é a tecla *Alt* enquanto que no Mac *Meta* é a tecla *Command*. Para consistência usaremos o termo *Meta* - Lembra-te apenas de mapear para a tecla apropriada no teu sistema operativo.

en: Abbreviations
pt: Abreviações

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."
pt: Para ajudar a manter as coisas simples e legíveis, usaremos as abreviaturas *C-* para *Control* mais uma outra tecla e *M-* para *Meta* mais outra tecla. Por exemplo, se um atalho requer que primas simultaneamente *Meta* e *r* escreveremos como *M-r*. O *-* significa apenas "ao mesmo tempo".

en: The following are some of the shortcuts I find most useful.
pt: Os seguintes são alguns dos atalhos que considero mais úteis.

en: Stopping and starting
pt: Parando e iniciando

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`.
pt: Em vez de alcançar o rato cada vez que se quer correr o código, podes simplesmente pressionar `M-r`. Da mesma forma podes parar o código carregando `M-s`.

en: Navigation
pt: Navegação

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.
pt: Fico mesmo perdido sem os atalhos de navegação. Recomendo vivamente que passes algum tempo a aprende-los. Estes atalhos trabalhas extremamente bem quando aprendes a teclar sem mexer as mãos pois eles usam letras standard e não requerem que mexas as mãos para alcançar o rato ou as setas do teu teclado.

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`.
pt: Podes mover para o inicio da linha com `C-a`, para o final da linha com `C-e`, subir uma linha com `C-p`, para baixo uma linha com `C-n`, um carácter para a frente com `C-f`, e um carácter para trás com `C-b`. Podes até apagar todos os caracteres do cursor até ao final da linha com `C-k`.

en: Tidy Code
pt: Código limpo

en: To auto-align your code simply press `M-m`.
pt: Para auto-alinhar o teu código simplesmente carrega `M-m`.

en: Help System
pt: Sistema de ajuda

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!
pt: Para comutar o sistema de ajuda podes premir `M-i`- No entanto, um atalho muito mais útil é `C-i` em que irá verificar a palavra por baixo do cursor e mostra os documentos se descobrir algo. Ajuda instantânea!

en: For a full list take a look at section 10.2 Shortcut Cheatsheet.
pt: Para uma listagem completa vê a secção 10.2 com uma folha de ajuda de atalhos.

en: Shortcut Cheatsheet
pt: Folha de ajuda de atalhos

en: The following is a summary of the main shortcuts available within Sonic Pi. Please see Section 10.1 for motivation and background.
pt: O seguinte é um sumário dos principais atalhos disponíveis no Sonic Pi. Por favor vê a secção 10.1 para motivação e contexto.

en: Conventions
pt: Convenções

en: In this list, we use the following conventions (where *Meta* is one of *Alt* on Windows/Linux or *Cmd* on Mac):
pt: Nesta lista, usamos a seguinte convenção (onde *Meta* ou é o *Alt* em Windows/Linux ou o *Cmd* no Mac):

en: `C-a` means hold the *Control* key then press the *a* key whilst holding them both at the same time, then releasing.
pt: `C-a` significa carregar na tecla *Control* e depois carrega a tecla *a* estando as duas pressionadas ao mesmo tempo, depois libertando.

en: `M-r` means hold the *Meta* key and then press the *r* key whilst holding them both at the same time, then releasing.
pt: `M-r` significa pressionar a tecla *Meta* e depois pressionar a tecla *r* ao mesmo tempo, depois libertando.

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.
pt: `S-M-z` significa presionar a tecla *Shift*, depois a tecla *Meta*, e finalmente a tecla *z* todas ao mesmo tempo, depois libertando.

en: `C-M-f` means hold the *Control* key, then press *Meta* key, finally the *f* key all at the same time, then releasing.
pt: `C-M-f` significa premir a tecla *Control*, e depois premir a tecla *Meta*, finalmente a tecla *f* todas ao mesmo tempo, depois libertando.

en: Main Application Manipulation
pt: Manipulação da Aplicação principal

en: `M-r` - Run code
pt: `M-r` - Correr código

en: `M-s` - Stop code
pt: `M-s` - Parar código

en: `M-i` - Toggle Help System
pt: `M-i`- Comutar o sistema de ajuda

en: `M-p` - Toggle Preferences
pt: `M-p`- Comutar preferencias

en: `M-{` - Switch buffer to the left
pt: `M-{` - Mudar para a buffer da esquerda

en: `M-}` - Switch buffer to the right
pt: `M-}` - Mudar para a buffer da direita

en: `M-+` - Increase text size of current buffer
pt: `M-+` - Aumentar tamanho do texto da buffer corrente

en: `M--` - Decrease text size of current buffer
pt: `M--` - Reduzir o tamanho de texto na corrente buffer

en: Selection/Copy/Paste
pt: Selecionar/copiar/colar

en: `M-a` - Select all
pt: `M-a` - Selecionar tudo

en: `M-c` - Copy selection to paste buffer
pt: `M-c`- Copiar selecção para colar na buffer

en: `M-]` - Copy selection to paste buffer
pt: `M-]` - Copiar seleção para colar no buffer

en: `M-x` - Cut selection to paste buffer
pt: `M-x` - Cortar seleção para colar na buffer

en: `C-]` - Cut selection to paste buffer
pt: `C-]` - Cortar seleção para a colar na buffer

en: `C-k` - Cut to the end of the line
pt: `C-k`- Cortar até ao fim da linha

en: `M-v` - Paste from paste buffer to editor
pt: `M-v`- Colar para o editor

en: `C-y` - Paste from paste buffer to editor
pt: `C-y` - Colar para o editor

en: `C-SPACE` - Set mark. Navigation will now manipulate highlighted region. Use `C-g` to escape.
pt: `C-SPACE` - Colocar marca. A navegação irá agora manipular a região sublinhada. Usar `C-g`para escapar.

en: Text Manipulation
pt: Manipulação de texto

en: `M-m` - Align all text
pt: `M-m` - Alinhar todo o texto

en: `Tab` - Align current line or selection (or select autocompletion)
pt: `Tab`- Alinha a corrente linha ou seleção (ou escolhe autocompletion)

en: `C-l` - Centre editor
pt: `C-l` - Centra o editor

en: `M-/` - Comment/Uncomment current line or selection
pt: `M-/` - Comuta os comentários da linha actual ou seleção

en: `C-t` - Transpose/swap characters
pt: `C-t` - Transpõe/troca caracteres

en: `M-u` - Convert next word (or selection) to upper case.
pt: `M-u`- Converte a próxima palavra (ou selecção) para maiúsculas.

en: `M-l` - Convert next word (or selection) to lower case.
pt: `M-l` - Converte a próxima palavra (ou selecção) para minúsculas.

en: `C-a` - Move to beginning of line
pt: `C-a` - Mover para o inicio da linha

en: `C-e` - Move to end of line
pt: `C-e` - Mover para o final da linha

en: `C-p` - Move to previous line
pt: `C-p` - Mover para a linha anterior

en: `C-n` - Move to next line
pt: `C-n` - Mover para a próxima linha

en: `C-f` - Move forward one character
pt: `C-f` - Mover para a frente um caractere

en: `C-b` - Move backward one character
pt: `C-b` - Mover para trás um caractere

en: `M-f` - Move forward one word
pt: `M-f` - Mover para a frente uma palavra

en: `M-b` - Move backward one word
pt: `M-b`- Mover para trás uma palavra

en: `C-M-n` - Move line or selection down
pt: `C-M-n` - Mover uma linha ou selecção para baixo

en: `C-M-p` - Move line or selection up
pt: `C-M-p` - Mover linha ou selecção para cima

en: `S-M-u` - Move up 10 lines
pt: `S-M-u` - Mover para cima 10 linhas

en: `S-M-d` - Move down 10 lines
pt: `S-M-d`- Mover para baixo 10 linhas

en: `M-<` - Move to beginning of buffer
pt: `M-<` - Mover para o inicio da buffer

en: `M->` - Move to end of buffer
pt: `M->` - Mover para o final da buffer

en: Deletion
pt: Remoção

en: `C-h` - Delete previous character
pt: `C-h` - Remove o caractere anterior

en: `C-d` - Delete next character
pt: `C-d` - Remove o proximo caractere

en: Advanced Editor Features
pt: Características avançadas do editor

en: `C-i` - Show docs for word under cursor
pt: `C-i` - Mostra documentação sobre a palavra por baixo do cursor

en: `S-M-z` - Redo
pt: `S-M-z` - Refazer

en: `C-g` - Escape
pt: `C-g` - Escapar

en: `S-M-f` - Toggle fullscreen mode
pt: `S-M-f` - comutar ecrã total

en: `S-M-b` - Toggle visibility of buttons
pt: `S-M-b` - Comutar visibilidade dos botões

en: `S-M-l` - Toggle visibility of log
pt: `S-M-l` - Comuta visibilidade do registo

en: `S-M-m` - Toggle between light/dark modes
pt: `S-M-m` - Comuta entre o modo claro/escuro

en: `S-M-s` - Save contents of buffer to a file
pt: `S-M-s`- Salva o conteúdo de uma buffer para um ficheiro

en: `S-M-o` - Load contents of buffer from a file
pt: `S-M-o` - Carrega o conteúdo de uma buffer para um ficheiro

en: Sharing
pt: Partilha

en: Sonic Pi is all about sharing and learning with each other.
pt: No Sonic Pi é tudo sobre partilha e aprendendo uns com os outros.

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*.
pt: Depois de aprenderes a codificar musica, partilhar as tuas composições é tão simples como mandar um email contendo o teu código. Por favor *partilha* o teu código com outro para que eles possam *aprender* com o teu trabalho ou mesmo usar num novo*mash-up*.

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.
pt: Se estás inseguro da melhor maneira de partilhar o teu trabalho com outros eu recomendo colocar o código no [GitHub] (https://github.com) e a tua música no [SoundCloud](https://soundcloud.com). Dessa forma poderás facilmente chegar a uma grande audiência.

en: Code -> GitHub
pt: Código -> GitHub

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.
pt: [GitHub](https://github.com) é um site para trabalhar e partilhar código. É usado por criadores bem como artistas para partilhar e colaborar no código. A maneira mais simples de partilhar uma nova peça de código (ou mesmo uma peça inacabada) é criar um [Gist](https://gist.github.com). Um [Gist](https://gist.github.com) é uma maneira simples de enviar o teu código numa maneira simples para os outros o verem, copiarem e partilharem.

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.
pt: Uma outra maneira importante de partilhares o teu trabalho é gravares o audio e o enviares para o [SoundCloud](https://soundcloud.com). Depois de enviares a tua peça, outro utilizadores podem comentar e discutir o teu trabalho. Eu recomendo também colocares uma ligação para o [Gist](https://gist.github.com) do teu código na descrição da faixa.

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).
pt: Para gravares o teu trabalho, clica no botão `Rec` na barra de ferramentas e a gravação começa imediatamente. Clica `Run` para começar a correr o teu código se não estiver já a correr. Quando estiver pronta a gravação, clica no botão `Rec` a piscar a vermelho outra vez, e será pedido para dar o nome ao ficheiro. A gravação será salva como ficheiro WAV, que pode ser editado e convertido para MP3 por diversos programas grátis (experimenta o Audacity por exemplo).

en: Hope
pt: Esperança

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.
pt: Eu encorajo-te a partilhares o teu trabalho e tenho esperança que todos aprendamos uns com os outros truques novos para o Sonic Pi. Estou mesmo excitado com o que tens para me mostrar.

en: Performing
pt: Performance

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.
pt: Um dos aspectos mais excitantes no Sonic Pi é que permite usares código como um *instrumento musical*. Isto significa que escrever código ao vivo pode agora ser visto como uma performance musical.

en: We call this *Live Coding*.
pt: Chamamos a isso *Live Coding*.

en: Show Your Screen
pt: Mostra o teu ecrã

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.
pt: Quando codificas ao vivo eu recomendo *mostrares o teu ecrã*. De outro modo é como tocar guitarra mas esconderes os teus dedos e as cordas. Quando pratico em casa eu uso o Raspberry Pi e um pequeno projector na minha sala de estar. Poderás usar uma Tv ou um projector para dares um espectáculo. Experimenta, é muito divertido.

en: Form a Band
pt: Forma uma banda

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).
pt: Live coding não é uma coisa completamente nova . Um pequeno número de pessoas têm estado a fazer durante alguns anos, tipicamente usando sistemas que eles proprios criaram. Um excelente sitio para descobrir mais sobre live coders e sistemas é [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.
pt: Outro grande recurso para explorar o mundo do live coding é [Algorave](http://algorave.com). Onde podes descobrir tudo sobre um tipo especifico de live coding para a criação de musica em clubes nocturnos.

en: Sonic Pi now supports a simple API for interacting with Minecraft Pi - the special edition of Minecraft which is installed by default on the Raspberry Pi's Raspbian Linux-based operating system.
pt: O Sonic Pi suporta agora um simples API para interagir com o Minecraft Pi - uma edição especial do Minecraft que vem instalada por default no sistema operativo baseado no Raspian Linux instalado no Raspberry Pi.

en: No need to import libraries
pt: Não é necessário importar bibliotecas

en: The Minecraft Pi integration has been designed to be insanely easy to use. All you need to do is to launch Minecraft Pi and create a world. You're then free to use the `mc_*` fns just like you might use `play` and `synth`. There's no need to import anything or install any libraries - it's all ready to go and works out of the box.
pt: A integração do Minecraft Pi foi desenhada para ser extremamente fácil de usar. Tudo o que necessitas é correr o minecraft Pi e criar um mundo. Então podes usar a função `mc_*` tal como poderias usar o `play` e `synth`. Não é necessário importar nada ou instalar bibliotecas - está pronto a ser usado e funciona "out of the box".

en: Automatic Connection
pt: Conexão automática

en: The Minecraft Pi API takes care of managing your connection to the Minecraft Pi application. This means you don't need to worry about a thing. If you try and use the Minecraft Pi API when Minecraft Pi isn't open, Sonic Pi will politely tell you. Similarly, if you close Minecraft Pi whilst you're still running a `live_loop` that uses the API, the live loop will stop and politely tell you that it can't connect. To reconnect, just launch Minecraft Pi again and Sonic Pi will automatically detect and re-create the connection for you.
pt: O API do Minecraft Pi trata de gerir a conexão à aplicação do Minecaft Pi. Isso significa que não precisas de te preocupar com nada. Se tentares usar o API do Minecraft Pi quando o Minecraft Pi ainda não está a correr, o Sonic Pi educadamente vai-te avisar. Similarmente, se fechares o Minecraft Pi enquanto ainda estiveres a correr um `live_loop` que usa o API, o live loop irá parar e dirá que não se consegue conectar. Para reconectar basta correres o Minecraft Pi outra vez e o Sonic Pi irá detectar e recriar a conexão por ti.

en: Designed to be Live Coded
pt: Desenhado para ser codificado ao vivo

en: The Minecraft Pi API has been designed to work seamlessly within `live_loop`s. This means it's possible to synchronise modifications in your Minecraft Pi worlds with modifications in your Sonic Pi sounds. Instant Minecraft-based music videos! Note however that Minecraft Pi is alpha software and is known to be slightly buggy. If you encounter any problems simply restart Minecraft Pi and carry on as before. Sonic Pi's automatic connection functionality will take care of things for you.
pt: O API do Minecraft Pi foi desenhado para trabalhar sem falhas dentro dos `live_loop`s. Isto significa que é possível sincronizar modificações nos teus mundos do Minecraft Pi com modificações nos teus sons do Sonic Pi. Videos musicais baseados no Minecraft instantâneos! Nota no entanto que o Minecraft Pi é um software alpha e pode ter bugs. Se encontrares alguns problemas, simplesmente reinicia o Minecraft Pi e continua como anteriormente. A conexão automática do Sonic Pi encarrega-se do resto.

en: Requires a Raspberry Pi 2.0
pt: Requer o Raspberry Pi 2.0

en: It is highly recommended that you use a Raspberry Pi 2 if you wish to run both Sonic Pi and Minecraft at the same time - especially if you want to use Sonic Pi's sound capabilities.
pt: É altamente recomendado que uses o Raspberry Pi 2 se quiseres correr ao mesmo tempo o Sonic Pi e o Minecraft - especialmente se quiseres utilizar as capacidades sonoras do Sonic Pi.

en: API Support
pt: Suporte de API

en: At this stage, Sonic Pi supports basic block and player manipulations which are detailed in Section 11.1. Support for event callbacks triggered by player interactions in the world is planned for a future release.
pt: Nesta fase, o Sonic Pi suporta blocos básicos e manipulação pelo jogador que são detalhadas na secção 11.1.  Suporte para chamada de eventos despoletadas pelo jogador no mundo está planeado para futuras edições.

en: Basic Minecraft Pi API
pt: API básico do Minecraft Pi

en: Sonic Pi currently supports the following basic interactions with Minecraft Pi:
pt: O Sonic Pi suporta as seguintes iterações básicas com o Minecraft Pi:

en: Displaying chat messages
pt: Visualizar mensagens de chat

en: Setting the position of the user
pt: Definir a posição do jogador

en: Getting the position of the user
pt: Receber a posição do jogador

en: Setting the block type at a given coordinate
pt: Colocar um determinado tipo de bloco numa determinada coordenada

en: Getting the block type at a given coordinate
pt: Verificar o tipo de bloco de determinada coordenada

en: Let's look at each of these in turn.
pt: Vamos ver cada uma delas à vez.

en: Let's see just how easy it is to control Minecraft Pi from Sonic Pi. First, make sure you have both Minecraft Pi and Sonic Pi open at the same time and also make sure you've entered a Minecraft world and can walk around.
pt: Vamos ver como é fácil controlar o Minecraft Pi a partir do Sonic Pi. Primeiro, verifica que temos o Minecraft Pi e o Sonic Pi abertos ao mesmo tempo e que entramos no mundo do Minecraft e nos podemos deslocar.

en: In a fresh Sonic Pi buffer simply enter the following code:
pt: Numa nova buffer do Sonic Pi coloca o seguinte código:

en: When you hit the *Run* button, you'll see your message flash up on the Minecraft window. Congratulations, you've written your first Minecraft code! That was easy wasn't it.
pt: Quando pressionamos o botão *Run*, verás uma mensagem a piscar na janela do Minecraft. Parabéns, escreveste o teu primeiro código no Minecraft! Isto foi fácil não foi.

en: Now, let's try a little magic. Let's teleport ourselves somewhere! Try the following:
pt: Agora vamos experimentar uma pequena magia. Vamos teleportar para outro sitio! Experimenta o seguinte:

en: When you hit *Run* - boom! You're instantantly transported to a new place. Most likely it was somewhere in the sky and you fell down either to dry land or into water. Now, what are those numbers: `50, 50, 50`? They're the coordinates of the location you're trying to teleport to. Let's take a brief moment to explore what coordinates are and how they work because they're really, really important for programming Minecraft.
pt: Quando carregares no *Run* - Boom! És instantaneamente teleportado para um novo sitio. Mais provável algures no céu e caíste em terra seca ou para a água. Agora, o que são estes números: `50, 50, 50`? Eles são as coordenadas da localização que estás a tentar teleportar. Vamos tomar algum tempo para explorar que coordenadas são e como funcionam porque elas são realmente importante para programares o Minecraft.

en: Coordinates
pt: Coordenadas

en: Imagine a pirate's map with a big `X` marking the location of some treasure. The exact location of the `X` can be described with two numbers - how far along the map from left to right and how far along the map from bottom to top. For example `10cm` across and `8cm` up. These two numbers `10` and `8` are coordinates. You could easily imagine describing the locations of other stashes of treasure with other pairs of numbers. Perhaps there's a big chest of gold at `2` across and `9` up...
pt: Imagina um mapa de um pirata com um `X` grande marcando o local de algum tesouro. A localização exacta do `X` pode ser descrita com dois números - quando ao longo do mapa da esquerda para a direita e quanto ao longo do mapa do fundo para o topo. Por exemplo `10 cm` ao longo e `8 cm` para cima. Estes dois números `10` e `8` são coordenadas. Podes imaginar facilmente descreveres a localização de outros tesouros com outros pares de números. Talvez exista um grande baú de ouro em `2` ao longo e `9` para cima...

en: Now, in Minecraft two numbers isn't quite enough. We also need to know how high we are. We therefore need three numbers:
pt: Agora, no Minecraft dois números não são suficientes. Necessitamos também saber a altura que estamos. Assim necessitamos 3 números:

en: How far from right to left in the world - `x`
pt: Quanto ao longo da direita para a esquerda estamos no mundo - `x`

en: How far from front to back in the world - `z`
pt: Quando ao longo da frente para trás estamos no mundo - `z`

en: How high up we are in the world - `y`
pt: Quando alto estamos no mundo - `y`

en: One more thing - we typically describe these coordinates in this order `x`, `y`, `z`.
pt: Uma coisa a mais - tipicamente descrevemos estas coordenadas nesta ordem `x`,`y`,`z`.

en: Finding your current coordinates
pt: Descobrindo as coordenadas actuais

en: Let's have a play with coordinates. Navigate to a nice place in the Minecraft map and then switch over to Sonic Pi. Now enter the following:
pt: Vamos brincar com estas coordenadas. Navega para um sitio agradável no mapa do Minecraft e depois muda para o Sonic Pi. Agora escreve o seguinte:

en: When you hit the *Run* button you'll see the coordinates of your current position displayed in the log window. Take a note of them, then move forward in the world and try again. Notice how the coordinates changed! Now, I recommend you spend some time repeating exactly this - move a bit in the world, take a look at the coordinates and repeat. Do this until you start to get a feel for how the coordinates change when you move. Once you've understood how coordinates work, programming with the Minecraft API will be a complete breeze.
pt: Quando carregares no botão *Run* verás que as coordenadas da tua posição actual apresentadas na janela de log. Toma nota delas, depois move-te para a frente no mundo e tenta outra vez. Repara como as coordenadas mudaram! Agora, recomendo que passes algum tempo a repetir isto - move-te um pouco pelo mundo, verifica as coordenadas e repete. Faz isso até perceberes como as coordenadas mudam enquanto te moves. Uma vez que percebas isso, programar com o API do Minecraft será muito fácil.

en: Let's Build!
pt: Vamos construir!

en: Now that you know how to find the current position and to teleport using coordinates, you have all the tools you need to start building things in Minecraft with code. Let's say you want to make the block with coordinates `40`, `50`, `60` to be glass. That's super easy:
pt: Agora que sabemos encontrar a posição actual e teleportar usando coordenadas, terás todas as ferramentas para começar a construir coisas com código Minecraft. Digamos que queres criar um bloco de vidro com coordenadas `40, `50`, `60`. É muito fácil:

en: Haha, it really was that easy. To see your handywork just teleport nearby and take a look:
pt: Haha, foi muito fácil. Para ver o resultado teleporta-te para uma zona perto e dá uma olhada:

en: Now turn around and you should see your glass block! Try changing it to diamond:
pt: Agora volta-te e verás o teu bloco de vidro! Tenta muda-lo para um diamante:

en: If you were looking in the right direction you might have even seen it change in front of your eyes! This is the start of something exciting...
pt: Se tiveres voltado para o lado correcto poderás ter visto a mudança a frente dos teus olhos! Isto é o principio de algo excitante...

en: Looking at blocks
pt: Observando os blocos

en: Let's look at one last thing before we move onto something a bit more involved. Given a set of coordinates we can ask Minecraft what the type of a specific block is. Let's try it with the diamond block you just created:
pt: Vamos ver uma ultima coisa antes de seguirmos para algo mais evoluido. Dado um conjunto de coordenadas podemos perguntar ao Minecraft que tipo especifico de bloco é. Vamos experimentar com o bloco de diamante que acabamos de criar:

en: Yey! It's `:diamond`. Try changing it back to glass and asking again - does it now say `:glass`? I'm sure it does :-)
pt: Yey! É um `:diamond`. Tenta mudar do movo para vidro e perguntar outra vez - agora diz `:glass`? Tenho a certeza que sim :-)

en: Available block types
pt: Tipo de blocos disponíveis

en: Before you go on a Minecraft Pi coding rampage, you might find this list of available block types useful:
pt: Antes de ires num diluvio de código no Minecraft Pi, poderás achas a seguinte lista de tipo de blocos disponíveis útil:
