Conference napalm::commusic_v1

I'm not sure what input you're looking for, but a fellow named Jim Conger has
written a book on programming MIDI sequencers, as well as a book on MIDI and the
IBM PC. I haven't read either, but they get decent reviews.

    well, my biggest problem is not HOW to program things; i'm considering
    MIDI as just another device to device protocol which are neatly covered
    using state machines. i mulling over the question of WHAT to program to
    make it a reasonable and not a YAS (yet another sequencer)
    regards,
    u.

    I've always wished I had a sequencer with defineable "jam points".
    
    One of the gotcha's with all sequencers is that they plod along
    regardless of what I want to do. If I get into a smokin' solo I
    might want to extend beyond the 16 bars I've already defined in the
    sequence. If I had "jam points" I could define the start and stop
    points. Step on a pedal and the sequence would loop between them.
    Step on it a second time and the sequencer would finish the current
    iteration and exit to the next part...
    
    More common, but definitely a "must have" is the ability to move
    either a track or MIDI channel forward or backward in time by shifting
    a small amount of CPTs. I'm tired of my horn swells coming in late...
    
    I'd also like to be able to program little "macro" instructions, along
    the lines of "ignore note messages on channel n if the sustain pedal
    is pressed".
    
    Edd

    re: .-1
    Why not do a sequencer that supports programming language syntax?
    That's what I've been working on. You could program things like:
    
    demoprog     |: C Eb F F# G F Eb D :|x4    ||
    
    This says to repeat the notelist four times.
    	"demoprog" is just the name of the part.
    	|: starts a repeat section
    	:|x4 ends a repeat section
    	|| ends the part 
    
    Now if you could substitute the constant 4 with some expression, for
    instance, if JAM tracks your "jam" pedal, you could do:
    
    demoprog     |: ... notelist ... :|x(JAM?INF:4)
    
    This could mean to repeat the notelist at least 4 times, but continue
    indefinitely while the jam pedal is down. This is using the C syntax
    a?b:c which has the value b if a is true and c if a is false.
    
    Now, what would really be neat is to also program a "keyboard watcher".
    It's simply a state machine. You could be set it running in parallel as
    you enter the loop, and it watches what you're playing. You could have
    the JAM flag initially set, and when the watcher recognizes some
    signalling riff that you play, it clears the JAM flag.
    
    demoprog	cue watch
    demoprog	|: ... notelist ... :|x(JAM?32:4)
    demoprog	||
    
    watch	(JAM=TRUE
    watch	wait_for_sequence(E5 G A Bb Bb A)
    watch	JAM=FALSE)
    watch	||
    
    The possibilities are endless... You could program several different
    riffs that send you off to any one of a bunch of different sections of
    the song, then while you jam, it could go wandering off in various
    directions. Eventually, you play some clear signal (say, the main
    theme) and next time around, it breaks back into the preprogrammed
    ending.
    
    I have the beginnings of a language like this working. It supports
    things like repeats, but for constant values only. You can nest the
    repeats, and can set several independent sequences going in parallel. I
    don't have any user defined functions, or variables yet. I'm still
    deciding how to do this. Unfortunately, I have enough of it running to
    be able to write songs with it, and that's a major distraction :)
    
    Parallelism is a key requirement. It is analogous to having separate
    tracks in a sequencer, but it's more powerful.

Re -1:

Are you aware of F. Benjamin Moore's cmusic language? It sounds like what you're
describing is mostly a subset of its capabilities, coupled with some new twists.
Perhaps you could continue with what you've developed but incorporate some of
Moore's work as well. (cmusic is described in Moore's book, "The Elements of
Computer Music.")

Cheers,
	Bob

    Yes, I've heard of cmusic, and have accidentally seen things about it.
    Perhaps now is the time to abandon part of my strategy: to NOT learn
    too much about other similar tools so as not to bias my own thinking.
    
    A few years ago, when I started this (1985!) - that seemed like a good
    idea. But, re-inventing the wheel isn't. Maybe it's time to "cheat" and
    learn all there is to know about cmusic...
    
    Is Moore's book the best reference? Or are there better references
    around? I recall hearing about a language (?) called CHANT from IRCAM,
    but I don't know if that's the same sort of thing.

    
    
    I believe that the new Roland MC50 has a feature quite similar to the
    aforementioned Jam facility. I.E. Two loop points which can then be
    overwridden by a pedal...
    I think it was the Mc50 because thats the only review I've read
    recently.
    
    
    						Paul.

    thanks for all suggestions and replies to my inquiry. some of the ideas
    will be included into the new opcode specs for the intermediate code
    machine (currently available just on paper,but previously used for
    intermediate code compilers ==> all features of programming languages
    available with midi io extentions) but i volunteer to type them
    into a public domain directory to make them available for public review.
    initially it will specify a database (RDB) design; a in memory
    representation of songs, threads (=named sequences) for parallell
    execution and instructions (=events) and the opcode specs for the
    state machine. availablility will be announced in this notes conference 
    
    so far for now,
    ulrich 
                                                                           

    In case you're still interested here's another tip:
    
    I think a good drumeditor is a must. Maybe you've ever seen the one in
    PRO 24, I kinda like it. You can use a grid from 1/4 to 1/32 triples,
    or "grid off". Most of the time I program one measure, repeat it and
    then change the measures where there should be breaks. You can define
    the notes and names of the drumsounds and the length they should be
    played. 
    
    Something I haven't been able to discover is the following function:
    
    Record a poly-track, for instance 3-note chords, and then split the
    notes to separate tracks with separate midi-channels. This would be
    usefull for me, cause I still have a SIXTRAK (what???). I'll probably
    never will sell it, cause all I will get back is about 1/6 of the
    price I paid for it. And it has a nice warm sound, not to be found in
    digital synths.
    
    Good quantization and humanazition is (I think) a must too.
    
    A good arranging section would save a lot of time.
    
    Frank