There are a lot of things wrong with this analogy, but I think it still encapsulates a nice ideal. We'd like to get it right the first time, and make it last with minimal maintenance.
(This is for software engineering, not computer science)
Many bridge-building projects go over time and over budget.
Most bridges have a feature list fixed years before construction is begun.
Bridges are static. Even draw-bridges do not adapt to their environment automatically, but require human intervention.
There is a categorical error when you try to apply construction practices of static things to the construction practices of dynamic things, hence the failure of waterfall. Note that the original papers that introduced waterfall actually suggest a system that more closely resembles iterative development than BUFD.
Iterative development is an interesting stop-gap, but it's certainly not the be-all and end-all we should be looking for.
I think so. As a rule, when something can be developed incrementally rather than planned and engineered, it should be. This makes mistakes less expensive, allowing you arrive at a satisfactory end result in a fraction of the time.
This is one of the huge advantages of the web over desktop software. Initial delivery to the desktop and subsequent updates cost significant time and headache. Redeploying to the server is just a matter of running a script.
This raises a good point about reuse. You wouldn't try to re-use the same bridge across a different span without modifications, but we require our software to run in different contexts (be it different web browsers, operating systems, versions of the language, et cetera.)
I'm not a materials/mechanical engineer, but it seems that engineers can build bridges properly the first time (most of the time, right?) because they are working against a set of well understood, well tested physical laws (for lack of a better word). Even I write the perfect, say, shopping cart application, that bit of software still relies on programming frameworks, web servers, operating systems, and hardware systems that have known issues.
http://mindstalk.net/vinge/vinge-sing.html
I think Vinge explains it better than Kurzweil.
Update: The child comment by binaryfinery points to where Vinge addresses this. Sorry, I failed to add the disclaimer that I only skimmed the article.
* Programming a computer in plain English.
* Teaching a machine to compose (real) music, or draw (real) art.
* Simulating a brain -- or, even better, emulating one.
* A programming language that makes it possible to write code that's worthy of being read as literature.
1) writing an AI,
2) proving P=/=NP, and
3) founding a 200-billion dollar company.
Oh, and #3 is neither...
No, I don't mean an alien empire running on Mac OS 7.6.5, I mean extreme interoperability so software can rewrite itself to work on a different platform (self-porting, in other words).
Having said that, their firewalls were lacking!
For software engineering, how about a practical way to do proofs of correctness for large real-world systems written in mainstream languages?
Lacking that, haskell's type system :D
Significant code reuse without using a lot of hacks. I think Lisp and Ruby made great strides towards this, but I don't think we're quite there yet.