In weniger als einer Minute können Sie mit dem Lesen von Autotools auf Ihrem Kindle beginnen. Sie haben noch keinen Kindle? Hier kaufen Oder fangen Sie mit einer unserer gratis Kindle Lese-Apps sofort an zu lesen.

An Ihren Kindle oder ein anderes Gerät senden


Kostenlos testen

Jetzt kostenlos reinlesen

An Ihren Kindle oder ein anderes Gerät senden

Jeder kann Kindle Bücher lesen  selbst ohne ein Kindle-Gerät  mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.
Autotools: A Practioner's Guide to GNU Autoconf, Automake, and Libtool

Autotools: A Practioner's Guide to GNU Autoconf, Automake, and Libtool [Kindle Edition]

John Calcote
5.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)

Kindle-Preis: EUR 19,33 Inkl. MwSt. und kostenloser drahtloser Lieferung über Amazon Whispernet

Weitere Ausgaben

Amazon-Preis Neu ab Gebraucht ab
Kindle Edition EUR 19,33  
Taschenbuch EUR 33,50  

Kunden, die diesen Artikel gekauft haben, kauften auch



The GNU Autotools make it easy for developers to create software that is portable across many Unix-like operating systems. Although the Autotools are used by thousands of open source software packages, they have a notoriously steep learning curve. And good luck to the beginner who wants to find anything beyond a basic reference work online.

Autotools Autotools is the first book to offer programmers a tutorial-based guide to the GNU build system. Author John Calcote begins with an overview of high-level concepts and a quick hands-on tour of the philosophy and design of the Autotools. He then tackles more advanced details, like using the M4 macro processor with Autoconf, extending the framework provided by Automake, and building Java and C# sources. He concludes the book with detailed solutions to the most frequent problems encountered by first-time Autotools users.

You'll learn how to:

  • Master the Autotools build system to maximize your software's portability
  • Generate Autoconf configuration scripts to simplify the compilation process
  • Produce portable makefiles with Automake
  • Build cross-platform software libraries with Libtool
  • Write your own Autoconf macros

Autotools focuses on two projects: Jupiter, a simple "Hello, world!" program, and FLAIM, an existing, complex open source effort containing four separate but interdependent subprojects. Follow along as the author takes Jupiter's build system from a basic makefile to a full-fledged Autotools project, and then as he converts the FLAIM projects from complex hand-coded makefiles to the powerful and flexible GNU build system.

Über den Autor und weitere Mitwirkende

John Calcote is a Senior Software Engineer and Architect at Novell, Inc. He's been writing and developing portable networking and system-level software for nearly 20 years and is active in developing, debugging, and analyzing diverse open source software packages. He is currently a project administrator of the OpenSLP, OpenXDAS, and DNX projects (open source software available at http: //, as well as the Novell-sponsored FLAIM database project (open source software available at http: //


  • Format: Kindle Edition
  • Dateigröße: 1135 KB
  • Seitenzahl der Print-Ausgabe: 360 Seiten
  • Verlag: No Starch Press; Auflage: 1 (10. September 2010)
  • Verkauf durch: Amazon Media EU S.à r.l.
  • Sprache: Englisch
  • ASIN: B003WUYEL6
  • Text-to-Speech (Vorlesemodus): Aktiviert
  • X-Ray:
  • Durchschnittliche Kundenbewertung: 5.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
  • Amazon Bestseller-Rang: #216.169 Bezahlt in Kindle-Shop (Siehe Top 100 Bezahlt in Kindle-Shop)

  •  Ist der Verkauf dieses Produkts für Sie nicht akzeptabel?

Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr


4 Sterne
3 Sterne
2 Sterne
1 Sterne
5.0 von 5 Sternen
5.0 von 5 Sternen
Die hilfreichsten Kundenrezensionen
2 von 2 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Perfect Job! 2. Januar 2013
Von Wolfgang
Format:Taschenbuch|Verifizierter Kauf
Very well explanation of Autotools, even for beginners. Reading the man pages did not give me the overiew to this tools, but this book does.

Practical examples included.
War diese Rezension für Sie hilfreich?
Die hilfreichsten Kundenrezensionen auf (beta) 4.5 von 5 Sternen  13 Rezensionen
22 von 22 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Just what the doctor ordered 23. September 2010
Von John Graham-Cumming - Veröffentlicht auf
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.
12 von 12 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Clear and well written 12. Oktober 2010
Von Paul Floyd - Veröffentlicht auf
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.
8 von 8 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Autotools 19. März 2011
Von G. Taverner - Veröffentlicht auf
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.
3 von 3 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen a book better than the Internet 24. Oktober 2011
Von Jeff - Veröffentlicht auf
Format:Taschenbuch|Verifizierter Kauf
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.
5 von 6 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen You need this book. 23. Februar 2012
Von Richard M. Snoby - Veröffentlicht auf
Format:Taschenbuch|Verifizierter Kauf
Let me begin by saying that I've never written a review of anything I have purchased on Amazon before. No real reason to do it, until now.

Since 2000 I've been writing makefiles and "makeries" for embedded products. I've been doing this with straight makefiles calling gcc and ld for Cisco and before that Scientific Atlanta. These have been pretty big projects so I feel confident when I say I understand makefiles and embedded make systems.

Some of our latest products we began using Buildroot to configure and use open source projects and that was a crash course in USING autotools to configure and build open source projects. These projects always targeted a non x86 instruction set and utilized the -with-sysroot option. The entire time we did this only once did I have to get inside a projects files to update it to use the latest libtools to fully support cross compiling properly.

What I took away from those projects was that I needed to learn how to instrument some of our in house code projects to use an autotools based make system. If it's good enough for GLIBC it's got to be good enough for what we do.
I searched and scratched around for a good tutorial on how to do a basic autotools based make system and could never find one that had enough information to where I was not going to have to spend months attempting to figure out autotools and I gave up.

Then last month I came across a partial online version of this book and it was EXACTLY what I was looking for. Even before I got through the 3rd chapter I order the book from Amazon. This is one of those books that you will always keep around just to have as a reference.
This book is well thought out and you can tell that A LOT of time went into this book. Probably countless hours of research and time spent online. The example takes you from ground zero through each component of autotools in a very real world implementation.

If you are involved in your companies make system or you want to learn how to properly support an open source project online, this book is money well spent.
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.
Kundenrezensionen suchen
Nur in den Rezensionen zu diesem Produkt suchen

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Erster Beitrag:
Eingabe des Log-ins

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen

Ähnliche Artikel finden