Thursday, September 30, 2010

Software that Annoys Me

This is a pure rant post, composed while I was wasting my life waiting for Eclipse to decide whether or not it can actually install some packages (it decided not to). Don’t read this if you don’t like ranting, or are sensitive about the nature or quality of modern software.

The end goal of all software is to utilize a computer to perform some tasks for the user. If the software makes it easy to perform these tasks, then it is a good. If not, then the software is likely the culprit, particularly if the tasks are simple.

What computers do well is remember things. Because of that, all I want to do is give the stupid machine a high level directive and let it fill in the blanks. I don’t mind having to tell it all of the details once, but when I have to do it over and over again, it quickly gets ridiculous. Some software does this well, but there a lots of examples of stuff that just takes the lazy approach, particularly when it comes to installations.

The other big annoyance with software is a boat load of functionality that is randomly scattered all over the place. Most problems come in groups of things you want to do and there is nothing worse than having to waste time flipping around endlessly inside of badly thought-out interfaces to find each of the little pieces necessary in order to accomplish a group of related tasks. Rarely do I do things that are exotic. Mostly I am using the software to perform its central task, the one that the programmers built it to do. So if I have to bounce around a lot, it shows how poor the collective thinking was on the part of the programmers.

Some software that bugs me:

Just about every product that has ever come out of Microsoft. Mostly because they maintain an army of young, smart, but poorly trained coders who work very hard on each piece in isolation. The finished products are always masterpieces of stupid complexity, disorganized interfaces and random functionality.

An example of this is that my Windows machine does weird things from time to time. I don’t know what cause these glitches, nor will I ever know. I’d list them out, but they change so frequently, and are always different with each descending new version of Windows. I’ve given up tracking them. I’d change some of my configuration parameters, but given that there are now an endless number of them distributed in overlapping sets across countless interfaces, I’m just as likely to make things worse as I am to make them better. It’s safer to just pretend they don’t happen.

Another example is “Security” in SQL Server (users, groups, roles, etc.) which is utterly demented. I’ve been in SQL Manager a billion times (OK, a few less than that), and by now I should at least be getting some idea of how the different pieces relate to each other. No doubt there is some relationship or model or some other twisted logic at play, but so far its hasn’t been obvious. The randomness in SQL Server reminds me of the insanity of the types and auto-formatting in Word. That used to work until they “improved” upon it so well that I’m always forced to always shut it off, or risk it destroying all of my work.

And thanks to a lack of overall design on their part, I’m running poorly written virus checkers, bogged down in policies and using other randomly dished out hacks, to mitigate the possibility of illegal access (even though my machine is physically secure). Between that mess and software bloat this causes my current box to run slower than DOS 6 on my IBM AT did twenty years ago (or is it thirty now?). If Moore’s law predicts the steady increase in hardware capabilities, an inverse that should be called Microsoft’s law, explains the corresponding decrease in software usability and performance: the more hardware performance you have, the more newbies will sloppily waste it.

But the very worst part of their works is the testing. I think they still use a 1-to-1 tester to programmer ratio, which means that while the applications are annoying, unpredictable and hard to use, they are patched with just enough duct tape that they “appear” workable.

Hibernate. This library is a classic example of awesome functionality and extreme usefulness buried beneath a layer of horrible APIs and bad documentation. The whole ORM concept is great and really useful, but I’ve always felt like the authors of Hibernate were so concentrated on their cool underlying algorithms that they couldn’t care less about the users. And in their case, the users are the other unfortunate programmers that want to utilize their technology. The libraries seem to go out of their way to make themselves obscure, weird, inconsistent and generally hard to grok. Once you get something figured out, you can use it to great success, but it’s always a beast to get there. Just because you know half of Hibernate, that knowledge sheds no light what so ever on the other half. Sophisticated underlying algorithms are great, but if the access to them sucks, then that severally diminishes the whole package.

Eclipse. Not sure, but I suspect that the Eclipse project is the single largest collection of programmers ever to come together to work on a single thing. A magnificent concept, but more for the fact that the by-product of this collaboration is possibly the most annoying, over-complicated, horrendously complex and silliest thing that humanity has ever produced. Recently I wanted to play around with Hibernate Tools, which exists as a plugin for Eclipse. Easy right, just install the basic Eclipse, point it to a repository with the Tools and then install them. Yep. Nope. Basically after wasting a day being bounced between useless web pages, and some really bizarre dependency handling, I’ve pretty much decided to give up. Whatever tools are out there are not worth the aggravation of having to navigate through a maze of randomly named gibberish, useless pages and other nonsense. Get something, install it, and then use it. How hard can that be?

All of the above -- and many more -- suffer from the same disease. The programmers have transferred their love of stupid complexity onto their users, as if they somehow expect the users to appreciate or thank them for it. In the Microsoft case I have no choice but to use their stuff, it is mandated from above. I am a captive audience. In the Hibernate case, the basic technology is too useful, so I have to be forgiving. But they should note that if something comes along that is even marginally better, I’d drop them in less than a second. In the Eclipse case, I used to use it, but then I switched to NetBeans and have never regretted it. NetBeans has its own set of annoying problems, but in comparison to Eclipse they are nearly trivial.

When programmers hyper-focus on the code they often forget about why they are building the software. Sophisticated code is nice, but not if it is wrapped in a shoddy package. It’s the whole thing that matters, not the bits.