I ran across an article about the allure of the Microsoft approach to selecting software on slashdot yesterday. For those of you not in the field of software development, the approach is simple. Microsoft is of the opinion that you should buy your operating system, your server software, your database solution, your development tools, your content management system, and even the syntax of your programming language all of the plug-ins, extensions, and updates to them, from Microsoft. It is obvious what the advantage is to Microsoft, but how does taking this approach help me, as a developer?
The author of the blog post is James Turner, who is an open-source developer, working in a particular sub-specialty of the field very similar to the one I work in. The argument that he makes in his blog entry is simple. It says that while the open source community has a lot of interesting solutions to offer, this is often the problem. The large number of choices that the open source community has to offer makes it difficult to make the decisions necessary to get the job done.
So what’s good about a monoculture, and why does Microsoft win so often when people make a decision about platforms? Largely because what the open source community sees as a strength, people trying to get a job done in the real world see as a weakness. We celebrate the diversity of choices available to solve a problem and call it freedom. IT managers and CIOs look at it and call it chaos, confusion and uncertainty.
In reading this opinion, I was reminded of a conversation I had over dinner this weekend. One of the people I was eating with brought up a book they’d read, in which the author talked about how it is that people find happiness. Parts of that conversation seemed applicable to the concept of software monocultures. The point that struck me as most applicable was the one that talked about salad dressing.
If you go into the grocery store looking for salad dressing, you’ve got literally hundreds of choices. If you then pick one and take that bottle of salad dressing home, and find that it’s not the best salad dressing in the entire world, you feel like you’ve somehow failed, because with all of those choices, surely the one you really wanted was there somewhere. If, on the other hand, you were to walk into the store and find you could pick between only Ranch and Italian, you might find that you were actually happier with the result. Having fewer choices sometimes makes you happier with the choices you make, because you can be more certain that they were the right ones.
(I’m certain this is not a word-for-word quote. It is, however, a reasonable paraphrase. Any inaccuracy is entirely my responsibility.)
Thinking about software in terms of salad dressing, I can see the point. Microsoft works hard to make sure I don’t have lots of difficult choices. In reality, I really only have two in most situations. Do I want to write my code in C#, or in VB? As a result of this very limited selection, I no longer have to try to decide which tools I will use. I need only to decide how I want to apply them to solve the problem at hand.
On the other side of the same coin, however, this approach has some problems. For one, it is often the case that I am deeply unhappy with the tools that Microsoft offers me to work with. They attempt to design their tools so that everyone can use them. In fact, they have to, because they only produce one tool, so it’s forced to be one size fits all. Most Microsoft tools offer an unimposing, graphical interface to do the things I want to do.
The trouble with this is that sometimes what I really need to do is get up to my armpits in the guts of what I’m working on. Microsoft tries to shield me from the icky internals, and sometimes in the process their tools end up treating me like an idiot child. This can be extraordinarily frustrating, and even insulting, when I know precisely what needs to be done, and even exactly how to do it at the nitty-gritty level, but I can’t convince their very friendly interface to let me past all of the pretty window dressing (Windows Dressing?) and actually do it.
Even worse, sometimes Microsoft’s tools will actually let me reach my arm far enough under the hood to do what I want. Then, as soon as I pull my hand back out, it looks over what I just did, and changes it. The tool figures it knows what I wanted better than I do, and it rearranges things, breaks formatting, and even outright changes the behavior of various elements in order to make my solution look the way the software thinks it should. For my tools to intentionally un-solve a problem I’ve actually taken the time to address gives me a feeling that is exactly the opposite of happy.
I certainly understand the desire to make a tool accessible to people who do not have my years of experience and formal education on these subjects. Sometimes, people need to be able to do quick, simple tasks, and they neither need nor want to have to dirty their hands on the very low-level details. For those people, and even for people like me when they just need to perform a simple task, a friendly interface is a huge help.
In the process of making their tools friendly and one-size-fits-all, Microsoft also limits the number of tools than I need to understand and be familiar with. I am freed from the need to sort through hundreds of possible solutions to my problems. Even if I could find a tool somewhere that was an exact fit for the issue I was trying to solve with it, I might well spend more time in finding it than I would save by using it instead of some more general, less ideally suited, but already familiar tool ready to hand.
Microsoft offers the certainty of no choices. Choice isn’t always good, and the open source community sometimes offers far too many ways to skin the same cat, choices that are born more out of pride, ego or stubbornness than a genuine need for two different paths.
This last point of Turner’s is one that I can definitely agree with. When looking for a tool I could use to solve a problem I ran into last month, I found a selection of literally hundreds of different solutions, each slightly different from the last, which all purported to do essentially the same thing. This was a list I found in the space of five minutes searching. I don’t doubt that if I’d spent another hour looking, I’d have found many hundreds more. Sorting through them took me a lot of time.
Members of the open source community are, at least to some extent, aware of this problem, but it’s a difficult one to solve. Oftentimes, they make an effort to merge a set of similar tools together, in order to make something with a wider set of features and a common interface. These efforts help to reduce the clutter, but it is only a matter of time before someone branches a new tool off of the combined one, for good reasons or bad.
In general, the open source community relies on many, many people making use of many, many tools to determine which are the best. Those tools that do a good job of meeting people’s needs gain prominence, and become more likely to turn up at the top of searches by new would-be tool users. Bad tools, those that for whatever reason don’t meet people’s needs, quickly wither into obscurity. This is a mechanism that works. It’s swift, unflinching, and Darwinian. The trouble is that at a glance, it’s hard to tell which tools are the good ones, and which simply haven’t yet had quite enough time to become extinct.
Now, [lest] you think I’ve been turned to the Dark Side, there is one BIG problem with a monoculture, which is that you’ve essentially sold your soul for the stability of a clear-cut set of choices. [Once you] go down the .NET path, you’re pretty much stuck there forever, Mono not withstanding. You’re always going to be running on a Windows platform. You got the pretty gold ring, but Sauron gets to pull your strings and make you dance.
This is another of Turner’s excellent points. The Microsoft platform can be an advantage because it removes a lot of extraneous choices. However, in the process, it also goes a long way towards removing the choice to change your mind.
If I’m careful when I write code, and do a good job of carefully thinking through how I set it up, the open source community makes it easy for me to change my mind down the road. In theory, I could at any point along the way simply remove the tool I’d earlier selected, and drop a new one in its place, if and when I find a better tool. If six months from now I decide I’m not happy with what Microsoft’s tools have to offer, I have a lot less flexibility.
Certainly, I can run other people’s software on my Microsoft operating system, or connect any of a wide variety of tools to a Microsoft database. That being said, if I have a Microsoft database running on a Microsoft server, being accessed with a Microsoft programming language through a Microsoft interface, and being displayed in my Microsoft web browser, I have a great deal of inertia working against me if I want to change any one part of that. Microsoft does not make it easy for me to just pluck their database out of the middle of that mix and drop in someone else’s.
From Microsoft’s perspective, choosing to build their platform that way makes good business sense. From my perspective as a developer, I become very nervous about making a choice that prevents me from making choices.