The art of computer programming - for it is a genuine creative art - is that of instructing a general purpose dynamic information-handling system how to do something specific for a special purpose. A computer program includes step by step descriptions of generative, decision-making, and response processes: what it does and how it interacts with you. It also includes defined representations, particular models and conceptualizations of the kinds of information the computer will process: in the case of music, assumptions about the nature of musical materials and processes.
A program is created in an "artificial language" - a language designed by people to be written by people but translatable into logic a computer can act on. Like all natural human languages, each computer language has its own conceptual biases, limitations, preconceptions, and unique possibilities. Computer languages, and the programs which people write in them, can be thought of as limited pre-defined windows into the potentially infinite possibilities the actual general purpose hardware computer allows. In effect, the specific programmer's individual choices of computer language, usage of that language, and specific program content, create, define, and delimit a unique window into the hardware's much broader capability. It is through such windows, called "application programs" that human end-users interact with the computer.
Once written, a computer program presents its user with, to all intents and purposes, a fixed unchangeable special purpose machine. In many cases this "machine" (the program) will have been crafted at an individual musician-programmer's personal discretion. In many other cases the marketing personnel of commercial companies will have made the decisions as to what hired programmers were told to make the program do, with a view to reaching a larger market rather than achieving a particular aesthetic result or creative capability. In either case, the program is fixed, a subjective creation drawn from infinite possibilities, one specific image painted firmly between the viewer and an underlying blank canvas.
In the early days of computer music, there were no pre-written music application programs such as now proliferate and are taken for granted. If you wanted to do music with a computer, you learned to program and you embarked on an exploratory journey, creating your own personal approaches and evolving them to fit your own musical needs. Music is a highly personal and mutable art form. In the 20th century the invention of new compositional processes and performance techniques, new ways of integrating orchestration with pitch-time composition, and the extension of the music's written notation to keep up with new needs figure prominently. The early days of computer music (and much of today's non-commercial software, where composer = programmer = user), generally focused on exploration and variety in such areas of musical innovation.
The standardization of MIDI (mid-1980s onward) involved a change of focus more toward the use of the computer as a labor-saving and a cost-cutting device for music production, and resulted in an unprecedented degree of standardization of creative technique and conceptualization of musical materials. In terms of software, this was characterized by the dominance of fixed application programs, entirely predefined, unchangeable by the user, and usually modeled on pre-existing musical techniques and models (conventional notation, multitrack tape recording, pre-defined orchestrations simulating traditional acoustic instruments, etc.). Music software began to be written by professional programmers, often having only minimal musical experience, for use by non-programming musicians. This was a major departure from the previous path of computer music, whose evolution had been driven during its earlier decades by the desires and visions of individual composers who learned to be their own programmers in order to explore untried musical methods, sounds, processes, and structures which had never been possible prior to computers. By the late 1980s, the programmer and the end user were no longer the same person, no longer motivated by the same aesthetic visions and needs.
Many of us who got into the field early and were accustomed to the freedom of creating personal windows of possibility from scratch, by programming (describing to the computer) whatever we wanted in general purpose computer languages running on general purpose computers, found that many things did indeed become much easier with standardized MIDI and its relatively standardized software application classes. But the ecstatic experience of staying up all night in a frenzy of discovery and exploration had become much more difficult to attain. Suddenly you had the benefit of many wonderful software tools written by others, but only if you limited your working methods to the ways they thought. You could no longer get any new kind of weirdo musical/sonic idea you felt like, tell the computer how to do it, and fly with it as far as you wanted.
Because accounting practices are fairly standard, it may be possible to standardize spreadsheet programs without compromising the user's quality of work. But in music, individuality is everything, and what each computer-using musician wants more than anything else in the world is to create completely unique and original personal statements: pieces, sounds, and working methods. The initial few years of MIDI-fied Macs were dominated by standardized application types (sequencers, notators, sound editors) and proved to be very frustrating to both computer music oldtimers (used to writing their own computer music programs) and to non-computer music oldtimers (used to pre-computer working methods, like the freedoms of pencil and paper). Though some of us oldtimers who had the programming chops to do so continued to write unique programs for our own use and sometimes made these publicly available, it has taken a long time for the commercial MIDI/music marketplace to recognize the basic need of musicians to be able to program (envision, create, define, and refine) their own working methods and concepts of music-space, versus just their musical works per se.
Fortunately, at this time, the newest latest generation of publicly available music software consists of an increasing variety of relatively open and flexible programming tools for musicians, rather than just pre-written programs, and this is extremely welcome. Each of these methods, these new "music languages" by which end-users can create unique personal programs for their own unique personal musics, do of course, have biases and limitations as do all languages. Each reveals different sets of possibilities or ways of working. But each is an open extensible personalizable system, a definable malleable creative workspace, a language of description, a way of representing, software that is finally soft enough for extensible creativity.
In the first generation of any new stage of a technology's evolution, much of what is first made available is modeled on previously established practices. For music this meant application programs for music printing, multitrack tape emulators, etc. In the same way, the first generation of relatively easy-to-use programming environments for the Mac are modeled on previously established Mac programming practices. Most of the increasing variety of music languages available for the Mac at this time are graphical rather than verbal, modeled on the Mac itself rather than on the thousand year accumulation of traditional vocabulary for music.
Beyond this, most of these user-programming programs appear to fall into essentially two groups. The first includes programming methods whose designs are based on, or built as extensions to pre-existing non-music-derived computer languages, including MIDI Basic, and the object-oriented (SmallTalk language, etc.) and "hypermedia" (originally from Ted Nelson's 1960s "HyperText" concept) programming models, both currently popular for reasons completely independent of and unrelated to recent musical practices. The second category includes those designs which are based on models useful in previous generations of electronic and computer music technology: Megalomania, Max, Hook-Up, and other such realtime-process-oriented patching - or connection - languages, which can trace their conceptual roots back to the early modular patchcord-programmable analog synthesizers (Don Buchla, Robert Moog) on one hand, and the digital "unit generator" concept of pioneer Max Mathews' series of synthesis languages on the other, these hardware and software models both having originated in the 1960s.
At this point we have just begun to see the programmability of widely available low cost computer music systems by the end user go from virtually nil (fixed application programs only) to programmability based on pre-existing extensible programming models. Hopefully, a new generation of software programming tools designed for the musician/programmer will evolve, based on the following three design criteria for future languages and programming environments:
Hopefully in the future, programs increasingly fulfilling these criteria will become available.