The Linux Kernel Mailing List (LKML) came alive on Thursday when Linus Torvalds chose to write, in a discussion about the risks of following specs without being flexible enough to take reality into account: "A 'spec' is close to useless. I have _never_ seen a spec that was both big enough to be useful _and_ accurate." The web is currently abuzz with the merits and demerits of this point of view.

As we always try and do, let's first look at exactly what Torvalds wrote:

Date	Thu, 29 Sep 2005 12:57:05 -0700 (PDT)
From	Linus Torvalds

"A 'spec' is close to useless. I have _never_ seen a spec that was both big enough to be useful _and_ accurate.

And I have seen _lots_ of total crap work that was based on specs. It's _the_ single worst way to write software, because it by definition means that the software was written to match theory, not reality.

So there's two MAJOR reasons to avoid specs:

- they're dangerously wrong. Reality is different, and anybody who thinks specs matter over reality should get out of kernel programming NOW. When reality and specs clash, the spec has zero meaning. Zilch. Nada. None.

It's like real science: if you have a theory that doesn't match experiments, it doesn't matter _how_ much you like that theory. It's wrong. You can use it as an approximation, but you MUST keep in mind that it's an approximation.

- specs have an inevitably tendency to try to introduce abstractions levels and wording and documentation policies that make sense for a written spec. Trying to implement actual code off the spec leads to the code looking and working like CRAP.

The classic example of this is the OSI network model protocols. Classic spec-design, which had absolutely _zero_ relevance for the real world. We still talk about the seven layers model, because it's a convenient model for _discussion_, but that has absolutely zero to do with any real-life software engineering. In other words, it's a way to _talk_ about things, not to implement them.

And that's important. Specs are a basis for _talking_about_ things. But they are _not_ a basis for implementing software.

So please don't bother talking about specs. Real standards grow up _despite_ specs, not thanks to them.

Linus

"Stop being so childish Linus and accept the fact that in the real world specs are in fact used. Specs are not bibles or fixed laws but approximations of reality (like you pointed out yourself), just as the code is an approximation of reality!!!"

But others came equally readily to his defence. Developer Eric Bardes for example, commented:

"What I think he is really trying to fight is what the Agile Movement calls Big Design Up Front (BDUF). BDUF recognizes that customers will never see how a software application will transform their business and will invariably change their minds. Dwight D. Eisenhower summed it up as 'In preparing for battle I have always found that plans are useless, but planning is indispensable.'"

And here was another post to Slashdot supporting his view:"Of course, Linus is right in one area: most specs are useless. There are two primary reasons for that. Either, the spec is poorly written; there are lots of those. Or, the spec describes a bad design; there are many more of those. Many of the original UNIX design documents were exemplary specs: they told you concisely what you could and could not rely on. On the other hand, many recent standards (like HTML or SOAP) are examples of well-written specs that are bad specs because the underlying designs suck. But the fact that many specs are bad doesn't mean that it is inevitable that the Linux specs would be bad; that only depends on Linus."

"[Linus] seemed pretty adamant that he hates specs in any form or fashion.

Of course, it's easy to do that when you're Linus Torvalds, and whatever you say/do is the de facto standard without the need to write a spec. He's basically a walking spec. However, I'd invite him to consider what would happen if all the peons adopted his theory. Nothing would interoperate with anything else.

The only thing I can think of is that he defines a spec as something that is inherently written once, before implementation begins, and is strictly adhered to no matter what. However, I don't think any sane person would agree with that definition, I can't imagine that's what the other people in the thread meant by the word "spec," and I can't believe he'd imagine anyone else defending such a process in the first place."

"Linus is an engineer/tech. He dislikes theory work because it often gives nothing in practice.

However, specs are not always theory, and they may be usefull, as well as docs. He may be smart enough (or know linux code enough) to not need any doc/spec, but it's not the case of many other people. Some specs are good, and sometimes necessary.

He cited OSI model, well, but I can assure you I won't go in an airplane if it was done with Linus' practices... There are specs in some places that are good, and that are read and followed. Even in non-dangerous domains such as Web standards, specs are necessary, and those who don't follow these specs make crap softwares/browsers!

Moreover, in Linux development model, which is fuzzy and distributed, not directed, defining the software may be vain. However, in a commercial environment, defining the spec is really writing a contract, which protects both the customer and the editor. Specs there defines what the software can and must do, and ensures it will do. Linus obviously lacks of experience in industrial and critical projects. He may be right for the kernel development (however I still doubt it should be so entire on that subject), but he's wrong on many other domains.

IOW, Linus does here a generalization which is at least as wrong as are the examples he cited. As we say : "all generalization are false".

If he finds a bad spec, either it throws it away, or he fixes it. It's the same for technical docs. But he shouldn't tell every specs are useless and bad. That's wrong."

"Linus is setting a common misperception of 'specification' onto stage and explaining that it really is two separate things that are often lumped as one. He isn't invalidating the concept of specification, only that people confuse ways of talking about things with ways of implementing things.

He is right that the reality of the way things are take priority over the way that we talk about the problem. We also need to talk about the problem, so specifications exist so devices from different manufacturers are able to communicate.

So the main point, as he said: 'it's a way to _talk_ about things, not to implement them.'

The common misconception is that it's possible to do systems development by progressively amending the specifications, rather than making the specifications be driven by technical requirements."

No sacred cows are being shot here, and you don't need to defend any favourite positions or dream up disaster scenarios that disprove the point Linus has made. He is simply asking that you realise there are two distinct areas and one follows the other."

The debate, naturally, will continue web-wide. As Torvalds, when typing his original strongly-worded post to LKML, doubtless knew it would.