Re: discriminant questions

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

On 21.09.11 10:08, Dmitry A. Kazakov wrote:

> It was one of key advantages of Ada 83 which tried to stay reference vs.
> value agnostic. It is sad to see, started with Ada 95, the drift towards
> IMO wrong direction under the influence of Java et al.

Java and C# at least try to cover the difference between values
and references by providing semi-automatic switching between
the two.  Whether or not covering the difference between
values and references is better than to state it explicitly
is another question.

Why should Ada not provide for the same sugar?  There are two
answers, one positive, one negative.

There is market force of C++ and the fun of C++ and while it is
at odds with both the rationale and with the advantages
of the original ideas behind Ada 83, Ada++ allows people to feel
better with Ada when they can try to write C++ in Ada.  (See
anonymous pointers, avoiding nesting, abbrvt sntx.)

The language market is driven by attractors.

Accessors are in the class of very fashionable attractors.
Extending the notion only a little, Eiffel now has assigners.
Python has properties.  C# has Get/Set within definitions.
Objective-C introduced dot notation for property/setProperty:
methods. Etc etc.  And Ada?

Wait!  These features do not seem to attract all programmers
alike.  For example, Objective-C's dot notation is not welcome
by all Objective-C programmers.  So there is some resistance.

Ada accessors IMHO violate a specific tradition of Ada,
the language: that intentions should either be stated
explicitly, or else there should be some explicit syntax
directly related.  Now we see

  Function_Name (P) := ...;

Everything that we see in this statement, or rather that
we don't see, is an implication.

This is very popular. Intentions of the designers aside,
and instead the intentions of the programmers into focus:
Omissions allow clever, lazy programming, because it reduces
Ada's prodding you into explicitly stating your intention.
Accessors do so by covering mechanism, not showing it.
We do not even get

  Name [P] := ...;

which would at least follow the stipulated Ada tradition of
having special syntax for special mechanism!


Aspects increasingly help quickly work around language design.
It is cheap and effective, you can get short term market success,
follow each trend. They can always modestly extend SPARK if good
old Ada is needed for sanity, clarity, and honesty of expression ...