I've been thinking about how difficult the relationship between time and
programming is. In fact I've been thinking that certain kinds of
programming might happen outside of time. When programming, it often
doesn't feel as though I'm working towards a whole, but that I've
started with a whole in my head and am jumping around it until I've
visited and described every part of it, at which point it exists in an
executable state inside the computer. It doesn't feel like a journey,
more like the simultaneous setting together of different pieces. When a
program is complete, it's a surprise, a snapping out as I realise there
is nothing more to do, a snapping back in to linear time as I prepare to
run the program I've written.
However while I'm programming I'm getting a bit older, and so are the
people around me. So if during a performance I step out of time to see
an idea as a whole timeless structure and transfer it into a computer,
where does that leave co-performers, or indeed the audience?
Somehow part of me still has to be aware of the music that is developing
while another part of me is in the timeless world of programming.
Livecoding compounds the problem - the program is executing linearly
while I am thinking non-linearly.
I think this is why my from-scratch livecoding in a musical
collaboration and/or in front of an audience hasn't been successful -
composing from scratch within the constraints of a live performance has
been too much to deal with - mixing non-linear thought with linear
thought. It's too hard to have a big idea and then find a way to
program it that allows a sound to gradually develop - because my thought
process of programming hasn't been linear. Much easier to start with
something I've made earlier and make variations on largely pre-meditated
developments.
On another theme, Nick often talks about the "haptic rate," if I
understand correctly this is the ratio between our bodies and the speed
at which we can trigger sounds with them. With the livecoding systems
I've found so far, it takes many seconds if not minutes to go from
decision to action - very high latency - but then that action can
trigger many other actions at speeds at the very limits of our senses.
So we've exchanged awesome speed for dreadful lag. This is made all the
more difficult because the lag doesn't exist for the composer, who is
too concerned with relating their non-linear composition to the computer
to really sense the time they are using.
Perhaps the problem I keep hitting on here is that the composition isn't
born only inside the programmer's head but also in the computer. In
this way of looking at things the programmer starts with a small
fragment of an idea, and builds it through small actions to and
reactions from the composition as it grows inside the computer.
How do others feel about time while they are programming?
alex
Received on Fri Aug 12 2005 - 15:20:47 BST