Re: How do I write directly to a memory address?

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

On 07.02.11 14:56, Ludovic Brenta wrote:

> This bad style had
> a lot of influence on the programmers of 15 years ago whose code I
> must now maintain.

Exactly.  Style has, by hypothesis, a strong impact on on code
quality, since programming patterns and programming idioms are
passed on at every stage of becoming outdated.  Programmers will
copy idioms with little consideration, especially when idioms
have become associated with revered authors, first edition.
They are not updated.  They are also not updated because
compilers will not reject old code.


> In Ada, this bad style is simply not possible.

It sure is possible to write awful and dangerous Ada text, even
with the dangers hidden.  While this style is possible, Ada culture
is less tolerant. (Or, more skeptical of the "practical" programmer.)


> In Ada, "in" really means "in".

No, "in" is intended to mean "in".  There are two reasons that
this is not an unbreakable property. The first is demonstrated by
Ada.Numerics.Discrete_Random.Random.
But Random is the exception rather than the rule, Ada tradition
promotes the reverse effect of what C tradition promotes, I think:
by Ada's default, by the traditional idiom, "in" stands for "in".
(In the case of void safety, the language discussions include
comments bemoaning that we'll have to write "not null"
instead of marking the reverse case (may be null), thus underlining
the tradition.)

The second reason that "in" need not mean "in" is less brutal:
it is the possibility of write access to a parameter object
from within the function if the objects is also a global object.
(Global to the function).  (Whence Ada getting "in out" parameters
for functions is considered an act of honesty, if I understand
comment in ARG mail correctly.)  Again, this kind of access is
considered by style (and is also possible in C).


>> For further ammunition for Verdun style language comparisons,
>> see function Ada.Numerics.Discrete_Random.Random.
> 
> What does that mean?

It means that Ada function Ada.Numerics.Discrete_Random.Random
only works because it violates its "contract".  The parameter (a
generator object) is passed "in", but is modified. Its mutation
is one effect of calling function Random.


>> I think there are better arguments.
> 
> No.

Yes, and you have named them.  They seem to have a little less
to do with the language definitions, but rather with "encouragement"
to write your intentions properly.
(In at least one video (lecture? Ada UK?) Robert Dewar
has been emphasizing a cultural issue a few times).