Re: Beware: Rep spec on an enumeration type ...

[gwinn@res.ray.com (Joe Gwinn)]

In article <dewar.881903209@merv>, dewar@merv.cs.nyu.edu (Robert Dewar) wrote:

> I actually think that more important than whether glitches exist is the
> support a vendor gives in helping you find and fix glitches. To me, one
> of the nice things about the specific discussion of enumeration types was
> the note from Intermetrics that the next version of the compiler would
> indeed fix the failure to recognize the confirming rep clause as a special
> case. It's that kind of responsiveness that users really need, and in this
> case will get.

Support after the blunder is very nice, but it's a lot less painful if we
can avoid the blunder in the first place.  And, my complaint was never
about lack of post-blunder support.


> <<It does nobody any good to allow Ada's reputation to be damaged by
>   allowing one Ada customer after another to blunder into such well-known
>   beartraps.  Most customers are domain experts, not language experts.
>   Telling them after the fact that they should have known better just makes
>   them angrier and angrier, and drives them away.>>
> 
> Well I must say this giant population of angry Ada users who don't know
> what they are doing must either be smaller than Joe thinks, or they must
> not be using GNAT :-)

Well, let me tell you another saying from the retail world:  For every
customer that complains, there are ten who will simple never come back. 
Silence is not golden.


> Seriously, I think Joe way overstates the problem here. Perhaps his shop has
> just had bad luck, but I think the kind of problem he worries about is a
> relatively minor issue in the overall success picture of the use of Ada.

Of course we were in a sense unlucky, but ...  On a project of any size,
the language will be well explored, and most such blunders will be made
somewhere, so it isn't really a matter of luck.


> You do not have to be a language expert to have the background to have a
> feeling for many of these issues. A basic graduate course in programming
> language design and compiler techniques, should be quite adequate, the
> sort of education that any CS graduate should have. If you have an entire
> project with no one with this kind of background, then I think that is
> definitely asking for trouble!

Well, this certainly allows us to size the problem:  One must have a
graduate degree in language design and compiler techniques to use Ada. 
That's quite a revelation.  We would have never suspected that Ada was
that hard to use.

This gets to the heart of the problem.  Our programmers, being domain
experts, would rather take graduate degrees in their respective fields of
interest, in their chosen professions.  If they were interested in being
compiler experts, they would have instead studied compilers, and they
would probably work for a compiler vendor, not a system vendor, because
few system vendors build compilers.  Nor would they be experts at other
than compilers; there are only so many hours in the day.  Domain expert
and compiler expert are very different fields.


> That being said, there are definitely some areas where Joe's wish for some
> standardized advice would be useful. For example, all Ada programmers should
> understand the two models of implementing variant records with default
> discriminant values, and all Ada programmers should be aware of the 
> consequences of using controlled types.

This sounds interesting.  Could you expound further?


Joe Gwinn