Re: Side-effect arithmetic again [was: Ada ... in embedded systems]

[bobduff@world.std.com (Robert A Duff)]

In article <4jkfpj$jl1@dayuc.dayton.saic.com>,
John G. Volan  <John_Volan@ccmail.dayton.saic.com> wrote:
>...but (2) not
>everyone who is involved in the development of software is necessarily
>a professional programmer that's doing the actual coding. IMHO, the
>fewer obstacles to understanding we put in the way of these associated
>folks, the better things will be all around.  But perhaps that's a
>minor point.

OK, fair enough.  Perhaps I shoudn't have been so strident in my earlier
post.  But let's not go from the above, to trying to sell Ada by saying
it's so "self documenting" that anybody can understand it.

>Oh, I don't think it's as bad as all that.  Instantiating a generic
>isn't all _that_ big a deal, and for beginners it can simply be an
>incantation that they can come to understand later.  But perhaps you
>have a point that something as "simple" as side-effect arithmetic
>shouldn't warrant a generic -- but where do you draw the line at
>"simple"?  Is I/O too "simple" to warrant having to instantiate
>Text_IO's generic subpackages; should we have had something analogous
>to printf instead?

Well, I don't know.  It *is* a problem for teaching Ada, to have to
introduce generic instantiations very early.  It's true that you can
just tell the beginner to type some magic incantation, and that's what
everybody does, but it makes the beginner uncomfortable.  The beginner
wants to understand everything in the program.

I wouldn't advocate printf, though -- it is inherently type unsafe.
Other solutions are possible.

Of course, Ada 95 has predefined instantiations for type Integer and so
forth.  And there's always 'Image.

>...Is deallocating a heap object too "simple" to
>warrant having to instantiate Unchecked_Deallocation, or should we have
>had a built-in free or delete operation?

No, I don't think so.

>... Is breaking the strong typing
>system when you need to too "simple" to warrant having to instantiate
>Unchecked_Conversion, or should Ada have just allowed arbitrary type
>conversions?

No, certainly not.

>Yes, that's a good technique, one that I've actually used in my own
>code, now that I think about it.  More people should realize that any
>sort of type, even scalar types, can be endowed with new _primitive_
>subprograms which can be _inherited_ by derived types.  This was true
>even in Ada83.  For all that Ada83 was branded as an "object based"
>language, but not an "object oriented" language, people should give
>Ada83 credit for actually having _inheritance_, even though it didn't
>have Ada95's mechanisms for type-extension and classwide polymorphism.

The "brand" was pretty fair, since polymorphism is pretty important.

- Bob