Recently I’ve been lusting after a modular analog synthesizer. Seriously lusting.

For a long-time advocate and champion of music software, this may seem an odd obsession. But perhaps it’s not quite as odd as it seems.

We can think of music-making as a process, or as a conceptualization. If you’re writing notes on score paper, that’s a pure conceptualization. It’s all happening in your head, and you have to become conscious of it before applying pencil to paper. If you sit down at the piano and doodle, that’s a process. Your unconscious intuition can guide it pretty effortlessly, sometimes with wonderful results. (If you’re doodling a solo on “Take the ‘A’ Train” or “‘Round Midnight,” you’re processing someone else’s concept. But for purposes of the present discussion, that’s a side issue.)

As much as I love Csound — it’s free, it’s incredibly powerful, and I’ve even written a book about it — using it is entirely conceptual in nature. You conceive an idea, you write some code, then you run the code and listen to the results. If you don’t care for the results, you stop playback, write some more code, and then click the Run button again. The concept precedes the results: They don’t coincide in real time. Okay, you can write code for a few knobs and sliders and then twiddle them while the music plays, but (a) that requires more conceptualizing, to create the knobs and hook them up to whatever parameters you think you may want to twiddle, and (b) twiddling knobs with a mouse is not an entirely spontaneous or intuitive process. There’s an added layer of abstraction between you and the music, and you can only twist one knob at a time.

Pd is a step in the right direction, in that you can interact with it while it’s producing sound. Need an extra filter? Just create one and patch it into the signal path without interrupting the flow of the music. Plus, it’s free and incredibly powerful. But this morning I’ve been looking at Pd again, and remembering why I actually prefer Csound as a programming environment. Pd is extremely abstract. It has a large set of object types, and the objects can send complex messages to one another. Until you know the objects pretty well — both what objects you have available and what types of messages they send and receive — using Pd is anything but intuitive.

Here, for example, is a message that appears in an example in a Pd manual page: “1 1000, 0 0 1000, 1 1000 1000”. I had to work out the syntax of this myself through trial and error, because the manual page doesn’t explain it. That’s pretty typical for Pd programming.

Even after you become an expert, Pd objects can be nested several levels deep. You can’t just look at a patch and see what’s going on. You may have to drill down and drill down again. At each level, the structure is two-dimensional, with “wires” crisscrossing one another. Csound code is abstract, but at least it’s linear — top to bottom. Seeing what’s going on is generally pretty easy. Okay, there are second-level abstractions in Csound too, but when you inspect them, you’ll find that the code is linear, not all twisted into knots. And Csound just about doesn’t have an equivalent of Pd’s messaging system: The outputs of opcodes are almost always either audio data or control data, the latter being in the form of raw numbers.

Which brings us back to hardware modular synthesizers. The concept of messaging is entirely foreign to hardware systems. A cable can contain only one thing — electricity. Buchla systems make a clear distinction between control signals and audio signals, but other modulars don’t even do that.

Yes, a modular panel is two-dimensional, and a patch can get pretty tangled. But it’s only one layer. There are no hidden depths at all. Or almost none — I’m aware that in Doepfer systems you sometimes have the option of opening the case and adding or removing a jumper, which will change the behavior of the module. But that’s not something you’re going to do in real time, while the sound is being produced. At least, the danger of electrocution being what it is, we hope not.

A modular synth is entirely about process. All of the modules are running, all the time. True, you can start and stop the audio output using trigger signals and envelope generators, but the oscillators and filters are running even when you’re not hearing anything.

Each knob and switch in a modular does one well-defined thing. You don’t have to define it; in fact, you can’t. The knob will do the same thing tomorrow that it does today. This limits your options, but at the same time it facilitates the process of learning to play the instrument as an instrument. Pd and Csound are also musical instruments, in a broad sense, but they have so darn many options that your intuition is never, ever going to be able to take over and just play music. You’re always going to have to pause and think before you do anything. And after you’ve thought through what you’re going to do, even if it only takes half a second, you’ll be doing it with the mouse or trackpad.

Yes, you can buy a Quneo and send OSC messages from a cute, brightly colored control surface. But before you can start playing music on the Quneo, you’ll have to think deeply about what you want it to control and then write a bunch of code. Tomorrow, you may change the code, which will completely alter what the Quneo does. So it would be an exaggeration to say that a control surface allows us to play a software instrument in an entirely intuitive way.

Undeniably, there are downsides to a hardware modular instrument. You can’t store your patches, for one thing. (Buchla’s 200e series modules provide a limited, incomplete form of patch storage.) You only have a fixed set of modules — you can’t drag and drop extra oscillators when you need them, much less use exotic modules that you didn’t think of incorporating when you designed your system.

And modular analog instruments are expensive! A modest system will set you back around $3,000. (A modest Buchla system is more like $15,000.) If you want a powerhouse, even a Doepfer system, which has great bang for the buck, is going to cost $12,000 or more.

The difference between real analog and computer-generated digital sound is, I think, a non-issue. In the past ten years, computer synthesis has gotten so good that the analog advantage is trivial, if it’s perceptible at all. The word “analog,” as Don Buchla points out, really refers to the user interface — the manner in which the instrument is played — not to the technology that’s lurking behind the panel.

I’m not rushing off to order a huge Doepfer system today, but I haven’t stopped thinking about it!


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s