People tend to say Computers are so fast today the overhead does not really matter, and if it does for a few inner loops, no problem: our language can interface with C. But that is beside the point. The real disadvantage of these languages is not their (somewhat inferior) execution speed, but their lack of static checking. If you write bogus in a compiled language, chances are the compiler will catch it. Some stricter languages[2] will catch more kinds of bogus than more lenient ones[3], but there are surprisingly many ways to write bogus that every compiler will catch. Interpreted languages do not have a compile phase, they just throw an exception when encountering bogus at runtime. If they encounter it: There are many execution paths through a program, and some may not be followed very often, making it easy to write, install, and use completely broken software. You may say Well, write tests then, but as useful tests are, they come with large disadvantages when relied upon as the only means of detecting errors: Firstly, they have to be written. A compiler knows about the language, but the developer has to write all necessary testcases by hand. It is easy to overlook something, and it is also very easy to be lazy and write too few tests (or none at all). Secondly, executing tests takes machine time (probably more than what was saved by not compiling), and writing tests takes developer time (lots of it). Finally, the static analysis a compiler provides tends to catch different errors than tests do, so combining the two will simply catch more problems than either method on its own.

Oh, and then there is the problem of external code. Libraries, modules, whatever. APIs should not change (needlessly), but sometimes they do. With ordinary binary code, there is an established way to keep around different versions of a given library, so older programs using an older API can still function. I am not aware of a similar mechanism for Python, so getting ImportErrors from a module that installed just fine is not that unusual. In fact, implementing such a method for an interpreted language would be somewhat more involved than for a compiled one: When a programmer links to a shared library, the linker will take that to mean the latest installed version of that library. The version number is then encoded into the application binary, so the correct library will be used whenever the application is started. However, the very nature of an interpreted language means that the program is not touched by anyone but the developer. So if the developer does not demand a particular version, nothing else does, either. Seriously: use a tool that fits the job rather than clutching a hammer and trying to see nails everywhere.

1. like Python
2. like Ada
3. like C

In the past few months, I have spent an hour or two almost every week to find the leak. Today, I have met with success:

In the normal fast-forward case the behavior remains unchanged. However, now local modifications and commits will be erased, and upstream rewrites are handled smoothly.  This ensures that the upstream
branch is tested as expected.

Argh! What bally idea is that? I would like to decide for myself what I want to test, thank you very much. If I really want to test Upstream, I will create a branch for that purpose. It is not up to some piece of software to decide in my place, and then remove my code from the repository!

Dabei bin ich eigentlich froh und dankbar, daß der gcc als Buildsystem die GNU Autotools verwendet. Sie werden zwar manchmal als veraltet und zu kompliziert abgetan, aber ich komme mit ihnen immer noch weit besser klar als mit CMake, Python Distutils und allem anderen, das ich bislang gesehen habe. Die Probleme beim gcc rühren allein daher, daß es mit dem bloßen Kompilieren nicht getan ist; stattdessen wird der dabei erzeugte Compiler dazu verwendet, aus dem Sourcecode noch einen Compiler (Stage2) zu erzeugen, und dieser wiederum erzeugt dann das fertige Kompilat (Stage3).[3] Of will man in verschiedenen Stadien verschiedene Optionen verwenden, und deshalb gibt es auch einen ganzen Zoo von Umgebungsvariablen, deren Zweck nicht immer ohne weiteres klar ist.

Ach so, die Lösung: nach dem Konfigurieren einfach make BOOT_CFLAGS='-g -O0' bootstrap eingeben, und schon klappt es.

1. Für den Fall, daß noch nicht alle des Programmierens nicht mächtigen Leser aufgegeben haben, sei gesagt: Ein Debugger ist ein Programm, mit dem man den Ablauf und den Zustand eines anderen — möglicherweise fehlerhaften — Programmen schrittweise verfolgen kann.
2. Jedenfalls halbwegs — so ein Notebook ist nicht gerade die schnellste aller Entwicklungsmaschinen
3. Dieser Bootstrap genannte Zauber dient dazu, den fertigen Compiler mit sich selbst zu kompilieren, was ein guter Test für seine Zuverlässigkeit ist.

Nun ja, ich habe dann ein bißchen nach einem passenden Projekt gesucht. Vielleicht ein schönes buntes Mac-Programm? Aber bald fiel mir wieder ein, daß ich vor fünf oder sechs Jahren schonmal ein bißchen im gcc herumgefuhrwerkt hatte, und das hat mir eigentlich von allen Projekten immer noch am meisten Spaß gemacht: einerseits ist der Compilerbau schon soetwas wie die Königsdisziplin der angewandten Informatik, und andererseits gibt es beim gcc unglaublich viele kleine Nischen und Unterprojekte, in denen man sich nicht gegenseitig auf die Füße tritt, man aber auch Chancen hat, daß der eigene Code hinterher im fertigen Produkt Verwendung findet. Naja, und dann hat der gcc natürlich eine sehr zentrale Rolle im GNU-Projekt und eine unglaublich breite Nutzerschaft, und das schmeichelt dem Ego dann auch irgendwie.

Für’s erste ist aber statt Blood, Sweat & Code noch der Kampf mit dem Buildsystem angesagt, damit ich den ersten Bootstrap hinbekomme.

If you use Jim Rogers’ Pipe Commands for Ada, and the linker complains about an
undefined reference to `c_constant_eof',
try
pragma Import (C, c_constant_EOF, "__gnat_constant_eof");
instead of
pragma Import (C, c_constant_EOF);

[via Usenet]

Whenever I enter our company’s precincts these days, I am reminded of ice cream: a packed layer of snow, sprinkled with dark grit, looks just like chocolate chip ice cream; a thin layer of slightly dirty snow on top has more or less the colour of nut ice cream.

On Music

Never mind. I meant to tell you something totally different. It is about iTunes, the program I use to listen to music, and to keep my music library in order (and for a podcast or two). I have not yet bought anything from the iTMS, and nowadays, my iPod is used but rarely. So, I could just as well use a different program. On the other hand, iTunes works very well, it is integrated into the OS (on the Mac, that is), and I do not know of any real alternative.[1]

Out of tune

Nevertheless, there are some things I do not like. Mostly, these are minor points. For example, you can change the toolbar[2] to suit you likings in almost every little utility; this is functionality provided by the operating system, so application programmers do not have to work too hard to include this in their program. Not so in iTunes. Or take Smart Playlists[3]: You can combine several criteria by either and or or, but not by both[4]. It is possible to work around this problem[5] by combining several Smart Playlists.

Rated

Two points are, however, a bit bigger: the way iTunes works with albums, and with ratings.
iTunes’ ratings are quite simple — and that is the reason it looks a bit slapped-on to me: You can rate each track with one to five stars. These will be shown in your track lists, and you can use them in Smart Playlists[6]. That is about it. Wait, there is something else: when rating a complete album, the stars are copied to all the album’s (unrated) tracks. They will be shown as outlines to remind you that the track as such has not been rated. Likewise, an album will be rated from the combined ratings of its tracks.[7].

So far, so good. Such a simplistic rating seems to me to belong to the 90s[8]. My average rating is slightly better than four — a prime example of grade creep. This is where I would like to see something completely new. I do not know exactly how it should work; however, the fundamental idea is to take away the need to give absolute ratings. Instead, one could for instance perform relative ratings between two tracks; the application would then calculate absolute ratings for all titles. Or maybe the rating is calculated incrementally, and you rate it up and down each time you listen to a track.[9]. Or maybe there is a totally different idea. Some engineer is bound to have a great idea.[10]

Albus, -a, -um

Now, I have to admit I am pretty old-fashioned. Since mp3 and similar formats have been accepted, the music business seems to have shifted toward single tracks.[11] Albums are more or less dead.

Well, not for me. I still like to listen to whole records: the tracks belong together, forming a whole that is more than its parts, and sometimes, they even tell a story.[12].

Fortunately, albums are not totally gone: iTunes will group tracks by album, putting the cover art next to the list of tracks. You can also instruct shuffle mode to play whole records at a time rather than single tracks. Finally, there is the indirect rating system I mentioned above.

However, I think there is still much room for improvement. For instance, I like to use Smart Playlists, to look for highly rated tracks, of for ones I have not listened to for a while. Sometimes, only isolated tracks from various albums will be collected in this way: I might have stopped listening in the middle of an album last week, so its first tracks are two weeks more recent than the last ones; or maybe, I have rated several tracks differently even though they belong to the same record, and now only a few can be found on my five-star list.

I would really like Smart Playlists to work better with albums: wouldn’t it be great to have a list of albums collecting dust rather than just isolated tracks?

[Edit: English]

1. Again: on the Mac. The situation may be different for other operating systems.
2. That is, the upper part of a window, where you will find icons serving as shortcuts to important commands.
3. Automatically compiled, rule-based collections of music.
4. Say, I cannot select all titles I like especially well and that are either from the 70s or belong to the folk genre.
5. Apple Mail does it, too.
6. For example, you could create a list of all tracks with four or more stars.
7. Unless you have explicitly rated the album already.
8. I am tempted to say: to last century.
9. I may have been less than clear: a new track is given an average rating, say, 3. Once I have listened to it, I think it is better than that, and iTunes increases its rating to 3.5 or so. After listening for the second time, I still think it is underrated, so it increases to 3.8 — and so weiter in smaller and smaller steps.
10. I have added something to the wish list:

    What I would like to see in a future iTunes version is a truly innovative rating system. Instead of assigning a fixed number of stars per title, something that evolves as I build up my library and listen to music would be great.

    For example, once I have assigned preliminary stars to a new title, iTunes might allow me to compare it to other titles with a similar rating (say, while listening to the track). iTunes could then adjust its rating accordingly. Globally adjusting ratings in order to use the full spectrum of one to five stars might also be useful. Currently, the average rating in my library is slightly above four stars, however it is hard to correct this manually.

11. Except for concerts, that is.
12. And I like vinyl. But the drive does not fit into my Mac. Sob.