Max Mathews appreciation at createdigitalmusic.com/

Casually following the release of 5.14 on the nabble mailing list indicates this seems like a good release, particularly for Windows users. An early tester reported “flawless” operation on Windows 7 (i7 processor).

Go to the link shown above for readme files and an installer for Windows.

Here are the release notes as an OpenDocument Text file: Csound Version 5.14 Release Notes

last modified 20110304

http://en.flossmanuals.net/bin/view/Csound/WebHome

There’s a discussion of the project on the Csound nabble.com forum at this URL

http://csound.1045644.n5.nabble.com/Csound-on-FLOSS-Manuals-td2847749.html#a2847749

This is still being produced but it has great potential. As I mention/gripe about frequently, Csound is so old and so huge, that to get a handle on it at all is difficult. Sort of like trying to eat an entire hippo for dinner…

In other news….Built versions of Csound 5.12 for Windows have had quite a few bumps along the road … keep checking the forum rather than soundforge to figure out if you want to get that version…

Also .. I don’t know what the deal with nabble.com is, or why the Csound forums are hosted there. In any case, here’s the new (?) link to it http://csound.1045644.n5.nabble.com/

He shows how to get your first sound out of Csound using the QuteCsound front end.

Search for user “ketchupok” or here are some direct links:

Configure QuteCsound: http://www.youtube.com/watch?v=sFnZytyNuWc

60 second intro to Csound (using QuteCsound front end) http://www.youtube.com/watch?v=P5OOyFyNaCA

I think he may be assuming a little more expertise than a beginner might have, but in any case well worth checking out his short videos.

He’s also using a Macintosh, although the principles are supposed to be the same over all platforms.

OK, this week I was able to go to an open house at Southwestern College in Chula Vista (outside San Diego, Calif.) and get a quick tour of the amazing recording studio that has been recently finished there. It’s a resource for their courses in recording engineering technology. I believe I heard that between $5 and$6 million was spent on it.

You can see pictures, panoramic views and see equipment lists here: http://xserve.swccd.edu/ras/Welcome.html

I am really envious of the students who get to work in this facility, and the musicians who’ve been able to record there. The professor, Jay Henry, who designed it from the ground up, also knows his stuff to an amazing degree. Check it out…

More Csound progress…

OK, lately (finding myself with a little extra spare time) I plunged back into Csound. In particular, I was working with some files I gathered over the years; some from the thonk processor, a few recorded with a tiny MP3 player on a city bus, and other random field and noise recordings. Nothing was really exciting me sonically, so I thought I’d delve back into the (extensive) granular synthesis and resynthesis tools available in Csound.

(Aside: Each time I do this I feel like I’m learning it from the ground up. Lesson: you definitely need to use it regularly to stay current!)

So I went and ran the various granular synthesis demo programs and listened to them to try to figure out if that kind of processing would allow me to get the sounds I think I’m interested in. There are several opcodes you can use to process either mathematical data or audio samples with granulation.

These are: grain, grain2 and grain3 (the older ones); granule (somewhat newer); and partikkel and partikkelsync (the newest, as far as I know.)

The problem is that, as with fractals, the parameters of the computation make a huge difference in the result. The only way this could be dealt with in the Old Days was to change the parameter, run it again, listen, change parameters again, etc. This is obviously terribly time consuming and inefficient.

[...still being worked on 25 Mar 2010...]

In going through old files and reprints, I came across a great article by Art Hunkins.

I did a search using Google and on SourceForge.net for audio toolkits or other open source program libraries or projects. Almost all of them are dead or haven’t been updated since, say, 2001. One project linked to a page that crashed.

Under the “subsynth” project page, at least the originator had the grace to explain he had to stop working on it (“yeah, this project’s pretty dead“…) (which sourceforge helpfully dates as “1647 days ago”. Quick, when do you think that was?)

Well, the “Python Sound Project” sounds promising. Whoops, that project was last touched 1251 days ago.

Now Nyquist sounds a lot more promising. At least it was worked on in 2009. But amusingly something as simple as clicking on the “FAQ” link on that page leads to

An error has been encountered in accessing this page.

1. Server: nyquist.sourceforge.net
2. URL path: /nyquist-faq.html
3. Error notes: NONE
4. Error type: 404
5. Request method: GET
6. Request query string: NONE
7. Time: 2010-03-12 21:09:15 UTC (1268428155)

See, the point I’m trying to make was that if there was a simple list of active, working, usable source code/libraries the typical eager programmer/user wouldn’t get terrifically frustrated.

So much OpenSource stuff is like this. I think many good programmers just give up and start writing their own libraries or utilities rather than try to ferret out what’s working and what’s ancient history.

I had some more thoughts about the Csound packaging discussion. As mentioned before, the big problem I see with Csound is its huge scope and tons of leftover and no-longer-supported components due to its age.

I’ve thought about a couple other software systems and how their developers managed this.

Unix

The history of Unix, GNU, Linux, etc. is a lot more complex that I can deal with here, but for our purposes Unix was originally developed at Bell Labs and not really intended to be publicly distributed for free. But students at (e.g.) UC Berkeley extended and developed it and the “BSD” distribution started to be seen everywhere.

Many companies took Unix concepts and “productized” it for sale. For instance, Sun developed “SunOS” (later renamed Solaris) which was basically just a Unix port that was guaranteed to run on their hardware and was supported.

Ironically, you can now get Solaris for free and it’s ported to a number of platforms.

StarOffice and OpenOffice

Late in the 90s and to date, Sun produced a program suite called “StarOffice” designed to compete with/replace Microsoft Office which was an expensive licensed product of Microsoft. Sun actually released a version called “OpenOffice” which is completely free and unsupported.

The point is that now the user has a choice. If you (or your company) can afford MS Office, you’re free to buy it. It will probably amount to a few hundred dollars (US) depending on the configuration you choose. But if you want to save money and don’t absolutely need to use the MS products, you can get StarOffice for USD50. If even that’s too much, you can download OpenOffice which has the same functionality for whatever it costs you to download a few hundred megabytes.

And my point is…?

What I’m obviously getting to is: would a Csound user pay a small amount for a stable, well-documented, software suite that did 90% of what Csound is capable of, if it meant no hassle in installing and using it?

I think a part of this equation might involve something like Steven Yi’s blue Csound frontend / composition environment. Although it’s been very interesting for a few years, it is suddenly at version 2.0.x and more stable and powerful than ever before (why? because it’s being actively developed; by a real software engineer; who is managing the project himself (or with a small group of other volunteers.) )

There are many competing factions at the Csound table. There are the grizzled veterans for whom Csound’s cruftiness is part of its charm; the Linux stalwarts who have to build it from source before using it; the students who are forced to study it in their electronic music curriculum, the fascinated hobbyists, the experienced computer music gurus, etc.

Wonderful thoughts. So who is going to pay for all this fine work?

Well, that is the crux, isn’t it? Look at the example of the amazing music application called “chuck.” My guess it was developed by a couple of amazingly talented grad students at Princeton, who are now probably trying to pay their rent and student loans. It hasn’t had a new release since (I think) mid-2008. That’s not to say it isn’t amazingly powerful and functional as it is — in fact, its forum is still very active. But without dedicated, professional, paid staff it’s hard to see how it can thrive, get bugs fixed, new features implemented and tested and so forth.

In a posting, Jim Aikin suggested the possibility of there being some institutional support for at least a little professional staff. Although it’s hard to imagine who would be the “angel” for Csound (it would certainly be me if I were hugely wealthy.) The problem with Open Source is that without coherent leadership things can get — diffuse. All the developers of Csound are volunteers, and Herculean work they do accomplish. The software is truly awesome in the real sense of the word. Just to give a tiny idea of the scope of Csound and cognates: the PDF version of the manual is over 2400 pages. Just imagine that.

The universe of Csound is so old and venerable now, that it’s analogous to a huge factory, with workshops and warehouses strewn all over the landscape, some features dead or moribund, and others only partially working. The users of Csound are also incredibly diverse. Some just want to do simple sound or music design writing orchestras and scores in text editors, some want to program it using other languages, others are doing audio and acoustics research and not using it for music at all; others are working on front ends (QuteCsound) and complete composition environments in which Csound is just the engine (e.g. blue.)

Then you have users on not only the Macintosh and Windows platforms, but Linux versions as well.

I think Mr Aikins’ idea is good; but it’s hard to imagine this happening realistically. Chuck (cs.chuck.princeton.edu) ongoing development is languishing as well–labors of love are romantic but they don’t put top ramen on the table.

Perhaps a model might be OpenOffice. This was supported by Sun (now Oracle). It is extremely solid, full featured, trivial to install, well-documented and evolving. Maybe like it (cf. StarOffice) and Linux, there could be an inexpensive “supported” version and a free “all the source code you can eat” version.

All the tools you need to develop it are free (similar to many Gnu tools and Microsoft Visual Express systems). But Java appeals to me since it’s pretty open, mature and runs pretty well on all platforms. And the clincher is that there are Java wrappers for the Csound API. There are a couple sample programs in the Csound distribution but (once again) the documentation is nonexistent. I hit on a website of a guy writing a modular synth program in Java to run Csound underneath it, and the excellent blue composition environment appears to be in Java. So there is some precedent that can be mined. Hopefully I’ll be able to provide some pointers for people who want to do this.

Well, like 1000 other things in my life, I have put this on the back burner while occupying myself with other more interesting things in life. I still would like to revisit this project though.

Anyway, I wanted to add that my researches indicate that there are two major free development environments for Java: NetBeans and Eclipse. Both have their own strengths and weaknesses, and a little research should unearth some papers comparing them. For my purposes, NetBeans seems perfectly serviceable, so I downloaded it and started experimenting with it. Nothing significant to report yet.

Netbeans can be downloaded here: http://www.netbeans.org/downloads/ and Eclipse coincidentally enough here: http://www.eclipse.org/downloads/

Although the more I look at Java the more convoluted a language it seems to be. There’s a humorous essay about how to shoot yourself in the foot in numerous programming languages. It’s all over the web but I tracked an early (original?) version down to here: http://www.fullduplex.org/humor/2006/10/how-to-shoot-yourself-in-the-foot-in-any-programming-language/

The problem with Java (after you’ve worked with simplistic syntaxes like Perl) is that it’s terribly convoluted. One comment to the above article suggested this construct for how to shoot yourself in the foot using Java:

Foot foot = new Foot();
Gun gun = new Gun();
gun.bullets.Add(10);
gun.fire (foot);
Result:
NullPointerException at : gun.bullets
or
java.lang.OutOfMemoryError at: gun.bullets.Add(10);
ClassNotFoundException at: Gun gun
-You have placed the Gun.class in the classpath?

This sort of gives you the flavor.