Two bad imitators
The most obvious method employed in live electronic music to repeat musical phrases, is to use an audio delay. This is a fantastic tool that; with practice allows the musician to jam along to past version of him or herself. A musician that have used this very effectively in a manner that I consider esthetically relevant for this project is Terry Riley playing with what he called his ‘phantom orchestra’ on records such as ‘a rainbow curved in air’.
The drawback of using an audio delay is the inherent predictability by which it operates. Although the very repetitiousness of it can be used to great musical effect, it is not always desirable.
To escape this effect, a live electronic musician may employ techniques which are on the opposite spectrum of predictability for generating musical phrases to play along with, namely using different forms of random information generators that in turn can be used to play musical phrases. This technique however has the inherent downside that it cannot be mastered by a musician in the same virtuoso way that the delay method can, since the player is not the originator of the musical material and thus are always one step behind, relegated to responding to the randomly generated phrases after the fact.
I wanted to explore a middle ground of these two extremes of certainty, which allows mastery and expression, and uncertainty which allows for non-repetitive and surprising events. Another reason for me wanting to try this is because of my own limitations as a keyboard player, I’m not Keith Jarret.
This could be (and has been) done in various ways. Following are two examples of early experiments I have done using using a synthesizer module called teletype. It is basically a very limited computer with a simple scripting language that allows the user write code in order to implement algorithms. (See my instrument)
bad imitator 1
bad imitator 2
I’m calling this technique ‘bad imitator’ because it will try to copy what I play but it will not be able to repeat back exactly what I played. This comes about because I have programed it in such a way that the there is non-linear elements in how it stores and recalls information that is given to it from my keyboard playing.
It works like this:The latest note values of my playing are stored in a short list (the one closest in the video) and the timing intervalsbetween my keystrokes are being stored in the list next to it. The module then goes down these lists,consecutively outputting the note and timing information, controlling the second musical ‘voice’ we hear in the recordings.
What makes it complex (or confused if you like) is that I am using different lengths for the list of note information and a different length for the list of timing information (length meaning the number of slots containing this information).
The result of this is that the right notes are being played back at the wrong time.
To complicate things even further, the information in the lists gets overwritten when I play in new notes. And when I do so, the timing and note information are also misaligned due to the differing pattern lengths. If I just leave it to play with the information stored at any given time, it will still repeat itself. But it will take the number of note slots, times the number of timing slots in the lists to do so (in the case of imitator 1, 8x9 = 72 notes to repeat).
To be able to play this bad imitator and with practice learn how it will respond to my input, I’ve found that it’s necessary to limit the information that it can hold to very few events.
(next: mouth harp)