(Originally published 11/27/2006 on zachmortensen.net)
Last week software-development pundit Joel Spolsky ranted about the obtuse design of the shut-down menu in the recently-released Microsoft Windows Vista operating system. A few days later, a former Microsoft engineer named Moishe Lettvin posted a reply that gives us a telling behind-the-scenes look into why large software systems fail, or more specifically, how a company working on a large software system can sink more than a million dollars into a seemingly trivial feature that turns out quite lousy in the end.
When you read Lettvin’s account of the endless quibbling in a year’s worth of design meetings, the 7 organizational layers and 43 people that had a say in how this particular feature worked, the practically unworkable amount of time it took to synchronize changes across the hierarchy of source-code repositories in the system, and the mere couple hundred lines of code that this process produced in a year, you may be tempted to blame many of the problems on an inefficient organization structure and the resulting work processes. But keep in mind a premise that Jay Galbraith set forth in his book Designing Organizations: That processes exist to support a firm’s organization structure, and the organization structure in turn exists to support the firm’s strategy.
If a firm’s strategy is inherently complex, it follows that the organization structure and processes required to execute that strategy must be sufficiently complex as well. Albert Einstein famously said: “Make everything as simple as possible, but not simpler.” If the strategy of producing software the size of Windows Vista is inherently and ridiculously complex by virtue of the way large software systems behave, then it would seem that the organization structure and processes required to support that strategy can be nothing less than ridiculously complex themselves. Rather than question the particular execution of such a strategy, it’s much more productive to question whether the strategy is fundamentally flawed in the first place.
I can’t be the only one who wonders why Microsoft chose to invest so many years of effort and so many billions of dollars rewriting a product whose most serious competitive threat, Linux, is literally given away. And “free” might become even more appealing when consumers notice that at $200-$400 per retail Vista license, they may be paying more for the obligatory operating system than for hardware when they make their next computer purchase! With such an expensive shut-down menu, to say nothing of the gaggle of other new features, is it any wonder why the product’s price has reached such unprecidented heights?
I submit that this same Million-Dollar-Menu phenomenon is occurring within the largest vendors of healthcare IT systems. We just don’t have as savvy a critic as Joel Spolsky or as honest an insider as Moishe Lettvin to enlighten us about the particulars. The largest vendors in our industry spend about $1 million per day on software development. When will their products create that much value for their customers? The short answer: Certainly not today, and maybe never if present trends hold. More to come on that topic later.
Given the amount of money spent on the Windows Vista shut-down menu, perhaps the most unfortunate admission by Lettvin is the following:
“The end result of all this is what finally shipped: the lowest common denominator, the simplest and least controversial option.”
The larger a software system, the lower the common denominator must be to satisfy the system’s myriad constraints. Such a mediocre system — whether an operating system or a hospital information system — at a premium price is a bad deal. And just as an unconstrained observer as Joel Spolsky can redesign an awkward Windows Vista feature in no time, so will smaller, focused, and more-agile software vendors continue to run circles around their larger overconstrained competitors, paradoxically delivering better software at a lower price not because of better execution, but because the strategy of delivering progressively bigger software products invariably trends toward the untenable market position of a mediocre product at a premium price.