Re: Surprise in array concatenation

[<adaworks@sbcglobal.net>]

"Jeffrey Carter" <spam@spam.com> wrote in message
news:B2_Te.5$oo1.2@dfw-service2.ext.ray.com...
> adaworks@sbcglobal.net wrote:
> >
> > Enumerated types, as presently designed, are not extensible.  They
> > do no encapsulate their operations, and new operations, though
> > they can be added, do not bind in a way that conforms to conventional
> > OO design principles.
>
> So? Ada types should not be a consideration during design. Once your
> have your design, you decide how to implement it. If enumerated types
> are not suitable, don't use them.
>
It is not a matter of suitable or not.   Rather, it is a concern that enumerated
types can compromise a design unless one thinks carefully about their
long-term effects within that design.

> Your compiler implements your design in machine code, which has no
> extension mechanisms. Should that affect your design?
>
We typically do not extend instances.  Extensibility is at a different
level of abstraction.  Even if Ada were compiled to an intermediate
byte code, as is the case with Java, extensibility would stillbe at
the source code level on classes, not instances.

In reply to Dr. Rosen, you are correct in your observation that Ada
does not force a design paradigm on its users.   However, there is
a difference between being required to use a particular paradigm
and being able to use one's preferred paradigm.   When enumerated
types are extensible, one can choose OOP, or not.  Java, for
example, has a "final" option to make this choice feasible.

I certainly do not suggest using Java instead of Ada. Java falls short
of what we would want for reliable computing in large-scale
software systems, but we can learn from other languages, even
when those languages have inherent shortcomings.

Richard Riehle