received from dave anderson on sept 11 1995 copyright 1089w

1) Overview of FORMULA

FORMULA is a programming system for personal computers (Atari ST and Macintosh) that control music synthesizers, typically via MIDI interfaces. FORMULA therefore does not specify waveform synthesis algorithms; its abstractions begin at the level of ``note'' and extend upwards.

FORMULA is based on the Forth language, adding to it many new functions and control structures. The intended applications of FORMULA include:

Programmed score interpretation:

FORMULA can be used as a language for representing static musical scores, similarly to DARMS or SCORE. In addition, it can express interpretive elements (e.g., tempo and volume fluctuation) often not present in scores.

Algorithmic composition:

FORMULA's constructs are executable; thus the features of the underlying programming language (e.g., control structures and parameterized procedures) are available at any point. This makes it possible to represent iteration, nesting, and randomness.

Interactive systems:

The output of a FORMULA program is played, normally with very accurate timing, while the program executes. FORMULA programs can respond rapidly to input, so they can define ``intelligent instruments'' that interact with a human performer through input devices such as MIDI instruments or computer keyboard and mouse.

FORMULA allows music to be generated by concurrent processes sharing a single address space; its runtime system manages the scheduling of these processes.

There are several process types:

Note-playing processes compute sequences of pitches and play these pitches as notes or chords. Each ``voice'' of a piece of music is typically represented by a separate note-playing process. Note-playing processes may be collected into groups.

Auxiliary processes are ``attached'' to note-playing processes or groups, and are used to supply note parameters such as volume, duration, articulation, etc. There are several subtypes of auxiliary processes: shapes are used to control volume and articulation, time deformations generate tempo fluctuations, and timing sequence generators produce rhythmic sequences.

Input-handling processes execute when input arrives from a particular device (keyboard, mouse, MIDI). In response to input, they may either generate output themselves, or create note-playing processes to do so.

This factorization into processes provides several advantages. First, concurrent musical voices can easily be expressed. Second, the structure (e.g., repetition) in each musical parameter can be exploited. For example, a repeating rhythm can be written as a loop even if the corresponding pitches do not repeat. Finally, it facilitates the specification of musical ``expression''. For example, the timing of a piece is typically divided into 1) the notated timing, specified by the timing sequence generator process; 2) the expressive fluctuations in tempo, specified by time deformation processes. These specifications are in separate sections of code, and can be modified independently. The tempo fluctuation itself can be factored into several time deformations, which are superimposed to produce the actual note timing.

2) The history of FORMULA

FORMULA is a joint effort of David Anderson and Ron Kuivila. Anderson and Kuivila were classmates at Wesleyan University, graduating in 1977. Anderson went to study Math and eventually Computer Science at Wisconsin - Madison, and Kuivila got an MFA at Mills College and returned to teach Music at Wesleyan.

In the summer of 1983 the two met again (more or less by accident) and discovered that they had the same hardware (Apple ][ and Mountain Music card) and software (Forth) and were interested in similar goals: multitasking and accurate timing. Anderson had recently been exposed to context-switching and deadline scheduling concepts in an Operating Systems class, and the idea of FORMULA was born.

In Fall 1983 Anderson developed the idea of separate processes to generate shapes and sequences to control volume and timing. The Apple ][ was inadequate (limited stack size) so in 1/84 Anderson and Bruce Holmer (now a CS professor at Northwestern) built a wire-wrapped single-board computer, using a Motorola 6809 processor, running the Flex OS and a Forth system. This was used to develop the first version of FORMULA, in which note-playing commands were sent by RS-232 to the Apple, which did event buffering. In 6/84 Anderson went to a Forth conference and gave a paper on FORMULA. He met Mitch Bradley, one of the leading figures in the Forth world. In the meantime, Kuivila got a 68K processor board for his Apple and heroically ported Fig Forth to it.

The trickiest and most profound mechanisms in FORMULA (process groups and time deformations) were hammered out in a series of bicoastal visits during 84 and 85. These meetings were characterized by long days, high levels of coffee consumption, and extremely intense discussions, occasionally verging on acrimony but always converging harmonically.

In 1/86 Anderson had bought an Atari ST, and FORMULA was ported to it. The Atari environment was Nirvana compared with earlier platforms: the machine was fast and had lots of memory, there was MIDI I/O, and most importantly it ran Forthmacs, Mitch Bradley's excellent Forth system.

Many features were added during 1986: time control structures and pitch sets (with help from George Homsy), hash-table event buffering, max/min delay scheduling parameters, and MIDI input handling. Later that year, Kuivila implemented a preemptive scheduler, while Anderson wrote the first Synthesizer manager.

In 1987 work meetings in Middletown and Amsterdam led to a "back to basics" movement, including the death of the extremely complex "context-sensitive word" mechanism, and an improved layering structure. This which was made fairly stable and released to the world (for Mac and Atari) as version 3.4 in 12/88. In 1988 Rob Vaterlaus developed a multi-window Mac version.

Since 1988, FORMULA has been used by a number of musicians, including Kuivila, Jim Horton, Ed Osborne, David Keberle, Henricus Holtmann, and George Homsy. It has been used to control propane-powered explosions, spark gaps, and robot actuators, in addition to MIDI. Papers about FORMULA appeared in the Computer Music Journal, the ICMC, ACM Trans. on Computer Systems, and IEEE Computer.

Most of the development on FORMULA since 1988 has been done by Kuivila to support his own work. Vaterlaus and Kuivila cleaned up and stabilized the Mac multi-window version, and this was released as version 4.0 in 1994. In 90/91 Anderson and Jeff Bilmes wrote a C++ system called MOOD that incorporated many ideas from FORMULA.

3) How to get FORMULA

As of 9/95, FORMULA is available by anonymous FTP from, in pub/dash/formula.tar.Z. The authors' addresses are:

David Anderson 1627 Blake St. Berkeley CA 94703

Ron Kuivila Music Dept., Wesleyan University Middletown CT 06457