Java Music Specification Language (JMSL) is a Java-based development tool for experiments in algorithmic composition, live performance, and intelligent instrument design.  JMSL is the evolutionary successor to Hierarchical Music Specification Language (HMSL).  While HMSL was FORTH-based and ran on Amiga and Mac computers, JMSL is written in Java and runs on any computer with a Java Virtual Machine.

Java is a language that has much to offer computer music composers including good object oriented support, extensive auxilliary APIs for networking, graphics etc., and the ability to run on multiple platforms including web browsers. JMSL extends Java with classes for hierarchical scheduling of composition objects, sequence generators, distribution functions, music notation, and other music related tools. This offers rich new territory for composers to explore.

JMSL's strengths include:

• Its Java core.  As opposed to a closed system with a proprietary language, JMSL allows the programmer to leverage off the vast resources available to Java developers, including Java's database connectivity, networking tools, 2D and 3D graphics packages, servlet API, and numerous third party packages.
• Polymorphic hierarchical scheduling.  Create complex hierachies of diverse music objects that share common notions of time.
• Device abstraction.  JMSL supports Softsynth's JSyn, Grame’s MidiShare, Robert Marsanyi's JavaMIDI, and Sun's JavaSound MIDI at a level that hides their implementation.
• Stylistically neutral core
• Includes JScore: an algorithmically extensible common music notation editor with an algorithmic transformation plugin API. Transcribes algorithmically composed music. Can play self-modifying scores.
• The composer can create stand-alone JMSL applications or deploy JMSL applets on the web.
• JMSL is freely downloadable in an evaluation version

SOME KEY IDEAS AND FEATURES

JMSL is based on HMSL, or Hierarchical Music Specification Language. The notion of hierarchies is a key one in JMSL.  A hierarchy is simply a collection of parent/child relationships. A song form provides a simple example, where a parent called mySong might have four children: verse1, chorus, verse2, chorus. In JMSL, mySong would probably be a SequentialCollection.

JMSL can schedule arbitrary events over time (not just musical ones).  MusicJob is JMSL's root class, with which the programmer can schedule actions. MusicJob implements JMSL's "Composable" interface: any class that is "Composable" can be scheduled in a compositional hierarchy (hence the name). JMSL hierarchies are made up of Composables.

MusicJobs (or any other Composables) can be grouped together in Collections. Collections can launch their children all at once (ParallelCollection), in a strict ordered sequence (SequentialCollection), in an order determined during the piece (SequentialCollection with a Behavior), or in a dynamic queue (QueueCollection). Being Composables themselves, Collections can be put inside other Collections.

An ordered table of abstract numerical data is called a MusicShape. A MusicShape is a multi-dimensional array which holds double precision floating point numbers. Melodies could be stored in a MusicShape, for example, where dimension 0 might stand for duration, dimension 1 might be pitch, and dimension 2 might be loudness. Collections of more conceptual values can be stored in a MusicShape as well, like parameters that feed a complex musical algorithm. It is the job of JMSL's Instruments and Interpreters, however, to deliver the promise of this interpretation (see below).  JMSL’s MusicShapeEditor allows for mouse-based editing in realtime.

JMSL's Instruments are essential classes for interpreting data in a way that is useful to the composer (ie hearing it as music in some way). Instruments deliver stock or custom interpretations of data. A MusicShape might have a stock MidiInstrument, for example, that interprets data as duration, pitch, velocity, and sustain time. Of course, the composer can build custom Instruments and Interpreters and sonify data as desired. Another Instrument may interpret its data as parameters to a JSyn software synthesizer, yet another may use its data to feed a stochastic process. JMSL includes a MidiInstrument class, and a variety of Instruments that play SynthNotes and Samples designed in JSyn (Java Synthesizer).

JMSL's JScore common music notation package is a standard staff-and-measure based notation editor. It has a API for importing algorithmically generated notes from within JMSL, as well as an API for transforming notes that are already notated.  JScore has a powerful and dynamically configurable Transcriber which can notate algorithmically generated music events scheduled arbitrarily over time. JScore also supports a simple event list text format which can be used to import music generated by other software systems (for example, JScore can read an input script by connecting to a URL of a CGI program written in Perl).  JScore exports its notation in a format readable by San Andreas Press’s SCORE Computer Music Typography System, for professional music publishing.  It also exports MusicXML, which can then be loaded into Finale (with its Dolet plugin), and other music applications that read MusicXML.  It also supports exporting to LilyPond format (LilyPond is a freely downloadable music publishing program, available at www.lilypond.org). JScore compositions can be deployed on the www using a prebuilt JMSL class (com.softsynth.jmsl.score.util.JMSLScoreApplet)  With its extensive support for JSyn instruments, JScore delivers the notated piece to the listener with sounds exactly as designed by the composer.

HISTORY

The original Forth-based HMSL was designed and programmed at the Mills College Center for Contemporary Music by Phil Burk, Larry Polansky, and David Rosenboom.

The key ideas in HMSL began to be ported to Java by Nick Didkovsky in 1997.

"In the late summer of 1997, I was reflecting on the uncertain future of the computer music pieces I've written over the years in the language HMSL, which runs on the Amiga computer. While my Amiga still faithfully runs my HMSL software, being committed to this platform had always been charged with extinction anxiety.

"About this same time, I became very interested in the programming language Java. Created and distributed freely by Sun Microsystems, Java promises to be a platform-independent language. That is, a program written in Java is supposed to run identically on a number of platforms for which Java "virtual machines" have been written: Linux, Windows 95, MacIntosh, SGI, Solaris, etc. The significance of this hit me very hard. Writing for a "virtual" computer that crosses platform boundaries is understandably attractive to a software designer who has seen his favorite "real" computer gradually squeezed out of the mainstream market.

"In September of 1997, I began porting HMSL to Java. As a kind of early test flight, I built my first Java/HMSL piece, a realtime statistical deconstruction of a Schubert Impromptu. Since the realization of this work, I have been collaborating with HMSL co-author Phil Burk on a complete rewrite in Java (as opposed to a mere port) . Dubbed JMSL, this new computer music environment offers tools to create arbitrarily complex multi-user musical environments, using the Internet as a network, as well as non-networked, stand-alone works like the Impromptu performed here. Under JMSL, which because of its Java roots is both platform-independent and Web-capable, the hardware distinctions separating computer musicians into technological camps will mean as little as the political and geographical boundaries separating them." (Artist's Statement, Circuits Conference, March 28, 1998)

After the premiere of the Schubert JMSL piece, Didkovsky sent his source code to HMSL designer/programmer Phil Burk, who suggested and implemented extensive redesign.  Together, Burk and Didkovsky both simplified and (re)volutionized JMSL, taking it well beyond a simple port of HMSL from Forth to Java.
 

JMSL Home