The Libertarian Programmer
I am a software engineer. I am also a libertarian. Not that I belong to the Libertarian party (I'm not a member of any political party). Rather, I have a libertarian viewpoint, which affects how I view a great many things including politics, religion, and software. Before I go on, let me briefly describe what "libertarian" means to me. The very nature of libertarians means that they do not hold to any rigid set of platform planks. They belong to a spectrum that goes from what I call "classic libertarians" who are illustrated by the authors of the US Constitution on one side, to the anarchocapitalists on the other side, who practically believe in having no government at all. What ties them all together is a belief in personal freedoms and the realization that the more government interference there is, the less freedom we have. The only difference is in where they draw the line.
So, how does this apply to programming? I don't think any programmer can completely divorce himself from the way he views the world. In fact, without this realization, he cannot keep from creating code that is influenced by his world view. This is especially true when it comes to user interface design. One of the programs I worked on is a fairly successful product with hundreds of thousands of users. Looking back I can see some mistakes we made in the program. One of the problem areas was the program preferences, which I was in charge of. I'm not talking about bugs, per se. No, the biggest problem with it was the sheer number of preferences. We're talking over 200 individual preferences that were made available to the user, some of which involved sub-preferences that numbered from 2 to 100+. There were three causes of the preferences. The first were when management decided they wanted some weird quirk that differed from industry standards in a way that we knew would be confusing to most users. Sometimes I think that it was due to their ignorance and inexperience, while other times it seemed their reasoning was nothing more than marking territory ("hey I'm the boss and I can tell you to make whatever changes I want to prove it"). In those cases, we included a preference out of mercy to the end user so that they could change the program to work in a more standard way. The second cause of preferences was also management-driven. They kept changing their minds about how a feature should work. After a few rounds of ripping out code and then putting it back in, we decided to leave the code there and simply use a preference to control whether or not it was used. It was much easier to just toggle the default value for the preference. The third cause of preferences is the reason for the vast majority of them, and I take most of the blame for the situation. It was because of my libertarian leanings that the preferences multiplied.
How did my libertarian views cause the problem? Since I believe strongly in individual freedom, I felt the user ought to have unrestrained freedom to alter the look, feel, and operation of the program. Anything and everything from the scrolling speed to the width of the caret in the text editor. To me, it seemed heavenly to be able to control every minute detail so I could make the program a manifestation of my individuality. However, I eventually realized that most people are not particularly libertarian. Even in America, where a lot of lip service is given to freedom, the fact is that most people don't want true liberty. Consider that most people vote for candidates from one of the two major parties. A lot is made of the supposed differences between the two parties, but they are both the same in that they seek to use government as a club to enforce their particular (dare I say) moral viewpoints. They only difference between them is what particular set of morals they want to enforce. That is how libertarians view the situation. What we discovered in regard to our users is that most of them simply accepted the program as delivered and never bothered with preferences. Those who looked at them were overcome by the number of them, even as nicely divided into categories as they were. Heck, even the technical staff had problems finding a given setting. We actually talked about including a search to help users find the preference they wanted.
In the end we found that all the effort to include the preferences, test each of them, fix them when an update broke one of them, provide a UI for them, and the resulting end-user confusion simply wasn't worth it. We thought about removing most of them, but once you provide a feature to your users, you don't dare remove it in a future release unless you want them to rise up and come after you with torches and pitchforks. It is better not to have provided a feature in the first place than to remove it after (some of) your users have seen it. Considering the small number of libertarian-minded users that appreciated the flexibility, it is clear that the investment in preferences didn't pay off.
Lesson learned. In our next project, we only had a couple preferences and made the choice to avoid any additional settings unless we have a significant chorus of users requesting a new one. We didn't hear a peep from any users about not having additional preferences. Perhaps we couldn't use the marketing point "the most flexible product on the market", which might have been a help in clinching a sale or two, but I think the users are actually happier without overwhelming numbers of settings. And the development and technical support staff certainly are. Although the first product may have been unusual in terms of the number of settings, it wasn't the only product out there with excessive settings. I know that some of the products I use have crazy numbers of settings - and I'm a guy that likes choices. I won't name any of them, but I'm sure you can think of some instances on your own.
I think that software developers may be more libertarian minded than the average person. After all, we love our configurable tools - from editors to IDEs. But it behooves us to realize that most people are, essentially, sheep that are happy with whatever they are given. Especially if the target user is not a developer. So design a good UI. But also realize that a good UI is one without scads of preferences.