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

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

[SAHARBAUGH]

I have read with interest the BB conversations about Ada vs C++.
I received by mail an advertisement for Franz Lisp. It says, among other things:
"if you're trying to develop complicated
applications with C++, you're working too
hard. It's a good introduction to object-
oriented programming, but it doesn't have
the built-in functionality of the world's
most advanced OOP tool: Allegro CL Common
Lisp with CLOS."  It goes on to mention
Multiple inheritance, custom facilities,
persistent storage, object-oriented 
databases, dynamic redefinition of classess
and methods, generic functions and says
"(it) is the most powerful object-oriented 
programming language available today."

Vendors are expected to overstate the worth
of their product, the legal term is "puffing",
BUT are we missing something by not discussing
Franz Lisp in the same context as C++ when
discussing the "vs Ada" language issue?

sam harbaugh saharbaugh@ROO.FIT.EDU        
-----------

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

[Jim Showalter]

>Vendors are expected to overstate the worth
>of their product, the legal term is "puffing",
>BUT are we missing something by not discussing
>Franz Lisp in the same context as C++ when
>discussing the "vs Ada" language issue?

There are a number of OO languages that are "purer" than C++. That's
been one of the criticisms leveled at C++, in fact: that in order
to maintain compatibility with C a lot of compromises had to be made
that aren't necessary in a from-scratch language design (such as
Eiffel and, probably, Franz Lisp).

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 ****************
*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: 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++.    *

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

[Ted Holden]

In article <9105211321.AA05681@ajpo.sei.cmu.edu> SAHARBAUGH@ROO.FIT.EDU writes:

>Vendors are expected to overstate the worth
>of their product, the legal term is "puffing",
>BUT are we missing something by not discussing
>Franz Lisp in the same context as C++ when
>discussing the "vs Ada" language issue?
>sam harbaugh saharbaugh@ROO.FIT.EDU        

You're not missing much.  Franz Lisp does not include the low-level
power and flexibility of C/C++, the immediate handles into every kind of
UNIX functionality, the immediate applicability of every new development
in the industry...  A lot of the discussion revolves around the phrase
"reusability of code".  The best book available on the topic is the
Programmer's Connection catalog, the most major catalog for
programmer/developer/designer tools in the mini/micro world.  You'll
find about a fifth to a half a column's worth of aftermarket stuff
available for each of the other languages, and several whole pages for
C, such is the dominance of C/C++ in America's market at present.  
Future medium-large systems will be parallel machines made from these
same microchips, and will be programmed with similar software.  C++ is
the best compromise available for the next ten years or so.  LISP may 
or may not be a better language if you could confine yourself to one
platform and one class of programs to write forever, but life isn't
like that.

Ted Holden
HTE

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

[Chuck Shotton]

In article <1991May30.004144.24252@netcom.COM>, jls@netcom.COM (Jim Showalter) 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.
> 

First, the only point being made in 1 and 2 above is that Ada is well suited
to supporting the decomposition of systems into manageable pieces, and it
doesn't provide the same level of SYNTACTIC support for OOP as other professed
OOP languages. Don't put words in my mouth. The third conclusion is simply
a faulty conclusion from the intent of the first 2.

I'd like YOU to explain to netland how to support dynamic inheritance at 
runtime in Ada without resorting to manually-supported coding conventions.

I've had a direct hand in the management, design, and implementation of about
250,000 lines of Ada over the past 2 or 3 years on NASA's SSE contract. We
used OOD techniques such as Buhr diagraming, etc. and coded according to the
design. BUT THAT DOESN'T MAKE THE CODE OBJECT ORIENTED.

The whole point of the comparison between C++ and Ada hinges on the semantic
interpretation of the term "object-oriented." To most Ada-literate individuals,
"object-oriented" refers to the concepts of information hiding and specific
design methodologies. To others (C++, academia, etc.) "object-oriented" connotes
message passing, inheritance, dynamic binding, methods, classes, etc. Ada
does NOT provide direct support via language constructs and run-time behavior
to support all of these concepts. The burden is placed on the programmer to
implement "message passing" and there is no way to safely (consistenly) implement
dynamic binding.

Rather than degenerate into a "mine's bigger than yours" comparison of two
vastly different languages (and programming paradigms), it would be more 
constructive to discuss how to implement TRUE object-oriented features within
the current limitations of Ada. I'd be interested in hearing suggestions for
supporting the aforementioned list of "alleged" object oriented language features
using plain vanilla Ada. This could actually be useful on some real projects.

-----------------------------------------------------------------------
Chuck Shotton                 Internet:   cshotton@girch1.med.uth.tmc.edu

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: Ada vs C++, Franz Lisp to the rescue?

[Jim Showalter]

chuck@brain.UUCP (Chuck Shotton) first wrote:
>> >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.

I [jls@netcom.com (Jim Showalter)] then responded that the obvious conclusion
to be drawn from the above paragraph was that OO is apparently basically
irrelevant to developing large systems.

chuck@brain.UUCP (Chuck Shotten) then responded:

>First, the only point being made in 1 and 2 above is that Ada is well suited
>to supporting the decomposition of systems into manageable pieces, and it
>doesn't provide the same level of SYNTACTIC support for OOP as other professed
>OOP languages.

Chuck, let me try again. When I read the first paragraph above, what I hear
is "Ada is far superior to C++ for large system development" AND "Ada is
not an object oriented programming language". Correct me if I'm wrong,
but don't these two statements in conjunction essentially say "Ada,
which is not an object oriented programming language, is nevertheless
far superior to C++ for large system development"? If so, why do you
deem it unreasonable for me to go one step further and conclude "The
usefulness of the 'pure' OO paradigm for actually building large systems
may well be overstated" (a conclusion I came to years ago)? I'm reading
the same text you're writing--please help me to understand why we are
in such disagreement.

>I'd like YOU to explain to netland how to support dynamic inheritance at 
>runtime in Ada without resorting to manually-supported coding conventions.

I never claimed that Ada was a so-called "pure" object-oriented language;
not surprisingly, what you describe above is hard to do in Ada. What I
HAVE claimed, repeatedly, is that this is in all likelyhood not much
of a deficit, particularly since what CAN be done and HAS been done in
Ada is stuff like building, on time and on budget, mega-SLOC distributed
real-time systems that meet all of their performance requirements (can
you make similar claims for any of the predominant "pure" OO 
languages?--this is not a flame: I'm honestly asking if anybody can
supply similar success stories for significant projects written in
C++, Smalltalk, Eiffel, etc [I asked a similar question a week or
so ago, and have so far received no responses]).

I have long believed that the most significant payoff from
using an OO language was in its general support for ABSTRACTION (e.g. narrow
interfaces, hidden data, etc), not in its specific support for inheritance and
polymorphism. Focusing on interfaces and design, suppressing inessential
details, and enforcing it all through the compiler is the big win that
gets you 90% (or more) of the way toward a well-engineered system. Support
for inheritance is just icing on the cake. Don't believe me? Consider, then,
a new language, C++--. This language retains the support for inheritance
and polymorphism offered by the current C++ language, but it is defined in
such a way that the .h files cease to exist, as do the notions of private
and protected data. Now, you tell me--what would be the relative usefulness
of this hypothetical language in comparison to, say, Ada, which HAS private
data and a spec notion analogous to C++'s .h files? I think
the answer is obvious--as soon as the support for abstraction capture and
enforcement is removed, the remaining benefits of the language are minimal,
even though what remains supports inheritance, dynamic binding, and all
that jazz.

I'm not saying that inheritance is useLESS, just that we should strive to
assign accurate relative weights to the various language features, and
first concentrate on getting the MOST useful features across to the widest
possible audience. To run off trying to spread the gospel about the wonders
of multiple inheritance in an industry where I have actually heard a well-
paid developer at a Large American Corporation ask (in all honesty): "What
is an interface?" seems to me to be a misguided expenditure of energy and
time.

>The whole point of the comparison between C++ and Ada hinges on the semantic
>interpretation of the term "object-oriented." To most Ada-literate individuals,
>"object-oriented" refers to the concepts of information hiding and specific
>design methodologies. To others (C++, academia, etc.) "object-oriented" connotes
>message passing, inheritance, dynamic binding, methods, classes, etc. Ada
>does NOT provide direct support via language constructs and run-time behavior
>to support all of these concepts. The burden is placed on the programmer to
>implement "message passing" and there is no way to safely (consistenly) implement
>dynamic binding.

And the burden is placed on the OO academic to demonstrate that any of this
is of any use in building real systems. It is probably a good idea to keep
in mind that the entire industry is NOT yet convinced that the OO paradigm
is the One True Way, that there are horror stories of projects going terribly
awry by embracing too uncritically the whole OO sales pitch (things, for
example, sometimes run too slowly to meet the original requirements...),
that there is some evidence of a growing backlash against OO because it
has turned out in at least some cases to have been oversold (as is the
way with most One True Ways), and so forth. Just because a cause generates
a lot of press and a lot of true believers doesn't make it RIGHT. It has
been my observation that OO fervor needs to be tempered with pragmatism
based on real-world experience, or it leads to disappointment.

>Rather than degenerate into a "mine's bigger than yours" comparison of two
>vastly different languages (and programming paradigms), it would be more 
>constructive to discuss how to implement TRUE object-oriented features within
>the current limitations of Ada. I'd be interested in hearing suggestions for
>supporting the aforementioned list of "alleged" object oriented language features
>using plain vanilla Ada. This could actually be useful on some real projects.

I believe there are several pre-processors available for Ada that add these
very features to the language at relatively low cost. I've never felt the
need for such features, so I've never looked into what these pre-processors
actually do, but I've heard that they're pretty useful.
-- 
**************** 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++, ...)

[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++, ...)

[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++, ...)

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