RE: OOP and large systems (was: Ada vs C++)

[knoll@coopn1.csc.ti.com (Ed Knoll @(719)593-5182)]

I'm starting to find this thread a little bit tedious, mainly because of
some of the poorly constructed arguements.  Let's line up some of the basic 
premises.

1) Some people believe Ada to be more OO than not.
2) Some people believe that there are attributes to "true" OO that are not 
   encompassed by Ada.
3) Some people feel that Ada is good for large system development.
4) Some people feel that C/C++ is not as good for large system development.

From what I have observed personally and absorbed via second sources, I
will group myself in the "Some people" camps.  The two competing arguements 
that have been lined up are that: 
  a) Ada should adopt some of the other attributes that make a "true" OO, 
  b) there is not a demonstrated need to adopt these other conventions.

I won't try to debate either of two arguements above, however, I will debate
the validity of the following arguement.

> My comment was that the so-called "pure" OO might well be largely
> irrelevant to such systems. Pure OO encompasses, by what I THINK is
> the general definition, not just encapsulation and information hiding
> but messages/methods, polymorphism, dynamic binding, and inheritance.
> Considering that Ada supports none of these well and yet supports
> the engineering of large complex systems quite well, the argument that
> pure OO may be largely irrelevant to the construction of such systems
> seems valid.

1) Just because Ada currently supports large systems development well, does not
   mean that it can't support that activity better.

2) The reason that Ada is better suited to large systems development than 
   C++ is due to the physical manisfestation in Ada of many attributes of 
   good software design practices.  This is an arguement against those lacks
   in C++; this is not a valid arguement against the ineffectiveness of
   the other OO attributes (i.e polymorphism, dynamic binding, etc...).

I not arguing for or against the other OO extensions to Ada.  It will 
always be easier to "adopt" new features than to "remove" poor ones because
of the backwards compatability problems, therefore, I think all extensions
should be well considered (which seems to be the case).  

However, we shouldn't try to argue against the OO extensions because C++ 
doesn't seem to have exhibited success in large systems development when 
we also argue that large systems development is outside of the reasonable 
problem domain for the C/C++ language.  

It might help if those who advocate those extensions will also supply the
arguements (or references to same) for why those features are desirable.


Edward L. Knoll

Texas Instruments
knoll@coopn1.csc.ti.com