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.

Amazon.com® Reader Reviews (Ranked by Helpfulness)

Average Amazon.com® Rating:  Based on 14 Ratings

Does what it should do - 2007-07-01
Reviewer Rating:
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 :)

Well organized, competent but uninspired and biased - 2007-06-25
Reviewer Rating:
Mr. Mecklernburg is definitely an expert in GNU Make and the book shows it. The information it contains is well organized and the author doesn't spend precious time on non-essentials.

The downsize of the book consists in the total lack of fun it produces. The reader has no joy while learning about make and he may quickly find himself yawning at pages and pages of explanations with little or no examples that smooth out the learning curve.

The book seems as if the author tried to show off his knowledge with the best eficiency per page and in the smallest number of pages. He succeeded, at least with me: I am convinced that Mr. Mecklenburg is an excellent engineer but a terrible teacher.

Besides the content not being enjoyable, it is so much biased towards *nix that the Windows programmer righfully asks himself "what about me"? The solution offered by Mr. Mecklenburg for Windows consists in the... Cygwin environment. I'll abstain from commenting on this suggested choice.

Despite its drawbacks, the programmer may find enough material to learn from it and get the job done. But make no mistake: this is not a feat and you'll need quite some determination to finish this book and extract something useful out of it.

Most information is useful. Slightly disorganized, which causes a very slow read. - 2009-07-18
Reviewer Rating:
Overall the book presents all the information you need to start using make - which is a lot of information. However, the writing style used when he's presenting sections that are supposed to be "follow along", leave a lot of holes and become tedious to figure out.

There's also a lot of "but we'll touch on that later" - which puts you in the position of having to read through a part, knowing that he'll explain something better later in the book, which will for the moment, leave you wondering what it is he's talking about. Unfortunately he does this a lot, even right in the middle of a follow along example. Arg.

I give it three stars because there aren't any other make books on make. This book does cover a lot of information and will definitely help you get started with make. Just don't expect to breeze through it without re-reading pieces of it 5 or 6 times. And definitely make sure you look at the errata for corrections.

Terrible - 2009-12-29
Reviewer Rating:
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.

An embedded developer point of view - 2009-12-13
Reviewer Rating:
I use GNU make in all my embedded firmware projects, under Linux, DOS and Windows.
This is a good book if you already know a basic use of "make". If you are completely new to make you should first search on-line documentation, I suppose.

I was a recursive-make fan before, but now I find that the non-recursive approach suggested here is really interesting. Probably the best is a mixed-architecture.

I don't like the implicit rules usage promoted: I prefer to define all the compiling options explicitly.

Make is a strange, very powerful non-procedural language for projects managing, and this book tries to explain its obscure characteristics.

If you plan to use the examples as a base for your own makefiles, take a look at the erratas on the O'Reilly website (there are some typos in the less common used procedures, personally I've found a lot in the make-depend parts).

Browse Similar Topics

Top Level Categories:
Operating Systems
Programming

Sub-Categories:
Operating Systems > Linux
Linux > Programming
Linux > Shell Utilities
Programming > UNIX