Seeing gcc as an intelligent agent

["Franck Z" <franck dot z dot gcc at orange dot fr>]

Hello,

I would like to ask the developpers' community about an idea that interests 
me these days.

It comes from the fact that the compilation time when I try to run the 
"make" command on the source code for gcc is too long for the configuration 
I use. Indeed, I enjoy the flexibility of USB keys in order to "play with 
gcc" when I get the occasion. Therefore, as I have access to Windows based 
systems, I opted for a Cygwin installation and a svn download of gcc trunk 
on a USB key which I can plug in in all freedom.

Of course, it's slower than if I used a hard drive, but even then it takes a 
lot of time, and so much disk access that I fear for my local hard drive 
(I'm jocking here, of course!). Moreover, I guess that many "amateur" 
developpers of open-source projects could share my opinion.

Therefore, I would like to ask you about the idea of turning the "gcc" 
command into an intelligent agent, with respects to the disk usage and the 
recompilations of headers that have a lot of impact on my way of using 
"make".

> From what I imagine, I would change both "make" and "gcc" so that some 
serialization of what different invokations of "gcc" performs is available 
throughout the execution of the "make" command.

At first, I thought of serializing "per se" objects that "gcc" would use, 
but I observed that the branch in the gcc project which aimed at rewriting 
the gcc source code in C++ is no longer active. The branch "incremental 
compilation", from what I understand, seems besides to take a different 
approach.

In fact, I now see the concept of intelligent agents as something more 
easily available to answer this issue. It seems to me that a memory mapping 
through a file, initiated by the "make" command and passed on to the various 
"gcc" executions could allow this approach, seamlessly (?).

For instance what's described here :
http://msdn.microsoft.com/en-us/library/aa366556.aspx

or through the mmap() function in Unix environments.

As far as I gauge this way of doing, no change of makefiles or "gcc" 
commands should be needed, but for an option telling gcc it has to use such 
a shared memory.

That being said, I'm not a very experienced programmer in both fields 
(intelligent agents and sharing memory between processes through mmap()). 
I've narrowed down my researches to the book "Artificial Intelligence: A 
Modern Approach (3rd Edition)" by Stuart Russell and Peter Norvig to learn 
about a grounded and shared understanding of intelligent agents.

-> What do you think of this approach ? (from what I've understood of the 
gcc source code, it's not in gcc's philosophy yet - but I may be wrong, I'm 
a junior developper)

-> Do you think the book I refer to is a good start ?

Many thanks to every one.

Franck Z.