Managing Projects with GNU Make: The Power of GNU Make fo... and over one million other books are available for Amazon Kindle. Learn more

Vous voulez voir cette page en français ? Cliquez ici.

Sign in to turn on 1-Click ordering.
Amazon Prime Free Trial required. Sign up when you check out. Learn More
More Buying Choices
Have one to sell? Sell yours here
Start reading Managing Projects with GNU Make on your Kindle in under a minute.

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Managing Projects with GNU Make [Paperback]

Robert Mecklenburg
3.5 out of 5 stars  See all reviews (2 customer reviews)
List Price: CDN$ 45.99
Price: CDN$ 26.30 & FREE Shipping. Details
You Save: CDN$ 19.69 (43%)
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Only 1 left in stock (more on the way).
Ships from and sold by Gift-wrap available.
Want it delivered Tuesday, September 23? Choose One-Day Shipping at checkout.


Amazon Price New from Used from
Kindle Edition CDN $18.95  
Paperback CDN $26.30  
Save Up to 90% on Textbooks
Hit the books in's Textbook Store and save up to 90% on used textbooks and 35% on new textbooks. Learn more.
Join Amazon Student in Canada

Book Description

Nov. 29 2004 0596006101 978-0596006105 3

The utility simply known as make is one of the most enduring features of both Unix and other operating systems. First invented in the 1970s, make still turns up to this day as the central engine in most programming projects; it even builds the Linux kernel. In the third edition of the classic Managing Projects with GNU make, readers will learn why this utility continues to hold its top position in project build software, despite many younger competitors.The premise behind make is simple: after you change source files and want to rebuild your program or other output files, make checks timestamps to see what has changed and rebuilds just what you need, without wasting time rebuilding other files. But on top of this simple principle, make layers a rich collection of options that lets you manipulate multiple directories, build different versions of programs for different platforms, and customize your builds in other ways.This edition focuses on the GNU version of make, which has deservedly become the industry standard. GNU make contains powerful extensions that are explored in this book. It is also popular because it is free software and provides a version for almost every platform, including a version for Microsoft Windows as part of the free Cygwin project. Managing Projects with GNU make, 3rd Edition provides guidelines on meeting the needs of large, modern projects. Also added are a number of interesting advanced topics such as portability, parallelism, and use with Java.Robert Mecklenburg, author of the third edition, has used make for decades with a variety of platforms and languages. In this book he zealously lays forth how to get your builds to be as efficient as possible, reduce maintenance, avoid errors, and thoroughly understand what make is doing. Chapters on C++ and Java provide makefile entries optimized for projects in those languages. The author even includes a discussion of the makefile used to build the book.

Special Offers and Product Promotions

  • Join Amazon Student in Canada

Frequently Bought Together

Managing Projects with GNU Make + sed & awk
Price For Both: CDN$ 52.60

  • sed & awk CDN$ 26.30

Customers Who Bought This Item Also Bought

Product Details

Product Description

Book Description

The Power of GNU make for Building Anything

About the Author

Robert Mecklenburg began using Unix as a student in 1977 and has been programming professionally for 23 years. His make experience started in 1982 at NASA with Unix version 7. Robert received his Ph.D. in Computer Science from the University of Utah in 1991. Since then, he has worked in many fields ranging from mechanical CAD to bioinformatics, and he brings his extensive experience in C++, Java, and Lisp to bear on the problems of project management with make.

Inside This Book (Learn More)
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index | Back Cover
Search inside this book:

Customer Reviews

5 star
2 star
1 star
3.5 out of 5 stars
3.5 out of 5 stars
Most helpful customer reviews
3.0 out of 5 stars Good book, but not for the absolute beginner April 29 2012
I use make for a variety of tasks. In addition to managing code compilation, I also use it to manage LaTeX document preparation. Before getting this book, I had cobbled together some (pretty clunky) makefiles that got the job done, but I wanted to do a better job and understand some of the snippets of makefiles that other's had shared with me; that's why I got this book.

The book is good, and contains a wealth of detail. However, it dives right in and makes a lot of assumptions about the reader's programming experience. For example, in the first motivational example, the author presents a program that counts the number of times different words appear in the input via the command line. No big deal, right? Well, he uses lex in that code. I get what he is trying to do; he's trying to show that make can do more than just call a compiler like gcc, but if you don't know what lex is, you're going to get all hung up on that. As you read the book, you need to keep a lot of place-holders in your head to keep track of things that have been introduced but not explained; as often the explanation comes much later on. I'd suggest that laying down a firmer foundation and holding the reader's hand early in the text would make the book a whole lot more accessible.

I did find this book useful, and I'm glad that I have it. I gave it three stars, though, due to the issues I've outlined above.
Was this review helpful to you?
4.0 out of 5 stars A great introduction to make Jan. 20 2010
Format:Paperback|Verified Purchase
I found the complexity level of this book just right for me; I've been toying with simple Makefiles for years and couldn't figure out some inconsistencies. The author explains pitfalls and common mistakes, the Makefile parsing process and the subtleties of variable assignment, which I found very valuable. I now feel ready to plunge in sterile reference manuals. Though it doesn't address autoconf which is possibly the most popular user of make, the book packs enough examples and thorough explanations to be worth its weight.
Was this review helpful to you?
Most Helpful Customer Reviews on (beta) 3.7 out of 5 stars  23 reviews
72 of 73 people found the following review helpful
4.0 out of 5 stars A much needed, and enjoyable, book about GNU Make May 16 2005
By John Graham-Cumming - Published on
I write a lot of Makefiles. In fact, I write a lot of Makefiles using

GNU Make and finally there's a book to complement the Free Software

Foundation's excellent GNU Make user guide. Also, finally, O'Reilly

has updated what must have been the worst book in their entire line

up: "Managing Projects with make"

Robert Mecklenburg's "Managing Project with GNU Make" is a must have

book if you end up writing or maintaining GNU Make Makefiles with more

than 100 lines in them. You don't need it if all your Makefiles are

created using ./configure, but every serious Makefile hacker should

read this book.

That's not to say that the book is perfect. Far from it. I was

annoyed while reading the book by the author's frequent, annoying

small errors (e.g. on p. 58 the author states that CURDIR contains the

argument of --include-dir when in fact it contains the full path of

the directory where GNU Make is looking for Makefiles) and over use of

the $(eval) (more on $(eval) below). In fact, the number of errors in

the book were surprising for an O'Reilly tome and it looks like the

edition could use a good proof-reading. I've sent in a detailed list

to the O'Reilly folks but nothing appears on their Errata web site


The section that describes the new $(eval) and $(value) functions

available since GNU Make 3.80 is excellent (pp. 82-86). And the book

contains a good discussion of the problems inherent in using recursive

make (pp. 108-116) and how to implement a non-recursive make

(pp. 117-123). The book is worth its cover price just for these three


Where I think the book really goes off track is in trying to shoehorn

too many things into GNU Make. Specifically, the author talks quite a

bit about ANT and spends an entire chapter showing how to replace ANT

with GNU Make. I found some of the things he thinks are wrong with

ANT to be silly: for example, "The Ant <mkdir> task does not invoke

the underlying mkdir program for your system. Instead, it executes

the Java mkdir() method of the class. This may or may

not be what you expect." Sure, if you are a GNU Make user you'd

expect that mkdir is mkdir the command; Java programms a probably

quite familiar with and are likely not to be confused. I

think the book would have been better without this chapter.

The section on parallel and distributed Make is really light.

Although this section describes the issues associated with trying to

parallelize a build, it wold have been nice to have a description of


There are only two books on GNU Make worth reading: this one and the

FSF's GNU Make manual. As I was reading Robert Mecklenburg's book I

couldn't help finding myself comparing it with the FSF manual (which

is the same as the info files installed with GNU Make).

Firstly, this isn't a good book to learn GNU Make from. Although Part

I of the book explains the basics of GNU Make with many examples, the

book does not provide a complete reference to GNU Make's language (for

example, Appendix A's list of command-line options is incomplete), and

has odd digressions (the section describing how += works (pp. 44-45)

makes it sound much more complex than it is) and ommissions (the

section on "Target- and Pattern-Specific Variables" (pp. 50-51) makes

no mention of pattern-specific variables at all).

Secondly, the author lurves the $(eval) function added in GNU Make

3.80. There are three problems with this: GNU Make 3.79.1 is commonly

seen in practice and doesn't contain $(eval), the implementation of

$(eval) in 3.80 has some bugs in it and the author uses $(eval) too

much, using it when it isn't needed. This hammer to crack a nut use

of $(eval) is annoying because it obscures simpler ways of writing


If you get this book and know a thing or two about Make jump directly

to Part II and read about benchmarking of Make, the really useful

debugging ideas and recursive/non-recursive make. Skip back to Part I

when you've got some time on your hands and need to have a fun read;

you'll know most of the material but there are gems worth finding.

When you are done with that have a good laugh about the "extreme Make"

in Appendix B. Skip over the description of the Linux Kernel

Makefile: it seems like it might be interesting, but isn't.

If you can only buy one book about GNU Make, then buy the Free

Software Foundation's GNU Make user guide. You'll be supporting the

people who actually created GNU Make, and you'll get a complete

reference to it. If you've already got the FSF book, then get Robert

Mecklenburg's excellent "advanced user's guide".
33 of 34 people found the following review helpful
1.0 out of 5 stars Terrible Dec 29 2009
By K. - Published on
Format:Paperback|Verified Purchase
I have almost no experience with writing makefiles. All I've done is edit existing makefiles until they work without really knowing what I am doing. I bought this book to fill in my knowledge. There seems to be a lot of information in this book. Unfortunately, there is a lot of information not in the book that makes it difficult to follow his examples. For example, on p. 5 there is text in there that makes up the file 'lexer.l', but the author doesn't say this. He simply puts that text on the page, calls it a 'scanner', then I see something called 'lexer.l' in the makefile he is using. It took me a while to figure out that the 10 or so lines of text he called a 'scanner' was in fact 'lexer.l'.

The author continually does this for at least the first 20 pages, where it took me hours to figure out what files he used and what were supposed to be in the files. This should have only taken me as long as it takes to type the files into the computer. There are supposed to be five files: counter.h lexer.h count_words.c counter.c and lexer.l. I don't understand why the auther cannot simply say "the text below define *.*", then write it out, instead of making the reader guess at what he is talking about. On page 20 he talks about refactoring the 'main' program, but what he really means is creating a new file called 'counter.c' not rewriting the 'main' program in 'count_words.c'.

It's too bad the author has decided to write in such an ambiguous style because his explainations of make features are very good, unfortunately, I can't verify this using his examples because he thinks his readers can read his mind.

The frustration caused by this lack of explicitness for his examples is the reason I give this book one star. Instead of simply using his examples, I have to figure out what the heck he is talking about, then try to use them the way he is. I'm spending orders of magnitudes more on this guessing than I am on learning make, which is why this book sucks. I'm only on page 20 and all ready I don't really want to use this book. I guess if you all ready know how to use make and just want a reference, this book is probably fine as you have plenty of your own examples to follow. But I do not.
6 of 6 people found the following review helpful
3.0 out of 5 stars Does what it should do July 1 2007
By Bas Vodde - Published on
I've used make and makefiles for many years. In my current product development there was suddenly a need for a little more than the standard make knowledge. For most Open Source tools there is a good O'reilly book, so I grabbed this one from the store.

This book exactly fitted to my need. It does what it should do, it explain make, and nothing more. Already after part 1 I got useful new bits of information. Nothing major, just small "ah-ha, that's how the do it"'s.

The book is structured ok (I felt it could be structured better, but have no suggestion how). It consists of basic and advanced parts. The basic part will cover rules, variables, functions and commands. The advanced will talk about large project, C++, Java, examples and some debugging.

All the basic concepts chapters were pretty good. Somehow I didn't enjoy the advanced chapters too much. I didn't feel I was learning much new things there. The Java chapter was a little odd. I've not met any Java developer who currently uses make, most have switched to ant quite some time ago (book was 2004, so might be changed in the fourth edition). The example makefile of the book was somehow not interesting. The second example makefile was the linux kernel. This was more interesting, but it didn't go into too much details.

All in all, I found it a good book. It gave me exactly what I needed. Somehow the writing style was a little dry. I couldn't really point my finger on what made it so.

I'll give it 3 stars. Not because it's not good, but exactly because it's a good book. However, it didn't give me something extra, which I always hope a book gives me.

Recommended when needing to know more about Make :)
8 of 9 people found the following review helpful
4.0 out of 5 stars Nice book; available on the net for free June 2 2007
By Amazon Customer - Published on
I've just begun reading the book and it's a nice book on GNU's make. As already mentioned, it is not a handbook but rather more like a discussion of how to best use make in your builds. That said, I'd like to point out that the text is available on the net for free. If you look at the associated O'Reilly web-page for this book, you can find the link entitled "Online Book" - click on that to see the index of the free, online book.
5 of 5 people found the following review helpful
1.0 out of 5 stars Not a good introduction Sept. 19 2011
By Brussels Lout - Published on
Format:Paperback|Verified Purchase
I do not recommend this book if you are new to gmake. It breaks the unwritten golden rule that new concepts should not be introduced using more advanced concepts not introduced until later. Makes sense doesn't it? Yet this book does it all the time. I found myself many times having to skip forward to look something up, only to have to skip forward again to look something else up. And by that time I needed knowledge of all the material skipped. Chicken and egg. There's a hole in my bucket.

I found it very frustrating.

Moreover, you will need to be proficient in sed and awk to understand some important examples. You will need familiarity with lexer.

This book may serve as a look-up manual for someone already familiar with make. But if you want to learn the tool for the first time, this is not a good place to start.
Search Customer Reviews
Only search this product's reviews

Look for similar items by category