On Wednesday 20 May 2009, Lou Cohen wrote:
> There was a discussion recently about the longevity of Csound itself, and
> that is also an important factor for me. While LISP has been around for a
> very long time, I'm aware of its many dialects. The existence of these
> dialects is like an alarm bell for me: it means that the community that
> supports LISP is splintered, and that cannot be good for its users.

While there was indeed a splintering into many dialects, that changed in the 
early 80s. A major goal of Common Lisp was to be a "common language for a 
common community". By the time ANSI Common Lisp was ratified in 1994, that 
goal was definitely achieved.

Haskell is much younger and still developing. The current standard is Haskell 
98 and the next standard, Haskell Prime, is some way off in the future. It's 
unclear yet what the future of the language will be, but it has already been 
around for over a decade and is showing no signs of dying. Far from it.

Likewise Python, Ruby, and many others. Even C is still developing. There are 
already two ANSI standards and I wouldn't be suprised if another revision is 
made in a decade or so. C++ is much younger and less mature, but much 
healthier now than it was 15 years ago.

If you want a language that has stood the test of time, is the most mature and 
stable, and is certain to be around for decades to come, then I'd recommend 
the longest-lived of all languages: Fortran. :) That's only half a joke.

However, the subject of this thread is "Haskell for computer music", and I 
don't want to write music in any of the above languages. I want to write music 
in a notation that is good for music. The size or degree of splintering of the 
community for that notation is irrelevant to me, esp when I can maintain the 
code for that notation myself.

So, the Haskore codebase that I use was derived from the 2001 Haskore code. I 
had to tweak it slightly to make it work with current GHC versions. Then I 
tweaked it some more to handle some extra notations that I wanted to use. 
(E.g. adding a load of opcodes to the orchestra support, extending the 
infrastructure to make adding new opcodes easier, etc.) I may tweak it again 
someday, but probably not for a while. When I do, those tweaks will probably 
be trivial things (like adding more opcode support).

I've no idea how I'd do any of that in most other languages. Lisp would likely 
be the easiest, as it has always had good support for adding notations, but as 
I have no Lisp code for Csound, that might be a lot of work. I've yet to use 
Common Music, so that might help, but I feel no need to investigate that yet.
Haskore does everything I need now. Many of the things I do in Haskore would 
be very hard to do without the non-strict semantics of Haskell. That's a 
pretty solid win right there. Now I can do the things that I could only 
vaguely imagine doing back in the late 80s. I had no way to even think about 
how to implement them then. I needed a while different way of thinking about, 
writing, and implementing notation. Lisp helped, as did Forth, but I needed 
on-strict semantics. That's possible to do in Lisp, but hard to do it as well 
as Haskell does, and I didn't know how to apply it to music. Paul Hudak gave 
the answer: Haskore.
-- 
Martin Rodgers http://www.wildcard.demon.co.uk