Rating: 
Summary: A hypocracy?
Review: It seems that at least one of the author (Brian W. Kernighan) plays a hypocracy here. While he's advising about clarity (easy-to-read programs), he himself created tens of very difficult names for C functions, file names, constants and variables; and he DID NOT APOLOGIZE for it, BEFORE giving so many advices in this book. Brian should at least apologize for inventing these (among many) names : execve, execlp (and many other various names for function to execute programs), printf, scanf, longjmp, ls, ln, lp, etc, etc. He should mention what ve in execve, what lp in execlp, and so on (for various exec). He should apologize for making printf and scanf (print and write is better), longjmp instead of longjump (why you so ugly in removing the 'u'?), ls instead of list (4 is not too much), alias (or link) instead of ln, and print (or printer) instead of lp.I also disagree with advice of style like this if (cond) { block(); } In my experience, this is better if (cond) { block(); } Many of the advices in this book have been proposed (in separate books) by many authors.
Rating: 
Summary: One of those books that will make you a better programmer
Review: Simplicity, Clarity and Generality are indeeds the qualities of fine code. This is one of the few books that strives to make you a better programmer. Most books are about how-to, this is a book that goes beyond that and gives you information that can make you better. The other two books that do this for me are "Programming Pearls" by Jon Bentley and "Refactoring: Improving the Design of Existing Code" by Martin Fowler.
The pedigree of the authors is something that you should not dismiss lightly, after all, Brian Kernighan is the "K" in the K&R book, and also with Rob Pike the author of "The Unix Programming Environment".
Lots of good stuff.
Rating:
Summary: Out of focus
Review: Sometimes even the greatest masters make minor works. Brian Kernighan is a master. And this book is a minor work. Why? Take a look at the TOC. It refers to, at least, 5 complicated topics wich deserve nothing less than a single book each one. How can someone cover decently them all in just one 267 pages book? Once you finish each chapter remains the feeling that it was just a glimpse, far from a good explanation. It's certainly an above the average book. The authors know what they are talking about. But you would be much better served by the suplementary reading at the end of each chapter. At least, they sugest you the really good books. This is also an Unix biased book. Kernighan and Pike don't like interactive debuggers. And they don't care too much about user interface. If you are on the Windows/Mac/Palm/etc side of programming, you'll probably see things a little diferently.
Rating:
Summary: Best General Programming Book in Years
Review: The book covers topics such as style, design, interfaces, notation, debugging, testing, performance tuning, and portability. Each of these topics gets its own chapter and is covered pretty throughly. The writing is generally very interesting though at times it does get a little too much into details. It must have been interesting. I have finished reading it in less than 24 hours after having received it. This is something I've never done with a computer book before!! The book does live up to its goal. I think any programmer (even with 20 years of experience) who reads this book will gain something from reading it. Before you think that I think the book is perfect, I will point out some areas where I think it could be improved. First, I think the book is too focused on C. This is not surprising given that Kernighan is one of the authors. Personally, I have always believed that C is a language that encourages bad programming practices. In a few places in the book, I see some of those in the code that is presented. The other area I was disappointed in was that there was not much on object-oriented programming practices. Beyond that, I saw something I do not believe should be in any good OO program. That something was a public instance variable. A few places I disagreed with the authors on style issues. However, all of these problems are fairly minor and will hopefully be corrected in the next edition. In conclusion, I think this is a book that all programmers should read at least once. I know I will keep my copy on my shelf for those times when I have questions like "how can I optimize this code?". It really is the best general programming book that has been published in years.
Rating:
Summary: Good text, but take with salt
Review: The text of the book is good and gives some very good advice about programming. But it is important to realize that they are only suggestions, and should sometimes be disregarded.
Rating: 
Summary: Pearls of Wisdom
Review: There are a number of tips that a programmer can take away from this book. The highlights of this book have been pointed out by earlier reviewers, so let me just mention one thing. Any philosophical person knows that knowledge can be taught and transmitted, but not wisdom. This book has, by the authors' own admission, been written on the basis of years of personal experience: good and bad. They are wiser because of that, but have they been succesful in transmitting that WISDOM to their readers? I am confident they have not been. One cannot "learn" something unless he has experienced it himself. This is a fundamental tenet of Eastern philosophy. The reviewers who are so appreciative, if they are truly so, are so, because they personally relate to the words of advice given by Kernighan and Pike. A person who has just been introduced to function macros neither understands nor appreciates the fuss the authors make over the usage of these constructs. On the other hand a user who has already been bitten by the bug would have felt "Aha! how wise! They are perfectly right!" In summary, my theses is that this is a good book, but if you are a novice programmer who expects to quickly get wise by reading this book, it may not be possible. Note, however, that I would say the same damn thing of all books in this genre: writing solid code and other books in the microsoft press stable.
Rating:
Summary: A great book if you want to be a professional programmer
Review: There is no doubt, this is a good book. In my opinion it focuses on the right aspects of programming and it does it in a concise and enjoyable way, and even better it does it on about 250 pages only. So, in fact I can manage to read it during hectic working days, not just buy it and decorate my bookshelf with it. I would recommend it to any beginner who wants to turn into a professional programmer. For the professionals who have been in the game for some years, it works very well as a reminder of what we should focus on to stay professionals. However, I feel it lacks something on how to handle really big software systems. But, together with the books by Steve Maguire and The Mythical Man-Month by Frederick Brooks, I would say you have a very good ballast as a professional programmer.
Rating:
Summary: A pragmatist's dream
Review: This book conveys that languages may come and go but time honored design principles and techniques will always remain the foundation for solid systems. A wonderful book for both novice programmers and experts alike.
Rating:
Summary: Compare it to Code Complete
Review: This book has all the details of Code Complete, but in 1/4 of the book. It is a really good book.
Rating:
Summary: A guide for real programmers
Review: This book helped me get beyond individual languages, op systems, and tools, into the heart of programming.
It's about solving problems and about getting clear on what I am doing before I start pounding the keyboard.
The sections about specific languages are useful, but not nearly as interesting as the general topics.
The sections on debugging are specially helpful.
| 
