Linus On Specifications (2005)
kerneltrap.org
kerneltrap.org
Once there are known holes in the theory, it's not a scientific theory. At best it's an approximation, but quite possibly it's just plain wrong.
When you are writing code, you can't forget about important parts. Because if you do, your code won't work at all.
Of course, even that doesn't work for all situations. Some shops can be "agile" enough to quickly get new iterations out there based on feedback. And that can be nice. There are other industries that are very much requirements/documentation driven (see medial software and devices) and the spec does matter.
Just because the code passes the developer's unit tests doesn't mean that nothing important has been forgotten. Most errors in programs are due to errors in comprehension. Spec review is the fastest and cheapest way to catch those problems. I've done this innumerable times.
Spec hate is a mystery to me. On the one hand, most programmers agree that shorter programs are easier to understand (pg articulated this well), so we go for DSLs, high-level langs etc. A spec is the ultimate short program.
I find specs very useful before starting on a project. It's much easier to for non-programmers (who may be domain experts though) to comment on the completeness of the proposed solution when they see a spec. And developers benefit from seeing feedback before writing code because it's easier to rewrite text than code (Spolsky said this well).
I'm undecided about maintaining specs to be in sync with code forever though. I don't do this except when I make big changes.
http://www.developerdotstar.com/mag/articles/reeves_design_m...
I do agree with the sentiment that processes that focus too much on design artifacts and less on practical issues of how to make working systems often lead to truly awful designs.
I disagree when he seems to imply that you don't need to document what you're building.
Being iterative with software and specifications/documentations can lead to both good software and specifications.
Write a small amount of software, formalize, write some more, etc.
Is that a reasonable generalization?
Here is a case where divergence between the model and "reality" would be catastrophic: http://www.fastcompany.com/node/28121/print
I'm also interested in exactly how one would apply an iterative cycle of implement->test->formalize to this category of software? (Ooops. There goes the rocket! Back to the keyboard!)