((λ (x) (x x)) (λ (x) (x x)))

Today's software culture, especially in the Open-source world, seems to be about quick, rapid releases of software, whether it is stable or not. That's something I have mixed feelings about. It is really nice to be able to see the latest and greatest in development, but I've also seen companies and organizations get a bad name with unstable software that wasn't properly vetted.

There are two organizations I would like to highlight. Firstly, Opera has been doing something with their desktop team for a while, releasing development snapshots for the masses for a quite a while. It's quite nice, but they frequently contain very dangerous or harmful bugs, and some people don't seem to know the difference between development snapshots and the real stable releases of the software. So much so, that Opera has taken steps to brand the two different (Opera Next) in order to make sure that people know the difference.

Then take OpenBSD. They always provide snapshots of their software, but it's not that public, and honestly, it's not that necessary. Usually, folks following OpenBSD either run the latest snapshot or CVS, or they run the stable versions, but they don't normally run both in their machines. Remarkably, OpenBSD's CVS tends to be very stable most of the time, unlike Opera's Next releases. And then there are the frequent, consistent, regular six-month stable releases from the OpenBSD project.

As a third datapoint, take Bare Bones software on the Mac, I've rarely if ever seen them release a piece of software that wasn't remarkably stable, but then they started doing some pre-release versions on their mailing lists, and I was worried. Yes, some bugs were introduced during those times, but they are remarkably small changes, and overall, the software seems to have maintained its stability.

What's all this rambling for? Basically, I really value stable, working software, more so than I value rapid release points and new features. Am I in the complete minority here? I feel that some software groups make releases too fast just to make sure that they keep ahead of the times or stay in the news headlines. I can understand why this might make sense in some business plan, but if you decide to do that, surely you can keep stability a priority as well, right? There are companies that manage to do it, so I know it can be done; why do so many groups not prioritize traditional software values like stability these days?

There are a lot of people who follow the school of self-documenting code, some of whom I respect as some of the best programmers I have ever met. On the other hand, in my practice, I have found that self-documenting code doesn't exist in my little world. Moreover, I can't help but think, if people really can write self-documenting code, then why do we have papers where people talk about their code, or why do we have developer documentation at all? Why do we have API documentation? Why do we have blog posts about our code? To me, if we really have self-documenting code, then we should be expecting to see blog posts of nothing but code, and that should be sufficient for us. Is it? I've certainly not seen an effective blog post, paper, or program that was entirely, completely, without comment or prose. Usually it is always associated at some point with comments. More commonly, the code is almost secondary, and the prose takes a front seat. If code can really be written in such a self-documentary manner, then shouldn't we have code-blogs? Why are we writing in English?

To me, this gets at the heart of documentation. I just don't buy self-documenting code. I do buy clear, concise, and self-evident code, but that is different. There are so many contextual elements about a program that a program can't tell us, and that's why we have papers about that code, and blog posts, and the like. We have natural language for a reason, and we should use it to its best effect when using code. However, we should not rely on prose where the programming language is the better way to communicate an idea.

The union of prose and code makes more sense to me than having one or the other. Maybe that's why I like literate programming so much.

So, I finally got fed up with trying to change all of the colors in all of my programs so that they didn't conflict with the careful imbalance of my eyeballs. Instead, I chose the background and foreground colors that I wanted on my terminal, my font (mostly because it has all the characters I want), and summarily destroyed the color capability of my terminal with this:

XTerm.vt100.colorMode: false

And it is about time, too!