From mboxrd@z Thu Jan  1 00:00:00 1970
X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me
X-Spam-Level: 
X-Spam-Status: No, score=-1.3 required=5.0 tests=BAYES_00,INVALID_MSGID
	autolearn=no autolearn_force=no version=3.4.4
X-Google-Language: ENGLISH,ASCII-7-bit
X-Google-Thread: 103376,63a41ccea0fc803a
X-Google-Attributes: gid103376,public
From: dewar@merv.cs.nyu.edu (Robert Dewar)
Subject: Re: Naming of Tagged Types and Associated Packages
Date: 1998/07/26
Message-ID: <dewar.901492388@merv>#1/1
X-Deja-AN: 375136703
References: <ur9zlv6tx.fsf@sandia.SPAMFREE.gov>
 <m34sw6mcbx.fsf@mheaney.ni.net> <6pdhfo$1br$1@platane.wanadoo.fr>
 <m367gl943o.fsf@mheaney.ni.net> <6petet$hff@drn.newsguy.com>
X-Complaints-To: usenet@news.nyu.edu
X-Trace: news.nyu.edu 901492594 19793 (None) 128.122.140.58
Organization: New York University
Newsgroups: comp.lang.ada
Date: 1998-07-26T00:00:00+00:00
List-Id: <comp.lang.ada>

Nasser said

<<abstraction, data hiding, sepration of interfaces and implementaions, strong
typing, generics, good exception, good build-in tasking model, and all
that good stuff is good enough for me. If I want to do heavy/pure
OO stuff, I would not use Ada, just becuase I am not used to the OO
ways of Ada, it just too different from all the other OO languages
out there (different in how its OO features are reprsented offcourse,
 the semactics are the same, but language representation (lexical
structure) is very important I think becuase it affect how one thinks
 and visualize things), and in that the class structure is more natural than
tagged records + procedures that takes paramters or returns paramters
of types of that record.
>>

Note that in the above, you note that you are not used to the OO ways of
Ada, and then go on to make some comments that really would only ve valid
if you *did* have the necessary familiarity. In fact once you know these
features well, and are "use" to them, you will find that (a) they are quite
natural to use, and (b) it is rather trivial to make the syntactic 
transition for cases where there is a direct correspondence. Of course
in the cases where there is NOT a direct correspondence (e.g. the built
in MI in C++, or the generalization of multiple arguments and return types
for dispatching in Ada), then the transition is of course harder.

Actually there are many "pure" OO abstractions for which the Ada approach,
which avoids the nasty binary operator problem in C++ is very much more
straightforward.