“Notes From the Metalevel is a practical introduction to computer composition. It is primarily intended for student composers interested in learning how computation can provide them with a new paradigm for musical composition.” I happened to have a pdf version of the book, but the good news is that there’s an html version of it too, which includes also all the midi files of the numerous examples included in the book. So make sure you check that out, if you’re interested in computer-based composition. You might also be interested in this review on computer music journal, and this course materials from Taube’s class at Illinois.

The preface to the fist chapter contains this suggestive excerpt from Leonard Schlain’s The Alphabet Versus the Goddess:

The one crowded space in Father Perry’s house was his bookshelves. I gradually came to understand that the marks on the pages were trapped words. Anyone could learn to decipher the symbols and turn the trapped words loose again into speech. The ink of the print trapped the thoughts; they could no more get away than a doomboo could get out of a pit. When the full realization of what this meant flooded over me, I experienced the same thrill and amazement as when I had my first glimpse of the bright lights of Konakry. I shivered with the intensity of my desire to learn to do this wondrous thing myself.
(spoken by Prince Modupe, a west African prince who learned to read as an adult)

Taube’s goes on (page 19-20) and uses it as a metaphor of what algorithmic composition (i.e., metalevel composition) is:

It is impossible to know exactly how Prince Modupe felt when he discovered a process by which his very thoughts could be trapped and released at will again into speech. But I think his epiphany must be close to what I experienced when, as a young composer, I was first shown how I could use a computer to represent my musical ideas and then “release them” into musical compositions. […]

At that instant it became clear to me that there was an entire level of notation above the scores that I had been writing in my regular composition classes, a level I knew nothing about! But I could see that in this level it was possible to notate my compositional ideas in a precise manner and work with them in an almost physical way, as “trapped words” that could be unleashed into musical sound whenever I wanted. […]

Given the existence of the acoustic and score representations one might ask if there is yet another representation that constitutes a level of abstraction above the performance score? The answer, of course, is yes; it is what this book terms the metalevel. If the score represents the composition then the metalevel represents the composition of the composition. A metalevel representation of music is concerned with representing the activity, or process, of musical composition as opposed to its artifact, or score. […]

This book is about using the computer to instantiate this level: to define, model and represent the compositional processes, formalism and structures that are articulated in a musical score and acoustic performance but are not literally represented there. By using a computer the composer can work with an explicit metalevel notation, or language, that makes the metalevel as tangible as the performance and acoustic levels.

Because this is the Winter issue, it includes the annual CMJ DVD, whose program notes appear near the end of the issue. The curators for the compositions on this year’s DVD are specialists in live cod- ing, the practice of onstage computer programming whose real-time output is an improvised and often collabora- tive musical performance. As always, the DVD also includes sound and video examples to accompany recent articles, as well as related files on the DVD-ROM portion of the disc.

A full description of the contents of the DVD is available here (and here if you’re not benefitting from an academic subscription), and I’m very proud to say that it includes also one of my livecoding pieces, Untitled 12, performed live at the Anatomy Museum livecoding event in 2010.

Here’s a couple of excerpts:

Secrets such as why the programming language Lisp inspires religious devotion, or how someone in their right mind would ever consider programming onstage as a form of musical performance, represent the sort of geekery that would seem to be the domain of an elite.

I doubt very seriously that live coding is the right performance medium for all computer musicians. [..] But Ramsay reveals what live coding music is. It’s compositional improvisation, and code simply lays bare the workings of the compositional mind as that process unfolds. Not everyone will understand the precise meaning of what they see, but there’s an intuitive intimacy to the odd sight of watching someone type code. It’s honest; there’s no curtain between you and the wizard.

An interesting comment from a reader (Damon) puts forward what I’d call the ‘livecoding as programming-virtuoso niche” view:

The live coding thing is clearly an amazing talent. I admire anyone who can do that, but it does seem pretty much a sophisticated parlor trick unless the music resulting can stand on its own.

The question becomes, were you to hear the piece without observing the live coding performance, would it stand up, or is the quality of the piece augmented by the way in which it was composed?

Is a decent painting painted by someone who paints blindfolded something I would rather see than an excellent painting by someone who paints in a conventional fashion?

Cause unless the live coder can spin something up that I would enjoy listening to on my portable media player, I feel like music takes a back seat to the musician, which is a truly peculiar something.

[…]

This is not to say live coding is something to be ignored, but where from ever in history have we asked this question? Does the musician matter more than the music?

And another, even more critical comment from another reader:

It is not about letting the audience in at all. It’s about cultivating an stage presence of virtuosic technical wizardry. No one in the audience understands the code and that’s why everyone marvels at the “magic”. Worse still it’s Lisp, a particularly archaic and obfuscated computer language.

=+=

I think this is all very useful to read, as it shows what non specialists may think of livecoding. I’ve been asking myself similar questions a lot of times, but never really reached a clear conclusion. Is livecoding a music-making activity, or is it best defined as multimedia-oriented programming?

I personally got into livecoding as a musician first, programmer second. As a result I usually see it as some sort of advanced music-making tool; however, funnily enough, in order for that to happen I need to program the livecoding environment and fine-tune it so that it matches better my approach to music. And when I do that, I inevitably lose the closure to the ‘instrument’ that would let me approach it as a ‘musical’ instrument. And I end up in the role of ‘multimedia programmer’.

It’s a cyclical process, which makes me think: maybe what’s so cool about it. Livecoding environments are malleable meta-instruments that let you create (software) music instruments.

So the music – the end result – is definitely part of it. But the process, the how in the music creation business is also what we have in focus here. For this process is also eminently creative (and here lies the difference with many other digital music ‘creation’ tools) and, maybe most importantly, this process is abstracted and codified and thus potentially reproducible and reusable by others.

Any comments?

There’re a thousand improvements that could be done to it still, but the core of the application is there: I packaged it as a standalone app that you can download here. (use the ‘show package contents’ Finder command to see the source code).

The application relies on a bunch of XML processing functions that I found within Impromptu ‘examples’ folder (specifically, it’s the example named 35_objc_xml_lib). I pruned that a bit so to fit my purposes and renamed it xml_lib.scm.

By using that, I created a function that extracts title and url info from the guardian feed:

(load "xml_lib.scm")
(define feedurl "http://feeds.guardian.co.uk/theguardian/world/rss")

;;
;; loads the feed and extracts title and url
;;

(define get-articles-online
     (lambda ()
        (let* ((out '())
               (feed (xml:load-url feedurl))
               (titles (objc:nsarray->list (xml:xpath (xml:get-root-node feed)
                                                "channel/item/title/text()")))
               (urls (objc:nsarray->list (xml:xpath (xml:get-root-node feed)
                                                "channel/item/link/text()"))))
           (for-each (lambda (x y)
                        (let ((xx (objc:nsstring->string x))
                              (yy (objc:nsstring->string y)))
                           (set! out (append out (list (list xx yy))))))
                titles urls)
           out)))

Some feed titles are a bit longish, so I added a utility function formattext that wraps the titles’ text if they exceed a predefined length.

(define formattext
   (lambda (maxlength txt posx posy)
      (let ((l (string-length txt)))
         (if (> l maxlength)
             (let loop ((i 0)
                        (j maxlength) ;; comparison value: it decreases at each recursion (except the first one) 
                        (topvalue maxlength)) ;; komodo value : must be equal to j at the beginning
                (if (equal? (- topvalue i) j) ;; the first time
                    (loop (+ i 1) j topvalue)
                    (begin   ;(print (substring txt (- topvalue i) j))
                             (if (string=? (substring txt (- topvalue i) j) " ")
                                 (string-append (substring txt 0 (- topvalue i))
                                                "\n"
                                                (substring txt (- topvalue i) (string-length txt)))
                                 (if (< i topvalue) ;;avoid negative indexes in substring
                                     (loop (+ i 1) (- j 1) topvalue))))))
             txt))))

And here’s the main loop: it goes through all the feed items at a predefined speed, and displays it on the canvas using a cosine oscillator to vary the colours a bit. At the end of it I’m also updating 3 global variables that are used for the mouse-click-capturing routine.

(define displayloop
   (lambda (beat feeds)
      (let* ((dur 5)
             (posx  (random 0 (- *canvas_max_x* 350)))
             (posy  (random 10 (- *canvas_max_y* 150)))
             (txt (formattext 40 (car (car feeds)) posx posy))
             (dim ;(+ (length feeds) 10))                  
                  (if (= (length feeds) 29)
                      60  ;; if it's the first element of the feed list make it bigger
                      (random 25 50)))
             (fill (if (= (length feeds) 29)
                         '(1 0 (random) 1)  ;; if it's the first element of the feed list make it reddish
                         (list (random) 1 (random) 1)))
             (style (gfx:make-text-style "Arial" dim fill)))
         (gfx:clear-canvas (*metro* beat) *canvas* (list (cosr .5 .6 .001) 0 (cosr .5 .6 .001) .5 ))
         (gfx:draw-text (*metro* beat) *canvas* txt style (list posx posy))
         (set! *pos_x* posx)
         (set! *pos_y* posy)
         (set! *current_url* (cadr (car feeds)))
     (callback (*metro* (+ beat (* 1/2 dur))) 'displayloop (+ beat dur)
               (if-cdr-notnull feeds
                               (get-articles-online))))))

In order to capture the clicks on the feed titles I simply create a rectangle path based on the x,y coordinates randomly assigned when displaying the title on the canvas. These coordinates are stored in global variables so that they can be updated constantly.

(io:register-mouse-events *canvas*)
(define io:mouse-down
   (lambda (x y)
      (print x y)
      (when (gfx:point-in-path? (gfx:make-rectangle *pos_x* *pos_y* 200 200) x y )
            (util:open-url *current_url*))))

Finally, the util:open-url opens up a url string in your browser (I’ve already talked about it here).

You can see all of this code in action by downloading the app and taking a look its contents (all the files are under Contents/Resources/app).

Some other things it’d be nice to do:

Any other ideas?

Although the article is quite introductory (Edwards makes it clear that the article “is more illustrative than all-inclusive, presenting examples of particular techniques and some of the music that has been produced with them”) it is defintely an interesting read. I found quite a few nice ideas in it and also references to musics and musicians I wasn’t familiar with.

Follows a list of ‘highlights’ from my iPad reader, to which I added hyperlinks to relevant explanatory materials:

After World War II, many Western classical music composers continued to develop the serial technique invented by Arnold Schönberg (1874–1951) et al. Though generally seen as a radical break with tradition, in light of the earlier historical examples just presented, serialism’s detailed organization can be viewed as no more than a continuation of the tradition of formalizing musical composition. Indeed, one of the new generation’s criticisms of Schönberg was that he radicalized only pitch structure, leaving other parameters (such as rhythm, dynamic, even form) in the 19th century. They looked to the music of Schönberg’s pupil Anton von Webern for inspiration in organizing these other parameters according to serial principles. Hence the rise of the total serialists: Boulez, Stockhausen, Pousseur, Nono, and others in Europe, and Milton Babbitt and his students at Princeton.

Lejaren Hiller (1924–1994) is widely recognized as the first composer to have applied computer programs to algorithmic composition. The use of specially designed, unique computer hardware was common at U.S. universities in the mid-20th century. Hiller used the Illiac computer at the University of Illinois, Urbana-Champaign, to create experimental new music with algorithms. His collaboration with Leonard Isaacson resulted in 1956 in the first known computer-aided composition, The Illiac Suite for String Quartet (wiki | video), programmed in binary, and using, among other techniques, Markov Chains in “random walk” pitch generation algorithms.

Cage said in an interview during the composition of HPSCHD (wiki | video), “Formerly, when one worked alone, at a given point a decision was made, and one went in one direction rather than another; whereas, in the case of working with another person and with computer facilities, the need to work as though decisions were scarce—as though you had to limit yourself to one idea—is no longer pressing. It’s a change from the influences of scarcity or economy to the influences of abundance and – I’d be willing to say—waste.”

Known primarily for his instrumental compositions but also as an engineer and architect, Iannis Xenakis was a pioneer of algorithmic composition and computer music. Using language typical of the sci-fi age, he wrote, “With the aid of electronic computers, the composer becomes a sort of pilot: he presses buttons, introduces coordinates, and supervises the controls of a cosmic vessel sailing in the space of sound, across sonic constellations and galaxies that he could formerly glimpse only in a distant dream.
[...]
Xenakis’s approach, which led to the Stochastic Music Programme (henceforth SMP) and radically new pieces (such as Pithoprakta, 1956), used formulae originally developed by scientists to explain the behavior of gas particles (Maxwell’s and Boltzmann’s Kinetic Theory of Gases). He saw his stochastic compositions as clouds of sound, with individual notes as the analogue of gas particles.
[...]
His Eonta (1963–1964) for two trumpets, three tenor trombones, and piano was composed with SMP. The program was applied in particular to the creation of the massively complex opening piano solo.

Koenig saw transcription (from computer output to musical score) as an important part of the process of algorithmic composition, writing, “Neither the histograms nor the connection algorithm contains any hints about the envisaged, ‘unfolded’ score, which consists of instructions for dividing the labor of the production changes mode, that is, the division into performance parts. The histogram, unfolded to reveal the individual time and parameter values, has to be split up into voices.”

Contemporary (late 20th century) techniques tend to be hybrids of deterministic and stochastic approaches. Systems using techniques from artificial intelligence (AI) and/or linguistics..
[...]
While naturally significant to AI research, linguistics, and computer science, such systems tend to be of limited use to composers writing music in a modern and personal style that perhaps resists codification because of its notational and sonic complexity and, more simply, its lack of sufficient and stylistically consistent data
[...]
Thus we can witness a division between composers concerned with creating new music with personalized systems and researchers interested in developing systems for machine learning and AI. The latter may quite understandably find it more useful to generate music in well-known styles not only because there is extant data but also because familiarity of material simplifies some aspects of the assessment of results. Naturally though, more collaboration between composers and researchers could lead to fruitful, aesthetically progressive results.

Application of algorithmic-composition techniques is not restricted to academia or to the classical avant garde. Pop/ambient musician Brian Eno (1948–) is known for his admiration and use of generative systems in Music for Airports (1978) [wiki | video] and other pieces. Eno was inspired by the American minimalists, in particular Steve Reich (1936–) and his tape piece It’s Gonna Rain (1965) [wiki | video].
[...]
Eno said about his Discreet Music (1975) [wiki | video], “Since I have always preferred making plans to executing them, I have gravitated towards situations and systems that, once set into operation, could create music with little or no intervention on my part. That is to say, I tend towards the roles of planner and programmer, and then become an audience to the results”.

After leaving his native Hungary in the late 1950s, Ligeti worked in the same studios as Cologne electronic music pioneers Karlheinz Stockhausen and Gottfried Michael Koenig though produced little electronic music of his own. However, his interest in science and mathematics led to several instrumental pieces influenced by, for example, fractal geometry and chaos theory. But these influences did not lead to a computer-based algorithmic approach. He was quoted in Steinitz saying, “Somewhere underneath, very deeply, there’s a common place in our spirit where the beauty of mathematics and the beauty of music meet. But they don’t meet on the level of algorithms or making music by calculation. It’s much lower, much deeper—or much higher, you could say.”

I have implemented algorithmic models of the first part of Désordre in the open-source software system Pure Data, which, along with the following discussion, is based on analyses by Tobias Kunze,26 used here with permission, and Hartmut Kinzler. It is freely downloadable from my Web site http://www.michael-edwards.org/software/desordre.zip
[...]
The main argument of Désordre consists of foreground and background textures..
[...]
In Désordre we experience a clear, compelling, yet not entirely predictable musical development of rhythmic acceleration coupled with a movement from the middle piano register to the extremes of high and low, all expressed through two related and repeating melodic cycles with slightly differing lengths resulting in a combination that dislocates and leads to metrical disorder. I invite the reader to investigate this in more detail by downloading my software implementation.

There has been (and still is) considerable resistance to algorithmic composition from all sides, from musicians to the general public. This resistance bears comparison to the reception of the supposedly overly mathematical serial approach introduced by the composers of the Second Viennese School of the 1920s and 1930s. Alongside the techniques of other music composed from the beginning of the 20th century onward, the serial principle itself is frequently considered to be the reason the music—so-called modern music, though now close to 100 years old — may not appeal.
[...]
Algorithmic composition is often viewed as a sideline in contemporary musical activity, as opposed to a logical application and incorporation of compositional technique into the digital domain. Without wishing to imply that instrumental composition is in a general state of stagnation, if the computer is the universal tool, there is surely no doubt that not applying it to composition would be, if not exactly an example of Luddism, then at least to risk missing important aesthetic developments that only the computer can facilitate, and that other artistic fields already take advantage of.

Much of the resistance to algorithmic composition that persists to this day stems from the misguided bias that the computer, not the composer, composes the music. In the vast majority of cases where the composer is also the programmer, this is simply not true. As composer and computer musician Curtis Roads pointed out more than 15 years ago, it takes a good composer to design algorithms that result in music that captures the imagination.
[...]
Furthermore, using algorithmic-composition techniques does not by necessity imply less composition work or a shortcut to musical results; rather, it is a change of focus from note-to-note com- position to a top-down formalization of compositional process. Composition is, in fact, often slowed by the requirement that musical ideas be expressed and their characteristics encapsulated in a highly structured and non-musical general programming language. Learning the discipline of programming is itself a time-consuming and, for some composers, an insurmountable problem.

The other day I watched for the first time “Laputa: Castle in the Sky” [wikipedia | imdb], the first film created and released by Studio Ghibli in 1986. I found the cartoon so inspirational and touching that I though I’d post something about it.

The themes that emerge are not at all new in Studio Ghibli’s anime: the love for a primordial dimension where nature still remains untouched; the celebration of the human values of honesty and respect for others; the relationship between technology and ecology; the fascination with sci-fi, futuristic worlds. All of this conveyed in two hours of Indiana Jones-style adventure..

[check out the video on youtube: http://www.youtube.com/watch?v=Q3AN0eDxE7E I couldn't embed it due to copyright violation in some countries!]

Other information and reviews are available on this site: http://www.wingsee.com/ghibli/laputa/, including:

- 9/7/11: A gig in Paris at La Generale, “Laboratoire artistique, politique et social”. 14, avenue Parmentier Paris XIe, Métro Voltaire (facebook | lastfm)

- 11/7/11: A workshop+gig at the 2011 Libre Software Meeting in Stransbourg (event page | facebook | lastfm).

I’m going to play a new livecoded song called ‘Fjords‘. During the last days I’ve also finalized several little things that make livecoding with Impromptu faster (and easier, at least for me), which is good, so I’m aiming at making available those too in the coming days…

Btw I’ll try to take videos of the various performances, so stay tuned!        

[Update 11/7/11] Here’s a recording of the Paris gig:

It’s intuitive to think that anything complex has to be made by something more complex, but evolution theory says that complexity arises out of simplicity. That’s a bottom-up picture. I like that idea as a compositional idea, that you can set in place certain conditions and let them grow. It makes composing more like gardening than architecture

It’s from http://www.soundonsound.com/sos/oct05/articles/brianeno.htm.

Here is one of the songs from the album Eno is talking about in that article, Another Day on Earth.

Biophilia for iPad will include around 10 separate apps, all housed within one “mother” app. Each of the smaller apps will relate to a different track from the album, allowing people to explore and interact with the song’s themes or even make a completely new version. It will also be an evolving entity that will grow as and when the album’s release schedule dictates, with new elements added. Scott Snibbe, an interactive artist who was commissioned by Björk last summer to produce the app, as well as the images for the live shows (which will combine his visuals with National Geographic imagery, mixed live from iPads on the stage), describes how Björk saw the possibilities of using apps, not as separate to the music, but as a vital component of the whole project. “Björk’s put herself way at the forefront here by saying, ‘We’ll release this album and these apps at the same time and they’re all part of the same story.’ The app is an expression of the music, the story and the idea.”

The review above is taken from an article on posterous.com. How will the music/apps look like? Here’s an example:

For one song, Virus, the app will feature a close-up study of cells being attacked by a virus to represent what Snibbe calls: “A kind of a love story between a virus and a cell. And of course the virus loves the cell so much that it destroys it.” The interactive game challenges the user to halt the attack of the virus, although the result is that the song will stop if you succeed. In order to hear the rest of the song, you have to let the virus take its course. Using some artistic license, the cells will also mouth along to the chorus. It’s this determination to fuse different elements together – be it juxtaposing a female choir from Greenland with the bleeps and glitches of electronic music pioneers Matmos during the Vespertine tour, or meshing soaring strings and jagged beats on the Homogenic album – that helps explain the power and success of Björk’s collaborations…..

Biophilia is the result of a collaboration with Scott Sona Snibble, a digital artist active in the app-world with products such as ‘OscilloScoop’:

More press coverage on Pitchfork and the Guardian.

Some of them will open up the musical capabilities of html5, which are pretty cool. Example, once you switch on the ‘web-audio‘ setting on Chrome, if you use a suitable musical musical library you could play a note just by issuing these javascript commands:

var n = Note.fromLatin('A4'); 

var freq = n.frequency(); // returns 440
var name = n.latin(); // returns "A"
var octave = n.octave(); // returns 4

The full example (with sound, if you’ve turned on the Web Audio setting as mentioned above) can be seen here: musicjs demo.

More info about web audio and related stuff can be found on this blog post: http://pixelist.info/web-audio-it-is-finally-almost-here/