Beyond Common Music Notation : The collections of Cage & Sauer : After Kelemen : A rapid composition, simulation and graphing continuum : Working with graphical units : Mulholland’s How to Consecrate and Imaginary Circle : The Triangle of the Art : Scripting and the ‘poietic’ thread : Fifteen Images : Mapping Yorkshire
Beyond Common Music Notation
During the 1950s, contemporary composers began to experiment more freely with alternatives to symbolic, or common music notation (CMN). We have already encountered Feldman’s ‘graph score’ notation with regard to Duos, Trios, Quartets, and in this chapter we will look at other alternative methods to scoring for live performance, and the relationship between scripting, graphic or extended scores, and the production of reference recordings to assist players in their interpretation, as well as to assist the composer in explorations of how a piece should be articulated.
The interest in developing new methods by which to express musical ideas can be related to musical concerns stemming from the need to produce effects that would be unwieldy to express in common music notation: for example, complex, pointillistic textures. The development of the graphic score also have parallels with the incorporation of improvisation or improvisatory concepts into the traditions of contemporary classical music – listen, for example, to the performance below of Feldman’s Atlantis (1959). This is one of Feldman’s ‘graph score’ pieces, composed on squared paper, in which each square indicated a fixed period of time, and the number therein tells the player how many notes to play during that time. Listen particularly the piano solo, which has an improvisatory quality stemming from the individual tastes of each player and their interpretation of the numerical material… although it is also doubtless well rehearsed.
Furthermore, John Cage observed that music is often lagging behind the visual arts in terms of development, and it is apparent that developments in visual art during this period had a profound influence on more experimental composers, for example Earle Browne, quoted below:
My first thoughts about making musical works in what I call a condition of mobility, and what is now called open form, were influenced by the mobiles of the American sculptor Alexander Calder. At approximately the same time, around 1948, the paintings and working methods of Jackson Pollock began to be widely publicized in America. A correlation that I made-rightly or wrongly-between these two artists and their technical and aesthetic points of view has been my rather obsessive primary motivation as an artist and composer since that time. The first works that I consider practical extensions of this point of view into music are in FOLIO (1952-53); they reflect both of the above artists’ characteristics, which I feel are applicable to the composition, form, and performing and experiencing of music.
The state of notation in the 1960s can be assessed by exploring John Cage’s Notations (1969), which is an exhaustive catalogue of musical notation gathered from the manuscripts and scores of around 150 modern composers, which run the gamut from conventionally notated pieces, to graphic scores, text scores and Dadaistic collage. Theresa Sauer’s more recent compilation, Notations 21 (2009), explores the contemporary revival of graphic scores, many of which are developed by computer-assisted means.
After Kelemen: Rapid Composition, Simulation and Graphing
Amongst the notations collected by Cage, one of the most striking with regard to the relationship between graphic mark and realisation by an ensemble, is Milko Kelemen’s Composé (1966), illustrated below, and audible here:
As can be heard, the graphic signs readily suggest the qualities of different instruments or styles of articulation. The strident piano as a sawtoothed black bar, the glissandos of brass instruments as wavy lines, multiphonic flutes as triangles, the bright, pointilistic qualities of tuned percussion as dots, the sustaining qualitiy of bowed strings as lines, and so on.
With computer-assisted composition, we can also explore the production of graphic scores as an element of the scripting process. Within the concept of a ‘composing continuum’, it becomes possible to explore complex musical ideas in code, and realise them, not as common notation, but as graphical objects, as well as also creating reference audio material concurrently.
The below score and audio recording were developed using a workflow that freely moved between a CAC environment (Opusmodus, in this case), a graphic design package (Inkscape) and digital audio workstation (Logic):
To begin working in such a way, two things are necessary: first, to ensure communication between your CAC environment and your DAW, and secondly to find an appropriate graphic design package.
The process of allowing MIDI messages to be shared between applications is relatively straightforward for Mac users. By opening the Audio MIDI Setup application (usually in Applications/Utilities), one can swiftly create or enable the IAC (Inter-Application Communication) driver. This allows you to set up virtual MIDI ports, which are mapped to the MIDI inputs on other applications:
As for graphic design or display software, Inkscape is an excellent free, open-source package which allows data from a CAC such as Opusmodus to be quickly manipulated. Another alternative would be to make us of the IAC driver in conjunction with a system like Max and Jitter, in order to capture and graphically render MIDI data as it is generated by the DAW. In this case, however, we will concentrate on using a standard graphic design package.
Many CAC packages allow for the visualisation of parametric data. The Symbolic Composer visualiser, for example, has already been mentioned in the discussion of Array in the chapter on composition for solo instrument. The graph below was produced by Opusmodus, which can visualise data based on pitch, duration and velocity parameters:
The graph above is a visual representation of a complex series of clusters that form the opening piano part of the After Kelemen piece shown above:
We’ll start by looking at how these clusters were generated, and how we can visualise them as graphs, before translating them to a more pleasing graphical form.
We could create a series of undulating pitches in various ways, such as the use of a noise-based algorithm (brownian noise would be suitable in this instance, for example). However, here a modulated sine-wave is created to deliver a more coherent arc of movement. The following script will create 50 values based on two modulating sine waves:
We can see the output of this using the Opusmodus’ list-plot function, in a similar way to the visualiser in Symbolic Composer:
When evaluated, this line of script outputs a graphical plot:
Once we have found a pleasing shape, we must decide how to use the data, which is currently in stored as a series of complex vectors, between -1.0 and +1.0. In this instance, we will use them as a series of transpositions, by rounding the list into integers between -36 and 0 (e.g. a span of 3 octaves):
To use these values to develop a series of clusters, we can use the gen-cluster function:
The function gen-cluster takes several arguments, which can explained in terms of the above script:
- (gen-cluster (rnd-sample events (gen-integer 3 7))
We begin by generating a series of numbers between 3 and 7. These numbers will define the size of each cluster. The variable events was previously assigned the value of 50, since we earlier generated 50 samples of sinusoidal data.
- :transpose pno_trans_A
This argument tells the function not only to generate a series of clusters, but to also transpose them, using the 50 integers between -36 and 0 which we generated earlier.
- :rotate (rnd-sample events (gen-integer 0 5)
The final argument will also rotate the values of the clusters between 0 and 5 steps.
We could even visualise the output again, this time using the pitch domain:
The next step is to create some two more sequences of clusters (pno_B and pno_C) by duplicating the code and altering the events variable and the sine wave parameters. Finally, we can create a small rest fragment and append the various parts:
We can visualise this OMN fragment as pitch and duration values using the following code:
You will notice that the 1/2 values correspond to the rests inserted between the cluster series.
One advantage of a CAC like Opusmodus is the freedom to copy and export data into other applications. For example, the above omn-list-plot function can export graphs as PDFs by the addition of the :file argument:
PDF is a file format that allows the flexible encoding and interchange of text and graphics. In this case the PDF comprises of a series of vector graphics. Using Adobe Acrobat Pro, it is easy to use the TouchUp Object tool to select the graph lines and axes in order to reduce the file to only the components that will be used in the graphic scoring:
This edited PDF can then be swiftly imported into a graphic design programme such as Inkscape. Here is an example of the Import PDF dialogue accessed via File > Import in Inkscape:
The graph itself can easily be broken into its constituent parts, and the necessary elements isolated by using the Object > Ungroup option:
And from there, they can be swiftly elaborated on. For example, each vector graphic is made up of a series of ‘nodes’ or points, which are joined dot-to-dot style. By filling in the shape and dragging the end nodes upward, we can begin to create blocks akin to Kelemen’s original score:
This can be then filled in and further edited, for example, by using the Path > Difference operator to cut out rectangles from the shape:
Concurrently, this data can be sounded out as part of a developing realisation of the piece within a DAW, most readily by saving and inserting the corresponding MIDI fragment from the CAC environment. In Opusmodus, auditioning an OMN snippet also makes that snippet qualify as the ‘last score’ evaluated. By electing to play the last score within the Opusmodus environment, one can not only see and hear the MIDI data, but can also save the fragment in question either by using File > Export > Last Score to Midi, or more directly by clicking Opusmodus’ piano roll window and using the save shortcut (cmd-S):
So, from a fragment of code, it is possible to swiftly create data suitable for both audible (MIDI) and graphic (PDF) expressions. Further graphic expressions may also be produced from other approaches to visualisation within the CAC, for example we can modify various arguments in omn-list-plot:
Which produces a graph showing only points, unjoined by lines:
Once again, it is fairly easy to dispense with the bar lines and axes in Acrobat Pro, leaving us with vector graphic data that can be swiftly manipulated:
he process of dynamically composing fragments in a CAC environment, and outputting graphics and MIDI data to a structured drawing package and DAW respectively enables – once one is familiar with the function of each package – an alternate perspective on the concept of a composing continuum. Here, the process of moving from code to a fully detailed common music notation score is not the chief concern, rather the rapid-prototyping of reference materials and score fragments becomes the motivation: such fragments of MIDI and graphical data then come to comprise a library of gestures, phrases and sections that can be endlessly revised and varied in code, and also recombined and further manipulated as a graphic scores and corresponding DAW simulations:
Triangle of the Art: Working with Graphical Units
In After Kelemen, we developed graphic scoring alongside what might be considered to be a ‘reference recording’ to give performers and idea of how the visual image may be translated into music. This approach presents a fused continuum: the scripting, scoring and audition occur concurrently as the work develops. As an alternative, we could also consider the way that graphic scores can be used to elicit a response – performative or compositional – and explore how we can use them to develop our own computer-assisted compositional practices.
In this respect, we could look at a work like Cornelius Cardew’s encyclopaedic Treatise (1963-67) and begin to devise our own responses through code. This would undoubtedly be a very valuable developmental practice – however, given the complexity of the work and the diversity of symbols, transformations and relationships thereof exhibited in the score, we will here concentrate on a simpler inspiration.
Drew Mulholland is currently research fellow with Glasgow University, assigned to the astronomy and astrophysics research group. Having a background in the experimental psychogeographic group Mount Vernon Arts Lab, Mulholland became composer-in-residence with Glasgow’s School Of Geographical & Earth Sciences in the mid-2000s. The graphic score in question dates from the end of this period, and is entitled How to Consecrate an Imaginary Circle. Mulholland writes that the score “was created using magickal symbols from the 1665 edition of Reginald Scot’s The Discovery of Witchcraft in which Scot describes the symbols as having the power to act as a conduit between man and the genii locurum (the spirits of a place).These symbols or sigils represent the human relationship with the world and place within it.”
The opening of the score looks like this:
And the original symbols from the 17th-century book of witchcraft that inspired the score are shown below:
It can be seen that various manipulations have been made to these symbols. The score opens up with a curve, evidently abstracted from the ‘sun-like’ symbol in the top right of the original series. Other symbols have been rotated or otherwise manipulated. However, each one does suggest a distinct sonic idea or musical trajectory. As a tribute to Drew’s score, a companion piece Triangle of the Art was devised by assigning each symbol a number (1-10) and generating a series of random values in order to dictate the flow of symbols. The stream of values is broken up by the presence of the third symbol at each corner of the triangle. The symbols are numbered in the presentation of the score below to aid our discussion of the process of going from graphic score to musical output:
The process of coding was to move through the triangle from the topmost point, in a clockwise direction. For each symbol, question were asked such as ‘how does this sound?’, ‘where does this suggest the music is moving?’, ’what form of gesture is this?’ and ‘what sort of musical structure does this suggest?’
The process began with the sun symbols at each corner. The intuition was that this would be a sharp, high-pitched and dense sound, such as a chromatic cluster. Given that the symbol occurs several times, it made sense to develop a function for each one. So, the script to generate a sun symbol looks like this:
And yields outputs such as:
To briefly examine the particulars of this function:
- (setf cluster-notes …
This will output a chord of consecutive semitones. The basic procedure is that gen-integer-seq generates the series ‘(0 1 2 3 4). Next, a single random number between 2 and 5 is generated using rnd-number. Unfortunately the output from this function is a list, so the car primitive is used to dispense with the list and simply return the number on its own. This allows the value to be used with filter-first, essentially reducing the series ‘(0 1 2 3 4) to ‘(0 1), ‘(0 1 2), ‘(0 1 2 3) or, unmodified, ‘(0 1 2 3 4). Finally, this series of integers is rendered into pitches using integer-to-pitch and chordized:
- (setf cluster (pitch-transpose …
This code will transpose the cluster using pitch-transpose anywhere between 12 and 24 steps upward:
- (setf om-out (make-omn …
Finally, an omn fragment is created with a random duration and fff dynamic. Being the last variable defined in the function, this is the value which the function will also return.
=> (h g5gs5a5bb5b5 fff)
So, calling (sym-3) will begin to return various clusters. Additionally it will set the variable om-out to whatever the output of the function was. This is useful, since it means we can easily get the last output and use it as material for the next function to process.
Looking at the graphic score, the next symbol is number 5, which is a diagonally descending line with alternating lines on either side. This was interpreted as a descending series of clusters, each alternating above and below a given trajectory:
This is quite a long chunk of code , but in summary:
- (setf last-highest (integer-to-pitch (find-max …
The function begins by looking at om-out (the variable containing the output of the last symbol called), and working out what the highest pitch in the OMN fragment is. This has to be done by converting the pitches to integers, then using find-max to find the highest value, and then converting back to pitches.
- (setf cl-size (filter-first …
The next stage is to generate a cluster size – a set of numbers based on truncating the series ‘(0 1 2 3 4). This is essentially the same procedure as used in the earlier function.
=> (0 1 2)
- (setf cluster-notes (chordize …
This statement will uses pitch-transpose-n to transpose the highest tone (b5) by the number of steps stored in cl-size (0 1 2).
- (setf tx-dest (list (append ‘(0) (rnd-number 1 -12 -24))))
The above statement will output two numbers: a zero, followed by a value between -12 and -24. This dictates how many steps the descending sequence will contain.
=> (0 -21)
- (setf tx-arc (gen-integer-seq tx-dest))
This statement generates a series of integers spanning the range of the musical gesture:
=> (0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16 -17 -18 -19 -20 -21)
- (setf tx-clusters-a (gen-repeat (length tx-arc) cluster-notes))
Next, the clusters are repeated for as many steps in the gesture:
=> (b5c6cs6 b5c6cs6 b5c6cs6 b5c6cs6 . . .
- (setf tx-clusters-b (pitch-transpose tx-arc (mclist tx-clusters-a)))
The repeated clusters are divided into sublists, each of which is then transposed against the descending series of values:
=> ((b5c6cs6) (bb5b5c6) (a5bb5b5) (gs5a5bb5) (g5gs5a5) (fs5g5gs5) …
- (setf tx-clusters-c (find-everyother 2 (flatten tx-clusters-b)))
(setf tx-clusters-d (filter-remove tx-clusters-c tx-clusters-b)
(setf tx-clusters-e (pitch-transpose ‘-12 tx-clusters-c))
The next set of statements are presented together. Find-everyother is used to filter out every second cluster. These clusters are then filtered from the original list, effectively giving us two lists of descending clusters. One of these lists is then transposed down by an octave.
- (setf tx-clusters-f (flatten (gen-mix tx-clusters-d tx-clusters-e)))
Both lists are then mixed together again, creating a series of alternating clusters:
=> (b4c5cs5 bb5b5c6 a4bb4b4 g4gs4a4 gs5a5bb5 f4fs4g4 …
- (setf om-out (make-omn …
Finally, an OMN fragment is generated in which all the clusters share a randomly assigned duration.
We can begin stringing our functions together to create a complex progression of musical transformations, so:
The above would yield a sequence that looks like this on the DAW piano roll:
The various musical processes associated with each symbol are described below. For the sake of brevity the code will not be discussed, although the full script for the composition is appended to this chapter.
The vertical lines are interpreted as clusters with increasingly wide upper and lower values. These clusters take their tonal centres from the note output by the last symbol invoked. The triangle which follows it is a re-iteration of only the upper and lower values of the cluster. It can be visualised like this on the piano roll:
This symbol has three elements – the lower circle represents a low cluster, the triangle a sequence of condensing and expanding chords, and the upper arrow a high tone from which the subsequent symbol will develop its musical gesture:
You will notice that the last symbol in this set only ever occurs in juxtaposition with other symbols in the score, for example:
One advantage of Opusmodus’ OMN notation is that combining fragments together is an easy task, and in a situation such as this facilitates a rapid ‘sounding’ of the score in question. The function uses in this case is merge-voices, which will combine two OMN lists into a more complex, multi-voiced fragment, for example:
Once the symbol-related functions have been defined, all that is required is that they are invoked in the desired series, incorporating merge-voices statements as necessary. Therefore the actual ‘scoring’ of the piece in scripting terms looks like this:
The output from Opusmodus looks like this, when viewed into Logic’s piano roll:
For the final realisation, organ registrations were incorporated (as was a fixed velocity), and the final chord was extended. Otherwise, all articulations and timings are exactly as produced by the code.
Of course, standard notation could also be produced as an element of each function, if a standardised score was desired or deemed integral to the compositional output.
Composing by way of functions, each of which can draw inferences from the output of the last one, provides one strategy to approach the question of continuation in scripted and algorithmic composition. It is not, of course, a ‘deep’ approach, depending as it does only on one value from the prior output, rather than more complex inferences from the totality of the last output phrase: in this instance, the complexity derives from the compositional association of graphical structures with sonic ones. Despite the relative simplicity of the approach, it does yield convincingly naturalistic, improvisatory progressions, and allows the composer to impart something of his or her own sensibilities in the realisation of reference material for performers.
The approach to structuring code naturally makes the production of variants an extremely straightforward task, for example:
Scripting, Graphics and the Poietic Thread
Having looked at the composing continuum as part of a rapid prototyping technique for graphic scoring and reference recording, we will now look at how this concept relates to more involved bodies of work.
One of the advantages of developing work in a scripting language is the ease by which a trace of the making, or poiesis, of a work can be established. Such a thread is often implicit in the script itself, and can be traced as it develops from fundamental parametric materials (such as sets of pitch, velocity and duration data) into more complex, compositional structures. Naturally, scored and sounding outputs will be output from this process. However, we may also explore the possibilities of articulating other aspects of the compositional process as part of the composition.
Nigel Morgan’s Fifteen Images does this on a grand scale, giving the performer with an ‘active’ multi-media score which presents not only a score for each of the fifteen movements of the piece, but also allows the performer or interested student of composition to step backward through the creative process for each section: to see the skeletal structure of the piece, the fundamental scripting components, the basic tonality and rhythmic materials, and even the composer’s original sketches. The rationale is to allow the performer to get ‘closer’ to the music, so that they may engage in informed improvisations on the materials presented to them: in effect, they may retrospectively participate in the same composing continuum. The various layers that express the poietic thread of the piece are as follows:
The layers of the score can be faded from one to another by the performer, so that hybrids can also be introduced, such as the harmonic plan superimposed with the basic score, shown here in the Active Notation software itself:
The score further extends the concept of an unfixed, ‘active’ score by also allowing further superimpositions of suggested articulations or approaches to playing the material, and also incorporates visual ‘textile animation’ for each movement by the artist Alice Fox. As can be seen above, there is a diagrammatic ‘script’ view, which presents the player with a visual representation of the actual script used to generate the piece, allowing them to get a feel for the compositional processes informing the end result, and hopefully enabling them to improvise around the score in a convincing and informed manner.
Naturally, such a project is a significant artistic and technical undertaking, although the ability of both Opusmodus and Symbolic Composer to produce notation makes similar, if less technically reliant, approaches much more viable in the sense of a rapidly integrated compositional continuum. One example would be Nigel Morgan’s subsequent Mapping Yorkshire composition, entirely realised with Opusmodus and the InDesign structured drawing package.
Mapping Yorkshire shares a similar philosophy to Fifteen Images: there are two printed scores: one presents each movement as fully notated composition; the other gives graphics, written instructions, notation fragments and printouts of the data used in the scripted elements.
The above examples should make clear a few of the extended possibilities open to the computer-assisted composer: the key concept that unites all these approaches is the portability of data between CAC environment and satellite programmes. This opens up new possibilities for computer-assisted composition, sonic and visual mediums, especially when one considers the relative ease that we might, for example, use a live coding tool to develop a work in an improvisatory manner, while simultaneously rendering visual representations using Max and Jitter, or the Processing scripting language for graphical communication. Further considerations of the ease of interchange between vectors, integers, pitches and so on may also open up new creative approaches for conveying the inner-workings of computer-assisted compositions to a non-specialist audience of players and listeners.
The Triangle of the Art [opmo]