Category: livecoding


A quick improv from Sheffield:

Here’s the state of my editor at the end:

d1 $ slow 2 $ sound "bd [sn sn bd]/2"

let x = density 2 $ striate' 8 0.75 $ sound (slow 4 $ "[bd bd/4] [ht mt lt]") in
d2 $ stack [every 3 rev $ every 4 (0.75 <~) x
            |+| pan "0.2",
            every 4 rev $ every 3 (0.5 <~) x
            |+| pan "0.8"
  |+| speed "1"
  |+| shape "0.6"

d4 $ every 4 (density 2) $ echo 0.5 $ brak $ every 3 (0.25 <~) $ sound "[future,odx,bd]*3"
  |+| shape "0.7"

let perc = 0.2 in
d3 $ slow 2 $ whenmod 10 12 (echo 0.25) $ density 2 $ sound (pick <$> "~ [operaesque]" <*> (slow 5 $ run 24))
  |+| slow 16 ((begin $ (*(1-perc)) <$>  sinewave1) |+| (end $ (+perc) <$> sinewave1))
  |+| speed (slow 2 "0.75 0.7")
  |+| pan "0.6"
  |+| shape "0.6"

let perc = 0.2 in
d4 $ slow 3 $ every 2 (rev) $ whenmod 10 12 (echo 0.25) $ density 2 $ sound (pick <$> "~ [operaesque]*3" <*> (slow 10 $ run 16))
  |+| slow 16 ((begin $ (*(1-perc)) <$>  sinewave1) |+| (end $ (+perc) <$> sinewave1))
  |+| speed "0.75"
  |+| pan "0.4"
  |+| vowel "i"


d6 $ whenmod 10 12 (density 2) $ whenmod 12 4 (rev) $ slow 2 $ sound "[futuremono]*3 [odx/3]"

d7 $ whenmod 6 4 (0.25 <~) $ every 4 (density (3/2)) $ slow 2 $ sound "[jungle/2]*2 [jungle/3]*2"
  |+| shape "0.7"

d7 $ (whenmod 2 4 ((|+| speed "0.9") . rev) $ every 2 (0.25 <~) $ sound "odx [sn/2 ~ sn/2]")

d2 silence

d8 $ ((slow 8 $ double (0.25 <~) $ striate 12 $ sound "[diphone2/1 ~ diphone2/3]*4")
  |+| (slow 4 $ speed ((*) <$> "[2 1] 1.5" <*> ((+0) <$> ((+0.4) <$> (slow 4 $ sinewave1))))))
  |+| vowel "i"

d9 $ slow 2 $ sound "[[odx]*4]/3 [[odx]*4 [odx]*8]/3"
  |+| speed "1"
  |+| cutoff "0.04"
  |+| resonance "0.7"
  |+| shape "0.8"

bps 1

Extending human ability

I don’t always enjoy praise, but it’s really great when commentators see through the cold reality of live coding or algorave and get at the promise that motivates what we’re doing.

Here’s a comment by a reddit user called Tekmo from a few months back, which I think is about the promise of a more embodied approach to the practice of programming:

I think the entire premise of this project is really brilliant. Right now it’s probably not immediately inspiring because it takes a minute or so to switch between patterns for an average user, but imagine somebody getting REALLY good at improving on this, with their own custom library of one or two-letter function names and performing by constantly improvising patterns every few seconds while programming at lightning speed.

But the real reason I think this is brilliant is because this is sort of what I always imagined programming was about: extending human ability. I feel like the super-heroes of the future will be programmers that command an impressive array of remote machinery as if it were an extension of their own body.

Here’s an excerpt from a nice blog post by DuBose Cole which to me hints at a cultural tipping point when more people start programming:

Events like Algorave highlight that by making more people creators through programming, we don’t just get new technical creations, but social and cultural ones as well. Algorave features electronic music created by algorithms programmed on the fly for a crowd. Revellers seem to attend due to either an interest in how the music is created, a particular love of electronic music, or just to have a party. An idea like Algorave takes the image of coding as a solitary experience and moves it forward, making the programmer a collaborative and immediate creator, as well as bit of a rock star.

What the idea highlights however, is that learning to create with code is less about the skill itself and more about what you do with it. Pushing coding literacy is only the beginning. Coders are creating an ever expanding culture of creation, which anyone with a basic appreciation or skill for programming can join in with. The increasing simplicity with which people can learn coding has not only changed who can create, but also the scope of what’s being created.

Brilliant stuff.

Texture 2.0 bug exposure

Texture 2.0 (my Haskell based visual live programming language) is working a bit more. It has reached gabber zero – the point at which a programming language is able to support the production of live techno. Also I’ve made some small steps towards getting some of my live visualisation ideas working. Here’s a video which exposes some nice bugs towards the end:

This is an unsupported, very pre-alpha experiment, but if you want to try to get it working, first install Tidal (and if you want sound, the associated “dirt” sampler). Then download the code from here:

.. and run it with something like runhaskell Main.hs


Algorave in Wired magazine

2013-08-01 20.46.09
Algorave has a page in the current (September 2013) edition of Wired UK, including short interviews with Alexandra Cardenas and I, and screenshots from Davide and Dave.

Release of tidal 0.2.1

For me the best part of my workshops during my residency here at Hangar was getting the participants to try out Tidal. In the final workshop there were around 12 of us jamming together, each with a speaker in a kind of drumming circle, at several points it was sounding really great.

In between workshops I’ve been cleaning up my various bits of code, and have now tied it all together into the first semi-documented release of Tidal. You can get the docs and the source over here.

Let me know if have feedback, or would like me to run workshops in your town…

Death of algorave


Here’s a room recording of xname and I playing a post-algorave set at Audacious Space in Sheffield. We start making sound from about 4 minutes in.

Xname performed using handmade circuits controlled with strobes and other lights. I used my livecoding DSL Tidal, which also sent flashing patterns to a monitor flat on the table, so xname’s system could be in sync with mine. She also directly beatmatched strobe frequencies, it turns out she has a secret DJ past.

I was pretty much hypnotised by xname’s strobes while live coding and didn’t really know how it went at the time, but am really happy with this recording. You’ll have to imagine the strobes.

Residency in Barcelona

I’m very happy to have a month’s residency in Barcelona coming up, starting 22nd July 2013. I’ll be running workshops (probably at the beginning, while locals are still in town) and working on some new things. It’s produced by L’ull Cec for Hangar, in the context of the Addicted2Random project, which is funded by the European culture programme. It’ll be really great to get some real focus on things I’m desperate to get done.

What on earth is live coding?

Busy times at the moment, but a quick pause to link to the afore-mentioned full interview in Dazed and Confused by the fine Stephen Fortune. I think the on-line version is a bit longer than in print. There’ll likely be another algorave related article in Wired magazine (the UK version I think) in the next month or so. Anyway here’s the text from Dazed and Confused for posterity:

Alex McLean is a programmer and live coder. He performs with a livecoding band called Slub and tours with the travelling Algorave festival. But what is “livecoding” exactly? “Live coders are basically performing by writing computer programs live on stage, while the programs are generating their art – whether that’s visuals or music,’ McLean says. “Their computer screens are projected, so that the audience can see the code being manipulated. But the focus is on the music, on people dancing and seriously enjoying themselves”. In the run up to an Algorave aboard the MS Stubnitz, London, we met McLean who did his best to scramble our brain.

Do you think a newcomer to the algorave scene would leave enlightened or mystified?
Hopefully they would enjoy the music without feeling that they were compelled to understand it. Also because we’re making music, not doing formally specified software engineering, there’s no real ground of understanding anyway, apart from the music itself. Even those making the software don’t really have to understand it – “bugs” often get into the code which don’t make sense, but still sound good, so we just go with it.

Is there any genre or activity which you feel livecoding resembles?
In terms of algorithmic music, on one side there’s the “electroacoustic” focus on experimental sound, the search for new dimensions of timbre and musical movement. But Live coding is a way of making music and is not tied to any particular genre. I’ve heard live coders make drone music, jazz, indian classical music, indie covers, and hip hop manipulated beatbox.

How do ideas circulate throughout the scene?
There’s a big overlap with free and open source culture, so sharing ideas in the form of software and sourcecode happens a great deal. There are many languages for algorithmic music and video, such as Supercollider, Fluxus, ChucK, Impromptu and PureData, and strong communities of practice have grown around them.

Are your fellow algoravers proficient programmers?
Yes, many livecoders make and adapt their own programming environments: that takes some experience. But proficiency at coding dance music is different to making financial systems or whatever. I’ve run workshops where I’ve got non-programmers making acid house together in a couple of hours. I think there’s real possibility to make producing algorave music more like drumming circles, where beginners can just join in and learn through doing.

Can any sort of coding be a creative activity? Or only certain forms, like livecoding?
Creativity is a surprisingly recent concept, and not that well defined, but I like to think of it as everyday behaviour, which most people engage in daily. Coding generally involves making sense out of huge, crazy structures, and it’s impossible to get anywhere without zoning out into a state of focussed, creative flow.

You claim you’d like to make programming more like a synthesiser. How would that be different from the other software systems that people use to make music?
I think it’s important to consider programming as exploration rather than implementation, because then we are using computer languages more like human languages. Any software interface can be thought of as a language, but the openness of programming allows us to set our own creative limits to explore, instead of working inside fixed, pre-defined limits. To me this is using computers on a deep level for what they are – language machines.

Who (or what) inspires you?
If I had to pick one person it would have to be Laurie Spiegel, I love the way she writes about using computer language to transform musical patterns.

Check out the original article.

Things coming up

I’m having a bit of a breather at the moment, but here’s some of the things I am up to over the Summer:

16th May 2013

Another Algorave on the MS Stubnitz. The last one was masses of fun, and really looking forward to seeing what the next one turns up..

May 27-30 2013

I won’t actually be there, but EunJoo Shin will present our collaboration microphone at NIME 2013, as a paper and installation.

15th June 2013

A performance collaboration with xname at the Audacious Space in Sheffield. Difficult to say much about this, but it’s going to be noisy..

27-28th June 2013

A paper on the Textural X (dodgy preprint here), and a performance at xCoAx2013: Computation, Communication, Aesthetics and X in Bergamo.

11th July 2013

Another outing to London for the Thursday Club, for a presentation and performance with Kate Sicchio of our piece in development “Sound Choreography <> Body Code”. Here’s some footage from our first performance at Audio:Visual:Motion.

19th-21st July 2013

Performance and workshops at the awesome Deer Shed Festival in North Yorks with Dave.

15th August 2013

A pre-warning of a gig at Cafe OTO, the return of lurk, featuring Leafcutter John, Alexandra Cardenas, Roger Dean and a new collaboration between Paul Hession and myself. Especially looking forward to this after recently realising I’ve actually seen Paul play before, several years ago with Tom Jenkinson and Matthew Yee-King:

15-20th September 2013

Co-organising the Schloss-Dagstuhl seminar Collaboration and Learning through Live Coding. Really excited about this, and we plan to do some other things around Europe before and/or after..

Transient and ephemeral code

Be sure to read the comments – Sam Aaron makes some important corrective points… The below left as documentation of thinking-in-progress.

There is now an exciting resurgence of interest in live programming languages within certain parts of the software engineering and programming language theory community. In general the concerns of liveness from “programming experience design” and psychology of programming perspectives, and the decade-old view of live coding and live programming languages from arts research/practice perspective are identical, with some researchers working across all these contexts. However I think there is one clear difference which is emerging. This is the assumption of code being live in terms of transience — code which exists only to serve the purposes of a particular moment in time. This goes directly against an underlying assumption of software engineering in general, that we are building code, towards an ideal end-game, which will be re-used many times by other programmers and end-users.

I tried injecting a simple spot of satire into my previous post, by deleting the code at the end of all the video examples. I’m very curious about how people thought about that, although I don’t currently have the methods at my fingertips to find out. Introspections very welcome, though. Does it seem strange to write live code one moment, and delete it the next? Is there a sense of loss, or does it feel natural that the code fades with the short-term memory of its output?

For me transient code is important, it switches focus from end-products and authorship, to activity. Programming becomes a way to experience and interact the world right now, by using language which expands experience into the semiotic in strange ways, but stays grounded in live perception of music, video, and (in the case of algorave) bodily movement in social environments. It would be a fine thing to relate this beyond performance arts — creative manipulation of code during business meetings and in school classrooms is already commonplace, through live programming environments such as spreadsheets and Scratch. I think we do need to understand more about this kind of activity, and support its development into new areas of life. We’re constantly using (and being used by) software, why not open it up more, so we can modify it through use?

Sam Aaron recently shared a great talk he gave about his reflections on live programming to FP days, including on the ephemeral nature of code. It’s a great talk, excellently communicated, but from the video I got the occasional impression that was is dragging the crowd somewhere they might not want to go. I don’t doubt that programming code for the fleeting moment could enrich many people’s lives, perhaps it would worthwhile to also give consideration to “non-programmers” or end-user programmers (who I earlier glibly called real programmers) to change the world through live coding. [This is not meant to be advice to Sam, who no doubt has thought about this in depth, and actively engages all sorts of young people in programming through his work]

In any case, my wish isn’t to define two separate strands of research — as I say, they are interwoven, and I certainly enjoy engineering non-transient code as well. But, I think the focus on transience and the ephemeral nature of code naturally requires such perspectives as philosophy, phenomenology and a general approach grounded in culture and practice. To embrace wider notions of liveness and code then, we need to create an interdisciplinary field that works across any boundaries between the humanities and sciences.