SONNET-LOCO

SONNET-LOCO

LOCO-SONNET, a graphical composition system

Modules in the micro-world 'Composing is making musical choices'

Composition can be looked at as the making of choices. Choices can be made by the composer or by the computer. In the last case the composer (you!) will have to give the rules to the computer. One of the possible rules is a random choice from a fixed set of possibilities. We create such a program, by means of the so called "choice system" ALEATORIC.
A SHOW module asks a color from ALEATORIC each time the button is clicked. ALEATORIC, upon being requested some output, asks the CONSTANT module for a list of possibilities. This module always return the same list of words. ALEATORIC picks one randomly and returns it to SHOW which displays the color.

Note that ALEATORIC does not know anything about colors, it just gives you a word as result.

Now we are going to use ALEATORIC to construct a musical example, creating a melody with pitches chosen randomly from a fixed set of possibilities.

Those of you who know about scales, and like to experiment with them, can immediately start creating random melodies in major, minor, or other scales, by selecting a suitable list of possibilities. It is good to build and name modules that will be used more often.

We also can make random rhythms using a duration chosen by ALEATORIC:

Or combine both principles.

In the last example we combined the two mechanisms of choosing random pitches as well as durations. LOCO supports lots of ways of combining very simple mechanisms into complex ones. We encourage the free experimenting with these combinations. They are so manifold that it is impossible to describe them all, just like describing all possible programs is an infinite task.

If you have a predefined order in mind, in which the choices have to appear, you can use the generator ORDERED instead of ALEATORIC. ORDERED would make the right traffic light, compared to the COLOR example we did with ALEATORIC, but we will give a musical example here:

In the next example we put a duration order of two elements against a melody line of three elements. Can you figure out what goes on when you listen to it?

We can use loudness to accentuate one of the patterns, if you select an instrument on your synthesiser which is sensitive for loudness.

Or the other:

A third principle of choice used by many composers is serial choice. A serial choice of a given set of possibilities will first use all of them before one can be chosen again. Think of a serial choice as a bucket full of possibilities (written on little pieces of paper). Each time a new value is needed, one piece of paper is taken out of the bucket at random without putting it back. Only when the bucket is empty all of the possibilities (pieces of paper) are put back in the bucket and the process is continued.

We can collect a number of objects in a list. In the next example a number of notes (12) are collected and the lsit is passed to a S module which orders the notes in a sequence and outputs that as a whole.

By making our patch into a module it can be used more easily as a building block.

When we use a serial choice for making rhythms, as we did in the second part of the example above, a kind of feeling for measure is created. This happens because after each dotted 1/8 note (1/16 + 1/8 + dotted 1/8) we can be sure a note will start. This even becomes more apparent when a second layer of the same kind of notes is added. This second layer is transposed down by an octave by using the transpose module. This module is one of the general transform modules that can be defined by the user. They operate on any musical object (including compound ones). The definition of these modules is given elsewhere (in the 'composing is transforming musical material' microworld).

Our next example will give a demonstration of the orthogonal nature of LOCO: everything can be coupled to everything. We will use a choice system to generate a list of possibilities that another choice system can choose from.

Adding a second layer makes the metric quality of the produced sequence even more clear.

The next example shows another way of combining choice systems. One choice system can choose the one whose result has to be used. SELECTED acts like a (rotary) switch.

Ordered will return the name of an input to select. SELECTED will use that name and asks for it results once (in this example it produces a pitch). NB. the sound example does start with the modules not reset to their starting state.

Modularity can be used for building compound musical objects like chords.

Note how defaults, that will be used when inputs are not connected, are passed to compound modules. A CHORD module is used in the next example, which alternates soft and loud notes with chords.

If you want to use an element by element translation of names you can use TRANSLATED that has a list of pairs (a kind of dictionary) as its input.

When you need choices with different probabilities, you can use WEIGHTED. It works like ALEATORIC, but assigns to each possibility a different probability. The next example shows the use of weighted durations. Half of the choices will be a sixteenth note, most of the rest will be eighths or, with a slight chance, a quarter.

Sometimes you want to choose from a (very) large number of possibilities. It then can be much easier to give only the borders in between which can be chosen. With SCALE you need a minimum, a maximum, and a resolution defining the size of the scaled steps in between. The larger the resolution, the less possibilities there are within the given range. SCALE returns a list which can be used as input to another choice system.

A whole tone scale has equal steps between every preceding note. You maybe want to compare the sound and making of this scale with the ones you made before with ALEATORIC. Of course, the arguments for SCALE can also be calculated by another choice system.

This example produces a constantly widening serial melody.
The next is an example using SCALE for fluctuating timing of a PRE grace note attached to a regular beat.

A useful process in composition is repetition. It is done with the module ITERATED which can repeat results a number of times. An example:

Each pitch is repeated twice. Adding a second layer of double-duration notes, one octave below and without repeating pitches makes a nice combination. The two layers could also be called Balungan and Pekingan, respectively, if it was a first step in making a simulation of a Javanese gamelan styled composition.

The process of doubling musical material in this way would have been expressed more elegantly as a transformation module - but that will be described elsewhere.

Another module is CUMULATIVE. It needs an increment and a start value as input.

Although this is not a very shocking example, CUMULATIVE is a strong principle. It, as its name suggests, cumulates all inputs, beginning with its starting value (c3 in the example above). The next values are determined by the increment. That can be a constant (as in the previous example), but also, and more interestingly, the output of another choice system, as is done the next example, which yields a melody with only thirds as pitch interval steps.

Brown melodies, like the one made here with CUMULATIVE, have a more flowing nature compared to aleatoric (or white) melodies.

The next program generator to be introduced is REMEMBERED. It can remember its previous input Its second input is a starting state. Combining this with SELECTED makes a neat markov chain model.

We use this to create a chord progression. Note the use of a textual representation of musical objects, this is not nessecary, but it is sometimes handy to use.

A graphical representation of the chord progression transition network.

COLLECT can be used to aggregate a certain number of outcomes from a choice system into a list, which can then be passed as an argument to another choice system. In the next example 2 pitches are collected in a list which is used 4 times to derive pitches in order. Thus a number of trills is made.

Another nice sounding example constructs short serial sequences from a scale.

Values that have to be iterated 0 times are skipped, this enables the easy programming of masking processes used sometimes in minimal music.