But we all know that coders, writing to the same spec, will do the same mistakes, so this basically guards against defective compilers more than anything else.
Actually the evidence is quite different. If you give the same spec to a dozen engineers/coders you will likely get a dozen different solutions and 11 of them might work.
yeh, remember ~25 years ago when I worked on the first Bluetooth, all the different companies came together for "unplug fest" to all try connecting to each others implementations, there were always minor differences in how each company had interpreted the spec.
And, what I like to point out:
If the spec is complete, unambiguous and correct, then it
is the program. Separate implementation step is superfluous and can only do harm. Said complete spec should be in formal language, so that compiler can implement it. This is called "programming language".
OTOH, if the spec is incomplete, ambiguous, or has mistakes in it, then surely the next step, "implementation", is very important, and as such different implementations behave differently, and it's well possible the "most incorrect" of them happens to be the best (desired outcome). In such case, "implementation" is not just implementation anymore, it is design.
Therefore, my opinion (which paulca will point out I have no right expressing because I'm not professional enough software developer) is that tightly separating specification and implementation and especially hiring "code monkeys" to do the implementation has been a huge mistake. Those who decide what the system should do, should be definitely working with the code as well. And vice versa, totally
everybody working with the code should have opinion of what the right outcome should be. (I'm not saying make random decisions alone, of course. Communicate.) In which case there is no clear line between specification and code, or waterfall model, but rather, collection of code, natural language descriptions, simulations etc. which are all kept in sync in a bidirectional process.
But what we still see is the idea of Perfect Specification unidirectionally flowing (waterfall) into lower-level implementation job, and instead of adding
understanding and
design to the whole process, companies apply all kind of super weird stuff like getting separate teams do the implementation and compare the results in hopes that somebody got the desired outcome. Like, why not instead get the implementers as part of the design team and
ask them, "what do you think the plane should do"? And if they are monkeys, how about, don't hire monkeys, get the wise guys, the designers, write code?