Re: Press Release - Ada 2012 Language Standard Approved by ISO

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

On 22.12.12 10:02, Dmitry A. Kazakov wrote:

>> In an ideal world, all of these "checks" will get made statically. Hopefully
>> that's coming. In mean time, it's important to get programmers used to the
>> idea of writing checks this way, so that future tools can make the checks
>> statically (there is no hope of making checks statically if they are just
>> written in natural language comments).
>
> OK, this is rather a tactical disagreement then. Ada's stance was
> conservative, not eager adding features impossible to implement properly.

Rather, history tells that Ada has been seen by some as being just a little
less improperly adventurous than Algol 68.

> Because somebody (Georg) could readily base his design on the faulty.

Don't worry, my predicates tend to be pure, are used for debugging,
and can be turned off/removed/left as documentation once the proofs
have been checked. (Letting them stay can be a Good Thing if you need
to prepare for the usual uncoordinated multi-player refactorings and
quick fixes.)

The expressions don't have significant effects as measured by the purpose
of the programs. For example, they may interrupt the normal flow, like
explicit tests, they will send a mail message with some state information
in it and ask for an optional user report. These reports are extremely helpful.

Checks can be written as if there was monitoring hardware, hence as
if they did not even have a way of toggling any of the program's bits.

> In the first step I would rather prefer means to declare user-defined
> operations pure, context-dependent pure, compile-time evaluated etc. This
> would be more universal than mere predicates, and "proper" predicates would
> require that stuff anyway. An alternative, letting the compiler/vendor to
> deduce such properties, is IMO unrealistic (an undecidable problem, I
> think).

Right, and I would like to learn what kind of restrictions Randy
is having in mind that will let compilers evaluate more expressions at
compile time.