Re: Other Ada Standards (was Re: SIGada Conference)

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

Dmitry A. Kazakov <mailbox@dmitry-kazakov.de> wrote:
: Or with getting rid of with clauses at all, as Robert Duff mentioned in
: passing! I never liked them. How about that?

That is what has been driving me up the wall when debugging
Java classes. The author liked a particular feature of the
IDE that popped up a menu of methods applicable to an object
if either the import list names the package, or if the fully
qualified named was there,
(type top.mid.Something.<hit Ctl-<space>>.)
Result: occurences of top.mid.Somthing.meth(...) everywhere
and _not_ top.mid.Something in the import list.

So, by just looking at the import list, nothing was known
about the dependences, because they were sprinkeled all over the
sources, and therfore implicit.
Can a good IDE help in this case? Not much I guess. To what extent can
it help when the source code cannot be compiled? I imagine that an
IDE might need error correction at an extreme AI guessing level so to
speak, in order to be helpful.

Should a programming language depend on an IDE?
There have been some extensions to Oberon-2, one being related to
concurrency, http://bluebottle.ethz.ch/languagereport/node3.html
AFAICS, if a maintainer wants to find the "concurrency structure"
of a an Active Oberon program, he/she will have to make a search
for some keywords embedded in type definitions, and prodecure
definitions.  (That is, it looks more like

    type T is
      program text
      program text
      protected
      program text
    end T;

rather than

    protected type T is
      program text
      program text
      program text
    end T;

The first variant might look quite flexible as you only have to add
some keyword like {ACTIVE} or {EXCLUSIVE} (for protected etc) after
some BEGIN.  To a reader this might look like you can add concurrency
ad hoc.  Or you might just switch some cuncurrency feature off for
a procedure by removing a keyword.  But then this is ad hoc design,
not easy to spot, and somehow feels not well structured, as it
buries the concurrency indicators in type definitions or procedure
implementations.  It might allow some clever tricks syntaxwise.
But do you want this kind of cleverness attitude expressed in
Ada programs?

Omitting with clauses might to have similar effects on design, I think.


-- Georg