Re: An observation of Ada (may offend)

[nebbe@lglsun.epfl.ch (Robb Nebbe)]

In article <3kcflv$164a@watnews1.watson.ibm.com>, ncohen@watson.ibm.com (Norman H. Cohen) writes:


|> If there is a weakness in Ada encapsulation, it has nothing to do with
|> parameter lists, but with the definition of "logically within the
|> defining unit".  Anyone can write a child package that is "logically
|> within the defining unit".  (Do-While Jones once called this the "Howard
|> Hughes effect": strangers claiming to be your heirs.)  Child units enjoy
|> access analogous to that permitted for C++ protected members in a
|> subclass of a definining class.  Thus the strongest degree of hiding that
|> Ada can provide is that of C++ "protected", not C++ "private".

Hiding is an all or nothing proposition; either something is hidden or
it isn't there is no "sort of hidden".

Now you can differentiate the information hiding facilities of different
langauges based in granularity, flexability, simplicity etc. IMHO "Protected"
is a quirk of C++ stemming from the lack of orthogonality between modules
and types. In other words you wind up compensating for the simplicity of the
type=module approach by increasing the levels of visibility or adding
features like nested classes and friend functions.

It isn't at all clear that "protected" is desirable in a language.

In Ada you can use whatever amount of information hiding you want through
the various uses of packages and types. In general this can be accomplished
by using child packages to provide specialized interfaces and allowing the
client to choose what they need to see. In other languages the progammer
is often required to forsee all possible uses of the abstraction or resort
to complicated schemes using multiple inheritance to increase the
flexibility of the solution.

Robb Nebbe