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

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

[Greg Titus]

In article <1991May30.004144.24252@netcom.COM> jls@netcom.COM (Jim Showalter) writes:
> [Somebody else writes:]
>>I won't argue the point that Ada is far superior when it comes to large system
>>development. This is a fact, plain and simple, and C++ cannot hold a candle
>>to Ada's abilities to decompose a problem into managable pieces and insure
>>the consistency between them. However, Ada is not all things to all programming
>>tasks, and one of the things it isn't is an object oriented programming
>>language.
>
>From the above paragraph, we have these two statements:
>
>1) Ada is a superior language for engineering large complex systems.
>2) Ada is not particularly supportive of OOP.
>
>These two statements lead to the following conclusion:
>
>3) OOP is largely irrelevant when it comes to engineering large complex systems.
>
>Now, far be it from me to actually MAKE this claim [;-)], I'm merely
>pointing out that it is the inevitable subtext of the above paragraph.

I don't see that, Jim.  I'd replace your 3) with "Ada is not the best
language when it comes to engineering large complex OO systems."
(Replace "not the best language" with "largely irrelevant" if you want
to retain the strength of your original conclusion.)

My own feeling is that we simply don't *have* a true object-oriented
language that is also appropriate for large systems.  Might be a neat
thing to work on, though ...

greg
--
--------------------------------------------------------------
Greg Titus (gbt@zia.cray.com)             Compiler Group (Ada)
Cray Research, Inc.                               Santa Fe, NM
Opinions expressed herein (such as they are) are purely my own.

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

[Jim Showalter]

Our story thus far:

>>>I won't argue the point that Ada is far superior when it comes to large system
>>>development. This is a fact, plain and simple, and C++ cannot hold a candle
>>>to Ada's abilities to decompose a problem into managable pieces and insure
>>>the consistency between them. However, Ada is not all things to all programming
>>>tasks, and one of the things it isn't is an object oriented programming
>>>language.
>>
>>From the above paragraph, we have these two statements:
>>
>>1) Ada is a superior language for engineering large complex systems.
>>2) Ada is not particularly supportive of OOP.
>>
>>These two statements lead to the following conclusion:
>>
>>3) OOP is largely irrelevant when it comes to engineering large complex systems.

>I don't see that, Jim.  I'd replace your 3) with "Ada is not the best
>language when it comes to engineering large complex OO systems."
>(Replace "not the best language" with "largely irrelevant" if you want
>to retain the strength of your original conclusion.)

Well, I may have overstated the case. Taking a page from the Get Smart
show, WOULD YOU BELIEVE: "3) OOP _may_ be largely irrelevant when it comes
to engineering large complex systems."? I think I can support this one
pretty easily: we have already established from 1) above that Ada is
a superior language for engineering large complex systems, and from 2)
we admit that Ada is not an OOP language [at least not in the classic
sense of the term], and so we have the apparent paradox of large
complex systems being superiorly engineered using a non-OOP language.
This certainly makes ME suspect that OOP must not be particularly
important when it comes to engineering large complex systems.

>My own feeling is that we simply don't *have* a true object-oriented
>language that is also appropriate for large systems.

Ah, okay--this changes things considerably. What you (I THINK) are
claiming is that IF there were a true object-oriented language that was also
appropriate for engineering large systems, then it would be a better
tool to use for such engineering than Ada but that, in the absence of
such a beast, Ada wins by default. Or am I completely lost (wouldn't
be the first time...).

>Might be a neat
>thing to work on, though ...

You could ask the Ada 9x people how neat they think things have been
for them. ;-)
-- 
**************** 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++.    *

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

[Greg Titus]

In article <1991Jun1.044011.29894@netcom.COM> jls@netcom.COM (Jim Showalter) writes:
>
> ... [a lot of stuff we've all seen already]
>
>Well, I may have overstated the case. Taking a page from the Get Smart
>show, WOULD YOU BELIEVE: "3) OOP _may_ be largely irrelevant when it comes
>to engineering large complex systems."?  ...

You betcha.


>
> [I (gbt) said]
>>My own feeling is that we simply don't *have* a true object-oriented
>>language that is also appropriate for large systems.
>
>Ah, okay--this changes things considerably. What you (I THINK) are
>claiming is that IF there were a true object-oriented language that was also
>appropriate for engineering large systems, then it would be a better
>tool to use for such engineering than Ada but that, in the absence of
>such a beast, Ada wins by default. Or am I completely lost (wouldn't
>be the first time...).

That's it exactly.  The usefulness of a language for large systems is
based on its ability to represent a relatively clean homomorphism of the
designer's favorite decomposition of the data structures and activities
in the solution.  The decomposition is the primary thing.  The question
of whether the objects or the activites are more important is far less
important, to my mind.


>
>>Might be a neat
>>thing to work on, though ...
>
>You could ask the Ada 9x people how neat they think things have been
>for them. ;-)

Perhaps I should have emphasized the "might".   ;-)   They are somewhat
constrained, I'm afraid.

greg
--
--------------------------------------------------------------
Greg Titus (gbt@zia.cray.com)             Compiler Group (Ada)
Cray Research, Inc.                               Santa Fe, NM
Opinions expressed herein (such as they are) are purely my own.

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

[Douglas Miller]

In article <085657.19195@timbuk.cray.com>, gbt@sequoia.cray.com (Greg Titus) writes:

> In article <1991May30.004144.24252@netcom.COM> jls@netcom.COM (Jim
> Showalter) writes:
>> [Somebody else writes:]
>>>I won't argue the point that Ada is far superior when it comes to large system
>>>development. This is a fact, plain and simple, and C++ cannot hold a candle
>>>to Ada's abilities to decompose a problem into managable pieces and insure
>>>the consistency between them. However, Ada is not all things to all programming
>>>tasks, and one of the things it isn't is an object oriented programming
>>>language.
>>
>>From the above paragraph, we have these two statements:
>>
>>1) Ada is a superior language for engineering large complex systems.
>>2) Ada is not particularly supportive of OOP.
>>
>>These two statements lead to the following conclusion:
>>
>>3) OOP is largely irrelevant when it comes to engineering large complex systems.
>>
>>Now, far be it from me to actually MAKE this claim [;-)], I'm merely
>>pointing out that it is the inevitable subtext of the above paragraph.
> 
> I don't see that, Jim.  I'd replace your 3) with "Ada is not the best
> language when it comes to engineering large complex OO systems."

What is a "large complex OO system", as opposed to a large complex system
developed useing OO?  You appear to be assuming what Jim has asked to be
shown.

> My own feeling is that we simply don't *have* a true object-oriented
> language that is also appropriate for large systems.  Might be a neat
> thing to work on, though ...

You have definitely missed the point.  Jim want to know how useful "true"
OO features (inheritance et al) are to large-scale development as compared
with those boring old OO features (static data abstraction et al).  So do
I.  Does anyone have any evidence one way or the other?

--
Douglas Miller <douglas.miller@viccol.edu.au>
Phone:     +61 3 805 3262      Fax: +61 3 808 9497
Post:      Computer Services, Victoria College, BURWOOD 3125, AUSTRALIA
Location:  Building A, 221 Burwood Highway, Burwood, Victoria, Australia 

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

[David T. Lindsley]

Ada is not an OOPL in the classic sense, no.  But Ada does allow and
in fact encourage object-oriented _design_.  Encapsulation (packages),
information hiding (private types), etc., are part of OOD (and OOPLs).

In other words, many of the things that make Ada suitable for working
with/on large, complex systems are those object-oriented techniques which
the language _does_ support.  Given this, I find the statement that OO
(analysis? design? programming? all three?) are "largely irrelevant" 
to the development of large, complex systems somewhat hard to swallow.

This doesn't mean that I believe C++ or Smalltalk (or any of the other
OOPLs) to be superior to Ada in the production of large systems.  The
final word on OO{whatever} isn't in yet (IMHO) -- I await the judgment
of history on that score...

-- 
Dave Lindsley	#24601#					   OPINIONS. MINE. 
dlindsle@blackbird.afit.af.mil		(The words don't come no smaller.)
			?? lamroN eb yhW ??

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

[Jim Showalter]

>Ada is not an OOPL in the classic sense, no.  But Ada does allow and
>in fact encourage object-oriented _design_.  Encapsulation (packages),
>information hiding (private types), etc., are part of OOD (and OOPLs).

>In other words, many of the things that make Ada suitable for working
>with/on large, complex systems are those object-oriented techniques which
>the language _does_ support.  Given this, I find the statement that OO
>(analysis? design? programming? all three?) are "largely irrelevant" 
>to the development of large, complex systems somewhat hard to swallow.

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.

I'm STILL waiting for someone who has actually completed a large complex
system using pure OO to speak up.
-- 
**************** 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++.    *

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

[Larry Carroll]

The most impressive aspect of C++, as reported by a group of programmers
(most of them Fortran & C users) here who were forced to learn & use it for a
task last year, was inheritance.  With careful attention to design, they 
were able to re-use a lot of their own code, & re-design it quickly when 
needed.

Re: OOP and large systems.

[Larry Baker]

 larryc@puente.jpl.nasa.gov (Larry Carroll) writes:
|> The most impressive aspect of C++, as reported by a group of programmers
|> (most of them Fortran & C users) here who were forced to learn & use it for a
|> task last year, was inheritance.  With careful attention to design, they 
|> were able to re-use a lot of their own code, & re-design it quickly when 
|> needed.

We use C++, and there are several people here (myself included) with Ada
backgrounds, who would add to the above observation: Dynamic Binding has,
for us, been a very significant added benefit.  The combination of DB and
Inheritance is a very, very powerful mechanism.
--
Larry Baker
NEC America C&C Software Laboratories, Irving (near Dallas), TX
baker@csl.dl.nec.com  cs.utexas.edu!necssd!baker

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

[Robert I. Eachus]

In article <1991Jun04.185632.18204@afit.af.mil> dlindsle@afit.af.mil (David T. Lindsley) writes:

   Ada is not an OOPL in the classic sense, no.  But Ada does allow and
   in fact encourage object-oriented _design_.  Encapsulation (packages),
   information hiding (private types), etc., are part of OOD (and OOPLs)...

     Hmmm. In Ada you can (and most software engineers do) use OO
DESIGN methods.  However, the properties of the language are such that
it is very difficult to modify data abstractions in unintended ways.
In the AI field, I have seen lots of Smalltalk, LISP, Scheme, LOOPS,
etc. systems which, like Topsy, just growed.  The lack of information
hiding and isolation of abstractions makes violations of any original
design easy in most "pure" OO PROGRAMMING environments.  And in most
of the OOP systems I have seen not only are these violations notable
by their presence, they make any maintenance a nightmare.

     I think that the ability we have to hide data abstractions in Ada
is precious, and any attempt to break that barrier to permit "pure"
OO programming in Ada is misguided.

     (Flame Retardant:  I am very much in favor of OO extensions in
Ada 9X, we just need to be very careful not to break more important
Ada properties.)
--

					Robert I. Eachus

with STANDARD_DISCLAIMER;
use  STANDARD_DISCLAIMER;
function MESSAGE (TEXT: in CLEVER_IDEAS) return BETTER_IDEAS is...