Re: discriminant questions

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

On 27.09.11 17:38, Dmitry A. Kazakov wrote:
> On Tue, 27 Sep 2011 17:11:03 +0200, Georg Bauhaus wrote:
> 
>> On 27.09.11 14:14, Dmitry A. Kazakov wrote:
>>> On Tue, 27 Sep 2011 12:18:28 +0200, Georg Bauhaus wrote:
>>>
> [...]
>>  So you end up explaining tasks
>> and protected objects anyway.  And you might be able to explain
>> why seemingly advantageous "primitives" like "concurrent" and
>> "lock" had been preferred to a library based approach.
> 
> As another example take elliptic integral of the first kind: F(x,k).

I had been talking about programming constructs, not specialized
mathematical functions that may or may not be expressed in terms
of more primitive mathematical functions.  The latter is quite
interesting, but might be seen as an experiment that should finally
arrive at some language, not just experimental libraries treated
as language.

That is, I'm assuming that programmers want a loop construct
in Ada, not just goto.

I'm assuming that they don't want to have to define loop in
terms of goto, even when this has certain advantages.
Or rely on libraries to supply "loop", not just the compiler.

I'm assuming that if programmers always had to build
(or have someone do it for them) specific concurrency constructs
out of concurrency primitives, than this is too time consuming.
A libraries approach seems like a kludge, too.

The of mine, quoted above, came out wrong: it should say that
"task" and "protected object" were chosen, not CAS or some such,
with libraries around it.

There is a staircase, so to speak, from very primitive features
up to more "heavy" features.  By *default*, I'd rather not
force programmers to always go down to the basement.
And hope that the libraries at upper floors are just as good as
what a language will normally make the compiler do.

Yes, in Ada 2012 we may reinvent basics in terms of more primitive
language features such as conditional goto, 'Succ/'Pred, and
and increment and decrement operations:

   type Nat is range 0 .. System.Max_Int;

   function "+" (Left, Right: in out Nat) return Nat is
      Y : Nat := 0;
   begin
      Copy (Target => Y, Source => Left);
  <<A>>
      if Right /= 0 then
         goto B;
      end if;
      goto C;
  <<B>>
      Y := Nat'Succ (Y);
      Right := Nat'Pred (Right);
      goto A;
  <<C>>
      return Y;
   end "+";


assuming a suitable definition of Copy.  I like it better
when Ada provides more than primitive built-ins. Goto and
libraries could provide a user-definable interface for defining
"loop".  I don't think programmers would ever care.

Rules for defining language primitives in libraries might
add some openness.  I truest that there will be overlap
between two sets of computer professionals, then:

 A := { Authors of compilers }
 B := { Authors of future library }

 A and B = A?

What is n in

 |A| - |A and B| = n% ?



> Why
> bother to with subprograms, accuracy of real types, real types themselves,
> approximation techniques for such a simple thing?

Ada's way of specifying fundamental types refers to concepts
relatively far away from hardware, IMO. The expression
  range 0.0 .. 100.0
is language. Thankfully, I don't have to follow some interface
of defining range types myself, interesting as it might be.
I'm also not sure that all Ada programmers will like it if
the very process of interpreting "range <x> .. <y>" is moved
to libraries.


> The answer to your question was given by Occam 700 years ago.

How much hair would the rasor have cut from Ada's definition
of its heavy concurrency primitives?

Iverson and the makers of S (and R) have begged to differ
as regards the "reach" of primitives.
The big money insurance industry says they were right.
(And, please, temporary success or failure of this or that
branch of industry is not an argument against language design
unless there is a causal relation.)

A question related to the "reach" of features: Are there patterns
of programming embedded control software that could very well
be reflected in language features?  I think they are, but not
in Ada, which is too primitive here.


>> At Ada-auth, they usually say something about customer response to
>> implementation defined pragmas and such.
> 
> Customer response to the language standard? Are you joking?

Response to experimental features such as pragma Assert; contracts
specified with pragma Precondition and such; or conditional
expressions, I think.