The Pursuit of the Flawless OS

by Paul Rubens

OS Roundup: Eurocrats and the normally sober American Law Institute have some ideas about how operating system makers and other software developers should write their code. Will anyone listen?

What do daft Eurocrats and the normally sober American Law Institute (ALI) have in common?

Both have recently come up with some particularly silly ideas about how operating system makers (and other software developers) should write code that works properly.

Given that Microsoft and the Linux Foundation teamed up and got their lawyers to write a joint letter to the ALI last week asking it to reconsider the relevant principal, you'd have to conclude both organizations feel threatened — my enemy's enemy is my enemy, in other words.

Put simply, the ALI was proposing software come with a non-disclaimable implied warranty of no material hidden defects, while the EU commissioners proposed licensing software should lead to the same rights as come with buying a good — it works as advertised, in the way that it is expected to.

In other words, these non-techies expect Microsoft, Red Hat, Novell and every other Tom Dick and Harry that sells (OK, licenses or just takes money for) an OS to make sure it doesn't have any significant bugs in them, or suffer the consequences.

The reality is that most software is riddled with bugs. Never mind "Software wants to be free," it's more like "Software wants to be buggy." That's the nature of software. A typical OS is orders of magnitude more complex than a fridge or an automobile and is expected to interact with combinations of hardware and software that don't even exist yet. Some estimates reckon that commercially grown software like Windows has about 25 bugs per 1,000 lines of code, and open source software like Linux perhaps a tenth or even a hundredth of that. If these estimates are correct, then in any large body of code there will still be more bugs than you can shake a stick at, and many of them are bound to be showstoppers.

The real question to ask here is this: Does anyone actually want an OS with no significant bugs in it? The answer is probably fewer people than you might think. I'd imagine NASA isn't too keen on its software crashing in the middle of an exorbitantly expensive space mission. Which is why it doesn't use Windows XP to control its equipment. And I seriously hope that the software controlling nuclear power stations, or nuclear missile silos, for that matter, isn't running on any bog standard Linux distro.

As a general principal, all the software for those kinds of applications is bespoke, and goes through a hugely expensive quality control, analysis and testing process to try to ensure it works flawlessly. Not that that guarantees all the bugs are ironed out, of course.

It's doubtful that that kind of rigorousness could ever be applied to the kind of sprawling mass produced OSes that most organizations use today. There aren't enough skilled software engineers; there are too many lines of code for it to be analyzed in any effective way, and even if it could, the pace of development would slow to an unacceptably slow crawl.

In any case, it would be so expensive to produce that license costs would go through the roof. Software makers would probably have to take out some sort of liability insurance as well. Like doctors, they would doubtless pass this cost on to the licensees, making the software more expensive still.

So NASA and the likes aside, the question, once more: Does anyone actually want an OS with no significant bugs? Or put another way, "Would you like to pay a hundred times more (or perhaps a thousand times more — who knows?) than you do now for your OS?"

I somehow doubt it. OSes that are cheap or free will always have bugs, but at least they let us balance our IT budgets. We all like to complain when the OSes we rely on don't run as they should, but we shouldn't forget that — to a great extent — we get what we pay for.

Paul Rubens is an IT consultant and journalist based in Marlow on Thames, England. He has been programming, tinkering and generally sitting in front of computer screens since his first encounter with a DEC PDP-11 in 1979.

Follow ServerWatch on Twitter

This article was originally published on Tuesday May 26th 2009
Mobile Site | Full Site