Re: on package naming, should the word

[Jeffrey Carter <jeffrey.carter@boeing.com>]

"Robert*@" wrote:
> 
> In article <%DHy7.30147$ev2.37198@www.newsranger.com>, Ted says...
> >
> >The way I was taught it, an "object" consists of a data type, together with the
> >operations on that type. Since a package is one means of encapsulating both
> >those things into one concept, it can indeed be considered an "object".
> >
> 
> If you "think" of a package as an object, then what do you "think" of
> when you think about the tagged record inside the package?
> 
> An object inside an object?

Package-as-Object refers to a package with only subprograms visible,
with the data storage in the package body. This defines an ASM.

A package with a type declaration and operations on the type defines an
ADT.

> 
> What do you see when you think of an array of object? an array of packages?

An object is an ASM or an instance of an ADT. An array of objects must
be an array of instances of an ADT.

Part of the confusion stems from 2 meanings for "type". In Ada, "type"
is used for defining a set of values.

For at least 30 years, the term "type" has been defined in S/W
engineering to mean a set of values and the operations on those values,
preferably encapsulated together, with a nice interface and unnecessary
information hidden. The result is an ADT.

In many languages, the Class construct provides all this. In many of
those languages, the Class construct is the only construct to provide
encapsulation and information hiding.

In Ada, there is separation of concerns. Type declarations define sets
of values, subprograms define operations on sets of values, and packages
provide encapsulation, information hiding, and modularity. Thus, the
combination of a type declaration and subprograms operating on that
type, encapsulated in a package, defines an ADT. Since not everything
that needs encapsulation and information hiding defines an ADT, and not
all types need to be ADTs, the separation of concerns allows all these
kinds of things.

If an ADT definition contains a tagged type, then the ADT is extensible
and calls to its operations may be dispatching. When extensibility is
not required, the ADT may contain a non-tagged type.

Those who do not recognize the special status packages have in Ada will
find themselves fighting the language. In a similar manner, those who do
not recognize the special status classes have in C++ will not understand
the idiom of using a class to obtain encapsulation and information
hiding, even though an ADT is not needed.

-- 
Jeffrey Carter