In truth, Autotools’ only real ‘saving grace’ is that it is what all the GNU projects are largely using.
Issues with Autotools:
- Truly ARCANE m4 macro syntax combined with verbose, twisted shell scripting for tests for “compatibility”, etc.
- If you’re not paying attention, you will mess up cross-compilation ability (It
should clearly be noted that Nokia came up with Scratchbox/Scratchbox2 to side-step highly broken Autotools build setups for Maemo/Meego.) If you, for any reason, have fixed, static paths in your tests, you’re going to break cross-compile support because it won’t honor your sysroot specification and it’ll pull stuff from out of your host system. If you break cross-compile support, it renders your code unusable for things like
OpenEmbedded and makes it “fun” for distributions trying to build their releases on a cross-compiler instead of on target.
- Does a HUGE amount of testing for problems with ancient, broken compilers that NOBODY currently uses with pretty much anything production in this day and age. Unless you’re building something like glibc, libstdc++, or GCC on a truly ancient version of Solaris, AIX, or the like, the tests are a waste of time and are a source for many, many potential breakages of things like mentioned above.
- It is pretty much a painful experience to get an Autotools setup to build usable code for a Windows system. (While I’ve little use for Windows, it is a serious concern if you’re developing purportedly cross-platform code.)
- When it breaks, you’re going to spend HOURS chasing your tail trying to sort out the things that whomever wrote the scripting got wrong to sort out your build (In fact, this is what I’m trying to do (or, rather, rip out Autotools completely- I doubt there’s enough time in the rest of this month to sort the mess out…) for work right now as I’m typing this. Apache Thrift has one of those BROKEN build systems that won’t cross-compile.)
- The “normal” users are actually NOT going to just do “./configure; make”- for many things, they’re going to be pulling a package provided by someone, like out of a PPA, or their distribution vendor. “Normal” users aren’t devs and aren’t grabbing tarballs in many cases. That’s snobbery on everyone’s part for presuming that is going to be the case there. The typical users for tarballs are devs doing things, so they’re going to get slammed with the brokenness if it’s there.
It works…most of the time…is all you can say about Autotools. It’s a system that solves several problems that only really concerns the GNU project…for their base, core toolchain code. (Edit (05/24/2014): It should be noted that this type of concern is a potentially BAD thing to be worrying about- Heartbleed partially stemmed from this thinking and with correct, modern systems, you really don’t have any business dealing with much of what Autotools corrects for. GNU probably needs to do a cruft removal of the codebase, in light of what happened with Heartbleed) You can use it to do your project and it might work nicely for a smallish project that you don’t expect to work anywhere except Linux or where the GNU toolchain is clearly working correctly on. The statement that it “integrates nicely with Linux” is quite the bold statement and quite incorrect. It integrates with the GNU toolsuite reasonably well and solves problems that IT has with it’s goals.
This is not to say that there’s no problems with the other options discussed in the thread here.
SCons is more of a replacement for Make/GMake/etc. and looks pretty nice, all things considered However…
- It is still really more of a POSIX only tool. You could probably more easily get MinGW to build Windows stuff with this than with Autotools, but it’s still really more geared to doing POSIX stuff and you’d need to install Python and SCons to use it.
- It has issues doing cross-compilation unless you’re using something like Scratchbox2.
- Admittedly slower and less stable than CMake from their own comparison. They come up with half-hearted (the POSIX side needs make/gmake to build…) negatives for CMake compared to SCons. (As an aside, if you’re needing THAT much extensibility over other solutions, you should be asking yourself whether your project’s too complicated…)
The examples given for CMake in this thread are a bit bogus.
- You will need to learn a new language.
- There’s counter-intuitive things if you’re used to Make, SCons, or Autotools.
- You’ll need to install CMake on the system you’re building for.
- You’ll need a solid C++ compiler if you don’t have pre-built binaries for it.
In truth, your goals should dictate what you choose here.
- Do you need to deal with a LOT of broken toolchains to produce a valid working binary? If yes, you may want to consider Autotools, being aware of the drawbacks I mentioned above. CMake can cope with a lot of this, but it worries less with it than Autotools does. SCons can be extended to worry about it, but it’s not an out-of-box answer there.
- Do you have a need to worry about Windows targets? If so, Autotools should be quite literally out of the running. If so, SCons may/may not be a good choice. If so, CMake’s a solid choice.
- Do you have a need to worry about cross-compilation (Universal apps/libraries, things like Google Protobufs, Apache Thrift, etc. SHOULD care about this…)? If so, Autotools might work for you so long as you don’t need to worry about Windows, but you’re going to spend lots of time maintaining your configuration system as things change on you. SCons is almost a no-go right at the moment unless you’re using Scratchbox2- it really doesn’t have a handle on cross-compilation and you’re going to need to use that extensibility and maintain it much in the same manner as you will with Automake. If so, you may want to consider CMake since it supports cross-compilation without as many of the worries about leaking out of the sandbox and will work with/without something like Scratchbox2 and integrates nicely with things like OpenEmbedded.
There is a reason many, many projects are ditching qmake, Autotools, etc. and moving over to CMake. So far, I can cleanly expect a CMake based project to either drop into a cross-compile situation or onto a VisualStudio setup or only need a small amount of clean up because the project didn’t account for Windows-only or OSX-only parts to the codebase. I can’t really expect that out of an SCons based project- and I fully expect 1/3rd or more Autotools projects to have gotten SOMETHING wrong that precludes it building right on any context except the host building one or a Scratchbox2 one.