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
* 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
* Lack of freely available garbage collector for implementations.
This really restricts the coding style to assuming that there is no
* 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".