Etude 1

I have been working with contrasting parameters lately. Mostly harmony but also “dirty” sound vs “clean” sound. Patterns and contrasts are, for me, very important elements in music.

These sounds are basically filtered white noise, so called subtractive synthesis. The bandwidth of the filters control how “clean” or “dirty” the sound is.

The harmony is based on two contrasting spectrums. The first on is an ordinary harmonic spectrum and the other one is based on the golden section.

I have been using patterns in supercollider to “play” the instruments. It allows you to construct everything from simple sequences to nested and user defined patterns. It is very easy to “play” the patterns with instruments. The following example plays an instrument called myInstrument. The parameters named startPan and endPan comes from a Pseq which is a simple sequence pattern.

p = Pbind(
  \instrument, \myInstrument,
  #[startPan, endPan], Pseq([
    [-0.9, -0.5],
    [-0.5, -0.9]
  ], 1)
).play;

One other thing that I have been using is audio buses. They allow you to make instruments that reads sound from one bus, process it and then sends the processed sound back out on the bus. You can have many buses and make the connections between the instruments and buses when you play them. This is very convenient when you want to make “effect” instrument such reverbs.

Advertisements

Early reflections on Supercollider

The first, and one of the most important, reflections regarding Supercollider is that it has a fairly vibrant community. For instance so is there a facebook-group and many you can watch many videos on YouTube where people are using the interactive features of SC.

A good expressive programming language is very important for at tool like SC. One of the great things with Common Music is that it is based on lisp, wich is my opinion, work very well with music. SuperCollider has its own pure object-oriented language. It is very expressive and has a lot of good functional-like aspects, such as good collections support.

En event that both shows the vibrant community and the expressive power of the language is an event calls sc140 that is a collection of 22 pieces from different composers that all is written to fit twitter, under 140 characters.

One od thing that takes some time to get used to is the difference between client and server. The so-called synth-defs live in the server and have slightly different coding-rules then code that live in the client. I wanted to make an instrument that takes a list of frequencies and makes subtractive synthesis with them. In ordinary SC-code would you send and array of frequencies as arguments and then use them.

~spekt = {
  arg freqs;
  freqs.postln;
}
~spekt.value(Array[5,6,7]);

Working with array-arguments in a instruments turned out to be a different ballgame. You had to declare the argument as a literal array wich is fixed in size. The consequence is that I have to make one instrument definition for each size of array.

SynthDef.new("spekt-4", { 
  arg freqs = #[0,0,0,0];
  freqs.postln;
}).send(s);
Synth.new("spek-4", [\freqs, #[110,220,330,440]]).play;

Overall have these early experiences with SuperCollider been adventures but plesant.

Electronic music

I have had a pause as a composer, but will try to begin writing music agin. I will primarily write electronic music, I think.

In the past I have used the lisp-based software from Stanford, but got tired of trying to get it to compile. I want something that just work. I have discovered Supercollider and will try to write some music with it.

This blog will initially be about my adventures with Supercollider and hopefully some music.