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....
Rating: 
Summary: I liked it.
Review: I have been teaching myself programming for the past few years, and the programming books I've read teach specific languages. This is a general programming book that teaches concepts that I could not learn anywhere else. Obviously, if you already understand the information in the book before you read it, you will not profit from it, and, from what I understand, it does not break new ground. I think it is a pretty clear and concise introduction to the language-independent parts of programming, such as data structures and algorithms. I'm not ready for the Knuth books yet, and this book was a nice introduction.
Rating: 
Summary: Doesn't go beyond the basics
Review: I really wanted to see more on software engineering, testing tools, etc. I think this book, if done well, would have been a huge tome. Instead, it is not a very insightful book for an experienced programmer. While it would be very useful for a novice or intermediate programmer, I'd have to recommend Code Complete over this one.
Rating:
Summary: Concise, well written, full of good and long-lasting advice.
Review: I was surprised by some unfavourable reviews of this book, but they were probably by people expecting something different. This is not a handbook or cookbook. This book is about how to do things wisely... it is about long-lasting principles about how to program in practice. It is not a book about how to program in the latest version of a given compiler and windowing system. I am not a professional programmer, but I do a fair bit of programming and lately software design for our research work. I have also read some of the earlier books by the same authors. Not everything was new to me, but nontheless it was never boring reading... I do not mind paying for a book full of ideas, and few instructions. This is a book I will not open every day, but having read it has made me a better and wiser programmer every day.
Rating:
Summary: Best book of its kind
Review: I've long recommended Pike's "Notes on Programming in C" on my web page. This book includes most of the content from that essay and much more, but is still thin and concise. What I like most about this book is that they justify all of their recommendations, show both good and bad examples, and keep the discussion grounded in actual code (rather than abstract principles). Other things I liked: - begins with a discussion of programming style and aesthetics - they critique some of the designs that they have been involved in, such as C's stdio and string handling libraries - they discuss the unique design issues presented by library design - they give examples in C, C++ and Java, and give an honest appraisal of the tradeoffs involved in each language. - FINALLY, excellent single chapter descriptions of systematic approaches to debugging and testing! - they face up to some of the tough design choices that must be made outside the UNIX Ivory Tower (rare for these authors). For example, they sacrifice UNIX consistency in one application so that the application will behave consistently across UNIX and Windows. Minor gripes: - still skirts around tough design issues in error recovery and reporting; they advocate the "print a diagnostic and exit" approach (which is totally inappropriate for library code), and don't discuss the tradeoffs - a few of the principles they cover will be trivial or obvious for experienced programmers
Rating:
Summary: Lots of useful thoughts
Review: I've never regretted when I bought a book written by B.Kernighan. This is not an exception. The book doesn't teach you any particular languages or algorithms. It just shows how to write good programs.
Rating:
Summary: Wonerful book
Review: If you buy one book on general programming practices, make this it. It is extremely good.. I learned a lot about how to create good, maintainable programs without many bugs, and many ideas on good design for performance as well.
Rating: 
Summary: Reasonably well-done but nothing new
Review: If you have not read Steve McConnell's books this book is worth reading. The supplementary reading lists at the end of each chapter are valuable (again, if you have not already read the material cited). I was disappointed in the lack of new material and/or fresh perspective on older material. Read McConnell, Stroustrup, Lakos, Gamma et al, and Scott Meyers and skip this one
Rating:
Summary: For new coders a five star, for old timers a one.
Review: If you've been around the block a couple of times don't waste your time. If however you are new and would like to see what's in this field do read carefully for the book contains many gems. Well written and carefully prepared.
Rating:
Summary: No waste of time here
Review: In computing, the learning curve is doubly steep. Not only do we have to learn very complex operations, but we have to learn them at a pace unrivaled in any other field. Furthermore, the equipment improves at a rate that simply boggles the mind. In this frantic environment, we rarely have time to read our code twice, much less read a book about code. Therefore, when we do read, we must make every minute count. This is one book where your count of wasted minutes would be a very small one.
Some of the tips in this book are obvious in retrospect, yet ones that you probably would not think of. My favorite is the fact that due to the changes in processors, a double precision floating point arithmetic operation can be faster than the equivalent one for integers. In the "old" days, the gospel was that you must avoid floating point operations unless absolutely necessary, to avoid the degradation of performance.
Other tips, such as methods to assure you comment what is necessary, taking a few minutes to learn simple performance features, debugging and testing guidelines; portability issues and basic algorithm analysis should cause you to pause for a moment. Even in our hectic development environments, stopping and analyzing your code is a necessity.
It is difficult to conceive of someone who will not find a tip in here that will justify the cost of the book. Unless of course, you are one of the authors. I listed it as one of the top books of the year in my On Books column that appeared in the September, 1999 issue of _Journal of Object-Oriented Programming_.
| 
