Re: Ada vs C++, Franz Lisp to the rescue?

Re: Ada vs C++, Franz Lisp to the rescue?

[Chuck Shotton]

> The reason I tend to focus primarily on C++ vs Ada is that C++ is
> becoming a de facto OO standard at a distressingly rapid pace and,
> as such, represents what I think is the single largest competition
> to Ada in cutting-edge OO and software engineering in the commercial
> sector. Seeing as how it is my personal vision that Ada be used to
> build lots and lots of large complex systems that have nothing to
> do with the government sector, I'm committed to offering a credible
> rebuttal to C++ whenever and wherever possible. It's not that it is
> impossible to engineer a complex system in C++, it's just that Ada
> is at least equally capable of doing so, and is a far more mature
> and robust option, so why not use it?> -- 
> **************** JIM SHOWALTER, jls@netcom.com, (408) 243-0630 ****************

I think the single, most important reason that C++ is overtaking Ada as the
OO language of choice is the very thing that makes Ada the DoD choice. Ada's
extreme standards process works to its detriment in introducing new changes
to the language. C++ came out of nowhere, without any of the bureaucratic
nightmares levied on Ada. A few, innovative people added REAL object oriented
extensions to C and tossed it on the market. Ada 9X may very well turn into
Ada 20X by the time any compilers hit the street.

Let me say that I am in no way a supporter of C++, nor a detractor of Ada.
(I've worked on the Space Station program for the past 4 years and done nothing
but Ada development.) However, C++'s support for object-oriented pardigms
such as inheritance, true methods, and dynamic binding are much closer to
"true" OO development than the work-arounds that Ada supports. You can hardly
argue that a generic or a task type can completely substitute for a true class
definition with instance variables, methods, and inheritance. Ada requires
too much of a burden to be placed on coding conventions and programming style
and provides too little support for "objects" in its current state to be 
considered a "real" object-oriented language. There's just no adequate support 
inherent in the languge.

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.
Information hiding, strong typing, and generics does not an OOP make. Maybe
when Ada 9X's support for procedures as arguments, etc. becomes available,
this comparison between C++ and Ada as OOPs will be a little more on target. 
But until then, there is no comparison. Defending Ada, tooth and nail, on
EVERY application is a no-win situation. Ada CAN'T do some things as well
as other languages.

-----------------------------------------------------------------------
Chuck Shotton                 Internet:   cshotton@girch1.med.uth.tmc.edu
"Your silly quote here."      UUCP:       ...!buster!brain

Re: Ada vs C++, Franz Lisp to the rescue?

[Jim Showalter]

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

Given that this claim has been made, I'm interested to see what sorts of
real-world data can be used to support or refute it. I keep hearing that
OO this and OO that are going to solve the software crisis and feed all
the world's children (much like structured programming was going to do
20 years ago...), but where is the DATA? How many practitioners of so-called
"pure" OO out there in net-land have success stories to tell about projects
on the order of 250KSLOC on up, preferably doing something difficult like
real-time process control or heterogeneous/distributed computing? And
the second, perhaps more important question I have is: on such projects,
to what degree did OO truly play a role (how much of the code was based
on inheritance and polymorphism, etc) vs more traditional programming
idioms?

I volunteer to provide success stories for similar projects successfully
completed NOT using "pure" OOP (data encapsulation and information hiding
were certainly used, but inheritance and polymorphism were not).
-- 
**************** 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++.    *

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