Re: Is Ada the future? [was: Is C++ the future?]

[Robb.Nebbe@di.epfl.ch (Robb Nebbe)]

val@cs.weber.edu (Val Kartchner) writes:

|> I have also been reading about Ada 9X.  In the booklet "Introducing Ada
|> 9X", Section 2.7, "Hierarchical Libraries", pp 20-23 and Section 2.8,
|> "Private Child Units", pp. 24-26 have text and code examples which
|> demonstrate these secion summaries (in the report's own words):
|> 
|>    The important special visibility rule is that the private part (if any)
|>    and the body of the child have visibility of the private part of their
|>    parent.
|> 
|>    The private part and body of any child can access the private part of
|>    its parent (and grandparent...).
|> 
|> Unless there is some subtlty that I've missed in the pages of *both* text
|> and code, all that one has to do to get access to the private datatypes
|> is to declare a child package.  (Note: this doesn't include renaming of
|> private interfaces, but does allow the foreign child to call private
|> interfaces and thereby effectively rename a private interface.)
|> 
|> Would an Ada programmer /ever/ knowingly defeat the intent of the package
|> interface and do this?  No, I don't think so.  Do you?  :-S

One way to think of child packages is that they are equivalent (not
exactly but close) to nested packages except you get the benefit of
separate compilation. I believe the intent is that a module may be
extended without disturbing the parent or to provide special interfaces
for certain clients.

As long as you express what you are doing clearly in the code a
language really shouldn't get in your way. (Ada83 is guilty of this)
This is quite different than the language doing things implicitly
that you didn't ask it to do. The is no way to accidently gain
visibility of the private part of a package and as you said you
cannot accidently make any private declarations visible in the
public part of the child.

- Robb Nebbe