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