Re: Crosspost: Help wanted from comp.compilers

["John R. Strohm" <strohm@airmail.net>]

"Hyman Rosen" <hyrosen@mail.com> wrote in message
news:1058378673.35463@master.nyc.kbcfp.com...
> Robert I. Eachus wrote:
> > If you understood Ada, you would understand that all of the "evidence"
> > you supplied confirmes what we have said.  The issue going into the Ada
> > 9X process was that tools that tried to short-cut the Ada recompilation
> > rules were tried--and they were much worse than the problem.
>
> If you go back to my original post, you'll see that I wrote
>      the implementations were horrible, leading to frequent
>      unnecessary "recompile the world" scenarios
>
> How is that different from what you just said? Are you
> disagreeing with me that this was the case?

No, what he pointed out was that MOST of the problem that MANIFESTED as long
recompile cycles was CAUSED by poor software engineering practices.  Tools
were tried to shortcut the recompile cycles CAUSED by the underlying
software engineering problems, and those tools turned out to be far worse in
practice than it would have been to FIX THE REAL PROBLEM.

>  > Do you really understand how the GNAT "source based" model works?
>
> Yes, in fact I do.
>
> > Everytime...
>
> As some of my evidence pointed out, the compilation systems which
> caused problems appeared to use compilation timestamps in their
> dependency checking, such that simply compiling a file caused the
> system to consider it to be newer than its dependents, and thus led
> to their recompilation in a days-long cascade. I don't know why
> they did it that way, but it certainly seems clear that they did.
> Certainly Ada doesn't require that this happen, which is why I
> spoke about horrible implementations, not horrible Ada.
>
> GNAT's way means that a file is recompiled only when the source
> modules it depends on change.

Same thing.  Exactly.

Consider a package spec, that declares a procedure.  Change the procedure
spec, say, adding another parameter, and recompile.  EVERYONE WHO CALLS THAT
PROCEDURE is now by definition obsolete: their procedure calls are all
broken.  Those calls MUST be fixed, and those units MUST be recompiled.  IF
THOSE BROKEN CALLERS AREN'T FIXED, BEFORE THE SYSTEM IS LINKED, THE BUILD
WILL BE BROKEN.

Read that sentence again.

IF THOSE BROKEN CALLERS AREN'T FIXED, BEFORE THE SYSTEM IS LINKED, THE BUILD
WILL BE BROKEN.

Now, the C/C++ model is to let the programmer link anyway, and HOPE that the
broken build will be caught in lab testing BEFORE it gets loaded into the
rocket, launched into orbit, and proceeds to render a multimillion-dollar
payload so much space junk.  Or maybe it is a lifesupport system, that just
kills a few people by forgetting to pump oxygen into the breathing loop.

This may be acceptable in the C/C++ community, hey, who cares if you kill a
few grunts or waste a few million dollars, but it was not considered
acceptable in the Department of Defense embedded systems community.
Requiring recompilation is, IN THE PRESENCE OF GOOD SOFTWARE ENGINEERING, a
safety check that isn't going to cost THAT much, compared to the potential
cost of NOT recompiling.

By the way, last time I looked, all the various version of 'make' for C/C++
use compilation timestamps to determine whether something needed to be
rebuilt.  So how is Ada "worse" than C/C++ in this regard?