|
Managing Projects with GNU Make (Nutshell Handbooks) | 
 enlarge | Author: Robert Mecklenburg
Publisher: O'Reilly Media, Inc.
Category: Book
List Price: $29.95
Buy New: $15.00
You Save: $14.95 (50%)
New (28) Used (9) from $15.00
Avg. Customer Rating:  12 reviews
Sales Rank: 176048
Format: Illustrated
Media: Paperback
Edition: 3
Number Of Items: 1
Pages: 300
Shipping Weight (lbs): 1.1
Dimensions (in): 9.1 x 6.9 x 0.9
ISBN: 0596006101
Dewey Decimal Number: 004
EAN: 9780596006105
ASIN: 0596006101
Publication Date: November 19, 2004
Availability: Usually ships in 1-2 business days
|
| Editorial Reviews:
Product Description
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.
|
| Customer Reviews: Read 7 more reviews...
 Does what it should do July 1, 2007
2 out of 2 found this review helpful
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 June 25, 2007
1 out of 2 found this review helpful
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.
 Excellent resource for programmers June 15, 2007
Make has been an icon in the GNU / Linux world for over thirty years now, and continues to be one of the most used utilities to ever be released on the platform. A good number of other projects have risen to take its place as an automated-build utility, but as of yet, none have been able to unseat Make. Some see Make as being too arcane and finicky to survive in the once it is confronted with an advanced, user-friendly, utility of the same purpose. However, as it stands now, Make is still the standard in the `industry', and Makefiles are distributed with almost every major software package on the GNU / Linux platforms (as well as some others!).
Any avid Linux or UNIX power user, as well as most system administrators, will need to have some knowledge of Make to do what they need. Programmers, on the other hand, need to have an intimate knowledge of Make, Makefiles, and what the abilities of Make are. This book is more for the latter group, and goes into detail that the former group probably doesn't need to know too much about. For the former group, I would suggest a more concise, simplified version of this book. For the programmers, this book is a must-have.
As I mentioned before, Make can be a little finicky at some points. This, some may say, is an understatement. There are a number of "gotcha's" in the language, as well as a lot of `hackish' features (when I say `hackish', think Perl `hackish'). Perhaps, more importantly, however, there are a lot of fairly advanced features that Make can handle, and few people seem to use these. This is where the book really shines - it goes over the rarely-seen, but perhaps some of the most advanced features, of the Make utility.
This might seem obvious to most, but the novel assumes that the reader has previous programming experience, and throws C++ code blocks at the reader on the third page of the first chapter. If you don't have any programming experience, you probably shouldn't be reading this book anyways - but I thought it worth mentioning.
The primary content of the book is split into two sections - basic topics, and then the more advanced topics. The author does an excellent job of starting out with the absolute basics, and slowly progressing into the more advanced topics at an easy-to-follow pace. I never felt like the pace was too fast, and the author does an excellent job of giving examples for each of the topics that require one. Each example is explained in detail, with an added bonus of a few "what-ifs" at some points.
In fact, this leads into one of my few complaints with the book. There is so much code, and so much text, and... well... nothing else. There are maybe a dozen and a half pages in the book that aren't just one big solid block of text. After a while, it becomes hard to take. It doesn't help that each page looks almost exactly the same, so after a while, things start to kind of bleed together. In the next edition, it would be nice to maybe see some page styling, new layouts, some more images / tables where possible, maybe some funny side anecdotes or something - *anything* to give the text some life.
Once you accept the pedantry of the text, you will find that it is extremely well written, and easy to understand. There were very few instances in which I had to re-read something multiple times to get an understanding of what was being communicated, and the author's ability to describe even complex topics in simple terms is really impressive at some points.
The advanced sections of the book delve into some topics that I didn't expect to see, and was honestly pleasantly surprised that they made their way into the text. Included in the list of `surprise topics' are alternatives to Make, benchmarking Make, parallel Make, distributed Make, third-party programs that work with Make to add new functionality, and even sections on Cygwin and Make.
Also in the advanced partition of the book were two other sections that I found to be extremely helpful, if not essential: Debugging Makefiles, and Example Makefiles. The Example Makefiles chapter includes both excellent Makefile examples as well as discussion of what is happening in them. The Debugging Makefiles chapter goes over a lot of the "gotcha's" in the language, how to find a problem, and then possible fixes for it. These were both nice touches to the book, and are examples of the dedication the author shows to covering the more difficult parts of the language.
For the purposes of an in-depth, complete tutorial in Make, this book succeeds wonderfully. The author, although a little pedantic in the design and layout, does an excellent job of communicating each lesson. I recommend this book to any professional or hobbies programmer looking to get a little extra control over the build process.
Nice book; available on the net for free June 2, 2007
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.
Good Overview March 14, 2007
This book is a good place to start for learning how to manage large projects with GNU Make. It covers the basics and then moves on to specialized topics including writing portable makefiles, increasing makefile performance, and debugging makefiles. I've been using GNU Make for years and still found the book worth reading.
|
|
|
Powered by Apache on Ubuntu Linux with php5, xml, mod_rewrite
Warning: AOM::include() [function.AOM-include]: URL file-access is disabled in the server configuration in /home/blacknight/linuxmall/web/aom.php(3) : eval()'d code(1) : eval()'d code(1) : eval()'d code on line 7108
Warning: AOM::include(http://www.linuxmall.net/textlinks.php) [function.AOM-include]: failed to open stream: no suitable wrapper could be found in /home/blacknight/linuxmall/web/aom.php(3) : eval()'d code(1) : eval()'d code(1) : eval()'d code on line 7108
Warning: AOM::include() [function.include]: Failed opening 'http://www.linuxmall.net/textlinks.php' for inclusion (include_path='.:/usr/share/php:/usr/share/pear') in /home/blacknight/linuxmall/web/aom.php(3) : eval()'d code(1) : eval()'d code(1) : eval()'d code on line 7108
|
|
|
| |
