David, Ron, et al,
> You raise many interesting points to which I will respond in more
> detail when I am back home and have a reasonable email system to
> But I must quickly respond to one point you raise, in particular:
> >The only new feature of OO is the ability to dynamically dispatch
> >which is a form of operator overloading.
> This is exactly right. I raised this point in a lecture once, and
> the "OO guys" snickered in the background. They didn't get it!
True. But much of this discussion goes back to the early 70s with
Smalltalk (and possibly even further, to the late 60s with Simula).
It _certainly_ did not start with C++, which first emerged in the
early 80s, about the same time as Ada 83. Originally called "C with
Classes", it was named C++ around 1986, if memory serves.
Dynamic dispatching was a technique that was known to the Green team
(whose design became Ada). [THere was a myth around that they didn't
know about this OO stuff, but in fact, Ichbiah (and maybe others on
the team) had worked on a Simula compiler and knew very well what
this was about.] Some of the early Ada writing indicated that they
were worried about the runtime performance of dynamic dispatching.
So Ada 83 ended up with a more static kind of overloading. Once the
hardware caught up with these cool language things, they became
feasible for real languages in real systems. Smalltalk embodied
lots of cool, cutting-edge ideas, but was way ahead of 70s hardware
and the Xerox Smalltalk machines of that day were very slow, in
part because of all that dynamic stuff.
> Then, as many of you may remember, early C++ compilers did not get
> NORMAL overloading correct. They didn't think to include the return
> parameter of a function call (the ONLY procedures in C/C++) as part
> of the procedure specification, for overloading purposes. They did
> finally fix this.
And of course there was no validation suite for C++, so these design
bugs slipped through more easily than they could have with Ada.
> More later.