Re: Is the Writing on the Wall for Ada?

[18k11tm001@sneakemail.com (Russ)]

Wes Groleau <groleau@freeshell.org> wrote in message news:<RbSdnT6kv7SrdPqiU-KYuQ@gbronline.com>...
> Robert I. Eachus wrote:
> > Wes Groleau wrote (to Russ):
> >  > Interesting how you were not able to persuade any of us ignoramuses
> >  > that temporaries are always needed without it nor that they are never
> >  > needed with it.
> > 
> > Let me tell you a story with names removed [snip interesting story]
> > 
> > Both Ada and Fortran were willing to allow her not to use temporaries, 
> > as long as the compiler could verify that this particular gotcha didn't 
> > occur.
> 
> The story was interesting, but whether due to my IQ
> or the fact it's an hour past my bedtime, I must confess
> I do not know whether you were illustrating my point
> or agreeing with Russ.
> 
> (Russ insists that A += 1 never needs temporaries
> and that A := A + 1 always does.)

That's not *quite* what I insist. What I insist is that, for
vector/matrix operations, "+" is a *function* that must create a
temporary vector/matrix and return it, and it must be *copied* to the
lhs. On the other hand, "+=" is a *procedure* that does not
necessarily need any temporaries because it can do its operations "in
place". No temporaries, no extra copying.

In the previous thread, someone claimed that "+=" needs a temporary
too for some sort of overflow checking (I don't recall the exact
reason given). If that is true, then it is an example of an inherent
inefficiency built in to Ada. For better or worse, C++ has no such
inefficiency. (I'm just stating a fact, I am *not* claiming that C++
did it right.)

Someone else also claimed that a good Ada compiler can make "+" as
efficient as "+=", but I don't see how that could be possible,
considering that I could define "+" and "+=" to do anything I want.
Nothing in the language requires me to define "+" to actually do
matrix addition. I could define it to write poetry if I wish.

And let's not forget that a properly defined "+" should be able to
handle sequential addition, such as A = B + C + D + E. No matter how
you slice it, each of those additions needs a temporary. On the other
hand, you could write

A = B
A += C
A += D
A += E

It's not as elegant, but no temporaries or extra copying are required
(unless the language imposes them for extraneous reasons).