Re: GNAT Modification_Time limitation

["Randy Brukardt" <randy@rrsoftware.com>]

<briot.emmanuel@gmail.com> wrote in message 
news:0d4679d2-30d7-493f-b9fd-688d044e1a4e@googlegroups.com...
>> I'd argue that these are something else on top of individual builds. And
>> that it is a mistake trying to combine basic building with those
>> higher-level configuration management things.
>
> Not sure about the concepts about you describe. For me, "basic building"
> is one run of the compiler on one specific file, which always recompiles,
> no question asked.
> What we are talking about in this thread a tools at the level of make and
> gprbuild, that decide what should be compiled, and when. For me, this is
> thte "higher-level build management part". That includes configuration
> management, since this tool is also responsible for deciding where the
> build artifacts (object files, executables,...) should be stored.

I think of a single compilation as a "compilation", while a "build" to me is 
something that results in one or more executable files, generally based on 
the source code found in a single directory. Going further (and we have some 
such features, particularly for sharing source/object between multiple 
distinct builds) is part of the higher-level management. (I don't have an 
simple name for that, which shows yet again how hard it is to describe.)

Ada of course allows "build" to be completely automated without any outside 
intervention at all. In theory, it's only necessary to point the build tool 
at the pile of source code.

...
>> It's hard to imagine a build taking less than two seconds; certainly not 
>> if
>> a human is involved, and very unlikely even if automated.
>
> Don't forget that Lionel's make-like tool and gprbuild are both meant to 
> be
> language-neutral. Compiling an Ada file in less than 2s is rare nowadays 
> (but
> possible with very simple files. But compiling a python file takes a few 
> ms,
> so just looking at timestamps cannot be enough (though when compilation
> is that fast, it doesn't matter much to redo it more often...

Again, a "build" in my view is compiling the set of files needed to create 
an executable. (Again, I'll ignore the management of shared libraries.) That 
generally requires the compilation of multiple files, and a linking phase as 
well. Moreover, unless you are running multiple builds from some 
higher-level tool, there's also human reaction time involved. The likelihood 
of that happening faster than 2 seconds isn't high. The issues I've seen 
almost always come from someone terminating a compilation in the middle 
without letting the compiler clean up any half-created artifacts.

Of course, most other languages need a lot of help to determine dependencies 
(information that is directly part of the Ada source code). That need for 
help has confused the issues a lot, because however you give it can't be 
automatic nor bullet-proof. Thus, this gets mixed up with the higher level 
issues. Ada only needs that help at a higher level than basic building; 
basic building should be automatic.

I've even had a customer (with large, complex systems) tell me that they 
didn't want the Ada compiler to even try to manage such things. They wanted 
to grab some set of source from version control and essentially have the 
compiler build it from that source (all found in one large glob in a single 
directory). They thought that build times were short enough that it wasn't 
worth the intermediate steps to avoid recompilations. I've rather thought 
that was the future of such tools; some higher-level management (probably 
from the configuration management system) where whatever the compiler does 
would seem to get in the way.

                                        Randy.