Re: Is the Writing on the Wall for Ada? [although this thread changed to something else a long time ago]

[Vinzent 'Gadget' Hoefler <ada.rocks@jlfencey.com>]

Russ wrote:

>"Jeff C," <nolongersafeto@userealemailsniff.com> wrote in message news:<BkAcb.579943$uu5.94364@sccrnsc04>...
>> "Vinzent 'Gadget' Hoefler" <ada.rocks@jlfencey.com> wrote in message
>> news:bkubhj$5v7t7$1@ID-175126.news.uni-berlin.de...
>> Russ wrote:
>> 
>> >just basic common sense. Let me ask you which of the following is more
>> >readable:
>> >
>> >lwienfowowoenfnowoqndfoowopqihjefhnowqoowldvno :=
>> >     lwienfowowoenfnowoqndfoowopqihjefhmowqoowldvno + 1
>> >
>> >or
>> >
>> >lwienfowowoenfnowoqndfoowopqihjefhnowqoowldvno += 1
>> 
>> They are not equivalent.
>
>You are very observant.

Well. I have to admit, I was - of course - expecting something like
this.

>But how long did it take you to determine that
>the two statements are not equivalent?

How long it took to compare the characters, three seconds, five
seconds.

Obviously, such a thing is not done at a first glance like you usually
do when you look over some code to find relevant places when you are
scanning it for errors.

>My point is that the second
>form, using augmented assignment, makes it instantly clear that one
>variable is being incremented.

It does make it clear if and only if you know what this weird operator
+= means (I know, this is not a strong argument).

Well, perhaps it even does not, speaking for myself, I still find this
one one of the most cryptic parts in C-like languages (together with
the funny and unspeakable names of all the C-library functions and the
hyper-cryptic boolean/logical operators, the latter being my
"favourites", I still don't get them and probably I'll never will).

>That means better readability.

I don't like it, but in this particular case I probably should agree.
But...

>> One lesson learned: You really should take care of your variable's
>> names. :)
>
>As I said before, those variable names are obviously ridiculous, but
>if I had more time I could come with a reasonable example of a
>complicated data structure illustrating the exact same point.

Yes, I know, we did that before. And I will come against it with a
simple renaming declaration that makes everything so much easier. ;)

>> Yipes! I think you just made the point that the C++ syntax is less error
>> prone...Now this mis-named thread will  never die.
>
>Yes, I think I *have* made the point that this particular aspect of
>C++ syntax is less error prone and more readable than Ada.

The problem I have with this syntax is that it at first it is not
clear what it means, it breaks at least my normal reading flow. And
like you mixed up variable names that might be not detectable at the
first glance, you also could mix it up with a normal assignment
operation. Yes, I consider "+=" and ":=" as looking not very
different.

So the result is still not better in terms of safety and readable
code, we would just exchange the possibility of mixing up something
with the possibility to mix up something else. What would we gain from
that? The acceptance of some idiotic kids who like to code one buffer
overflow after another? ;->

The second thing: If we introduce such a syntax in Ada, this means it
*will* be used even in simple cases like

|Count := Count + 1;

that converts to

|Count += 1;

(because programmers *are* lazy) and IMO this *would* definitely have
a large impact on general readability. I'd say, the general effect on
readability would be worse than that what we would get back from
adding something like the "+="-operator syntax to the language.

>The same principle applies here. If Ada enthusiasts are too blind to
>see the obvious deficiency of the lack of augmented assignment
>operators, then what hope is there for Ada when it has so much else
>going against it?

Well, I still consider

|Add (lwienfowowoenfnowoqndfoowopqihjefhnowqoowldvno, 1);

(with a "pragma Inline (Add);" if you want so)

a good alternative. Call it a compromise. Well, I know the
C++-community wouldn't accept it, because "+=" is so much "nicer", but
I don't care about them. They don't care about me, so we're even. :)


Vinzent.