Re: problem with abstract types

["Robert I. Eachus" <rieachus@attbi.com>]

Robert A Duff wrote:

> Right, but if the code can't figure out the Tag of Reg when it is
> created, or if the Tag changes over time, then Reg will have to be of
> an access-to-Registry'Class type.  But that does not imply that all
> the operations need to take access parameters.  They can take Registry
> parameters, and you would then pass Reg.all as the actual parameter.

Bob, this is at best overkill in this case.  I can imagine a situation 
where you might want to copy data from one type of registry to another 
that would require having two open registries with different tags.  But 
even in that case, you have as an invariant that every object of type 
registry has a single tag value, and it must be determinable when the 
registry is opened.  Open registries morphing their types underneath a 
program boggles the mind.

I guess that there is a meta-rule here.  To paraphrase Einstein, "The 
user view of a data structure should be as simple as possible, but no 
simpler."  ;-) The "extra" work the implementor of an abstraction may 
have to accept to keep the visible abstraction simple is just good 
software engineering.

Ada goes to a lot of hard work to allow simple abstractions to be 
implemented with little or no run-time overhead.  In this particular 
case, the compiler might generate better code for the case with a 
classwide variable initialized at open than for an access to classwide 
type varible.  But I don't see that "savings" as the real reason for 
implementing an abstraction correctly.  The real benefit is that the 
user of the abstraction doesn't have to sweat the details if the 
abstraction is a good match to "reality," whatever that means to the 
user of the abstraction.

For example, if you are writing avionics software, "this aircraft" is an 
implicit constant.  Some of its attributes, such as weight or current 
airspeed may change, but avionics software does not expect to find 
itself in a new aircraft during flight.  If you are working on air 
traffic control software, "this aircraft" is a variable, and in fact, 
you even have to change the type of aircraft associated with a 
particular track.  (Mostly from unknown to a particular class, but that 
is a detail.)