Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin Series)

Every so often, a book comes along that codifies best practice in a way that manages to illuminate the path from where things are right now, to a better place that we'd rather be -- things like Fowler et al.

This book has changed the way I code, hopefully for the better! Fittingly for a book about clean coding, it is cleanly written with clear examples and case studies.

I knew this was going to be an excellent book from the moment I heard Uncle Bod describing his ideas of Clean Code at his key note at an ACCU conference. I bought the book there and then, but didn't start reading it until a couple of years later. More recently I got it signed by Uncle Bob at Skillsmatter. After just a few pages it propelled itself into my top three books every programmer should read (behind Kent Beck's Test Driven Development and The Pragmatic Programmer by Andy Hunt & David Thomas) and at the end it's still there. The chapter on comments is worth the price of the book alone. I have worked in places over the last few years, where comments have been encouraged to explain the code, rather than writing code that explains itself. Another great chapter is the one on functions and the advice to keep them small is especially good and compelling. As I look back over the table of contents now, every chapter that describes how to improve an aspect of code is an absolute mine of good advice. The final few chapters contain a number of refactorings. One on an application from the ground up and the others on existing code written by other people. This is the only place where the book got gratuitous and I must admit I skipped most of the final refactoring. The final chapter is a summary of the advice given in the rest of the book and something I will find myself referring to again and again. If you've read Test Driven Development and The Pragmatic Programmer, make sure you read Clean Code next.

This is a great book, and one which any developer will learn a great deal from. In most respects, it is a five-star book, but... the title is misleading. By rights it should be called "Clean Java Code". Let me explain: I am an ActionScript developer, and bought this book to improve my code style and structure. For the most part, it has done that: the chapters on naming, comments, functions and classes are absolutely superb. But then, huge swathes of the book are devoted exclusively to Java, and use some fairly complex (and, in my opinion, not very well formatted) code to convey their intention. I don't generally have a problem with using Java-oriented books to learn more general programming concepts (Martin Fowler's "Refactoring" and O'Reilly's Head-First Design Patterns are both books I would recommend to anyone, regardless of their language-of-choice), but around 1/3rd of Bob Martin's book is virtually impenetrable to anyone who does not already have significant Java experience. That said, I should re-iterate that this book will be hugely valuable to any programmer. I just wish that they had tried to use a little more pseudo-code and a little less real-world examples, with all of the complexities entailed, and I think a lot could have been done to make the Java code more readable for users of other languages.

So good. So easy formulated. So useful. A lot of things are so obvious, but for some reason not many developers are following such elementary rules. Highly recommend to read, and doesn't metter if you experienced developer or just begginer. I also wish this book to be translated on indian languages. Guys, I very much like you. We are very close mentally. I have a lot of indian friends due to proffession. But, the way you coding is .... pleas, please, please - read this book.

The book starts out with a fairly lengthy description of how you should read it and that you shouldn't skip the case studied or you won't learn anything. As a person with limited understanding of Java (I am a PHP developer) I found the case studies very difficult to follow and don't think I got that much out of them. The more general chapters on the other hand were great. Very solid pragmatic advice on naming variables, constructing classes, writing functions and eliminating crap (spurious comments and such). Since reading it I feel as though I'm writing better code and there isn't much better endorsement of a coding book than that. Don't be put off by the fact that this is essentially a Java book - it's full of insights and advice that you can read one night and apply the next day at work to good effect.

Seriously, EVERYONE learning to code or anyone in the software engineering industry MUST read this book and learn the principles by which all programs should be made thinking on. I'm not saying every single principle described in the book is applicable to absolutely all scenarios, but the big majority of them are. Following these, will help you write cleaner code that is easier to read and understand using less mental capacity, which will in turn allows your brain to be fresher for other tasks like refactoring. It will also help in communicating more effectively with your colleagues having a common framework to work on and make easier to pass on the knowledge to other colleagues.

You're a self taught programmer who learned from stack overflow and a second hand beginner's guide to java. You've got an app on google play, and it works, but that's not enough any more because the bug reports are coming in and there are parts of your code where you fear to go. Classes with thousands of lines and nested indentations that stretch across to the margin line. Functions that don't make sense even with the comments you scattered throughout them. It's a mess and you know it. If this rings true for you, then Clean Code by Robert C Martin is going to help you, like it helped me. It's clearly written, easy to understand and provides code examples both good and bad to explain its practices. I just wish I had read it two years ago when I started programming.