Rating: 
Summary: Excellent book on programming
Review: This is a very well-written and interesting book which covers many aspects of programming, including algorithms, debugging, testing, performance, portability, design, interfaces, style and notation. The book's major strength is that the examples given are sufficiently deep to be useful and educational. There are many good exercises given for the reader to explore further programming concepts. Some of the mini-projects that are discussed include pattern-matching, a library to deal with data in CSV format and program that uses a Markov chain algorithm to generate readable prose. One minor flaw in this book is that almost all of the examples are written in C, C++ or Java, whereas the title of the book suggests a more generic approach. I'd recommend this book without hesitation to someone who has been programming for 2 or 3 years and wants to really improve their productivity and add a level of professionalism to their coding and program design.
Rating: 
Summary: an excellent book
Review: addison-wesley's computing series never fails me. and this book is not an exception. just as the author advocates, Simplicit, Clarity, and Generality are very important in our practice of everyday programming. but regrettably, most of us don't pay much attention to these 'minor' aspects. i find a lot of tips in this book are very useful. and to raise a good programming habit is invaluable. in short, this book is one of my favorite in computer books. (nearly all my favorites come from Addison-Wesley). but i got a little confused about the markov algorithm described in chapter 3. can any experienced programmer discuss it with me? your help is much appreciated.
Rating: 
Summary: A major disappointment
Review: After reading all these rave reviews, I bought the book, expecting gems. Instead, I got a bunch of boring aphorisms and silly rewrites of programs that are long in the tooth. If you've had anything but the most banal of computer science education you have already outgrown this book.
Rating:
Summary: We need to teach this to undergraduates
Review: All too often our undergraduate students are left to learn programming by themsleves. The universities do a very good job of teaching algorithms, theory and special parts of "systems" (compilers, operating systems) but we rarely see any book that guides the student from the introductory courses to more advanced programming. This is not a book about tricks or tips. It is a systematic exposition of various topics that are needed in practice. This is mmuch more than the earlier "Elements of Programming Style" by K and Plauger. It contains, for example, a chapter on profiling. No doubt every reader will have a list of topics that they would like to see included but the topics that are there are vital and very well treated. I hope that we will be able to teach a course based in part on this book at McGill.
Rating:
Summary: Good for pros, Great for beginners
Review: As seen below, ego-scratchers will complain that this book doesn't cover any new ground. However, this book is an excellent resource for software engineers of any skill level. Things I liked: The code isn't "baby talk" code like many books-- the examples have some real meat on them. Also, the description of quicksort in chapter 2 is the best one I've ever read. So, if you're the greatest programmer in the world, go write your own book. Otherwise, get this one.
Rating:
Summary: stuff that matters
Review: For the facts I have nothing substantial to add to the January 2001 reviews. I do programming since 1983. Started with Fortran, Pascal, Modula 2 and C. Read Bertrand Meyer's "O-O Software Construction" which opened my eyes how to design interfaces. I created code and rewrote code. I worked together with programmers of many kinds of personalities. Comparing my experiences with what Kernighan and Pike's book tells is, that this book really discloses the fundamentals of effective software development to produce maintainable software systems: simplicity, clarity, generality. And working with programmers who are on the way to discover or yet have discovered these pearls of wisdom is fun! BTW: "The Pragmatic Programmer" written by Andrew Hunt and David Thomas is another great book to consider.
Rating:
Summary: Snappy Reading and Excellent Advice with One Shortcoming.
Review: Hi, This book is great for programming style and clarity but there is a glaring flaw: The authors have a bad case of six (or eight) letteritus when it comes to variable names. Even though they advocate readable names for globals and functions, they still change "procedure" to "proc", "SIZE" to "SIZ" and "buffer" to "buf". Other than that it is a good book.
Rating:
Summary: A Disappointment
Review: I always have high expectations of Kernighan and I am not satisfied with this book. The writing is good, but the scope and depth of the content are questionable. The notion of "program" as portrayed in this book does not reflect the state of the art. There is no meaningful coverage of software reuse, adaptation, and evolution. There are no discussions on orthogonal aspects of development and deployment. If you write code that is to be configured and composed by persons other than yourself -- and code that does not have the unrealistic luxury of printing an error message (to what?) and exit (to where?) -- you should look elsewhere for serious help. More generally, this book is indicative of the scaling problems of Computer Science education. If one picked up a book entitled "The Practice of Woodworking" that took an approach similar to Kernighan's, one would not expect the book to address issues related to professional carpenters and house architects. In computer books, the vast differences between a "paper boat" program and an "aircraft carrier" program are not always honestly clear.
Rating:
Summary: Simple and excellent
Review: I am bemused by the disparaging comments of my fellow readers in regard to this book. Kernighan and Pike make clear their intent in the first paragraph of the preface to this book; it is about simplicity, clarity, and generality. To be sure, there is tinder here for short tempers and delicate egos. If you're under the gun, trying to duct-tape together the fifth release of some huge, unwieldy application, this book does not contain the short-term quick fixes you've been hoping for. If you're righteously convinced of your own sound practices and don't care to look at someone else's methods, this book may irk you. Kernighan and Pike have written a book about the most basic habits and outlook that a programmer should have. They have not tried to address all facets of programming. Instead, they sacrifice scope to make their points stand out all the more clearly. Would this be a better book if they had cast their net wider? Hardly. If you start off by applying the carefully thought out, methodical approaches described clearly throughout this book, your code will still hit abstruse bumps and strange circumstances. But most problems will succumb to the same analytical ways of thinking and tools that Kernighan and Pike have laboured to describe with such clarity. But don't imagine that I think this book is perfect; the authors have been doing many things in the same ways for a long time. Most often, this is because their methods are effective, but sometimes they are far too close to being cop-outs. For example, the idea that it's OK to just print an error message and bomb out if something goes wrong is laughable outside of the Unix command line environment, and is rarely appropriate even there. Fundamentally, though, if you can't solve the problems at the ends of the chapters (they're easy), or you think you can't possibly benefit from reading a book that troubles to describe quicksort (which you probably learned in CS-201), then there is likely nothing for you here. At least until you think to question your perspectives. Until then, I'll confess to a sense of relief that I don't have to work with you :-)
Rating:
Summary: Worth the money, but problems.
Review: I found the book enjoyable. Best parts are stories of the old days, and some good chunks of code. Bad things: 1. Apparently written to "cash-in" on trendy lore-of-programming books ("Code Complete" etc.). 2. Chapters end with exercises that *aren't answered*. Even on their web page; some are obviously speculative but some clearly have correct answers which I thought I was paying-for when I bought the book. 3. So I'm stupid: the Markov chain chapters left me confused about the algorithm itself. 4. The C++ Java "interface" etc. stuff seems tacked-on to a basically C-language orientation (see #1 above). There is virtually *no* treatment of GUIs. This could be a plus of course. But I still enjoyed the book....
| 
