MUSYS(ID:8015/)

Systems language for the EMS studio 

Interconnection language for the EMS studio, developed by Peter Grogono. It eveolve into MOUSE outside the music studio

People:
Related languages
MUSYS => Mouse   Evolution of
References:
  • Grogono, Peter "MUSYS: Software for an Electronic Music Studio" Software - Practice and Experience, vol. 3, pages 369-383, 1973. view details
    Resources
    • Page for MUSYS at Concordia
      The composition component of MUSYS was written for Leo. The problem was to write a program that could translate a "score", written in a format to be determined, into a data stream suitable for Sofka. The memory constraints were quite severe. There was a FORTRAN compiler but after discovering that a 15 line program filled the memory, I decided not to use it. The alternative was assembly language.

      The MUSYS compiler was based on two ideas. The first, macro expansion, was inspired by Christopher Strachey's Macrogenerator, written in 1965 to bootstrap CPL onto the Titan (successor of Atlas) computer at Cambridge University.

      A MUSYS user would typically start by defining some macros. Here is a typical macro that corresponds to a single note of music:

            NOTE O1.%A. A1.%B. E1.%B/2+7. T1.%C-1. E1.%B/2+2<7. T1.1 T=T+%C @  

      The two letter codes identify devices. For example: O1 is oscillator 1, A1 is amplifier 1, and E1 is envelope shaper 1. The definition of NOTE assumes that oscillator 1 has been patched through amplifier 1 and envelope shaper 1. (It was possible to alter the patch dynamically using electronic switches, but not many composers used this facility.) There are also pseudo-devices: T1, for example, indicates a delay.

      A composition consisting of a single note might look like this:

            #NOTE 56, 12, 15;  
            $

      This note has pitch 56 (chosen from an eight-octave chromatic scale with notes numbered from 0 to 63), loudness 12 (on a logarithmic scale from 0 to 15), and duration 15/100 = 0.15 seconds. The loudness value also determines the envelope of the note.

      The following program is more elaborate. It plays fifty random tone rows:

            50 (N = 0 X = 0
            1  M=12^  K=1  M-1 [ M (K = K*2) ]  
               X & K[G1]
               X = X+K  N = N+1  #NOTE M, 15^, 10^>3;
               12 - N[G1]
            $

      Compositions consisting of random notes are generally not very interesting, although very occasionally you get lucky. Usually, the composer had to write a list of the notes to be played in a separate file that was read by the MUSYS compiler.

      The MUSYS compiler (interpreter might be a better word, but we always called it a compiler) read the program file and data file and compiled a list of device/data pairs. Most pairs consisted of two 6-bit bytes, but a few devices required more data than 6 bits. The single note composition above, for example, would generate (codes such as "O1" would actually be 6-bit numbers):

            O1 56 A1 12 E1 13 T1 14 E1 7 T1 1  

      When the list of pairs has been generated and stored on disk, the composition could be "performed". Performance consisted of Leo sending the data in the list to Sofka. In fact, since Sofka kept control of the time, she asked Leo for data when she needed it.

      The compiler could generate up to six interleaved streams of data called, for some obscure reason, "buses". This feature simplified programming considerably. Apart from the obvious application - providing six independent voices - there were many other applications. For example, you could put the notes, without dynamics, on one bus and the dynamics on a second bus, to provide smoother phrasing than is possible if a particular dynamic is associated with each note.

      external link