Sonic Pi - en to ja translation catalogue (1266 entries)

en: 1 Welcome to Sonic Pi
ja: 1 Sonic Pi へようこそ

en: Welcome friend :-)
ja: Welcome friend:-)

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.
ja: でも、ちょっと待ってください。まずは自己紹介が必要でしたね。失礼いたしました！ 私は、Sonic Piを作成した[Sam Aaron](http://twitter.com/samaaron)といいます。Twitter上の[@samaaron](http://twitter.com/samaaron)で見つけることができますので、連絡くれるとうれしいです。もしかすると、僕がSonic Piを使って観客の前で演奏している[ライブコーディングのパフォーマンス](https://youtube.com/samaaron)にも興味を持ってもらえるかもしれません。

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!
ja: Sonic Piを改善するために、気づいたことや、アイデアを持っていたら、是非、知らせてください。フィードバックはとても役立ちます。あなたのアイデアが次の重要な機能になるかもしれません！

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.
ja: 最後に、このチュートリアル（使いかた）は、カテゴリ別にグループ化されたセクションに分かれています。始まりから終わりまで、簡単に学べるように手引きを書いたので、自由に、色々なセクションを覗いてみてください。何か、不足している点に気がついたら、将来のバージョンのために検討したいので、知らせてください。

en: Finally, watching others live code is a really great way to learn. I regularly stream live on [https://youtube.com/samaaron](http://youtube.com/samaaron) so please do drop by, say hi and ask me lots of questions :-)
ja: 最後に、他人のライブコーディングを見るのはとても良い学習方法です。私は定期的に[http://youtube.com/samaaron](http://youtube.com/samaaron)でライブをストリーミングしているので、ぜひ立ち寄って、たくさんの質問をしてみてください :-)

en: OK, let's get started...
ja: では、早速はじめましょう！

en: 1.1 Live Coding
ja: 1.1 ライブコーディング

en: Live Coding
ja: ライブコーディング

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.
ja: Sonic Piの最もエキサイティングな側面のひとつは、まるでギターをライブで演奏するかのように、ライブでコードを書いて音楽を作ることができることです。つまり、ステージやコンサートでSonic Piが使えるということです！

en: Free your mind
ja: 心を解き放て

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...
ja: これからチュートリアルで、実際のSonic Piの詳しい使い方に入る前に、まず、ライブコーディングがどんなものか体験してみましょう。あまり（もしくは全然）わからなくても、心配ご無用！ そのまま席についたまま、楽しんでいきましょう。

en: A live loop
ja: ライブループ

en: Let's get started, copy the following code into an empty buffer:
ja: さぁ、はじめましょう！ 下のコードを上の空欄のエディタにコピーしてみましょう。

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

en: Now, press the `Run` button and you'll hear a nice fast bass drum beating away. If at any time you wish to stop the sound just hit the `Stop` button. Although don't hit it just yet... Instead, follow these steps:
ja: 左上の`Run`（再生）ボタンを押すと、いい感じの速さでバスドラムの音が聞こえてきます。`Stop`（停止）ボタンを押せば、いつでも音を止めることができます。ですが、まだ`Stop`（停止）ボタンを押さずに、次のステップを実行しましょう。

en: Make sure the bass drum sound is still running
ja: バスドラムがまだ鳴っていることを確認します。

en: Change the `sleep` value from `0.5` to something higher like `1`.
ja: `sleep`の値を、`0.5`から、`1`のような、より大きい値に書き換えてみましょう。

en: Press the `Run` button again
ja: `Run`（再生）ボタンをもう一度押します。

en: Notice how the drum speed has changed.
ja: ドラムの速さがどのように変わったかを確認してみましょう。

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...
ja: この瞬間を忘れないでください。これが、あなたが初めてSonic Piでライブコーディングをした瞬間です。そしてこれが最後にはならないはず…

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:
ja: これは簡単でした。では他の要素を加えてみましょう。`sample :bd_haus`の上に、`sample :ambi_choir, rate: 0.3`を追加してみます。コードはこのようになるはずです。

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

en: Now, play around. Change the rates - what happens when you use high values, or small values or negative values? See what happens when you change the `rate:` value for the `:ambi_choir` sample just slightly (say to `0.29`). What happens if you choose a really small `sleep` value? See if you can make it go so fast your computer will stop with an error because it can't keep up (if that happens, just choose a bigger `sleep` time and hit `Run` again).
ja: では、ちょっと遊んでみましょう。値を変えてみてください。大きな値、小さな値、もしくはマイナスの値にしたとき、何が起こるでしょうか？ では、`:ambi_choir`の`rate:`の値をほんの少し（0.29などに）変えた時、どうなるでしょう？ `sleep`の値をすごく小さくすると、どうでしょう？ 速くしすぎると、エラーが出てコンピュータが止まってしまいます。これはコンピュータがついていけないからです（そんな時は、より大きい値を`sleep`に設定して`Run`ボタンをもう一度押しましょう）。

en: Try commenting one of the `sample` lines out by adding a `#` to the beginning:
ja: では、`sample`の行に`#`をつけることで、「コメント」してみてください。

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

en: Notice how it tells the computer to ignore it, so we don't hear it. This is called a comment. In Sonic Pi we can use comments to remove and add things into the mix.
ja: コンピュータに#をつけた行を無視するよう命令したので、聞こえませんね。これはコメントと呼ばれます。Sonic Piでは、要素を削除したり追加したりするのにコメントを使います。

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:
ja: 最後に、遊んでみると面白いのことをみなさんにお伝えしましょう。下のほうにあるコードを空いたBufferにコピーします。次に、2つのループがある（つまり2つのことが同時進行している）ということ以外は深く考えないようにして、遊びながら実験してみましょう。その際、以下のようなヒントがあります：

en: Try changing the blue `rate:` values to hear the sample sound change.
ja: `rate:`の青い値を変更し、`sample`の音が変わることを聞いてみましょう。

en: Try changing the `sleep` times and hear that both loops can spin round at different rates.
ja: `sleep`の時間を変更し、それぞれのループを異なる速度で繰り返すのを聞いてみましょう。

en: Try uncommenting the sample line (remove the `#`) and enjoy the sound of the guitar played backwards.
ja: `sample`の行のコメントを解除して（`#`を削除）、ギターの逆再生を楽しみましょう。

en: Try changing any of the blue `mix:` values to numbers between `0` (not in the mix) and `1` (fully in the mix).
ja: いくつかの`mix:`の値を`0`（最小値）から`1`（最大値）の間で変えてみましょう。

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...
ja: `Run`ボタンを押すのを忘れないでください。次のループで音が変化するのを聞くことができるでしょう。うまくいかなくても気にしないでください。`Stop`ボタンを押して、Buffer内のコードを削除して、新しいコードをコピー&ペーストして、再び演奏の準備をすれば良いです。失敗することがどんなことよりも学習の近道になるのですから。

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

en: Now, keep playing and experimenting until your curiosity about how this all actually works kicks in and you start wondering what else you can do with this. You're now ready to read the rest of the tutorial.
ja: さあ、これらが実際にどう動くか好奇心が動き出すまで、そしてあなたが次に何をしたらいいかを知りたくなるまで、演奏と実験を続けましょう。さあ、残りのチュートリアルを読む準備ができました。

en: So what are you waiting for...
ja: 次にあなたを待っているものは…

en: 1.2 Exploring the Interface
ja: 1.2 インタフェースの探索

en: The Sonic Pi Interface
ja: Sonic Pi のインタフェース

en: Sonic Pi has a very simple interface for coding music. Let's spend a little time exploring it.
ja: Sonic Piは、音楽をコーディング（記述）するためのとてもシンプルなインタフェース（操作画面）を持っています。ちょっと見てみましょう。

en: ![Sonic Pi Interface](../../../etc/doc/images/tutorial/GUI.png)
ja: ![Sonic Piのインターフェイス](../../../etc/doc/images/tutorial/GUI.png)

en: *A* - Play Controls
ja: *A* - 演奏の操作

en: *B* - Editor Controls
ja: *B* - 編集の操作

en: *C* - Info and Help
ja: *C* - 情報とヘルプ

en: *D* - Code Editor
ja: *D* - コードエディタ

en: *E* - Prefs Panel
ja: *E* - 設定画面

en: *F* - Log Viewer
ja: *F* - ログビューア

en: *G* - Help System
ja: *G* - ヘルプシステム

en: *H* - Scope Viewer
ja: *H* - スコープビューア

en: *I* - Cue Viewer
ja: *I* - キュービューア

en: A. Play Controls
ja: A. 演奏の操作

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.
ja: ここにあるピンクのボタンで、音を再生したり停止するための主要な操作ができます。*Run*ボタンは編集画面内のコードを実行します。*Stop*ボタンですべてのコードの動作を停止します。*Save*ボタンは外部ファイルにコードを保存し、*Record*ボタンは演奏中の音を（WAVファイルに）録音します。

en: B. Editor Controls
ja: B. 編集の操作

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.
ja: ここにあるピンクのボタンでコードエディタの設定を変えられます。*Size +* と *Size -* ボタンでコードエディタの文字を大きくしたり小さくしたりできます。

en: C. Info and Help
ja: C. 情報とヘルプ

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.
ja: これらの青いボタンで、情報、ヘルプや設定にアクセスします。*Info*ボタンは、概要、コア、協力者、コミュニティ、ライセンス、ヒストリーといったSonic Pi自体についての情報を画面に表示します。*Help*ボタンは*G*のヘルプシステム表示を切り替えます。また*Prefs*ボタンは基本的なシステムを操作するための設定画面の表示を切り替えます。

en: D. Code Editor
ja: D. コードエディタ

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.
ja: ここは音楽を作曲/演奏したりするためのコードを書く領域です。コードを書いたり、消したり、切り取り、貼り付けなどを行うためのシンプルな編集画面です。Google DocsやWordの基本版だと思ってください。編集画面ではコードの意味合いに応じて自動で色つけします。はじめは変わっていると思うかもしれませんが、とても使いやすくなるはずです。例えば、数値は青色で示されます。

en: E. Prefs Panel
ja: E. 設定画面

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.
ja: Sonic Piには変更可能な設定がたくさんあり、*Prefs*ボタンを切り替えることでアクセスできます。このボタンにより、環境設定パネルの表示/非表示を切り替えることができます。設定の例としては、モノラルモードへの変更や、ステレオ反転、ログ出力の切り替え、さらにRaspberry Piのボリュームスライダーやオーディオセレクターなどがあります。

en: F. Log Viewer
ja: F. ログビューア

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.
ja: コードを実行させた時、ログ画面にはプログラムがどうなっているかについての情報が表示されます。デフォルトでは、正確な再生時間を毎音ごとにメッセージとして見ることができます。コードのデバッグ（欠陥を取り除く作業）に利用でき、コードが何をしているかを理解することにも役立ちます。

en: G. Help System
ja: G. ヘルプシステム

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.
ja: 最後は、Sonic Piインタフェースのもっとも重要な部分の1つである、画面の下にあるヘルプシステムです。青い*Help*ボタンによって表示/非表示を切り替えることができます。ヘルプシステムは、ヘルプと情報を含んでいます。このチュートリアル、入手できるシンセのリスト、サンプルや実例、エフェクトのリスト、そして音楽をコーディングするために備えているSonic Piの全機能のリストといった、Sonic Piの全てについてのヘルプと情報があります。

en: H. Scope Viewer
ja: H. スコープビューア

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).
ja: スコープビューアは、あなたの聞いている音を見ることを可能にします。ノコギリ波がのこぎりのようだったり、単純なビープ音が正弦波であることを簡単に見ることが出来ます。また、うるさい音と静かな音の違いを線の大きさで見ることも可能です。Sonic Piには、3つのスコープがあります。デフォルトは左右のチャネルを混ぜあわせたモノラルスコープです。左右のチャネルを別々のスコープで描画するステレオスコープがあります。最後に、左右のチャネルの位相の関係を描画する[リサジュース曲線](https://ja.wikipedia.org/wiki/%E3%83%AA%E3%82%B5%E3%82%B8%E3%83%A5%E3%83%BC%E5%9B%B3%E5%BD%A2)スコープがあります。

en: I. Cue Viewer
ja: F. キュービューア

en: All internal and external events (called cues in Sonic Pi) are automatically logged in the Cue Viewer. For example, if you have a MIDI controller connected and press one of its buttons, you'll see a new cue event in the Cue Viewer telling you the name of the controller and which button you pressed. Once you've mastered the basics of making and producing sounds, you'll start to want to cue sounds or whole sections of sounds based on events such as these. A cue event is just an indication that something happened. For example, every time a live loop spins round, it sends a cue event out which is logged in the Cue Viewer. Also, external events such as MIDI messages from connected MIDI equipment and OSC messages from other programs or computers are also displayed in the Cue Viewer. It is also possible to directly generate cue events using the `cue` function. Anything that appears in the Cue Viewer can be used to trigger something happening. This is covered in more detail in Sections 10 to 12 of this tutorial.
ja: すべての内部および外部のイベント（Sonic Piではキューと呼ばれます）は、キュービューアーに自動的に記録されます。たとえば、MIDIコントローラーが接続された状態でボタンを押すと、コントローラーの名前からなる新しいキューイベントがキュービューアーに表示されます。サウンドの作成と生成の基本をマスターすると、このようなイベントに基づいて、サウンドまたはサウンドのセクション全体をキューに入れたいと思うようになります。キューイベントは、何かが起こったことを示すだけです。たとえば、ライブループが実行されるたびに、キュービューアに記録されているキューイベントが送信されます。また、接続されているMIDI機器からのMIDIメッセージや他のプログラムやコンピューターからのOSCメッセージなどの外部イベントもキュービューアーに表示されます。 `cue`関数を使用してキューイベントを直接生成することもできます。キュービューアに表示されるものはすべて、何かが発生するようにトリガーするために使用できます。これについては、このチュートリアルのセクション10〜12で詳しく説明しています。

en: 1.3 Learning through Play
ja: 1.3 遊びを通した学び

en: Learning through Play
ja: 遊びを通した学び

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.
ja: Sonic Piは、遊びと実験を通して、コンピューティングと音楽の両方を学ぶ手助けをしてくれます。もっとも大切なことは、楽しむこと。そうすれば、コードや作曲、演奏を、学ぶ前に自然と身につけられるでしょう。

en: There are no mistakes
ja: 間違いはない

en: Whilst we're on this subject, let me just give you one piece of advice I've learned over my years of live coding with music - *there are no mistakes, only opportunities*. This is something I've often heard in relation to jazz but it works equally well with live coding. No matter how experienced you are - from a complete beginner to a seasoned live coder, you'll run some code that has a completely unexpected outcome. It might sound insanely cool - in which case run with it. However, it might sound totally jarring and out of place. It doesn't matter that it happened - what matters is what you do next with it. Take the sound, manipulate it and morph it into something awesome. The crowd will go *wild*.
ja: このチュートリアルの内容に取り組むにあたって、私が何年もライブコーディングしてきて得られたアドバイスを紹介しましょう。「間違いはない、あるのはただ可能性だけ」これは、しばしばジャズについて言われることですが、ライブコーディングにも同様に言えることです。経験に関係なく、あなたが全くの初心者でも、熟練のライブコーダーでも、コードを実行してまったく予期せぬ結果になることがあります。めちゃくちゃクールに聞こえる場合は、そのコードを実行すればいいのですが、すごく耳障りで場違いに聞こえる場合もあります。そうなっても問題ではありません。重要なのは、あなたが次にすべきことです。音を取り、操作し、素晴らしいものに変えるのです。観衆は*熱狂*するでしょう。

en: Start Simple
ja: シンプルにはじめよう

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.
ja: 学習していると、*今すぐ*すごいことをしたい気持ちに駆られます。しかし、今はその気持ちをこらえ、それは*後に*到達する遠い目標として持ってください。その代わり、今のところは、あなたが楽しくやりがいをもって書くことができる*最も単純な*事を考えていきましょう。それが、あなたの頭の中のすごいことへの小さな一歩になるのです。一度その単純な一歩についてアイデアを思いついたら、それを作って遊んでみてください。そして、そこからどのような新しいアイデアを得られるか見てみましょう。すぐに、あなたは楽しみながら確実に上達することに大忙しになっているでしょう。

en: Just make sure to share your work with others!
ja: でも、みんなと作品をシェア（共有）することは忘れないでください！

en: 2 Synths
ja: 2 シンセ

en: Synths
ja: シンセ

en: OK, enough of the intros - let's get into some sound.
ja: Sonic Piの紹介はこれくらいにして、さっそく音を試してみましょう。

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...
ja: Sonic Piの分かりやすくシンプルな操作画面に騙されないでください。もし使いこなせたら、洗練されたサウンド操作を可能にします。きっと驚くはずです。

en: 2.1 Your First Beeps
ja: 2.1 初めての音

en: Your First Beeps
ja: 初めての音

en: Take a look at the following code:
ja: 次のコードを見てください。

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...
ja: ここからすべてが始まります。アプリケーションの上部のコードウィンドウ（`Run`ボタンの下の大きな空白）にコピーして貼り付けます。そして、`Run`ボタンを押してみましょう。

en: Beep!
ja: ビープ音が鳴った！

en: Intense. Press it again. And again. *And again...*
ja: ビックリした？ もう1回、押してみましょう。*そしてもう1回…*

en: Can you hear the difference? Try a lower number:
ja: 違いが分かりますか？ より低い値も試してみましょう。

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.
ja: したがって、数値が小さいほどビープ音のピッチが低くなり、数値が大きいほどビープ音のピッチが高くなります。 ピアノと同じように、ピアノの下部（左側）のキーは低い音を演奏し、ピアノの上部（右側）のキーは高い音を演奏します。

en: It turns out that the C of the 4th octave (C in English notation) is identified by the number 60. `play 60` therefore plays the C of the 4th octave. To play the next piano key to the right, you have to add 1 to 60 and then type `play 61`, which in this case is the black key of the C sharp. To play the D, the next key to the right, `play 62`.
ja: ド(英語圏でのCの第4オクターブ)は数値60で表せます。よって、`play 60`はドを再生します。ピアノの次の音を奏でるには、数値60に1を足して`play 61`と入力する、この場合はピアノの黒鍵、ド#が再生されます。レを再生するにはこの次の鍵盤の数値である、`play 62`で再生することができます。

en: *Don't worry* if this means nothing to you - it didn't to me when I first started. All that matters right now is that you know that *low numbers make lower beeps* and *high numbers make higher beeps*.
ja: もし、これがあなたにとって何の意味か分からなくても*心配しない*でください。私も始めた時は同じでした。いま重要なことは、*小さい数値は低い音*を、*大きい数値は高い音*を生み出す、ということを知っておくことです。

en: Chords
ja: 和音

en: Playing a note is quite fun, but playing many at the same time can be even better. Try it:
ja: 音符を奏でることはとても楽しいですが、同時にたくさんの音符を鳴らすとさらに楽しくなります。これを試してみましょう。

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.
ja: 華やかです！ 複数の`play`を書くと、全て同時に演奏されます。自分で試してみましょう。どの数値がいい組み合わせでしょうか？ どれがひどい音？ 実験、探求しながら、自分自身で見つけていきましょう。

en: Melody
ja: メロディー

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:
ja: 音符と和音を演奏するのは楽しいですね。でも、メロディーの演奏はどうすればよいでしょうか？一音ずつ、同時ではなく演奏したい場合は？ それは簡単です。音符の間に`sleep`を入れば可能です。

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`:
ja: なんて素敵なアルペジオ（和音を続けて弾くこと）！ では、`sleep 1`の`1`は何を意味するのでしょうか？ これは1拍休む、という意味ですが、とりあえず今は、1秒休む、と考えましょう。では、アルペジオをもう少し早くしたいと思ったら？ それは、短い値を使えばよいのです。例えば半分の値`0.5`ではどうでしょう？

en: Notice how it plays faster. Now, try for yourself, change the times - use different times and notes.
ja: 早くなりましたね。では、自分で時間を変えてみましょう。違う時間と音符を使ってみましょう。

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.
ja: たとえば`play 52.3`や`play 52.63`のような中間的な値でも演奏してみてください。通常の音符にこだわる必要は全くありません。遊んで、楽しんでみてください。

en: Traditional Note Names
ja: 伝統的な音符の名前

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:
ja: みなさんの中で、すでにいくつかの音楽記号を知っている人は、たとえばCとかF#などの音名を使ってメロディーを書きたいかも知れません（もし知らなくても心配無用です。それが必要というわけではありません）。Sonic Piはそれをカバーしてくれます。以下のことをやってみましょう。

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:
ja: 演奏する音階の前にコロン':'を入れることを忘れないでください。コロンを置くと、Cが`:C`のように色が変わります。また、音名のあとに数値を追加してオクターヴを指定することもできます。

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`.
ja: 半音♯（シャープ）にしたい場合は、’play :Fs3'のように音名の後に's'を追加します。半音♭（フラット）にしたい場合は、'play :Eb3'のように'b'を追加します。

en: 2.2 Synth Options
ja: 2.2 シンセのオプション

en: Synth Options: Amp and Pan
ja: シンセのオプション: ampとpan

en: As well as allowing you to control which note to play or which sample to trigger, Sonic Pi provides a whole range of options to craft and control the sounds. We'll be covering many of these in this tutorial and there's extensive documentation for each in the help system. However, for now we'll introduce two of the most useful: *amplitude* and *pan*. First, let's look at what options actually are.
ja: Sonic Piは、演奏した音符や再生したサンプルを制御可能なだけでなく、音の作成や制御のための様々なオプションを提供しています。このチュートリアルではこれらの多くを紹介していく予定です。また、ヘルプシステムにはそれぞれについての詳細なドキュメントがあります。ここでは、その中でも最も有用なものの2つ、*amplitude（音量）*と*pan（パン）*を紹介します。では最初に、オプションが実際にどのようなものか見てみましょう。

en: Options
ja: オプション

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).
ja: Sonic Piはシンセのためにオプションという概念を備えています。オプションは、サウンドの特徴をコントロールしたり変更するための手段で、`play`に渡されます。シンセはそれぞれ独自に細かく音をチューニングするためのオプションを持っています。その一方で、`amp:`（音量）やエンベロープ（他の章で紹介します）のような、多くのサウンドに共通するオプションもあります。

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:
ja: オプションは、`play`の後にカンマ`,`を入れて、その後、`amp:`（コロン`:`を忘れずに）のようなオプションの名前、スペース、そしてオプションの値、というように渡していきます。例えば、

en: (Note that `cheese:` isn't a valid opt, we're just using it as an example).
ja: （`cheese:`は無効なオプションです。例として使っています）

en: You can pass multiple opts by separating them with a comma:
ja: カンマを使って区切り、複数のオプションを使用することができます。

en: The order of the opts doesn't matter, so the following is identical:
ja: オプションの順番は問題ではないので、以下は同じものです。

en: Opts that aren't recognised by the synth are just ignored (like `cheese` and `beans` which are clearly ridiculous opt names!)
ja: シンセで認識されないオプションは無視されます（`cheese`（チーズ）と`beans`（豆）などは明らかに馬鹿げた名前でしょう！）

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:
ja: もし偶然同じオプションを2回、違う値で使った場合は、最後のものが有効になります。例えば、ここでの`beans:`は、0.5ではなく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:`.
ja: Sonic Piの多くの命令にはオプションが用意されているので、ちょっとだけ時間を使って、その使い方を習得しましょう！ それでは最初のオプション`amp:`で演奏してみましょう。

en: Amplitude
ja: アンプ（音量）

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.
ja: アンプは音の大きさをコンピュータで表したものです。*アンプが大きいと大きな音を出し*、*アンプが小さいと静かな音を出し*ます。Sonic Piは時間と音符を数字を使って表現するので、アンプにも数字を使用します。1の値が通常の音量であるのに対して、0はサイレント（無音）です（何も聞こえませんよ）。2、10、100 というふうに、アンプを上げることができます。ただし、全体の音を増幅しすぎると、大きな音になりすぎないように、Sonic Piはコンプレッサー（圧縮）と呼ばれるエフェクトを使用して確実な音量に抑えることを覚えておいてください。これは多くの場合、音がこもって奇妙に聞こえます。ですから、圧縮を防ぐために0から0.5のような値で使用してみてください。

en: Amp it up
ja: 音量を上げる

en: To change the amplitude of a sound, you can use the `amp:` opt. For example, to play at half amplitude pass 0.5:
ja: 音の大きさを変えるために、`amp:`オプションを使います。例として、半分の音量で演奏するために、0.5にしてみます。

en: To play at double amplitude pass 2:
ja: 倍の音量で演奏するために、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):
ja: `amp:`オプションは、関連付けられている`play`への命令だけを変更します。ですから、この例では、最初の命令は半分の音量になり、次はデフォルトの値（1）に戻ります。

en: Of course, you can use different `amp:` values for each call to play:
ja: もちろん、それぞれの命令で異なった`amp:`の値を設定して演奏することもできます。

en: Panning
ja: パンニング

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.
ja: もうひとつの面白いオプションは`pan:`です。ステレオで音の位置を制御します。左に音をパンすることは左のスピーカーから音が聞こえることを意味し、右にパンすれば右のスピーカーから聞こえます。値としては、-1は最も左、0は中心、1は最も右、というようにステレオの領域で表現することができます。もちろん、音の正確な位置をコントロールするために、-1から1の間のどの値でも使用することができます。

en: Let's play a beep out of the left speaker:
ja: 左のスピーカーから音を鳴らしてみましょう。

en: Now, let's play it out of the right speaker:
ja: では、右のスピーカーから鳴らします。

en: Finally let's play it back out of the center of both (the default position):
ja: 最後に元の通り、中心から鳴らしてみます（デフォルトの位置です）。

en: Now, go and have fun changing the amplitude and panning of your sounds!
ja: では、続けてあなたの音のアンプやパンを変えて楽しんでみましょう！

en: 2.3 Switching Synths
ja: 2.3 シンセの切り替え

en: Switching Synths
ja: シンセの切り替え

en: So far we've had quite a lot of fun making beeps. However, you're probably starting to get bored of the basic beep noise. Is that all Sonic Pi has to offer? Surely there's more to live coding than just playing beeps? Yes there is, and in this section we'll explore some of the exciting range of sounds that Sonic Pi has to offer.
ja: これまで、ビープ音を鳴らして楽しんできました。けれども、もしかするとあなたはこのベーシックなビープ音に退屈し始めているかも知れません。これがSonic Piが提供してくれるサウンドの全てなのでしょうか？ もちろん、ビープ音だけではなくて、もっと他にもたくさんのライブコーディングがありますよね？ はい、あります。この章ではSonic Piが作り出すワクワクさせる音を試してみましょう。

en: Sonic Pi has a number of different instruments it calls synths (which is *short for synthesisers*). Whereas samples represent pre-recorded sounds, synths are capable of generating new sounds depending on how you control them (which we'll explore later in this tutorial). Sonic Pi's synths are very powerful and expressive and you'll have a lot of fun exploring and playing with them. First, let's learn how to select the current synth to use.
ja: Sonic Piは、シンセサイザーの略であるシンセと呼ばれる楽器の機能を持っています。サンプルがすでに録音された音であるのに対して、シンセはあなたがそれをコントロールすることに応じて新しいサウンドを生み出すことができます（このチュートリアルの後半でみていきます）。Sonic Piのシンセは、パワフルで表現力に富んでいて、試しながら演奏したり、楽しめるはずです。最初に、ひとまずここでシンセを使うために、選び方を学んでみましょう。

en: Buzzy saws and prophets
ja: 賑やかなsawとprophet

en: A fun sound is the *saw wave* - let's give it a try:
ja: 面白い音は、*ノコギリ（saw）波*です。試してみましょう。

en: Let's try another sound - the *prophet*:
ja: 他の音*prophet*を試してみましょう。

en: How about combining two sounds. First one after another:
ja: 2つを一緒にしたらどうでしょう。一方のあとに、もう一方を。

en: Now multiple sounds at the same time (by not sleeping between successive calls to `play`):
ja: （連続する `play`の間にスリープを入れないことで）同時に複数のサウンドが鳴ります：

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`.
ja: `use_synth`コマンドは、下の`play`にだけ影響していることに注意してください。大きなスイッチのようなものだと考えてください。指定したどんなシンセでも、新しい`play`へ命令として演奏されます。`use_synth`で新しいシンセにスイッチすることができます。

en: Discovering Synths
ja: シンセを見つける

en: To see which synths Sonic Pi has for you to play with take a look at the Synths option in the menu at the bottom of this help screen (between Examples & Fx). There are over 20 to choose from. Here are a few of my favourites:
ja: Sonic Piにあるシンセを確認するには、このヘルプ画面の下部にあるメニューのシンセ・オプション確認してください（ExamplesとFxの間）。20種類以上あります。その中から私のお気に入りをいくつか紹介します：

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.
ja: では、*音楽の中でシンセを切り替えて*遊んでみてください。音楽の異なるセクションに違うシンセを使うように、シンセを組み合わせて新しい音を作って楽しんでください。

en: 2.4 Duration with Envelopes
ja: 2.4 エンベロープでのデュレーション

en: Duration with Envelopes
ja: エンベロープでのデュレーション

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.
ja: 前のほうのセクションで、音をいつ再生するか制御するのに、どのように`sleep`コマンドを使用可能か見てきました。しかし、まだ我々は音のデュレーション（長さ）を制御できていないですね。

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:
ja: 音のデュレーションを制御するための、パワフルでシンプルな手段として、Sonic Piには*ADSR amplitude envelope*（ADSR・アンプ・エンベロープ）という概念があります（ADSRが何を意味するかはこのセクションの後半で紹介します）。アンプ・エンベロープは制御のための便利な2つの側面を持っています。

en: control over the duration of a sound
ja: 音のデュレーション（長さ）を制御する

en: control over the amplitude of a sound
ja: 音のアンプ（音量）を制御する

en: Duration
ja: デュレーション

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.
ja: デュレーションは音の持続する長さのことです。長いデュレーションは、より長く音が鳴ることを意味します。Sonic Piの全てのサウンドは、アンプ・エンベロープで制御でき、ひとつのエンベロープ（音量や音色の時間的な変化）の長さは、音の長さでもあります。

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.
ja: ADSRエンベロープは、デュレーションの制御だけでなく、*アンプ（音量）の緻密な制御*も可能にします。全てのサウンドは、サイレント（無音）で始まり、間に音があり、またサイレントで終了します。エンベロープを使用すると、サウンドの音がある部分の音量をスライドさせたり、保持したりすることができます。これは、音楽の音量を上げたり下げたりするのを、誰かに指示するような感じです。例えば、あなたは誰かに「無音で始めて、ゆっくりとフル・ボリュームにして、少しそのままで、そして一気に無音に戻る」と頼むとします。Sonic Piはエンベロープでこれをプログラムできるようにしてくれます。

en: Just to recap, as we have seen before, an amplitude of 0 is silence and an amplitude of 1 is normal volume.
ja: 前のセクションで見てきたように、アンプの`0`は無音、`1`は通常の音量です。

en: Now, let us look at each of the parts of the envelopes in turn.
ja: では、エンベロープのそれぞれの部分を順番に見ていきましょう。

en: Release Phase
ja: リリース・フェーズ（終わるまでの時間）

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):
ja: エンベロープのうちデフォルトで使われている唯一の部分はリリース・フェーズです。通常、全てのシンセのリリース・フェーズ（終わるまでの時間）は1で、これは終了するまでに1拍（デフォルトBPMの60の場合には1秒）のデュレーションを持っているということです。

en: The note will be audible for 1 second. Go ahead and time it :-) This is short hand for the longer more explicit version:
ja: この音は1秒間だけ聞こえます。続いて時間を指定しよう。上の記述は、次の明示的で長い記述を簡略化したものです。

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:
ja: これも全く同じように（1秒間持続する）音が出たと思います。しかし、`release:`のオプションを変更することでとても簡単に持続時間を変更することができるようになりました。

en: We can make the synth sound for a very short amount of time by using a very small release time:
ja: また、非常に小さなリリース・フェーズの値を使って、シンセのサウンドをとても短くすることができます。

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:
ja: 音がリリースされるまでの持続時間はリリース・フェーズと呼ばれていて、デフォルトではリニア・トランジション（直線的な移行、つまり真っ直ぐ）です。以下の図は、この移行を表したものです。

en: The vertical line at the far left of the diagram shows that the sound starts at 0 amplitude, but goes up to full amplitude immediately (this is the attack phase which we'll cover next). Once at full amplitude it then moves in a straight line down to zero taking the amount of time specified by `release:`. *Longer release times produce longer synth fade outs.*
ja: 図の左端の縦の線は、サウンドが`0`の音量（ゼロ・アンプ）からスタートしていることを示しています。しかし、すぐに最大アンプに上がります（これは私たちが後で学ぶ、アタック・フェーズというものです）。いったん最大アンプになり、それから`release:`で指定した値を取りながら、直線的にゼロに下がります。*長いリリース・タイムは長いシンセ・フェード・アウト（徐々に消えること）を生成します。*

en: You can therefore change the duration of your sound by changing the release time. Have a play adding release times to your music.
ja: これにより、リリース・フェーズを変更して、あなたのサウンドのデュレーションを変えることができます。自分の音楽にリリース・タイムを追加して演奏してみましょう。

en: Attack Phase
ja: アタック・フェーズ

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:
ja: 通常、アタック・フェーズは全てのシンセにおいて`0`です。つまり、`0`アンプから`1`にただちに移動することを意味します。シンセは最初から音が打たれます。けれども、あなたは音をフェード・イン（徐々に大きく）したいかも知れません。これは、`attack:`のオプションで実現することができます。いくつかの音をフェード・インしてみましょう。

en: You may use multiple opts at the same time. For example for a short attack and a long release try:
ja: 複数のオプションを使うこともできます。例えば、短いアタック、長いリリースに、変更してみましょう。

en: This short attack and long release envelope is illustrated in the following diagram:
ja: この、短いアタックに長いリリースのエンベロープは、以下の図のように表します。

en: Of course, you may switch things around. Try a long attack and a short release:
ja: もちろん、ほかに変更することもできます。長いアタックに短いリリースを試してみましょう。

en: Finally, you can also have both short attack and release times for shorter sounds.
ja: そして、アタックとリリース両方短くして、短いサウンドにもできます。

en: Sustain Phase
ja: サステイン・フェーズ（持続時間）

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.
ja: アタック・フェーズとリリース・フェーズの設定に付け加えて、サステイン・フェーズ（持続時間）を指定することができます。サステイン・フェーズとは、アタックとリリースの間でフル・アンプの音が鳴り続ける時間のことです。

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.
ja: サステイン・フェーズは、オプションのリリース・フェーズに入る前に、ミックスの中で主となる存在感を与えたい重要なサウンドにとって有効です。もちろん、`attack:`と`release:`両方のオプションを0に設定することもとても有効ですし、サウンドに対して、完全にフェード・インなし、フェード・アウトなしにするためにサステインを使えば良いのです。けれど、注意してください、0のリリースはオーディオの中にクリック音を生成します。たいていの場合、0.2のようなごく小さい値を使う方が良いです。

en: Decay Phase
ja: ディケイ・フェーズ（減衰時間）

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:
ja: そして、今あなたがさらなる制御のレベルを必要としているならば、ディケイ・タイムというものを設定することもできます。これは、アタックとサステインの間にくるエンベロープのフェーズで、音量が`attack_level:`から`decay_level:`（もしこれを明示的に指定しなければ、この値は`sustain_level:`と同じ値に設定されます）に落ちる時間を指定します。通常では、`decay:`のオプションは0で、アタックとサステインのレベルは両方とも1です。ですから、ディケイ・フェーズで効果を得るには、アタック、サステインのレベルも指定しなくてはなりません。

en: Decay Level
ja: ディケイレベル

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:
ja: 最後の仕掛けは、`decay_level:`オプションがデフォルトでは`sustain_level:`と同じ値に設定されていて、エンベロープを完全に制御したい場合に明示的に別な値に設定できることです。これにより次のようなエンベロープを作ることができるでしょう。

en: It's also possible to set the `decay_level:` to be higher than `sustain_level:`:
ja: また`decay_level:`を`sustain_level:`より大きく設定することもできます。

en: ADSR Envelopes
ja: ADSR エンベロープ

en: So to summarise, Sonic Pi's ADSR envelopes have the following phases:
ja: つまり要約すると、Sonic PiのADSRエンベロープには、以下のフェーズがあります。

en: *attack* - time from 0 amplitude to the `attack_level`,
ja: *attack*（アタック）- 音量を0から`attack_level`まで移行させる時間

en: *decay* - time to move amplitude from `attack_level` to `decay_level`,
ja: *decay*（ディケイ）- 音量を`attack_level`から`decay_level`まで移行させる時間

en: *sustain* - time to move the amplitude from `decay_level` to `sustain_level`,
ja: *sustain*（サステイン）- 音量を`decay_level`から`sustain_level`まで移行させる時間

en: *release* - time to move amplitude from `sustain_level` to 0
ja: *release*（リリース）- 音量を`sustain_level`から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:
ja: サウンドのデュレーションは、これらのフェーズの合計であることに注意することが大切です。したがって、以下のサウンドは、0.5 + 1 + 2 + 0.5 = 4 で、4秒のデュレーションになります。

en: Now go and have a play adding envelopes to your sounds...
ja: ではあなたのサウンドにエンベロープを追加して演奏してみましょう。

en: 3 Samples
ja: 3 サンプル

en: Samples
ja: サンプル

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.
ja: あなたの音楽を発展させる方法は他にもあります。すでに録音された音を使うことです。偉大なヒップホップの伝統では、これらのあらかじめ録音された音のことを、*サンプル*と呼びます。つまり、マイクを持って外に出て、雨が優しくキャンバスを打つ音を録音しに行けば、それだけでサンプルを作ることができます。

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...
ja: Sonic Piは、サンプルで楽しいことがたくさんできるようになっています。130以上のパブリック・ドメイン（著作権がない）サンプルが、ジャム（即興演奏）するために同梱されているだけでなく、あなたが持っているサンプルを操作して演奏することも可能です。さっそく見てみましょう…

en: 3.1 Triggering Samples
ja: 3.1 サンプルを使う

en: Triggering Samples
ja: サンプルを使う

en: Playing beeps is only the beginning. Something that's a lot of fun is triggering pre-recorded samples. Try it:
ja: ビープ音を演奏するのは最初だけです。もっと面白いのは、録音済みのサンプルを使うことです。やってみましょう。

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:
ja: Sonic Piは演奏のためにたくさんのサンプルを持っています。`play`コマンドを使うようにサンプルを使えばよいのです。複数のサンプルや音符を演奏するには、それらをひとつひとつ順番に書いていきます。

en: If you want to space them out in time, use the `sleep` command:
ja: もし間を空けたいなら、`sleep`を使います。

en: Discovering Samples
ja: サンプルを探す

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:
ja: あるいは、オート・コンプリーション（自動補完）システムを使うこともできます。`sample :ambi_`のような複数のサンプルを束ねるグループ名をタイプし始めると、同じグループ内から選択できるサンプルの名前がドロップ・ダウンして表れます。以下のサンプル・グループの接頭語を入力してみましょう。

en: Now start mixing samples into your compositions!
ja: さあ、あなたの曲でサンプルのミックスを始めてみましょう！

en: 3.2 Sample Parameters
ja: 3.2 サンプル・パラメータ

en: Sample Parameters: Amp and Pan
ja: サンプル・パラメータ：アンプとパン

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:`.
ja: シンセの項目で見てきたように、パラメータで簡単にサウンドを制御することができます。サンプルは全く同じパラメータの仕組みを備えています。何度も登場する、`amp:`と`pan:`をもう一度見てみましょう。

en: Amping samples
ja: サンプルの音量を変更する

en: You can change the amplitude of samples with exactly the same approach you used for synths:
ja: シンセで使った書き方と全く同じ方法で、サンプルのアンプ（音量）を変えることができます。

en: Panning samples
ja: サンプルをパンする

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:
ja: サンプルで`pan:`のパラメータを使うこともできます。例えば、次のコードは、定番のドラムフレーズのアーメン・ブレイクを左耳で再生し、半分まで来たところで再度右耳で再生する方法です。

en: Note that 0.877 is half the duration of the `:loop_amen` sample in seconds.
ja: 0.877は、`:loop_amen`サンプルの半分の再生時間であることに注意してください。

en: Finally, note that if you set some synth defaults with `use_synth_defaults` (which we will discuss later), these will be ignored by `sample`.
ja: そして、`use_synth_defaults`（あとで説明します）をシンセに設定している場合、サンプルはこれを無視して再生します。

en: 3.3 Stretching Samples
ja: 3.3 サンプルを引き延ばす

en: Stretching Samples
ja: サンプルを引き延ばす

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.
ja: すでに私たちは、音楽を作るために様々なシンセやサンプルを演奏することができます。そろそろ、音楽をもっとユニークで面白くするために、シンセとサンプルを編集する方法を学ぶ時間です。まずは、サンプルを引き延ばしたり圧縮する方法をみてみましょう。

en: Sample Representation
ja: サンプルで表現する

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.
ja: サンプルとは、あらかじめ録音されたサウンドで、サウンドを再生するためにスピーカーのコーン（振動板）をどう動かすかを表す数値が格納されています。スピーカーのコーンは行ったり来たり（振動）するため、数値は、その時々でコーンがどれくらいの距離を行ったり来たりすべきかをその時々で表す必要があります。録音された音を忠実に再生するために、サンプルは概して1秒間に何千もの数値を格納しておく必要があるのです！ Sonic Piはこの数値のリストを使って、適切なスピードでサウンドを再生するための正しい方法をあなたのコンピュータのスピーカーに伝え、振動させるのです。けれども、サウンドを変えるためにスピーカーに与えられる数値のスピードを変えるのも楽しいですよ。

en: Changing Rate
ja: レートを変える

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`:
ja: アンビエント・サウンドのひとつ、`:ambi_choir`で演奏してみましょう。デフォルトのレートで演奏するには、`sample`に`rate:` のオプションを渡します。

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`:
ja: これはデフォルトのレート（1）で演奏するので、まだ何も変わったところはありません。ですが、数値を何か他の値に変えてもよいのです。`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.
ja: ワオ！ 何が起きたのでしょう？ そう、2つのことが起こりました。1つ目は、サンプルは再生に2倍の時間をかけていました。2つ目は、サウンドは1オクターブ低くなっていました。もう少し詳しく、これらのことを探ってみましょう。

en: Let's stretch
ja: 引き延ばしてみる

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:
ja: 引き延ばしたり圧縮したりして楽しいサンプルは、定番のアーメン・ブレイクです。通常のレートでは、*ドラムン・ベース（音楽ジャンルのひとつ）*のトラックを思わせます。

en: However by changing the rate we can switch up genres. Try half speed for *old school hip-hop*:
ja: :loop_amenですが、レート（速度）を変えると、音楽のジャンルが切り替わったように聞こえます。半分のスピードにすると、*オールドスクールのヒップホップ*に。

en: If we speed it up, we enter *jungle* territory:
ja: スピードを上げると、*ジャングル*のジャンルになりますね。

en: Now for our final party trick - let's see what happens if we use a negative rate:
ja: では、パーティーの最後の仕掛けに、マイナスのレートを使うと何が起きるでしょうか。

en: A Simple Explanation of Sample Rate
ja: サンプル・レートの解説

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.
ja: サンプルは、バネのように考えると便利です。再生速度（プレイバック）は、バネを縮めたり伸ばしたりするようなものです。もしサンプルをレート 2 で再生した場合、通常の長さの半分に、*バネを縮める*ことになります。ですので、サンプルは半分の時間で演奏するので、より短くなります。もしサンプルを半分のレートで再生した場合、2倍の長さに*バネを伸ばす*ことになります。そのため、サンプルは再生に2倍の時間をかけるため、より長くなるのです。もっと縮める（レートを上げる）と、短く再生され、さらに伸ばす（レートを下げる）と、さらに長く再生されます。

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*.
ja: バネを縮めることは、その密度（1cmあたりのコイルの数）を増やすことです。これは*高いピッチ（音程）*のサンプルに近づくことになります。バネを伸ばすことは、密度を減らすことで、*低いピッチ（音程）*のサウンドに近づいていきます。

en: The Maths Behind Sample Rate
ja: サンプル・レートの背後にある計算

en: (This section is provided for those that are interested in the details. Please feel free to skip it...)
ja: （このセクションはさらに細かい部分に興味がある人向けです。飛ばしても構いませんよ…）

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:
ja: 上記で見てきたように、サンプルは、スピーカーが一定の時間でどのように振動すべきかを表現した長大な数値のリストによって表されています。この数値のリストで、これと同じようなグラフを描いてみます。

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.
ja: あなたはこれと同じような図を、以前に見たことがあるかも知れません。これはサンプルの*波形*と呼ばれるものです。これは数値のグラフです。このような波形はだいたい、1秒間に44100ポイントのデータを有しています（これはナイキスト・シャノンのサンプリング定理によるものです）。サンプルが2秒間続くなら、スピーカーに1秒間に44100ポイントのレート（長さ）を与えることで88200の数値で表現されます。もちろん、1秒間に88200ポイントで、2倍のレートとすることもできます。ですので、これは1秒間で再生されます。1秒間に22050ポイントで、半分のレートで再生することも可能です。この場合、4秒で再生されます。

en: The duration of the sample is affected by the playback rate:
ja: サンプルのデュレーションは、再生するレートの影響を受けます：

en: Doubling the playback rate halves the playback time,
ja: 2倍の再生レートは、再生時間を半分にする

en: Halving the playback rate doubles the playback time,
ja: 半分の再生レートは、再生時間を2倍にする

en: Using a playback rate of one fourth quadruples the playback time,
ja: 4分の1の再生レートは、再生時間を4倍にする

en: Using a playback rate of 1/10 makes playback last 10 times longer.
ja: 10分の1の再生レートは、10倍長く再生させる

en: We can represent this with the formula:
ja: これを以下の数式で表します。

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.
ja: 再生レートを変えることは、サンプルのピッチ（音程）にも影響します。周波数や波形のピッチがどれくらい速く上下に動くかで決定されます。我々の脳は、どういうわけか、スピーカーの速い動きを高い音階に、遅い動きを低い音階に捉えます。だからあなたは時々、大きなベース・スピーカーが超低音を吐き出すのを見ることができるのです。実際に高い音を出しているときのスピーカーよりも、ゆっくりと振動しているのです。

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.
ja: もし波形を取り出して圧縮したら、1秒間でさらに頻繁に上下します。これがサウンドをより高い音にするのです。上下の運動を2倍にすると、周波数が2倍になるということになります。そのため、*サンプルを2倍のレートで再生すると、聞こえる周波数が2倍になる*ということです。また、*レートを半分にすると、周波数が半分になる*ということでもあります。他のレートはそれに応じて周波数に影響します。

en: 3.4 Enveloped Samples
ja: 3.4 エンベロープ・サンプル

en: Enveloped Samples
ja: エンベロープ・サンプル

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.
ja: ADSRエンベロープを用いて、サンプルのデュレーション（再生時間）とアンプ（音量）を編集することもできます。しかしながら、シンセのADSRエンベロープとは少しだけ異なったように作用します。サンプルに使用するエンベロープは、サンプルのアンプとデュレーションを減らすことしかできません。決して増やすことはできないのです。サンプルは、それが再生され終わったときか、エンベロープが完了したときのいずれかで停止します。どちらが先でも停止します。非常に長い`release:`を使ったとしても、サンプルのデュレーションは延長されません。

en: Amen Envelopes
ja: アーメン・エンベロープ

en: Let's return to our trusty friend the Amen Break:
ja: では、我々にはすっかりお馴染みのフレーズ、アーメン・ブレイクに戻りましょう：

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:
ja: オプションが設定されていない場合、全サンプルがフル・アンプ（最大音量）で聞こえます。もし1秒間のフェード・インを使いたい場合、`attack:`パラメータを使います（フェード・インとは徐々に音が大きくなることです）。

en: For a shorter fade in, choose a shorter attack value:
ja: もっと短いフェード・インの場合は、`attack:`の値を小さくします。

en: Auto Sustain
ja: オート・サステイン

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.
ja: ADSR エンベロープの特徴が標準的なシンセ・エンベロープと異なる点は、*サステイン（持続時間）*の値です。標準的なシンセのエンベロープでは、もし手動で変更しなければ、0に設定されています。ですが、サンプルでは、サステインの値は通常、*魔法のように全自動*にセットされます。サステインの時間は、サンプルの残りを演奏するように調整されます。デフォルトの値を渡さないときに、サンプルがフルで流れるのはこのためです。アタック、ディケイ、サステイン、リリース（この4つの頭文字がADSR）の値が全て0のときは、何の音も聞こえません。Sonic Piはサンプルの長さがどれくらいなのか計算し、アタック、ディケイ、リリース・タイムを差し引いて、あなたのサステイン・タイムの結果を使用します。もし、アタック、ディケイ、リリースの値がサンプルのデュレーションより長く追加された場合、サステインは0にセットされます。

en: Fade Outs
ja: フェード・アウト

en: To explore this, let's consider our Amen break in more detail. If we ask Sonic Pi how long the sample is:
ja: これまでのことを探索するために、アーメン・ブレイクをさらに詳細に見てみましょう。アーメン・ブレイクのサンプルがどれくらいの長さなのか、Sonic Piに尋ねてみてはどうでしょう：

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:
ja: 1秒間のサンプルの長さは`1.753310657596372`と答えるでしょう。ここでは、便宜的に`1.75`としますリリース・タイムを`0.75`にすると、驚くべきことが起こります。

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.
ja: サンプルの最初の1秒をフル・アンプで再生し、最後の0.75秒はフェード・アウトします。これが*オート・サステイン*の動きです。標準では、`release:`はいつもサンプルの最後から動作します。もしサンプルの長さが10.75秒なら、最初の10秒はフル・アンプで再生し、最後の0.75秒はフェード・アウトします。

en: Remember: by default, `release:` fades out at the end of a sample.
ja: 通常、`release:`はサンプルの最後でフェード・アウトするということを覚えておいてください。

en: Fade In and Out
ja: フェード・インとフェード・アウト

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:
ja: サンプルのデュレーションの間にフェード・アウトとインを行うには`attack:`と`release:`の両方を使うことができます。オート・サステインの仕組みと一緒に、使用できます。

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.
ja: サンプルのアーメン・ブレイク全体のデュレーションは1.75秒なので、アタックとリリースの時間が1.5秒まで追加されると、サステインは自動的に0.25秒にセットされます。これで簡単にサンプルをフェード・イン、アウトすることができます。

en: Explicit sustain
ja: サステインの明示的な指定

en: We can easily get back to our normal synth ADSR behaviour by manually setting `sustain:` to a value such as 0:
ja: 手動で`sustain:`を0などにセットして、通常のADSRシンセの挙動に簡単に戻すこともできます。

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.
ja: いま、サンプルはトータルで0.75秒間だけ再生されました。`attack:`と`decay:`のデフォルト値が0ですので、サンプルはフル・アンプ（最大音量）に直接変わり、0秒間サステイン（持続）し、リリースの0.75秒間で0アンプに戻ります。

en: Percussive cymbals
ja: 打楽器のシンバル

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`:
ja: この仕様を、長いサウンドのサンプルを短く、より打楽器的にするために、効果的に使うことができます。`: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:
ja: 上のサンプルでは一定時間シンバルの音が鳴っているのが聞こえます。ですが、もっとパーカッシブ（打楽器的）にしてみましょう。

en: You can then emulate hitting the cymbal and then dampening it by increasing the sustain period:
ja: サステイン（持続時間）を増やすことで、シンバルを叩いた後の減衰の効果も出すことができます：

en: Now go and have fun putting envelopes over the samples. Try changing the rate too for really interesting results.
ja: 今すぐ、サンプルを楽しくさせるエンベロープをいじってみましょう。面白い結果を得るために数値を思いきり変更してみましょう。

en: 3.5 Partial Samples
ja: 3.5 部分的なサンプル

en: Partial Samples
ja: 部分的なサンプル

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:
ja: このセクションでは、Sonic Piのサンプルの再生について私たちが探求してきたことをまとめます。簡単にまとめてみましょう。これまで、サンプルを再生する方法をみてきました。

en: We then looked at how we can change the rate of samples such as playing them at half speed:
ja: まず、サンプルのレート（速さ）を変更する方法を見つけて、このように半分の速度で再生してみました。

en: Next, we looked at how we could fade a sample in (let's do it at half speed):
ja: 次に、サンプルを徐々に大きくするフェードインを知りました（半分の速度でやってみましょう）。

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:
ja: また、`sustain:`に明確な値とアタックとリリースの両方の短い値を設定することで、サンプルを打楽器のように使用する方法を見つけました。

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?
ja: では、いつもサンプルの先頭から開始する必要はあるのでしょうか？ そして、いつもサンプルの最後まで終了する必要はあるのでしょうか？

en: Choosing a starting point
ja: 開始点の選択

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:
ja: サンプルのどこからでも、好きな場所を選んで音を再生することが可能です。0はサンプルの開始で、1は終了です。0.5はサンプルの途中です。アーメン・ブレイクの最後の半分を再生してみましょう。

en: How about the last quarter of the sample:
ja: どのようにすればサンプルの最後の1/4を再生できますか？

en: Choosing a finish point
ja: 終了点を選択する

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:
ja: 同様に、サンプルの0から1の間の値を終了点として選ぶことができます。アーメン・ブレイクの半分までで終わらせてみましょう。

en: Specifying start and finish
ja: 開始と終了の指定

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:
ja: もちろん、私たちは好きな部分を再生するために、これまでの開始と終了の2つを組み合わせることができます。どのようにすれば真ん中あたりの短い場所だけを選べるのでしょうか？

en: What happens if we choose a start position after the finish position?
ja: もし、終了位置のあとを、開始位置として選ぶとどうなるでしょう？

en: Cool! It plays it backwards!
ja: かっこいい！ 逆再生になりますね！

en: Combining with rate
ja: レートと組み合わせ

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:
ja: ここで紹介した部分再生の機能を、すでに学んだ`rate:`を組み合わせることができます。例えば、アーメン・ブレイクの真ん中のとても小さな部分をとてもゆっくりと再生することができます：

en: Combining with envelopes
ja: エンベロープとの組み合わせ

en: Finally, we can combine all of this with our ADSR envelopes to produce interesting results:
ja: そして、面白い結果を創りだすために、ADSRエンベロープと、いままでの全てを組み合わせることができます。

en: Now go and have a play mashing up samples with all of this fun stuff...
ja: 今すぐ、サンプルとこれまでに紹介した楽しい内容を組み合わせて演奏してみましょう！

en: 3.6 External Samples
ja: 3.6 外部サンプル

en: External Samples
ja: 外部サンプル

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.
ja: 内蔵のサンプルは、すぐに使用でき、再生することができる一方で、あなたは自分で録音した音を試してみたいと思うかもしれません。Sonic Piはこれに完全に対応しています。最初に、あなたの録音した音の携帯性について少し議論してみましょう。

en: Portability
ja: 携帯性

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.
ja: あなたが内蔵のシンセやサンプルだけを使って作曲した場合、音楽を忠実に再現するために必要なものは、コードだけになります。でもちょっと考えてみてください。それは、実はとても凄いことなのですよね！ あなたの音楽を忠実に再現する作品は、テキストによるシンプルなものなので、電子メールで周りに送ったり、[Gist](https://gist.github.com)に埋め込んで公開することができます。コードを持っていれば友人と本当に簡単に共有することができます。

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.
ja: しかし、もしあなたが、自身で記録したサンプルを使ってしまうと、この携帯性が失われてしまいます。なぜならば、あなたの音楽を他の人達が再現しようとしても、あなたのコードだけでは再生することができず、記録したサンプルが必要になってしまうからです。この事は、あなたの音楽を他の人が操作したり編集したり、試してみることを制限してしまうことがあるということです。もちろん、あなた自身が録音したサンプルを使うことを止めるということではなく、方法（データを送って、正しく共有するなど）に配慮していけばよいという事です。

en: Local Samples
ja: 自分で録音した（ローカルな）サンプル

en: Sonic Pi will automatically load and play the sample. You can also pass all the standard params you're used to passing `sample`:
ja: Sonic Piは自動的にサンプルを読み込んで再生します。あなたは、`sample`に今まで使ってきた全てのパラメータを、あなたが録音した音に使うことができます。

en: 3.7 Sample Packs
ja: 3.7 サンプルパック

en: Sample Packs
ja: サンプルパック

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.**
ja: **注: このセクションは外部サンプルのある巨大なディレクトリを扱う際の高度なトピックを扱っています。あなたがサンプルパックをダウンロードしたり購入したりして、それをSonic Piから使いたい場合が当てはまるでしょう。**

en: **Feel free to skip this if you're happy working with the built-in samples.**
ja: **内蔵サンプルで問題なければ、このセクションは飛ばしても構いませんよ。**

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.
ja: 外部サンプルのある大きなフォルダを扱う際に、個々のサンプルを再生する度にパス全体をタイプするのは、面倒かもしれません。

en: For example, say you have the following folder on your machine:
ja: 例えば、次のようなフォルダがあなたのマシンにあるとします。

en: When we look inside that folder we find the following samples:
ja: そしてそのフォルダの中の次のようなサンプルがあるとします。

en: Typically in order to play the piano sample we can use the full path:
ja: 例えばピアノのサンプルを再生したい場合、次のようなフルパスでの指定が可能です。

en: If we want to then play the guitar sample we can use its full path too:
ja: 次にギターのサンプルを再生したい場合、また同じようにフルパスでの指定が可能です。

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?
ja: しかしながら、これらのどちらのサンプルの呼び出しでも、ディレクトリ内のファイル名を知っている必要があります。もしサンプルを順番に聴いて行きたい場合どうしたら良いでしょう？

en: Indexing Sample Packs
ja: サンプルパックのインデックス

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:
ja: もしディレクトリの1番目のサンプルを再生したい場合、必要なことは次のように`sample`にディレクトリ名と'0'のインデックスを渡すだけです。

en: We can even make a shortcut to our directory path using a variable:
ja: さらにディレクトリ名は変数を使ってショートカットを作ることも可能です。

en: Now, if we want to play the second sample in our directory, we just need to add 1 to our index:
ja: 次に、ディレクトリの2番目のサンプルを再生したい場合、先ほどのインデックスに1を追加すれば出来ます。

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.
ja: もはやディレクトリ内のサンプルの名前を知る必要がないことに注意してください。必要なのはディレクトリそのもの（もしくはそのショートカット）を知っていることです。もしディレクトリ内のサンプルの数より大きい値をインデックスに指定した場合、リングのように単純に先頭に戻ります。したがって、どのような数字もディレクトリ内のどれかのサンプルを取得することが保証されているのです。

en: Filtering Sample Packs
ja: サンプルパックのフィルタ

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:
ja: インデックスは機能的には十分かもしれませんが、サンプルを分類するもっと強力な方法が必要になるかもしれません。幸いにして、いくつかのサンプルパックではファイル名に意味のある情報を付加してくれています。ディレクトリ内のファイル名を別な観点から見てみましょう。

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.
ja: これらのファイル名はかなりの情報を持っていることに注目してください。最初にサンプルのBPM（beats per minute）があります。ピアノのサンプルはBPMが120で最初の3つのメロディーはBPMが100であることが分かると思います。また、サンプルのファイル名はキーを含んでいます。ギターのサンプルはキーがBbでメロディーのキーはA#です。この情報は我々の他のコードと組み合わせるのにとても役立ちます。例えば、ピアノのサンプルをBPM120でBbのキーのソースコードとしか使えないことが分かると思います。

en: It turns out that we can use this particular naming convention of our sample sets in the code to help us filter out the ones we want. For example, if we're working at 120 BPM, we can filter down to all the samples that contain the string `"120"` with the following:
ja: サンプルの特定の命名規則を使って、我々が必要とするファイルをフィルタできることが分かりました。例えば、BPM120で演奏している場合に、`"120"`という文字列を含む全てのサンプルを次のようにフィルタできます。

en: This will play us the first match. If we want the second match we just need to use the index:
ja: これは最初にマッチしたものを再生します。もし2番目にマッチしたものを再生したい場合には、インデックスを使用します。

en: Finally, we're still free to add our usual opts to the call to `sample`:
ja: 最後に、フィルタを使用した場合にも`sample`で通常使用されるオプションをそのまま自由に追加できます。

en: Sources
ja: ソース

en: For example, take a look at the following code:
ja: 例として、次のコードを見てください。

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).
ja: ここでは、2つのディレクトリの内容と1つの特定のサンプルを組み合わせています。もし`"/path/to/my/samples/"`に3つのサンプルがあり、`"/path/to/my/samples2/"`に12個のサンプルがあるとすると、インデックスやフィルタ可能となるサンプルは16(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:
ja: デフォルトでは、ディレクトリ内のサンプルファイルのみが候補リストに集められますが、ときにはネストした数多くのフォルダ内のサンプルを検索したりフィルタしたりしたいことがあるかもしれません。その場合には、次のように`**`をパスの最後に付けることで、全てのサブディレクトリ内のサンプルを再帰的に検索することができます。

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.
ja: とても大きなフォルダのセットを検索するのは、長い時間が掛かるかもしれないことに気をつけてください。しかし、フォルダーのソースの内容は全てキャッシュされるので、この遅延は一度目しか発生しません。

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.
ja: 最後に、ソースの指定は「必ず先頭に」付けるようにしてください。もし何もソースが指定されない場合、内蔵サンプルのセットが候補リストして選択されます。

en: Filters
ja: フィルタ

en: Once you have a list of candidates you may use the following filtering types to further reduce the selection:
ja: 候補リストを取得した後、選択肢を減らすために次のようなフィルタのタイプを使うことができます。

en: `"foo"` Strings will filter on substring occurrence within file name (minus directory path and extension).
ja: `"foo"`という文字列は、（ディレクトリパスと拡張子を除いた）ファイル名の部分一致を抽出します。

en: `/fo[oO]/` Regular Expressions will filter on pattern matching of file name (minus directory path and extension).
ja: `/fo[oO]/`という正規表現は、（ディレクトリパスと拡張子を除いた）ファイル名のパターンマッチを抽出します。

en: `:foo` - Keywords will filter candidates on whether the keyword is a direct match of the filename (minus directory path and extension).
ja: `:foo`というキーワードは、（ディレクトリパスと拡張子を除いた）ファイル名の完全一致を抽出します。

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).
ja: `lambda{|a| ... }`という1つの引数を伴ったProc（手続きオブジェクト）は、候補リストのフィルタまたは生成する関数として扱われます。この関数は、現在の候補リストが引数として渡され、新しい候補リスト（サンプルの有効なパスのリスト）を返却する必要があります。

en: `1` - Numbers will select the candidate with that index (wrapping round like a ring if necessary).
ja: `1`のような数値は、インデックス（必要があればリングのように先頭に戻る）で、候補から選択します。

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:
ja: 例として、あるディレクトリから`"foo"`の文字列を含むサンプルを抽出し、そのうちの最初のものを半分のレートで再生するには、次のように書きます。

en: See the help for `sample` for many detailed usage examples. Note that the ordering of the filters is honoured.
ja: 詳細な使用例は`sample`のヘルプを参照してください。また、フィルタの順序が尊重されることに注意してください。

en: Composites
ja: 複合

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:
ja: 最後に、ソースまたはフィルタを配置することが可能な位置であればどこでもリストを使用することができます。リストは自動的に平坦化され、正規のソースとフィルタとして扱われます。したがって、次に示す`sample`の呼び出しは意味的には全て同じものになります。

en: Wrapping Up
ja: まとめ

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.
ja: このセクションでは、サンプルパックを操作・使用する強力な方法を必要とする人のための高度な内容を紹介しました。このセクションの大部分があまり意味があるように思えなかったとしても心配しないでください。それは、これらの機能のどれもまだあなたが必要としていないというだけだと思います。しかし、サンプルの巨大なディレクトリを扱うことになり、これらの機能が必要なことが分かったときに、またこのセクションに戻って読み直すことができるでしょう。

en: 4 Randomisation
ja: 4 ランダム化

en: Randomisation
ja: ランダム化

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.
ja: 音楽にすこし面白さを加えるために、ランダムという素晴らしい方法があります。Sonic Piは音楽にランダム性を追加するためにいくつかの素晴らしい機能を持っていますが、Sonic Piのランダムは、真のランダムではありません。これは一体何を意味しているのでしょう？ 勉強を開始する前に、この衝撃的な真実を見ていきましょう。

en: Repeatability
ja: 再現性

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:
ja: たいへん便利なランダム関数に、2つの数字の間（最小値と最大値）で乱数（ランダムな値）が得られる`rrand`があります（rrandはレンジド・ランダムの略です）。ランダムな音階を演奏してみましょう。

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!
ja: おぉー、ランダムな音符を演奏しましたね。これは、`83.7527`の音符を演奏しました。50と95との間のランダムな音符でしたね。でも、ちょっと待ってください、上記で、私はあなたが再生したランダムな音符を正確に予測していませんか？ 何か怪しくないですか？ 再度コードを実行してみてください。ランダムのはずが、再び`83.7527`が選ばれましたよね？ 実は、ランダムにすることができないのです！

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.
ja: 答えは、それが真のランダムではなく、擬似ランダムであるということです。Sonic Piは、再現可能なランダム風の数を用意しています。これは、あなたのマシンで作成した音楽が、たとえその中でいくつかランダム性を使用している場合でも、誰か他の人のマシンで同じように聞こえることを保証するのに大変便利な機能です。

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:
ja: もちろん、ある音楽作品において、もし`83.7527`が「ランダムに」毎回選択された場合、それは非常に面白くありません。しかし、そうにはなっていません。以下のことを試してみてください。

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!
ja: そう！ 最終的には、ランダムに聞こえますね。ランダム関数へ続いて呼び出されるその後の実行結果はランダムな値を返します。ただし、また再生する場合は正確に乱数値の同じシーケンスを生成し、まったく同じ音が鳴ります。Runボタンが押されるたびに、まるですべてのSonic Piコードが毎回、同じ時間に戻るかように蘇ります。それはまさに映画「恋はデジャ・ブ」のようにシンセの音が繰り返されるのです！

en: Haunted Bells
ja: ホーンテッド・ベル

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:
ja: ランダム動作を取り入れたゾクッとするようなベルの音を使った楽しい作例です。繰り返しサンプルのベル音:perc_bellをループさせ、ベル音の再生速度と音の間のsleepにランダムな数値を用いています。

en: Random cutoff
ja: ランダムなカットオフ

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:
ja: ランダム化のもう1つの楽しみ方の例は、ランダムにシンセのカットオフを加えることです。これを試してみるのに絶好のシンセは、:tb303 エミュレータです。

en: Random seeds
ja: ランダムシード

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!
ja: もし、Sonic Piが提供する乱数の特定の配列が気に入らない場合、`use_random_seed`を介すことで別の開始点を選択することが可能です。シードのデフォルト値は0であるため、異なる乱数を試すために別のシードの値を入力してみましょう！

en: Consider the following:
ja: 下記を考えてみてください：

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:
ja: このコードを実行するたびに、5音階の同じシーケンスが聞けるでしょう。異なるシーケンスを聞くには、シードの値を変更します。

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.
ja: こうして異なる5音階のシーケンスを生成します。シードの値を変更することによって、あなたの好きなフレーズを見つけることができます。他の人と共有するとき、あなたが聞いたものとまったく同様のフレーズを彼らも聞くことができるでしょう。

en: Let's have a look at some other useful random functions.
ja: 有用なランダム関数をもう少し見ていきましょう。

en: choose
ja: choose：選択

en: A very common thing to do is to choose an item randomly from a list of known items. For example, I may want to play one note from the following: 60, 65 or 72. I can achieve this with `choose` which lets me choose an item from a list. First, I need to put my numbers in a list which is done by wrapping them in square brackets and separating them with commas: `[60, 65, 72]`. Next I just need to pass them to `choose`:
ja: あらかじめ用意した数値をリストの中からランダムに選択することは、一般的に行われていることでしょう。例えば、60、65または72の中から1音を演奏することができます。`choose`を用いれば、リストから1つの項目をで選択することができます。まず、カンマで区切った番号のリストを角括弧でラップ（包んで）し、配置する必要があります：`[60, 65, 72]`。次にそれらを`choose`に渡す必要があります。

en: Let's hear what that sounds like:
ja: どんな音になるか聞いてみましょう。

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)`:
ja: すでに`rrand`について触れてきましたが、再び実行してみましょう。これは、2つの値の間の乱数（排他的）を返します。この意味するところは上部または下部の番号いずれの値も含まれません。常に両者の間にある値です。そして、その番号は常に浮動小数点になります - それは整数ではなく、分数です。`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:
ja: 時々、あなたは小数点ではなく、整数の乱数を望むこともあるでしょう。これは`rrand_i`を用いることで解決できます。それは小数点を除いて`rrand`と同様に最小値および最大値の範囲（この場合、最長値と最大値も含まれます）に潜在するランダム値を返す動作をします。下記は、`rrand_i(20, 110)`によって返される数値の例です。

en: This will return a random float between 0 (inclusive) and the max value you specify (exclusive). By default it will return a value between 0 and one. It's therefore useful for choosing random `amp:` values:
ja: `rand`は、`0`を含む最小値と、引数として指定した最大値未満の間のランダムな浮動小数点数を返します。デフォルトでは`0`と`1`の間の値を返します。このため、`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.
ja: `rrand_i`と`rrand`の関係と同様に、`rand_i`は`0`と引数として指定した最大値の間の整数値を返します。

en: dice
ja: dice:サイコロ

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!
ja: ランダムな数字を出す際に、サイコロ投げをまねてみたくなることもあるでしょう。これは、常に下の値が1である`rrand_i`の特殊なケースです。`dice`を呼び出す時は、サイコロの面の数を指定する必要があります。標準的なサイコロは6面で、`dice(6)`では、1, 2, 3, 4, 5または6を返すサイコロと同様の作用をします。しかし、空想のボードゲームのように、4面、12面または20面サイコロ、さらには120面のサイコロで値を見つけたいこともあるでしょう。

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.
ja: 最後に、一般的なサイコロを振って、例えば6を出すということをやってみたくなることもあるでしょう。`one_in`はサイコロの面の数分の1の確率でtrueを返します。したがって`one_in(6)`では6分1の確率でtrue、それ以外の場合はfalseを返します。`true`と`false`の値は、このチュートリアルの次のセクションで説明するif文で非常に有用です。

en: Now, go and jumble up your code with some randomness!
ja: さあ、ランダム性を使いこなしてコードをまぜこぜにしていきましょう！

en: 5 Programming Structures
ja: 5 プログラミングの構造

en: Programming Structures
ja: プログラミングの構造

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...
ja: これまでの章で、みなさんは`play`や`sample`コマンドを使ったり、`sleep`を使ってシンプルなメロディーやリズムを作曲することを通して音楽制作（サウンドプログラミング）の基礎を学ぶことができました。Sonic Piのコードの世界で他にどんなことができるか興味が出てきたことでしょう…

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.
ja: それでは、プログラミングの基礎となるループや条件文、ファンクション（関数）やスレッドなどに進みましょう。それらが、音楽的なアイデアを実現するための驚くほど強力なツールになることでしょう。

en: Let's get stuck in with the basics...
ja: それでは、やってみましょう。

en: 5.1 Blocks
ja: 5.1 ブロック

en: Blocks
ja: ブロック

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:
ja: Sonic Piでよく見る構造はブロック（`block`）といいます。ブロックは沢山のコードをひとかたまりとして、便利に扱うことができます。たとえば`synth`や`sample`では、その後ろのパラメータによって音を変えることができました。しかし、場合によってはコード数行に同じ変更内容を反映させたい時などが出てきます。たとえばループする時に、5回のうち1回だけリバーブを加えたい場合を考えてみます。

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:
ja: コードのまとまりを使って何かをしようとするときに、コードのブロックの始まりと終わりをSonic Piに伝える必要があります。その際に`do`を*始まり*に、`end`を*終わり*として使用します。

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.
ja: しかし、これではまだ完璧ではないので、実行されません（動かしてみてもエラーメッセージが出るだけです）。実行したい*始まり*と*終わり*のブロックをSonic Piへ伝達が完了していないからです。`do`の前に特別なコードをすこし書くことによってこのブロックをSonic Piに教えることができます。このチュートリアルの後半でこれらの特別なコードを使ったいくつかの事例を紹介していきます。ひとまず、みなさんが特別なコードを使ってSonic Piを動かしたい場合、`do`と`end`でコードをまとめることが重要であることを覚えておいてください。

en: 5.2 Iteration and Loops
ja: 5.2 イテレーション（反復）とループ

en: Iteration and Loops
ja: イテレーション（反復）とループ

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`.
ja: 以前に我々は、`play`と`sample`のブロックで、様々な音を作り出せることを見てきました。また、`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.
ja: これらの基本的なブロックを使用することで*多く*の楽しさがあることを理解してもらえたのではないでしょうか。しかし、音楽を作るための強力なコードを学べば、その楽しさの次元はまた新しい段階に向かうでしょう。次のいくつかのセクションではパワフルな新しいツールを探っていきます。はじめに「イテレーション（反復）とループ」を学びます。

en: Repetition
ja: リピート

en: Have you written some code you'd like to repeat a few times? For example, you might have something like this:
ja: 何回か繰り返しを行うためにはどのようにコードを書いたらよいでしょう？ 例えばこのようなコードです。

en: What if we wished to repeat this 3 times? Well, we could do something simple and just copy and paste it three times:
ja: これを3回繰り返したい場合、どうしたら良いでしょう？ 単純に考えればコピーして貼り付けを3回繰り返せば可能です。

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.
ja: ちょっと長過ぎますよね。もしサンプルを`:elec_plip`に変更させたい場合、どうしたら良いでしょうか？ 3か所全部の`:elec_blup` をひとつひとつ変えなくてはいけません。さらに重要なことですが、繰り返しが50回とか1000回になったとしたらどうでしょう？ 変更したいコードがすごくたくさんになってしまいます。

en: Iteration
ja: イテレーション（反復）

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:
ja: コードの繰り返しは、*これを3回やって*と言うくらい簡単に出来るべきだし、実際のところ簡単に出来ます。先ほど学んだコードブロックを思い出してください。3回繰り返したいコードのブロックには「始まり」と「終わり」が記されていますね。そんな時にこの特別なコードである`3.times`を使いましょう。同じコードを*3回繰り返す*代わりに、`3.times`を書くことで、とても簡単に出来るようになります。その時にコードの最終行に`end`を書き入れることも忘れないようにしましょう。

en: Now isn't that much neater than cutting and pasting! We can use this to create lots of nice repeating structures:
ja: コピーと貼り付けを繰り返すより、ずっと美しいコードになったと思いませんか？このようにブロックを使うと、沢山の繰り返しの構造を作ることが出来るのです。

en: Nesting Iterations
ja: イテレーション（反復）のネスティング（入れ子）

en: We can put iterations inside other iterations to create interesting patterns. For example:
ja: 繰り返しの中にさらに繰り返しを入れることによって面白いパターンを作ることが出来ます。例えば

en: Looping
ja: ループ（終わりのない繰り返し）

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:
ja: もしすごくたくさんの繰り返しをしたい場合、`1000.times do`のようにすごく大きな数値の繰り返しをさせることになってしまいます。こういった場合は、おそらく（stopボタンを押すまで）無限に繰り返す機能がほしいと思うでしょう。さあ、アーメン・ブレイクのサンプルを無限にループさせてみましょう。

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:
ja: loopについて知っておかなくてはならない重要な点は、これはコードの中でブラックホールのように動いてしまう点です。一度loop機能が動いてしまうと、`stop`ボタンを押さない限り永遠に再生されるということです。つまり、これはloopより後ろにあるコードを*絶対に*聞くことが出来ないということを意味しています。例えば、下の例で言うと、シンバルの音はloopより後ろにあるため、決して再生されることはありません。

en: Now, get structuring your code with iteration and loops!
ja: さあ、これで回数を指定するイテレーション（反復）と永遠に繰り返すループのコーディング方法を理解することができましたね!

en: 5.3 Conditionals
ja: 5.3 条件文

en: Conditionals
ja: 条件文

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.
ja: ランダムな音符を再生する（前章参照）だけでなく、あるコードとそれとは別なコードの実行をランダムに決めたくなるかもしれません。例えば、ドラムとシンバルをランダムに再生したいような場合です。このような場合、`if`文を使うことで実現できます。

en: Flipping a Coin
ja: コイントス

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:
ja: それではコインをトス（投げる）してみましょう。もしもコインが表であればドラムを鳴らし、裏であればシンバルを鳴らします。簡単ですね。コイントスの機能は`one_in` という機能（ランダムのセクションで紹介しています）によって実現されます。2つのうちの1つというように条件を細かく指定するときには`one_in(2)`と記述すると、ドラムを鳴らすコードとシンバルを鳴らす2つのコードどちらかを決められるようになります。

en: Notice that `if` statements have three parts:
ja: if文は3つのパートを持っていることに注目してみましょう。

en: The question to ask
ja: 条件

en: The first choice of code to run (if the answer to the question is yes)
ja: はじめの選択によって実行されるコード（条件が正しかった場合）

en: The second choice of code to run (if the answer to the question is no)
ja: 次の選択によって実行されるコード（条件が間違っていた場合）

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.
ja: 典型的なプログラム言語では、概ね、真（正しいという意味）を`true`で表現し、偽（正しくない場合）は`false`と表記します。そのため、先の例で`one_in`が行っているような、`true`か`false`か答えることができる質問が必要となります。

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:
ja: はじめの選択では `if` と`else`の間に挟まれたプログラムが実行され、そして2番目の選択では`else`と`end`の間が実行されるということに注目しましょう。それは複数行のコードをまとめる*do/end*ブロックにとても似ていますね。例えば、

en: This time we're sleeping for a different amount of time depending on which choice we make.
ja: `sleep 0.5`や`sleep 0.25`など、異なる休符時間を持つ場合、そのどちらかに応じることになります。

en: Simple if
ja: シンプルなif（if修飾子）

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:
ja: 時には、任意のコードを1行だけ実行したいときがあるでしょう。これは`if`と条件を後ろに記述することで可能です。例えば、

en: This will play chords of different numbers with the chance of each note playing having a different probability.
ja: 上のコードでは、それぞれの音符が持つ別の確率によって、異なる数のコード（和音）を奏でるでしょう。

en: 5.4 Threads
ja: 5.4 スレッド

en: Threads
ja: スレッド

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.
ja: それでは、強烈なベースラインとかっこいいビートを作った場合、どのようにしてそれらを同時に鳴らしたらいいでしょう？ 1つの回答としては、手動でそれらを同時に鳴らす事です ― まず、いくつかのベースを演奏し、その後にいくつかのドラム、またその後にベースというように…しかしながら、すぐに沢山の楽器を処理することが難しいことに気づくでしょう。

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*.
ja: もし、Sonic Piが自動的にそれらを作り出せるとしたらどうでしょう？ *thread*（スレッド）と呼ばれる特別な命令によってそれが可能になります。

en: Infinite Loops
ja: 無限の繰り返し

en: To keep this example simple, you'll have to imagine that this is a phat beat and a killer bassline:
ja: 例を単純にするために、以下のコードを強烈なベースラインとかっこいいビートだと思ってください。

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.
ja: ループはプログラムの*ブラックホール*のようだと以前にお話しました。一度ループを入れると、stopボタンを押さない限り、そこから抜け出せなくなります。では、どうしたら同時にふたつの繰り返しを演奏することが出来るでしょう？私たちは、同時にそれらのコードをタイミングを合わせスタートさせるようにSonic Piに伝えなくてはいけません。これがスレッドを使った解決方法なのです。

en: Threads to the Rescue
ja: スレッドを使った解決方法

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!
ja: はじめの*do/end*ブロックを`in_thread`で囲むことで、次にくる*do/end*ブロックを*ぴったりと*同時にループさせるようにSonic Piに命令することができます。それではドラムとベースラインを同時に鳴らすことに挑戦してみましょう！

en: Now, what if we wanted to add a synth on top. Something like:
ja: そして、もう1つの音を追加したいので、先ほどのように繰り返しを入れてみましょう。

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:
ja: 前と同じ問題が出てきましたね。`in_thread`によって最初の繰り返しと2つ目の繰り返しが同時に演奏されています。しかし3番目の繰り返しが演奏されません。ですので以下のように、もう1つのスレッドが必要となります。

en: Runs as threads
ja: スレッドとして実行する

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.
ja: 驚くべきことに`Run`ボタンを押すということは、実際にはコードを実行するための新しいスレッドを作っていることになります。そのために複数回`Run`ボタンを押すことは、互いの上に音を階層化することになります。`Run`それ自体がスレッドであるために、音を自動的に紡ぎ合わせることになるのです。

en: Scope
ja: スコープ

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:
ja: Sonic Piをマスターしようとするとき、スレッドが、音楽のために最も重要な構成要素であることに気がつくでしょう。スレッドの重要な役割の1つとして、他のスレッドから*現在の設定*を分離することがあります。どういうことかというと、例えば`use_synth`を使ってシンセの種類を変更する時、*現在のスレッド*中にあるシンセだけを変更します。他のどのスレッドも変更しません。そのことを確認してみましょう。

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.
ja: 真ん中の音だけがほかのものと違うことに注目してみましょう。`use_synth`の宣言はスレッドの中だけに影響し、スレッドの外にあるものには影響しません。

en: Inheritance
ja: インヘリタンス（継承機能）

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:
ja: `in_thread`を使って新しいスレッドを作ると、新しいスレッドには現在のスレッドの全ての設定が自動的に継承されます。ではその機能を見てみましょう。

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.
ja: 2番目の音符は、それが別のスレッドから再生されたにもかかわらず`:tb303`シンセで演奏されることに注目してください。`use_*`関数を使ったいかなる設定も同様に作用するでしょう。

en: When threads are created, they inherit all the settings from their parent but they don't share any changes back.
ja: スレッドが新規に作成されると、元のスレッドからすべての設定を継承しますが、スレッド作成以降の変更を共有することはありません。

en: Naming Threads
ja: スレッドの命名

en: Finally, we can give our threads names:
ja: 最後に、スレッドに名前つける機能を覚えましょう。

en: Look at the log pane when you run this code. See how the log reports the name of the thread with the message?
ja: このコードを実行した際、ログ画面を見てみましょう。ログの中にスレッドの名前が表示されることを確認できましたか？

en: Only One Thread per Name Allowed
ja: 1つの名前につき1つのスレッド

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:
ja: 名前付きのスレッドについて知っておくべき最後のひとつは、ある名前の付いたスレッドは同時に1つだけ実行されることです。では以下を見てみましょう。次のコードを考えてみてください。

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.
ja: Bufferに上のコードを貼り付けて、`Run`ボタンを押します。数回押してみましょう。複数のアーメン・ブレイクが不協和音として反復されるでしょう。もういいですよね。`Stop`ボタンを押しましょう。

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.
ja: この動作はこれまで何度も見てきました。Runボタンを押すと、既に鳴っているサウンドのレイヤーの一番上にサウンドを追加します。このためループが含まれている場合、Runボタンを3回押すと、3つのレイヤーが一斉に再生されます。

en: However, with named threads it is different:
ja: ただし、名前付きのスレッドでそれは異なります。

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:
ja: このコードでRunボタン複数回、押してみてください。ひとつのアーメン・ブレイクのループのみが聞こえるでしょう。そして下記のテキストがログ画面に表示されます。

en: Sonic Pi is telling you that a thread with the name `:amen` is already playing, so it's not creating another.
ja: Sonic Pi は、`:amen`という名前があるスレッドが既に存在するため、別のものを作成しませんと伝えています。

en: This behaviour may not seem immediately useful to you now - but it will be very handy when we start to live code...
ja: この動作はすぐに使う必要性はないように思えますが、ライブコーディングを始めると、非常に便利なものになるでしょう。

en: 5.5 Functions
ja: 5.5 ファンクション（関数）

en: Functions
ja: ファンクション（関数）

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.
ja: 一度、膨大なコードを書き始めると、それらの構造をより簡単かつ整理された状態で把握できるように、構築しまとめたいと感じることになるでしょう。`ファンクション`（関数）はそんなことをとても効果的に成し遂げる方法です。この関数を使うとコードのまとまりに対して名前をつけることも可能になります。早速、見ていきましょう。

en: Defining functions
ja: 関数の定義

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`.
ja: ここでは`foo`という名前を付けた新しい関数を定義しています。この章ではすっかりお馴染みの*do/end*ブロックと、`define`という魔法の言葉の後ろに、この関数に付けたい名前を続けています。関数の名前は`foo`である必要はなく、`bar`や`baz`といったどんなものでも構いませんが、理想的には`main_section`や`lead_riff`といった何か意味のあるものがよいでしょう。

en: Calling functions
ja: 関数の呼び出し

en: Once we have defined our function we can call it by just writing its name:
ja: いったん1つの関数を定義すると、ただ名前を書くことでそれを呼びだすことができます。

en: Functions are remembered across runs
ja: 複数の`Run`を超えた関数の利用

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:
ja: これまでのところ、`Run`ボタンを押すたびに、Sonic Piを完全に白紙の状態から始めたことにして、表示されているBuffer以外のコードは無いものとしていました。これは、別のBufferまたは別のスレッド内のコードを参照できなかったからです。しかし、関数はそれを変えることができます。あなたが関数を定義すると、Sonic Piはそれを*覚える*ことができます。では、ちょっとやってみましょう。まずBufferにあるすべてのコードを消して、次のものに変更します。

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`).
ja: `Run`ボタンを押して、関数の`foo`が再生されることを確認してください。コードはどこにいったのでしょう？ また、Sonic Piは、実行の仕方をどのように知っていたのでしょうか？ Sonic PiはBufferを消したあとでも、あなたが打ち込んだ関数を覚えていて、定義した関数をしっかりと再生してみせたのです。この動作は`define`もしくは`defonce`を使用した時にだけ働く機能です。

en: Parameterised functions
ja: 引数の付いた関数

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:
ja: 最小値と最大値の情報を`rrand`へ渡すように、引数を受け取る関数についても興味を持つかもしれません。ちょっと見てみましょう。

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.
ja: この例はあまり面白いものではありませんが、ポイントとなる点を示しています。ここでは、引数の付いた`my_player`という名前の関数を、`play`の独自のバージョンとして作成しています。

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.
ja: この引数は`define`で括られた*do/end*ブロックのdoの後に記述する必要があります。引数は、垂直のバー`|`で囲み、複数の引数を扱う場合はカンマ `,`で分割し、引数の名前はどんな言葉でも付けることが出来ます。

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`.
ja: この魔法は、`define`を使い*do/end*ブロック内で行われます。また、実行されるための値のような変数名を使うことも出来ます。この例で言うと、`n`という値の音符を鳴らしています。引数はコードが起動した際にその領域に記憶されている実際の数値に置き換えられるという約束と考えることができます。あなたが関数を呼び出した際は、この数値を関数に置き換えて実行することが出来るのです。この`my_player 80`というのは、80という音符を鳴らすということです。関数の定義の中で、`n`はすぐに`80`に置き換えられます。そして`play n`は`play 80`となるのです。また次に`my_player 90`という関数を呼び出すと、今度は`n`が`90`に置き換えられ、`play n`は`play 90`として再生されるのです。

en: Let's see a more interesting example:
ja: それではさらにおもしろい例を見てみましょう。

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`.
ja: ここでは`repeats.times do`という行の中で1つの数値のように`repeats`が使われます。また、`play`を呼び出した際の音符の名前と同じように`root`が使われています。

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!
ja: 関数に多くの処理を移動することによって、コードをとても表現力豊かにかつ読み易く書けることがわかりましたね！

en: 5.6 Variables
ja: 5.6 変数

en: Variables
ja: 変数

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:
ja: ここで、`:loop_amen`という記号は変数`sample_name`に'記憶'されました。`:loop_amen`を使いたいところではどこでも`sample_name`を使うことが可能です。例えば次のとおりです。

en: There are three main reasons for using variables in Sonic Pi: communicating meaning, managing repetition and capturing the results of things.
ja: Sonic Piでは変数を使う際、3つの主要な使い方があります。意味の伝達、重複の管理、そして結果の獲得です。

en: Communicating Meaning
ja: 意味の伝達

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!
ja: コードを書くとき、あなたはコンピュータが理解しOKを出してくれることだけを考え、どのようにコンピュータに伝えて動作させるのかを意識するだけであれば、それは簡単な事ですね。しかし、覚えておかなくてはいけない大事なことは、コンピュータがコードを読むということだけではないということです。他の人もそれを読み、何が起こっているか理解をしようとするでしょう。あなた自身も将来、自分の書いたコードを見返して、どんなことをしたのか？ 理解する必要がある時が来るかもしれません。たぶん確実にあなたにも他の人にも、そういったことが起こるのです!

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:
ja: あなたのコードがどのように動いているのか他人が理解をするための1つの方法として、コメントを書く（前章で確認できます）という方法があります。もう1つの方法として、理解しやすい変数名を使うという方法があります。次のコードを見てください。

en: Why does it use the number `1.7533`? Where did this number come from? What does it mean? However, look at this code:
ja: 上の例だけを見ると、なぜ`1.7533`という数値を使ったのでしょう？ その数値はどこから来たのか？ それは何を意味しているのか？ という疑問がわきます。しかし、次のコードを見てみましょう。

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:
ja: こう書くとすぐに`1.7533` がサンプル音源`:loop_amen`の長さであるということがわかりますね。もちろん、下記のように一行に書くことも可能です。

en: Which, of course, is a very nice way of communicating the intent of the code.
ja: どちらを用いたとしても、コードの意味がよりわかりやすいものになりました。

en: Managing Repetition
ja: 重複の管理

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:
ja: コードの中では沢山の重複が頻繁に見られます。また、もし何かを変更したいときは、膨大な場所を変更する必要も出てきます。次のコードをみて下さい。

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.
ja: 上のコードは`:loop_amen`で沢山のことをしすぎています！ もし`:loop_garzul`のような他のサンプルのループによる音が聞きたい場合はどうしましょう？ そうするにはすべての`:loop_amen`を探しだして`:loop_garzul`に変更する必要があります。そんな変更ができる沢山の時間があればいいんですが…もし仮にあなたがステージの上で演奏している最中だったらどうでしょう？ 特にみんなのダンスを止めないために、変更するためのそんな優雅な時間はないかもしれません。

en: What if you'd written your code like this:
ja: 下記のようなコードを書いたとして、

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.
ja: これは先程のコードと同じです（試してみてください）。しかし、`sample_name = :loop_amen`の一行を`sample_name = :loop_garzul`に変更するだけで多くの箇所を変更できました。そして、それは変数の力によるものです。

en: Capturing Results
ja: 結果の獲得

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:
ja: 最後に、変数を使う優れた理由はそのコードの結果の獲得をするということです。例えば、サンプル音源の長さを使って何かを行いたい時など。

en: We can now use `sd` anywhere we need the duration of the `:loop_amen` sample.
ja: 上記のように書くことで、今、`:loop_amen`というサンプルの長さが必要な時、どこにでも`sd`を使うことが出来るようになります。

en: Perhaps more importantly, a variable allows us to capture the result of a call to `play` or `sample`:
ja: おそらくもっと重要なのは、変数は、playやsampleの結果をキャプチャすることができることです。

en: Now we have caught and remembered `s` as a variable, which allows us to control the synth as it is running:
ja: またこのように書くことで `s` が変数として記憶され、シンセをコントロールできるようになります。

en: We'll look into controlling synths in more detail in a later section.
ja: また、後の章ではもっと詳しくシンセをコントロールすることも学びます。

en: Warning: Variables and Threads
ja: 注意：変数とスレッド

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*:
ja: 変数はモノに名前を与えたり、ある処理においてどういった結果が返ってくるのか推測するのに役立ちます。ただし、通常、変数はスレッド内で完結するローカル変数として定義する必要があることを知っておく必要があります。したがって、以下のようなことをしてはいけません。

en: In the above example we assign a ring of numbers to a variable `a` and then used it within two separate `live_loop`s. In the first live loop every `0.5`s we sort the ring (to `(ring 1, 2, 3, 4, 5, 6)`) and then print it out to the log. If you run the code, you'll find that the printed list *is not always sorted!*. This may surprise you - especially that sometimes the list is printed as sorted, and sometimes it is not. This is called non-deterministic behaviour and is the result of a rather nasty problem called a race-condition. The problem is due to the fact that the second live loop is also manipulating the list (in this case shuffling it) and by the time the list is printed, sometimes it has just been sorted and sometimes it has just been shuffled. Both live loops are racing to do something different to the same variable and every time round a different loop 'wins'.
ja: 上の例では変数`a`に数字のリングを割り当て、2つの別々の`live_loop`の中でそれを利用しました。最初のライブループでは0.5秒ごとにリング `(ring 1, 2, 3, 4, 5, 6)`をソートしてログにプリント出力しています。コードを実行すれば、プリントされたリストが*いつもソートされているわけではない*ことがわかるでしょう。もしかすると、リストがソートされていたり、されていなかったりすることにびっくりするかもしれません。これは非決定的挙動と呼ばれるもので、レースコンディションというやっかいな問題の結果でもあります。その問題の原因は2つ目のライブループもまたリストを操作(この例ではリストをシャッフル)していることにあり、リストはプリントされる時に、ちょうどソートされた状態であることもあれば、ちょうどシャッフルされた状態であることもあるのです。2つのライブループが同じ変数に対して別々のことをしようと競い合っていて、毎回どちらか異なる方が勝っているということです。

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:
ja: これに対して2つの解決策があります。　1つは、*複数のライブループやスレッドで同じ変数を使わない*ことです。例えば、以下のコードはそれぞれのライブループが別々の変数を持っているので常にソートされたリストがプリントされます。

en: However, sometimes we do want to share things across threads. For example, the current key, BPM, synth etc. In these cases, the solution is to use Sonic Pi's special thread-safe state system via the fns `get` and `set`. This is discussed later on in section 10.
ja: しかし、スレッド間で何かを共有したいこともあります。例えば、現在のキーやBPM、シンセなどです。このような場合には、Sonic Piの特別なスレッドセーフな状態管理システム、`get` と `set` という関数を使うことで出来ます。これについては、後ほどセクション10で説明します。

en: 5.7 Thread Synchronisation
ja: 5.7 スレッドの同期

en: Thread Synchronisation
ja: スレッドの同期

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.
ja: 一度、関数やスレッドを使用したとても高度なライブコーディングを行うと、あるスレッドが止まってしまうような間違いがとても容易に発生することに気づいたかもしれませんね。`Run`ボタンを押してスレッドを再スタートさせることは容易にできるので、それは大した問題ではありません。しかし、スレッドを再スタートさせるときには、元々のスレッドと*時間がずれる*ことになります。

en: Inherited Time
ja: 時間の継承

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.
ja: 以前話した時に、新しいスレッドが`in_thread`として作られると元のスレッドのすべての設定が継承されることを学びました。これは現在の時間を含んでいます。つまり、スレッドが同時にスタートするときには常に他のスレッドと同期していることを意味しています。

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.
ja: しかし、あるスレッドを独自のタイミングで起動したときは、現在実行中の他のスレッドと同期していることはほとんどないでしょう。

en: Cue and Sync
ja: CueとSync

en: Sonic Pi provides a solution to this problem with the functions `cue` and `sync`.
ja: Sonic Pi は`cue`と`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.
ja: `cue`はすべての他のスレッドに向けてビートメッセージを送ることができます。初期状態の他のスレッドでは、これらのビートのメッセージは関係付けられず、無視されます。しかし、`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.
ja: `sync`という機能は、一定の時間、実行中のスレッドを止める`sleep`という関数と非常に似ていることに気づくことが重要です。しかし、`sleep`ではどのくらい休止させるかを決めることができましたが、`sync`ではそれを決めることができず、`sync`は長さに関わらず、次の`cue` が出てくるまで待つのです。

en: Let's explore this in a little more detail:
ja: それでは、もうちょっと詳しく見ていきましょう。

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.
ja: ここでは2つのスレッドが使われています。1つは、音は鳴りませんがメトロノームのような機能として1秒ごとに`:tick`というビートメッセージを送っています。2つ目のスレッドは、`tick`というビートメッセージと同期し、その際に`cue`のスレッドの時間の情報を継承して実行を続けます。

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:
ja: この結果、`:drum_heavy_kick`のサンプルは、たとえ同時に実行されていない2つのスレッドであったとしても、他のスレッドが`:tick`のメッセージを送信したタイミングで、ぴったりと聴くことができるでしょう。

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.
ja: このちょっとやっかいな`sleep(0.3)`は、1つめのスレッドとは時間がずれた2つめのスレッドを作り出してしまいます。しかしながら、`cue`や`sync`を使えば、タイミングがずれてしまうようなアクシデントを回避してくれます。

en: Cue Names
ja: Cueの名前

en: You are free to use whatever name you'd like for your `cue` messages - not just `:tick`. You just need to ensure that any other threads are `sync`ing on the correct name - otherwise they'll be waiting for ever (or at least until you press the Stop button).
ja: `cue`には`:tick`以外のどんな好きな名前でも付けられます。その際には他のスレッドと同期させるために必ず正しい名前を使用する必要があります。もし違った場合、永遠に（もしくはストップボタンを押すまで）それは`cue`のメッセージを待ち続けることになります。

en: Let's play with a few `cue` names:
ja: それでは`cue`の名前付けを見てみましょう。

en: Here we have a main `cue` loop which is randomly sending one of the heartbeat names `:foo`, `:bar` or `:baz`. We then also have three loop threads syncing on each of those names independently and then playing a different sample. The net effect is that we hear a sound every 0.5 beats as each of the `sync` threads is randomly synced with the `cue` thread and plays its sample.
ja: ここではメインの`cue`ループでビートメッセージをランダムに`:foo`と`:bar`、`:baz`に送るようにしています。それから3つのスレッドがそれぞれ独自に同期して、それぞれ異なるサンプルの音を再生します。実際には、`sync`スレッドとして用意した3つのスレッドのいずれかが`cue`スレッドとランダムに同期し、0.5秒毎にサンプル音の再生を聴くことができるでしょう。

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`.
ja: 逆に`sync`スレッドを単に次の`cue`まで待たせるようにしても、もちろんそれは動作します。

en: 6 FX
ja: 6 エフェクト

en: Studio FX
ja: スタジオ・エフェクト

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.
ja: Sonic Piには、あなたの作ったサウンドに簡単にスタジオ·エフェクトを追加できるという最もやりがいのある楽しい側面があります。たとえば、部分的にリバーブを追加したり、エコーやディストーション（歪み）、ワブルベース（ベース音にフィルタLFOを掛け、断続的な音にすること）を加えることができます。

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...
ja: Sonic Piには、エフェクトを追加する非常にシンプルで強力な方法があります。さらに、それをチェイン（連結）させることができ（これにより、ディストーション（歪み）を通し、その後エコー、さらにリバーブということができます）、またエフェクトユニットのオプションを（シンセやサンプルにオプションを与えるのと同じように）個別に制御することもできます。さらに、エフェクトが実行されている間にも、オプションを変更することができます。これにより、例えば、トラック全体を通してベースのリバーブを強くしていくといったことも可能です。

en: Guitar Pedals
ja: ギター・エフェクター

en: Guitar -> Distortion -> Reverb -> Amplifier
ja: ギター -> ディストーション -> リバーブ -> アンプ

en: Let's explore FX!
ja: さあ、エフェクトを探究していきましょう！

en: 6.1 Adding FX
ja: 6.1 エフェクトの追加

en: Adding FX
ja: エフェクトの追加

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.
ja: このセクションでは、エフェクト「リバーブとエコー」の組み合わせを見ていきます。それらをどのようにチェイン接続するか、どのように制御するのか、これらの使用方法について説明します。

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.
ja: Sonic Piのエフェクトシステムは、ブロックを使用します。セクション5.1を読んでいなければ、戻って目を通してください。

en: Reverb
ja: リバーブ

en: If we want to use reverb we write `with_fx :reverb` as the special code to our block like this:
ja: リバーブを使用する場合、次のように特殊なコード`with_fx :reverb`をブロックに書きます。

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.
ja: 早速コードを実行してリバーブを聞いてみましょう。いいでしょ！ 音全体が残響効果で素晴らしくなります。

en: Now let's look what happens if we have code outside the do/end block:
ja: さあ、次はブロックの外にコードを書いて何が起こるか見てみましょう。

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.
ja: どうして最後の`play 55`にリバーブが適用されないのでしょうか。それはブロックの*外部*に書かれているため、リバーブエフェクトは適応されないのです。

en: Similarly, if you make sounds before the do/end block, they also won't be captured:
ja: *do/end*ブロックの手前で音を生成する場合も同様にリバーブは適用されません。

en: Echo
ja: Echo：エコー

en: There are many FX to choose from. How about some echo?
ja: 選択できるエフェクトは他にもたくさんあります。エコーはどうでしょうか?

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:
ja: Sonic Piのエフェクトブロックの強力な側面の1つは、既に`play`と`sample`で見てきたオプションと同様のオプションが渡されることです。たとえば、エコーの楽しいオプションは、拍単位で遅れの長さを示す`phase`があります。下記のコードで、エコーの遅れをゆっくりにしてみましょう。

en: Let's also make the echo faster:
ja: エコーの遅れを早くしてみましょう。

en: Let's make the echo take longer to fade away by setting the `decay:` time to 8 beats:
ja: エコーが8拍の時間でフェードアウトする様に、`decay:`を設定してみましょう。

en: Nesting FX
ja: エフェクトの入れ子

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:
ja: エフェクトブロックで最も強力な側面の1つは、入れ子ができるということです。これはとても簡単にエフェクト同士を連結することができます。たとえば、あるコードにエコーとリバーブを掛けたい場合どうしますか？ その答えは単純です。1つのエフェクトの内側にもう一方を配置するだけです。

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.
ja: オーディオの流れについて内側から外側へ追ってみましょう。`play 50`を含む`block`の*do/end*ブロック内のコード全ては、最初にエコーエフェクトに送られ、その音がリバーブエフェクトへと順に送られていきます。

en: Discovering FX
ja: エフェクターの発見

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:
ja: Sonic Piは、あなたが演奏するためにたくさんのエフェクトを搭載しています。どういったエフェクトが使えるのかを見つけ出すためには、ヘルプシステム画面の下にある`エフェクト`ボタンをクリックし、利用可能なリストを見てください。ここに私のお気に入りを記載しておきます。

en: 6.2 FX in Practice
ja: 6.2 エフェクトの実践

en: FX in Practice
ja: エフェクトの実践

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.
ja: エフェクトの外観は一見シンプルですが、実際には内部は異常に複雑なモンスターです。そのシンプルさは、しばしば、この機能を酷使させようと誘惑します。もしもあなたが強力なマシンを持っている場合は問題は無いかもしれませんが、Raspberry Piで動作させる場合、確実にビートを刻み続けるようにしたいのであれば、どのくらいの負荷をかけているのか注意する必要があります。

en: Consider this code:
ja: このコードを考えてみましょう。

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...
ja: このコードは非常に短いリリース時間で音符`60`を演奏しています。そして、リバーブを加えたいために、コードをリバーブで囲んでいます。問題はなさそうには見えますが…。

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.
ja: コードが何をするかを見ていきましょう。まず、`loop`は内側のすべてが永遠に繰り返すことを意味します。次に、`with_fx`ブロックがあります。これはループが繰り返される度に、新しいリバーブエフェクトを作成することを意味します。ギターの弦を弾くたびに別々のリバーブエフェクターを用意して演奏しているようなものです。そんなことができたらかっこいいかもしれませんが、それはあなたが望むものとは限らないということです。たとえば、Raspberry Piでこのコードを実行させるためにはとても労力を要します。リバーブは`with_fx`によって制御され、停止か消去されるまで、生成され続け、スム−ズな演奏に必要とする大切なCPUパワーを奪うことになりかねません。

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:
ja: ギタリストのように、すべての音が1つのリバーブエフェクターを通る従来の設定と同様の流れを作るには、どうしたら良いでしょうか？ とてもシンプルです。

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.
ja: `with_fx` ブロックの*内部*に`loop`を配置します。この方法では、ループ内すべての音符の再生にリバーブを1つだけ作成します。このコードは効率的で、Raspberry Piで正常に動作します。

en: A compromise is to use `with_fx` over an iteration within a loop:
ja: `loop`内の繰り返しの上位に`with_fx`を使うことで折り合いを付けます。

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.
ja: `loop`の外部に`with_fx`を引き上げることで、16音符ごとに新しいリバーブを作成しています。

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:
ja: このようなパターンは一般的なので、`16.times`のブロックを書かずに全く同じ動作をするオプションを`with_fx`はサポートしています。

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.
ja: `reps: 16`の例も`16.times do`の例も同様に振る舞います。`reps: 16`は`do/end`のブロックを16回繰り返すので、どちらも交換可能に使うことができ、どちらか好きな方を選ぶことができます。

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.
ja: 「間違いはない、あるのはただ可能性だけ」と言ったのを思い出してください。しかしながら、これらの異なるアプローチからは、異なるサウンド、また異なる性能をもたらします。あなたのプラットフォームの性能の制約の中で、最も良いと思うアプローチを使いながら演奏するようにしましょう。

en: 7 Control
ja: 7 コントロール

en: Controlling running sounds
ja: 演奏中のサウンド制御

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.
ja: これまでの章では、どのようにシンセやサンプルを扱い、アンプ（増幅）、パン、エンベロープなどのオプションを変更するのかを見てきました。呼び出された個々の音には、元来、音の継続時間を設定するデュレーションオプションが備わっています。

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?
ja: もしも演奏中にギターの弦を歪めビブラートさせるように、オプションを変更できたなら、それってクールではないでしょうか？

en: You're in luck - this section will show you how to do exactly this.
ja: あなたは幸運です - このセクションでは、まさしくそれをどのように行うのかを紹介します。

en: 7.1 Controlling Running Synths
ja: 7.1 演奏中のシンセ制御

en: Controlling Running Synths
ja: 演奏中のシンセ制御

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:
ja: これまでは、新しいサウンドとエフェクトを引き起こす方法についてだけ見てきましたが、Sonic Piは、演奏中の音を操り、処理する機能を備えています。次のコードのように、シンセの参照を取得するために変数を使用してこれを実現します。

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.
ja: ここで、ローカル変数`s`が音符60を演奏するシンセを表しています。この変数は、*実行毎にローカル*である点に注意してください。ある実行のdefineで定義された関数のように他の実行からアクセスすることはできません。

en: Once we have `s`, we can start controlling it via the `control` function:
ja: 一度`s`を用意すれば、`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.
ja: 演奏している間に、1つのシンセのみを呼び出し、3回ピッチを変更しています。ここで注目すべき点は、4つの異なるシンセを呼び出していないということです。

en: We can pass any of the standard opts to `control`, so you can control things like `amp:`, `cutoff:` or `pan:`.
ja: 標準的なオプションは`control`へ渡すことができるので、`amp:`, `cutoff:`あるいは`pan:`などを制御することができます。

en: Non-controllable Options
ja: 制御不可能なオプション

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.
ja: 一度シンセが開始されると、一部のオプションは制御することができなくなります。ADSRエンベロープ·パラメータがこれに該当します。そのオプションが制御可能かは、ヘルプシステムのドキュメントを参照してください。ドキュメントに「一度設定されると変更することは出来ません」と書かれている場合、シンセが開始された後にオプションを制御することはできません。

en: 7.2 Controlling FX
ja: 7.2 エフェクトの制御

en: Controlling FX
ja: エフェクトの制御

en: It is also possible to control FX, although this is achieved in a slightly different way:
ja: エフェクトも、少々異なる方法をとりますが、制御する事が出来ます。

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.
ja: 変数を使用する代わりに、*do/end*プロックのブロックパラメータを使用します。これは、実行中のエフェクトとして*do/end*プロックの中から参照するパラメータとして、`|`と`|`の間にユニークな名前を指定する必要があります。このパラメータの振る舞いは、引数の付いた関数を使用する場合と同じです。

en: Now go and control some synths and FX!
ja: さあ、シンセやエフェクトをコントロールしてみよう！

en: 7.3 Sliding Options
ja: 7.3 オプションのスライド

en: Sliding Opts
ja: オプションのスライド

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.
ja: シンセやエフェクトのオプションを見ていくと、`_slide`で終わるオプションがあることに気づいたかもしれません。それらを試しに呼び出しても、何の効果も示さなかったかもしれません。これは通常のオプションではなく、前回のセクションで紹介したように、シンセを制御するときのみ動作をする特別なオプションです。

en: Consider the following example:
ja: 次の例を考えてみましょう。

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:
ja: ここでは、各`control`の呼び出し後、すぐにシンセのピッチの変更を聞くことができますが、ピッチが変化する間にスライドさせたくなるかもしれません。ここでは`note:`オプションを制御しているので、スライドを追加するためには、シンセの`note_slide`オプションを追加する必要があります。

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.
ja: `control`の呼び出しの間の音程が滑らかに繋がっていることがわかるはずです。いい感じではないでしょうか。`note_slide: 0.2` よりも短いスライド時間を使うことで、スライドをスピードアップすることができますし、もっと長い時間を使ってテンポを遅くすることができます。

en: Every parameter that can be controlled has a corresponding `_slide` parameter for you to play with.
ja: 制御することのできるオプションは、対応する`_slide`オプションを持っています。

en: Sliding is sticky
ja: スライドの設定は保持される

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.
ja: 一度、実行しているシンセの`_slide`オプションを設定したら、それは記憶され、対応するオプションがスライドする度に使用されます。スライドを停止するためには、次の`control`を呼び出す前に`0`に`_slide`値を設定する必要があります。

en: Sliding FX Opts
ja: エフェクト・オプションのスライド

en: It is also possible to slide FX opts:
ja: また、エフェクトオプションをスライドさせることも可能です。

en: Now have fun sliding things around for smooth transitions and flowing control...
ja: さあ、滑らかな変化と流れるような制御のために、色々スライドして楽しんでみましょう。

en: 8 Data Structures
ja: 8 データ構造

en: Data Structures
ja: データ構造

en: A very useful tool in a programmer's toolkit is a data structure.
ja: プログラマのツールキットで非常に有用なツールはデータ構造です。

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.
ja: 時には、複数の要素を表したものを使いたいかもしれません。例えば、次々に演奏される一連の音符を保持すると便利だと気づくことがあるかもしれません。プログラミング言語は、正にこういったことを行うためにデータ構造を持っています。

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.
ja: プログラマが利用できるエキサイティングで奇抜なデータ構造は沢山あり、また常に新しいものが発明されています。しかし、今の我々が本当に検討するべきものは、とてもシンプルなデータ構造 - リストです。

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.
ja: では、より詳細に見てみましょう。まずは、リストの基本的な形式を学習し、続いて、リストがスケール（音階）やコード（和音）を表現するためにどのように使用されるのかを学習していきましょう。

en: 8.1 Lists
ja: 8.1 リスト

en: Lists
ja: リスト

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:
ja: このセクションでは、非常に有用なデータ構造であるリストについて見ていきます。以前に我々はランダム化の章でリストについて簡単に触れました。音符のリストから無作為に選んで再生する次のようなコードです。

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:
ja: ここでは、コードやスケールを表現するためのリストの使い方についても見ていきます。最初に、コードを演奏する方法をおさらいしてみましょう。`sleep`を使用しない場合、すべての音が同時に演奏されることを思い出してください。

en: Let's look at other ways to represent this code.
ja: このコードの別の表現方法を見てみましょう。

en: Playing a List
ja: リストの演奏

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:
ja: 1つの方法は、\[52, 55, 59\]のように、すべての音符をリストに配置することです。使いやすいplay関数は、リストになった音符をどのように演奏するかをすぐに理解します。次のコードを試してみてください。

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:
ja: おー、これは読みやすいですね。音符リストの演奏は、通常のオプションのいずれも妨げになりません。

en: Of course, you can also use the traditional note names instead of the MIDI numbers:
ja: もちろん、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.
ja: 多少の音楽理論の知識を持っている方なら、3オクターブで*Eマイナー*のコードが演奏されたことがわかるでしょう。

en: Accessing a List
ja: リストへのアクセス

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.
ja: もう1つの非常に便利なリストの機能は、リストから情報を取得する機能です。これは少し奇妙に聞こえるかもしれなませんが、本の23ページを開いてくださいと誰かに頼まれることよりも簡単なことです。リストの場合は、インデックス23の要素は何ですか？ と尋ねればいいのです。唯一、奇妙なことは、プログラミングのインデックスは通常、1ではなく0から開始されることです。

en: With list indexes we don't count 1, 2, 3... Instead we count 0, 1, 2...
ja: リストのインデックスは1,2,3と数える代わりに、0,1,2と数えていきます。

en: Let's look at this in a little more detail. Take a look at this list:
ja: それではもう少し詳細にみてみましょう。次のリストを見てください。

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:
ja: これは特に難しいことは何もありません。リストの2番目の要素は何でしょうか？ そう、もちろん`55`です。簡単ですね。それでは、同様にコンピュータが答えることができるかどうかを見てみましょう。

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:
ja: 以前にこのようなものを見たことがない場合、少し奇妙に見えるかもしれませんが、大丈夫。私を信頼してください。難しいことはありません。上記の行には、`puts`という命令、リストの`52, 55, 59` 、インデックスが`[1]`の3つの部分があります。まずはじめに、Sonic Piへログの中から答えを出力させるためputsを命令します。次にリストを与えています。そして最後に第2の要素を問い合わせています。角括弧でインデックスを囲む必要があり、カウントは`0`で始まるので、2番目の要素のインデックスは`1`となります。下記、みてみましょう。

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...
ja: コード`puts [52, 55, 59][1]`を実行してみてください。ログに`55`と表示されるでしょう。インデックス`1`を別のインデックスに変えてみてください。さらに長い`list`を与えて、どのように演奏で使えるのか考えてみてください。例えば、どのような音楽の構造が音符の連続として表現されるか？ などです。

en: 8.2 Chords
ja: 8.2 コード（和音）

en: Sonic Pi has built-in support for chord names which will return lists. Try it for yourself:
ja: Sonic Piは和音名でリストを返す機能を内蔵しています。実際に試してみましょう。

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:
ja: さあ、本当に動きましたね。そのままのリストよりも美しく見えるし、そして他の人にとっても読みやすいでしょう。では、どんな和音をSonic Pi はサポートをしているのでしょうか。沢山あります。次のように、いくつかのコードを試してみましょう。

en: Arpeggios
ja: アルペジオ

en: We can easily turn chords into arpeggios with the function `play_pattern`:
ja: `play_pattern`関数で簡単にコード（和音）からアルベジオ（和音を構成する音を一音ずつ順番に弾いていく奏法）に変更して演奏を行うことができます。

en: We can even pass a list of times which it will treat as a circle of times:
ja: `play_pattern`には時間のリストを渡すこともでき、それは循環する時間として扱われます。

en: This is the equivalent to:
ja: これは次のコードと同じです。

en: Which would you prefer to write?
ja: どちらの書き方を好みますか？

en: 8.3 Scales
ja: 8.3 スケール（音階）

en: Scales
ja: スケール（音階）

en: Sonic Pi has support for a wide range of scales. How about playing a C3 major scale?
ja: Sonic Piは広い範囲の音階を演奏できます。C3メジャースケールの再生はどのように行うのでしょうか？

en: We can even ask for more octaves:
ja: さらに多くのオクターブを実行することができます。

en: How about all the notes in a pentatonic scale?
ja: ペンタトニックスケール（オクターブに5つの音が含まれる音階のこと）のすべての音符はどうでしょう?

en: Random notes
ja: ランダムな音符

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:
ja: コードとスケールは、ランダムな選択を強いるには素晴らしい制約です。コードE3マイナーからランダムに音符を取り出すには次の例を実行してください。

en: Try switching in different chord names and cutoff ranges.
ja: 異なる和音名やカットオフする範囲を試してみましょう。

en: Discovering Chords and Scales
ja: コードとスケールの検索

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).
ja: Sonic Piによってサポートされているスケールやコードを検索するには、このチュートリアルの左にある`命令`ボタンをクリックし、APIリストから`chord`か`scale`を選びます。メインパネルの情報に、コードやスケールの長いリストが現れるまで下にスクロールしてください。

en: Have fun and remember: there are no mistakes, only opportunities.
ja: 「間違いはない、あるのはただ可能性だけ」ということを思い出して、楽しんでください。

en: 8.4 Rings
ja: 8.4 リング

en: Rings
ja: リング

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.
ja: 標準のリストを一捻りした面白いものにリングがあります。いくつかのプログラミングを理解していれば、リングバッファやリングアレイなどを見たことがあるかもしれません。ここでは、まさに`ring`（環状リスト）について見ていきます - それは短く、簡単です。

en: In the previous section on lists we saw how we could fetch elements out of them by using the indexing mechanism:
ja: リストに関する前のセクションでは、インデックスの機構を使用してリストから要素を取り出す方法を説明しました。

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.
ja: もしインデックス100を取り出そうとしら、何が起こるでしょう？ まあ、3つの要素しか持たないリストの中でインデックス100の要素は、明らかにありません。だからSonic Piは空を意味する`nil`を返すでしょう。

en: However, consider you have a counter such as the current beat which continually increases. Let's create our counter and our list:
ja: ここでは、現在のビート（拍子）が継続的に増加する`counter`を考えてみましょう。まずはカウンタとリストを作成します。

en: We can now use our counter to access a note in our list:
ja: これで、リストの音符にアクセスするためのカウンタを使用することができます。

en: Great, we got `52`. Now, let's increment our counter and get another note:
ja: 素晴らしい、`52`を取得しました。カウンタを増やして別の音符を取得してみましょう。

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.
ja: すごいでしょう、`55`を取得し、それを再び繰り返すならば`59`を得ます。さらに繰り返す場合は、リスト内の数が不足し`nil`になるでしょう。では、ちょうどループのはじめに戻り、再びリストの先頭から開始したい場合はどうしたらようでしょうか？ そのためにリングを使います。

en: Creating Rings
ja: リングの作成

en: We can create rings one of two ways. Either we use the `ring` function with the elements of the ring as parameters:
ja: リングは、2つの方法のどちらか1つで作成することができます。どちらの方法もリングの要素を引数とする`ring`関数を利用します。

en: Or we can take a normal list and convert it to a ring by sending it the `.ring` message:
ja: また、通常のリストを取得し、それに`.ring`メッセージを送ることで、リングに変換することができます。

en: Indexing Rings
ja: リングのインデックス化

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:
ja: いったんリングを取得したら、通常のリストを使用する場合とまったく同じ方法で使用することができます。ただし、インデックスがマイナスもしくはリングの数値より大きい場合は、通常のリストと動作が異なり、先頭あるいは末尾に巻き戻ってリングの要素のどれか1つを必ず指します。

en: Using Rings
ja: リングを使用する

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.
ja: ここで、現在のビート（拍子）の値を表すために変数を使用しているとしましょう。その変数は、現在表しているビート値に関わらず、演奏に使用する音符やリリース・タイム、その他リングに格納された何か有用な値を取得するのに、インデックスとして使用できます。

en: Scales and Chords are Rings
ja: スケールとコードはリング

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.
ja: 知っておくと役立つこととして、`scale`（音階）と`chord`（和音）によって返されたリストもリングであり、任意のインデックスでそれらにアクセスすることを可能にします。

en: Ring Constructors
ja: リングのコンストラクタ（作成関数）

en: In addition to `ring` there are a number of other functions which will construct a ring for us.
ja: `ring`関数の他にも、リングを作成する沢山の関数があります。

en: `range` invites you specify a starting point, end point and step size.
ja: `range`は始点、終点とステップサイズを指定します。

en: `bools` allows you to use `1`s and `0`s to succinctly represent booleans.
ja: `bools`は、`1`と`0`を使用して簡単にブール値を表すリングを作成できます。

en: `knit` allows you to knit a sequence of repeated values.
ja: `knit`は一連の繰り返される値のリングを作成できます。

en: `spread` creates a ring of bools with a Euclidean distribution.
ja: `spread`はユークリッド分布に従ったブール値のリングを作成します。

en: Take a look at their respective documentation for more information.
ja: 詳細については、個々のドキュメントを見てください。

en: 8.5 Ring Chains
ja: 8.5 リングのチェイン

en: Ring Chains
ja: リングのチェイン

en: In addition to the constructors such as `range` and `spread` another way of creating new rings is to manipulate existing rings.
ja: `range`や`spread`のようなコンストラクタ（作成関数）に加えて、別なリングの作成方法としては、作成したリングを操作する方法があります。

en: Chain Commands
ja: チェインコマンド

en: To explore this, take a simple ring:
ja: 次のような単純なリングを作成します。

en: What if we wanted it backwards? Well we'd use the chain command `.reverse` to take the ring and turn it around:
ja: リングを逆にしたいときにはどうしたらよいでしょう？ リングを反転させるには、チェインコマンドの`.reverse`を使います。

en: Now, what if we wanted the first three values from the ring?
ja: では次に、リングから最初の3つの値を取得するにはどうしたらよいでしょう？

en: Finally, what if we wanted to shuffle the ring?
ja: 最後に、リングをシャッフルするにはどうしたらよいでしょう？

en: Multiple Chains
ja: 多重チェイン

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.
ja: ここまでで既にリングを作成する強力な方法を見てきましたが、これらのチェインコマンドを一緒に用いることで*本当の*力を発揮します。

en: How about shuffling the ring, dropping 1 element and then taking the next 3?
ja: リングをシャッフルし、最初の要素を削除し、それに続く3つの要素を得る場合にはどうすればよいでしょう？

en: Let's take this in stages:
ja: 段階的に見ていきましょう。

en: `(ring 10, 20, 30, 40, 50)` - our initial ring
ja: `(ring 10, 20, 30, 40, 50)` - リングの最初の状態

en: `(ring 10, 20, 30, 40, 50).shuffle` - shuffles - `(ring 40, 30, 10, 50, 20)`
ja: `(ring 10, 20, 30, 40, 50).shuffle` - シャッフルし - `(ring 40, 30, 10, 50, 20)`

en: `(ring 10, 20, 30, 40, 50).shuffle.drop(1)` - drop 1 - `(ring 30, 10, 50, 20)`
ja: `(ring 10, 20, 30, 40, 50).shuffle.drop(1)` - 最初の要素を削除し - `(ring 30, 10, 50, 20)`

en: `(ring 10, 20, 30, 40, 50).shuffle.drop(1).take(3)` - take 3 - `(ring 30, 10, 50)`
ja: `(ring 10, 20, 30, 40, 50).shuffle.drop(1).take(3)` - 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.
ja: *コマンドを一緒にくっつける*だけで、これらのコマンドの長いチェインを作れることが分かったと思います。チェインコマンドは好きな順序で組み合わせることができます。またそれにより、既に存在するリングから新しいリングを生成する、とても豊かで強力な方法を作り出すことができます。

en: Immutability
ja: 不変性

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.
ja: リングは強力で重要な特徴を持っています。それは不変性と言って、リングを変更できないということを意味しています。このセクションで紹介しているチェインコマンドが、*リングを変更するのではなく*、*新しいリングを作成*していることを意味しています。これにより、スレッドを跨いでリングを共有して、同じリングを使っている他のスレッドに影響を与えないで、チェインを開始できることを意味しています。

en: Available Chain Methods
ja: 利用可能なチェインコマンド

en: Here's a list of the available chain methods for you to play with:
ja: ここに利用可能なチェインコマンドを記載しておきます。

en: `.reverse` - returns a reversed version of the ring
ja: `.reverse` - 逆順のリングを返却します

en: `.sort` - creates a sorted version of the ring
ja: `.sort` - ソートされたリングを作成します

en: `.shuffle` - creates a shuffled version of the ring
ja: `.shuffle` - シャッフルされたリングを作成します

en: `.pick(3)` - returns a ring with the results of calling `.choose` 3 times
ja: `.pick(3)` - `.choose`を3回呼び出した結果のリングを返却します

en: `.take(5)` - returns a new ring containing only the first 5 elements
ja: `.take(5)` - 最初の5つの要素をのみからなる新しいリングを返却します

en: `.drop(3)` - returns a new ring with everything but the first 3 elements
ja: `.drop(3)` - 最初の3つの要素以外の要素からなる新しいリングを返却します

en: `.butlast` - returns a new ring with the last element missing
ja: `.butlast` - 最後の要素が欠けた新しいリングを返却します

en: `.drop_last(3)` - returns a new ring with the last 3 elements missing
ja: `.drop_last(3)` - 最後の3つの要素が欠けた新しいリングを返却します

en: `.take_last(6)`- returns a new ring with only the last 6 elements
ja: `.take_last(6)`- 最後の6つの要素をのみからなる新しいリングを返却します

en: `.stretch(2)` - repeats each element in the ring twice
ja: `.stretch(2)` - リングの個々の要素を2回ずつ繰り返します

en: `.repeat(3)` - repeats the entire ring 3 times
ja: `.repeat(3)` - リング全体を3回繰り返します

en: `.mirror` - adds the ring to a reversed version of itself
ja: `.mirror` - 逆順のリングを自分自身に追加します

en: `.reflect` - same as mirror but doesn't duplicate middle value
ja: `.reflect` - mirrorと同様ですが、真ん中の要素を重複させないようにします

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.
ja: 数字を引数に取っているチェインコマンドは、他の数字を取ることももちろん可能です。最初の5個の要素を削除したい場合には、`.drop(3)`の代わりに、気軽に`.drop(5)`を呼んでください。

en: 9 Live Coding
ja: 9 ライブコーディング

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.
ja: Sonic Piの中で最もエキサイティングな特徴の1つは、ライブでギターをかき鳴らすのと同じように、ライブで音楽を演奏しながら、その場でコードを書き換え、音を変化させていくことができることです。この方法で優れているのは、（シンプルなループを走らせ、そのサウンドが完璧になるまで調整するように）作品を作っている間にどのような音が出来ているかその場でフィードバックを得られることです。ですが、一番の利点は、Sonic Piでステージ上でライブができることです。

en: In this section we'll cover the fundamentals of turning your static code compositions into dynamic performances.
ja: このセクションでは、静的なコードのチューニングの基本から動的なパフォーマンスまで扱います。

en: Hold on to your seats...
ja: しっかりついてきてくださいね。

en: 9.1 Live Coding Fundamentals
ja: 9.1 ライブコーディングの基本

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:
ja: ここまでの章で、我々は実際に楽みながら演奏をする方法を十分に学んできました。この章では、これまでのすべての章から、どの様に作曲を開始し、ライブパフォーマンスに繋げるかを紹介していきます。そのために3つの主な要素が必要になります。

en: An ability to write code that makes sounds - CHECK!
ja: チェック要素：音を作るコードを書く能力

en: An ability to write functions - CHECK!
ja: チェック要素：ファンクション（関数）を作成する能力

en: An ability to use (named) threads - CHECK!
ja: チェック要素：（名前付き）スレッドを使う能力

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:
ja: よーし、始めましょう。最初の音をライブコーディングしましょう。まず演奏したいコード含む関数が必要です。簡単なところから始めましょう。スレッドでその関数を呼び出すループもほしいところです。

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.
ja: もし上のコードが少し複雑に見える場合は、ファンクション（関数）とスレッドのセクションに戻って復習してください。既にこれらを頭に焼き付けているならば、それほど複雑ではないでしょう。

en: If you run this code, you'll hear note 50 repeating again and again...
ja: このコードを実行すると、音符50を何度も何度も繰り返します。

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!
ja: ここからが面白くなるところです。コードを*実行したままで*、50を別の数値55に変更し、もう一度`Run`ボタンを押してみましょう。わお！ 音が変化しましたね！ ライブ！

en: Try changing it again, change the note, change the sleep time. How about adding a `use_synth` statement? For example, change it to:
ja: スリープ時間をや音符を変更し、再び試してみてください。`use_synth`を追加してみるのはどうでしょう？ たとえば、次のように変更してみてください。

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:
ja: かなり面白くなってきましたが、それをさらに盛り上げることができます。何度も何度も同じ音符を演奏する代わりに、和音を弾いてみましょう。

en: How about playing random notes from the chord:
ja: 和音からランダムな音符を演奏するのはどうでしょう。

en: Or using a random cutoff value:
ja: またはランダムなカットオフ値を使用してみましょう。

en: Finally, add some drums:
ja: 最後に、ドラムを追加しましょう。

en: Now things are getting exciting!
ja: どんどんおもしろくなってきましたね！

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...
ja: しかしながら、ファンクション（関数）とスレッドを使ったライブコーディングにステップアップする前に、一息ついて、Sonic Piでのコーディングを劇的に変えてしまうかもしれない`live_loop`について次の章を読んでいきましょう。

en: 9.2 Live Loops
ja: 9.2 ライブループ

en: Live Loops
ja: ライブループ

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.
ja: このチュートリアルの中でもこの章は、最も重要です。もし1つの章だけを読むのであれば、この章でしょう。もし前の章でライブコーディングの基礎を読んでいるのであれば、`live_loop`は、それと同じことを少ないコード量で簡単に実現できる方法と言えます。

en: If you didn't read the previous section, `live_loop` is the best way to jam with Sonic Pi.
ja: 前の章を読んでいない場合、`live_loop`はSonic Piでジャム（即興演奏）するための最良の方法でしょう。

en: Let's play. Write the following in a new buffer:
ja: 演奏してみましょう。新しいBufferに次のように書いてください。

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.
ja: `Run`ボタンを押してください。1拍毎に基本的なビープ音が鳴ります。これでは楽しくないのですが、まだ`Stop`を押さないでください。`60`を`65`へ変更して、`Run`ボタンを押してください。

en: Woah! It changed *automatically* without missing a beat. This is live coding.
ja: わお！ リズムを崩さずに*自動的に*変化しました。これがライブコーディングです。

en: Why not change it to be more bass like? Just update your code whilst it's playing:
ja: もっとベースのように変えてみてはどうでしょう？ 演奏したままコードを更新しましょう。

en: Then hit Run.
ja: ここで*Run*ボタンを押してください。

en: Let's make the cutoff move around:
ja: カットオフを動かしてみましょう。

en: Hit Run again.
ja: `Run`ボタンをもう一度押しましょう。

en: Add some drums:
ja: ドラムを追加してみましょう。

en: Change the note from `e1` to `c1`:
ja: `e1`から`c1`に音符を変更してみましょう。

en: Now stop listening to me and play around yourself! Have fun!
ja: このあとは私の言うことを聞くのを止めて、自由に演奏してみましょう！ 楽しんでください！

en: 9.3 Multiple Live Loops
ja: 9.3 マルチ・ライブループ

en: Multiple Live Loops
ja: マルチ・ライブループ

en: Consider the following live loop:
ja: 次のライブループを考えていきましょう。

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.
ja: なぜ`:foo`という名前をつける必要があるか疑問を持つかもしれません。この名前は、このライブループが他のすべてのライブループと異なっていることを示すために重要です。

en: *There can never be two live loops running with the same name*.
ja: *同じ名前で実行中の2つのライブループが存在することはできません*。

en: This means that if we want multiple concurrently running live loops, we just need to give them different names:
ja: これは、複数同時にライブループを実行したい場合、それぞれに異なる名前を付ける必要があることを意味します。

en: You can now update and change each live loop independently and it all just works.
ja: 各ライブループを個別に変更し更新できます。そしてすべてちゃんと動作します。

en: Syncing Live Loops
ja: ライブループの同期

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.
ja: 既に気づいているかもしれませんが、ライブループは、以前に見てきたスレッドのcueのメカニズムを使用して自動的に動作します。ライブループがループするたびに、それが新しい名前を持つライブループの`cue`を生成します。これにより、`cue`をきっかけに何も停止せずにサウンドのループを同期させることができます。

en: Consider this badly synced code:
ja: 次のような同期されていないコードを考えてみましょう。

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:
ja: それを停止することなくタイミングと同期を修正することができるかを見てみましょう。まずは、`foo`ループ内の`sleep`の引数を0.5に変えてみましょう。

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:
ja: まだ終わりではないですね。あなたはビートがまったく合っていないことに気付くでしょう。これはループが*ずれて*いるからです。他と同期するように、それを修正していきましょう。

en: Wow, everything is now perfectly in time - all without stopping.
ja: おおー、すべてを停止することなく完璧に同期しましたね。

en: Now, go forth and live code with live loops!
ja: さあ、ライブループを使ってライブコーディングを始めましょう！

en: 9.4 Ticking
ja: 9.4 チック

en: Ticking
ja: チック

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.
ja: ライブコーディングでリングをループしていて、気が付くとたくさんのことをしていたことはないでしょうか。例えば、メロディーの音符、リズムのためのスリープ時間、コード進行や音色のバリエーションなどをリングに入れたり。

en: Ticking Rings
ja: リングのチック

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:
ja: Sonic Piは`live_loop`の中でリングと一緒に使える*とても*手軽なツールを提供しています。それはチックシステムと呼ばれ、*tick through rings（リングをチックタックと進める）* 機能を提供しています。次の例を見てください。

en: This is equivalent to:
ja: 上のコードは次のコードと同じです。

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:
ja: ここでは、E3マイナーペンタトニックのスケールを作成し、各要素をチックしています。これは、`.tick`を`scale`の呼び出しの末尾に追加することによって実現されています。チックはライブループの中でローカルであるため、個々のライブループは別々のチックを持つことができます。

en: Tick
ja: 標準関数としてのチック

en: You can also call `tick` as a standard fn and use the value as an index:
ja: `tick`はまた標準関数としても呼ぶことができ、その値はインデックスとして使うことができます。

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.
ja: しかし、この場合は`.tick`を呼ぶほうが良いでしょう。`tick`関数の用途は、チックの値で手の込んだことをしたかったり、リングのインデックス以外にチックの値を使いたかったりする場合ではないでしょうか。

en: Look
ja: ルック

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.
ja: チックの魅力的なところは、それが新しいインデックス（もしくはそのインデックスにあるリングの値）を返すだけでなく、次にチックを呼んだときに必ず次の値を返すことを保証していることでしょう。このようなチックの動作は、様々な形で`tick`のドキュメントの例で見ることができるでしょう。しかし、ここで、チックの現在の値を見たいだけで、値を*増加させたくない*の場合もあることを指摘することは重要でしょう。これは`look`関数により実現可能です。`look`は、標準関数として呼んだり、リングの後ろに`.look`を付けたりできます。

en: Naming Ticks
ja: チックの名前付け

en: Finally, sometimes you'll need more than one tick per live loop. This is achieved by giving your tick a name:
ja: 最後に、1つのライブループに複数のチックが必要になることがあるかもしれません。これはチックに名前を付けることで実現できます。

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`.
ja: ここでは2つのチックを使っていて、1つは音符用に、もう1つはスリープ時間用にしています。これらのチックは同じライブループにあるので、別々にしておくためにユニークな名前を与えています。これはちょうど`live_loop`に名前を付ける（`:`から始まるシンボル名を渡すだけ）のと同じことです。上の例では1つは`:foo`でチックを呼び出し、もう1つは`:bar`で呼び出しています。また、これらの値を`look`したい場合には、チックの名前を`look`に渡す必要があります。

en: Don't make it too complicated
ja: 複雑にしすぎないように

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.
ja: チックシステムの能力のほどんどは、最初のうちは役に立たないでしょう。このセクションの全ての内容を学習しようとしないでください。1つのリングでチックすることだけに集中するとよいでしょう。そうすることで、`live_loop`でリングをチックする簡単さや楽しみを得ることができるでしょう。

en: Take a look at the documentation for `tick` where there are many useful examples and happy ticking!
ja: `tick`のドキュメントには役に立つ例がたくさんあるので、それを見て楽しくチックを使ってみましょう！

en: Sonic Pi has a global memory store called Time State. The two main things you do with it are to `set` information and `get` information. Let's dive deeper...
ja: Sonic PiにはTime Stateというグローバルなメモリ領域があります。主に、情報を`set`したり、情報を`get`したりするためのものです。詳しく見てみましょう。

en: To store information into the Time State we need two things:
ja: Time Stateに情報を保存するためには2つのことが必要です。

en: the information we want to store,
ja: 保存したい情報と、

en: a unique name (key) for the information.
ja: その情報のための独自の名前(キー)です。

en: For example, we might want to store the number `3000` with the key `:intensity`. This is possible using the `set` function:
ja: 例えば、`3000`という数字を`:intensity`というキーで保存したいことがあるかもしれません。 これは`set`関数を使うことで可能になります。

en: We can use any name for our key. If information has already been stored with that key, our new `set` will override it:
ja: キーにはどんな名前でも使うことができます。そのキーですでに情報が保存されている場合は新しい`set`関数によって上書きすることができます。

en: Pattern Matching
ja: パターン マッチング

en: Match any path segment
ja: あらゆるpath要素へのマッチ

en: Let's assume we want to wait for the next event that has three path segments:
ja: pathが3つに区切られている次のイベントを待ちたいとしましょう。

en: This will match any Time State event with exactly three path segments, regardless of their names. For example:
ja: このパターンはちょうど3つの区分を持つpathならば, その区分の名前に関わらずどんなTime Stateイベントにもマッチします。 例えば:

en: However, it will *not* match paths with fewer or more path segments. The following will not match:
ja: しかし、区分の数が少なかったり多かったりするpathにはマッチしません。 例えば以下のものにはマッチしないでしょう:

en: Each `*` means *any content*. So we could match paths with just one segment with `/*` or paths with five segments with `/*/*/*/*/*`
ja: それぞれの`*`は「あらゆるもの」を意味しています。 なので、区分が一つだけのpathには `/*` でマッチでき、5つの区分を持つpathには次のパターンでマッチできます: `/*/*/*/*/*`

en: Matching partial segments
ja: 部分的なパス要素へのマッチング

en: However, it wouldn't match the following:
ja: しかし、以下のものにはマッチしないでしょう：

en: Matching Nested Path Segments
ja: ネストされたpath要素へのマッチ

en: Matching Single Letters
ja: 一文字へのマッチング

en: You can use the `?` character to match against a single char such as `"/?oo/bar/baz"` which will match:
ja: 1文字へのマッチングには `?` の文字を使うことができ、`"/?oo/bar/baz"` は次のようにマッチします:

en: Matching Multiple Words
ja: 複数の文字へのマッチング

en: Matching Multiple Letters
ja: 複数の文字へのマッチング

en: OSC Pattern Matching
ja: OSC パターンマッチング

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:
ja: さて、コードを音楽に変換することをマスターしたあなたはこう思うかもしれません—次は何をすればいいんだろう？ Sonic Piの構文やサウンドシステムの中で作業するという制約は時に刺激的で、新しい創造性をもたらすこともあるでしょう。しかし、コードを現実世界に持ち出すことも時には必要なのです。私たちが欲しいのは次の2つの追加要素です：

en: To be able to convert actions in the real world into Sonic Pi events to code with
ja: 現実世界での行動をSonic Piのイベントに変換し、コーディングできるようになること

en: 11.1 MIDI In
ja: 11.1 MIDI入力

en: MIDI In
ja: 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!
ja: この章では、MIDIコントローラを接続し、シンセや音をコントロールするためにSonic Piへイベントを送信する方法を学びます。キーボード、またはコントローラを接続して実際に動かしてみましょう！

en: Connecting a MIDI Controller
ja: MIDIコントローラーの接続

en: For example, you could write a program in another programming language which sends and receives OSC (there are OSC libraries for pretty much every common language) and work directly with Sonic Pi. What you can use this for is only limited by your imagination.
ja: 例えば, OSCを送受信するプログラムを別の言語で書いてSonicPiと直接つなげて動かすことができます(多くの言語にはOSCのライブラリがあります)。 これをどう使うかはみなさんの想像次第というわけです。

en: Receiving from External Machines
ja: 外部マシンから受信する

en: Conclusions
ja: おわりに

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.
ja: これでSonic Pi入門のチュートリアルを終了します。皆さんがここに至るまでに何かを学べたと願っています。すべてを理解していなくても心配せずに、演奏を楽しんでください。そうすれば、あなたのペースで習得できるはずです。何か疑問点があれば、チュートリアルのどこかに書いてあるかもしれないので、気軽に戻って読み直してみてください。

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.
ja: 最後に、ヘルプシステムのドキュメントをより深くチェックすることをお勧めします。このチュートリアルでは紹介していない機能がいくつかあるので、新たな発見が待っているでしょう。

en: So play, have fun, share your code, perform for your friends, show your screens and remember:
ja: 遊んで、楽しんで、コードを共有して、そしてスクリーンを見せながら、友人のために演奏してください。そして思い出してください。

en: *There are no mistakes, only opportunities.*
ja: *間違いはない、あるのはただ可能性だけ*

en: A Appendix A - MagPi Articles
ja: A 付録A - MagPi掲載記事

en: MagPi Articles
ja: MagPi掲載記事

en: Appendix A collects all the Sonic Pi articles written for the MagPi magazine.
ja: 付録Aは、雑誌MagPiのために書かれたSonic Piの記事を集録しています。

en: Dive into Topics
ja: トピックに進む

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.
ja: 付録に集録されている記事は、決まった順序で読むように意図されたものではなく、またチュートリアルとの重複した内容も数多く含まれています。これらの記事は、Sonic Piの全てを紹介するというよりは、Sonic Piの特定の面にフォーカスし、分かりやすく、また楽しく紹介しています。

en: Read the MagPi
ja: 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/
ja: MagPiは、美しく活字化されたPDFファイルを以下のサイトから無料でダウンロードできます。https://www.raspberrypi.org/magpi/

en: Suggest a Topic
ja: トピックを提案する

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!
ja: もしあなたが関心があってこれらのMagPiの記事で紹介されていないトピックがあったら、提案してみてはどうでしょう？ 最も簡単な方法は、提案を[@Sonic_Pi](http://twitter.com/sonic_pi)宛にツイートすることです。あなたの提案が次のMagPiの記事のテーマになるかもしれないのです！

en: A.1 Tips for Sonic Pi
ja: A.1 Sonic Piのためのヒント

en: Five Top Tips
ja: トップ5のヒント

en: 1. There are no mistakes
ja: 1. 間違いはない

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.
ja: Sonic Piで学ぶ最も重要な教訓は、*間違いはない*ということです。Sonic Piの一番の習得方法は、繰り返し試してみることです。いろんなことを試し、コードから出る音が良いか悪いか気にするのをやめ、できるだけ異なるシンセ、異なる音符、異なるエフェクト、異なるオプションを実験してみましょう。とてもひどくて笑ってしまうものも数多くある一方で、宝石のような本当に素晴らしい音もあるでしょう。そして、単純にあなたの好みの音は取っておき、そうでないものは捨ててしまえばよいのです。より多くの`間違い`をすればするほど、あなたにしか出来ないコーディング音楽をより早く発見し、習得できるに違いありません。

en: 2. Use the FX
ja: 2. エフェクトを使う

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:
ja: `sample`や`play`といったSonic Piの音作りの基本をマスターしたとして、次はどうしよう？ Sonic Piには、あなたのコードの音を変えることができる27を超えるスタジオ・エフェクトがあるのを知っていますか？ エフェクトは、ドローソフトの派手なイメージフィルタと同じようなものです。ただし、イメージフィルタがぼかしを入れたり、白黒にしたりするのに対し、エフェクトは音にリバーブやディストーション、エコーなどを追加します。それはちょうどギターからエフェクトペダルにケーブルを差して、さらにアンプに差すようなものと考えるとよいでしょう。幸いにも、Sonic Piではエフェクトが本当に簡単になっていて、ケーブルも必要としないのです！ あなたのやることは、エフェクトを追加したいコード領域を選択し、エフェクトのコードで包むだけです。たとえば、次のようなコードがあったとしましょう。

en: If you wanted to add FX to the `:loop_garzul` sample, you'd just tuck it inside a `with_fx` block like this:
ja: `:loop_garzul`のサンプルにエフェクトを追加したい場合には、次のように`with_fx`に押し込むだけでよいのです。

en: Now, if you wanted to add FX to the bass drum, go and wrap that with `with_fx` too:
ja: では次にバスドラムにエフェクトを追加したい場合には、同じように`with_fx`で包んでみましょう。

en: Remember, you can wrap *any* code within `with_fx` and any sounds created will pass through that FX.
ja: *どんな*コードでも`with_fx`で包めば、どんな音もそのままエフェクトに送られることを覚えておくとよいでしょう。

en: 3. Parameterise your synths
ja: 3. オプションを使う

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:
ja: もしあなた自身のコーディング音楽を本当に発見したい場合に、あなたはすぐにシンセやエフェクトを変更したり制御する方法を知りたくなるに違いありません。たとえば、音符の長さを変更したり、リバーブをもっと追加したり、エコーの間隔を変更したりしたいかもしれません。幸いにも、Sonic Piでは驚くべきレベルの制御の方法が提供されていて、オプション・パラメータ、略してオプションと呼ばれる特別な仕組みによって、まさしくこれと同じことが可能です。ちょっと見てみましょう。以下のコードをBufferにコピーして実行してみましょう。

en: Ooh, a lovely guitar sound! Now, let's start playing with it. How about changing its rate?
ja: おお、すてきなギターサウンドですね！ では、これで遊んでみましょう。レートを変えてみるのはどうでしょう？

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:
ja: 行の最後にちょっと付けた`rate: 0.5`は何だろう？ これはオプションと呼ばれています。Sonic Piの全てのシンセとエフェクトはオプションをサポートしていて、たくさんのオプションで遊べます。エフェクトでもオプションは利用可能です。次を試してみましょう。

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:
ja: Sonic Piについて素早く調べてみたり実験したりする一番の方法は、ライブコーディングすることです。ライブコーディングにより、あるコードから演奏を開始して、演奏を止めずに継続してコードをいじったり、変更したりできます。たとえば、`sample`でcutoffのオプションがどのように動作するか分からない場合には、ただ実行してみればよいのです。では試し見てみましょう！ 以下のコードをSonic PiのBufferにコピーしてみましょう。

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`...
ja: 実行すると、こもった音のドラムブレイクを聞くことができるでしょう。では、`cutoff:`の値を`80`に変更して再度実行してみましょう。違いが分かりますか？ `90`, `100`, `110`も試してみましょう。

en: Once you get the hang of using `live_loop`s you'll not turn back. Whenever I do a live coding gig I rely on `live_loop` as much as a drummer relies on their sticks. For more information about live coding check out Section 9 of the built-in tutorial.
ja: `live_loop`を一度使い始めると、`live_loop`を使わないコードに戻れなくなるでしょう。ドラマーがスティックを頼りにするのと同じように、私もライブコーディングするときはいつも`live_loop`を頼りにしています。ライブコーディングについての詳細は、チュートリアルの9章をチェックしてみてください。

en: 5. Surf the random streams
ja: 5. ランダムストリームに乗る

en: Finally, one thing I love doing is cheating by getting Sonic Pi to compose things for me. A really great way to do this is using randomisation. It might sound complicated but it really isn't. Let's take a look. Copy this into a spare workspace:
ja: 最後に、私が好きでよくやるのは、Sonic Piに作曲してもらうズルい方法です。これを実現する本当に卓越した方法は、ランダム化を使用することです。ランダム化と言うと複雑そうに聞こえるかもしれませんが、実際にはそうでもありません。少し見てみましょう。以下のコードをBufferにコピーしてください。

en: Now, when you play this, you'll hear a constant stream of random notes from the scale `:e2 :minor_pentatonic` played with the `:dsaw` synth. "Wait, wait! That's not a melody", I hear you shout! Well, here's the first part of the magic trick. Every time we go round the `live_loop` we can tell Sonic Pi to reset the random stream to a known point. This is a bit like going back in time in the TARDIS with the Doctor to a particular point in time and space. Let's try it - add the line `use_random_seed 1` to the `live_loop`:
ja: ここで、上記のコードを実行すると、`:e2 :minor_pentatonic`のスケールから選ばれた音符の絶え間ないランダムな流れが、`:dsaw`のシンセで再生されるのを聞くことができるでしょう。「待って！ これはメロディーじゃない」とあなたが叫んでいるのが想像できます。落ち着いてください。これはマジックのトリックの前半部分です。Sonic Piでは、`live_loop`を繰り返す度に、特定の位置にランダムストリームをリセットするように指示することができます。それは、「Dr. Who」に登場するタイムマシンのTARDISが、特定の時間と場所に辿り着くのとちょっと似ています。ではやってみましょう。`live_loop`に`use_random_seed 1`の行を追加してみてください。

en: Now, every time the `live_loop` loops around, the random stream is reset. This means it chooses the same 16 notes every time. Hey presto! An instant melody. Now, here's the really exciting bit. Change the seed value from `1` to another number. Say `4923`. Wow! Another melody! So, just by changing one number (the random seed), you can explore as many melodic combinations as you can imagine! Now, that's the magic of code.
ja: これで、`live_loop`がループする度に、ランダムストリームがリセットされるようになりました。これは、ループの度に同じ16の音符が選択されていることを意味しています。あら不思議！ 手軽なメロディーでしょう。ここからが本当に面白くなるところです。シードの値を`1`から別な数値、たとえば`4923`に変更してみましょう。ワオ！ 別なメロディーになったでしょう！ 1つの数字（ランダムシード）を変更するだけで、あなたの想像する限り多くのメロディーの組合せを試すことができるのです！ これがコードのマジックなのです。

en: A.2 Live Coding
ja: A.2 ライブコーディング

en: This may sound like a far fetched story from a futuristic night club but coding music like this is a growing trend and is often described as Live Coding (http://toplap.org). One of the recent directions this approach to music making has taken is the Algorave (http://algorave.com) - events where artists like myself code music for people to dance to. However, you don't need to be in a nightclub to Live Code - with Sonic Pi v2.6+ you can do it anywhere you can take your Raspberry Pi and a pair of headphones or some speakers. Once you reach the end of this article, you'll be programming your own beats and modifying them live. Where you go afterwards will only be constrained by your imagination.
ja: これは未来のクラブの現実的でない話のように聞こえるかもしれませんが、音楽をコーディングすることは盛り上がりつつあるトレンドであり、しばしばライブコーディング（http://toplap.org）と呼ばれています。この音楽制作アプローチの最近の流れの1つは、Algorave（http://algorave.com）です。私のようなアーティストが、人々をダンスさせるために音楽をコーディングするイベントです。しかし、ライブコーディングするのにクラブに居る必要はありません。Sonic Pi v2.6以上では、ヘッドホンやスピーカーとRaspberry Piを持っていける場所であればどこでも、ライブコーディングができます。一度この記事を最後まで読めば、あなた自身のビートをプログラミングでき、それをライブで変更できるでしょう。その後どこに進むかは、あなたのイマジネーションにだけ制約されるでしょう。

en: Live Loop
ja: ライブループ

en: The key to live coding with Sonic Pi is mastering the `live_loop`. Let's look at one:
ja: Sonic Piでライブコーディングする鍵は、`live_loop`をマスターすることです。次のコードを見てみましょう。

en: Redefining On-the-fly
ja: その場で再定義する

en: Ok, so what's so special about the `live_loop`? So far it just seems like a glorified `loop`! Well, the beauty of `live_loop`s is that you can redefine them on-the-fly. This means that whilst they're still running, you can change what they do. This is the secret to live coding with Sonic Pi. Let's have a play:
ja: では、`live_loop`の何が特別なのでしょう？ 見たところ`loop`にそっくりですね！ ええと、`live_loop`の利点は、その場で再定義できることです。これは、ライブループが実行されている間にも、その中でやっていることが変更できるということです。これがSonic Piのライブコーディングの秘訣です。試してみましょう。

en: Sleeping is important
ja: 休みは大切

en: One of the most important lessons about `live_loop`s is that they need rest. Consider the following `live_loop`:
ja: `live_loop`に関する最も重要な教訓の1つは、それを*休ませる*ことが必要だということです。次の`live_loop`を考えてみましょう。

en: If you try running this code, you'll immediately see Sonic Pi complaining that the `live_loop` did not sleep. This is a safety system kicking in! Take a moment to think about what this code is asking the computer to do. That's right, it's asking the computer to play an infinite amount of choir samples in zero time. Without the safety system the poor computer will try and do this and crash and burn in the process. So remember, your `live_loop`s must contain a `sleep`.
ja: このコードを実行しようとすると、`live_loop`が`sleep`していないとSonic Piがエラーを出すでしょう。これはセーフティシステムが実行されたことを示しています。このコードがコンピュータに何を実行させようとしているか、少し考えてみてください。そうです。無限の数のコーラスのサンプルを0秒の間に再生するように指示してるのですね。もしセーフティシステムが無ければ、コンピュータはこれを実行しようして壊れてしまうでしょう。そんな訳で、`live_loop`には必ず`sleep`を含めることを覚えておいてください。

en: Combining Sounds
ja: 音を混ぜ合わせる

en: Music is full of things happening at the same time. Drums at the same time as bass at the same time as vocals at the same time as guitars... In computing we call this concurrency and Sonic Pi provides us with an amazingly simple way of playing things at the same time. Simply use more than one `live_loop`!
ja: 音楽は同時に発生する事象で溢れています。ギターとボーカルが同時に鳴っているところにベースが同時に鳴り、それらと同時にドラムが鳴るといったように…計算機の世界ではこれを*並行性*と呼び、Sonic Piも驚異的にシンプルな方法で同時に演奏することができます。単純に1つより多い`live_loop`を使えばよいのです。

en: One of the interesting things about using multiple `live_loop`s is that they each manage their own time. This means it's really easy to create interesting polyrhythmical structures and even play with phasing Steve Reich style. Check this out:
ja: 複数の`live_loop`を使った場合に興味深いのは、それぞれのループがそれぞれの時間を管理しているということです。これは、とても簡単にポリリズム的な構造を作ることを意味していて、スティーヴ・ライヒのような位相のずれを演奏することも簡単にできます。以下を見てください。

en: Bringing it all together
ja: まとめ

en: In each of these tutorials, we'll end with a final example in the form of a new piece of music which draws from all of the ideas introduced. Read this code and see if you can imagine what it's doing. Then, copy it into a fresh Sonic Pi buffer and hit Run and actually hear what it sounds like. Finally, change one of the numbers or comment and uncomment things out. See if you can use this as a starting point for a new performance, and most of all have fun! See you next time...
ja: これらの個々のチュートリアルで紹介したアイデアの全てから引き出された新しい楽曲の例で終わりにしたいと思います。以下のコードを読んで、何をしているか想像してみてください。次に、それをSonic Piの新しいBufferにコピーし、`Run`を叩いて実際にどんな音がするか聞いてみましょう。最後に、どれかの数値を変更したり、コードをコメントアウトしたりコメントインしたりしてみましょう。そして、このコードが新しいパフォーマンスの開始点として使えるか見てみましょう。これらはとても楽しいと思います！ ではまた会いましょう。

en: A.3 Coded Beats
ja: A.3 コード化されたビート

en: Coded Beats
ja: コード化されたビート

en: One of the most exciting and disrupting technical developments in modern music was the invention of samplers. These were boxes that allowed you to record any sound into them and then manipulate and play back those sounds in many interesting ways. For example, you could take an old record, find a drum solo (or break), record it into your sampler and then play it back on repeat at half-speed to provide the foundation for your latest beats. This is how early hip-hop music was born and today it's almost impossible to find electronic music that doesn't incorporate samples of some kind. Using samples is a really great way of easily introducing new and interesting elements into your live coded performances.
ja: 現代の音楽における技術的な発展で最も刺激的かつ飛躍的なものの1つは、サンプラーの発明だったと言えます。サンプラーは、あらゆる音を記録し、操作し、そしてさまざまな方法でこれらのサウンドを再生することができる箱です。たとえば、もしあなたが古いレコードを持っていたとして、そこからドラムソロ（もしくはブレイク）を探しだし、サンプラーに記録して半分の速度で再生すれば、あなたの作品のビートの下地として利用可能です。これはどのように初期のヒップホップが生まれたかを示すものですが、今日の電子音楽でこのようなサンプルを含まないものを探すことは、ほぼ不可能でしょう。サンプルを使用することは、あなたのライブコーディングのパフォーマンスに、新しく面白い要素を簡単に追加する本当に素晴らしい方法です。

en: So where can you get a sampler? Well you already have one - it's your Raspberry Pi! The built-in live coding app Sonic Pi has an extremely powerful sampler built into its core. Let's play with it!
ja: ではサンプラーはどこにあるのでしょう？ サンプラーは既にRaspberry Piの中にあります！ Raspberry Piに同梱されたSonic Piはとてもパワフルなサンプラーを内蔵しています。これで遊んでみましょう！

en: The Amen Break
ja: アーメン・ブレイク

en: One of the most classic and recognisable drum break samples is called the Amen Break. It was first performed in 1969 in the song "Amen Brother" by the Winstons as part of a drum break. However, it was when it was discovered by early hip-hop musicians in the 80s and used in samplers that it started being heavily used in a wide variety of other styles such as drum and bass, breakbeat, hardcore techno and breakcore.
ja: 古典的でよく知られたドラムブレイクはアーメン・ブレイクと呼ばれるものです。アーメン・ブレイクは、Winstonsによって1969年に"Amen Brother"という曲で、ドラムブレイクの一部として演奏されました。しかし、それは初期のヒップホップミュージシャンによって80年代に発見されてサンプラーで使用された後、ドラムンベース、ブレイクビート、ハードコア・テクノ、ブレイクコアといった他の幅広いジャンルでも頻繁に使用されるようになりました。

en: I'm sure you're excited to hear that it's also built right into Sonic Pi. Clear up a buffer and throw in the following code:
ja: アーメン・ブレイクがSonic Piにも内蔵していると聞いて、あなたがワクワクしてくれると思っています。Bufferをきれいにして、次のコードを入力してみてください。

en: Hit *Run* and boom! You're listening to one of the most influential drum breaks in the history of dance music. However, this sample wasn't famous for being played as a one-shot, it was built for being looped.
ja: *Run*を叩いて、ブーンとやってみてください！ ダンスミュージックの歴史で最も影響力のあったドラムブレイクの1つを聞くことができるでしょう。しかし、これは1回限りで演奏されることよりも、ループとして演奏されることで有名です。

en: Beat Stretching
ja: ビートを引き延ばす

en: Let's loop the Amen Break by using our old friend the `live_loop` introduced in this tutorial last month:
ja: 先月のチュートリアルで紹介した、我々にはもうお馴染みの`live_loop`を使って、アーメン・ブレイクをループしてみましょう。

en: OK, so it is looping, but there's an annoying pause every time round. That is because we asked it to sleep for `2` beats and with the default BPM of 60 the `:loop_amen` sample only lasts for `1.753` beats. We therefore have a silence of `2 - 1.753 = 0.247` beats. Even though it's short, it's still noticeable.
ja: ループはしていますね。でもループする度に不快な無音部分がありますね。これは、`2`拍sleepするように指示しているのに、`:loop_amen`のサンプルは、デフォルトのBPM60で`1.753`拍しか持続しないからです。したがって、`2 - 1.753 = 0.247`拍の無音が発生していしまいます。その時間は短くはありますが、容易に気づくことができます。

en: To fix this issue we can use the `beat_stretch:` opt to ask Sonic Pi to stretch (or shrink) the sample to match the specified number of beats.
ja: この問題を解決するのに、`beat_stretch:`オプションを使うことができます。このオプションは、指定した数値の拍に合うようにサンプルを引き延ばす（あるいは縮める）ことを、Sonic Piに指示します。

en: Sonic Pi's `sample` and `synth` fns give you a lot of control via optional parameters such as `amp:`, `cutoff:` and `release:`. However, the term optional parameter is a real mouthful so we just call them *opts* to keep things nice and simple.
ja: Sonic Piの`sample`と`synth`関数は、`amp:`や`cutoff:`、`release:`といったオプション引数によって、数多くの操作を提供しています。しかし、オプション引数という言葉は言いにくいので、単純にするために*オプション*と呼ぶようにします。

en: Now we're dancing! Although, perhaps we want to speed it up or slow it down to suit the mood.
ja: これでダンスできますね！ だけど、おそらく雰囲気に合わせてこのサンプルを速くしたり遅くしたりしたいと思うのではないでしょうか。

en: Playing with Time
ja: 時間に合わせて演奏する

en: OK, so what if we want to change styles to old school hip hop or breakcore? One simple way of doing this is to play with time - or in other words mess with the tempo. This is super easy in Sonic Pi - just throw in a `use_bpm` into your live loop:
ja: では、オールドスクールのヒップホップやブレイクコアのスタイルに変更したい場合にはどうしたら良いでしょう。それを実現する簡単な方法は、時間に合わせて演奏することです。言い換えると、テンポを操作するということです。これは、Sonic Piではとても簡単です。`use_bpm`をライブループに入れるだけでよいのです。

en: Whilst you're rapping over those slow beats, notice that we're still sleeping for 2 and our BPM is 30, yet everything is in time. The `beat_stretch` opt works with the current BPM to make sure everything just works.
ja: この遅いビートでラップしている間に、BPM30であっても2拍sleepして全てが時間通りであることに気がつくと思います。全てがただ時間通りに動くように、`beat_stretch`オプションが現行のBPMと協調して動作しているのです。

en: Filtering
ja: フィルタリング

en: Now we can live loop samples, let's look at some of the most fun opts provided by the `sample` synth. First up is `cutoff:` which controls the cutoff filter of the sampler. By default this is disabled but you can easily turn it on:
ja: サンプルをライブループできるようになったので、`sample`で提供されている楽しいオプションを見ていきましょう。最初は、`cutoff:`です。これはサンプラーのカットオフ・フィルタを操作します。このオプションはデフォルトでは無効になっていますが、簡単に有効にできます。

en: Go ahead and change the `cutoff:` opt. For example, increase it to 100, hit *Run* and wait for the loop to cycle round to hear the change in the sound. Notice that low values like 50 sound mellow and bassy and high values like 100 and 120 are more full-sounding and raspy. This is because the `cutoff:` opt will chop out the high frequency parts of the sound just like a lawn-mower chops off the top of the grass. The `cutoff:` opt is like the length setting - determining how much grass is left over.
ja: 続いて`cutoff:`オプションを変更してみましょう。たとえば100に変更後*Run*を叩いて、どう音が変化するかループの終わりまで聞いてみてください。50のような小さい値はメロウで低音が強調され、100や120といった大きい値は、より幅広い音が聞こえ、ザラザラとしていることに気付くでしょう。これは`cutoff:`オプションが、ちょうど草刈機が芝生を刈るように、高い周波数の部分を削り取るからです。`cutoff:`オプションは長さの設定（どれだけ芝生を残すか）のようなものです。

en: Slicing
ja: スライスする

en: Another great tool to play with is the slicer FX. This will chop (slice) the sound up. Wrap the `sample` line with the FX code like this:
ja: もう1つの遊んでみるべき凄いツールは、スライサー・エフェクトです。これは音をブツ切り（スライス）にします。`sample`の行を次のようにスライサー・エフェクトで包んでみましょう。

en: Finally, let's go back in time and revisit the early Bristol drum and bass scene with this month's example. Don't worry too much about what all this means, just type it in, hit Run, then start live coding it by changing opt numbers and see where you can take it. Please do share what you create! See you next time...
ja: 最後に、今月の例として、時代を遡って初期のブリストルのドラムンベースシーンを再訪してみましょう。あまり上記の意味するところは気にせずに、ただコードをタイプして実行し、オプションの値を変更してライブコーディングを開始して、どのような音になるか聞いてみましょう。そして、あなたの作ったものを是非共有してください！ ではまた。

en: A.4 Synth Riffs
ja: A.4 シンセ・リフ

en: Synth Riffs
ja: シンセ・リフ

en: Whether it's the haunting drift of rumbling oscillators or the detuned punch of saw waves piercing through the mix, the lead synth plays an essential role on any electronic track. In last month's edition of this tutorial series we covered how to code our beats. In this tutorial we'll cover how to code up the three core components of a synth riff - the timbre, melody and rhythm.
ja: リードシンセは、たとえそれがゴロゴロ鳴るオシレーターの浮遊であったり、ミックスを通して耳をつんざくようなデチューンされたノコギリ波であったしても、あらゆる電子音楽において不可欠な役割を果たしています。先月の記事では、ビートをどのようにコーディングするかについて紹介しました。今月の記事では、シンセ・リフの3つのコアな要素、すなわち、その音色、メロディー、リズムをどのようにコーディングするかについて紹介したいと思います。

en: OK, so power up your Raspberry Pi, crack open Sonic Pi v2.6+ and let's make some noise!
ja: では、Raspberry Piを起動し、v2.6以降のSonic Piを開いて、音を出してみましょう！

en: Timbral Possibilities
ja: 音色の可能性

en: An essential part of any synth riff is changing and playing with the timbre of the sounds. We can control the timbre in Sonic Pi in two ways - choosing different synths for a dramatic change and setting the various synth opts for more subtle modifications. We can also use FX, but that's for another tutorial...
ja: シンセ・リフに不可欠な要素は、音色で遊んだり変更したりすることです。Sonic Piでは、2つの方法で音色を操作することができます。劇的な変化として異なるシンセを選択することと、より微かな調整としてシンセのオプションの設定を変更することです。またエフェクトも使用できますが、これについては別なチュートリアルが必要そうです…

en: Let's create a simple live loop where we continually change the current synth:
ja: シンセを継続的に変更するシンプルなライブループを作ってみましょう。

en: Take a look at the code. We're simply ticking through a ring of synth names (this will cycle through each of these in turn repeating the list over and over). We pass this synth name to the `use_synth` fn (function) which will change the `live_loop`'s current synth. We also play note `:e2` (E at the second octave), with a release time of 0.5 beats (half a second at the default BPM of 60) and with the `cutoff:` opt set to 100.
ja: コードを見てみてください。ここでは、シンセの名前のリングを単純にチックしています（リングはリストを何度も繰り返すことで、シンセの名前を循環します）。そして、シンセの名前を`use_synth`関数に渡すことで、`live_loop`で使用するシンセを変更しています。また、`:e2`（2番目のオクターブのE）の音符を、リリースタイムを0.5拍（デフォルトBPMの60では0.5秒）、`cutoff:`オプションを100で演奏しています。

en: Hear how the different synths have very different sounds even though they're all playing the same note. Now experiment and have a play. Change the release time to bigger and smaller values. For example, change the `attack:` and `release:` opts to see how different fade in/out times have a huge impact on the sound. Finally change the `cutoff:` opt to see how different cutoff values also massively influence the timbre (values between 60 and 130 are good). See how many different sounds you can create by just changing a few values. Once you've mastered that, just head to the Synths tab in the Help system for a full list of all the synths and all the available opts each individual synth supports to see just how much power you have under your coding fingertips.
ja: 異なるシンセが、全く同じ音符を鳴らしているにもかかわらず、とても異なった音に聞こえるでしょう。では、実験して遊んでみましょう。リリースタイムを大きい値や小さい値に変更してみましょう。たとえば、`attack:`や`release:`オプションを変更して、フェードイン・フェードアウトの時間が音にとても大きなインパクトを与えるのを見てみましょう。最後に`cutoff:`オプションを変更して（60と130の間の値が良いでしょう）、カットオフの値もまた音色にとても大きな影響を与えるのを見てみましょう。いくつかの値を変更するだけで、多くの音を作り出せたのではないでしょうか。このことを一度修得してしまえば、ヘルプシステムの`シンセ`タブには全てのシンセの一覧と個々のシンセが利用可能な全てのオプションがあり、コーディングの際にすぐ利用できるでしょう。

en: Timbre
ja: 音色

en: Timbre is just a fancy word describing the sound of a sound. If you play the same note with different instruments such as a violin, guitar, or piano, the pitch (how high or low it sounds) would be the same, but the sound quality would be different. That sound quality - the thing which allows you to tell the difference between a piano and a guitar is the timbre.
ja: 音色とは、ある音がどう鳴っているかを表現する、ただの聞こえの良い言葉です。もしあなたがバイオリン、ギター、ピアノといった異なる楽器で同じ音符を演奏すると、音程（音が高いか低いか）は同じでも、音の質は違うでしょう。その音の質、つまりピアノとギターとの違いを指摘できるような内容、が音色です。

en: Melodic Composition
ja: メロディーの作曲

en: Another important aspect to our lead synth is the choice of notes we want to play. If you already have a good idea, then you can simply create a ring with your notes in and tick through them:
ja: リード・シンセで重要なもう1つの側面は、演奏する音符の選択です。もしあなたが良いメロディーのアイデアを既に持っていたら、単純にそれをリングに入れてチックしていくことができます。

en: Here, we've defined our melody with a ring which includes both notes such as `:e3` and rests represented by `:r`. We're then using `.tick` to cycle through each note to give us a repeating riff.
ja: ここでは、`:e3`といった音符と`:r`で表現される休符を含むリングでメロディーを定義しています。そして、リフが繰り返し演奏されるように、`.tick`を使ってリングを循環しています。

en: Auto Melody
ja: 自動メロディー

en: It's not always easy to come up with a nice riff from scratch. Instead it's often easier to ask Sonic Pi for a selection of random riffs and to choose the one you like the best. To do that we need to combine three things: rings, randomisation and random seeds. Let's look at an example:
ja: 良いリフを一から思いつくのは、いつも簡単であるとは限りません。ランダムなリフの生成をSonic Piにお願いして、出来たリフから一番良いと思うものを選ぶほうが、より簡単なケースが多いでしょう。これを実現するのに、次の3つのものが必要です。リングとランダム化とランダムシードです。例を見てみましょう。

en: There's a few things going on - let's look at them in turn. First, we specify that we're using random seed 3. What does this mean? Well, the useful thing is that when we set the seed, we can predict what the next random value is going to be - it's the same as it was last time we set the seed to 3! Another useful thing to know is that shuffling a ring of notes works in the same way. In the example above we're essentially asking for the 'third shuffle' in the standard list of shuffles - which is also the same every time as we're always setting the random seed to the same value right before the shuffle. Finally we're just ticking through our shuffled notes to play the riff.
ja: ここではいくつかのことが実行されています。順番に見ていきましょう。最初に、ランダムシードとしてここでは3を使っています。これは何を意味するのでしょうか？ そうですね、シードを設定することで便利な点は、次のランダム値が何になるか正確に予測できることです。つまり、最後にシードを3に設定したときと同じになります。もう1つ便利な点は、音符のリングのシャッフルでも同じように動作することです。上記の例では、標準的なシャッフルのリストの内の`3番目のシャッフル`を必然的に要求していることになります。これもシャッフルする直前に設定したランダムシードの値が同じであれば常に同じになります。最後に、シャッフルされた音符を単純にチックして、リフを演奏しています。

en: Now, here's where the fun starts. If we change the random seed value to another number, say 3000, we get an entirely different shuffling of the notes. So now it's extremely easy to explore new melodies. Simply choose the list of notes we want to shuffle (scales are a great starting point) and then choose the seed we want to shuffle with. If we don't like the melody, just change one of those two things and try again. Repeat until you like what you hear!
ja: ここからが面白くなるところです。ランダムシードを別な値、たとえば3000に変更すると、全く異なったシャッフルの音符が得られるでしょう。これは、新しいメロディーを探索する方法としては、極めて簡単でしょう。シャッフルしたい音符のリスト（スケールはとても良い出発点でしょう）を選択し、続いてシードを選択してみましょう。もし生成されたメロディーが気に入らなかったら、音符のリストかシードのいずれかを変更して、もう一度やってみましょう。気にいったものが生成されるまで、続けてみましょう！

en: Pseudo Randomisation
ja: 疑似ランダム化

en: Sonic Pi's randomisation is not actually random it's what's called pseudo random. Imagine if you were to roll a dice 100 times and write down the result of each roll onto a piece of paper. Sonic Pi has the equivalent of this list of results which it uses when you ask for a random value. Instead of rolling an actual dice, it just picks the next value from the list. Setting the random seed is just jumping to a specific point in that list.
ja: Sonic Piのランダム化は、実際には真のランダムではなく擬似ランダムと呼ばれるものです。サイコロを100回振ってその結果を紙切れに書いておくのを想像してみてください。Sonic Piは、その結果のリストと同等のものを持っていて、ランダムな値を要求されるとそれを使っています。実際のサイコロを振る代わりに、リストから次の値を単純に取得しているのです。そして、ランダムシードの設定は、リストの特定の場所に移動しているに過ぎません。

en: Finding your Rhythm
ja: リズムを発見する

en: Another important aspect to our riff is the rhythm - when to play a note and when not to. As we saw above we can use `:r` in our rings to insert rests. Another very powerful way is to use spreads which we'll cover in a future tutorial. Today we'll use randomisation to help us find our rhythm. Instead of playing every note we can use a conditional to play a note with a given probability. Let's take a look:
ja: リフで重要なもう1つの側面は、リズム（いつ音符を演奏していつ演奏しないのか）です。以前に、休符として`:r`をリングに使用できることを見たと思います。他の非常に強力な方法としては、`spread`関数を使う方法がありますが、これはいずれチュートリアルで扱いたいと思います。今回はリズムの発見にランダム化を使ってみたいと思います。全ての音符を演奏する代わりに、確率によってある特定の条件でのみ演奏することが可能です。次のコードを見てみましょう。

en: A really useful fn to know is `one_in` which will give us a `true` or `false` value with the specified probability. Here, we're using a value of 2 so on average one time every two calls to `one_in` it will return `true`. In other words, 50% of the time it will return `true`. Using higher values will make it return `false` more often introducing more space into the riff.
ja: 知ってると本当に便利な関数は、`one_in`でしょう。この関数は指定した確率に依存して`true`か`false`を返します。ここでは、引数として2を使用しているので、`one_in`を2回呼ぶ度に1回`true`を返します。言い換えると、50％の確率で`true`を返します。2よりも大きな値を使用すると`false`をより多く返し、リフにより多くの休符を与えるでしょう。

en: Notice that we've added some iteration in here with `16.times`. This is because we only want to reset our random seed value every 16 notes so our rhythm repeats every 16 times. This doesn't affect the shuffling as that is still done immediately after the seed is set. We can use the iteration size to alter the length of the riff. Try changing the 16 to 8 or even 4 or 3 and see how it affects the rhythm of the riff.
ja: また、ここで`16.times`という繰り返しが追加されていることに気づいたかもしれません。これは、16個の音符の度にランダムシードをリセットしたいためです。これにより、16回の繰り返しの度に、リフのリズムが繰り返されます。これはシャッフルには影響しません。なぜなら、それはシードを設定した直後に実行されているからです。リフの長さを変更するために、繰り返しのサイズを変更することができます。16という値を、8, 4, 3といった値に変更して、それがどのようにリフのリズムに影響するか見てみてください。

en: OK, so let's combine everything we've learned together into one final example. See you next time!
ja: 今回学習したことをまとめて最後の例としましょう。ではまた！

en: A.5 Acid Bass
ja: A.5 アシッドベース

en: Acid Bass
ja: アシッドベース

en: It's impossible to look through the history of electronic dance music without seeing the enormous impact of the tiny Roland TB-303 synthesiser. It's the secret sauce behind the original acid bass sound. Those classic squealing and squelching TB-303 bass riffs can be heard from the early Chicago House scene through to more recent electronic artists such as Plastikman, Squarepusher and Aphex Twin.
ja: エレクトロニック・ダンス・ミュージックの歴史を俯瞰する上で、ローランドTB-303の多大な影響を無視することは出来ないでしょう。それはアシッドベースサウンドの秘伝のタレであると言えます。古典的なTB-303のベースリフは、初期のシカゴハウスのシーンからPlastikman, SquarepusherやAphex Twinといったより最近の電子音楽のアーティストで聞くことができるでしょう。

en: Although getting your hands on an original TB-303 is not so easy you will be pleased to know that you can turn your Raspberry Pi into one using the power of Sonic Pi. Behold, fire up Sonic Pi and throw this code into an empty buffer and hit Run:
ja: オリジナルのTB-303を入手するのはとても困難ですが、Sonic Piの力でRaspberry PiをTB-303にすることが出来るのです。よく見ていてください。Sonic Piを起動して、空のBufferに以下のコードを打ち込んで、`Run`を打ってください。

en: Instant acid bass! Let's play around...
ja: とても簡単なアシッドベースですね！ これで遊んでみましょう…

en: First, let's build a live arpeggiator to make things fun. In the last tutorial we looked at how riffs can just be a ring of notes that we tick through one after another, repeating when we get to the end. Let's create a live loop that does exactly that:
ja: 最初に、音が面白くなるようにライブ・アルペジエーターを作ってみましょう。前回のチュートリアルで、リフが音符のリングで実現できるのを見ました。リングは、要素を次々と進めて行って（チックして）、末尾に達すると先頭に戻って繰り返します。それと同じことを実行するライブループを作ってみましょう。

en: Take a look at each line.
ja: 一行ごとに見て行きましょう。

en: On the first line we set the default synth to be `tb303` with the `use_synth` fn.
ja: 最初の行では、`use_synth`関数でデフォルトのシンセを`tb303`に設定しています。

en: On line two we create a live loop called `:squelch` which will just loop round and round.
ja: 2行目では、`:squelch`という名前のライブループを作って、単純にループを繰り返しています。

en: Line three is where we create our riff - a ring of notes (E in octaves 1, 2, and 3) which we simply tick through with `.tick`. We define `n` to represent the current note in the riff. The equals sign just means to assign the value on the right to the name on the left. This will be different every time round the loop. The first time round, `n` will be set to `:e1`. The second time round it will be `:e2`, followed by `:e3`, and then back to `:e1`, cycling round forever.
ja: 3行目ではリフを作っています。1, 2, 3番目のオクターブのEからなる音符のリングを`.tick`で単純に進めて行っています。リフの現在の音符を示すのに`n`を定義しています。等号は、単に右の値を左の名前に割り当てることを意味しています。この値はループが繰り返される度に異なります。最初の繰り返しでは、`n`は`:e1`に設定されています。2回目の繰り返しでは`:e2`になり、その次は`:e3`です。そして、その次には`:e1`に戻って、永遠に繰り返し循環しています。

en: Line four is where we actually trigger our `:tb303` synth. We're passing a few interesting opts here: `release:`, `cutoff:`, `res:` and `wave:` which we'll discuss below.
ja: 4行目では、実際に`:tb303`シンセをトリガーしています。ここで、いくつか興味深いオプションを渡しています。`release:`, `cutoff:`, `res:`と`wave:`です。これらについては、この後議論します。

en: Line five is our `sleep` - we're asking the live loop to loop round every `0.125`s or 8 times a second at the default BPM of 60.
ja: 5行目は`sleep`です。デフォルトBPMの60で、`0.125`秒毎または1秒間に8回ライブループを繰り返すよう指示しています。

en: Line six is the `end` to the live loop. This just tells Sonic Pi where the end of the live loop is.
ja: 6行目はライブループの`end`です。これは単にSonic Piにライブループの終わりの箇所を示しています。

en: Whilst you're still figuring out what's going on, type in the code above and hit the Run button. You should hear the `:tb303` kick into action. Now, this is where the action is: let's start live coding.
ja: このコードで何が起きているか思い描いている途中かもしれませんが、上記のコードをタイプして`Run`ボタンを叩いてみてください。`:tb303`が動作し始めるのを聞くことができるでしょう。では、ライブコーディングを始めましょう。

en: Whilst the loop is still live, change the `cutoff:` opt to `110`. Now hit the Run button again. You should hear the sound become a little harsher and more squelchy. Dial in `120` and hit run. Now `130`. Listen how higher cutoff values make it sound more piercing and intense. Finally, drop it down to `80` when you feel like a rest. Then repeat as many times as you want. Don't worry, I'll still be here...
ja: ライブループが動作している最中に、`cutoff:`オプションを`110`に変更して、`Run`ボタンを再度叩いてみてください。音がざらついて押しつぶされたように聞こえると思います。次に`120`に変更して`Run`を叩いてみてください。更に`130`はどうでしょう。より大きなカットオフの値が、よりけたたましく激しい音にしているのを聞くことができるでしょう。最後に、休みたくなったら`80`にしてみましょう。これらを好きなだけ繰り返してみてください。心配しないで。私はずっとここに居ますよ…

en: Finally, for a big impact on the timbre try changing the `wave:` opt to `1`. This is the choice of source oscillator. The default is `0` which is a sawtooth wave. `1` is a pulse wave and `2` is a triangle wave.
ja: 最後に、音色に大きなインパクトを与えるのに、`wave:`オプションを`1`に変更してみてください。これはオシレーターの選択です。デフォルトは`0`で、ノコギリ波です。`1`はパルス波で、`2`は三角波です。

en: Of course, try different riffs by changing the notes in the ring or even picking notes from scales or chords. Have fun with your first acid bass synth.
ja: もちろん、リングの中の音符を変更したり、スケールやコードから音符を選択して、異なるリフを試してみるのも良いでしょう。はじめてのアシッドベースシンセを楽しんでください。

en: Deconstructing the TB-303
ja: TB-303の分解

en: The design of the original TB-303 is actually pretty simple. As you can see from the following diagram there's only 4 core parts.
ja: オリジナルのTB-303の設計は、実際のところとてもシンプルです。以下の略図から分かるように、4つのコアな部分しかありません。

en: Notice that I've passed everything through a `:reverb` FX for extra atmosphere - try other FX to see what works!
ja: 追加の雰囲気のために全てを`:reverb`エフェクトに渡しているのに気が付いたかもしれません。他のエフェクトもどう作用するか試してみてください！

en: A.6 Musical Minecraft
ja: A.6 音楽的なMinecraft

en: Musical Minecraft
ja: 音楽的なMinecraft

en: Hello and welcome back! In the previous tutorials we've focussed purely on the music possibilities of Sonic Pi - (turning your Raspberry Pi into a performance ready musical instrument). So far we've learned how to:
ja: こんにちは、そしてまたお会いしましたね！ 前回のチュートリアルでは、純粋にSonic Piの音楽的な可能性に焦点を当てました（Raspberry Piをパフォーマンスに十分対応可能な楽器にしました）。ここまでで、我々は以下のことを学びました：

en: Live Code - changing the sounds on-the-fly,
ja: ライブコーディング - 音楽を止めずに変更する、

en: Code some huge beats,
ja: 大規模なビートをコードする、

en: Generate powerful synth leads,
ja: 強力なシンセリードを生成する、

en: Re-create the famous TB-303 acid-bass sound.
ja: 有名なTB-303のアシッドベースサウンドを再生成する。

en: There's so much more to show you (which we will explore in future editions). However, this month, let's look at something Sonic Pi can do that you probably didn't realise: control Minecraft.
ja: 他にもたくさん紹介したい内容はあります（いずれこのチュートリアルで掘り下げる予定です）が、今月は、Sonic Piで出来ることのうち、おそらくあなたが知らないものを紹介したいと思います。Minecraftの制御です。

en: Hello Minecraft World
ja: Minecraftのワールドへようこそ

en: OK, let's get started. Boot up your Raspberry Pi, fire up Minecraft Pi and create a new world. Now start up Sonic Pi and re-size and move your windows so you can see both Sonic Pi and Minecraft Pi at the same time.
ja: では始めましょう。Raspberry Piをブートし、Minecraft Piを起動して新しいワールドを作りましょう。そして、Sonic Piを起動し、Sonic PiとMinecraft Piの両方が見えるように、ウィンドウをリサイズしたり移動したりしましょう。

en: In a fresh buffer type the following:
ja: 新しいBufferに次のコードを入力してみましょう。

en: Now, hit Run. Boom! Your message appeared in Minecraft! How easy was that? Now, stop reading this for a moment and play about with your own messages. Have fun!
ja: では、`Run`を叩いてみてください。ブーン！ メッセージがMinecraftに表示されましたね！ とても簡単だったでしょう？ では、チュートリアルを読むのを止めて、少しの間メッセージを変更して遊んでみましょう。楽しでみて！

en: Now let's do some exploring. The standard option is to reach for the mouse and keyboard and start walking around. That works, but it's pretty slow and boring. It would be far better if we had some sort of teleport machine. Well, thanks to Sonic Pi, we have one. Try this:
ja: では、少し探検してみましょう。ワールドで移動する標準的なやりかたは、マウスとキーボードを使って、あたりを歩き始めることです。これは機能しますが、かなり遅いし退屈でしょう。何か瞬間移動マシンのようなものがあると良いのですが。。ええ、Sonic Piのおかげで、それは実現できます。これを試してみてください。

en: Crikey! That was a long way up. If you weren't in flying-mode then you would have fallen back down all the way to the ground. If you double-tap space to enter flying-mode and teleport again, you'll stay hovering at the location you zap to.
ja: びっくりした！ 遠くまで移動できたでしょう。もし飛行モードなかったら、全ての行程を戻って地面に落ちてしまうでしょう。スペースキーをダブルタップして飛行モードに入ってもう一度瞬間移動すると、指定した場所に移動して浮いているでしょう。

en: Now, what do those numbers mean? We have three numbers which describe the coordinates of where in the world we want to go. We give each number a name - x, y and z:
ja: では、これらの数字は何を意味するのでしょうか？ ワールド内の行きたい場所の座標を表現するのに、3つの数字を使っています。そしてそれらに名前を付けています。x, yそしてzです。

en: x - how far left and right (80 in our example)
ja: x - どのくらい右端から左に離れてるか（我々の例では80）

en: y - how high we want to be (40 in our example)
ja: y - どのくらい高くあがったか（我々の例では40）

en: z - how far forward and back (100 in our example)
ja: z - どのくらい手前から奥へ離れてるか（我々の例では100）

en: By choosing different values for x, y and z we can teleport *anywhere* in our world. Try it! Choose different numbers and see where you can end up. If the screen goes black it's because you've teleported yourself under the ground or into a mountain. Just choose a higher y value to get back out above land. Keep on exploring until you find somewhere you like...
ja: 異なるx, y, zの値を選ぶことで、ワールドの中の*どこでも*瞬間移動することができます。試してみよう！ 違う値を選んで、どこに辿り着いたか見てみましょう。もし画面が真っ黒になってしまったら、それは地面の下か山の中に瞬間移動してしまったからです。地面よりも上に戻るように大きなyの値を選択してください。何か発見するまで探検を続けましょう…

en: Using the ideas so far, let's build a Sonic Teleporter which makes a fun teleport sound whilst it whizzes us across the Minecraft world:
ja: ここまでのアイデアを使って、Minecraftのワールドを瞬間移動するときの音を面白くする`Sonic Teleporter`を作ってみましょう。

en: Magic Blocks
ja: 魔法のブロック

en: Now you've found a nice spot, let's start building. You could do what you're used to and start clicking the mouse furiously to place blocks under the cursor. Or you could use the magic of Sonic Pi. Try this:
ja: では、良い場所が見つかったと思いますので、何か作り始めてみましょう。あなたの慣れたやり方でもできますし、マウスを激しくクリックしてカーソルの部分にブロックを設置することも可能です。それ以外に、Sonic Piの魔法を使うことも可能です。これを試してみてください。

en: Now look up! There's a melon in the sky! Take a moment to look at the code. What did we do? On line one we grabbed the current location of Steve as the variables x, y and z. These correspond to our coordinates described above. We use these coordinates in the fn `mc_set_block` which will place the block of your choosing at the specified coordinates. In order to make something higher up in the sky we just need to increase the y value which is why we add 5 to it. Let's make a long trail of them:
ja: 見てみてください！ メロンが空中に現れました！ ここでは何をしてるのでしょうか？ 少し時間を取ってコードを見てみましょう。1行目では、プレイヤーの位置を取得してx, y, zの変数に入れています。これらの対応する座標については上で説明しています。これらの座標は、次の行の`mc_set_block`関数で、指定したブロックを設置するのに使用されます。ブロックをより高い位置に設置するには、yの値に5を加えていたのを増やす必要があります。次にブロックの長い軌跡を作ってみましょう。

en: Now, jump over to Minecraft, make sure you're in flying-mode (double tap space if not) and fly all around the world. Look behind you to see a pretty trail of melon blocks! See what kind of twisty patterns you can make in the sky.
ja: では、Minecraftを表示して、飛行モードであることを確認して（もし飛行モードなかったらスペースキーをダブルタップしましょう）、ワールド中を飛び回ってみましょう。後ろにメロンのブロックの可愛い軌跡を見ることができたでしょう。どんなに曲がりくねったパターンでも作れたと思います。

en: Live Coding Minecraft
ja: Minecraftをライブコーディングする

en: Those of you that have been following this tutorial over the last few months will probably have your minds blown at this point. The trail of melons is pretty cool, but the most exciting part of the previous example is that you can use `live_loop` with Minecraft! For those that don't know, `live_loop` is Sonic Pi's special magic ability that no other programming language has. It lets you run multiple loops at the same time and allows you to change them whilst they run. They are incredibly powerful and amazing fun. I use `live_loop`s to perform music in nightclubs with Sonic Pi - DJs use discs and I use `live_loop`s :-) However, today we're going to live code both music and Minecraft.
ja: このチュートリアルをここ数ヶ月読んできた人は驚いたかもしれません。メロンの軌跡はとてもクールだけど、先程の例の最もエキサイティングな部分はMinecraftでも`live_loop`を使えるということです！ 知らない方のために説明すると、`live_loop`は他のプログラミング言語が持っていない、Sonic Piの特別な機能です。`live_loop`は複数のループを同時に実行し、また実行している最中にそれを変更することができます。それは信じられないほど強力で、驚くほど楽しいものです。私は、Sonic Piを使ってクラブで音楽を演奏するときに`live_loop`を使います。DJはレコードを使い、私は`live_loop`を使います:-) 今日は、音楽とMinecraftをライブコーディングしたいと思います。

en: Let's get started. Run the code above and start making your melon trail again. Now, without stopping the code, just simply change `:melon` to `:brick` and hit run. Hey presto, you're now making a brick trail. How simple was that! Fancy some music to go with it? Easy. Try this:
ja: では始めましょう。先程のコードを実行し、メロンの軌跡を作ってみましょう。そして、そのコードを止めずに、ただ`:melon`を`:brick`に変更して`Run`を叩いてみてください。あら不思議、レンガの軌跡が作れたでしょう。なんと簡単なのでしょう！ それに合わせて何か気の利いた音楽はいかがでしょう？ それも簡単です。これを試してみてください。

en: Now, whilst that's playing start changing the code. Change the block types - try `:water`, `:grass` or your favourite block type. Also, try changing the cutoff value from `70` to `80` and then up to `100`. Isn't this fun?
ja: では、それが演奏されている間に、コードを変更してみましょう。ブロックのタイプを変更してみましょう。`:water`や `:grass`、そしてあなたの好きなブロックを試してみましょう。それに加えて、カットオフの値を`70`から`80`に変更し、そして`100`に上げてみましょう。楽しいよね？

en: Let's combine everything we've seen so far with a little extra magic. Let's combine our teleportation ability with block placing and music to make a Minecraft Music Video. Don't worry if you don't understand it all, just type it in and have a play by changing some of the values whilst it's running live. Have fun and see you next time...
ja: ここまで見てきた全てに、ちょっとした魔法を追加して組み合わせてみましょう。瞬間移動とブロック設置の機能と音楽を組み合わせて、Minecraftのミュージックビデオを作ってみましょう。全てを理解できなくても気にせずに、ただ以下のコードをタイプして、いくつかの値を実行中に変更してみましょう。楽しんでください。ではまた…

en: A.7 Bizet Beats
ja: A.7 ビゼービート

en: Bizet Beats
ja: ビゼービート

en: After our brief excursion to the fantastic world of coding Minecraft with Sonic Pi last month, let's get musical again. Today we're going to bring a classical operatic dance piece straight into the 21st century using the awesome power of code.
ja: 先月は、Sonic PiでMinecraftのコーディングの素晴らしい世界に小旅行しましたが、また音楽的なものに戻りましょう。今日は、コードの凄い力を使って、クラシックのオペラ作品を21世紀に持ち込んでみましょう。

en: Outrageous and Disruptive
ja: 奇抜で破壊的な

en: Let's jump into a time machine back to the year 1875. A composer called Bizet had just finished his latest opera Carmen. Unfortunately like many exciting and disruptive new pieces of music people initially didn't like it at all because it was too outrageous and different. Sadly Bizet died ten years before the opera gained huge international success and became one of the most famous and frequently performed operas of all time. In sympathy with this tragedy let's take one of the main themes from Carmen and convert it to a modern format of music that is also too outrageous and different for most people in our time - live coded music!
ja: タイムマシンに乗って1875年に遡ってみましょう。ビゼーという作曲家が、彼の最後のオペラ作品となるカルメンを書き上げました。不運なことに、その作品は、多くの刺激的で破壊的な新しい音楽作品と同じように、あまりに奇抜でまた普通でないために、当初人々には全く好かれませんでした。そして残念なことに、その作品が国際的に多大な成功を収め、歴史上、最も有名で頻繁に公演されるオペラの1つになる10年前にビゼーは亡くなってしまいました。この悲劇に共感して、カルメンのメインテーマの1つを取り上げ、現代を生きる多くの人々にとって、あまりに奇抜でまた普通でない形式の音楽 - ライブコーディングされた音楽に変換してみましょう！

en: Decoding the Habanera
ja: ハバネラの解読

en: Trying to live code the whole opera would be a bit of a challenge for this tutorial, so let's focus on one of the most famous parts - the bass line to the Habanera:
ja: このチュートリアルでカルメンの全体をライブコーディングしようとするのは少し難しいので、最も有名な部分 - ハバネラのベースラインに着目しましょう。

en: This may look extremely unreadable to you if you haven't yet studied music notation. However, as programmers we see music notation as just another form of code - only it represents instructions to a musician instead of a computer. We therefore need to figure out a way of decoding it.
ja: もしあなたが楽譜について学んでいなかったら、これは全く読めないでしょう。しかし、プログラマとして楽譜を見ると、それはプログラミングコードの別な形式と捉えることができます。つまり楽譜は、コンピュータの代わりに演奏者に対する指示を表していると言えます。したがって我々は楽譜を解読する方法を理解する必要があります。

en: Notes
ja: 音符

en: The notes are arranged from left to right like the words in this magazine but also have different heights. *The height on the score represents the pitch of the note.* The higher the note on the score, the higher the pitch of the note.
ja: 音符は、左から右に、ちょうどこの雑誌の単語と同じように並んでいますが、それぞれ異なる高さの位置を持っています。*楽譜上の高さは、音符のピッチ（音程）を表しています。* つまり、楽譜上高い位置にあるものほど、音符のピッチは高くなります。

en: In Sonic Pi we already know how to change the pitch of a note - we either use high or low numbers such as `play 75` and `play 80` or we use the note names: `play :E` and `play :F`. Luckily each of the vertical positions of the musical score represents a specific note name. Take a look at this handy look up table:
ja: Sonic Piでのピッチの変更方法は既に知っているはずです。`play 75`や`play 80`といったように数値を使ったり、`play :E`や`play :F`といったように音名を使ったりできます。楽譜の上下の位置は、それぞれ特定の音名を表しています。便利な対応表を見てみましょう。

en: Rests
ja: 休符

en: Music scores are an extremely rich and expressive kind of code capable of communicating many things. It therefore shouldn't come as much of a surprise that musical scores can not only tell you what notes to play but also when *not* to play notes. In programming this is pretty much equivalent to the idea of `nil` or `null` - the absence of a value. In other words not playing a note is like the absence of a note.
ja: 楽譜はとても表現力豊かなコードで、多くのことを伝達できます。したがって、楽譜がどの音符を演奏するかについてのみならず、音符をいつ演奏*しない*かについて伝達していても、それほど驚くことではないでしょう。これは、プログラミングにおいては`nil`とか`null`（値の無いこと）と同じ考え方です。言い換えると、音符を演奏しないことは、音符が無いことに似ていると言えるでしょう。

en: If you look closely at the score you'll see that it's actually a combination of black dots with lines which represent notes to play and squiggly things which represent the rests. Luckily Sonic Pi has a very handy representation for a rest: `:r`, so if we run: `play :r` it actually plays silence! We could also write `play :rest`, `play nil` or `play false` which are all equivalent ways of representing rests.
ja: 楽譜をよく見ると、演奏する音符を表す点と線の記号と、休符を表す曲がりくねった記号との組合せであることが分かると思います。Sonic Piにはとても便利な休符の表現として`:r`が用意されていて、`play :r`を実行するとSonic Piは無音を演奏するのです！ これはまた、`play :rest`や`play nil`や`play false`とも書くことができ、これらはみな休符を表す同じ方法です。

en: Rhythm
ja: リズム

en: Finally, there's one last thing to learn how to decode in the notation - the timings of the notes. In the original notation you'll see that the notes are connected with thick lines called beams. The second note has two of these beams which means it lasts for a 16th of a beat. The other notes have a single beam which means they last for an 8th of a beat. The rest has two squiggly beams which means it also represents a 16th of the beat.
ja: 楽譜を解読するのに学習する最後の内容は、音符のタイミングです。元の楽譜では、音符同士を繋げる細い線、連桁（beam）と呼ばれているものを見ることができるでしょう。2つ目の音符では2つの連桁があり、これは16分の1拍だけ音が持続することを意味しています。その他の音符は1つの連桁を持っていて、それは8分の1拍だけ音が持続することを意味しています。休符は2つの曲がりくねった連桁を持っていて、これもまた16分の1拍を表しています。

en: When we attempt to decode and explore new things a very handy trick is to make everything as similar as possible to try and see any relationships or patterns. For example, when we re-write our notation purely in 16ths you can see that our notation just turns into a nice sequence of notes and rests.
ja: 新しいことを探索したり解読したりするときに役立つコツは、全てを可能な限り似たものにし、それらの関係やパターンを見出すことです。たとえば、元の楽譜を純粋に16分で記述し直すと、音符と休符の良い感じのシークエンスに変わるでしょう。

en: Re-coding the Habanera
ja: ハバネラの再コーディング

en: We're now in a position to start translating this bass line to Sonic Pi. Let's encode these notes and rests in a ring:
ja: ハバネラのベースラインをSonic Piに翻訳する準備ができました。音符と休符をリングにコード化しましょう。

en: Let's see what this sounds like. Throw it in a live loop and tick through it:
ja: どんな音がするか聞いてみましょう。ライブループに入れて、チックでリングを循環するようにしましょう。

en: Fabulous, that instantly recognisable riff springs to life through your speakers. It took a lot of effort to get here, but it was worth it - high five!
ja: すばらしい。スピーカーから一瞬でそれと分かるリフが活動的に鳴り始めたと思います。ここまで辿り着くのに多くの苦労がありましたが、その価値はありました。やったね！

en: Moody Synths
ja: ムーディーなシンセ

en: Now we have the bass line, let's re-create some of the ambience of the operatic scene. One synth to try out is `:blade` which is a moody 80s style synth lead. Let's try it with the starting note `:d` passed through a slicer and reverb:
ja: ベースラインが出来たので、オペラのシーンの背景音を再生成してみましょう。試してみるシンセの1つは、`:blade`です。これは、80年代スタイルのムーディーなリードシンセです。そのシンセを`:d`の音で開始し、スライサーとリバーブに渡すようにしてみましょう。

en: Now, try the other notes in the bass line: `:a` and `:f5`. Remember, you don't need to hit stop, just modify the code whilst the music is playing and hit run again. Also, try different values for the slicer's `phase:` opt such as `0.5`, `0.75` and `1`.
ja: では、ベースラインの`:a`と`:f5`を他の音に変えてみてください。注意すべきは、`Stop`を叩く必要はないということです。音楽が演奏されている最中に、だたコードを変更して`Run`を再度叩いてください。そして、スライサーの`phase:`オプションを、`0.5`や`0.75`や`1`といった異なる値にしてみてください。

en: Finally, let's combine all the ideas so far into a new remix of the Habanera. You might notice that I've included another part of the bass line as a comment. Once you've typed it all into a fresh buffer hit Run to hear the composition. Now, without hitting stop, *uncomment* the second line by removing the `#` and hit run again - how marvellous is that! Now, start mashing it around yourself and have fun.
ja: 最後に全てのアイデアを組合せて、ハバネラの新しいリミックスを作ってみましょう。もう1つのベースラインがコメントアウトされていることに気が付いたかもしれません。新しいBufferにこれらをタイプしたら、`Run`を叩いて曲を聞いてみてください。そして、`Stop`を叩かずに、2行目のベースラインを*コメントを解除*して、`#`を削除し、`Run`を再度叩いてみてください。なんと凄いのでしょう！ では、あなた自身でこのコードを弄って楽しんでください。

en: A.8 Become a Minecraft VJ
ja: A.8 Minecraft VJになる

en: Become a Minecraft VJ
ja: Minecraft VJになる

en: Everyone has played Minecraft. You will all have built amazing structures, designed cunning traps and even created elaborate cart lines controlled by redstone switches. How many of you have performed with Minecraft? We bet you didn't know that you could use Minecraft to create amazing visuals just like a professional VJ.
ja: みなさんはMinecraftで遊んだことがあると思います。そして、凄い構造物を建てたり、巧妙なトラップを設計したり、レッドストーンのスイッチで制御された精巧なトロッコの路線を作ったりしたことがあるかもしれません。しかし、Minecraftでパフォーマンスをしたことがある人はどのくらい居るでしょうか？ Minecraftを使ってまさにプロフェッショナルなVJのように凄いビジュアルを作れることを知っている人は少ないと思います。

en: If your only way of modifying Minecraft was with the mouse, you'd have a tough time changing things fast enough. Luckily for you your Raspberry Pi comes with a version of Minecraft that can be controlled with code. It also comes with an app called Sonic Pi which makes coding Minecraft not only easy but also incredibly fun.
ja: あなたにとって、Minecraftを操作する唯一の方法がマウスだったら、十分に速くそれを実行できるようになるまで苦労するに違いありません。幸運にも、あなたの持っているRaspberry Piには、コードで制御可能なMinecraftが搭載されています。そして、Raspberry Piには、Sonic Piというアプリケーションも搭載されていて、ただ簡単なだけでなく、信じられないほど楽しくMinecraftをコーディングすることが可能です。

en: In today's article we'll be showing you some of the tips and tricks that we've used to create performances in night clubs and music venues around the world.
ja: 今回の記事では、我々が世界中のクラブやホールでパフォーマンスしたヒントとコツをお教えしたいと思います。

en: Let's get started...
ja: では始めましょう…

en: Getting Started
ja: 入門

en: Let's start with a simple warm up exercise to refresh ourselves with the basics. First up, crack open your Raspberry Pi and then fire up both Minecraft and Sonic Pi. In Minecraft, create a new world, and in Sonic Pi choose a fresh buffer and write in this code:
ja: 基本を習得するために、ウォームアップの練習から始めましょう。最初にRaspberry Piを起動し、続いてMinecraftとSonic Piの両方を起動してください。Minecraftでは、新しいワールドを作成し、Sonic Piでは新しいBufferを選択して、以下のコードを書いてください。

en: Hit the Run button and you'll see the message over in the Minecraft window. OK, we're ready to start, let's have some fun......
ja: `Run`ボタンを叩いて、Minecraftのウィンドウ内にメッセージを見ることができたでしょう。大丈夫ですね。では準備ができました。楽しんでください……

en: Sand Storms
ja: 砂嵐

en: When we're using Minecraft to create visuals we try and think about what will both look interesting and also be easy to generate from code. One nice trick is to create a sand storm by dropping sand blocks from the sky. For that all we need are a few basic fns:
ja: Minecraftを使ってビジュアルを生成する際に、どのようなものが見た目が面白そうで、またコードから生成するのに簡単なのか試行錯誤しました。良さそうなテクニックの1つは、砂のブロックを空から落として砂嵐を作るというものです。これを実現するのに必要なものは、以下の基本的な関数です。

en: `sleep` - for inserting a delay between actions
ja: `sleep` - アクションの間の遅延を挿入するのに使います

en: `mc_location` - to find our current location
ja: `mc_location` - 現在の位置を取得するのに使います

en: `mc_set_block`- to place sand blocks at a specific location
ja: `mc_set_block`- 砂のブロックを指定した位置に設置するのに使います

en: `rrand` - to allow us to generate random values within a range
ja: `rrand` - ある範囲の乱数を生成するのに使います

en: `live_loop` - to allow us to continually make it rain sand
ja: `live_loop` - 砂嵐が起こったままにするのに使います

en: If you're unfamiliar with any of the built-in fns such as `rrand`, just type the word into your buffer, click on it and then hit the keyboard combo `Control-i` to bring up the built-in documentation. Alternatively you can navigate to the *lang* tab in the Help system and then look up the fns directly along with all the other exciting things you can do.
ja: もしあなたが`rrand`といったSonic Piが内蔵する関数に親しくなかったら、その関数名をBufferにタイプし、クリックして選択した後、`Control-i`のキーの組合せを叩いて、内蔵のドキュメントを開いてみてください。あるいは、ヘルプシステムの*命令*タブを開いて、他にも面白そうな項目がある中から、対象の関数名を直接探すこともできます。

en: Let's make it rain a little first before unleashing the full power of the storm. Grab your current location and use it to create a few sand blocks up in the sky nearby:
ja: 砂嵐のフルパワーを開放する前に少し砂を降らせてみましょう。現在の位置を取得し、近くの空中にいくつか砂のブロックを作ってください。

en: When you hit Run, you might have to look around a little as the blocks may start falling down behind you depending on which direction you're currently facing. Don't worry, if you missed them just hit Run again for another batch of sand rain - just make sure you're looking the right way!
ja: `Run`を叩いたとき、辺りを見回す必要があるかもしれません。プレイヤーがどの方向を向いているかにもよりますが、プレイヤーの後ろに砂が降っているかもしれません。でも心配しないでください。砂が降るのを見逃したとしても、`Run`をもう一度叩いて砂を降らせて、プレイヤーが正しい方向を向くようにすればよいのです！

en: Let's quickly review what's going on here. On the first line we grabbed Steve's location as coordinates with the fn `mc_location` and placed them into the vars `x`, `y`, and `z`. Then on the next lines we used the `mc_set_block` fn to place some sand at the same coordinates as Steve but with some modifications. We chose the same x coordinate, a y coordinate 20 blocks higher and then successively larger z coordinates so the sand dropped in a line away from Steve.
ja: では上のコードで何が起きているか手短に見ていきましょう。1行目では、`mc_location`関数を使って、プレイヤーの位置を座標として取得し、`x`, `y`, `z`に設定しています。次の数行では、`mc_set_block`関数を使って、プレイヤーの座標から少し変更を加えたところに砂を置いています。x座標は同じで、y座標は20ブロック高く、z座標は順に大きくして、プレイヤーからまっすぐ離れるように砂を落としています。

en: Why don't you take that code and start playing around with it yourself? Try adding more lines, changing the sleep times, try mixing `:sand` with `:gravel` and choose different coordinates. Just experiment and have fun!
ja: このコードであなた自身で遊んでみてはどうでしょう。コードを追加したり、sleepの時間を変更したり、:sand`と`:gravel`を組合せたり、違う座標を選んでみたりしましょう。色々実験して楽しんでみてください！

en: Live Loops Unleashed
ja: ライブループ解放

en: OK, it's time to get the storm raging by unleashing the full power of the `live_loop` - Sonic Pi's magical ability which unleashes the full power of live coding - changing code on-the-fly whilst it's running!
ja: では、`live_loop`のフルパワーを解放して、嵐を激しくする時が来ました。`live_loop`はライブコーディングのフルパワーを開放するSonic Piの特別な機能で、コードを実行したまま変更できてしまうのです！

en: What fun! We're looping round pretty quickly (8 times a second) and during each loop we're finding Steve's location like before but then generating 3 random values:
ja: なんと楽しいのでしょう！ このコードは、とても速く（毎秒8回）ループしていて、それぞれのループではプレイヤーの位置を前と同じように取得していますが、次の3つのランダムな値を生成しています。

en: `xd` - the difference for x which will be between -10 and 10
ja: `xd` - x座標の差で、-10と10の間の値を取ります

en: `zd` - the difference for z also between -10 and 10
ja: `zd` - z座標の差で、同じく-10と10の間の値を取ります

en: `co` - a cutoff value for the low pass filter between 70 and 130
ja: `co` - ローパスフィルタのカットオフの値で、70と130の間の値を取ります

en: We then use those random values in the fns `synth` and `mc_set_block` giving us sand falling in random locations around Steve along with a percussive rain-like sound from the `:cnoise` synth.
ja: そしてこれらのランダムな値を`synth`と`mc_set_block`関数で使用して、砂をプレイヤーの周りのランダムな位置に落とし、それに合わせて`:cnoise`シンセでパーカッシブな雨のような音を鳴らしています。

en: For those of you new to live loops - this is where the fun really starts with Sonic Pi. Whilst the code is running and the sand is pouring down, try changing one of the values, perhaps the sleep time to `0.25` or the `:sand` block type to `:gravel`. Now hit run *again*. Hey Presto! Things changed without the code stopping. This is your gateway to performing like a real VJ. Keep practising and changing things around. How different can you make the visuals without stopping the code?
ja: ライブループに慣れていない人にお話すると、ここからがSonic Piで本当に面白くなるところです。コードが実行されていて砂が吹き出している最中に、コード内のどれかの値、たとえばsleepの時間を`0.25`に変えたり、ブロックタイプを`:sand`から`:gravel`に変えてみてみましょう。そして`Run`を*もう一度*叩いてみてください。あら不思議！ コードが止まらずに変更されました。これが、本物のVJと同じようにパフォーマンスする入り口です。練習してコードを変更し続けてください。あなたはコードを止めずにどれだけビジュアルを変えることができるかな？

en: Epic Block Patterns
ja: 壮大なブロックのパターン

en: Finally, another great way of generating interesting visuals is to generate huge patterned walls to fly towards and close by. For this effect we'll need to move from placing the blocks randomly to placing them in an ordered manner. We can do this by nesting two sets of iteration (hit the Help button and navigate to section 5.2 of the tutorial "Iteration and Loops" for more background on iteration). The funny `|xd|` after the do means that `xd` will be set for each value of the iteration. So the first time it will be 0, then 1, then 2... etc. By nesting two lots of iteration together like this we can generate all the coordinates for a square. We can then randomly choose block types from a ring of blocks for an interesting effect:
ja: 最後に、興味深いビジュアルを生成するためのもう1つの素晴らしい方法は、巨大な模様付きの壁を生成して、そこを行き来することです。この効果のためには、ブロックをランダムに配置することから、規則的に配置することに移る必要があります。これを行うには、2つのイテレーション（反復）を入れ子にします（イテレーションの詳細については、ヘルプボタンをクリックして、チュートリアルのセクション5.2"イテレーション（反復）とループ"に移動してください）。doの後の面白い `| xd |`は、イテレーションの各値に対して`xd`が設定されることを意味します。 したがって、最初は0, 1, 2…などとなります。このように2回のイテレーションを入れ子にすることで、すべての座標を正方形に生成することができます。また、ブロックのリングからブロックタイプをランダムに選択して、興味深い効果を得ることもできます。

en: Pretty neat. Whilst we're having fun here, try changing `bs.choose` to `bs.tick` to move from a random pattern to a more regular one. Try changing the block types and the more adventurous of you might want to try sticking this within a `live_loop` so that the patterns keep changing automatically.
ja: かなりかっこいいね。このコードで楽しんでいる最中に、`bs.choose`を`bs.tick`に変更して、ランダムなパターンからより規則的なものにしてみましょう。ブロックタイプの変更やより冒険的な変更は、`live_loop`の中でやってみましょう。そうすればパターンは自動的に変更し続けるでしょう。

en: A.9 Randomisation
ja: A.9 ランダム化

en: Surfing Random Streams
ja: ランダムストリームに乗る

en: Back in episode 4 of this tutorial series we took a brief look at randomisation whilst coding up some sizzling synth riffs. Given that randomisation is such an important part of my live coding DJ sets I thought it would be useful to cover the fundamentals in much greater detail. So, get your lucky hat on and let's surf some random streams!
ja: このチュートリアルの第4話では、いくつかのシンセ・リフをコーディングしながら、ランダム化を簡単に見ました。ランダム化は私のライブコーディングDJセットの重要な部分であることを考えると、その基礎をより詳細に取り上げることが有用であると考えました。では、幸運の帽子を被って、ランダムストリームをサーフィンしましょう！

en: There is no random
ja: ランダムは存在しない

en: The first thing to learn which might really surprise you when playing with Sonic Pi's randomisation functions is that they're not actually really random. What does this actually mean? Well, let's try a couple of tests. First, imagine a number in your head between 0 and 1. Keep it there and don't tell me. Now let me guess... was it `0.321567`? No? Bah, I'm clearly no good at this. Let me have another go, but let's ask Sonic Pi to choose a number this time. Fire up Sonic Pi v2.7+ and ask it for a random number but again don't tell me:
ja: これはあなたを本当に驚かせるかもしれませんが、Sonic Piのランダム化関数で遊ぶときに最初に学ぶことは、これらの関数が実際にはランダムではないということです。これは実際にはどのような意味でしょう？ では、いくつかのテストを試してみましょう。まず、0と1の間の数字をあなたの頭の中で想像してください。そのまま私に教えないでください。私が当ててみましょう…それは`0.321567`ですか？ 違いましたか？ ブー、当然ながら私はこれを上手く当てることができません。ではもう一度やりましょう。今度はSonic Piに番号を選んでもらいましょう。v2.7以降のSonic Piを起動して、乱数を要求してみてください。そして先程と同じように私には教えないでください：

en: Now for the reveal... was it `0.75006103515625`? Yes! Ha, I can see you're a little sceptical. Perhaps it was just a lucky guess. Let's try again. Press the Run button again and see what we get... What? `0.75006103515625` again? This clearly can't be random! You're right, it's not.
ja: では当ててみましょう… それは`0.75006103515625`ですか？ 合ってましたか！ でも、あなたが少し疑っているのが分かります。それは多分ただのまぐれ当たりでしょう。もう1度やってみましょう。もう1度実行ボタンを押して、出たものを見て… 何？ `0.75006103515625`？ これは明らかにランダムではありません！ あなたは正しい、ランダムではないですね。

en: What's going on here? The fancy computer science word here is determinism. This just means that nothing is by chance and everything is destined to be. Your version of Sonic Pi is destined to always return `0.75006103515625` in the program above. This might sound pretty useless, but let me assure you that it's one of the most powerful parts of Sonic Pi. If you stick at it you'll learn how to rely on the deterministic nature of Sonic Pi's randomisation as a fundamental building block for your compositions and live coded DJ sets.
ja: ここでは何が起きてるでしょうか？ ここで登場するコンピュータ科学の用語は決定論です。これは、偶然によるものは何も無く、すべてが運命づけられていることを意味します。あなたのバージョンのSonic Piは、上記のプログラムで常に `0.75006103515625`を返すようになっています。これはかなり役に立たないかもしれませんが、Sonic Piの最も強力な部分の1つであることを断言させてください。もしあなたがそれを追求すれば、作曲やライブコーディングDJセットの基本的なビルディング・ブロックとして、Sonic Piのランダム化の決定論的な性質に依存する方法を学ぶことになるでしょう。

en: A Random Melody
ja: ランダムメロディ

en: When Sonic Pi boots it actually loads into memory a sequence of 441,000 pre-generated random values. When you call a random function such as `rand` or `rrand`, this random stream is used to generate your result. Each call to a random function consumes a value from this stream. Therefore the 10th call to a random function will use the 10th value from the stream. Also, every time you press the Run button, the stream is reset for that run. This is why I could predict the result to `rand` and why the 'random' melody was the same every time. Everybody's version of Sonic Pi uses the exact same random stream which is very important when we start sharing our pieces with each other.
ja: Sonic Piが起動すると、441,000の事前に生成された乱数のシーケンスが実際にメモリにロードされます。`rand`や` rrand`のようなランダム関数を呼び出すと、このランダムストリームが関数の結果を生成するために使われます。ランダム関数の呼び出しする度に、このストリームから値を消費します。したがって、ランダム関数への10回目の呼び出しはストリームからの10番目の値を使用します。また、Runボタンを押すたびに、その実行のためにストリームがリセットされます。これが、私が`rand`の結果を予測できたり、'random'なメロディーがいつも同じである理由です。皆さんのSonic Piは、まったく同じランダムストリームを使用しています。これは、私たちの作品をお互いに共有するときに非常に重要です。

en: Let's use this knowledge to generate a repeatable random melody:
ja: 繰り返し可能なランダムメロディを作るために、この知識を使ってみましょう。

en: Type this into a spare buffer and hit Run. You'll hear a melody consisting of 'random' notes between 50 and 95. When it's finished, hit Run again to hear exactly the same melody again.
ja: これを空いたBufferに入力して`Run`を叩いてください。50から95の'ランダムな'音符で構成されるメロディーを聞くことができるでしょう。メロディーが終わったら、もう一度`Run`を叩いてみてください。先ほどと全く同じメロディーを聞くことができるでしょう。

en: Handy Randomisation Functions
ja: 便利なランダム化関数

en: Sonic Pi comes with a number of useful functions for working with the random stream. Here's a list of some of the most useful:
ja: Sonic Piにはランダムストリームを扱う便利な関数がたくさんあります。その中でも有用な関数のリストです。

en: `rand` - Simply returns the next value in the random stream
ja: `rand` - ランダムストリームの次の値を返します

en: `rrand` - Returns a random value within a range
ja: `rrand` - 範囲内のランダムな値を返します

en: `rrand_i` - Returns a random whole number within a range
ja: `rrand_i` - 範囲内のランダムな整数を返します

en: `one_in` - Returns true or false with the given probability
ja: `one_in` - 与えられた確率でtrueまたはfalseを返します

en: `dice` - Imitates rolling a dice and returns a value between 1 and 6
ja: `dice` - サイコロを転がして、1から6までの値をランダムで返します

en: `choose` - Chooses a random value from a list
ja: `choose` - リストからランダムに値を1つ選択します

en: Check out their documentation in the Help system for detailed information and examples.
ja: 詳細情報や例については、ヘルプにあるそれぞれの関数のドキュメントを参照してください。

en: Resetting the Stream
ja: ランダムストリームのリセット

en: Whilst the ability to repeat a sequence of chosen notes is essential to allow you to replay a riff on the dance floor, it might not be exactly the riff you want. Wouldn't it be great if we could try a number of different riffs and choose the one we liked best? This is where the real magic starts.
ja: 選択した音符のシーケンスを繰り返す機能は、リフをダンスフロアで再現するためには不可欠ですが、あなたが望んだリフではないかもしれません。もし、いくつかの異なるリフを試して、一番好きなリフを選ぶことができれば、素晴らしいことではないでしょうか？ これが本当のマジックの始まりです。

en: We can manually set the stream with the fn `use_random_seed`. In Computer Science, a random seed is the starting point from which a new stream of random values can sprout out and blossom. Let's try it:
ja: ランダムストリームを`use_random_seed`関数で手動で設定することができます。コンピュータサイエンスでは、ランダムシードとは、ランダムな値の新しいストリームが芽吹き、開花する出発点です。試してみましょう：

en: Great, we get the first three notes of our random melody above: `84`, `83` and `71`. However, we can now change the seed to something else. How about this:
ja: いいね。上のコードのランダムメロディーの先頭から`84`, `83`, `71`の3つの音符が得られました。ここで、シードを別な値に変更できます。これはどうでしょう：

en: Interesting, we get `83`, `71` and `61` . You might notice that the first two numbers here are the same as the last two numbers before - this isn't a coincidence.
ja: 興味深いことに、ここで`83`, ` 71`, `61`を取得します。ここの最初の2つの数字は、先程の後ろ2つの数字と同じです - これは偶然ではありません。

en: Remember that the random stream is just a giant list of 'pre-rolled' values. Using a random seed simply jumps us to a point in that list. Another way of thinking about it is to imagine a huge deck of pre-shuffled cards. Using a random seed is cutting the deck at a particular point. The fabulous part of this is that it's precisely this ability to jump around the random stream which gives us huge power when making music.
ja: ランダムストリームは「あらかじめ準備された」値の巨大なリストに過ぎないことを思い出してください。ランダムシードの使用は、そのリスト内の特定の位置に単にジャンプするだけです。それについて考えるもう1つの方法は、あらかじめシャッフルされたトランプカードの巨大なデッキを想像することです。ランダムシードを使用することは、デッキの特定の位置でカードを分けることです。このことの素晴らしい点の1つは、ランダムストリームを行ったり来たりするこの機能こそ、音楽を作るときに私たちに大きな力を与えるということです。

en: Let's revisit our random melody of 8 notes with this new stream resetting power, but let's also throw in a live loop so we can experiment live whilst it's playing:
ja: ランダムメロディーに戻りましょう。今度は新しいランダムストリームのリセットで得られた8つの音符だけでなく、ライブループに入れて演奏中に実験できるようにしています：

en: Now, whilst it's still playing, change the seed value from `0` to something else. Try `100`, what about `999`. Try your own values, experiment and play around - see which seed generates the riff you like best.
ja: では、上のコードが動いている間に、シードの値を`0`から別な何かに変えてみましょう。`100`、`999`はどうでしょう。それからあなたの好きな値を試して、実験して遊んでみましょう。そして、どのシードが一番好きなリフを生成するか見てみましょう。

en: This month's tutorial has been quite a technical dive into the workings of Sonic Pi's randomisation functionality. Hopefully it has given you some insight into how it works and how you can start using randomisation in a reliable way to create repeatable patterns within your music. It's important to stress that you can use repeatable randomisation *anywhere* you want. For example, you can randomise the amplitude of notes, the timing of the rhythm, the amount of reverb, the current synth, the mix of an FX, etc. etc. In the future we'll take a close look at some of these applications, but for now let me leave you with a short example.
ja: 今月のチュートリアルでは、Sonic Piのランダム化機能の動作を技術的に詳しく説明しました。信頼性の高い方法でランダム化を使用して音楽内で繰り返し可能なパターンを作成する方法と、それがどのように動作するのかについて、何らかの示唆を与えられたことを願っています。そして、繰り返し可能なランダム化を*どこでも*使用できることを強調しておきます。例えば、音符の音量、リズムのタイミング、リバーブの量、現在のシンセ、エフェクトの掛かり具合などをランダム化することができます。これらについて、将来いくつかの応用を詳しく見たいですが、ここでは簡単な例を挙げておきます。

en: Type the following into a spare buffer, hit Run, and then start changing the seeds around, hit Run again (whilst it's still playing) and explore the different sounds, rhythms and melodies you can make. When you find a nice one, remember the seed number so you can get back to it. Finally, when you've found a few seeds you like, put on a live coded performance for your friends by simply switching between your favourite seeds to create a full piece.
ja: 空いたBufferに以下のように入力し、`Run`を叩いてみてください。そして、シードを変更してみて、（演奏された状態のまま）もう1度`Run`を叩いてみてください。それによって作り出されるさまざまなサウンド、リズム、メロディを探索してみてください。もし素敵なものを見つけたら、シードの数字を覚えておいてください。最後に、あなたが好きなシードがいくつか見つかったら、お気に入りのシードを切り替えて曲にするだけで、ライブコーディングのパフォーマンスを提供できます。

en: A.10 Control
ja: A.10 コントロール

en: Controlling Your Sound
ja: 音をコントロールする

en: So far during this series we've focussed on triggering sounds. We've discovered that we can trigger the many synths built into Sonic Pi with `play` or `synth` and how to trigger pre-recorded samples with `sample`. We've also looked at how we can wrap these triggered sounds within studio FX such as reverb and distortion using the `with_fx` command. Combine this with Sonic Pi's incredibly accurate timing system and you can produce a vast array of sounds, beats and riffs. However, once you've carefully selected a particular sound's options and triggered it, there's no ability to mess with it whilst it's playing right? Wrong! Today you're going to learn something very powerful - how to control running synths.
ja: ここまでで、このシリーズではサウンドをトリガーすることに焦点を当ててきました。我々は、`play`や`synth`でSonic Piに組み込まれた多くのシンセサイザーを起動させることができ、`sample`であらかじめ録音されたサンプルをトリガーする方法を見てきました。また、トリガーされたサウンドを、`with_fx`コマンドを使ってリバーブやディストーションなどのスタジオ・エフェクト内にどのようにラップできるかを見てきました。これをSonic Piの信じられないほど正確なタイミングシステムと組み合わせると、広大なサウンド、ビート、リフを生成することができます。しかし、特定のサウンドのオプションを慎重に選択してトリガーすると、再生されている間にそのサウンドを変更することはできないでしょうか？ それができるのです！ 今日は、実行中のシンセをコントロールするとてもパワフルな方法を学びます。

en: A Basic Sound
ja: 基本的なサウンド

en: Let's create a nice simple sound. Fire up Sonic Pi and in a fresh buffer type the following:
ja: はじめに、良い感じの簡単な音を作ってみましょう。Sonic Piを起動し、新しいBufferに以下のコードを打ち込んでください：

en: Now press the Run button at the top left to hear a lovely rumbling synth sound. Go ahead, press it again a few times to get a feel for it. OK, done? Let's start controlling it!
ja: では、左上にある`Run`ボタンを押して、素敵な響きのシンセサウンドを聞きましょう。続いて、`Run`ボタンを何度か押して、その音の感覚を掴みましょう。できましたか？ では制御してみましょう！

en: Synth Nodes
ja: シンセ・ノード

en: A little known feature in Sonic Pi is that the fns `play`, `synth` and `sample`, return something called a `SynthNode` which represents a running sound. You can capture one of these `SynthNode`s using a standard variable and then **control** it at a later point in time. For example, let's change the value of the `cutoff:` opt after 1 beat:
ja: `play`, `synth`, `sample`といった関数が、実行中のサウンドを表象する`SynthNode`と呼ばれるものを返却することは、Sonic Piで少し知られている機能かもしれません。これらの`SynthNode`は標準的な変数に入れることができ、後で**制御**することができます。例えば、`cutoff:`のオプションを1拍後に変更してみましょう。

en: Let's look at each line in turn:
ja: 各行を順番に見ていきましょう。

en: Firstly we trigger the `:prophet` synth using the `synth` fn as normal. However we also capture the result in a variable called `sn`. We could have called this variable something completely different such as `synth_node` or `jane` - the name doesn't matter. However, it's important to choose a name that's meaningful to you for your performances and for people reading your code. I chose `sn` as it's a nice short mnemonic for synth node.
ja: 最初に、`:prophet`シンセを`synth`関数でいつものようにトリガーしています。しかし、その結果を`sn`という変数に入れています。この変数は`synth_node`や`jane`といった何か全く異なるものでも構いません。しかし、何か意味のある名前を選ぶことがあなたのパフォーマンスや後でこのコードを読む人々にとって重要でしょう。私は、シンセ・ノードのニーモニック（略名）が良かったので、`sn`を選びました。

en: On line 2 we have a standard `sleep` command. This does nothing special - it just asks the computer to wait for 1 beat before moving onto the next line.
ja: 2行目では、標準的な`sleep`コマンドを呼んでいます。これは何も特別なことはありません。次の行に進む前に1拍待つようコンピュータに指示しているだけです。

en: Line 3 is where the control fun starts. Here, we use the `control` fn to tell our running `SynthNode` to change the cutoff value to `130`. If you hit the **Run** button, you'll hear the `:prophet` synth start playing as before, but after 1 beat it will shift to sound a lot brighter.
ja: 3行目はコントロールによって楽しくなるところです。ここでは、`control`関数を使って実行中の`SynthNode`にカットオフの値を`130`に変更するよう指示しています。**Run**ボタンを叩くと、`:prophet`シンセが前と同じように演奏され、1拍後にそのサウンドが明るくなるのを聞くことができるでしょう。

en: Modulatable Options
ja: 調整可能なオプション

en: Most of Sonic Pi's synths and FX opts may be changed after being triggered. However, this isn't the case for all of them. For example, the envelope opts `attack:`, `decay:`, `sustain:` and `release:` can only be set when triggering the synth. Figuring out which opts can and can't be changed is simple - just head to the documentation for a given synth or FX and then scroll down to the individual option documentation and look for the phrases "May be changed whilst playing" or "Can not be changed once set". For example, the documentation for the `:beep` synth's `attack:` opt makes it clear that it's not possible to change it:
ja: Sonic Piのシンセやエフェクトのオプションのほとんどは、トリガーされた後に変更できるかもしれません。しかし、これはすべてに当てはまるという訳ではないのです。例えば、エンベロープのオプション `attack:`, `decay:`, `sustain:`と`release:`は、シンセをトリガーするときだけ設定できます。オプションを変更できるどうかは簡単です。特定のシンセまたはエフェクトのドキュメントに進み、個々のオプションのドキュメントまでスクロールして、"May be changed whilst playing"（演奏中に変更可能です）か"Can not be changed once set"（一度設定されると変更できません）というフレーズを探すだけです。例えば、`:beep`シンセの`attack:`オプションのドキュメントは、それを変更できないことを明確にしています：

en: Multiple Changes
ja: 複数の変更

en: Whilst a synth is running you're not limited to changing it only once - you're free to change it as many times as you like. For example, we can turn our `:prophet` into a mini arpeggiator with the following:
ja: シンセが動作している間は、一度だけ変更することに限らず、何度でも自由に変更することができます。例えば、次のように`:prophet`をミニ・アルペジエーターにすることができます：

en: In this snippet of code we just added a couple of extra things. First we defined a new variable called `notes` which contains the notes we'd like to cycle through (an arpeggiator is just a fancy name for something that cycles through a list of notes in order). Secondly we replaced our single call to `control` with an iteration calling it 16 times. In each call to `control` we `.tick` through our ring of `notes` which will automatically repeat once we get to the end (thanks to the fabulous power of Sonic Pi's rings). For a bit of variety try replacing `.tick` with `.choose` and see if you can hear the difference.
ja: このコードスニペットでは、いくつか余分なものを追加しました。最初に、`notes`という新しい変数を定義しました。この変数には、循環させたい音符が含まれています（アルペジエーターは音符のリストを順番に循環する何かに名前を付けたものです）。第二に、私たちは単一の呼び出しを`control`に置き換え、それを16回呼び出す反復で置き換えました。`control`の呼び出しの度に、`notes`のリングを順に`.tick`していきます（Sonic Piのリングの素晴らしいパワーのおかげで、リングは末尾に達すると先頭に戻ります）。ちょっとした変化として、`.tick`を`.choose`で置き換えて、その違いを聞くことができるかどうか確認してください。

en: Note that we can change multiple opts simultaneously. Try changing the control line to the following and listen for the difference:
ja: 複数のオプションを同時に変更することもできます。コントロールの行を次のように変更して、その違いを聞いてみてください：

en: Sliding
ja: スライド

en: When we control a `SynthNode`, it responds exactly on time and instantly changes the value of the opt to the new one as if you'd pressed a button or flicked a switch requesting the change. This can sound rhythmical and percussive - especially if the opt controls an aspect of the timbre such as `cutoff:`. However, sometimes you don't want the change to happen instantaneously. Instead, you might want to smoothly move from the current value to the new one as if you'd moved a slider or dial. Of course, Sonic Pi can also do this too using the `_slide:` opts.
ja: `SynthNode`をコントロールすると、正確に時間通りに応答し、ボタンを押したり、変更を要求するスイッチをフリックしたかのように、オプションの値を新しいものに即座に変更します。これは、特にオプションがの`cutoff:`ような音色の1つをコントロールしている場合に、リズミカルでパーカッシブに聞こえることがあります。しかし、瞬間的に変更が発生することを望まないこともあります。その代わりに、スライダーやダイヤルを移動した場合のように、現在の値から新しい値にスムーズに移動したい場合があります。もちろん、Sonic Piでも`_slide:`オプションを使うことで、これを行うことができます。

en: Each opt that can be modified also has a special corresponding `_slide:` opt that allows you to specify a slide time. For example, `amp:` has `amp_slide:` and `cutoff:` has `cutoff_slide:`. These slide opts work slightly differently than all the other opts in that they tell the synth note how to behave **next time they are controlled**. Let's take a look:
ja: 変更可能なオプションには、それぞれ対応する`_slide:`という特別なオプションがあり、スライドの時間を指定できます。例えば、`amp:`は`amp_slide:`を、`cutoff:`は`cutoff_slide:`を持っています。これらのスライド・オプションは、**次にそれらがコントロールされたときに**どのように動作するかをシンセの音符に指示するという点で、他のすべてのオプションとは少し異なります。次のコードを見てみましょう：

en: Notice how this example is exactly the same as before except with the addition of `cutoff_slide:`. This is saying that next time this synth has its `cutoff:` opt controlled, it will take 2 beats to slide from the current value to the new one. Therefore, when we use `control` you can hear the cutoff slide from 70 to 130. It creates an interesting dynamic feel to the sound. Now, try changing the `cutoff_slide:` time to a shorter value such as 0.5 or a longer value such as 4 to see how it changes the sound. Remember, you can slide any of the modifiable opts in exactly this way and each `_slide:` value can be totally different so you can have the cutoff sliding slowly, the amp sliding fast and the pan sliding somewhere in between if that's what you're looking to create...
ja: この例が`cutoff_slide:`を除いて先の例と全く同じであることに注目してください。これは、このシンセで次に`cutoff:`をコントロールすると、現在の値から新しい値にスライドするのに2拍かかることを示しています。したがって、`control`を使用したとき、カットオフが70から130までスライドするのを聞くことができるでしょう。これは、音に興味深いダイナミックな感触を作り出します。次に、 `cutoff_slide:`の時間を0.5などの短い値や4などのより長い値に変更して、音の変化を確認してください。変更可能なオプションであれば、これと同じようにスライドできることを覚えておいてください。それぞれの`_slide:`の値は完全に異なるので、あなたがやろうとすれば、カットオフをゆっくりとスライドしつつ、アンプは速くスライドし、パンをどこかの間をスライドさせることも可能です…

en: Let's look at a short example which demonstrates the power of controlling synths after they've been triggered. Notice that you can also slide FX just like synths although with a slightly different syntax. Check out section 7.2 of the built-in tutorial for more information on controlling FX.
ja: シンセがトリガーされた後にコントロールする力を実証する短い例を見てみましょう。エフェクトもシンセと同じようにスライドできますが、少し文法が異なることに注目してください。エフェクトのコントロールについての情報は、チュートリアルのセクション7.2をチェックしてみてください。

en: Copy the code into a spare buffer and take a listen. Don't stop there though - play around with the code. Change the slide times, change the notes, the synth, the FX and the sleep times and see if you can turn it into something completely different!
ja: 以下のコードを使用可能なBufferにコピーして聞いてみてください。そこで止めずに、そのコードで遊んでみてください。スライドの時間や音符、シンセ、エフェクトやスリープの時間を変更して、全く異なるものに変更できたことを確認してください！

en: A.11 Tick Tock
ja: A.11 チック・タック

en: Tracking the Beat
ja: ビートを追跡する

en: Last month in this series we took a deep technical dive into the randomisation system underpinning Sonic Pi. We explored how we can use it to deterministically add new levels of dynamic control over our code. This month we're going to continue our technical dive and turn our attention to Sonic Pi's unique tick system. By the end of this article you'll be ticking your way through rhythms and riffs on your way to being a live coding DJ.
ja: このシリーズでは先月、Sonic Piを支えるランダム化のシステムについて技術的に詳しく見ました。そして、コードを動的に制御する新しい基準を、どのように決定論的に追加できるか探索しました。今月は、引続きSonic Piのユニークなチック（tick）システムに焦点を当て、技術的に詳しく見てみたいと思います。この記事の終わりまでに、あなた自身のやり方で、ライブコーディングDJに必要なリズムやリフのチックができるようになるでしょう。

en: Beat Counting
ja: ビートをカウントする

en: When making music we often want to do a different thing depending on which beat it is. Sonic Pi has a special beat counting system called `tick` to give you precise control over when a beat actually occurs and even supports multiple beats with their own tempos.
ja: 音楽を作るときに、何ビート目であるかによって何か異なることをしたいことがよくあるでしょう。Sonic Piには、`tick`と呼ばれるビートをカウントする特別なシステムがあって、ビートが実際にいつ起こるかを正確に制御でき、またそれぞれ独自のテンポを持った複数のビートにも対応しています。

en: Let's have a play - to advance the beat we just need to call `tick`. Open up a fresh buffer, type in the following and hit Run:
ja: 早速遊んでみましょう。ビートを進めるのに必要なことは、単に`tick`を呼ぶだけです。新しいBufferを開いて、次のコードを入力して`Run`を叩いてみてください：

en: This will return the current beat: `0`. Notice that even if you press the Run button a few times it will always return `0`. This is because each run starts a fresh beat counting from 0. However, whilst the run is still active, we can advance the beat as many times as we want:
ja: これは現在のビートの`0`を返すでしょう。`Run`ボタンを数回押しているにも関わらず、これが常に`0`を返すことに注意してください。これは、それぞれの実行で新しいビートのカウントが0から開始するためです。しかし、実行がアクティブのままであれば、ビートを好きなだけ進めることができます：

en: Whenever you see the symbol `#=>` at the end of a line of code it means that that line will log the text on the right-hand-side. For example, `puts foo #=> 0` means the code `puts foo` prints `0` to the log at that point in the program.
ja: コードの行の末尾に`#=>`シンボルがあるときは、そのコードが右側のテキストをログ出力することを意味しています。例えば、`puts foo #=> 0`は`puts foo`がプログラムのその場所で`0`をログ出力することを意味します。

en: Checking the Beat
ja: ビートを確認する

en: We've seen that `tick` does two things. It increments (adds one) and returns the current beat. Sometimes we just want to look at the current beat without having to increment it which we can do via `look`:
ja: ここまでで、`tick`が2つのことをしているのを見てきました。それは、ビートを増やし（1を加算し）、ビートの値を返しています。場合によっては、ビートを増やさずにただ値を見たいことがあるかもしれませんが、それは`look`で実現できます：

en: In this code we tick the beat up twice and then call `look` twice. We'll see the following values in the log: `0`, `1`, `1`, `1`. The first two `tick`s returned `0`, then `1` as expected, then the two `look`s just returned the last beat value twice which was `1`.
ja: このコードでは`tick`でビートを2回増加させ、その後`look`を2回呼んでいます。実行すると、ログに`0`, `1`, `1`, `1`の値が表示されるでしょう。最初の2つの`tick`で`0`と`1`を返し、次の2つの`look`はビートの最新の値である`1`を単純に返しています。

en: So now we can advance the beat with `tick` and check the beat with `look`. What next? We need something to tick over. Sonic Pi uses rings for representing riffs, melodies and rhythms and the tick system has been specifically designed to work very closely with them. In fact, rings have their own dot version of `tick` which does two things. Firstly, it acts like a regular tick and increments the beat. Secondly it looks up the ring value using the beat as the index. Let's take a look:
ja: `tick`でビートを進め、`look`でビートを確認できるようになりました。次は何でしょう？ `tick`で何かを進める必要がありそうですね。Sonic Piはリフやメロディーやリズムを表すのにリングを使っていて、`tick`システムはこれと密接に連携するよう設計されています。実際に、リングは`.`の付いた`tick`の独自のバージョンを持っていて、それは2つのことをします。最初に、それは通常の`tick`と同じようにビートを増加させます。次に、ビートをインデックスとして使用して、リングの値にアクセスします。次を見てみましょう：

en: `.tick` is a special dot version of `tick` which will return the first value of the ring `:a`. We can grab each of the values in the ring by calling `.tick` multiple times:
ja: `.tick`は`tick`の`.`付きの特別なバージョンで、これはリングの最初の値である`:a`を返します。次のように、`.tick`を複数回呼ぶことで、リングの値をそれぞれ掴むことができます：

en: Take a look at the log and you'll see `:a`, `:b`, `:c` and then `:a` again. Notice that `look` returns `3`. Calls to `.tick` act just like they are regular calls to `tick` - they increment the local beat.
ja: ログを見ると、`:a`, `:b`, `:c`が表示され、その後再び`:a`が表示されているでしょう。`look`が`3`を返しているのに注目してください。`.tick`の呼び出しは、`tick`の通常の呼び出しとちょうど似た振る舞いをしていますが、それは独自のビートを増加させているのです。

en: A Live Loop Arpeggiator
ja: ライブループ・アルペジエーター

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:
ja: 'tick'は、リングと`live_loop`と組み合わせることによって、本当の力が発揮されます。それらを組み合せると、シンプルなアルペジエーターを構築して理解するために必要な全ての道具を手に入れたことになります。必要なものは、次の4つです：

en: A ring containing the notes we want to loop over.
ja: ループしたい音符を保持するリング

en: A means of incrementing and obtaining the beat.
ja: ビートを増加したり保持したりする手段

en: The ability to play a note based on the current beat.
ja: ビートに応じて音符を演奏する機能

en: A loop structure to keep the arpegiator repeating.
ja: アルペジエーターを繰り返し続けるループ構造

en: These concepts can all be found in the following code:
ja: これらの概念のすべてを、次のコードで見つけることができます：

en: Let's look at each of these lines. First we define our ring of notes which we'll continually play. We then create a `live_loop` called `:arp` which loops round for us. Each time round the `live_loop` we set our synth to `:dpulse` and then play the next note in our ring using `.tick`. Remember that this will increment our beat counter and use the latest beat value as an index into our notes ring. Finally, we wait for an eighth of a beat before looping round again.
ja: 各行を順に見ていきましょう。最初に、繰り返し演奏される音符のリングを定義しています。次に、`:arp`と名付けられた`live_loop`を作ってループさせています。`live_loop`を繰り返す度に、シンセを`:dpulse`に設定し、`.tick`と使ってリング内の次の音符を演奏しています。これにより、ビートのカウンタを増加させ、最新のビートの値を音符のリングのインデックスとして使っている点に注意してください。最後に、1/8拍待ってループしています。

en: Multiple Simultaneous Beats
ja: 複数の同時ビート

en: A really important thing to know is that `tick`s are local to the `live_loop`. This means that each `live_loop` has its own independent beat counter. This is much more powerful than having a global metronome and beat. Let's take a look at this in action:
ja: 本当に知っておいて欲しい大切なことは、`tick`は`live_loop`でローカルなことです。これは、それぞれの`live_loop`がそれ自身の独立したビートのカウンタを持っていることを意味します。これは、グローバルなメトロノームとビートよりもはるかに強力です。実際に動いているところを見てみましょう：

en: Clashing Beats
ja: ビートを壊す

en: A big cause of confusion with Sonic Pi's tick system is when people want to tick over multiple rings in the same `live_loop`:
ja: Sonic Piの`tick`システムに関する混乱の大きな原因は、`live_loop`に複数のリングで`tick`をしようとする際に生じるものです：

en: Even though each `live_loop` has its own independent beat counter, we're calling `.tick` twice within the same `live_loop`. This means that the beat will be incremented twice every time round. This can produce some interesting polyrhythms but is often not what you want. There are two solutions to this problem. One option is to manually call `tick` at the start of the `live_loop` and then use `.look` to look up the current beat in each `live_loop`. The second solution is to pass a unique name to each call to `.tick` such as `.tick(:foo)`. Sonic Pi will then create and track a separate beat counter for each named tick you use. That way you can work with as many beats as you need! See the section on named ticks in 9.4 of the built-in tutorial for more information.
ja: `live_loop`には独自のビートのカウンタがありますが、ここでは同じ`live_loop`内で`.tick`を2回呼び出しています。これは、ループする毎にビートが2回増加されることを意味しています。これは何か面白いポリリズムを生み出すことができるかもしれませんが、多くの場合あなたが望むものではないでしょう。この問題には2つの解決策があります。1つめは、`live_loop`の開始時に手動で`tick`を呼び出し、`.look`を使って各`live_loop`の現在のビートを確認することです。2つめは、`.tick(:foo)`のように、`.tick`の呼び出しにユニークな名前を渡すことです。Sonic Piは、名前付きチック毎に別々のビートのカウンタを作成し、追跡します。そうすれば、必要なだけ多くのビートで作業できます！ 詳細については、チュートリアルの9.4の名前付きチックに関するセクションを参照してください。

en: Let's bring all this knowledge of `tick`s, `ring`s and `live_loop`s together for a final fun example. As usual, don't treat this as a finished piece. Start changing things and play around with it and see what you can turn it into. See you next time...
ja: `tick`, `ring`, `live_loop`の知識を使って、最後に楽しい例を紹介しましょう。いつものように、これを完成された曲として扱わないようにしてください。これで遊びながら色々と変更して、どこまで変えることができるか見てみてください。ではまた次回お会いしましょう…

en: A.12 Sample Slicing
ja: A.12 サンプルをスライスする

en: Sample Slicing
ja: サンプルをスライスする

en: Sound as Data
ja: データとしてのサウンド

en: Before we get started let's just take a brief moment to understand how to work with samples. By now, you've all hopefully played with Sonic Pi's powerful sampler. If not, there's no time like the present! Boot up your Raspberry Pi, launch Sonic Pi from the Programming menu, type the following into a fresh buffer and then hit the Run button to hear a pre-recorded drum beat:
ja: 始める前に、少し時間を取って、サンプルで作業する方法を理解しましょう。ここまでで、みなさんはSonic Piの強力なサンプラーで遊んだことがあると思います。もし試したことがなかったら、今やってみましょう！ Raspberry Piを起動し、Sonic Piを`Programming`のメニューから起動し、新しいBufferに次のように入力して、`Run`ボタンを押すと、あらかじめ録音されたドラムビートを聞くことができます：

en: A recording of a sound is simply represented as data - lots of numbers between -1 and 1 which represent the peaks and troughs of the sound wave. If we play those numbers back in order, we get the original sound. However, what's to stop us from playing them back in a different order and creating a new sound?
ja: 音の記録は、音の波形の山と谷を表す-1から1のたくさんの数値のデータとして単純に表現されます。これらの数値を順番に再生すると、元の音が得られます。しかし、それらを別の順序で再生して新しい音を作り出すことに、何か問題があるしょうか？

en: How are samples actually recorded? It's actually pretty simple once you understand the basic physics of sound. When you make a sound - for example by hitting a drum, the noise travels through the air in a similar fashion to how the surface of a lake ripples when you throw a pebble into it. When those ripples reach your ears, your eardrum moves sympathetically and converts those movements into the sound you hear. If we wish to record and play back the sound, we therefore need a way of capturing, storing and reproducing those ripples. One way is to use a microphone which acts like an eardrum and moves back and forth as the sound ripples hit it. The microphone then converts its position into a tiny electric signal which is then measured many times a second. These measurements are then represented as a series of numbers between -1 and 1.
ja: 実際にサンプルはどのように記録されるのでしょうか？ 音の基本的な物理を一度理解すれば、実際のところかなり簡単です。例えばドラムを叩くなどして音を出すと、小石を投げ込んだときに湖の表面が波打つのと同じように、空気中を音が移動します。これらの波紋があなたの耳に届くと、あなたの鼓膜が共振するよう動いて、その動きを聞こえる音に変換します。したがって、音を記録して再生したい場合、これらの波紋をキャプチャし、保存し、再生する方法が必要です。1つの方法は、鼓膜のように音の波紋が届いたときに前後に振動するマイクロフォンを使用することです。マイクロフォンはその位置を小さな電気信号に変換します。そして、それを1秒間に何度も測定します。これらの測定値は、-1と1の間の一連の数値として表されます。

en: If we were to plot a visualisation of the sound it would be a simple graph of data with time on the x axis and microphone/speaker position as a value between -1 and 1 on the y axis. You can see an example of such a graph at the top of the diagram.
ja: 音を視覚化してプロットしようとすると、x軸に時間を、y軸にマイクロフォン/スピーカーの位置を-1と1の間の値として持つデータの単純なグラフになるでしょう。このようなグラフの例は、図表の上部に見ることができるでしょう。

en: Playing Part of a Sample
ja: サンプルを部分的に再生する

en: So, how do we code Sonic Pi to play a sample back in a different order? To answer this question we need to take a look at the `start:` and `finish:` opts for `sample`. These let us control the start and finish positions of our playback of the numbers which represent the sound. The values for both of these opts are represented as a number between `0` and `1` where `0` represents the start of the sample and `1` is the end. So, to play the first half of the Amen Break, we just need to specify a `finish:` of `0.5`:
ja: では、サンプルを別の順序で再生するためには、Sonic Piでどのようにコーディングすれば良いでしょうか？ この質問に答えるには、`sample`の`start:`と`finish:`オプションを見てみる必要があります。これらは、サウンドを表す数字の再生の開始位置と終了位置を制御します。これらのオプションのどちらの値も`0`と`1`の間の数字として表され、`0`はサンプルの開始を、`1`は終了を表しています。したがって、アーメン・ブレイクの前半部分を再生するに必要なことは、次のように`finish:`に`0.5`を指定するだけです：

en: We can add in a `start:` value to play an even smaller section of the sample:
ja: また、`start:`の値を追加することもでき、先ほどの例より更に短い区間のサンプルを演奏することも可能です：

en: For fun, you can even have the `finish:` opt's value be *before* `start:` and it will play the section backwards:
ja: 更に面白いのは、`finish:`オプションの値を`start:`より*前に*設定することができます。その場合には、その区間が逆再生されます：

en: Re-ordering Sample Playback
ja: サンプル再生の順序並び替え

en: Now that we know that a sample is simply a list of numbers that can be played back in any order and also how to play a specific part of a sample we can now start having fun playing a sample back in the 'wrong' order.
ja: サンプルが単純にどの順序でも再生可能な数字のリストであることと、特定の位置から再生する方法を習得したので、サンプルを'誤った'順序で楽しく再生することができるようになりました。

en: Let's take our Amen Break and chop it up into 8 equally-sized slices and then shuffle the pieces around. Take a look at the diagram: at the top A) represents the graph of our original sample data. Chopping it into 8 slices gives us B) - notice that we've given each slice a different colour to help distinguish them. You can see each slice's start and finish values at the top. Finally C) is one possible re-ordering of the slices. We can then play this back to create a new beat. Take a look at the code to do this:
ja: アーメン・ブレイクを8つの同じサイズのスライスにぶつ切りにして、それをシャッフルしてみましょう。図を見てください：上のAはサンプルのオリジナルのデータです。それを8つのスライスにぶつ切りにしたのがBです。それぞれのスライスを異なる色にして区別しやすくしていることに注意してください。また、各スライスの開始と終了の値が上にあるのを見ることができるでしょう。最後にCは、スライスの並び替えの1例です。これを再生して新しいビートを作ることができます。これを実現するためのコードを見てみましょう：

en: we choose a random slice to play which should be a random number between 0 and 7 (remember that we start counting at 0). Sonic Pi has a handy function for exactly this: `rand_i(8)`. We then store this random slice index in the variable `slice_idx`.
ja: 0から7のランダムな数字（0から数え始めることを忘れないでください）のいずれかのスライスを選択しています。Sonic Piは正にこれを行うための便利な関数として、`rand_i(8)`を使うことができます。次に、このランダムなスライスのインデックスを`slice_idx`変数に格納しています。

en: We define our `slice_size` which is 1/8 or 0.125. The `slice_size` is necessary for us to convert our `slice_idx` into a value between 0 and 1 so we can use it as our `start:` opt.
ja: `slice_size`を1/8または0.125に定義しています。`slice_size`は、`slice_idx`を`start:`オプションで使用する0から1の値に変更するために必要です。

en: We calculate the start position `s` by multiplying the `slice_idx` by the `slice_size`.
ja: 開始地点である`s`は、`slice_idx`と`slice_size`を掛け算して求めます。

en: We calculate the finish position `f` by adding the `slice_size` to the start position `s`.
ja: 終了地点である`f`は、開始地点である`s`と`slice_size`を足し算して求めます。

en: We can now play the sample slice by plugging in the `s` and `f` values into the `start:` and `finish:` opts for `sample`.
ja: 変数`s`と`f`を`sample`関数の`start:`と`finish:`にそれぞれ繋げて、サンプルのスライスを再生することができるようになりました。

en: Before we play the next slice we need to know how long to `sleep` which should be the duration of the sample slice. Luckily, Sonic Pi has us covered with `sample_duration` which accepts all the same opts as `sample` and simply returns the duration. Therefore, by passing `sample_duration` our `start:` and `finish:` opts, we can find out the duration of a single slice.
ja: 次のスライスを再生する前に、どれだけの時間`sleep`するか、すなわちスライスされたサンプルの長さを知る必要があります。幸いにも、Sonic Piには単にサンプルの長さを返す`sample_duration`関数があり、それは`sample`と全く同じオプションを受け入れます。したがって、`sample_duration`に`start:`と`finish:`オプションを渡してあげれば、スライスの長さを知ることができるのです。

en: We wrap all of this code in a `live_loop` so that we continue to pick new random slices to play.
ja: そして、新しいランダムなスライスを選んで再生し続けるように、このコードの全てを`live_loop`で包みます。

en: Let's combine everything we've seen so far into a final example which demonstrates how we can take a similar approach to combine randomly sliced beats with some bass to create the start of an interesting track. Now it's your turn - take the code below as a starting point and see if you can take it in your own direction and create something new...
ja: ここまで見てきた全てを組み合わせて最後の例にしましょう。興味深いトラックの作り始めるのに、ランダムにスライスされたビートとベースを組み合せた同じようなアプローチが可能であることを示していると思います。次は、あなたの番です。このコードを開始地点として、自分自身で進めて何か新しいものを作れるか見てみてください…

en: A.13 Code a Probabilistic Sequencer
ja: A.13 確率的シーケンサーをコーディングする

en: Code a Probabilistic Sequencer
ja: 確率的シーケンサーをコーディングする

en: In a previous episode of this Sonic Pi series we explored the power of randomisation to introduce variety, surprise and change into our live coded tracks and performances. For example, we randomly picked notes from a scale to create never-ending melodies. Today we're going to learn a new technique which uses randomisation for rhythm - probabilistic beats!
ja: このシリーズの前回の記事では、ランダム化の力を探求し、それがライブコーディングされたトラックやパフォーマンスに多様性や驚きや変化をもたらすのを示しました。例えば、ある音階からランダムにピックアップした音符で、終わりのないメロディーを作りました。今日は、ランダム化をリズムに適用した新しいテクニック、確率的ビートについて学びます。

en: Probability
ja: 確率

en: Before we can start making new beats and synth rhythms we need to take a quick dive into the basics of probability. This might sound daunting and complicated, but really it's just as simple as rolling a dice - honestly! When you take a regular 6 sided board game dice and roll it what's actually happening? Well, firstly you'll roll either a 1, 2, 3, 4, 5 or 6 with exactly the same chance of getting any of the numbers. In fact, given that it's a 6 sided dice, on average (if you roll lots and lots of times) you'll throw a 1 every 6 throws. This means you have a 1 in 6 chance of throwing a 1. We can emulate dice rolls in Sonic Pi with the fn `dice`. Let's roll one 8 times:
ja: 新しいビートやシンセのリズムを作り始める前に、確率に関する基本についてざっと見てみる必要があります。これは複雑で骨の折れるように聞こえるかもしれませんが、実際のところ、サイコロを振るのと同じくらい簡単です！ 普通の6面のサイコロを振ると何が起きるでしょうか？ そうですね。1, 2, 3, 4, 5, 6のいずれかが同じチャンスで得られるでしょう。実際、6面のサイコロであれば、（もしあなたが何度も何度も振れば）平均して6回に1回1の目が出るでしょう。これが1の目を出すのに1/6のチャンスがあることを示しています。Sonic Piでは、サイコロを振るのを`dice`関数でエミュレートできます。では8回サイコロを振ってみましょう：

en: Notice how the log prints values between 1 and 6 just as if we'd rolled a real dice ourselves.
ja: ちょうど実物のサイコロを振ったのと同じように、1から6の間の値をログに表示していることに注目してください。

en: Random Beats
ja: ランダム・ビート

en: Now imagine you had a drum and every time you were about to hit it you rolled a dice. If you rolled a 1, you hit the drum and if you rolled any other number you didn't. You now have a probabilistic drum machine working with a probability of 1/6! Let's hear what that sounds like:
ja: では、あなたの目の前にドラムがあって、それを叩こうとするときにいつもサイコロを振るのを想像してみてください。もしあなたが1の目を出したらドラムを叩き、それ以外の目を出したら叩かないとしましょう。これであなたは、1/6の確率で動作する確率的なドラムマシーンを手に入れたことになります！ どんな音がするか聞いてみましょう：

en: Let's quickly go over each line to make sure everything is very clear. First we create a new `live_loop` called `:random_beat` which will continually repeat the two lines between `do` and `end`. The first of these lines is a call to `sample` which will play a pre-recorded sound (the `:drum_snare_hard` sound in this case). However, this line has a special conditional `if` ending. This means that the line will only be executed if the statement on the right hand side of the `if` is `true`. The statement in this case is `dice == 1`. This calls our `dice` function which, as we have seen, returns a value between 1 and 6. We then use the equality operator `==` to check to see if this value is `1`. If it is `1`, then the statement resolves to `true` and our snare drum sounds, if it isn't `1` then the statement resolves to `false` and the snare is skipped. The second line simply waits for `0.125` seconds before rolling the dice again.
ja: 全てが明確になるよう、各行をざっと見ていきましょう。最初に、`:random_beat`という名前を付けた`live_loop`を作って、`do`から`end`までの2行を繰り返しています。ループ内の最初の行は、`sample`を呼んであらかじめ録音された音（この場合は`:drum_snare_hard`の音）を再生しています。しかし、この行には特別な`if`の条件が末尾に付いています。これは、この行が`if`の右側の条件式が`true`であるときだけ実行されることを意味しています。この場合、条件式は`dice == 1`です。`dice`関数の呼び出しは、我々が既に見てきたように、1から6の値を返します。つづいて、等価演算子の`==`を使って、この値が`1`かどうかチェックしています。もし`1`であれば、この条件式は`true`となり、スネアドラムの音が再生され、`1`でなければ、この条件式は`false`となり、スネアドラムはスキップされます。ループ内の2行目は、次にサイコロを振る前に、単に`0.125`秒間待っているだけです。

en: Changing Probabilities
ja: 確率を変更する

en: Those of you that have played role play games will be familiar with lots of strangely shaped dice with different ranges. For example there is the tetrahedron shaped dice which has 4 sides and even a 20 sided dice in the shape of a icosahedron. The number of sides on the dice changes the chance, or probability of rolling a 1. The fewer sides, the more likely you are to roll a 1 and the more sides the less likely. For example, with a 4 sided dice, there's a one in 4 chance of rolling a 1 and with a 20 sided dice there's a one in 20 chance. Luckily, Sonic Pi has the handy `one_in` fn for describing exactly this. Let's play:
ja: ロールプレイングゲームをプレイしたことがある人の中には、さまざまな範囲を持つ不思議なな形をしたサイコロに馴染みがあるかもしれません。たとえば、三角錐（正四面体）の形をした4面のサイコロや、正二十面体の形をした20面のサイコロがあります。サイコロの面の数はも1の目を出すチャンスや確率を変えます。面が少なければ、より1の目を出しやすくなり、面が多くなれば、より1の目を出しにくくなります。たとえば、4面のサイコロでは、1の目をだすのに1/4のチャンスがありますが、20面のサイコロでは、1の目をだすのに1/20のチャンスがあります。幸いにも、Sonic Piにはちょうどこれと同じことができる便利な`one_in`関数があります。次をやってみましょう：

en: Start the live loop above and you'll hear the familiar random rhythm. However, don't stop the code running. Instead, change the `6` to a different value such as `2` or `20` and hit the `Run` button again. Notice that lower numbers mean the snare drum sounds more frequently and higher numbers mean the snare triggers fewer times. You're making music with probabilities!
ja: 上のライブループを開始すると、馴染みのあるランダムリズムを聞くことができるでしょう。しかし、実行されているコードを止めないでください。そのかわり、`6`を異なる値、たとえば`2`とか`20`に変更して、`Run`ボタンを叩いてみてください。小さい数字はスネアドラムがより頻繁に再生され、大きい数字はスネアドラムがあまり頻繁に再生されないということを意味しているのに注目してください。これであなたは確率で音楽を作っていることになるのです！

en: Combining Probabilities
ja: 確率を組み合せる

en: Things get really exciting when you combine multiple samples being triggered with different probabilities. For example:
ja: 複数のサンプルが異なる確率でトリガーされるのを組み合せると、本当に刺激的になります。例えば：

en: Again, run the code above and then start changing the probabilities to modify the rhythm. Also, try changing the samples to create an entirely new feel. For example try changing `:drum_cymbal_closed` to `:bass_hit_c` for extra bass!
ja: もう一度、上のコードを実行して、リズムを変更するために確率を変更してみてください。また、試しにサンプルを変更してみると、全く新しい感覚を生み出すでしょう。例えば、低音を追加するために、試しに`:drum_cymbal_closed`を`:bass_hit_c`に変更してみてください！

en: Repeatable Rhythms
ja: 再現可能なリズム

en: Next, we can use our old friend `use_random_seed` to reset the random stream after 8 iterations to create a regular beat. Type the following code to hear a much more regular and repeating rhythm. Once you hear the beat, try changing the seed value from `1000` to another number. Notice how different numbers generate different beats.
ja: 次に、我々にはすっかりお馴染みの`use_random_seed`を使って、8回の繰り返しの後に、ランダム・ストリームをリセットすると、規則的なビートを作ることができます。次のコードをタイプして、より規則的で再現可能なリズムを聞いてみましょう。一度ビートを聞いたら、シードの値を`1000`から別なものにしてみましょう。異なる数字が異なるビートを生成することに注目してください。

en: One thing I tend to do with this kind of structure is to remember which seeds sound good and make a note of them. That way I can easily re-create my rhythms in future practice sessions or performances.
ja: この種の構造で私がよくやるのは、よい感じの音がしたらシードを記録しておくことです。それにより、後で練習したりパフォーマンスしたりするときに、簡単にそのリズムを再生成することができます。

en: Finally, we can throw in some random bass to give it some nice melodic content. Notice that we can also use our newly discovered probabilistic sequencing method on synths just as well as samples. Don't leave it at that though - tweak the numbers and make your own track with the power of probabilities!
ja: 最後に、よい感じのメロディーを提供するランダムなベースを入れることができます。我々が新しく発見した確率的なシーケンスの方法は、サンプルと同じようにシンセに対しても同様に使用可能です。このコードをそのままにせずに、数字を操作して、確率の力であなた自身のトラックを是非作ってください！

en: This month we're going to take a deep dive into one of Sonic Pi's most powerful and flexible audio FX - the `:slicer`. By the end of this article you will have learned how to manipulate the overall volume of parts of our live coded sound in powerful new ways. This will allow you to create new rhythmic and timbral structures and broaden your sonic possibilities.
ja: 今月は、Sonic Piで最もパワフルでフレキシブルなエフェクトの1つである、`:slicer`を深く見ていきたいと思います。この記事の終わりまでに、ライブコーディングされたサウンドの全体的な音量を操作する、新しいパワフルな方法を習得できるでしょう。これは、新しいリズム的・音色的な構造を生成することができ、また音響的な可能性を広げることができるでしょう。

en: Slice that Amp
ja: あの音量をスライスしよう

en: So, what does the `:slicer` FX actually do? One way to think about it is that it's just like having someone play around with the volume control on your TV or home hi-fi. Let's take a look but first, listen to the deep growl of the following code which triggers the `:prophet` synth:
ja: 実際のところ、`:slicer`エフェクトは何をやってるのでしょうか？ 誰かがテレビやオーディオ製品のボリュームコントロールで遊んでいるのと同じようなものと考えてみるのも、1つの方法かもしれません。早速見ていきたいところですが、最初に`:prophet`をトリガーする次のコードの深い唸り声を聞いてみてください：

en: Now, let's pipe it through the `:slicer` FX:
ja: では、これを`:slicer`エフェクトに通してみましょう：

en: Hear how the slicer acts like it's muting and unmuting the audio with a regular beat. Also, notice how the `:slicer` affects all the audio generated between the `do`/`end` blocks. You can control the speed at which it turns the audio on and off with the `phase:` opt which is short for phase duration. Its default value is `0.25` which means 4 times a second at the default BPM of 60. Let's make it faster:
ja: `:slicer`が規則的なビートで音をミュートしたりしなかったりするのを聞いてみてください。また、`:slicer`が`do`/`end`ブロックの中で生成された全ての音に影響していることに注目してください。音のオン・オフの速さは、`phase duration`の短縮語である`phase:`オプションを使ってコントロールできます。`phase:`オプションのデフォルト値は`0.25`で、デフォルトのBPM60だと、1秒間に4回という意味になります。もっと速くしてみましょう：

en: Now, play with different `phase:` durations yourself. Try longer and shorter values. See what happens when you choose a really short value. Also, try different synths such as `:beep` or `:dsaw` and different notes. Take a look at the following diagram to see how different `phase:` values change the number of amplitude changes per beat.
ja: では、異なる`phase:`の長さで遊んでみましょう。長い値や短い値を試してみましょう。本当に短い値を選んだら何が起こるか見てみてください。また、`:beep`や`:dsaw`といった異なるシンセや、異なる音符も試してみましょう。次の図で、異なる`phase:`の値が、1拍の間に音の大きさを変更する回数をどのように変化させるか見てみましょう。

en: Phase duration is the length of time for one on/off cycle. Therefore smaller values will make the FX switch on and off much faster than larger values. Good values to start playing with are `0.125`, `0.25`, `0.5` and `1`.
ja: `phase duration`は、オン・オフの周期の時間の長さを示してします。したがって、より小さい値はエフェクトのオン・オフをより早く切り替えます。はじめに試してみるのに良さそうな値は、`0.125`, `0.25`, `0.5`, `1`でしょう。

en: Control Waves
ja: 波形を操作する

en: By default, the `:slicer` FX uses a square wave to manipulate the amplitude through time. This is why we hear the amplitude on for a period, then immediately off for a period, then back on again. It turns out that the square wave is just one of 4 different control waves that are supported by `:slicer`. The others are saw, triangle and (co)sine. Take a look at the diagram below to see what these look like. We can also hear what they sound like. For example, the following code uses (co)sine as the control wave. Hear how the sound doesn't turn on and off abruptly but instead smoothly fades in and out:
ja: デフォルトでは、`:slicer`エフェクトは音の大きさを操作するのに矩形波を使っています。一定時間音量がオンで聞こえてその後急にオフになるのは、これが理由です。矩形波は、`:slicer`がサポートしている4つの制御波形の1つであることが分かるでしょう。それ以外のものは、ノコギリ波、三角波、正弦波（または余弦波）です。下の図はそれぞれがどのような形をしているか示しています。また、それがどのような音がするのか聴くこともできます。例えば、次のコードは正弦波（または余弦波）を制御波形として使用しています。音が急にオン・オフせずにスムーズにフェードイン・フェードアウトするのを聴いてみてください。

en: Have a play with the different wave forms by changing the `wave:` opt to `0` for saw, `1` for square, `2` for triangle and `3` for sine. See how different waves sound with different `phase:` opts too.
ja: `wave:`オプションを変更することで、異なる波形で演奏してみましょう。`0`がノコギリ波、`1`が矩形波、`2`が三角波で、`3`が正弦波です。 また、異なる`phase:`オプションを組み合わせて、それぞれの波形がどのような音がするか試してみましょう。

en: Each of these waves can be inverted with the `invert_wave:` opt which flips it on the y axis. For example, in a single phase the saw wave typically starts high, and slowly goes down before jumping back to the top. With `invert_wave: 1` it will start low and slowly go up before jumping back down again. Additionally, the control wave can be started at different points with the `phase_offset:` opt which should be a value between `0` and `1`. By playing around with `phase:`, `wave:`, `invert_wave:` and `phase_offset` opts you can dramatically change how the amplitude is modified through time.
ja: これらの波形は、`invert_wave:`オプションでy軸方向に反転させることができます。例えば、典型的なノコギリ波は、高い値から始まり、徐々に値が下がっていって、ある時点で元の高い値に戻ります。`invert_wave: 1`を指定することで、低い値から始まり、徐々に値が上がっていって、ある時点で元の低い値に戻るようになります。また、波形操作は、`phase_offset:`オプションに`0`から`1`の値を指定することにより、波形の任意の位相から開始することができます。`phase:`, `wave:`, `invert_wave:`と`phase_offset`オプションを変更することで、時間に沿って音量をどれだけ変化させるかを、劇的に変更することができます。

en: Setting your levels
ja: 音量を設定する

en: By default, `:slicer` switches between amplitude values `1` (fully loud) and `0` (silent). This can be changed with the `amp_min:` and `amp_max:` opts. You can use this alongside the sine wave setting to create a simple tremolo effect:
ja: デフォルトでは、`:slicer`エフェクトは`1`（最大）と`0`（無音）の間の音量を切り替えます。これは、`amp_min:`と`amp_max:`オプションで変更できます。これを正弦波の設定に適用することで、シンプルなトレモロ効果を作ることができます：

en: This is just like grabbing the volume knob on your hi-fi and moving it up and down just a little so the sound 'wobbles' in and out.
ja: これはちょうど、オーディオ機器のボリュームつまみをひねって、音を`グラグラ`させるのに似ています。

en: Probabilities
ja: 確率

en: One of `:slicer`'s powerful features is its ability to use probability to choose whether or not to turn the slicer on or off. Before the `:slicer` FX starts a new phase it rolls a dice and based on the result either uses the selected control wave or keeps the amplitude off. Let's take a listen:
ja: `:slicer`エフェクトのパワフルな特長の1つは、スライサーをオン・オフするかしないかを選択するのに、確率を使用可能なことでしょう。`:slicer`エフェクトが次の位相を開始する前にサイコロを振って、その結果をもとに選択した波形を使うかもしくは音量をオフにしたままにするかします。聞いてみましょう：

en: Hear how we now have an interesting rhythm of pulses. Try changing the `probability:` opt to a different value between `0` and `1`. Values closer to `0` will have more space between each sound due to the likelihood of the sound being triggered being much lower.
ja: 興味深いパルスのリズムを生成できたのを聞くことができるでしょう。試しに、`probability:`オプションを`0`から`1`の間の値に変更してみましょう。`0`に近い値にすると、音がトリガーされる確率がより低くなるため、それぞれの音の間が広がるでしょう。

en: Another thing to notice is that the probability system in the FX is just like the randomisation system accessible via fns such as `rand` and `shuffle`. They are both completely deterministic. This means that each time you hit Run you'll hear exactly the same rhythm of pulses for a given probability. If you would like to change things around you can use the `seed:` opt to select a different starting seed. This works exactly the same as `use_random_seed` but only affects that particular FX.
ja: 他にお伝えしたいのは、`:slice`エフェクトにおけるランダム化システムは、`rand`や`shuffle`といった関数経由でアクセス可能なランダム化システムとちょうど同じであるということです。これらはどちらも完全に決定的です。これは`Run`を叩いたときに、指定された確率に対応して毎回同じパルスのリズムを聞くことになることを意味しています。これらを変更したい場合には、`seed:`オプションを使って異なるシードを選択することが可能です。これは`use_random_seed`と全く同じように動作しますが、特定のエフェクトにのみ影響します。

en: Finally, you can change the 'resting' position of the control wave when the probability test fails from `0` to any other position with the `prob_pos:` opt:
ja: 最後に、確率的にオフになった場合に制御波形内の'休止する'位置を、`prob_pos:`オプションを使って`0`から他の値に変更できます：

en: Slicing Beats
ja: ビートをスライスする

en: One really fun thing to do is to use `:slicer` to chop a drum beat in and out:
ja: `:slicer`エフェクトでドラムビートをブツ切りするのは、やってみると本当に楽しいことの1つです：

en: Changing tempo
ja: テンポを変更する

en: As we have already seen, changing the default BPM with `use_bpm` will make all the sleep times and synth envelope durations grow or shrink to match the beat. The `:slicer` FX honours this too, as the `phase:` opt is actually measured in beats not seconds. We can therefore fix the issue with `loop_amen` above by changing the BPM to match the sample:
ja: 既に見てきたように、`use_bpm`でデフォルトのBPMを変更すると、全てのsleepの長さとシンセのエンベロープの長さがビートに一致するように伸縮されます。`:slicer`エフェクトの`phase:`オプションな実際には秒単位でなく拍単位なので、同じようにこれを受け入れることができます。したがって、BPMを変更してサンプルに一致させることで、上の`loop_amen`の問題を解決できます。

en: Let's apply all these ideas into a final example that only uses the `:slicer` FX to create an interesting combination. Go ahead, start changing it and make it into your own piece!
ja: 最後に、これらのアイデアを全て適用して1つの例にしましょう。`:slicer`エフェクトのみを使って、興味深い組み合わせを作り出してみましょう。ここから変更して自分自身の作品にしてみましょう！

en: A.15 Five Live Coding Techniques
ja: A.15 ライブコーディング5つのテクニック

en: Five Live Coding Techniques
ja: ライブコーディング5つのテクニック

en: In this month's Sonic Pi tutorial we're going to take a look at how you can start treating Sonic Pi like a real instrument. We therefore need to start thinking of code in a completely different way. Live coders think of code in a similar way to how violinists think of their bow. In fact, just like a violinist can apply various bowing techniques to create different sounds (long slow motions vs short fast hits) we will explore five of the basic live coding techniques that Sonic Pi enables. By the end of this article you'll be able to start practicing for your own live coded performances.
ja: 今月のチュートリアルでは、Sonic Piを本物の楽器と同じように扱う方法を見ていきたいと思います。そのため、コードについて今までと全く異なる見方で考える必要があります。ライブコーダーはコードを、バイオリニストにとっての弓と同じように考えています。実際、バイオリニストが異なる音を作るのに様々な弓のテクニックを適用する（長くゆっくりとした動きと短く速い打弦）のとちょうど同じように、Sonic Piで可能な基本的なライブコーディングのテクニックを5つ見ていきます。この記事の終わりまでに、あなたはライブコーディングのパフォーマンスの練習を始めることが出来ているでしょう。

en: 1. Memorise the Shortcuts
ja: 1. ショートカットを覚える

en: The first tip to live coding with Sonic Pi is to start using the shortcuts. For example, instead of wasting valuable time reaching for the mouse, moving it over to the Run button and clicking, you can simply press `alt` and `r` at the same time which is much faster and keeps your fingers at the keyboard ready for the next edit. You can find out the shortcuts for the main buttons at the top by hovering the mouse over them. See section 10.2 of the built-in tutorial for the full list of shortcuts.
ja: Sonic Piでライブコーディングする際の最初のヒントは、ショートカットを使うことです。例えば、マウスに手を伸ばして`Run`ボタンに合わせてクリックするのに貴重な時間を無駄にするよりも、単に`alt`と`r`を同時に押すことが可能です。これは速いし、指がキーボードに置かれたままなので、次の編集のための準備が整っています。ショートカットを探すには、画面上部のボタンにそれぞれマウスを乗せると表示されます。ショートカットの一覧を見るには、チュートリアルの10.2を参照してください。

en: When performing, one fun thing to do is to add a bit of flair with your arm motion when hitting shortcuts. For example, it's often good to communicate to the audience when you're about to make a change - so embellish your movement when hitting `alt-r` just like a guitarist would do when hitting a big power chord.
ja: パフォーマンスの際、1つやってみると面白いのは、ショートカットを叩くときの動作に少し装飾を追加してみることです。例えば、あなたが音を変更しようとするときにそれを観客に伝えるのは良いことです。したがって、`alt-r`を叩く際の動作を飾るのはギタリストがパワーコードを掻き鳴らすのとちょうど同じことなのです。

en: 2. Manually Layer your Sounds
ja: 2. 手動で音を重ねる

en: Now you can trigger code instantly with the keyboard, you can instantly apply this skill for our second technique which is to layer your sounds manually. Instead of 'composing' using lots of calls to `play`, and `sample` separated by calls to `sleep` we will have one call to `play` which we will manually trigger using `alt-r`. Let's try it. Type the following code into a fresh buffer:
ja: コードをキーボードから素早く実行できるようになったら、そのスキルは、手動で音を重ねる2つめのテクニックに適用できます。たくさんの`play`と`sample`の呼び出しを`sleep`で挟んで'作曲'する代わりに、1つの`play`の呼び出しを`alt-r`で手動で実行してみたいと思います。では試してみましょう。次のコードを新しいBufferにタイプしてみてください：

en: Now, hit `Run` and whilst the sound is playing, modify the code in order to drop down four notes by changing it to the following:
ja: タイプしたら、`Run`を叩いて音を出してみてください。音が出ている間に、次のコードのように、4音下げるためにコードを変更してください：

en: Now, hit `Run` again, to hear both sounds playing at the same time. This is because Sonic Pi's `Run` button doesn't wait for any previous code to finish, but instead starts the code running at the same time. This means you can easily layer lots of sounds manually with minor or major modifications between each trigger. For example, try changing both the `note:` and the `cutoff:` opts and then re-trigger.
ja: では、再度`Run`を叩いてみてください。両方の音がそのまま再生されているが聞こえると思います。これは、Sonic Piの`Run`が前回実行したコードが終わるのを待つたずに、新しいコードを開始するためです。これは、実行の度に多少の変更を加えることで、簡単にたくさんの音を重ねることが可能ということです。例えば、`note:`と`cutoff:`オプションの両方を変更して、再度実行してみてください。

en: You can also try this technique with long abstract samples. For example:
ja: また、このテクニックは長いアブストラクトなサンプルでも試すことができます。例えば、次のコードです：

en: Try starting the sample off, and then progressively halving the `rate:` opt between hitting `Run` from `1` to `0.5` to `0.25` to `0.125` and then even try some negative values such as `-0.5`. Layer the sounds together and see where you can take it. Finally, try adding some FX.
ja: 最初はサンプル無しで始めて、`Run`を叩く度に、`rate:`オプションを`1`から`0.5`, `0.25`, `0.125`に変更し、さらに`-0.5`のような負の値も試してみましょう。音を重ね合わせてどう聞こえるか試してみてください。最後に何かエフェクトを追加してみてください。

en: When performing, working with simple lines of code in this way means that an audience new to Sonic Pi has a good chance to follow what you're doing and relate the code that they can read to the sounds they are hearing.
ja: パフォーマンスの際にこのようなシンプルなコードを使用すると、Sonic Piにあまり馴染みのない観客にとっては、あなたが何をしているのかを追ったり、コードと音を関連付けたりするのに良い機会になると言えるでしょう。

en: 3. Master Live Loops
ja: 3. ライブループをマスターする

en: When working with more rhythmic music, it can often be hard to manually trigger everything and keep good time. Instead, it is often better to use a `live_loop`. This provides repetition for your code whilst also giving the ability to edit the code for the next time round the loop. They also will run at the same time as other `live_loop`s which means you can layer them together both with each other and manual code triggers. Take a look at section 9.2 of the built-in tutorial for more information about working with live loops.
ja: もっとリズミカルな音楽の場合、全てを手動で実行しながら良いタイミングを保つのは難しいでしょう。その場合は、`live_loop`を使うのが良いでしょう。これはコードを繰り返しつつ、次にループが先頭に戻ったときに実行されるように、コードを編集できる機能を提供しています。また、ライブループは他の`live_loop`と同時に実行でき、それはすなわち、ライブループ同士を重ねたり、他に手動で実行したコードと重ねたりすることが可能ということです。ライブループに関するより詳細な情報については、チュートリアルの9.2を参照してください。

en: When performing, remember to make use of `live_loop`'s `sync:` opt to allow you to recover from accidental runtime mistakes which stop the live loop running due to an error. If you already have the `sync:` opt pointing to another valid `live_loop`, then you can quickly fix the error and re-run the code to re-start things without missing a beat.
ja: パフォーマンスの際には、`live_loop`の`sync:`を使うことを覚えておくと良いでしょう。これは、エラーによってライブループの実行が止まってしまった場合の回復手段として役に立ちます。もし既に`sync:`が他の正常に動作している`live_loop`を指しているのであれば、エラーをすぐに修正してコードを再実行することで、ビートが欠いた状態を解消して再起動できるでしょう。

en: After you run this code, all existing and new sounds will have a low pass filter applied to them and will therefore sound more muffled. Note that this means that the new mixer values stick until they are changed again. However, if you want, you can always reset the mixer back to its default state with `reset_mixer!`. Some of the currently supported opts are: `pre_amp:`, `lpf:` `hpf:`, and `amp:`. For the full list, see the built-in docs for `set_mixer_control!`.
ja: このコードの実行後、既に出ている音とこれから出てくる音の全てにローパスフィルタが適用されるので、ぼんやりとした音になります。これは、先程のコードで設定されたミキサーの値が、再び変更されるまで保持されることを意味しています。しかし、もし値をリセットしたい場合には、`reset_mixer!`でいつでもデフォルトの状態に戻すことができます。現在対応しているオプションには、`pre_amp:`, `lpf:`, `hpf:`,`amp:`があります。全てのオプションの一覧については、`set_mixer_control!`のドキュメントを参照してください。

en: Use the mixer's `*_slide` opts to slide one or many opts values over time. For example, to slowly slide the mixer's low pass filter down from the current value to 30, use the following:
ja: オプションの値を時間に沿ってスライドさせるために、ミキサーの`*_slide`オプションを使ってみましょう。例えば、ミキサーのローパスフィルタを現在の値から30にゆっくりスライドさせるには、次のコードを使ってみてください：

en: You can then slide quickly back to a high value with:
ja: 次に、高い値に素早くスライドして戻すこともできます：

en: When performing, it's often useful to keep a buffer free for working with the mixer like this.
ja: パフォーマンスの際には、ここでやったようにミキサーのためのBufferを空けておくと便利でしょう。

en: 5. Practice
ja: 5. 練習

en: The most important technique for live coding is practice. The most common attribute across professional musicians of all kinds is that they practice playing with their instruments - often for many hours a day. Practice is just as important for a live coder as a guitarist. Practice allows your fingers to memorise certain patterns and common edits so you can type and work with them more fluently. Practice also gives you opportunities to explore new sounds and code constructs.
ja: ライブコーディングの最も重要なテクニックは練習です。すべてのプロのミュージシャンに共通する点は、自分の楽器を練習することです。多くの場合、1日に何時間も練習しています。ギタリストと同じようにライブコーダーにとっても練習は重要です。練習によってあなたの指は特定のパターンや一般的な編集内容を覚えるので、入力や作業がよりスムーズに行えます。練習はまた、新しい音やコード構成を探求する機会をあなたに提供します。

en: When performing, you'll find the more practice you do, the easier it will be for you to relax into the gig. Practice will also give you a wealth of experience to draw from. This can help you understand which kinds of modifications will be interesting and also work well with the current sounds.
ja: パフォーマンスの際には、やってきた練習が多ければ多いほど、緊張せずにライブに入ることが簡単になると気づくでしょう。練習はまたそこから豊富な経験を提供するでしょう。それにより、どんな種類の変更が面白く、また現在の音に上手く作用するか分かるようになるでしょう。

en: A.16 How to Practice Live Coding
ja: A.16 ライブコーディングの練習方法

en: 8 Tips for Live Coding Practice
ja: ライブコーディング練習の8つのヒント

en: Last month we took a look at five important techniques for mastering live coding - in other words, we explored how we could use Sonic Pi to approach code in the same way we would approach a musical instrument. One of the important concepts that we discussed was practice. This month we're going to take a deeper dive into understanding why live coding practice is important and how you might start.
ja: 先月は、ライブコーディングをマスターするための5つの重要なテクニックを見ました。言い換えると、楽器と同じようなやり方でコードに接するために、どのようにSonic Piを使うことができるか探求しました。そして、我々が議論した重要なコンセプトの1つに、練習がありました。今月は、なぜライブコーディングの練習が重要で、それをどのように始めるかについて、理解を深めて行きたいと思います。

en: Practice regularly
ja: 定期的に練習しよう

en: The most important piece of advice is to make sure you practice regularly. As a rule I typically practice for 1-2 hours a day, but 20 mins is just fine when you're starting out. Little but often is what you're aiming for - so if you can only manage 10 minutes, that's a great start.
ja: 最も重要なアドバイスとしては、必ず定期的に練習することです。私自身は1日1-2時間練習するようにしていますが、最初は20分でもよいでしょう。少しの時間でも頻繁に練習することを目標にしましょう。もし10分しか捻出できなかったとしても、良いスタートになります。

en: Practice tip #1 - start to develop a practice routine. Find a nice time in the day that works for you and try and practice at that time as many days of the week as you can. Before long you'll be looking forward to your regular session.
ja: 練習のヒント #1 - 練習ルーチンを開発する。あなたにとって都合の良い時間を見つけて、週のうち可能な限り多くの日にその時間で練習するようにしてみましょう。いずれ定期的なセッションが楽しみになると思います。

en: Learn to Touch Type
ja: ブラインドタッチを習得する

en: If you watch a professional musician performing on stage you'll likely notice a few things. Firstly, when they play they don't stare at their instrument. Their fingers, arms and bodies know which keys to press, strings to pluck or drums to hit without them having to think about it too much. This is known as "muscle memory" and although it might sound like something only professionals can do - it's just the same as when you first learned to walk or ride a bike - practicing through repetition. Live coders use muscle memory to free their minds from having to think about where to move their fingers so they can focus on the music. This is called touch-typing - typing without having to look at the keyboard.
ja: ステージで演奏するプロのミュージシャンを見ると、いくつか気が付くことがあると思います。最初に、彼らが演奏するとき楽器を凝視することはないでしょう。指と腕と体が、どのキーを押すか、どの弦を弾くか、どのドラムを叩くかを、深く考えること無く覚えていると思います。これは"運動記憶"として知られているもので、プロの人達だけが出来ることのように聞こえるかもしれませんが、あなたが繰り返し練習して歩いたり自転車に乗ったりできるようになったことと同じです。ライブコーダーはどこに指を動かせば良いか考えずに済むように運動記憶を使い、それによって音楽に集中するのです。これはブラインドタッチと呼ばれるもので、キーボードを見ることなくタイプすることです。

en: Practice tip #2 - learn how to touch type. There are many apps, websites and even games which can help you achieve this. Find one you like the look of and stick at it until you can code without looking down.
ja: 練習のヒント #2 - ブラインドタッチを習得する。ブラインドタッチを習得するためのアプリケション、ウェブサイト、さらにはゲームが数多くあります。どれか好きなものを探して、キーボードを見ずにコーディングできるまで続けてみましょう。

en: Code whilst standing
ja: 立ったままコーディングする

en: The body of a musician is conditioned for playing their instrument. For example, a trumpet player needs to be able to blow hard, a guitar player needs to be able to grip the fretboard with strength and a drummer needs to be able to continually hit the drums for long periods of time. So, what's physical about live coding? Just like DJs, live coders typically perform whilst standing up and some even dance whilst they code! If you practice live coding whilst sitting at a desk and then have to get up and stand at a gig, you'll likely find the difference very difficult and frustrating.
ja: ミュージシャンの体は、それぞれの楽器を演奏するように調整されています。例えば、トランペット奏者は強く吹ける必要がありますし、ギタープレイヤーはフレットを強く握れる必要がありますし、ドラマーは長い時間繰り返し叩くことができる必要があります。では、ライブコーディングではどうでしょうか？ ライブコーダーは典型的にはDJのように立ちながらパフォーマンスします。さらには踊りながらということさえあります。ライブコーディングを座ったままで練習して、ライブの際に立たなければならない場合、その違いがとても難しくイライラさせるでしょう。

en: Practice tip #3 - stand whilst you practice. The easiest way to do this is to use a standing height desk. However, if like me you don't have one at home, there's a couple of low-fi options. The approach I take is to use an ironing board which happens to work rather well. Another is to stack some boxes or large books on a normal desk and place your keyboard on top of that. Also, make sure you stretch before you start practicing and try and dance a little during the session. Remember, nobody is watching you, so have fun and you'll feel much more natural on stage.
ja: 練習のヒント #3 - 立って練習する。これを実現するのに最も簡単な方法は、スタンディングデスクを使うことです。しかし、もしスタンディングデスクが家に無い場合にも、いくつかローファイな選択肢があります。私はアイロン台を使っていますが、意外に使いやすいです。他にも何かの箱や大きい本を普通の机に置いて、その上にキーボードを置くこともできます。また、練習前にストレッチしておいたり、セッション中に少し踊ってみたりするのもよいでしょう。誰も見ていないので、楽しんでやってみましょう。そうすれば、ステージで緊張しなくなるでしょう。

en: Practice setting up
ja: 準備の練習

en: Most instruments require some assembly and tuning before they can be played. Unless you're a rockstar with a bus full of roadies, you'll have to set up your own instrument before your gig. This is often a stressful time and it is easy for problems to occur. One way to help with this is to incorporate the setup process into your practice sessions.
ja: 多くの楽器は、演奏する前にそれを組み立てたりチューニングしたりする必要があります。あなたがバスいっぱいの会場設営スタッフを抱えるロックスターでも無い限り、ライブの前に自分の楽器を準備しなければなりません。これはしばしばストレスの掛かる作業で、問題が発生しやすいです。これに対処する1つの方法は、練習セッションの際に準備のプロセスを組み込んでしまうことです。

en: Practice tip #4 - treat setting up as an important part of your practice. For example, have a box or bag that you can keep your Raspberry Pi and keyboard in etc. Before each practice session, take out all the parts, connect everything, and work through the boot process until you have Sonic Pi running and can make sounds. Once you've finished practicing, take the time to carefully pack everything away afterwards. This may take some time at first, but before long you'll be able to setup and pack everything away incredibly quickly without having to think about it.
ja: 練習のヒント #4 - 準備を練習の重要な部分として扱う。例えば、Raspberry Piやキーボードを入れておく箱やバッグを用意します。練習セッションの前に、毎回全ての部品を取り出して接続し、Sonic Piが実行されて音が出るまでの起動プロセスを一通り作業してください。練習が終わったら、時間を取って慎重に全てを詰め直してください。これは最初は時間が掛かるかもしれませんが、あなたはすぐに何も考えずに非常に素早く準備と片付けが出来るようになるでしょう。

en: Experiment Musically
ja: 音楽的に実験する

en: Once you've set up and are ready to start making music, you might find yourself struggling to know where to start. One problem many people face is that they might have a good idea of the kinds of sounds they want to make, but are frustrated that they can't produce them. Some people don't even know what kind of sounds they want to make! The first thing to do is not to worry - this is very common and happens to every musician - even if they've been practicing for a long time. It is much more important to be making sounds you don't like than not making any sounds at all.
ja: 音楽を作り始める準備ができたとき、どこから初めて良いか分からないかもしれません。多くの人々が直面する問題の1つは、作りたい音楽がどのようなものであるかは良いアイデアを持っていても、それを作り出すことができずにフラストレーションがたまることではないでしょうか。さらに、自分がどのような音がを作りたいか分かっていない人々さえ居ます！ これらに対して第一にやることは、心配しないことです。これはミュージシャンにはよくあることで、長年練習を積み重ねたミュージシャンも例外ではありません。全く何も音を出さないよりも、好みではなくとも何か音を出すことが重要です。

en: Practice tip #5 - spend time making sounds and music you don't like. Try to make time to explore new sounds and ideas. Don't worry that it might sound terrible if it's not the style you're looking for. When you're experimenting like this you increase the chance of stumbling over a sound or combination of sounds which you love! Even if 99% of the sounds you make are bad, that 1% might be the riff or intro to your new track. Forget the things you don't like and remember the parts you do. This is even easier when you're making music with code - just hit save!
ja: 練習のヒント #5 - 好みでない音を作るのに時間を使う。新しい音やアイデアの探求に時間を使いましょう。それがあなたの探しているスタイルでなくひどい音がしても気にしないようにしましょう。実験すると、あなたの好きな音や音の組み合わせに出会う機会を増えるのです。99％の音が悪くても1％があなたの新しい曲のリフやイントロになるかもしれないのです。好みでないものは忘れ、好みのものを覚えておくようにしましょう。これは、コードで音楽を作っていれば全く簡単でしょう。保存を押すだけです！

en: Hear the Code
ja: コードを聞く

en: Practice tip #6 - write some code into Sonic Pi but don't hit the Run button. Instead, try to imagine what sound it is going to produce. Then, hit Run, listen, and think about what you got right and what you didn't. Keep repeating this until it become a natural part of your coding process. When I practice I normally have a good idea of what the code will sound like. However, I still am occasionally surprised, and then I'll stop and spend some time thinking about why I was wrong. Each time this happens, I learn new tricks which allow me to express myself in new ways.
ja: 練習のヒント #6 - Sonic Piにコードを書いても`Run`を押さない。その代わり、それがどのような音を作り出すか想像してみてください。次に、`Run`を叩いて聞いてみましょう。何が想像した音と合っていて何が合っていなかったか考えましょう。これを、あなたのコーディングのプロセスの一部になるまで繰り返してください。私が練習するとき、普通はコードがどのような音がするか想像できています。しかし、想像していなかった音が未だに出ることがあって驚くことがあります。そのときは、そこで止まって、時間を取ってなぜ私が間違っていたか考えるようにしています。このようなことが起こる度に、私は新しい方法で自分を表現できる新しい技を学んでいます。

en: Remove all distractions
ja: 気が散るものを全て取り除く

en: A common problem when practicing is to become distracted with other things. Practicing is hard and requires real discipline regardless of the kind of music you're making - from jazz to classical to EDM. If you're struggling to get started or make progress, it's often too easy to hop on social media, or look something up on the internet etc. If you've set yourself a target of 20 minutes of practice, it's important to try and spend all that time being as productive as possible.
ja: 練習の際の一般的な問題は、他のことに邪魔されることです。練習は、それがどのような種類の音楽（ジャズからクラシック、ダンス・ミュージック）であれ、過酷で本当の訓練を必要とします。もしあなたが練習を始めたり、進めるのに苦労しているのであれば、それはしばしばソーシャルメディアにアクセスしたり、インターネット上の何かを見るのが簡単すぎることが原因でしょう。仮にあなたが20分間の練習を目標とした場合、その20分間の間可能な限り生産的であるようにすることが重要です。

en: Practice tip #7 - before you start practicing remove as many distractions as possible. For example, disconnect from the internet, put your phone in another room and try to practice in a quiet place where you're unlikely to be disturbed. Try to focus on coding music and you can return to your distractions when you've finished.
ja: 練習のヒント #7 - 練習を始める前に可能な限り気が散るものを取り除く。例えば、インターネットを切断したり、電話を他の部屋に置いたりして、不意に気をそらされない静かな場所で練習するようにしましょう。練習が終われば、またそれらの気をそらすものに戻れるので、それまでは音楽のコーディングに集中するようにしましょう。

en: Keep a practice diary
ja: 練習日記をつける

en: When you are practicing, you'll often find your mind is full of new exciting ideas - new musical directions, new sounds to try out, new functions to write, etc. These ideas are often so interesting that you might stop what you're doing and start working on the idea. This is another form of distraction!
ja: あなたが練習している最中、気がつくと、音楽の方向、試してみたい音、書いてみたい関数など、新しい刺激的なアイデアで頭がいっぱいになることがあるかもしれません。これらのアイデアはしばしばとても面白そうなので、練習をやめてそのアイデアを作業してしまうかもしれません。これは、別な形の'気が散るもの'と言えるでしょう！

en: Practice tip #8 - keep a practice diary by your keyboard. When you get an exciting new idea, temporarily pause your practice session, quickly jot the idea down, then forget about it and carry on practicing. You can then spend some quality time thinking about and working on your ideas after you've finished practicing.
ja: 練習のヒント #8 - 練習日記をつける。刺激的な新しいアイデアが浮かんだら、一時的に練習セッションを停止し、素早くアイデアを書き留めてください。そして、そのアイデアのことは忘れて、練習を続けてください。そうすれば、練習が終わった後、そのアイデアを集中して検討したり作業できるのです。

en: Try to establish a practice routine which incorporates as many of these ideas as possible. Try to keep the sessions as fun as possible but be aware that some practice sessions will be hard and feel a little like work. However, it will all be worth it once you've created your first piece or given your first performance. Remember, practice is the key to success!
ja: ここで紹介したアイデアを可能な限り取り込んだ練習ルーチンを確立するようにしてください。練習セッションは可能な限り楽しくしておくべきですが、ときには練習セッションは過酷で仕事のように感じることもあるでしょう。しかしながら、一度初めての作品を完成させたり、初めてのパフォーマンスを成功させたりしたら、練習はその価値があったと言えるでしょう。覚えておいてください、練習は成功の鍵なのです！

en: A.17 Sample Stretching
ja: A.17 サンプル ストレッチ

en: sample :loop_amen, rate: 1
ja: sample :loop_amen, rate: -1

en: Essential Knowledge
ja: 不可欠な知識

en: This section will cover some very useful - in fact *essential* - knowledge for getting the most out of your Sonic Pi experience.
ja: この章では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.
ja: 利用可能な多くのキーボードのショートカットを活用する方法と、作品を共有する方法、そしてSonic Piでパフォーマンスする際のいくつかのヒントを見ていきます。

en: Using Shortcuts
ja: ショートカットの使用

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.
ja: Sonic Piは、コーディング環境であると同時に楽器でもあります。したがって、あなたが観客の前でライブ演奏している場合は特に、ショートカットを使うことで、はるかに*効率的で自然に*Sonic Piの演奏を行うことができます。

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!
ja: Sonic Piの多くの機能は、キーボードを介して制御することができます。Sonic Piの演奏や作業により慣れるために、ショートカットをもっと使いこなしましょう。私個人はブラインドタッチができ（あなたにも習得をお勧めします）、マウスを使う必要があるときにはいつも、動作が遅れるのでイライラしてしまいます。このため、私は普段からこれらのショートカットのすべてを使っています！

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.
ja: ショートカットを学べば、効果的にキーボードを使用でき、すぐにプロのようなライブコーディングができるようになるでしょう。

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.
ja: しかし、*一度にすべてを憶えようとしない*で、最初はあなたが最も使うものを試しながら憶えていき、その後継続して他のショートカットを追加していくと良いでしょう。

en: Consistency across Platforms
ja: プラットフォーム間での一貫性

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.
ja: クラリネットを習っているところを想像してみてください。すべてのクラリネットは、指使いや操作の全てが一貫してしていることを前提として作られていますが、もしそうでなかったら、別のクラリネットに乗り換えるには大変な時間を費やしてしまうだろうし、1回だけの制作のためにそれを使用することについて戸惑ってしまうでしょう。

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.
ja: 残念なことに3つの主要なオペレーティングシステム（Linux、Mac OS XおよびWindows）では、カット＆ペーストなどの操作のために独自の基準が用意されています。Sonic Piは、これらの基準を尊重します。しかしながら、Sonic Piでは、プラットフォームの基準に対応することよりも、*プラットフォーム間での一貫性を優先しています*。これはRaspberry PiでSonic Piを演奏してショートカットを学んだら、MacやPCに乗り換えても違和感無く同じように操作できることを意味しています。

en: Control and Meta
ja: Controlと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.
ja: 一貫性への考え方のひとつにショートカットの命名があります。Sonic Piにおいて、主要な2つの組み合わせキーを当てはめるために、*Controlキー*と*Metaキー*を用います。すべてのプラットフォームでは、*Controlキー*は同じです。しかし、LinuxとWindowsでは、実際の*Metaキー*はAltキーで、Macの*Metaキー*は*コマンド⌘キー*です。一貫性のために、*Metaキー*という言葉を使いますが、あなたのオペレーティングシステムにおける適切なキーに置き換えるようにしてください。

en: Abbreviations
ja: 略語

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."
ja: シンプルで読みやすくするために、*Ctrlキー*＋その他のキーは「*C-*」、*Metaキー*＋その他のキーは「*M-*」の略語を使います。例えば、あるショートカットが*Metaキー*と'r'を同時に押さえる必要がある場合、「*M-r*」と表記します。そして、*-*は、"同時に押さえる"を意味しています。

en: The following are some of the shortcuts I find most useful.
ja: 以下は、僕が見つけたとっても有用なショートカットのいくつかです。

en: Stopping and starting
ja: 停止と開始

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`.
ja: マウスを使う代わりに、`M-r`でコードを実行することができます。同様に、`M-s`でコードを停止することができます。

en: Navigation
ja: ナビゲーション

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.
ja: ナビゲーションのショートカットを使わない操作は実にもどかしいです。そのため、ショートカットを学ぶことに時間を費やすことを強くお勧めします。ブラインドタッチを習得すれば、マウスやキーボードの矢印キーに手を移動させる必要が無くなるので、これらのショートカットをさらに有効に活用することができます。

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`.
ja: 行の先頭に移動するには`C-a`、行の末尾に移動するには`C-e`、1行上は`C-p`、1行下がるには`C-n`、1文字進むには`C-f`、そして、1文字戻るには`C-b`。`C-k`でカーソルから行の末尾まで全ての文字を消去する事ができます。

en: Tidy Code
ja: コードの整形

en: To auto-align your code simply press `M-m`.
ja: コードを自動整形するには`M-m`を押します。

en: Help System
ja: ヘルプシステム

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!
ja: ヘルプシステムを切り替えるには、`M-i`を押します。しかし、何かを見つける場合、もっとはるかに便利なショートカットは、カーソル下の単語検索し、ドキュメントを表示する`C-i`です。簡単でしょう！

en: Shortcut Cheatsheet
ja: ショートカット一覧表

en: Conventions
ja: 規定

en: In this list, we use the following conventions (where *Meta* is one of *Alt* on Windows/Linux or *Cmd* on Mac):
ja: このリストでは下記の規定に準拠します（WindowsとLinuxの*Meta*キーは*Alt*キー、そしてMacは*Cmd*キー）:

en: `C-a` means hold the *Control* key then press the *a* key whilst holding them both at the same time, then releasing.
ja: `C-a` は*Control*キーを押さえながら*a*キー、両方を同時にを押した後に離す事を意味しています。

en: `M-r` means hold the *Meta* key and then press the *r* key whilst holding them both at the same time, then releasing.
ja: `M-r` は*Meta*キーを押さえながら*r*キー、両方を同時にした後に離す事を意味しています。

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.
ja: `S-M-z` は*Shift*キーを押さえながら*Meta*キー、そして最後に*z*キー全てを同時に押した後に離す事を意味しています。

en: `C-M-f` means hold the *Control* key, then press *Meta* key, finally the *f* key all at the same time, then releasing.
ja: `C-M-f`は*Control* キーを押さえながら*Meta*キー、そして最後に*f*キー全てを同時に押した後に離す事を意味しています。

en: Main Application Manipulation
ja: 主なアプリケーションの操作

en: `M-r` - Run code
ja: `M-r` - コードを実行

en: `M-s` - Stop code
ja: `M-s` - コードを停止

en: `M-i` - Toggle Help System
ja: `M-i` - ヘルプシステムを表示

en: `M-p` - Toggle Preferences
ja: `M-p` - 設定を表示

en: `M-{` - Switch buffer to the left
ja: `M-{` - 左のBufferに切り替え

en: `M-}` - Switch buffer to the right
ja: `M-}` - 右のBufferに切り替え

en: `M-+` - Increase text size of current buffer
ja: `M-+` - 文字サイズを大きく

en: `M--` - Decrease text size of current buffer
ja: `M--` - 文字サイズを小さく

en: Selection/Copy/Paste
ja: 選択/コピー/張り付け

en: `M-a` - Select all
ja: `M-a` - 全てを選択

en: `M-c` - Copy selection to paste buffer
ja: `M-c` - 選択箇所をコピー

en: `M-]` - Copy selection to paste buffer
ja: `M-]` - 選択箇所をコピー

en: `M-x` - Cut selection to paste buffer
ja: `M-x` - 選択箇所をカット

en: `C-]` - Cut selection to paste buffer
ja: `C-]` - 選択箇所をカット

en: `C-k` - Cut to the end of the line
ja: `C-k` - カーソルから行の末尾まで全ての文字を消去する

en: `M-v` - Paste from paste buffer to editor
ja: `M-v` - エディタへ張り付け

en: `C-y` - Paste from paste buffer to editor
ja: `C-y` - エディタへ張り付け

en: `C-SPACE` - Set mark. Navigation will now manipulate highlighted region. Use `C-g` to escape.
ja: `C-SPACE` - マークを設定します。以降のナビゲーション操作で選択箇所を変更できます。`C-g`でマークを解除します。

en: Text Manipulation
ja: 文字の操作

en: `M-m` - Align all text
ja: `M-m` - テキストを整形

en: `Tab` - Align current line or selection (or select autocompletion)
ja: `Tab` - 現在の行または選択箇所のテキストを整形（または、自動補完を選択）

en: `C-l` - Centre editor
ja: `C-l` - 真ん中へ移動

en: `M-/` - Comment/Uncomment current line or selection
ja: `M-/` - 現在の行または選択箇所をコメント／コメント解除

en: `C-t` - Transpose/swap characters
ja: `C-t` - カーソルの前後の文字を入れ替え

en: `M-u` - Convert next word (or selection) to upper case.
ja: `M-u` - カーソルの後ろの単語（または選択箇所）を大文字に変換

en: `M-l` - Convert next word (or selection) to lower case.
ja: `M-l` - カーソルの後ろの単語（または選択箇所）を小文字に変換

en: `C-a` - Move to beginning of line
ja: `C-a` - 行の先頭に移動

en: `C-e` - Move to end of line
ja: `C-e` - 行の末尾に移動

en: `C-p` - Move to previous line
ja: `C-p` - ひとつ前の行に移動

en: `C-n` - Move to next line
ja: `C-n` - 次の行に移動

en: `C-f` - Move forward one character
ja: `C-f` - 一文字進む

en: `C-b` - Move backward one character
ja: `C-b` - 一文字戻る

en: `M-f` - Move forward one word
ja: `M-f` - 一単語進む

en: `M-b` - Move backward one word
ja: `M-b` - 一単語戻る

en: `C-M-n` - Move line or selection down
ja: `C-M-n` - 現在の行または選択箇所を下に移動

en: `C-M-p` - Move line or selection up
ja: `C-M-p` - 現在の行または選択箇所を上に移動

en: `S-M-u` - Move up 10 lines
ja: `S-M-u` - 10行上に移動

en: `S-M-d` - Move down 10 lines
ja: `S-M-d` - 10行下に移動

en: `M-<` - Move to beginning of buffer
ja: `M-<` - Bufferの先頭に移動

en: `M->` - Move to end of buffer
ja: `M->` - Bufferの末尾に移動

en: Deletion
ja: 削除

en: `C-h` - Delete previous character
ja: `C-h` - 前の文字を削除

en: `C-d` - Delete next character
ja: `C-d` - 次の文字を削除

en: Advanced Editor Features
ja: 高度なエディタの機能

en: `C-i` - Show docs for word under cursor
ja: `C-i` - カーソルの下の単語のドキュメントを表示

en: `M-z` - Undo
ja: `M-z` - アンドゥ（行った操作を取り消し、元の状態に戻る）

en: `S-M-z` - Redo
ja: `S-M-z` - リドゥ（一旦取り消した操作をやり直す）

en: `C-g` - Escape
ja: `C-g` - エスケープ

en: `S-M-f` - Toggle fullscreen mode
ja: `S-M-f` - フルスクリーンモードを切り替え

en: `S-M-b` - Toggle visibility of buttons
ja: `S-M-b` - ボタンの表示を切り替え

en: `S-M-l` - Toggle visibility of log
ja: `S-M-l` - ログの表示を切り替え

en: `S-M-m` - Toggle between light/dark modes
ja: `S-M-m` - ライト／ダークモードを切り替え

en: `S-M-s` - Save contents of buffer to a file
ja: `S-M-s` - Bufferの内容をファイルに保存

en: `S-M-o` - Load contents of buffer from a file
ja: `S-M-o` - Bufferの内容をファイルから読み込む

en: Sharing
ja: 共有

en: Sonic Pi is all about sharing and learning with each other.
ja: Sonic Piで最も大事なことは、お互いに共有し学習することです。

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*.
ja: いったん、どのように音楽をコード化するかを学んだら、作曲したコードを共有することは電子メールを送信するのと同じくらい簡単なことです。あなたの作品から*学び*、さらに新しい*マッシュアップ*で部品を使えるように、他の人とコードを*共有*しましょう。

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.
ja: もしあなたの作品を他者と共有するためのよい方法が見当たらなければ、あなたの音楽を[SoundCloud](https://soundcloud.com)へ、そしてコードを[GitHub](https://github.com)に置くことをお勧めします。それらの方法で、あなたの作品は、容易にたくさんの人に届けることができるでしょう。

en: Code -> GitHub
ja: コードを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.
ja: [GitHub](https://github.com)は、コードを共有し作業するためのサイトです。コードの共有や共同作業のためにプロの開発者と同じくアーティストも使用しています。新しい作品のコード（あるいは未完の作品）を共有する最も簡単な方法は、この[GitHub](https://github.com)で[Gist](https://gist.github.com)を作成することです。[Gist](https://gist.github.com)は、コードを簡単にアップロードする方法で、これにより他の人が簡単に参照、コピーし共有することができます。

en: Audio -> SoundCloud
ja: 音をSoundCloudへ

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.
ja: 作品を共有するもう1つの重要な方法は、音を録音し[SoundCloud](https://soundcloud.com)にアップロードすることです。作品をアップロードしたら、他のユーザがコメントしあなたの作品について話し合うことができます。また、トラックの詳細にあなたのコードの[Gist](https://gist.github.com) へリンクを貼ることをお勧めします。

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).
ja: 作品を記録するには、ツールバーの`Rec`ボタンを押すと、すぐに録音を開始します。もしコードがすでに実行中でなければ、開始するために`Run`を押してください。録音が完了したら、再び点滅している`Rec`ボタンを押すと、ファイル名を入力するよう求められます。WAVファイルとして保存された録音は、無料のソフトウェア（例えば、Audacityを試してみてください）で編集したりMP3に変換することができます。

en: Hope
ja: 希望

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.
ja: 私はみなさんが作った作品を共有し、我々がお互いにSonic Piの新しいトリックや動作を教えあえることを願っています。あなたが何を見せてくれるか本当に楽しみにしています。

en: Performing
ja: パフォーマンス

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.
ja: Sonic Piの中で最もエキサイティングな側面の1つは、*楽器*としてコードを使うことができるということです。これは、コードをライブで書くことが、音楽を演奏する新しい方法とみなすことができることを意味します。

en: We call this *Live Coding*.
ja: 我々は、これを*ライブコーディング*と呼んでいます。

en: Show Your Screen
ja: 画面を表示しよう

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.
ja: ライブコーディングするとき、観客に*あなたの画面を表示する*ことをお勧めします。そうでなければ、ギターを指や弦を隠しながら演奏するようなものです。私は家で練習するときは、Raspberry Piと小型プロジェクターでリビングルームの壁に投影しています。テレビや学校/職場のプロジェクターを使ってみましょう。挑戦してみてください。とても楽しいですよ。

en: Form a Band
ja: バンドを結成しよう

en: Don't just play on your own - form a live coding band! It's a lot of fun jamming with others. One person could do beats, another ambient background, etc. Use the `live_audio` functionality to combine code with traditional instruments such as a guitar or a microphone.
ja: 1人で演奏するのではなく、ライブコーディングバンドを結成しましょう！他の人といっしょに演奏するのはとても楽しいですよ。1人がビートを担当して、もう1人はアンビエントなBGMを奏でる、みたいにね。ギターやマイクのような普通の楽器とコードを組み合わせる時には`live_audio`機能を使ってください。

en: See what interesting combinations of sounds you can create with code.
ja: コードを使ってどんな面白い音の組み合わせが作れるか、試してみましょう。

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).
ja: ライブコーディングは新しいものではありません。一部の人々は、自ら構築した特注システムを使用して、ここ数年ライブコーディングに取り組んできました。他のライブコーダーやシステムについての詳細を知るには、[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.
ja: ライブコーディングの世界を探索するためのもう1つの偉大なリソースは、[Algorave](http://algorave.com)です。ここで、クラブシーンでのライブコーディングに特化した情報を見つけることができます。
