I had an idea for a new piece of music based loosely on the idea of data caching in computer systems, and on the idea of mutual recursion.

I will spend time formally describing the piece in a future post, but the high-level idea is this:

Emitters.  There is a set of ‘emitters’.  These are abstract, and could be humans or groups of humans or whatever.  An emitter is, abstractly, an list of values ordered from oldest to newest.  Each emitter is initialized to some arbitrary initial sequence, where the values in the sequence fall within the range [0, …, L], and L is the length of emitters’ sequences.  The number of values an emitter contains is arbitrary, but must be the same for all emitters.

Time and Triggering.  Each emitter also has a time interval associated with it.  There is assumed to be some global timing mechanism (pulse, clock, etc).  An emitter with interval ‘i’ is “triggered” every i ticks of the global clock.  When triggered, the emitter compares its values to the values of all other emitters.  The emitter is trying to determine how many of the values it contains are also contained within some other emitter, which in this discussion I’ll call the “overlap”.  The value of the overlap is guaranteed to be in the range [0, …, L], since at the least, no emitter contains any tone contained by the querying emitter; and at most every tone is contained in some other emitter.

Emitting and Updating.  For a given global tick, once all triggered emitters have determined their overlap value, they do two things:

First, they emit their current sequence.  The form of the emission depends on the medium to which the piece is being rendered.  The simplest thing to do is to print a list of numeric values.  With additional complexity, the numeric values could be mapped to tones, and the emission could be the production of a chord of those tones by a computer.  Another rendition would be to map the values to tones, and emit a written version of the chord for playing by a human player, or human players.

After emitting, emitters “shift” their overlap value into their sequence as the newest value.  This means the oldest value is discarded, the second oldest takes the position of the oldest, and so forth, and the overlap value takes the position of the newest value.

And that process fully specifies the piece, though not quite formally.  There is still a great deal of characterization of this piece to be done, and it is entirely possible that this piece is in fact an instance of some other general function from the world of math that I am unaware of.

One interesting thing I have discovered through preliminary experiments is that it seems to be the case that sequences always converge after a very small number of ticks.  They converge to sequences of 2’s with a single 1 interspersed amongst them.  I have seen this behavior for a variety of numbers of emitters, emitter sequence lengths, and tick intervals.  It would be very interesting to learn whether this is bound to happen in general.

I have written a short program that produces a numeric rendering of sequences that I will publish shortly.

This is a draft of the description I am sending to the Racer Sessions of the piece I am presenting in 2 weeks, on October 3rd.

—-

The name of the work I am presenting this week is Nondeterminate.
Nondeterminate is a piece of music that I wrote in a computer programming
language, and that is interpreted and played by a computer, uniquely, every
time the program is run. The key idea of this work is that it explores the
idea of “nondeterminism” in complex systems —- and in this case, the complex
system is a computer. I’m going to do my best to explain a few things about
this piece here: (1)What is nondeterminism? (2)Why are computers
nondeterministic? (3)How can a computer program be “interpreted” by a
computer “uniquely”? (4)What you should listen for when you hear
Nondeterminate. I may not go in that order, but I’ll cover each of those
points. Along the way, I’ll mention some related music you might want to check
out, and at the end, I’ll talk about other ideas I have related to this idea of nondeterminism.

So the most important thing to sort out is what I mean when I say
“nondeterminism”. We all have some definition of this in our heads, I’m
sure. In this context, I consider an event nondeterministic if it is hard to
predict, but not random. A good example of something nondeterministic in the
real world is the location of a traffic jam — it isn’t random, because it is
the result of some idiot or an accident or something, but it is very hard to
predict in advance where a traffic jam will take place.

The flow of particles in a body of fluid is another example — it isn’t random,
but we can’t figure out how to model it (it is a 1000 year old open problem in
mathematics to model fluid flow without randomness). The idea that randomness
closely models nondeterminism allows us to approximately think about the idea,
but is somewhat deceptive. Very few things are truly random, and it is
important to keep in mind that nondeterministic events have a clear causal
chain, but that it is very difficult to understand or predict. In fact this is
one of the key ideas of the piece today: In Nondeterminate I quite deliberately
did not use randomness.

The absence of randomness is essential, in my opinion, because the idea of
chance in music has been explored deeply by many people. One example that is
particularly relevant to this discussion is ‘Pithoprakta’ by Iannis Xenakis.
This piece is a musical encoding, for a small orchestra, of a mathematical
model of the flow of particles in a fluid. This model is approximate, and
relies on randomness to simulate nondeterminism — we have all probably heard
of ‘brownian motion’; that is the model that Xenakis turned into music.

I found out about this piece of music after I performed an experiment with a
fluid dynamics simulation of my own. I have a program that models the
interaction of particles in a fluid that some physicist somewhere wrote. Using
the same technique I used to make Nondeterminate a piece of music (which I will
explain in just second), I made this simulation a piece of music. The result
was random noise. The reason is that the simulation uses randomness.

The above three paragraphs answer point (1). Nondeterministic events are
non-random, but difficult to predict, and always have a causal chain. So why
are computers a good example of this?

Today’s computers are designed to do many things at the same time. The idea of
doing things at the same time is called “concurrency”. A computer program
is, at its heart, just a list of things for the computer to do. Add 1 + 2,
read a value from the computer’s memory, etc. Capturing the idea of
concurrency, programmers can create programs made up of individual “threads”
of execution. Each thread is, in effect, it’s own program. The threads all
run through their lists of things to do concurrently. Threads can run, and
ignore the activities of the other threads, but more often, threads must
communicate with one another.

The threads are operating independently in a concurrent program. That means if
I am thread #1, and you are thread #2, I don’t necessarily know what you’re
doing, and you don’t know what I am doing. Occasionally, however, I need some piece
of information that you recently computed, and so I communicate with you to get
it, and then I can continue doing my list of things. However, threads may also power
through their lists of things at different rates, and the rate at which a
single thread makes progress relative to the others is very difficult to predict (in fact, this is an open problem in computer science). Furthermore, from one execution to the
next, a thread’s rate of execution may vary from prior and future executions
due to environmental factors (the temperature of the air can even have an
impact on this). The result is that the order in which the communications that
take place between threads is difficult to predict, but is not random — it is
nondeterministic. This nondeterminism is the nondeterminism I tried to
explore in this work.

I am now through points (1) and (2). The next thing to explain is how a
computer can transform a non-deterministic pattern of inter-thread
communication events into a piece of music. I am going to spare you some
details here, because this is probably the least interesting part. I wrote
another program that takes any arbitrary program as its input. This program is
called Audiolyzer (I released it on the web at
http://github.com/blucia0a/Audiolyzer). The way Audiolyzer works is by
analyzing the code that makes up each thread in the program that was its input.
During that analysis, it finds communication events, and marks them with a
special marker. This marker generates a tone when the program runs. Each
thread has its own unique tone, and so when you run a program using Audiolyzer,
you can hear the interleaving of the communication events in the program’s
threads. The interleaving is non-deterministic from run to run, and so the
pattern of sounds you hear each time you run the program is unique. The
computer is interpreting the program and generating a new piece of music with
each execution.

So the above explained what the premise of this work was.  Now I’m going to discuss some things you should listen for when you listen to Nondeterminate.  When you are first listening, you will hear what initially sounds like random bleeps and bloops all mixed together. It isn’t the case! Listen carefully and patterns will emerge.

The reason for the patterns is that there is one additional constraint on the
interleaving of communication events. That constraint is that every thread
eventually needs to get a turn. The computer is being fair. For example, if
there are 16 threads (like there are in movement #1), you may hear the tone
that corresponds to thread #1 first. After that, you will not hear thread #1’s
tone again, until you’ve heard all the other threads’ tones. This ensures that
every thread gets to do its communcation without being “starved”. The
patterns in this case will be length 16 sequences of tones.

It isn’t a hard and fast rule, however, which is another interesting feature of
the piece — you will hear the sequences mutate as the piece unfolds. The
computer tries to be fair, but it can only react within the bounds of its
environment. Two threads may have their communication order inverted, just
because of environmental factors that change the rate of their execution
(again: air temperature, other programs, etc). Fairness plus mutation leads to
something that sounds like procedurally generated minimalist music.

An example you may have heard is by Steve Reich, called “Tokyo/Vermont
Counterpoint”. It begins with a simple pattern, which then mutates over the
course of the piece. The main difference between Nondeterminate and this work
is that Nondeterminate generates a *different* base pattern with each execution
(in fact, many times during each movement), whereas Reich’s piece is statically
defined by its base pattern.

The piece is organized in four movements. Each is intended to explore a different aspect of nondeterminism.

The movements are structured in the following way: Movement 1 sets the stage,
using 16 threads to introduce the concept of nondeterminism, and (hopefully)
revealing the pattern concept that is explored in later movements. Movement 2
divides the threads into two groups of 16 — 16 are low, and 16 are high.
Within a group, there are nondeterministic interleavings, but the groups
interleave, deterministically alternating. The third movement is an attempt,
within the confines of programming as a compositional medium, to *eliminate*
nondeterminism. This movement is a parody of the other three, creating 8
groups of 4 that typically proceed in sequence, and the tones of which
interleave in a much more predictable way. Movement 4 is the culmination of
the piece. It creates 64 threads, spanning the spectrum from A3 to C8. The
patterns are 64 tones long, and therefore take some time to discern. However,
by the end of the piece, it is clear what the order is, and the mingling of
nondeterminism, and mutations is illustrated.

I chose to keep this piece simple. I did not vary the rhythmic pattern of the
piece. I did not use a particularly interesting voice (it is a simple sine
wave). There are two reasons, one more convincing than the other: The less
convincing is that I wanted the concept of nondeterminism to be the highlight
of the piece (I think that comes across as the piece is), and the more
convincing is that writing music this way is difficult, and I was hard pressed
to make something that sounded this coherent by way of programming.

Finally, I’d like to note that the idea of nondeterminism is not begun, and
ended with computer systems. Other sources of nondeterminism exist, and may
have similarly interesting patterns to those found in computer systems. I
think it would be interesting, for example, to create a piece of music that was
a continuous tone, the pitch of which corresponded to the density of traffic on
a stretch of highway over a period of days. Because of the fact that people
go to work in the morning and come home in the evening, patterns would emerge,
but to a degree, because people are flaky and whimsical, it is likely that the
tone would vary a great deal in smaller, nondeterministic ways as well.

I hope you all enjoy the piece, and if you’re saavy with computers, you can
download the source code to Audiolyzer, as well as the source code to
Nondeterminate from http://github.com/blucia0a/Audiolyzer.


Recommended Listening:

Iannis Xenakis - Pithoprakta (explores randomness in complex systems as music)
Krzystof Penderecki - De Natura Sonoris (explores composing for wide ranges of
tones)
Steve Reich - Tokyo/Vermont Counterpoint (explores patterns and mutations)
Terry Riley - In C (patterns again, and minor variations over long duration)

It is as if the guy who runs the record store was reading my blog when he sent out his newsletter today.  The New Arrivals list included Iannis Xenakis’ Pithoprakta.  This piece, described in more detail here.

The key part of the write up:

Xenakis tried to emulate the behaviour of an ideal gas through the musical equivalent of the kinetic gas theory, assigning to each molecular speed of a gas a pizzicato glissando event, with the slope of the glissando proportional to the corresponding particle’s speed. Arguing that, according to the law of large numbers, the differences in speed (each glissando) as the number of particles (in this case each instrument of the orchestra) increases tend to disappear in average and the macroscopic effect is one of a constant, ie. the gas temperature, which is proportional to the average speed of all the particles that are part of it

This is, to some degree the basis of my most recent composition.  The key difference (and it is a substantial one) is that my piece is concerned with a computer simulation of a fluid, and Xenakis was mapping sound to a mathematical description of a fluid.  I like that he is capturing the randomness of fluid dynamics in a musical composition, though he certainly isn’t the first — John Cage is another who used lots of randomness, and mappings from natural processes to music during his career. 

Now, I don’t know much about Xenakis, and I hadn’t heard of this piece until today.  I did some reading, and it turns out that he was an engineer, by degree, who felt his talents were better applied to the criticism and production of music.  That means he was a nerd too!

In my previous post, I described a composition that I made based on a computer simulation of stochastic fluid dynamics.  I like the idea of putting patterns in particle interaction (or patterns in data-structure manipulation, depending on your perspective) to work as musical tools.  By transliterating from the language of particles/data-structures to the language of sound, a piece of music emerges.

I am curating The Racer Sessions on October 3rd.  I plan to use an updated version of the fluid dynamics piece as the composition I present.  With it, however, I plan to make another composition, if I have time during the next two months.   I will compose by writing a program.  I know how the program’s operations are translated to sounds, so I can use the programming language as a compositional medium.  Then, rather than using patterns the chance interactions of a randomized simulation to make sound, I can use explicitly and intentionally constructed patterns to generate a more coherent and intentional piece of music. 

The aspect of this style of composition that will be particularly challenging is that programs of the sort I plan to write are inherently non-deterministic [a paper I co-authored on this subject].  The root of the non-determinism is that there are many concurrently acting ”threads”.  Each thread can do as much or as little as it wants before the next is allowed to do what it wants.  Conceptually, each thread has a list of program actions to perform (each of which may or may not generate a sound).  The computer system adds the threads to a queue, much like they’re standing in line at the grocery store.  Each gets to the front of the line and does whatever it has to do (the program actions I specify) for as long as it likes.  When the front thread finishes, or its program actions indicate it should wait or yield, or the system decides the front thread has had enough, the next in line gets to go, and the front thread goes to the back of the line.  Now, because of computer systems issues too subtle to be interesting in this context (resource contention, variable memory access latency, hardware error correction, memory consistency, etc) there is also a phenomenon something like ”cutting in line”.  That means that the order of the queue can’t even be relied on in a program (composition).  The upshot of the non-determinism is that each thread’s actions can, to a degree be proscribed in a composition program, but ultimately, the sequence in which each thread, and all threads’ actions are performed is up to the system.  Viewed as a black box, it is as thought the composition undergoes a randomizing transformation as it is executed.

I am interested to investigate what and how much the effects of the randomizing transformation will be.  My hope is to have a few test compositions up here before October 3rd.

This is a composition that I created about 6 months ago, and is derived from my primary occupation as a computer scientist.

As part of my work, I was playing with a scientific computing benchmark that performs a simulation of fluid dynamics.  The simulation is a big complicated multi-threaded program, which means there are lots of things all happening at the same time.  The program’s function is to take a big mathematical representation of a body of some fluid, and to simulate the way the particles in that fluid interact.  As it turns out, particle fluid interactions are pretty much random, and so this program models that randomness (or ‘stochasticity’, as fluid dynamics people call it).

Now, in terms of the program, you can think of it as having several ‘threads’, each of which deals with a piece of the total simulation, and which perform computations more or less at the same time as the other threads.  There are points at which these threads need to exchange information between one another.  These communications represent the interactions of particles in the body of fluid.  I thought it would be interesting to ‘listen’ to these interactions.

To do so, I wrote a program that takes any arbitrary multi-threaded program (written in C/C++), and finds points in that program where the threads communicate (‘synchronization points’).  Then, it runs the program you give it (for instance, the fluid dynamics simulation), and generates a sequence of tones corresponding to these communication points.  Each thread of execution is assigned its own tone.  Each time a thread performs a communication, it briefly generates its tone, and then continues its execution as normal.  Using the fluid dynamics program as an example:  communication between simulation threads occurs when particles interact.  This leads to the generation of tones.  So putting this together, we can listen to what the fluid system sounds like, as its particles interact stochastically.

This link: http://drop.io/0dn3xpf leads to a recording of the fluid dynamics simulation from a portion of the program’s execution (the full execution would take weeks to listen to).  I assigned the threads in the program the tones from the C major scale. 

When I have the time, I plan to release the software tool that I used to create the recording.  It is slightly complicated to use, but it (probably) works on windows or linux or mac, and can generate music like this for any program.  For programmers out there, the code can be changed to assign different pitches and durations to the different threads, as well.

Up to this point, the focus of this blog has been on obtaining other music that I didn’t know anything about, and writing something about it.  This was an attempt at two things: 1)Get better at writing about things (and actually having a point, which it is possible I still do not) and 2)Learn about the music by listening to it carefully enough to say something to attempt to make a point.

Today, I am going to move the focus of my writing to something that has been on my musical mind lately.  Specifically, I am going to write about a method of composition that I have been thinking about.  I don’t know if this method is a new method (I doubt it is), but I think of it as “Static Improvisation”, and in the ensuing text, I am going to try to explain what I mean by that. 

The high level idea is that a composition composed of “static improvisations” is like a framework that abstracts the details of many pieces of music with one representation.  It is up to the performers to disambiguate between these abstractly “aliased” instances of the piece, and to select one, in advance of a performance, to perform.   Another way of saying this is that the composition describes a set of parameters and constraints, and before performing the musicians, (in contrast with the composer), set the parameters in a way that satisfies the constraints, and then perform the resulting instance of the piece.

The concept of improvisation in general has been broadly explored, and needs no explanation.  The style of composition I am discussing here, however, is probably most similar to the compositional techniques of the minimalists of the late 20th century.  An example of a composition that is similar in nature, but, as I will explain, different is the well-known “In C” by Terry Riley.  In this work, performers are restricted to playing in the key of C (not surprisingly), meaning they must limit themselves to the white keys on a piano.  In addition, the composer has written several one- and two- bar phrases that the performers will play.  It is then only loosely proscribed in the actual text of the piece where each phrase is played — it is up to the performers to select from the set and to play them.  Steve Reich explored a similar structure on his recording entitled “Drumming”, in which the entire composition is based entirely on a one-bar rhythm phrase that is applied in a variety of contexts by varying the instrument, de-aligning the phrase in phase on one part from the rest of the group, and by the omission of some notes occasionally.  Static Improvisation is similar in spirit to the these compositions in that both call for the musicians to adhere to a structure, and then at the time of the performance, rather than just sequentially transforming a set list of notes in to sounds, they must make judgements about what to play, and where to play it (in the case of “In C” for instance), but not with complete freedom, as with general improvisation.

Static Improvisation further explores this area by not actually proscribing the phrase or rhythm or notes that are to be played, but by only imposing compositional constraints on what those phrases or rhythms must be.  For example, one such constraint could be that each phrase be no more than 2 bars (if the piece is in time), and that from a given note, the next note must always be the sharp of that note’s fifth.  Another might be that the performer is to compile a set of rhythmic phrases, and those phrases are the only ones that they are to play during the performance.   Then, in advance of a performance, a performer incorporates these constraints and produces a piece of music for their part that satisfies them all.  The performance then unfolds as the performer manipulates the fixed patterns that they created in advance in an improvisational way to create an instance of the piece.

The distinction between these constraints, and the constraints I’ve described concerning Riley and Reich above is that in the case of Static Improvisation, the performer must actually participate in the composition process, much in the same way an improvisational musician would do.  They actually have to work within the same compositional frame that the composer intended (as an improviser often must), and at the same time create units that will compile to make the whole of an instance of the composition.  In contrast with classical improvisation, however, the performer is not free to make arbitrary decisions during the performance of the piece.  That is, the decisions made beforehand are fixed — a decision made during performer-composition is a constant for the duration of the performance.  That means, if a constraint is that a performer must only ever play from a set of phrases they produce at the outset of the piece, then those phrases are set, and the performer may choose at anytime to play any, but cannot play any other.

The language that I am using to describe this style of composition is largely borrowed from the world of computer science, and I will clarify what these things mean for the interested and informed.  My use of the word “Static” in the description derives from the same as “static” in “static analysis” of computer programs.  This is analysis that is done on the source code before the code is compiled and run — statically.  This is a contrast to dynamic analysis, which in the improvisation idiom is analogous to dynamic improvisation, or what is commonly called just improvisation.  The concept of abstracting many “instances” of a piece of music in one composition is also very analogous to a computer program.  A computer program is an abstract representation of a runtime behavior that is dependent on the input parameters and environmental constraints.  A program is a composition, and a program’s execution is it’s “performance”.  In much the same way, a static improvisation composition is like a program, in that it takes an input (performers’ decisions) and defines a set of constraints, and when then performed produces an output (a de-abstracted “instance” or “execution” of the composition).

I am currently in the process of composing and refining a piece of music for several instruments, and I hope to be able to play it with a group sometime soon.  I’m sure the process of composing and performing will be enlightening for me in the process of expanding this method as a vehicle for composition, and I will continue to write as ideas in this vein progress.

I was searching for Sonny Sharrock tabs, and while I couldn’t really find any, I did find this interview with him on the subject of soloing.  It’s a little melodramatic, but not without content.

Eddie Gale is probably best known for playing the trumpet with the Sun Ra Arkestra.  He appears not to have had a particularly prolific solo career (based on my cursory search of the web), but Ghetto Music really stands out, not just amongst his other work, but in general.

As a drummer, I consider one of the best features of this album to be Richard Hacket and Thomas Holman’s drumming.  These two do an incredible job of framing each song on this album with a hard groove, and with great twitchy improvisational work at the same time.  About two minutes into the second track “Fulton Street” (Fulton Street, baaaby) Gale takes a solo, and I think that more notable than the solo itself is the work of the rhythm section.  These two drummers cooperate with one another, and with the bassists (Judah Samual and James Reid) to create a dense, complex, yet consumable typhoon of sound.  Something I especially like is that at any given point, at least one of the drummers is feverishly hammering out time on a ride cymbal, and over this is a flurry of snare/tom fills that vary between post-bop polyrhythms and stiff drum corps riffs.

The doubling of the bass and drum parts is an interesting move, but it is in kind with the spirit of this album — 17 musicians perform on this record, 11 of whom are “The Noble Gale Singers”, ostensibly led by Joann Gale.   The sound of this record is emotionally and acoustically dense.  It is likely in part due to the fact that it is the sum of 17 musicians.

This album wrangles its listener in with The Rain.  The track begins with a syrupy guitar riff, and the sweet voice of Joann Gale.  The rhythms section announces the song’s actual beginning about a minute later, with a solid groove in 6 beats, underscored by a somewhat simple ostinato part on the bass.  A vocal/guitar solo punctuates the song, about mid-way through, and sets up a second groove section, during which the choir fills out the lyrics, and Gale (Eddie, this time) goes into a solo that is a really nice contrast to the spastic rhythm parts.  He plays a much more legato style than the rest of the band, and in counterpoint to the vocal part (it really feels like a non-sequitur from the vocal part, but in a good way).

Fulton Street really unleashes the rhythm section in force.  The song is also structured in kind of an interesting way.  There are short ‘verse’ sections, and then some abrupt percussion call and response bits.  The horns come in, after this, and then everyone cuts in unison.  This sequence is repeated several times, and in my view, this gives the song a social spirit, in a way that A/B/A/B + maniacal soloing generally doesn’t.  By virtue of the requirement for group coordination in sections like this, the music seems to better embody the feeling of the group.

A Understanding (An Understanding? Track listing is “A Understanding”) is the ‘ballad’ of the album, if it can be called that.  It is mysterious, and captivating, and includes some really beautiful parts for the tenor sax, as well as some moral support from the fidgety rhythm section.  The song’s soothing sound tapers into an ending that serves as a hard segue into A Walk With Thee.

A Walk With Thee is a march, that starts with a cool chanting part in a minor key.  The bass and percussion stick to ostinato, and, again, something between hard bop and a marching band.  This track emphatically features the horns, and they run the show for the most part, with the percussion boiling up to meet them from time to time.

Unfortunately, I haven’t spent enough time with The Coming of Gwilu to have any real good take on what it is all about, and at 13+ minutes, it would likely be an undertaking to really consume it in a meaningful way in short order.  As a result, I’m going to abstain writing anything more about it, than the following: First, the vocal part sounds great — slightly meloncholy, and possibly in another language (some african language perhaps?  Scat?)  Second, the steel drum, tin whistle, pots, pans, washboard, etc came out for this track, and that makes the rhythm part seem a little more playful than on the other tracks, where the percussion is dense and imposing.

It has been a while, while I was away in New York, but I was eager to get back into the swing of things, so the first weekend I was back, I went to the record store and got some new stuff.  Along with a sort of mediocre-in-hindsight record by The Fourth Way, I picked up Ornette Coleman’s record Science Fiction.

In 1971, Coleman made this record, more than 10 years after Free Jazz, and more than 5 years after Coletrane’s Ascension record.  I mention these two records here because they give context to Science Fiction, and are no doubt strong conceptual contributors.  Science Fiction is a great free jazz record - Coleman’s wailing sax, Ed Blackwell and Billy Higgins’ fevered (and cooperative) drumming, and some really touching bass parts played by Charlie Haden.  A variety of trumpet players play on the record, varying by track.  With this cast of characters, some of whom had played with Coleman for upwards of 15 years at this point, S.F. is a well-executed, mostly improvised jazz recording.  There are a couple of things which really set it apart, however, making it not just a good example of a genre that, by 1971 was beginning to be well-explored.

First of all, the opening track on side one “What Reason Could I Give” is a good example of how atonal and rhythmically composition and improvisation can be beautiful music.  The sound is textural, with little coherent movement by the players, but this gives rise to subtle, spontaneous harmony.  In addition, when coherence does emerge, it is surprising and in juxtaposition to the prevailing disorder makes your listening brain really light up.

All of these things are great, but what makes this track really great is the experimental jump made by Coleman in bringing in a syrupy female vocalist to sing over everything.  Asha Puthli, on what, according to Wikipedia, is her first recording repeatedly questions listeners: “what reason could I give?” By contributing her voice, she rounds out the song’s seven part ensemble.  Less frequently than saxophone or trumpet does a female vocal part ‘run the show’ on a free jazz album, but this track shows that not only does it work, but it really sounds great.

Side one moves on to its second track Civilization Day.  Which, while technically sound, and very dense, turns out to be a lack-luster romp, living as a scaffold for improvisation which lacks the magic of that on the first track.

After this, the first side finishes strong, though.  Street Woman is a Coleman classic.  The recognizable opening riff leads into solos in his characteristic crying timbre, held up by some intricately woven bass/drum duos.  Some way into the track, everyone lays out, and gives Haden a chance to shine on bass.  His solo here plays with the established melody (the opening riff) in an interesting way.  With a lot of flourish, and colorful alterations, he manipulates the riff, varying it in tempo and time, and by inverting and interleaving it spontaneously.  This leaves the flavor of the song intact, but leaves room for Haden to really show what he can do on bass.  At the same time, the solo isn’t just a demonstration of his skill as a bassist, which sometimes leaves technically complex solos feeling robotic.  Instead, the song remains emotionally charged, and carries its intensity to the song’s end.

The final track on side one is the album’s title track.  It is especially free; of melodic and rhythmic structure.  It is a wave of sound, with a dissonant, confused texture to it, which sometimes emerges in free jazz work.  The dissonance lends itself as an eerie backdrop to the recital of a poem written and performed by David Henderson.  The poem’s content is fairly nebulous, addressing human existence, and religion, to name a few of its themes.  In my view, the poem’s content is unimportant.  As with the experimental (and successful) use of a female vocalist on the first track, this track goes further if the poem’s recital is considered more like an instrument.  Henderson’s unusual cadence and his monotone, but enunciative speech contribute to the overall spooky feel of this track.

That is the dirt on side one.  I haven’t yet spent enough time listening to side two to say anything about it, so I’ll leave that for the future.  Haden’s bass, Puthli’s sweet voice, and Coleman’s evokative whine, will likely keep Science Fiction near the top of my stack for a while.

Well, I am suddenly, and officially a big fan of Charles Mingus.  Up until tonight, I didn’t really know a lot about his music.  I have had a bootlegged digital version of an album of him playing the piano, and a vinyl version of an album of his entitled Three Worlds of Drums.  Then, a couple weeks ago I picked up Let My Children Hear Music on vinyl.

I was very impressed by Let My Children Hear Music.  I wanted more, but I just hadn’t gotten around to getting it, nor had I chanced across it.  Then, earlier tonight, I picked up some new records, and after I got back, I went on a minor downloading spree.  Amongst all this new music ended up being The Black Saint and the Sinner Lady.  To say I was very impressed by this album, like I was Let My Children Hear Music, is an understatement.

I am trying to pinpoint exactly what it is about these two albums that I like so much.  The first thing is that they have a dense “vertical” component.  What I mean by this is that there is a great deal of layering of the parts played on them each.   It seems like a common theme for these pieces to begin with a fanfare of bawdy horns, and to lead into a swinging melody which sets up the remainder.  It all seems really carefully planned, but at the same time, surprisingly natural — it doesn’t have any rigidity to it, in spite of the fact that it has clearly been meticulously constructed in advance (for the most part at least).

At several points (especially on Black Saint), something unexpected emerges from the established sound.  On the first and last track of Black Saint, it is a non-sequitur Spanish guitar part.   On Let My Children Hear Music, there is an heavily orchestrally accompanied reading of a poem (read by Mingus himself).  These bizarre elements complement the core of solid composition, blaring horns, and thunderous, symphonic percussion (in contrast to, say, rock percussion, or jazz percussion, a la Billy Cobham).  The change in tone doesn’t upset the precise feel of it all;  It has been carefully worked in such as to be different overtly, but not to drastically vary stylistically.  Mingus somehow makes spoken word poetry seem compositionally natural.  That takes some skill.

I think that, by far, the most impressive feature of both albums is the fact that they are so intricately composed.  No track on either of these albums feels like an excuse for some jazz musicians to go ahead and improvise.  This is a stark contrast to some other jazz which is actually quite good, but less (or at least less *obviously*) composed.  Specifically, the work of Ornette Coleman and Eric Dolphy come to mind when I think of the contrast to Mingus’ compositional style.  Coleman and Dolphy set the tone and build the theme of the piece, but the bulk of the presentation is devoted to their chops, or to the collective chops of the group.  Mingus’ work, on the other hand is more devoted to the structure and specific layering of sounds and melodies, to produce songs that sound almost cinematic.  It is as though each of these records is the soundtrack to a movie which doesn’t exist, or the score to a wild, suggestive 1930’s cabaret performance.  It is really captivating to listen to.

I plan to devote more time to listening to Charles Mingus, and perhaps I will have something more insightful to say about his work in the future, but I couldn’t contain myself tonight when I was listening to this new album, I had to say something about it.