Is Eeyore Designing Your Software?

This classic Eric Lippert post describes, in excruciating, painful detail, exactly how much work it takes to add a single ChangeLightBulbWindowHandleEx function to a codebase at Microsoft:

This is a companion discussion topic for the original blog entry at:

Good post!

All of those processes make it cost prohibitive to do a single addition like ChangeLightBulbWindowHandleEx.

I’m sure that’s why Microsoft bundles all of these teensy-weensy changes into one biggy-wiggy push.

For those people who are claiming that they don’t understand how Open Source projects can get away with lacking a lot of efforts that they see as essential, think of that clichd cartoon “What the customer asked / What was in the spec / … / What the customer actually needed”.

Given a choice between the price of a typical enterprise installation and that of an open source program that fills the same need, a lot of those ‘essential’ features turn up to be not that important after all. If you’re ponying up $40,000 for your software, you’re going to be pissed off if you find out it doesn’t support the Uzbek locale because you were planning on extending your business there, eventually. If it comes for free, however, you start realizing that you’re not actually doing business in Uzbekistan right now and the entire expansion deal may be a dead end anyway, so you’ll deal with that when it happens.

Yup. Been there done that. Nearly 15 years in a CMM level (almost) 3 shop; they never submitted to formal evaluation though.

Then too, I’ve been paid to develop open source software. I was hired by a big company to work exclusively on an internal project later released as open source. I continued on that project for several years after it had become open source.

In the open source project we did conform to Spolsky’s “12 steps” long before Spolsky wrote it up. We also used an Agile process based on first having taken a lot of time to get many (most) of the requirements defined and an system architecture designed. In the ongoing Agile process, there was a significant lack of workflow and formal process. What I believe was key to the project’s success is that the work required a very high level of “job maturity”. What I mean by that is that the participants had to deal with all the important details of what he was working on in its entirety. I believe this means that the majority of developers on the project were at least in the top 20% of software developers worldwide. Me being the notable exception, of course.

Some of the other things that made a strict division of labor and workflow management less important was the the project was architecturally more sound than some products that come out of many commercial shrinkwrap companies. That means that that our project used a modular approach; low levels of dependencies on other components; adaquate data hiding; and other good programming practices. All these things are artifacts of better and best software developers.

I now do some software development as a “shop of one”. The software I am working on now may someday see the light of day as open source, but for now it is for in house (my personal house) only. I use a similar Agile process for implementing features. I use Spolsky’s “12 Steps”. I added some process from Fogel, “Producing Open Source Software” in anticipation of release as an open source project. I also added some process elements (checklists, automated checkers, test coverage metrics, memory leak detection, …) from my own experience that help with product quality.

It works for me.

See also comments by Justin; David W;

@Doug – My own process includes things learned from “Personal Software Process”.

@Gunther – Yes, some OSS projects release software for user testing. The big ones and many smaller projects also develop test suites too. Mine does.

@Peter S – on “Shadow IT organizations”. Sometimes a bad solution is better than no solution at all or an unacceptably long wait for the formal IT organization to get to implementing what is needed.

Maybe this is why the programmers in the zoo don’t seem to have as much life as the ones you find writing code on the open Serengeti plains in Africa.



Several months ago I installed Ubuntu. There is so much to love about this OS. However, I had issues finding a driver to fully utilize my Nvidia graphics card. Within hours I was poking around in ugly text files, restarting X, and installing drivers posted on a stranger’s personal web site. I was also instructed to take fonts from a Windows install in order to get the display looking reasonable…

Then there are things I take for granted on my Windows’ machine…like being able to copy paste from one window to another. If I was using a mix of GNOME KDE applications (or whatever) these things don’t work reliably.

Eventually I just became tired of fighting with the system and reinstalled Windows. It just works…mostly. It takes a couple of months of living with Linux for me to start appreciating Windows again.

For the past week I’ve been playing with Django. Django is an AMAZING framework! I will likely launch a personal project using Django. However, here is the install instructions I was working through:

Notice paragraphs like the following:

“Now that we have Python 2.4 and mx Extensions installed, we can install psycopg. Unfortunately the psycopg devs do not maintain win32 binaries…”

I completely appreciate the person who created this web page, but half way into this I wanted to quit. I miss being able to click “setup.exe” and being done 3 minutes later.

Then came development with Django. Again, I love SO MUCH about this framework, but some of the error messages were almost meaningless. If I forgot to put a “colon” the error would often direct me to something deep in the Django framework itself…instead of the obvious typo that I had made.

I could go on to describe Django’s lack of API documentation or that I couldn’t find an IDE with robust reflection auto-complete abilities.

All this being said, just evaluating Django has opened my mind and helped me see new possibilities. I have already begun to apply things I’ve learned to my ASP.NET projects. This is the way it has always been for me. Open source opens my mind to new possibilities and innovations. However, when it comes time to get work done…Windows, Visual Studio and ASP.NET.


In response to “shadow IT” doing a terrible job.

There’s a reason. There’s alway a reason.

  1. Management never hires enough IT people. To management, they’re plumbers. Unpleasant, expensive necessities.

  2. It gets done badly by someone who knows how to do it or it doesn’t get done at all. At times your whole dept. *can’t" function without the bad solution that IT doesn’t have the time to provide anyway.

So you can complain, but “shadow IT” is like open source. Volunteer all the way, and hey, you get what you paid for.

The fundamental dysfunction behind it, like virtually all corporate dysfunction, flows from decisions made at the top by the tragically ignorant souls with nothing more than business degrees.


you’re experience closely mirrors mine. I got so fed up with NetBeans. I installed NetBeans 6, worked with several pre-releaase builds and also the final, and really simple things just didn’t work. I was trying to do something simple, connect to one of the world’s most used web services (Amazon E-Commerce) and set up a GUI app that has a form for a search entry, a button to launch the search and a table to diplay the results. It was something that I expected to take a day to build.

A similar experience as to what you described: soon I was knee deep in build scripts, trying to install WSDL parsers that were compatible with the java revision and doing all kinds of things like that.

Each little issue I encountered took up a lot of time and none of them had straightfoward answers. Worse yet, they were just never ending! For something so f*#!ing simple!

Anyway, after months (yes, literally months – ok, not working full time on this) I just pulled the plug on java. BTW: My experiences with Eclipse weren’t any better, although not as recent.

I installed Visual Studio .Net 2008 and had this little test project working in the originally anticipated day. Everything just worked as expected.

Again, one thing wasn’t the problem, but the fact that it’s never just one thing. Every time I got something working, something else, just as absurdly simple, either just didn’t work or threw some error or something. I really don’t know how they expect anyone to actually program using tools like this.

Hi Jeff, I totally agree with you in this aspect. It’s important to see the advantages of each approach but in this case open projects are more dinamic than big companies.

For me it’s a lack in OpenSource. Sure, anyone can look at the code and “repair” it. But as you can see, most OS-developers want to add features, not to repair bugs. You can read a lot of this things from developers like Alan Cox or in the Mozilla project. A half developer doing Thunderbird issues? Nobody to fix kernel problems, but a lot of guys to implement new features. That is really the opensource part (and never go to the firefox security newsgroup. It’s scarring to see a high priority bug which isn’t fixed after a year…)

You think Microsoft are doing all that for fun? They’re doing it because their customers demand that it is done, or (for localization) to target bigger markets. Or, given they have a big bullseye marked on their backs now, to satisfy governments. Adding a new function to Windows and not documenting it? Why, that’s anti-competitive! (Adding a new feature that duplicates something in the market and not charging for it is also out, which is why Hyper-V is available separately at a stupidly low price, and the cost of Windows Server 2008 without Hyper-V is coincidentally the same as Windows Server 2008 with Hyper-V, less the stupidly low price of Hyper-V ‘sold separately’.)

The amazing thing, to my mind, is that enterprise customers are not demanding that it’s done for open-source-derived products.

On my Linuxbox, witch runs almost exclusively open source software, 98% is localized to Norwegian. Security patches and bug fixes arrive daily. Just because there’s no fat manager supervising the process, it gets done, there is a plan.

The only justification for all that overhead would be if the quality would otherwise suck. However, looking at cruft like Vista, I can only say: the process doesn’t guarantee it doesn’t suck. Which means: if that process, all that expensive overhead, doesn’t guarantee quality, why bother? I mean: if skipping half the overhead results in the same quality, why bother doing the rest of the steps?

And if I may add: the process described isn’t applied to a lot of areas apparently. When looking at the SDK, there are many methods undocumented, and no-one can tell what they do.

I disagree with you on the Quality. Withing an hour of installing Vista, I was up and running using it and installing my favorite apps.

Microsoft has adopted this process because of the lessons it has learned in previous releases. It’s not like this process was implemented from Day 1 at Microsoft. It’s been put in place to help ease issues caused by security concerns, localization problems, application compatibility, and the like. Microsoft gains revenue by ensuring that all the boxes are checked off. Open Source doesn’t care because, for the most part, they don’t depend on selling their software to but food on the table.

This reasoning alone is why Linux will never be huge on the desktop. Microsoft’s process has evolved to put an Operating system on hundreds of millions of computers. Clearly it works. It’s also still working.

For more popular and successful open source projects all the issues discussed above are taken into account. Granted, many of them are taken into account after the fact. Someone writes the code, and perhaps the unit tests and javadoc/doxyogen header comments, and all the support people upon seeing the svn commit go and update the localization strings or do whatever it is they do.

However, one thing I’ve noticed with open source projects is they tend to have better process than closed source projects. When your only collaboration is svn and a mailing list, you make sure your code works before you commit it. When no ones paying you to write the program your writing, you take enough pride in your work to write a unit test.

I can’t imagine anyone thinks rigour and quality (good processes executed by great people) is a bad idea.

Is this, then, where commercial OSS comes in?

Alfresco, Zimbra, etc generate cash and can (do?) fund quality processes (quality ain’t free) and tap into the pool for ‘innovation’ as well as grunt work…?

That’s a deep pipeline, and it’s even deeper than described (who gave the go ahead to implement ChangeLightBulbWindowHandleEx?)

It’s overkill for a single feature, but if you think about that pipeline in the context of a project/product/product-line, then it’s not as ridiculously unbalanced as presented.

As far as comparisons to Open Source; how many people would be involved for a comparable (localization-requiring) feature to make it into the next version of Mozilla?

Obviously nobody commenting deals with Sarbanes-Oxley regulations. The auditors barely let us get away with having Linux; anything that actually performs business functions HAS to have all of those processes. If we use open source apps, then WE have to do all that work before we put it in.

I think this kind of process is crucial to any software development. It’s a pain in the a$$, for sure, but worth it. I’ve been writing mainframe programs for better than five years now, worked in shops where I could copy my code directly to production myself without oversight, and worked in shops where a change required every bit as many steps as the light bulb change above. In all honesty, I prefer the Microsoft approach. It may be just a little of the “keeping me honest”, but it’s nice to know that the other developers around here are jumping through the same hoops, that we shouldn’t end up with too many programs that can be submitted to the dailywtf.

this says everything you need to know about Opensource

“On my Linuxbox, witch runs almost exclusively open source software, 98% is localized to Norwegian. Security patches and bug fixes arrive daily. Just because there’s no fat manager supervising the process, it gets done, there is a plan.

The key words are 98% localised (which is good enough), if no-one uses it in Mongolia then it won’t get done, but the Norwegian Linux users want it in Norwegian so they translate what they use… How many Windows programs do you use that don’t localise properly?