(...and other famous last words)
It's far from my intention to start a language war. I subscribe to Bjarne's
philosophy that such "wars" are fruitless, and do nothing to advance the
computing community. However, I feel it is important to right a few wrongs.
One of the biggest problems is that Ada is saddled with many myths, but the reality is that Ada 95 is a language that is reliable, flexible, AND efficient. Interestingly, the Ada 95 ISO reference manual is also smaller than the C++ ISO reference manual. (For those that might scoff at the efficiency claim: If your knowledge of the Ada compiler domain is more than a year old, you're hopelessly out of touch with the current market) For more information, check out the Ada Homepage or ACM's SIGAda.
In Bjarne's book, "The Design and Evolution of C++" (excellent book, by the way), Bjarne remarks about the Booch C++ components: "This library...is one of the better examples of the use of multiple inheritance"
Unfortunately for Bjarne, Grady designed MI out of the C++ components by version 2.1 (the Ada 95 components are based on version 2.3). This was because, 1) MI was proving to increase the maintenance penalty of the components (remember, inheritance generally increases coupling), 2) MI was not implemented evenly across different vendors, and 3) Templates were a much better mechanism for generalized components and utliities.
It's important to understand that MI, while useful, is not necessarily implemented in the same manner as C++. Ada 95, for instance, has three different mechanisms to inherit from multiple classes, yet those mechanisms are inherently more reliable than the C++ form. The issue of MI remains an oft-debated issue, and will remain so for many years to come. Watch this space for more links/additions to this issue.
Adding fuel to the myth fire, Bjarne has discussed, on numeous occasions, about the relative sizes of the Ada 83 components compared to the C++ components. While the Ada 83 components weighed in around 125,000 non-comment lines of code (please, no arguments about the much maligned SLOC metric), the C++ components tipped the scales at a svelte 12,000 LOC (Bjarne jokingly commented this must mean you could be 10 times more productive in Ada :-). Unfortunately, Ada 95 destroys that claim by consuming a mere (estimated) 10,500 LOC. Over 10% less than C++. Does this prove Ada 95 is superior to C++? Hardly, but it does indicate that one can indeed find more terseness, even in a "wordy" language.
I should make a couple of comments in Bjarne's defense: First, Grady indicated that, had he redesigned the Booch Components in Ada 83, his redesign would probably have taken less than 50,000 lines of code. Second, the reduction in the Ada 95 code comes from the elimination of the (my opinion) abominable syntax of C++'s templates.
Of course, the above statistics also blow away Alexander Stepanov's (creator of the C++ Standard Template Library) comments at OOPSLA '95 where he said, "You have to write too many lines of code with Ada." (Follow-up comment: Alexander's comments were based on his experience with Ada 83, which would indeed have required a significantly higher amount of code -- another indication of the leap Ada 95 had made in supporting moder-programming techniques)
Other famous last words:
"I drank what?!" -- Socrates