Exercise 6.1 - Code Blocks

1

2

3

So far, we have written short code fragments to define specific musical events and properties. In this tutorial, you will learn how to write blocks of code to perform a series of tasks, to capture more complex functionality. These code blocks (or subroutines) can either be placed in a cell directly and triggered when the cell is played, or associated with a pattern effect and used whenever the effect is used in the pattern.
   In Manhattan, code blocks also allow us to push (write) data to other parts of the pattern, whereas previously we have only pulled (read) data to write to the current cell. For this we will learn about the assignment operator, =.

To create a code block in a cell:

• Open the formula editor for that cell (=) and press the Tab key. This switches to a single text box in which you can freely write one or more lines of formulas or code.
• Because the code can address anything, we have to tell the computer where to place the result of any calculations. For this, we use the assignment operator, "=", which copies the result of the right hand side of the expression to the location identified by the left. It tells the computer what to do with the result of a calculation (previously, for cell formulas, this was already fixed for us).
• Enter the following code in the first cell of the pattern, as a code block (press Tab to switch editing modes):

[+2].pitch = .pitch + 7

• To confirm your edit and close the editor, press Ctrl-Enter (a single Enter will simply move to the next line). Observe what happens when you play the pattern – the cell two rows in the future is assigned a pitch seven semitones (a perfect fifth) higher than that in the current cell.
• Continue to part 2, when ready.

Exercise 6.2 - Code Order

1

2

3

Understand the order of execution:

• We are going to add a second line of code to also change the pitch in the current cell:

  .pitch = rnd(C-5, B-5)

• The order of the lines matters. Open the cell's code editor (=) and try adding this line before the existing line of code, so that it reads:

.pitch = rnd(C-5, B-5)
 [+2].pitch = .pitch + 4

• Commit the changes (Ctrl-Enter) and play the pattern. The order of the lines means the future note will use the new, changed pitch value.
• Now try reversing the order of the lines and playing the pattern:

[+2].pitch = .pitch + 4
 .pitch = rnd(C-5, B-5)

• The future note will now be calculated based on the original, unchanged value – before it is changed by the second line of code. The right order will depend on what you want to do, musically.

In these code blocks, you can do everything you could do in previous formulas, but also have much more flexibility to change the pattern and vary your music. In later tutorials, we will also see further ways to affect larger changes from such code.

  You can copy this cell (including its code) and paste it elsewhere in the pattern to perform the same task in other place - but we can also simply 'call' upon another cell's code when we need it...

• Continue to part 3, to see this in practice.

Exercise 6.3 - Calling Code

1

2

3

While copy-and-pasting cells allows us to reuse the code that we've written (which get copied as part of the cells), the pattern can get messy and unmanageable as the amount of code grows. Moreover, imagine if we later want to alter the code, but then have to update all the different copies strewn across the music.
  Instead, we need a mechanism to be able to write code once in one place, and then reuse it whenever and wherever we need. This is the principle of functions, explored in the next tutorial, but Manhattan also offers a simple mechanism for one to simply 'call' the code of another other cell...

Executing (or calling) code from another cell:

• Unmute Channel 2.
• Channels 2 to 5 contain several blocks of code that depend upon each other. If you play the pattern, the code in the first cell in Channel 2 will prepare other cells in the pattern for playback: muting Channel 1, unmuting Channels 2 to 5, and setting specific starting values. Look in the cell at [2:0] and inspect the code.
  
   
  Notice how each line of code is accompanied with comments explaining its function. Text that appears after the comment symbol (’) until the end of the line is not treated as code, allowing you to write anything you like - for any purpose. In coding, using comments is an important habit to get into, as it explains what your code is doing - not only to others, but to yourself!
• There are several other cells containing code in these channels - as denoted by the blue marker (█). They broadly outline a dialogue between Channels 3 and 4 - where notes are exchanged in a basic 'call and response' pattern - but which is currently incomplete.
• In several cells, you will notice the following line:

  @Conversation.run()

  The .run() function is an instruction to take the code from the referenced cell (i.e. @Conversation) and run it in the current cell. At the moment, however, there is no such cell.
• Pick an empty cell in any unused or muted channel, anywhere in the pattern, and label it  Conversation  (to create a label: move to the cell and press ", then enter the text and press Enter), then copy and paste the following code into it (select the text with the mouse, right click, and select "Copy"):

  ' A little John Williams magic...
  [+1].pitch = .pitch + 2      ' up a major 2nd
  [+2].pitch = [+1].pitch - 4  ' down a major 3rd
  [+3].pitch = [+2].pitch - 12 ' down an octave
  [+4].pitch = [+3].pitch + 7  ' up a perfect 5th

• Now play the pattern from the start (Alt-Space) to hear the full exchange, replicating a famous musical 'conversation', using one of the most famous 5-note motifs in cinema history, written by John Williams.
• Click here to see the trailer, featuring the motif...
  
   
  In Steven Spielberg's influential 1977 film, Close Encounters of the Third Kind, humans make first contact with alien visitors by sharing of a 5-note musical motif, hoping the vistor spaceship will repeat it back - they do, hesitantly at first, but then with increasing gusto.
• Look at the code and comments in the cells of the pattern to see how this epic exchange is replicated:
  • Channel 3 first plays the motif (at [3:4]) and waits for a response from Channel 4 (at [4:12]).
  • This initial exchange is repeated again and again (rows 20 to 28), with increasing fluidity, speed, and variety - as the two parties learn to better communicate. Tempo increases with each channel using the notes of the other.
  • Both parties (and the music) ultimately become a little over-excited, but when the tempo reaches maximum (@FF), the cacophony gives way to playing together (see [2:20]).

The .run() mechanisms is extremely powerful, and allows you to collect fragments of code together, name them, and call upon them wherever and wherever you need. It can even be useful to set aside a muted channel to host arrays and the code blocks you frequently use, and call on them by name in the rest of your pattern.
  In the next tutorial, we'll explore functions, another mechanism for writing code that can be reused, but also adapted for different situations.