Esoteric Dissertations from a One-Track Mind

June 22, 2007

Amazing Stories of Software Compatibility

Filed under: programming — codesmithy @ 5:48 am

Raymond Chen wrote a book called “The Old New Thing,” which complements his blog with the same title. There is a bonus chapter available online which I found to be fairly amazing. The two things that I am struck by, is how seriously Microsoft takes compatibility and how many resources they dedicate to actually maintaining it. As the technology progresses, more sophisticated and general techniques become available, such as giving problematic programs their own sandbox so previous correctness can be maintained while properly behaving programs can move forward (Windows 2000 shims being one such example).

However, people find incredible ways to depend on specific behavior of the existing code. Such as “If it has eight bytes, it must be a dialog box.” An additional problem is that Microsoft, more so in the past, thought that programmers could be trusted to do the “right” thing; that trust turned out to be somewhat misplaced. The organizations that create programs are agents that want to accomplish their own self-interested goals. Which is why the Raymond Chen’s hypothetical conversation with a vendor is the typical response. You don’t gain the organization’s attention until you mention a threat to one of its goals, and frequently you have to make that connection for them. “Oh, our next release of XYZ will not work on Windows ’95, but we want to ship XYZ on ’95.” But, you should also expect the response to: “Your program does work on Windows NT,” to be the perfectly rational “We don’t support Windows NT.” Which is to say, this problem you speak of, you see, it doesn’t affect any of my goals. The expectation for support is also slightly unfair, although it tends to be pervasive. The fact that code does subtly (or other times not so subtly) break across different platforms means additional testing. Corporations are driven by rational self-interested behavior. How much will cost to get a administered Windows NT box? How much testing will have to be done? How many sales will we have on that particular platform? The rational response might be, we don’t support that platform the costs out-weight the benefits. They might be all for Windows NT support in principle, but they also need to look at their bottom line. The fact that Microsoft comes along later and says, hey you broke your program on NT or worse yet Windows 2000 (something literally impossible to test for since it didn’t exist during development) doesn’t change the fact that the companies goal is to maximize profit, which ensuring compatibility with future OS revisions may not be justified.

Therefore, it is more insightful abstract the people and instead view the corporations involved as two self-interested agents. Microsoft interested in externalizing the costs of compatibility, which they use to sell their new operating system, and the vendor who wants to sell a quantity of software that depends on the previous operating system, and isn’t necessarily concerned with compatibility with future versions (based on expected software lifetime and expected install base and sales figures versus costs of development and testing). Therefore, future compatibility is a cost that software vendors would also like to externalize. The fact that Microsoft invests so heavily in compatibility is because they consider it so vital to the sales of their new operating system. The minutiae of what actually breaks and why is intellectually interesting from my point of view as a programmer but as a business operative is fairly meaningless, since it literally comes down to profit. Better technologies for compatibility are just ways of reducing costs. Complaints that programmer X is so stupid, and did this all wrong is a failure to see the forest from the trees. Rational self-interest of the capitalistic entities involved are causing the friction, and as a member of an institution in that corporation, an employee takes on the properties of that entity in collectively solving the threat to its profits.

Given this view, the misplaced hatred for sloppy programmer X who produced the code is properly placed on the system causing the friction. Rational self-interested parties that don’t necessarily share mutual goals, and therefore compete. It is another symptom of a capitalist system that fairness has nothing to do with who bears the cost. Complaining about compatibility from different vendors is like barking at the moon, might as well just sit down an fix the problems at hand rather than ponder how in the world the code ever got written in the first place. For one, it did get written. Also, there is a lot of it, as Chen’s chapter demonstrates. Therefore, it better to take the approach that the problem at had is more of a puzzle rather than a product of some malicious, evil entity. As most any programmer can embarrassingly attest to, that malicious entity sometimes turns out to be yourself.

Leave a Comment »

No comments yet.

RSS feed for comments on this post. TrackBack URI

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

Blog at

%d bloggers like this: