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. Refactoring: Improving the Design of Existing Code (Object Technology Series) or the Gang of Four Design patterns : elements of reusable object-oriented software . This is one of those books. And if much of the material is the sort that seems obvious in hindsight -- well, that is the mark of a well written book, to make the concepts that clear. Taking a series of real world examples -- open source projects with significant user bases, including FitNesse and JUnit -- a series of worked examples take us from good, or at least adequate, code, to a form which is better factored, and easier to read, with the steps along the way clearly marked. Yes, even some of Kent Beck's code is put under the microscope, and carefully polished that extra stage or two more. The reader is cautioned that, without working long hours to follow these examples, this will be just another of those feel-good books. I don't quite agree -- spending just a little time to follow the transformations, and then reflecting on one's own outpourings should be enough to make this a feel-bad book. All the sins from obscurely named variables to sprawling functions that gaily mix abstraction levels, we've all done them (especially programming in FORTRAN on minicomputers with slow stacks and a rule of thumb that 1 call ~ 40 loc in terms of performance). The maxim to take from the book is based on Baden-Powell's "Try and leave this world a little better than you found it", and owes to the same school of thought as "whenever you are in the garden, pull at least one weed". The meat of the book is in distinguishing what are the weeds from the intended crop. So read it, understand the examples, and then refer to it often -- like the other titles mentioned, it is a reference work, and should join them as among the most thumbed on your bookshelf.

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.

Uncle Bob (Robert C. Martin) is a recognized expert in todays world of software development. His books "Agile Software Development: Principles, Patterns and Practices" and "Agile Principles, Patterns and Practices in C#" should by now be well known by the majority of serious java and C# developers. I read the latter last year, and I was blown away by Uncle Bob's insight into the process of writing software in a manner, that more or less guarantees success for both the customer and the development company. When "Clean Code" was published I rushed to buy it, and again I am in awe! This book book hits the nail on why so many software development projects ends up in pain for the developers as the code rots and becomes unmaintainable. Not only are the symptoms cleary described and analyzed, Uncle Bob also provides the remedy. By breaking down the process of cleaning up code into detecting very specific "smells" and heuristics, and by supplying the reader the tools to fix the problems in the software, the reader automatically becomes empowered, inspired and motivated to go and clean up his or her mess. I strongly believe, that if all developers were to read this book and start living by the rules stated within, life would improve for every single developer, customers would be able to purchase very high quality software products a lot cheaper, and everyone would benefit. My applause to Uncle Bob - Thank you for this fantastic work of art!

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.

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.

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.

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.

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.

Excelente libro

.

Está centrado en el lenguaje Java, pero puede ser útil con otros lenguajes de programación porque se explica bastante bien. El libro pasa por casi todos los aspectos que se puede encontrar durante la codificación de un programa. Indica las situaciones en las que nos encontramos a menudo, y cómo resolverlas teniendo en mente que lo que quedará de nuestro trabajo es el código. Y siempre se vuelve al código, ya sea un mismo u otra persona. La idea principal es que éste debe ser claro, limpio y lo más descriptivo posible, lo que pasa por evitar vicios y soluciones sofisticadas. Vale la pena sin duda, y sirve para darse cuenta que todo lo que nos pasa por la cabeza cuando se codifica, nos pasa a todos, darnos cuenta de ello y decidir lo qué queremos hacer. Si ya tienes unas pautas de estilo bien marcadas, quizás no sea tan provechoso como para un principiante.

This is a great book. I have found the concepts informative and helpful. I'm glad I decided to get it. As an aid, I listened to the audio book version while I followed along reading it. This made taking notes a dream. I am now on my way to leveling up my programming skills.

(German Review below) I think I should excuse for hyping this book, but I'm completely enthusiastic about it. It's the first textbook that left me sorry it's over. There may be various reasons. It seems I'm a nerd. I love programming and I inherited incredibly rotten C-Code at work. As newbie to software developement I expected to learn from professionals at work. Instead I got code, that was written from at least 3 different Authors with differend minds about the programming style. The only thing they seemed to agree on was: no comments, no automated tests, no descriptive names and to avoid function calls and do everything inline. Even though the book uses only Java, I could easily transfer the advice to my C code. Since I started using suggestions from this book my code became more readable and programming became more fun. I spend more time programming and less time browsing unreadable code. The book is easily to read. It gives sound and clear advice without beeing to scholarly. It focuses on describing many screws you can use to tune the readability of your code. The authors give reason for almost everything instead of blindly obtruding their preferences. This is a definite 5 Stars. Ich muss mich entschuldigen, dass ich das Buch so hype, aber ich bin total begeistert. Es ist das erste Lehrbuch, bei dem ich bedauert habe, als ich damit fertig war. Das mag an verschiedenen Dingen liegen. Ich bin offenbar ziehmlich nerdig, ich programmiere sehr gerne und ich habe in meinem Job eine unglaublich verrotteten C-Quellcode zu betreuen. Als Software-Entwicklungs-Neuling hatte ich gedacht, ich komme in ein Unternehmen und lerne aus dem Quellcode von Profis wie man es richtig macht. Statt dessen habe ich Code übernommen, der offensichtlich von mindestens 3 Verschiedenen Autoren mit mindestens 3 Verschiedenen Programmierstilen erstellt wurde. Keine Tests, keine Kommentare, kein Durchblick, Lange (beschreibende) Funktions und Variablennamen gelten als unleserlich, Funktionsaufrufe als Performance-Bremse. Das Buch konzentriert sich zwar auf Java-Beispiele, trotzdem konnte ich es gut auf meinen Legacy-Code anwenden. Seit ich begonnen habe, den Code anhand einiger Tipps neu zu gestalten macht das Programmieren wieder mehr Spaß. Man verbringt weniger Zeit mit suchen und mehr Zeit damit, etwas zu verändern. Das Buch ist locker geschrieben. Es enthält prägnante Aussagen, ohne dabei allzu schulmeisterisch herüber zu kommen. Es schwurbelt nicht herum, sondern bespricht systematisch viele Schrauben an denen man drehen kann, um seinen Quellcode leserlicher zu machen. Dabei geht es nicht ums prinzip und vorlieben der Autoren, sondern um klare Vorteile. Eindeutig 5 Sterne.