Re: Ada requires too much typing!

[Luis Espinal <Luis_member@newsguy.com>]

In article <hu5e4u$6il$1@news.eternal-september.org>, Alex R. Mosteo says...
>

>
>Hi Luis, thanks for the detailed reply. I understand your points clearly.
>
>My days of Java are a bit behind so I'm not sure what I'm about to say can 
>be done in Java. In Ada, one could extend an interface adding a new method 
>like this:
>
>procedure Moo (This : A) is null;
>
>And effectively it won't break any client, since it provides a default "no-
>op" implementation. It won't work for functions, obviously. In any case, 
>clients would need to recompile, since in Ada land we're not talking of a 
>world of JVMs and dynamic hot-plugging, I presume. This alone (the use of 
>stand-alone executables) may make the problem much less of an issue.
>
>Also, not needing to specify defaults to overload a method could be of help?
>
>procedure Foo (This : A) is abstract; -- Added in 1st spec
>
>procedure Foo (This : A; Bar : A'Class) is null; -- Added in 2nd spec
>
>I've done sometimes the thing of having a insulating base class providing 
>some/most of the interface core functionality, but at the same time I 
>realized that this defeats to some degree the point of interfaces, since you 
>can't inherit from two such base classes.
>
>In any case I feel your pain about the lot of Java programmers and 
>frameworks ;-) I guess it has its goods and its bads.
>
>Alex.
>

That actually seems like a much better implementation of interfaces than Java's.
I think it would have been interesting if Ada interfaces were to provide a
default behavior for function that throws an exception when called. In Java, we
usually have to inherit functions off interfaces for which no appropriate
behavior exist, and thus the usual convention (manually implemented mind you) is
to add a throw UnsuportedOperationException() for those functions.

That'd probably be appropriate for enterprise systems, but not for critical
systems which is probably why it is not implemented in Ada. You are right to
point out that in Ada things compile or do not. In Java we never really know who
is going to dynamically load (or inherit) from artifacts of our making.

- Luis.