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

[Ludovic Brenta <ludovic@ludovic-brenta.org>]

Georg Bauhaus wrote:
> Exactly.  Style has, by hypothesis, a strong impact on on code
> quality [...]

I would rephrase that as: style has, *in my experience*, a strong
impact on code quality.

>> 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, it is pretty difficult to hide such dangers.  In the case I
was talking about, had the subprogram been written in Ada, the
programmer would have had to declare a copy of the "in" argument
explicitly or to make the argument "in out"; both would have made the
bug immediately obvious to any reviewer.  The reason why the bug
eluded so many people and survived 15 years was that reviewers failed
to see the assignment as the cause for the bug.  Perhaps because they
were tainted by Ada culture where, if you assign to an argument, this
necessarily means the argument is "in out".

You can always program dangerously in Ada but you have to be explicit
about it.

>>> 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.

The generator is not modified; its associated (pointed-to) state is.
When reviewing a function that takes a pointer (or an object
containing a pointer), I expect and look for writes through the
pointer, so again the bug I was talking about would not have survived
a code review.

>>> 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).

Well, I came to wonder what intentions are conveyed by "void foo (int
arg)" and why modifying arg inside foo could be intentional.  Since I
came up with no convincing reason (the only reasons being variants of
premature optimization), I concluded that the possibility of "void foo
(int arg)" as opposed to "void foo (const int arg)" was a flaw in the
C language, that cost me a lot of effort.

--
Ludovic Brenta.