#sc140 #minimalelectronica

November 21, 2009 7:26 PM

sc140: 22 minimal electronica tracks composed in Super Collider using 140 characters or less. Twitter user, computer scientist, and compilation curator Dan Stowell started the trend by tweeting his encoded field recordings of waves crashing on the beach.

Artist bios
Further reading at New Scientist
Via textually.org

posted by carsonb (22 comments total)

Very nice, thanks very much for posting this, carsonb.
posted by carter at 7:59 PM on November 21, 2009

Yeah, [this is good].
posted by loquacious at 8:03 PM on November 21, 2009

This was included in hippybear's FPP about the THX sound. Awesome stuff, for sure.
posted by idiopath at 8:04 PM on November 21, 2009

idopath: Supercollider, sure, but that post didn't cover sc140 as far as I can tell.
posted by carsonb at 8:14 PM on November 21, 2009

idiopath, lo ciento. And I see that you added sctwitting and a link to an article mentioning Dan Stowell in a comment. This compilation is still news though. Thanks for the context.
posted by carsonb at 8:21 PM on November 21, 2009

Yes, it is still news, and news I find interesting, if I thought it was worthy of deletion I would have flagged as a double and moved on :)
posted by idiopath at 8:23 PM on November 21, 2009

Damn, this is cool. I didn't realize SC allowed such complexity to result from so little input. Maybe it is worth the learning curve after all.
posted by O Blitiri at 9:09 PM on November 21, 2009

neat! (love track 11)
posted by sexyrobot at 9:14 PM on November 21, 2009

b=Buffer.read(s,"sounds/a11wlk01.wav");

140 characters, plus a WAV sample in this case.
posted by milnak at 9:20 PM on November 21, 2009

O Blitiri: "Maybe it is worth the learning curve after all."

In my (limited) experience, I couldn't find a decent reference manual for the syntax of the language, but the semantics are smalltalk style OO, with library functions implementing the MUSIC N sound synthesis model (which Csound also uses), and a syntax reminiscent of javascript.

Some basic familiarity with Object Oriented Programming* and the MUSIC N control / audio generator synthesis model is a huge head start for using supercollider.

*and by OOP I don't mean anything to do with Java or C++
posted by idiopath at 9:21 PM on November 21, 2009

milnak: "b=Buffer.read(s,"sounds/a11wlk01.wav");

140 characters, plus a WAV sample in this case."

Some people like to call that clinamen - the freedom to break the rules that proves we have free will.
posted by idiopath at 9:24 PM on November 21, 2009

OK, so I finished listening to the whole thing, and I have to say, for the relative simplicity of the tools they were working with, that was an excellent collection of music. And even if the character count were not limited it would have been worth checking out.

The variety says much about the flexibility of supercollider (and, of course, much more variety is possible without the restricted character count). Of course the power of the language design has much to do with why these could be short as well - how much audio could you output with 144 characters of Java? Of course given perl and a basic MUSIC N synthesis lib you could probably work some real magic, if you dared :)
posted by idiopath at 10:18 PM on November 21, 2009

Oh, great, now I'm going to have to download and learn SuperCollider, like I didn't already have enough hobbies and no free time. Thanks a lot. Jerk.


Seriously though, good links, nice glitchy tracks.
posted by lekvar at 10:27 PM on November 21, 2009 [1 favorite]

Any Supercollider ninjas want to explain where the rhythmic structure in this piece comes from? I get some of the code, but I can't see how the regular timing results:

01
Nathaniel Virgo
{LocalOut.ar(a=CombN.ar(BPF.ar(LocalIn.ar(2)*7.5+Saw.ar([32,33],0.2),2**LFNoise0.kr(4/3,4)*300,0.1).distort,2,2,40));a}.play//#supercollider

posted by fcummins at 6:04 AM on November 22, 2009

given perl and a basic MUSIC N synthesis lib you could probably work some real magic, if you dared :)

Well, there's scruby, which brings SuperCollider to ruby.
posted by weston at 11:21 AM on November 22, 2009

fcummins: "Any Supercollider ninjas want to explain where the rhythmic structure in this piece comes from?"

I am far from a supercollider ninja

here is the code broken down with line breaks and indentation, to show the nesting levels more clearly

{
LocalOut.ar(
   a=CombN.ar(
     BPF.ar(
       LocalIn.ar(2)*7.5+Saw.ar([32,33],0.2),
       2**LFNoise0.kr(4/3,4)*300,
       0.1
     ).distort,
   2,
   2,
   40)
  );
  a
}.play

To read the code like a modular synth, you read from the inside out.

We have here a LocalIn (a feedback source, reading from the LocalOut above it) summed with a stereo Saw (sawtooth wave, natch) as the audio input to a BPF (band pass filter), with 2 to the power of a LFNoise0 controlling the center frequency. The first two arguments to the LFNoise0 are frequency and multiplier. If I am reading the help file correctly, an argument of 4/3 means that it is generating a new value once every 4/3 seconds. The bandwidth of the filter that this is all plugged into is .1, and the output is clipped to the standard full scale by the distort method. This filtered output becomes the input of a comb filter, which is one of the building blocks used to create a reverb from scratch, or in a glitchy piece like this can be used on its own. Finally this is fed back in to the enclosed LocalIn (which a short delay to prevent an infinite processing loop which would stall audio output).

This is also implicitly output to the speakers, I guess. So I am fuzzy on some of the details, but it looks like a combination of the LFNoise0 and the natural cyclic stuff resulting from the feedback delay are creating the rhythmic effect.
posted by idiopath at 12:59 PM on November 22, 2009 [5 favorites]

OK, referring back to the LFNoise0 help file, it is a step noise function, so yeah, if the first argument is 4/3, that means it is outputting a discrete random value every 1.33333... seconds.
posted by idiopath at 1:07 PM on November 22, 2009

Ok, having actually played with the code and messed around with some variables, the 4/3 is how often the LFNoise0 gives new frequencies to the bandpass, and the 2, 2, 40 are the maximum, and current delay of the comb filter, and the decay time - inputs come back in again 2 seconds later (this is seperate from the LocalIn feedback), and with a feedback level such that they decay to silence in 40 seconds (the "maximum delay" does not do much here, since the delay time is a fixed value).

So it is building up a loop out of random bleeps slightly out of sync with the loop, such that the percieved measure start / end will continuously evolve over time - new event every 1.3333... seconds and a repeat of all events every 2 seconds, with each event decaying after about 40 seconds of repeats. The LocalIn feedback gives an extra resonance effect to the BPF, more or less (I think, so far).

I replaced the 4/3 with 4.213/3 and got a much less rythmic feeling result - the events do not end up syncing up again over time, because 1.4043333.... has fewer common multiples with 2 than 1.333333.... does (effectively none, given the constraint of the decay time).
posted by idiopath at 2:34 PM on November 22, 2009 [2 favorites]

Thanks ideopath!
posted by fcummins at 11:54 PM on November 22, 2009

ideoidiopath. glitches abound.
posted by fcummins at 11:55 PM on November 22, 2009

No problem, I had been meaning to brush up my supercollider skills, and it was a good excuse. One correction: the argument to LFNoise0 is a frequency in hz, not time between changes in seconds (for values close to 1 it is easy to mistake the one for the other). I made up a version of the piece that uses midi sliders for all the parameters, which may lead to publishing a "remix" of sorts if I find just the right settings.
posted by idiopath at 12:11 AM on November 23, 2009

milnak: That .wav file is included with the SuperCollider distribution for use with code examples, so that tweet will always run as heard.
posted by doubtfulpalace at 2:03 AM on November 23, 2009