Sat Sep 8 22:24:49 EDT 2018

Making incremental builds faster

There has to be a way to do this for other sytems...

EDIT (9/10)

This problem keeps coming back.  And really I don't see how something
so simple can get so complex and out-of-hand.

What about this: construct an explicit dependency graph.  Now, invert
it, such that it becomes clear what needs to be recompiled on edit.
Then at commit points (save), recompile and build.

This idea keeps coming back:

- Keep legacy build systems for "offline" builds.  E.g. a nightly
  rebuild, or the final delivery.  This is the "reference build".  It
  will necessarily be hacky.

- Construct a (partial) incremental build system that is validated
  against the main build.

For validation, one possibility is to use the incremental build system
to implement the "edit-compile-run" cycle, and have the main build
system in the background run in parallel to check that the incremental
system is working properly.

In the last couple of weeks I've run into the Haskell Data.Graph
package.  Maybe have a look at creating an overlay.  Also, there is
the Haskell build system "shake".  This might work as well.

EDIT: What about just creating a good Makefile?  I.e. do this using a
tool.  This way, the "offline" builds will benefit as well.