Good list Dale!

but just one nit:
>  (do you know the syntax for an array of entries to a task?).

Several years ago I learned the hard way that it's really a "family of
entries" not "array of entries" when I publicly described the use of "an
array of task entries" in something I wrote.  It looks like an duck, and it
quacks like a duck, but it's not a duck.

So the name of the construct is probably just as likely to be unknown as its
syntax.  ;-)

GeneO.

-----Original Message-----
From: Team Ada: Ada Advocacy Issues (83 & 95)
[mailto:[log in to unmask]]On Behalf Of Dale Stanbrough
Sent: Thursday, October 08, 1998 3:47 PM
To: [log in to unmask]
Subject: Re: Ada Pros and Cons


Some disadvantages of Ada are...


* Lack of recursive types across packages. This means that you have to
  package things in the same package, or resort to unchecked_conversion,
  (which works, but is fighting the type system, rather than it helping
   you).

* Privacy is based on the location of an item in a package, rather than
  on a per item basis, which results in contortions to achieve various
  coding styles.

* Lack of freely available garbage collector for implementations.
  This really restricts the coding style to assuming that there is no
  garbage collector.

* No easy to use multiple inheritance/interfaces. Yes I know you can use
  generic mixins, but I've always found the results more indirect than
  using solutions in other languages.

* Stream stuff seems rather obscure. Teaching this to students is a matter
  of constantly introducing new, strange syntax.

        (for X'Write use Procedure_Name);
        (X'Write (Stream, item);

* Exception handling is rather schizophrenic. You can use the standard
stuff,
  or you can use the Ada.Exceptions package.
  Also exceptions seem rather limited compared to Java & C++, where you can
  throw arbitrary objects. I know Tucker Taft says this is possible in Ada
  for an implementation can provide a root object which can be derived from,
  but no one has yet).

* Lack of clearly defined constructors that don't perform copying (you can
  use functions, but I think they copy the newly created value, which seems
  rather pointless to me).

* Weird syntax to enforce initialisation

        (type must_initialize (<>) is private; !!!)

* There is a _lot_ of syntax, which makes writing tools difficult.
  ASIS should help this, but one project using it reported a _large_
learning
  curve in using it. This puts it out of scope for a tools company that
could
  consider porting their Java/C++ tools to Ada.
  (do you know the syntax for an array of entries to a task?).



Not specifically Ada language...

* Lack of bindings

* Lack of interest by students.
  Curiously many students quite like Ada, and find it easy to get things
done
  in it, but still see no future in it.

* I still quite like object.action notation. I think it reads better.



"All languages suck. Some just suck less than others".

Dale