Re: Efficiency of code generated by Ada compilers

[csampson@inetworld.net (Charles H. Sampson)]

Robert A Duff <bobduff@shell01.TheWorld.com> wrote:

> csampson@inetworld.net (Charles H. Sampson) writes:
> 
> > <tmoran@acm.org> wrote:
> 
> >>    Bearing := (Bearing + Turn_Angle) mod 360;
> >
> >      I'd be interested in hearing reactions to something I did. ...
> 
> >      I then overloaded "+" and "-" for (Bearing, Turn_Angle) arguments
> > and Bearing return value.  In those functions is where the mod 360
> > occurred.  (Actually, mod 360.0, as it were.)
> >
> >      There were two advantages to doing that.  The more important was
> > that previously both of the kinds of values were being represented as
> > subtypes of Long_Precision and programmers would occasionally
> > interchange them and cause big debugging problems.  The second was
> > removing the "mod" from sight, which allowed the programmers to simply
> > think of taking a bearing, turning an angle, and getting the resulting
> > bearing, without worrying about all the niceties that might be going on
> > inside "+".
> 
> Sounds to me like a good way to do things.  It would still be a good
> idea if you called it "Turn_Left" or something like that, instead
> of "+".  But I don't object to "+".

     This was for the U. S. Navy, and "positive is right" is pretty much
universal.  For programmers, that is, not for sailors.  They think port
and starbord.

> I object to having built-in support for angle arithmetic in the
> language, though.

     I don't follow.  What is angle arithmetic?  Whatever it is, it
sounds too specific for a general purpose language.

> Did you eliminate meaningless ops like "*"?  You could do that
> by making the types private, but then you lose useful things
> like literal notation.  Or you could declare "*" to be
> abstract, which is an annoyance, but might be worth it.

     I would have liked to eliminate meaningless ops.  As you noted,
making the types private results in the loss of literals.  I wasn't
ready to go that far.

     What I really want is a way to hide existing visible operations,
particularly the ones from Standard.  I've asked about it before and
there doesn't seem to be too much enthusiasm, not enough to warrant the
time to get the niggling details correct.  The problem is, you can't
write something like

          if Current_Bearing + 0.5 > 180.0

because it's ambiguous.  (Is "+" from Standard or is it the special "+"
for bearings and turn angles?)  So you end up having to qualify literals
when there's only one reasonable "+" in the minds of the programmers.
Of course, you won't have that problem if your style is to always use
typed constants, but I wasn't ready to go that far either.

                        Charlie
-- 
All the world's a stage, and most 
of us are desperately unrehearsed.  Sean O'Casey