Autotools 148
Muad writes "John Calcote is a senior software engineer in Novell's Linux business, who after slogging up the steep learning curve the Autotools triad poses to those packaging software according to the portable GNU conventions for the first time, very kindly decided to make the experience easier to newcomers by sharing his years of experience and carefully crafted bag of tricks. His book is a welcome update to a field that has not seen entries now for a full ten years, so long has been the time since GNU Autoconf, Automake, and Libtool by Gary V. Vaughn, Ben Ellison, Tom Tromey, and Ian Lance Taylor hit the shelves. Unfortunately, the publishing industry is driven by the need to turn a profit to fund its endeavors, and specialist items like this book are not obvious candidates for volume selling - which is a credit to No Starch Press' willingness to venture down this path." Keep reading for the rest of Federico's review.
The book opens with John's experiences in adopting the Autotools, and quickly offers what is in my view a very important word of caution that is often lacking in the few tutorials I have seen on the Net: the Autotools are not simply a set of tools but foremost the encoded embodiment of a set of practices and expectations in the way software should be packaged the GNU way. While it is acceptable for beginners not to know what these expectations are, the right frame of mind to approach the Autotools is to focus on learning what way the Autotools operate, what they are trying to accomplish, and why. Attempting to use the Autotools without understanding the bigger picture will lead to very high amounts of pain, as it is one of the toolsets most difficult to adapt for use separate from the policies they represent, so strongly are these conventions embedded in their fabric. With this understanding, it becomes possible to generate extensive configurations with a few lines of Autoconf or Automake - without this understanding, it very quickly becomes a battle to force a round peg into a square tool.| Autotools: A practitioner's guide to GNU Autoconf, Automake, and Libtool | |
| author | John Calcote |
| pages | 360 |
| publisher | No Starch Press |
| rating | 8/10 |
| reviewer | Federico Lucifredi |
| ISBN | 1593272065 |
| summary | Teaches how to master the Autotools build system to maximize your software |
John's style is more extensive and takes a longer path to the "technical meat" of the problem than the 10-year old alternative, but in this reader's opinion it flows significantly better as there is an underlying story, a thread that connects the bits of what is otherwise a pretty arid subject. For those masters of shell-fu, this book is a page-turner, while for mere mortals it is a good, approachable, path into a difficult skill.
The book is structured around the packaging of two different projects, the first being a simplified "Hello, World" project to provide a digestible introduction to the processes and technology of the Autotools, while the second representing the full-blown packaging of a complex, real-world project (the FLAIM high-performance database). This is a very good approach, breaking the theory into many practical examples of practice, and providing many ready-made bits that the rest of us can start our own configuration build files from. The result is a first half providing a gentler, streamlined introduction to the subject matter, before the full jump into the gory details of the most complex possibilities the toolset offers. While it must be noted that John attempts to keep away from those most fine details which "may be subject to change" between minor releases of the tooling, which is doubtlessly good for both our scripts' and the book's shelf life, it must be observed that he does not shy away from very dense (and otherwise utterly undocumented) material, such as the use of M4 macros in Autoconf, something a colleague of mine once pointed to me as "the one more reason I'd rather chew broken glass than deal with Autotools".
Assuming you have the requisite knowledge of Make, Shell scripting (particularly Bash), and GCC that are essential to a developer, packager, maintainer or buildmaster of a Linux, BSD or *NIX project, or that you are on your way to achieving those skills, this is a book that belongs in your shelf, right next to the RPM documentation. This is material for experts or experts in the making, but in my opinion you will find no better introduction to this complex subject. I had it on my wish list well before it was ever printed, and its presence on my desk caused several other developers in my office to order their copies pretty much on the spot upon finding out of its existence. Either as a learning tool for a skill you are trying to attain, or as a reference to turn to when faced with the complexities of this unique set of tools, this book is well worth its price tag.
I certainly hope this is not the last publication we see on the Autotools in this decade, but either way, it is a good start indeed - and my hope is that the publisher will refresh the title when an update is warranted, without waiting ten years!
Federico Lucifredi is the maintainer of man (1) and a Product Manager for the SUSE Linux Enterprise and openSUSE distributions.
You can purchase Autotools: A practitioner's guide to GNU Autoconf, Automake, and Libtool from amazon.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.
Autotools do not need a book (Score:5, Insightful)
... they should be replaced by something else.
Re:Autotools do not need a book (Score:1, Troll)
Re:Autotools do not need a book (Score:5, Interesting)
I often need to install software in an environment that's different from where it's going to be run, e.g. I install it on a file server, where the target directory is /export/apps/stow/, and then I use "stow" to put it in /export/apps, which clients mount as /usr/site, so they see "/usr/site/bin/", and are set up to look in /usr/site/lib for libraries, and so forth.
I don't know if this is instrinsic to newer build schemes or not, but my recent experience has been that "old-style" (autotools-based) packages work just fine, they interoperate well with stow, accept the "--prefix" argument to configure, and work just fine for the clients. Cmake-based packages tend to hard-code path names into start-up scripts, which then break on the clients, which view the app in a different hierarchy -- they don't have /export, in particular.
Now, it may well be that these are badly-written cmake scripts, and cmake is perfectly capable of doing it right, I honestly don't know. But it seems to me that cmake (and Python's easy-install, and every other new build scheme I've run across in the past few years) are all part of a new generation of tools which really want the build-time and run-time environments to be the same, because they're built around the "single-user isolated workstation" model.
But it's not true. Lots of us still have centralized file servers that use NFS exports to make centrally-managed Linux applications available to many clients. The new tools make some things easier, but this, they make harder.
Also, uphill through the snow both ways, and we liked it, get off my lawn, kids today don't know nothin', no respect I tell you.
Re:Autotools do not need a book (Score:4, Informative)
I've run into the same problem with cmake. I don't really have that problem with python tools as python's virtual environment tools [python.org] seem to handle things nicely. Tools such as pip [python.org] natively handle virtual environments, automatically installing into it when one is active.
Also, there are lots of nice wrappers [python.org] to work with python's tools, for developers, such as gogo [bitbucket.org].
Re:Autotools do not need a book (Score:3, Interesting)
"I don't really have that problem with python tools as python's virtual environment tools seem to handle things nicely. Tools such as pip natively handle virtual environments, automatically installing into it when one is active."
Which is another aspect of the very same problem. So their solution to ignoring they should seggregate functional development from bug fixing, that they should take API stability as an almost sacred cow is "reinventing" the "static linked environment"?
Try to install two disparaged tools based on the same shared environment and welcome to the fun of app A asking for 'foo 1.2.3' and app B needing 'foo 1.2.4', so you end up producing a virtual environment for each and every app you install. Good luck then with tracking security advisories for "foo" (and all the other dependencies of each installed app). Good luck with finding an upgrade path that will just fix known security issues without breaking functionality for any of your installed apps.
But, but, but... you should use the very bleedging edge -the developer of App A will say, without paying attention to the fact that you manage 2000 machines with 150 different main apps from different developers and dates, disregarding even that each of those developers will define "bleeding edge" as "whatever it happens to run in my development box, disregarding if it's really needed or it's stable or it will be supported by my dependecies' developers".
Ahhh, youngsters... now, you get off my lawn!
Re:Autotools do not need a book (Score:2)
I don't know if this is instrinsic to newer build schemes or not, but my recent experience has been that "old-style" (autotools-based) packages work just fine, they interoperate well with stow, accept the "--prefix" argument to configure, and work just fine for the clients.
Not true. No true at all.
I used stow for many many years. And it's true, a lot of packages just worked. You'd do a "configure --prefix /run/time/target", then "make install prefix=/install/time/target", and it would work. But this is *hardly* universal. Many many apps fail due to install-time relinking, which means you have to hack libtool and the build a bit in order to get them to install. It's doable, certainly, but it's hardly automatic.
Now, I haven't had to deal with cmake-based systems recently, so it may be that they're even more broken than this. But it's never been completely trivial to build for one runtime path, while installing to another.
'course, as a user on an isolated workstation, I finally just moved away from stow, and manage my custom-built packages using checkinstall. But that's obviously no solution when you're managing applications on an NFS share.
Re:Autotools do not need a book (Score:2)
Other build-package problems (Score:2)
Re:Autotools do not need a book (Score:2)
Hi Urban Garlic,
The most important thing to know is that the --prefix argument (for a correctly designed configure script which follows the conventions) indicates the run-time installation directory of the program. I.e. the path given to --prefix may actually be compiled into the program and then used by that program at run-time.
The average free software user compiles the program on the same machine where he will run it. And so the prefix is also the place where the program is copied during "make install".
The default value for --prefix is often /usr/local, for this specific use case.
If you're building a distro or toolchain, you may have to override --prefix to /usr. (Assuming that the programs you are making wll go into /usr/bin, /usr/lib, etc on the target system).
The point is that the prefix has to be correct for the ultimate destination where the software lives.
Of course, when you're preparing a package for another system (perhaps a cross-compiled package, even), and the prefix is /usr, of coures you can't do "make install" because that will try to copy into /usr on the local build system! You must install into some temporary directory (or a "sysroot" directory where you are building up the filesystem image for a target). The way this is done varies from package to package. Some packages accept an extra configure parameter, like --install_dir. Many packages accept a make variable called DESTDIR which is specified on the "make install" command line; the contents of DESTDIR is prepended to the prefix. In some cases you can override the prefix variable itself at install time "make install prefix=...".
Re:Autotools do not need a book (Score:2)
You must install into some temporary directory
I'm sure he knows this since he is already using Stow [gnu.org]. Stow works pretty well for having multiple versions of different software packages built from source and installed simultaneously, and having a proper package management system for it all. Though these days I use Checkinstall [asic-linux.com.mx] - having the final package as a .deb or .rpm make it a bit easier to distribute the built packages.
Re:Autotools do not need a book (Score:2, Insightful)
"Now, it may well be that these are badly-written cmake scripts, and cmake is perfectly capable of doing it right"
The critics about the book make a point about "the Autotools are not simply a set of tools but foremost the encoded embodiment of a set of practices and expectations in the way software should be packaged the GNU way".
It's not that cmake can or can't be properly used in order to provide a platform-independent prebuild environment but it lacks the grayback experience. As the old motto says, "those who don't understand UNIX are condemned to reinvent it, poorly". Unix-zen, once "the cool wave" is about 40 years old now. New generations feel they know better than the old farts (and many times, they are right) and that they can do it better and simpler... just because they are not (still) aware of the whole landscape and its corner-cases. So, yes, they might re-implement the old farts' tools better and simpler (after all, they have the advantage of building of top on the shoulders of giants, so to say) but, at the same time, they are condemned to fail on the same stepstones their olders managed to workaround just because they choose to ignore them, and then add their own package of failures.
"But it seems to me that cmake (and Python's easy-install, and every other new build scheme I've run across in the past few years) are all part of a new generation of tools which really want the build-time and run-time environments to be the same, because they're built around the "single-user isolated workstation" model."
Young is always proud and think to know better than anybody else. They just produce tools for what they know and they choose to ignore everything else. No wonder they fail on things that would seem trivial for older people that already had to fight with them years ago.
This is the generation of 'reinventing the wheel': they are doing better in some aspects and fail heavily on things that should be known by now.
Re:Autotools do not need a book (Score:2, Funny)
because they are not (still) aware of the whole landscape and its corner-cases
Youngsters can undervalue knowledge of "the whole landscape and its corner-cases", but old farts can also overvalue it. The beauty of new tools like CMake is that they can leave the past behind, and stop worrying about corner cases on obsolete platforms. At one time I was an absolute expert on MSDOS and Windows 3.1. I leave that off my resume now because it no longer has any practical value, and it just makes me look old :-(
Re:Autotools do not need a book (Score:4, Funny)
Re:Autotools do not need a book (Score:2)
Actually building on multiple platforms without maintaining separate build files for each is the problem...
CMake was created to build Kitware's other products, most notably VTK and ITK. To date, I've built both, and other things built on top of them on three platforms, with several variations: GCC on Linux, both 32bit and 64bit, MinGW and Visual C on Windows. I don't need to install anything else apart from CMake and the compiler (and associated Make package) on each of those platforms, run it once, and then run make. On the other hand, just you try running autotools on Windows...
The other option, which I see a lot of projects using, is to have multiple build systems - an autotools one for Unices, and a .sln/.vcproj set for Windows. I don't think I need to point out the fun in maintaining that...
Re:Autotools do not need a book (Score:2)
In most cases, the MSVS project files are a courtesy for the people who are probably going to be using MSVS. I remember piles of 1990's open-source projects which ran on Windows, and everyone was asking for the project files. What is this other compiler you speak of - Cygwin isn't a compiler it's a fake unix environment, you can't make a Windows program without MSVS they say. Plus, whomever is doing the Windows port probably uses MSVS anyway.
For a true open-source solution, they would provide the command-line build. That way people can use the free version of msvs if they want. But for debugging and patching, and especially if I'm porting, I want to use MSVS because it's what I'm familiar with and it works.
Before .NET, I used to call MSVS the only decent software MS made, with SQL a close second. Not that they were perfect, but they were developed for coders by coders. Then it took 5 years for MSVS .Net to mature, and it's only getting better. But it's the standard, and the guy porting probably uses it, so why not include it.
Re:Autotools do not need a book (Score:2)
The other compiler is MinGW32 [mingw.org] - there are others, like Borland C, and ICC...
I think CMake supports them all.
There are still piles of projects running on Windows. Right now, I'm on Windows (work machine), with KDE 4.4, Inkscape, Gimp, VTK and ITK among other things installed. Remember, lots of devs work on Windows, and quite a large body of users too. Not to mention other environments, like embedded systems which might or might not be able to work with full autotools...
Re:Autotools do not need a book (Score:2)
Indeed, but a book can make it easier to develop such a thing.
Re:Autotools do not need a book (Score:1, Interesting)
They have been.
Cmake among others has effectively replaced autotools. It's FAR easier to deal with, cross platform, fast, will build makefiles, visual studio solutions, and X-code, and supports testing and other things.
There are some other ones around too like Scons, but the point is, anyone starting a new project now with autotools is a dolt or a masochist or both.
Autotools is dead. Let's let it be buried in peace, please.
Re:Autotools do not need a book (Score:3, Insightful)
If that were true you wouldn't have needed to say it
Re:Autotools do not need a book (Score:2)
The efficient markets hypothesis as applied to software. If it was better, we'd already use it!
Re:Autotools do not need a book (Score:5, Interesting)
I've just recently been in the situation of selecting a build system for a project with an existing codebase. I looked at the obvious alternatives, including cmake.
In the end, I chose autotools.
When you're doing a non-trivial project, cmake doesn't become any less complicated than autoconf and automake anymore - if your build is complex, you have to deal with that complexity somewhere after all. And there's a lot more and better resources for using autotools than cmake around, for figuring out odd corner cases. If you have a somewhat odd build requirement, chances are somebody else has already solved it using autotools already.
From my experience so far, most of what people dislike about using autotools come from Automake. But Automake is of course completely optional to use, and Autoconf - which provides most of the benefits - was made to be standalone. If you have a system with existing makefiles, it makes a lot of sense to simply use Autoconf to configure the app and the makefiles and leave Automake alone.
This is a lengthy but really illuminating document on using the autotools, that specifically goes through using autoconf alone and on how to adapt an existing project: http://www.freesoftwaremagazine.com/books/agaal/brief_introduction_to_gnu_autotools/ [freesoftwaremagazine.com]
Re:Autotools do not need a book (Score:3, Interesting)
I agree -- autoconf is independent, and does a great job handling system configuration stuff without involving automake -- but I think you're being a bit unfair to automake.
For projects that "fit" automake, it's actually a wonderful tool, as it allows a highly concise description of the package contents and dependencies, with almost zero fat and overhead, and does pretty much all the typical boilerplate stuff (convenience targets, separate build-directory support, installation, automatic dependency generation, consistency checking, etc) automatically without the user ever having to see the ugly internals. However automake also imposes a degree of structure on a project (not surprisingly, roughly following that of many GNU packages), and is not so flexible if you want something different. For packages that don't follow this structure, or which make particularly complex demands on the build system, automake may not fit very well, and may end up just getting in the way. [It's not entirely inflexible though -- it does try to provide for customization to some degree, and remember, it's essentially a wrapper around makefiles, and will pass through traditional makefile rules largely unscathed.]
I'd highly recommend trying automake first though, just to see if it works for you, because when it does work, it's really nice.
From what I've been able to figure out, most people who say they hate the autotools aren't realllly griping about the actual functionality, but rather expressing their distaste at the really grody implementation. It's very true that the implementation details of autotools (a bizarre mixture of m4, bourne-shell, perl, make, etc, all of which are even more ugly that necessary in order to remain portable) is not for the squeamish. However a user of autotools doesn't have to care about the implementation details for the most part -- and from a user's point of view it actually works quite well, and has some very nice features.
Even better would be this (Score:2)
decided to make the experience easier to newcomers by sharing his years of experience and carefully crafted bag of tricks.
Even better would be reading that this gentleman had gotten behind efforts to make working with the tools easier. Simply teaching me tricks though welcome, is not good enough. Working with the tool(s) still is difficult.
Re:Autotools do not need a book (Score:1, Informative)
Oh but I might still buy a copy. Just to wipe my @ss with. I can't begin to think of the hours I've wasted debugging build failures of this heap of cr@p.
mk-configure (Score:1)
Re:mk-configure (Score:2)
Over the years I also had made a meta-makefile which does much of what I needed.
Latest version is on github at
But even then quite often I just use qmake!
--jeffk++
Re:mk-configure (Score:2)
Re:Autotools do not need a book (Score:2)
My thoughts exactly. Autotools is/are abominations.
Re:Autotools do not need a book (Score:2)
Re:Autotools do not need a book (Score:2)
I suppose it's nice (Score:5, Insightful)
I suppose it's nice that someone writes a book like this, since a lot of existing projects use autotools (or more commonly, try to by means of copy/paste and cargo-cult based build scripting).
But autotools should really be phased out. It solves a lot of problems that aren't problems anymore, and makes a helluva lot of new ones in the process. There are a lot of up and coming build systems to challenge it, and then there's CMake which is an OK compromise between those and practicality.
Re:I suppose it's nice (Score:1, Interesting)
Care to point out what new problems autotools creates? From my experience, autotools projects tend to work flawlessly while cmake ones tend to throw a lot of obscure errors that no one is able to figure out.
Re:I suppose it's nice (Score:5, Interesting)
The autotools suite requires that software developers keep revising things that worked before, because autotools has some new paradigm for some aspect of its operation every year or so.
For example, one of my open source projects lets the user specify which extra modules should be compiled into the binary. (It doesn't use loadable modules because that was even more painful when we started out.) Over a span of about two years -- and I think three "minor" (1.x) releases of automake -- the approved way of conditionally linking object files changed twice. The changes were not documented, and nobody bothered to describe any way that would work across the several versions of automake that were in common use at the time. In contrast, doing the same thing with autoconf alone or with some non-autotools script is dead simple.
autoconf has also gotten progressively fussier. For example, simple m4 macro invocations like FOO(bar) used to work fine. Now they often generate a warning that the argument is not quoted properly. To pick one example of prior art, C solved that particular precedence problem about 35 years ago. There is no good reason for autoconf to make the software maintainer throw in all the []s that it wants.
Those are just a few examples from my experience; others will have more.
Re:I suppose it's nice (Score:4, Insightful)
> Care to point out what new problems autotools creates?
Builds that take half an hour just to "configure", checking for the existence of things like strcpy(), but anyway fail at compile or link time because a missing symbol in an upgraded dynamic library?
Re:I suppose it's nice (Score:2)
Builds that take half an hour just to "configure", checking for the existence of things like strcpy(), but anyway fail at compile or link time because a missing symbol in an upgraded dynamic library?
Is there ever a situation in which configure couldn't cache the "yes" answers and reuse them between programs? That's what I find most frustrating about autoconf.
I can understand not caching "no" answers long-term. For example, you try to configure package Foo and find that it depends on package Bar. Once you've installed Bar, you don't want configure to remember that Bar wasn't installed last time.
However, once "checking for bar.h... yes" comes up, is there ever a situation (short of uninstalling Bar) when you don't want that answer to be cached? I could happily imagine a case where configure always uses a specific host-wide cache file by default. Add some logic to "pkg_delete" or "aptitude remove" to delete that cache file so that removing an installed package would invalidated the cache, but otherwise leave it intact. Is there a corner case that could cause problems with this arrangement? On the FreeBSD systems I administer, I'd be willing to bet that half the time spent in a typical software upgrade is spent waiting for configure to decide if stdlib.h is still installed.
Re:I suppose it's nice (Score:2)
> What autoconf does is check for a representative function in the library
Yes, I understand the reason. The problem is that a lot of projects try dozens of such standard functions apparently with the (false) hope of running on every legendary Unix, so it really takes time. The problem is aggravated when at the end of the process your build fails so you must rerun configure with some correcting option: The same tests usually are reexecuted.. I read there is a cache to avoid it but apparently most autoconf developers just ignore how to leverage it, or doesn't work at all.
Re:I suppose it's nice (Score:2)
Ok, I exaggerated with the time... but only assuming that your build will be successful on the first execution (in my experience this is rarely the case.) So you end re-executing configure (with other options or after altering the system in some way). That way it's not uncommon to dedicate several hours for the build, with a lot of that time consumed in the configure executions.
Re:I suppose it's nice (Score:2)
> All configuration systems will take some time.
Of course, everything takes some time, but when something takes too much time, then there is a problem. Of course "too much time" is a subjective matter.
> the developer can check for dynamic library versions during the configuration
Yes, the developer could do a lot of things, but (IMO) the autotools are too difficult to master and use, so the configurations are largely suboptimal. Again, you can point to developer laziness but I believe it's more a conception/requirements/design problem with the tooling.
Re:I suppose it's nice (Score:2)
Care to point out what new problems autotools creates?
The fact that I can't use them on Windows. Seriously, I can't see how we call a build system "cross platform" when it doesn't cooperate with the most widely deployed build environment.
It seems to me that it might be possible for a Python-based build system to have enough platform independence that it could build projects on Linux, Mac, and Windows. SCons looks like it's coming along. I'd really like to see more developers get behind it, but on the open source projects that I've worked on many of the developers are antagonistic toward any OS other than Linux.
Re:I suppose it's nice (Score:2)
Re:I suppose it's nice (Score:2)
I use SCons at work for a project that builds on Windows, Mac, and Linux, and we even supported IRIX for a while. Our build is pretty complicated, including some code-generation steps where we build a program, run it, and generate new source files based on the output, and SCons works pretty smoothly. It's definitely lacking in a few areas, but lately it's been quite stable despite adding new features fairly quickly.
We do have a lot of "if windows... elif macos" kind of code. But I don't know if any system can entirely get rid of those. There are some platform-specific concepts that are really hard to abstract in a platform-independent way (e.g. side-by-side assembly nonsense on windows, or the weird handling of shared library paths on Mac).
The biggest downside I see to SCons is that your build system can easily get very complex, and then you have to debug and maintain all that code.
Re:I suppose it's nice (Score:2)
One problem is that a configure script prints lots of things to stdout. The few relevant lines are drowned in pages of irrelevant ones. For example, I once built SDL_image and later a program that links to it and that program's attempts to load PNG files failed. It turns out that the configure script of SDL_image failed to link with libpng and said so, but I didn't catch that message because it was between hundreds of useless lines.
I didn't expect SDL_image to build without PNG support, since I explicitly told configure to include PNG loading (--enable-png). Still it decided to not include the feature since it thought libpng was unavailable. I think it's reasonable that if I request something explicitly and it cannot be delivered, the result should be an error and not omitting the requested feature. I don't know if this behavior is built into autoconf or it is just a practice associated with autoconf, but I have seen it happen on many different packages.
Another problem is that a lot of unnecessary checks are done. It seems half the packages out there check for a Fortran compiler while they don't contain a single line of Fortran code. Also features are checked that are present on every system produced in the last 10 years and in most cases compilation will fail anyway if the feature is not present since the result of the configure check is ignored by the actual code. The unnecessary checks both add to the irrelevant output and slow down the build.
Because configure is a shell script, it runs its checks sequentially. So even if you have a quad core system, only one core is being put to use. For compilation Make is used, which is given a dependency graph that allows it to run certain tasks in parallel. It would make sense to do the configuration step in Make as well, but that is not how autoconf works.
Because autotools generate files, if an error occurs for example while running the configure script, you have to manually trace it back to the configure.ac or to one of its include files. This is a generic problem when generating code, but in autotools it is made worse by the use of a macro expander instead of a compiler: many errors that could be caught by a compiler will be forwarded to the output by a macro expander. And in the case of automake, there are two layers of expansion: Makefile.am -> Makefile.in -> Makefile, increasing the effort of tracing problems back to their origin.
Note that these points are design flaws in the autotools, so it's not likely they can be addressed while staying compatible with thousands of existing packages using the current autotools. So I would like to see a replacement for autotools, but so far every other system I tried (Ant, SCons, qmake) works great for simple builds but becomes a struggle for more complex builds.
Re:I suppose it's nice (Score:5, Informative)
It's true, pretty much. We developed configure scripts and ways to generate them in the days of 28.8kbps modems and they had to work on Unix System III and Xenix and HP-UX. We couldn't assume anything like Perl or Python was available. Linux distros were only just appearing, and there were no package management systems. Windows was still a 16-bit DOS shell. It was a different world. I'm amazed this stuff has endured as long as it has with so few changes. By the time Automake was written, several years after Autoconf, we at least felt we could assume the presence of Perl.
Want to know why it's called "Autoconf", which I think is a bit ugly of a name? I wanted to call it "Autoconfig", but when you add a version number and ".tgz" to that, you exceed the 14-character file name limit of some of the Unix variants it had to be downloaded and installed on!
Dave MacKenzie
Autoconf's main developer
Good grief, those run-on sentences (Score:1, Offtopic)
Good heavens, I'm all for sentences with body, but this is terrible. I actually stopped reading the article after the second one. You know what this site could use? Editors.
Re:Good grief, those run-on sentences (Score:2)
You know what this site could use? Editors.
You must be new here.
Re:Good grief, those run-on sentences (Score:2)
To be fair, I wouldn't consider those run-on sentences (they are, by and large, grammatically correct, less a missing comma here or there). They're just... excessive.
Re:Good grief, those run-on sentences (Score:2)
Jeez, I realise that attention spans are diminishing these days, but this is ridiculous!
Let me get this straight: (Score:5, Informative)
Did I miss any novell/suses?
Re:Let me get this straight: (Score:2, Offtopic)
Crappy Approach (Score:2, Insightful)
Re:Crappy Approach (Score:2)
RE: A not so Crappy Approach (Score:2, Insightful)
Those who don't understand Automake are doomed to repeat the mistakes of build systems that are not designed like Automake.
The one language that actually drives all of Automake is ML. Funny it is the one language you didn't list, but you listed a bunch of the high level macro files that get expanded with ML. If you don't know sh, then you shouldn't be programming on the command line (stick to an IDE that does the compilation for you). C isn't required for any component of Automake. If you write a makefile with automake, you made a big mistake, as Automake writes the makefiles for you.
There are other systems out there which are easier to use, but there's only a handful that does things in a manner that is highly reliable and portable on many platforms. Those that do strive for such goals end up operating like Automake, but often they do so without allowing such easy access to the internal guts of what is really going on.
Yes, I like cmake too, but bashing Automake just because you don't understand it is just the computer equivalent of name-calling.
Re: A not so Crappy Approach (Score:5, Insightful)
Hmmm... are you sure that you didn't mean the macro language M4? I thought that ML was the pure functional ancestor to languages like Haskell.
Anyway, I played around with M4 a little bit because I thought it looked handy for a few things. It has a deceptively simple specification that only takes a few pages, but it's one of the most extreme examples of "emergent behavior" I've encountered. Even simple tasks rapidly become mind boggling due to the deceptively tricky nature of recursive text substitutions and quoting. It's a real brain teaser of a language. It does seem like it would be a nifty tool if I spent enough time to really figure it out.
Re: A not so Crappy Approach (Score:2)
You're right, M4. Funny, a recent news article must have left me with ML on my mind.
I would rather carve a Makfile into my arm (Score:3, Insightful)
Re:I would rather carve a Makfile into my arm (Score:3, Funny)
I would rather carve a Makfile into my arm with a nail
I thought that's precisely what autotools is for?? ~
Re:I would rather carve a Makfile into my arm (Score:2)
why autotools suck - just google it (Score:5, Interesting)
Shallow Learning Curve (Score:3, Funny)
Shouldn't that be shallow learning curve? Steep would imply quick effortless progress towards expertise (at least if you put the independent variable on the abscissa and dependent on the ordinate as is customary). A shallow learning curve now would imply slow progress...
Re:Shallow Learning Curve (Score:5, Insightful)
Oh, for the love of jesus, not this again...
Yes, "learning curve" is a colloquialism that is not, literally, logically consistent. Move on already. Seriously.
Re:Shallow Learning Curve (Score:2)
Re:Shallow Learning Curve (Score:4, Informative)
Re:Shallow Learning Curve (Score:2)
I thought it was how much you have to learn (Y axis) vs. how long you use the software (X axis). A shallow learning curve takes less learning (= effort) in the short term.
Re:Shallow Learning Curve (Score:2)
Descartes is now officially spinning in his grave.
Autotools (Score:2)
Print on Demand for Obscure Topics (Score:2)
Unfortunately, the publishing industry is driven by the need to turn a profit to fund its endeavors, and specialist items like this book are not obvious candidates for volume selling - which is a credit to No Starch Press' willingness to venture down this path.
The situation is not as dire as this post seems to suggest. Print on demand [wikipedia.org] is an option for a book such as this. Getting a publisher like No Starch is great since they will provide traditional editing, review and marketing services however the publisher is not necessarily making any great investment since they too can take advantage of a print on demand type of approach. There is no longer a need to print a large number of books up front.
Re:Print on Demand for Obscure Topics (Score:2)
CMake (Score:5, Informative)
Re:CMake (Score:2)
Thanks for the link. Time to read up on CMake. When debug a broken build script in Gentoo, my personal experience is that I usually figure out what's wrong more quicker with Autotool than Cmake. The main reason is probably that I am more familiar with the former from reading this autotool online tutorial/reference: Autotool Mythbuster [flameeyes.eu]
The problem with CMake (Score:2)
is that it's got ugly syntax, effectively no cross-compiling support, and less-than-helpful documentation. And its generated Makefiles sometimes miss changes in header files, forcing you to "make clean".
But yeah, it's still a good alternative to autotools.
Re:CMake (Score:1, Insightful)
I think it's a testament to how bloody awful Autotools is that people think CMake is an improvement!
Re:CMake (Score:2)
Cross-platform, but not cross-compiling (Score:2)
I'll throw this bit of fuel on the flame-fest, in the form of a question:
Does anybody else find that Autotools based projects, while being very cross-platform, are almost impossible to actually cross-compile?
I do embedded systems work, and the embedded universe is moving to Linux as the kernel, and quite frequently a sub-set of the Gnu environment for the runtime. So you get things like BitBake, OpenEmbedded, and Angstrom, which attempt to enable you to build a complete system from sources. However, what all these environments do is run QEMU to emulate the target CPU in order to do the builds.
Now, that's stupid IMHO: I have this VERY FAST multi-core workstation, and I am
1) Throwing away all but one core, and
2) Hobbling that core emulating a completely different architecture (e.g. emulating an ARM to build for the OMAP).
Much of the - I shall use the term "work" although a more bovine-scatological term springs unbidden to mind - involves writing "recipes" for BitBake to work around issues in Autotools.
Much of Autotools seems to me to assume that the machine building the code will be the machine running the code - or at least, a machine of the same type as the machine running the code. So all the Autotools "magic" to deduce structure layouts, word sizes, byte orders, and such all assume that you can
a) compile the code using the host's C compiler,
and
b) Run the resulting probe programs on the host.
Both of which are totally FALSE for cross-compiling.
I used to say that you could design a new CPU that nobody had ever seen, and once you ported Binutils, GCC, and Linux to it, you could build an entire functioning distro for it, just by iterating over the various source packages for and cross-compiling. I know better now: most of the source packages out there DO NOT cross compile worth a damn! They might BUILD NATIVELY on a wide range of architectures, but not cross-compile.
Re:Cross-platform, but not cross-compiling (Score:2)
Indeed, requiring that part of the build takes place on the target machine, or having to emulate it, is an incredibly lame-assed copout.
At Zeugma Systems, I produced an embedded GNU/Linux distro known as Zeugma Linux. The rule of the project was that everything cross-compiles.
No MIPS instruction was emulated during the build.
I took the lessons that I learned, and incorporate them into the small configure scripts that I write by hand, which takes far less effort over the life of the project than dealing with Autotools.
Re:Cross-platform, but not cross-compiling (Score:1)
From someone setup the build for a production system to compile on linux and target platform being windows, I am little confused.
`--build=build-type'
`--host=host-type'
`--target=target-type'
Re:Cross-platform, but not cross-compiling (Score:3, Insightful)
Now, configure something like CORBA targeting a PPC, but configuring on an X86, for compilation on an X86 using a cross compiler.
Oops - all your structure padding code for the CORBA martialling is broken, because the autoconf scripts all assume they can find out the padding of the structures by emitting a program, building it, running it (whoops! wrong arch!) and getting the output.
It's all well and good if the program is trivial enough that it does no serious probing of the system, or if the configure host is the same CPU type as the target, but break that, and unless the project's configure script is set up to correctly detect a cross compile, to provide a set of configuration parameters you can provide on the command line to set the variables that would normally be inferred by probing, AND has the wit to refuse to run without you providing those parameters because it detected you are cross compiling, and you will NOT get a running program by default, NOR will you be able to get one without major surgery on the configuration data by hand.
Re:Cross-platform, but not cross-compiling (Score:1)
You have committed a logical fallacy
In sticking to the original post you can cross compile from x86 arch to arm without a emulator.
It has been a while since I played around with are but here is an example http://www.ailis.de/~k/archives/19-ARM-cross-compiling-howto.html [ailis.de]
On a side note, I don't care much for autotools, because I am surrounded by windoz users at work, and they love visual studio.
Re:Cross-platform, but not cross-compiling (Score:2)
Re:Cross-platform, but not cross-compiling (Score:2)
Note that the option to specify the target architecture is "--host". This makes sense for GCC and binutils and almost nowhere else, but every package has to deal with this naming. To make things worse, configure scripts created by recent versions of autoconf print a warning when you use "--host" in this way, but offer no alternative.
Whether or not a package using autotools will cross compile depends on how the configure.ac was written. Often it is copy-pasted together using fragments from other packages without really understanding what they do and in that case it is likely to break. If the configure.ac was written with cross compilation in mind or just does not attempt any tricky stuff, cross compilation will work fine.
Cross-compilation support is not magically added by autotools, the maintainer still has to consider the fact that the produced binaries might not be executable on the machine doing the build. The same is true of cross-platform support, by the way: autoconf does not provide it out of the box, it only provides a means of implementing it.
Re:Cross-platform, but not cross-compiling (Score:2)
I think this is the problem with autotools. It gives the impression of supporting lots of things, but the majority of scripts out there even break if you try to build in a separate tree from the source code. All those checks for the behavior of strcpy() and so on impresses newbies to think that their program would compile on Xenix and Sys5 and what have you, while in practice it's completely pointless.
Re:Cross-platform, but not cross-compiling (Score:2)
I indeed regularly run into configure scripts or Makefiles that think they can execute the binaries they have built on the build machine.
Just as bad are configure scripts that realize they cannot run a certain check in a cross compile and will use a hardcoded pessimistic result instead. In many cases the package then breaks during compilation because this alternative is completely untested since no actual system still in use requires it. In other cases it leads to useful features being turned off or unnecessary workarounds being enabled.
Another problem I often run into when compiling for embedded systems is not caused by autotools: a lot of packages pretend to be far more modular than they actually are. When aiming for a minimal footprint I like to disable all features that this particular system does not require. Deviating from the default configuration leads to compile errors on many packages. Sometimes because header files are included unconditionally even if the code using them is between #ifdefs. Sometimes because what is thought to be an optional dependency is actually not (or no longer) optional. And sometimes because package features have dependencies between themselves which are not (or incompletely) enforced by the build system.
FOR ALL AUTOTOOLS "REPLACEMENTS" (Score:3, Insightful)
please note that all current 'replacements' are totally wrong and actually work only as puny build systems, not supporting any of the great portability benefits that autotools give. Scons, cmake, whatever else depend on their working installation on _build_ machine. This is wrong, only working shell+make+gcc should be needed to actually build software.
So...
Is there ANY good "replacement", preferably lightweight, with this great virtue? As far as I know, there's none.
Re:FOR ALL AUTOTOOLS "REPLACEMENTS" (Score:1, Interesting)
only working shell+make+gcc should be needed to actually build software.
You've identified the key dividing line between Autotools fans and detractors. If you absolutely must limit your dependencies to "shell+make+gcc", Autotools may be the best tool for the job. I just don't understand why anybody chooses to limit themselves that way. It seems like all pain and no gain.
Re:FOR ALL AUTOTOOLS "REPLACEMENTS" (Score:3, Insightful)
Re:FOR ALL AUTOTOOLS "REPLACEMENTS" (Score:2)
You can write a GNU make makefile which replaces the implicit rules with rules that use CL.EXE and so on to compile binaries, then run the whole shootin' match in Cygwin. You can find tips for your implicit rules by reading the nmake files that ship with Visual C.
(Yes, I have done this)
BTW, if you're running Firefox on Win32, it was built with Visual C++, GNU make, and autotools running under mingw. Google "mozilla build"
Re:FOR ALL AUTOTOOLS "REPLACEMENTS" (Score:2)
Cygwin. gcc targeting native APIs.
-molo
Re:FOR ALL AUTOTOOLS "REPLACEMENTS" (Score:2)
In other words, programs should not build natively on Windows. It's 2010, isn't it time you see how outdated that requirement is?
Re:FOR ALL AUTOTOOLS "REPLACEMENTS" (Score:2)
Cmake just needs to be able to compile itself on the platform. Since it's C++ with few to no dependencies, that's not very demanding.
CMake also makes project files and makefiles more suitable for non-unix development.
shell+make+gcc aren't present natively on Windows, that's the whole point. Installing cygwin/mingw is a lot more demanding than installing a single, small executable (that you can include with the source).
Autoconf runs a boatload of checks to make sure it runs on archaic Unixes like Xenix and Irix (except that it won't actually, if you are so naive as to try). But Windows and other non-Poxis OSes (which, believe it or not, have their uses) it is stubbornly hostile to.
Re:FOR ALL AUTOTOOLS "REPLACEMENTS" (Score:2)
shell+make are also a requirement on the build machine. "shell" is not even a single program, but a collection of utilities: at least sed is required and probably a lot more, looking at the contents of MSYS.
Why is one set of build requirements OK and another totally wrong? In my opinion it is important that the build requirements are few in number and are highly portable themselves. But that does not mean that anything except shell and Make is automatically disqualified.
No amount of documentation ... (Score:5, Interesting)
can compensate for the low quality of this garbage, not to mention its poor performance (some builds spend more time running configure than actually compiling, installing, and tarring up the resulting run-time and devel packages!)
These tools have to be redesigned from the ground up by someone who understands that free software has made large inroads into the embedded world where it needs to be, doh, cross-compiled.
For my own projects, I develop a carefully-crafted configure shell script by hand and recommend everyone do the same.
The script has carefully developed and tested support for (1) cross-compiling, (2) configuring/building in a separate directory, and (3) installation into a temporary package directory.
Furthermore, this script should ONLY test the features that are actually needed by the program. (The program should assume a reasonably modern system; don't bother testing for obscure bugs in System V release 3, okay?) The script should make sure that it tests only header files and compiling with the toolchain that it is given. The configure test programs programs should never accidentally include something in the build machine /usr/include, or link something from /usr/lib!
Configure scripts should never run any program that they compile because it may be the wrong architecture, and they should not have an "if cross compiling" check which disables their features when cross-compiling and substitutes dumb defaults! Quite simply, implement the tests so that cross-compiling is not needed.
For instance, instead of making a C program which outputs values with printf, make it so that the values are used as initializers for static data. Then use the cross-compiling toolchain's "nm" utility to extract the values from the compiled object file. You don't have to run a program to know how wide a (void *) is. Just do "static char size_of_void_star[sizeof (void *)]". Compile it, and then interrogate the .o to discover what is the content of the size of the data region named by size_of_void_star!
Look at the stupid configure script for GNU bash. When crossing, it assumes totally pessimistic values for all checks that can't be done when cross-compiling. Unless you explicitly override the ac_* variables yourself, you get a shell which has no job control! The bash build assumes that your kernel has a tty system dating back to the middle 1980's.
Nobody should dig through a configure script to find out what broken tests they have to override by setting the variables manually.
Shell code should never be generated by m4 macros, let alone ones which frequently change.
Look at the stupidity of thisl. Suppose you want to produce a minimal patch for some open source project that uses autoconf. Suppose that as part of your patch you have to enhance the configure script with some new options. To do that, you have to modify configure.in. But projects ship with the generated configure script. So you want to regenerate that, right? Oops, your version of autoconf is different, and so you get a HUGE diff. Worse yet, the generated configure script breaks!
So people end up with ten different versions of autoconf installed, so they can always run the right one which matches what the configure script was produced with that is in the tarball.
Build configuration from scratch is not difficult. It is easy. Autotools do not simplify anything. They monstrously complicate something which is already simple and doesn't require simplification or automation. Using the Autotools is a false economy. You may think you are getting something for free and saving time, but in the end you will spend more time over the life of your project wrestling with this garbage (and also waste the time of countless other people you don't even know) than if you just carefully wrote a small configure script by hand.
Amen brother - TELL IT! (Score:2)
I whole-heartedly agree with you - and I'll make another point. Much of what auto* was designed to do was to allow porting the Gnu toolchain over to a target which did not have it - e.g. porting binutils and GCC to some Unix box that did not have them yet, thus they had to assume as little about the target system as possible to allow bootstrapping. However, the idea was that once you HAD binutils, GCC, and libc, you could use them, and have a predictable standard environment.
Now-a-days, that is almost a gimme - any new system will almost certainly have GCC as a part of the bring-up. So why not move on to a pkg-config style system, where there is an executable that can be run for the target platform, that can answer questions like "How big is a pointer? an int? A float? Do you have these library routines? What do I do to dynamically link a program?" pkg-conf does a wonderful job for the programs it knows about, why not extend it to answer all the myriad of standard questions that auto* seems to ask every time it's run?
Sure, you'd have to generate that program for a new target - but guess what? most of the "questions" are ones GCC already knows the answer to, so why not just make GCC be the "pkg-config" for basic CPU arch type questions? Then, even if I am cross-compiling for a Floobydust300 rev B processor, all I have to do is 'floobydust-unknown-linux-gcc --whatis "sizeof(int)"' and I have my answer. (alternatively, dump an XML file, or a key=value file, or header, or any number of other approaches).
Re:Amen brother - TELL IT! (Score:2)
Interesting solution, but it doesn't answer what happens when I don't use GCC - suppose I'm on Windows, using MSVC, or for that matter, on Linux using ICC or clang? Those are still important use cases for cross-platform applications and libraries.
So, let's have a program that knows about all these compilers and platforms, and can generate the appropriate build scripts.
Hello, CMake... ;-)
Re:No amount of documentation ... (Score:2)
Thanks for the tips.
I too develop configuration scripts by hand, but frankly have not cross-compiled anything in over a decade. I've been wondering how the heck to support cross-compiling cleanly, and from your laundry list, it looks like I'm pretty close already -- our best practices jibe pretty well.
Now if only you could tell me how to get upstream packagers to stop asking me to convert a *very* complicated build to autoconf, I'd be even more grateful. :D
Re:No amount of documentation ... (Score:2)
How you can appease the upstream managers is probably by making being compatible. Name the script "configure" and make it support all the standard options like --prefix, --host, --build and so forth. Support "make install" and the DESTDIR= variable to specify a temporary directory for packaging.
Re:No amount of documentation ... (Score:2)
Re:No amount of documentation ... (Score:2)
I'm discussing cross-compiling, so running the program requires emulation, or else uploading it to the target.
The nm utility is standardized by POSIX and The Single Unix spec, and should be in any reasonable toolchain for a a Unix-like system, including a cross-compiling toolchain.
If you have an "arm-cc" for cross-compiling for arm, then there should be an "arm-nm", as well as "arm-ld" and such.
nm can extract the size of a symbol (i.e how much space it occupies). So for instance if we declare:
int __foo[sizeof (struct abc)];
and compile this to produce a .o file, that .o file contains the symbol __foo along with size information. The size of the storage region __foo tells us how large "struct abc" is for our target system.
We can now use this information to configure something in the build.
I've used this trick, for instance, to determine which integer type is large enough to hold a pointer. (C99 gives us intptr_t, but that creates a C99 dependency).
This is something you can't do at compile time, because in C you can't retarget a typedef based on the value of an expression (even a constant one), and the preprocessor (#if, #ifdef) cannot portably evaluate things like sizeof (void *).
Re:No amount of documentation ... (Score:2)
While you should use portability mechanisms in the code itself, sometimes it is not practical.
The things in are constant expressions, and C (and to a lesser degree C++) have limited flexibilities in metaprogramming based on the values of constant expressions.
If you want to conditionally define something based on a function applied to the values in limits.h, you may have to get access to those values outside of the source and generate a header file with preprocessor symbols.
There is a need for build configuration which tailors some things to the target. Only, there is not a need for crappy build configuration.
Mod up (Score:2)
Packt are way too fond of publishing any old crap just to get an early book out on a niche topic. They have been known (by me) to randomly spam people who blog on their books' topics, asking them to review the book. Once they get you interested in the free book they start hounding you for a review on your blog. I wouldn't have minded TOO much if their books had anything worthwhile to write about.
Re:"the GNU way" == Garbage (Score:2)
Yeah, that whole GNU Compiler Collection thing is just a waste of time. Can't compile a binary out of anything. Thankfully Microsoft were forced to give away a free version of Visual C++ for some reason, having killed all the commercial competition. Also, Intel have released a compiler for linux, which you can actually run in a shell that just happens to be pre-compiled somehow. So, thankfully there are alternatives to GCC.
Re:NIGGA (Score:1)
I have to know. What the hell is the point of this shit? I mean, if it had a link to something, or a shout-out to GNAA, or just anything, I would understand.