RLPF.ar

... and I'm forty-one. Funny, I don't feel a day over 53.

Here's what the next couple of days have in store:

• Tuesday: Bus from Guangzhou to Shekou (suburb of Shenzhen, right across from Hong Kong)
• Wednesday morning (early, ugh): Ferry from Shekou to Hong Kong International Airport
• Wednesday midday - Thursday morning Chinese time (Wednesday night, East Coast US): HK to O'Hare (ugh) to Dulles

At least we have overnight in a hotel Tuesday night. Still, nothing can make the long flight entirely pleasant. (The cocktails aren't that good.)

I've posted this elsewhere, around and about. It belongs on my blog too. I've mentioned lilypond (music notation software) before. Lately I've been digging more deeply into it for a new piece for sheng, a fascinating Chinese instrument related to the khaen from Laos and Northeast Thailand. The instrument can play sustained and moving notes at the same time, like piano or organ. Like those instruments, the notation can become intricate, with multiple voices on the same staff and with that, the possibility of collisions between symbols.

I remember how awkward this is to do in Finale. In virtually every case, I would have to move something by hand, adjust tie or slur direction, slide notes horizontally, move accidentals or rhythmic dots. But working on a passage in lilypond yesterday, I saw this come out with no manual adjustment.

What's the big deal? The point of notation is to be legible: easy to understand from some distance. Small details of positioning make the difference between notation that is valid and notation that is beautiful, and a pleasure to read. Two details in the 3/8 bar caught my eye:

• The two stems (pointing up and pointing down) are actually not in exactly the same horizontal position. You might think at first that it would be tidier to align them precisely. But this would give the wrong cue to the eye, by making the stems look like a single line that was broken in the middle. They shouldn't be. The voices are separate entities. Offsetting the lower voice just slightly to the right makes it more immediately obvious to the eye.
• The dots in the upper voice are shifted to the right to make a clean column. Finale may have improved in this regard, but if not, I'm pretty sure the dots would be the same distance to the right of their respective noteheads. Not only would that look messy, but it would also create semantic confusion. The rhythmic dot for the D would appear right above the C#, where it could be mistaken for a staccato dot.
• Well, three... how about the breath mark after the half note? An elegant shape.

It brings to mind the best potential of open source software. In commercial software development, the priority is to save developer time. Where good software architecture practices are followed, it's for ease of maintenance by internal developers. Software can also be designed for openness and extensibility, implying not only ease of maintenance but also ease of absorbing ideas and new code from users. Music notation benefits especially from this sort of openness. It's far too complex a field -- with apologies to LaTEX, it's even more typographically complex than typesetting of formulas in higher mathematics -- for any one person (or even one development team) to grasp all the intricacies. It's up to the users to notice output that isn't quite right and complain, or (better) suggest solutions.

Commercial development of notation software like Finale funnels users' suggestions through a narrow spout. Most of the suggestions never make it through, or they're bent into something a little bit different from the user's intent. (I saw this in person when I worked in a software company.) Lilypond allows users to fix the problems and add new features themselves, with no middleman who is as concerned about stockholders' return-on-investment as about serving the users' needs. (This is not to fault Finale specifically. It's simply a necessary consequence of organizing software development around a corporation. Corporate interests do matter in that environment. You can't get away from it.) It can incorporate a lot more wisdom directly from the user community, and it's become a smarter (though harder to learn) tool because of it -- like SuperCollider vs. Max/MSP, for that matter. I'll grant, a good deal of open-source software is garbage, but when it brings the right people and the right ideas together, it can go higher, further and better than the proprietary stuff.