Re: Separate Compilation in Programming Languages

[<adaworks@sbcglobal.net>]

"Ray Blaak" <rAYblaaK@STRIPCAPStelus.net> wrote in message 
news:uy799dama.fsf@STRIPCAPStelus.net...
> <adaworks@sbcglobal.net> writes:
>
>> An implementation of an Interface (in Java) is still tightly bound to
>> its specification, and any change of that implementation will carry forward.
>
> But of course. And that is exactly analogous a change to an Ada package spec
> impacting the package body.
>
>> It is true that the Interface specification remains unchanged, and that is a
>> good thing.  However, if any part of the Interface specification changes,
>> every other unit dependent on that specification will also have to be
>> recompiled.
>
> Again, exactly the same as changing an Ada package spec.
>
Only when dependencies are at the specification level.  But, in Ada we
can defer the dependency to the package body.  In Java you cannot
defer that dependency.  A dependent unit, when the specification
changes is combined with its implementation.   Therefore, every dependent
specification must also be compiled.   As noted below, we can defer
the dependency in Ada to the package body.  There is nothing analogous
to this in Java.

>> In the Ada model, where I defer the dependency on that
>> Interface to the body of the dependent package, I need not recompile the
>> specification of the dependent package.  Rather, I can compile only the
>> body, leaving the rest of my architecture intact.
>
> Recompiling a file does not imply the need to imply client files if the
> public signatures have not changed. Most IDEs can handle this.
>
Exactly my point.  If the public signatures do not change, there is no
need for recompilation.  When the public signature does change, the
entire dependent architecture goes out of phase.  If, however, that public
signature change is isolated to the the implementation files, the separately
compiled package body (as it is in Ada) the architecture remains intact.

In Java, all public signatures, including implementations, are dependent on
parent public signatures.  There is no way to separate them.   When one
changes, everything dependent on that one change is also changed.  In
Ada, we move the dependency to the pacakge body so changes to a
specification has no effect on the Ada specification, thereby preserving
architectural integrity.   This is not possible, as nearly as I can tell from
all the examples given to me so far, in Java.

> Also, recompiling an implementation class will not cause a recompilation of
> the interface clients at all, since they do not even (necessarily) see the
> implemetation in the first place.
>
> Again, exactly analogous to an Ada package body needing to be
> recompiled. Ada's separation of spec and body is what allows you to do this. A
> Java interface and its implementation class is an analogous separation.
>
>> I'm not sure why this is such a difficult idea.  It is probably because I am
>> not expressing it with sufficient skill.
>
> Well, as politely as possible, I submit that it is not about the skill, but
> that I think you are mistaken.
>
Perhaps.  But I still don't see how one can defer the dependency of a
Java signature to the implementation of the Java class and prevent
the need for recompiling the entire architecture when the signature of
a parent class changes.   The ripple effect through the entire chain
of dependencies when one of those signatures changes is almost
certain to be affected by such a change of signature.   If Java can
somehow accomodate that change automatically, it must be some
kind of magic that is not immediately apparent, even to the Java
developers I know.

Richard Riehle