The only reason to use a build system - is to reduce iteration time (compile times and a like).
I wouldn't say that is the only reason, nor even the first reason, although a useful feature. Every project will need to be built, and whichever way you decide to manage that could be considered a build system, even if you manually type it in by hand (do check out 21st Century C
to see some tips on how to make ad-hoc manual compilations from the terminal a breeze).
The first reason thing that a build system should provide is the documentation and execution of your build plan. Even if the one you end up with is horrible, it should at least do this much. The worst thing you could possibly
do is forget how to build your code. Arguably the next worst is to have a build system that you can execute, but not know how or why any of it works. One of Casey's early arguments against implementation independent architectural blueprinting is that it is a simply a non-functional duplicate of the code itself. Similarly, a build system's artifacts in your project should serve as both documentation and executable.
In that respect, Autotools is terrible, maybe even the worst. Unless you've handrolled your autotools build as I described in my previous
post and know exactly how you did everything, its a pretty steep learning curve. Even I've gone back to autotools builds I've authored myself and have to take a couple hours to read enough of it to remember how it works.
That pretty much takes care of anything out there other than the simplest possible script that's directly executable on the shell of your environment. To add the feature of reduced iteration, the next place I would go is to a simple makefile. It does mean that both you and your downstream have to have a compatible make exectuable installed, but that is pretty trivial price to pay next to the opacity of Autotools or having to install the entirety of CMake.
Probably one of the largest implementations of a make driven build is Kbuild from the Linux Kernel project
. Bear in mind, this system encompasses the complexity of thousands of developers all submitting code that ultimately is merged into a single project tree.