ROBERT C. MARTIN, CLEAN CODE -

Let's get this out of the way right now: There are a LOT of books out there about improving your programming style. Even books that aren't about coding style tend to have at least a chapter or two on it, or pepper the text throughout with capsule suggestions on good style. In my experience, these books fall into three categories. The first category is the "safe" category. It offers obvious, unchallenging homilies about exception safety and RAII. It'll make you feel good about yourself because you're already doing most of the things; and the ones you're not, you will have already thought about doing and have good reasons for not doing. This first category does not improve the coding style of already decent programmers. The second category is more crotchety and conservative. This is the camp that would have you never have multiple returns from functions, and document every single function with a ten-line preamble comment (more if the function actually does anything). This type is more daring, and may have some good suggestions, but it's difficult to find them because they're hidden in reams of bad suggestions which can be discarded without much thought. This category is also "safe", not because it tells you things you already know, but because it tells you things you can ignore. The third category is this book. It's not a safe book. Many of the suggestions will mystify or anger you. They'll sound ridiculously Panglossian, impractical for any but the most trivial of codebases. Others will strike you as trivially obvious, which will irritate you, until you realize that you're not following them, which will irritate you more. This is a book which will change you, for the better.

Robert C. Martin, or Uncle Bob as he is called, is probably the most impressive coder I have read a book from ever! Right from the word go Robert is filling you with tons of information, skill, and knowledge about what is good code. He doesn't mix any words, letting you know immediately that you will spend some time with this book, it took me almost two weeks to work my way through with a great understanding of the concepts in this book. I don't want to scare anyone, this book is really important for any coder to read. I will be suggesting it to my employers from now on as a required reading for our developers. The concepts are sound, solid, and make sense. There is no voodoo in this book, and nothing that doesn't come from a great deal of working with code. Clean Code has the ability to turn any good coder into a great coder, and build teams into better coding machines. Robert explains the best techniques if factoring code so that it will be easiest to read, and refactor. If the tips, tricks, and suggestions are followed then any coder would be able to follow in your footsteps and enjoy maintaining your code. There is nothing too outrageous in Clean Code, but instead is a good explanation of why you should code the way we were taught. If you weren't taught to code well, then you really owe it to the coders in your wake to come and read this book.

Books like Clean Code are much more worthwhile than any "Learn the latest hyped technology API now!" book. Clean Code will never be outdated while specific technology books have a shelf life of six months to two years. Whatever language or API you are working in, you will find solid advice in Clean Code on how to write code that is effective and that you can take pride in. You may disagree with some of Martin's specific advice, but you will still learn a lot by understanding his reasoning for a particular practice. Bob Martin is a wonderful writer, which is a rarity in the technical book field. His prose is as concise and effective in communicating his thoughts as the code that you will write if you take the time to learn from the master.

When you do code maintenance, you can really "love" or "hate" a person that you do not even know just by the code he or she has written. Messy code almost always goes hand in hand with lower productivity, lower motivation, and a higher number of bugs. In the first chapter, Robert C. Martin presents in a very instructive way, the opinion from very well-known personalities about what "clean code" is, and also suggests we apply the Boy Scout Rule (Leave the campground cleaner that you found it) to our code. The following chapters present practical advice about how to do this cleaning (or even better, how to avoid the mess in the first place). The suggestions presented in the book (meaningful names, pertinence of comments, code formatting, etc) may sound very familiar to any experienced programmer but they are presented with such a level of detail and with very illustrative examples that it is almost impossible not to learn valuable things chapter by chapter. All the examples are in Java, but the guidelines they illustrate can be applied, in most of the cases, to other languages. The most challenging chapter to read (but also a very valuable one) was the Refactoring of the class SerialDate (from the JCommon library). It is a real-life example and the author shows step-by-step what it takes to do refactoring. The last chapter, "Smells and Heuristics" makes a very good closure presenting in categories and in a condensed way, potential problems and suggested ways to solve/mitigate them. I enjoyed reading this book and after finishing it, I decided to apply the Boy Scout Rule. I took a module written in a procedural language and not only managed to improve the clarity of the code, but also reduced the number of lines from more than 1,100 to 650. The next person to touch this code will certainly be happy to deal with cleaner code!

When most people hear the term "bad writing" they understand the term: Confusing, inconsistent, rambling, big words used incorrectly. In fact, we have lots and lots of educational programs designed to teach grammar, composition, journalism, and fiction. Master's Degrees in the subject, even. But for software development we seemed obsessed with "architecture" (whatever that means), process and patterns. In this book, Bob Martin takes a specific stab at what good code looks like. He provides rules, examples, and even sample transformations. It is not an easy book. If you are a new developer, you can invest a lot of time and energy into really absorbing the concepts and practicing them yourself. If you are more senior, you may disagree, you may struggle, you may toss the book in a corner and yell at it ... But then you'll pick it back up again. And you will be a better developer for it. One thing that I struggle with about the traditional CS cirricula is that so little attention is spent on maintenance, which is the vast majority of actual development time. This book presents an aesthetic and the skills to write maintainable code. If you teach software development, you'll want to use this book in your courses. Student, Journeyman, Master, or Instructor - A book like this belongs on your bookshelf. Follow the advice in it, or have an explanation why not - either way you'll be a strong developer. Of course, there are other books in this area. What struck me about this one is the quality of the writing; it is truly engaging and -- a little inspiring. That quality is so rare in technical books that I give this one five stars.