Today I'm starting a new project. After being hugely inspired by fellow monomist Marcus Fischer's recent success to post one creative thing a day for a year, I have decided to embark on a similar journey. I'm interested in appreciating the feeling of having visible non-work-related creativity as an explicit part of my lifestyle. So, here's to being creative!

Day 8: Rebound

Posted on Sunday the 14^th of February, 2010

Today I took boingg, one of the most basic monome apps and re-implemented it using Polynome and SuperCollider (for the clock). Implementing this application really showed the inefficiencies of my Polynome implementation. The fact that Polynome is currently only a prototype implementation of an architectural design was really made clear when SC metronome was ticking quickly. At low tempos (such as that demonstrated in the video) things were perfectly fine. I think that this adds further weight to my initial thought that one day I’ll have to re-implement Polynome in Clojure. Not yet though, there’s still a lot of mileage I can get out of the current implementation.

Posted on Saturday the 13^th of February, 2010

Today I wanted to make the new thing a photo. The photo I decided to take was of an artistic impression of the Baltic Flower Mill which is located in Gateshead in the North East of England. This picture is one of the first things that Susanna and I bought together, and given that we met in Newcastle and share many fond memories of the quayside there, it felt fitting to make today’s thing a reflection of that.

So today’s new thing is a reflection of a reflection.

Posted on Friday the 12^th of February, 2010

Today I continued the video theme of yesterday and recorded a beautiful multi-coloured sphere bouncing and changing colours. Much of the effort of this kind of creative output is currently being funneled into learning how to use the tools necessary to manipulate video. Hopefully as I prepare more such clips my skill and comfort will improve alongside the results. For now, I’m very happy I managed to both slow down and reverse this clip…

Posted on Thursday the 11^th of February, 2010

Today I took a short piece of video footage I recorded a few weeks ago of my beautiful swan mobile and played some piano music along side it.

This was an interesting challenge. My piano ability has only really lived in the confines of my own space; I improvise for pleasure mainly as an outlet for my emotions. Therefore trying to synchronise what I was playing with the feeling of the video was an interesting challenge and experience. I found myself repeatedly watching and playing along with the scene until I ended up with something I was happy enough with.

One of the clearest benefits of explicitly making ‘one new thing’ each day is getting to understand the notion of happy enough. Clearly it’s unreasonable to ask of anyone that they create a masterpiece every day. At least a masterpiece from the creator’s perspective (if indeed that notion exists in a non-platonic form). It’s therefore very obvious that I very quickly need to know when something is good enough. I feel that this will allow me to become more confident of trying things out of my comfort zone and to appreciate what I have achieved rather than looking at what I failed to achieve or, even worse, not trying in the first place.

Posted on Wednesday the 10^th of February, 2010

Sadly I didn’t get too much time for my creative thing today. This evening I attended a very interesting presentation on MacRuby at the local Amsterdam CocoaHeads meeting. I enjoyed it a lot - the speaker was both knowledgeable and engaging and great to chat with afterwards.

So, what did I get up to? Well I managed to get back-communication from Polynome to SCLang working. I was initially running into problems getting SCLang to register the OSC messages that I was sending. However, after scrutinising the documentation I ascertained that SCLang expects all external OSC messages on an explicit port: 57120. Once I figured that out (and not to have two instances of SCLang running simultaneously) things became a lot more straightforward.

I essentially had to add two components. Firstly the I needed to tell my Polynome client to send a new rate when a button was pressed. I achieved this with the button_pressed method (which does some very basic calculation on the x and y coords of the button to generate a rate value). This is then sent off via OSC on the SCLang port.

class SCFlasher < Polynome::Client
  def init
    listen(5706, "/tick") {toggle_all}
  end

  def button_pressed(x,y)
    send_to(57120, "/press", (x * 8) + y)
  end
end

Finally I had to add an OSC listener at the SCLang side. For this I used a OSCresponderNode. The first param being nil means that the responder will listen to anybody attempting to talk over that port. I specify that I’m listening for the path /press and I then print out the message (for sanity logging) and then use the first param (an integer) to update the tempo of the TempoClock.

~outAddr = NetAddr("localhost", 5706);
c = TempoClock(1);
c.schedAbs(t.beats.ceil, { ~outAddr.sendMsg("/tick"); 1});

OSCresponderNode(nil, '/press', { |t, r, msg| msg.postln ; c.tempo = msg[1]  }).add;

Running all the processes results in the required behaviour. I’ve refrained from recording a video, as there’s only so many epileptic inducing flashing videos I want to impose on people. I’ll create another video when things get a little more interesting (hopefully soon).

Posted on Tuesday the 9^th of February, 2010

Today I tackled something that had been tickling my fancy for a while: how to connect Emacs to SuperCollider.

I knew that it was possible, there are a number of screencasts demonstrating it in a tantalizing fashion. I also stumbled across a lot of issues with it, so knew that it wasn’t going to be easy.

So, I sat down, cup of tea in hand and tackled it methodically until I broke the beast. People in the street must have wondered what the hell I was doing as I was jumping about with joy. So, for today’s new thing, I offer a dual aspect endeavour: the discovery of a solution and the documentation of it.

Here’s to Day 3!

Posted on Monday the 8^th of February, 2010

To continue along yesterday’s theme, I did some more work plumbing work with Polynome. This time I added some operations which affected all the lights: all on, all off and perhaps more interesting: toggle all. I then added some nice ways of adding OSC listeners and senders to a client app. Hooking this all together with a simple SCLang script allowed me to make a Polynome flasher app which is driven by ticks from SCLang. Perhaps for another entry, I’ll draw some diagrams about how it all currently works.

For those interested, the Polynome client code needed to describe this app is as follows:

class SCFlasher < Polynome::Client
  def init
    listen(5706, "/tick") {toggle_all}
  end
end

The SCLang code required to send the flash ticks is also similarly simple. The various tempos listed at the end were some of the values I evaluate live during the video in order to change the flash rate. I really appreciate the fact that SCLang supports live-coding out of the box.

~outAddr = NetAddr("localhost", 5706);
t = TempoClock(1);
t.schedAbs(t.beats.ceil, { ~outAddr.sendMsg("/tick"); 1});

t.tempo = 10;
t.tempo = 4;
t.tempo = 0.5;
t.tempo = 1;

Posted on Sunday the 7^th of February, 2010

Here’s the initial animation that RubyMonomeSerial plays on the monome to signal that it has connected correctly. It took me a number of iterations to get values for lighting and dimming acceleration that I was happy with. I didn’t want it to be too long (as I’m developing, I tend to reset the connection a large number of times) but I did want it to be noticeable.