Path: utzoo!attcan!uunet!ncrlnk!ncrcae!hubcap!gatech!mcnc!thorin!pooh!coggins
From: coggins@pooh.cs.unc.edu (Dr. James Coggins)
Newsgroups: comp.lang.c++
Subject: Re: C++, Objectivce-C and projects..
Message-ID: <5263@thorin.cs.unc.edu>
Date: 11 Nov 88 19:03:40 GMT
References: <5155@thorin.cs.unc.edu> <6639@spool.cs.wisc.edu>
Sender: news@thorin.cs.unc.edu
Reply-To: coggins@cs.unc.edu (Dr. James Coggins)
Organization: University Of North Carolina, Chapel Hill
Lines: 56

In article <6639@spool.cs.wisc.edu> dcmartin@cheddar.cs.wisc.edu (David C. Martin) writes:
>In article <5155@thorin.cs.unc.edu> (Dr. James Coggins) writes:
>
>>Now for the leap...
>>
>>4. The Smalltalk-like languages will be the better tools for large
>>software development because item #1 above will kick in to make the
>>project more manageable. 
>>
>>Opinions?
>
>I have been reading this newgroup for sometime and with this posting
>finally saw something with which I agreed.

Good. (But note that in this discussion I'm not "selling" anything -
I'm really trolling for ideas.)

>In essence,
>C++ appears to be an ADT language w/ some support for OO-like inheritence,
>but that is about it.
>
>However, I *like* C++ for building ADTs!  Perhaps, someday, I will even
>use C++ to build a real OOPS.

This is an interesting comment since the (in-person) discussion that
led to my original posting arrived at a concensus that C++ classes are
NOT ADTs and that Smalltalk classes are closer to ADTs.

(an ADT consists of data, procedures, and axioms that define consistent
states of the structure.  Most discussions and all implementations forget
about the axioms.)

More specifically, my colleague's assertion was that the ABSTRACTION in
the ADT is in Smalltalk-like OO languages more thoroughly divorced from
implementation than in Simula-like languages.  That is, a C++ class is
intimately bound to its implementation, therefore in order to reuse
any code between projects and people, the reuser must buy into the
abstraction produced by the author AND into the implementation and
realization baggage the author produced.  It is the latter stuff that
kills most potential opportunities for extensive, small-granularity
code reuse.  His assertion was that the increased independence between
specification and implementation available in Smalltalk-like OO
languages would yield greater benefits in very large systems because
the reuser could switch implementation/realizations more easily if
required. 

Maybe we see here the beginning of a new paradigm that will be the
"structured programming of the '90's" as OOP is the "SP of the '80's"?

---------------------------------------------------------------------
Dr. James M. Coggins          coggins@cs.unc.edu
Computer Science Department   "Make it in Massachusetts" - ad slogan
UNC-Chapel Hill               "I made it OUT of Massachusetts"
Chapel Hill, NC 27514-3175                - my slogan
---------------------------------------------------------------------