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

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

[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

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

[Jim Showalter]

Overall, a nice cogent post. I have a few quibbles (don't I always?):

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

Agreed. However, I have not seen any compelling argument(s) to the effect
that, if Ada supported "pure" OO, it would support development of large
complex systems any better than it does now. I HAVE heard a lot of quasi-
religious tub-thumping for pure OO as a miracle cure-all for what ails
software development organizations, but I've seen precious little hard
data in its favor, and precious few success stories. Mind you, I'm not
predisposed to reject pure OO as a valid software engineering paradigm--I
actually find the model rather pleasing from an aesthetic standpoint--but
I DO think it's fair to ask what proof there is that pure OO is anything
more than a research toy and/or snake oil du jour that sells compilers
and introductory texts but produces few if any demonstrable results. I
have buckets full of success stories for Ada in large complex systems:
I am STILL waiting to hear success stories for pure OO on similar systems
(and no, 20K programming-in-the-small efforts don't count).

>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.  

Speak for yourself--there are plenty of people arguing that C++ IS suited
for the development of large complex systems. Some even make that claim
for C.

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

Indeed.
-- 
**************** JIM SHOWALTER, jls@netcom.com, (408) 243-0630 ****************
*Proven solutions to software problems. Consulting and training on all aspects*
*of software development. Management/process/methodology. Architecture/design/*
*reuse. Quality/productivity. Risk reduction. EFFECTIVE OO usage. Ada/C++.    *