Customer Reviews

Autotools: A Practioner's Guide to GNU Autoconf, Automake, and Libtool

5 star:		(6)
4 star:		(0)
3 star:		(0)
2 star:		(0)
1 star:		(1)

 

 

If there was ever a tool that needed a book it's Autoconf (and related scripts). Happily, Calcote has done a great job of describing, in detail, a collection of tools that can seem opaque at first glance (also at second glance). This book is vital for anyone who needs to work with Autotools and I wish I'd had it years ago.

The final chapter (A catalog of tips and reusable solutions for creating great projects) is fantastic because it dishes up a collection of practical, real solutions to problems users of Autotools will encounter. Above all, the book shows that it was written by someone who truly understands the set of tools, and thankfully is able to write clearly.

He doesn't shy away from getting into difficult details (like the M4 macro language) and chapters 8 and 9 are an exposition of the use of Autotools for an actual, large project showing what a real-world use of the tools looks like. Those 50 pages are probably the most valuable in the entire book.

Highly recommended for anyone who needs to use Autotools.

To quote the first page of the introduction "... and there are also many developers who hate the Autotools - with a passion". I think that I can safely say that I started out in that camp. In short, I find that autotools projects too oftern do not live up to the aim of being cross platform, and more philosophically, that they encourage non-standard C/C++ "standard" libraries and compilers. But I'm not writing a review of a book about Autotools, not the Autotools themselves.

The book is organized as 2 introductory chapters, then 5 chapters on autoconf/automaka/libtool. That's followed by 2 chapters covering an example of converting a non-trivial project to use Autotools. The last two chapters cover M4, the macro language Autotools is based on, and then a catalog of tips. This isn't a reference book, you won't find an exhaustive list of all the Autotools macros.

Even if you are not going to use autotools extensively, I found the introduction to "make" very clear. In fact, as good an introduction as anything I've read. Though I've read the O'Reilly books on "make" and "GNU make", I still learned a few things about "make". If, like me, you are just an occasional user of Autotools, then you'll find it useful if the "configure" script doesn't work out of the box. As an example, I tried to build CUnit just after reading this book. I followed the "readme.txt", but it didn't work. Running one extra command and adding some command line options sorted it out. If you're going to be using Autotools extensively, then you'll obviously want to read this book.

Calcote does go out of his way to recommend platform-independent practices, even going as far as to accommodate make tools other than GNU make. Example code is marked with numbered dots, which are then referred to in the text. I found that very readable and easy to follow. In general the tone of the book is quite calm and neutral (compared to some authors on GNU software who seem to get, well, a bit over-excited about their subject).

The only weakness I felt was in the chapter on libtool and dynamic linking. Mac OS X ought to have been mentioned (perhaps it was omitted because of its peculiar "app bundles"). I think that the difference between UNIX dynamic libraries ought to have been mentioned (all global data/functions exported by default, like static libraries) and Windows dynamic libraries (only data/functions decorated with __declspec(dllexport) are exported, for performance reasons).

In the end, did this book soften my views on Autotools? Yes, a bit. It may not match my ideals, but I can't imagine that Autotools is going to be replaced any time soon. So I'm better off knowing about how to use Autotools.

This is an excellent book! It is aimed at open source package maintainers, however I read it because I just wanted to know how to use
Autoconf and Automake properly. For this objective it was perfect and worth every penny. The book develops a project logically, starting with a hand written makefile, turning this into a template for Autoconf then using Automake and Libtool. In later sections the author gives an account of how he took an existing open source project and converted it to use the Autotools. There is a chapter on m4 and another containing tips and advice from the author's hard won experience. Everything is well explained and the philosophy behind these tools is made clear. There are plenty of useful footnotes to the text and code listings are particularly well referenced in the text.

While it is true that this book contains much content that can be found in other places, i.e. online and for free, the author explains things better than any online source. For example, standard GNU documentation rarely states why a particular design decision was made; this book explains some of these.

This book is a wish-come-true for all those looking for an autotools introduction. The author is an experienced software engineer, but, unlike most experienced engineers, takes his time to explain the intricacies of autotools in an accessible manner. He starts off with an autotools history and then proceeds from the basics of autoconf, automake and libtool to more advanced topics (including an introduction to m4). All of this using an open source project -- from the ground up! The best part of this book is that the information provided is just enough to get the reader to actually look for more information about autotools on his or her own. I highly recommend this book for anyone looking to understand how the autotools toolset works and/or how to effectively use it.

I had high hopes for this book but it's the worst I've read in recent memory and I'm very disappointed.
1) Author is very opinionated and makes very broad statements/judgements without any supporting evidence. Some of which I've seen disproved over years in the industry.
2) At random points throughout the book we have it explained to us that tool X written in 1988 to address issues with tool Y in 1987 and that it's functionality is extremely limited but that's ok because the original design goals were A & B because in 1987 blah blah blah... This book was written in 2010, stop telling me that the tools are crap and then justifying them. I want to read about it from a modern perspective, what can I use it for now? How can it be used today? What are it's strengths and how can I utilise them, etc.
3) Strong sense of passionate loyalty and old-school purism rather than pragmatism. Similarly, more of an academic feel than a real-world feel (for lack of a better description).
4) Explanations and even simple diagrams are ambiguous and unclear.

I got halfway through this book and I can't take it any more. I've gone from having a lot of enthusiasm on the topic to thinking the only one, single thing the autotools suite has going for it is incumbency. I'm going to just read up online and look at how some large oss projects do it instead; I hope I'm wrong. I do not recommend this book.

A recommended choice for programming collections is John Calcote's AUTOTOOLS: A PRACTITIONER'S GUIDE TO GNU AUTOCONF, AUTOMAKE, AND LIBTOOL. Autotools are used by thousands of open source software packages but have a reputation for being difficult to learn. This is the first title to offer programmers a tutorial to the GNU build system, and is a pick for any programming collection.