Re: Communications of ACM: Sir, Please Step Away from the ASR-33!

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

On 29.12.10 15:52, Dmitry A. Kazakov wrote:

>> No, using tools, they will be guided in the direction the
>> tool knows best.  Just like an Ada compiler will instruct
>> us to not leave out values in a case distinction.
> 
> Ada is capable of this because it has types. It is not because Ada knows
> anything about specific types, but because the programmer can use the type
> system to express constraints the compiler will then check. There is no
> magic knowledge Ada oracle sheds to guide programmers. All information is
> exclusively from the programmer.

The information in models is man-made, too.

> Any tool is no different, it is a
> dangerous delusion to believe otherwise.

There are differences among tools' domains.
(In what they are about, in what they can express.)

Tools are different, and so are the benefits.
Even when two tools are in the same class of tools:
An Ada compiler will treat a case statement in a way
that is different from the way a C compiler treats a switch.
Both are, by intent, case distinctions.

So even among compilers guidance is different.

The crucial part is that an Ada compiler guides you by
answering the question "Which case distinctions do I
have to change?" (provided you don't use C style "others"
for subtypes typically appearing in case statements).
A C compiler typically cannot do this.

Modeling tools will answer different questions.  But they will
answer them when answers are more difficult to find using only
Ada source text and human inference.  This is because, when
modeling, humans have expressed one set of notions. This
set is slightly different from the set expressed in Ada source.



>> Even StP went far to make
>> sure your model was checked in all sorts of directions.
> 
> Assembler checks the code in that sorts of direction too.

Assembly language cannot, for example, *express* IS-A
relations, Ada can (there is syntax for it), UML too,
and more than this.

You can have conventions in assembly language, like the first
parameter pushed for a call is a pointer to a memory location, and
the first word there is a pointer that either represents the
null pointer or is a pointer to another memory location of
similar structure. (...)  I think this isn't meant by *express*
IS-A.


>> The compiler is a guide where it "knows the area".
> 
> Why this area must be different for an Ada compiler and a UML diagram
> interpreter?

Ada and UML deal with a different set of objects and notions.
There is some correspondence, but the focus is different.

>> These associations,
>> relations, etc.  are not easily spotted, not in one
>> place, in a source program.  The compiler won't tell you.
> 
> and UML would?

Yes. BON, e.g., is a particularly simple way to express relations
and orders of communication.  UML has this, too. Formally,
unlike comments.


> Why a thing important to the program must
> be external to it?

The system architecture is such that concurrent processes
communicate via a data store. So the important thing happens
to be external to the program.  It is a requirement that I
cannot change. But a model can express the external control
as a system element nevertheless.

> Why this thing must be external in Ada, but internal in
> UML?

An external control can be an element of a UML diagram or
other modes of expression, but not in Ada (not directly).
The set of objects directly expressible in some modeling
language may be larger (or different).


>> Suppose there is a setup like the following: some external entity
>> acts as a mutex controlling concurrent activities of
>> co-operating "jobs".
> 
> Don't use low-level concurrency primitives. Ada has better means for that.

That's the non-argument I'd like to again ask to avoid:
the setup is given, as is.  When I can use Ada
to cope with the given setup, I'll have to act as if Ada
had no direct support for the CSP mechanisms permitted
in the given setup.  However, direct support is available
in other (modeling) formalisms. They can be mapped
to Ada (in several ways). I pick a mapping that matches
the setup.

The model is clear, the implementation in Ada is up
to the programmer.