Re: ADA Popularity Discussion Request

[Georg Bauhaus <sb463ba@l1-hrz.uni-duisburg.de>]

Kevin Cline <kevin.cline@gmail.com> wrote:

: But an experienced APL programmer would undoubtedly find the shorter
: APL program easier to read.

Though not all of them would agree that J programs are as easy
to read. Conversly, if you know J's operators and functions by
heart, and you read one of the 2-letter sequences in ML or Eiffel
or Ada, overload resolution has to happen in you "reading apparatus".
Why not try to avoid this when it makes sense to do so?

 
:  Concise mathematical notation makes it possible to reason
: about mathematical objects at a high level.
: So, instead of "limit(e->0) [f(x + e) - f(e)] / e", we write "f'(x)"

Uhm, the left formula is, in a sense, the body of the spec
on the right; they are *both* in concise mathematical notation.
To me, the second is as much an abbreviation as "non-inlined
subprogram calls".

How many items of concise notation should there be per page,
in a program of some size, given a set of programmers with
different areas and depths of knowledge? At least there should
be a "modularisation of notations". How can you achieve that
when the language, not the modules, defineds or invites conciseness?
 
: Relatively few programmers would be capable of writing the SPIRIT
: parser library, but when that's what you need, Ada just won't get you
: there.

It does get me there, unless you are referring to writing an exact
copy the SPIRIT parser based on Ada templates.
But there is no need.
If you need an EBNF like executable notation in Ada, SPITBOL patterns
are at your service; they are readily available for Ada. It is not
exactly the same thing as template computing, but it should turn
out to be equally powerful. This is working code, the rules are copied
from the example in the SPIRIT introduction:

begin
   integer    := span("0123456789");

   group      := '(' & (+expression) & ')';   -- "+" defers
   factor     := integer or group;
   term       := factor & arbno(('*' & factor) or ('/' & factor));
   expression := term & arbno(('+' & term) or ('-' & term));


  -- `input_text` is an Unbounded_String as per the above grammar.
  --  (which omits white space patterns.)

   match(input_text, group ** output, result);
   --   in addition to matching, displays, on `output`, what has been
   --  matched

end expr;


Ada will get me there, if along a slightly different path. :-)

-- Georg