List Price: $34.39 Our Price: $18.91 You Save: $15.48 (45%)

Product Description

This is the eBook version of the printed book. If the print book includes a CD-ROM, this content is not included within the eBook version.

• How to tell the difference between good and bad code
• How to write good code and how to transform bad code into good code
• How to create good names, good functions, good objects, and good classes
• How to format code for maximum readability
• How to implement complete error handling without obscuring code logic
• How to unit test and practice test-driven development

Customer Reviews:

• Clean Code Belongs on Every Coder's Shelf
  Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin Series)
  
  First Impressions
  
  I began reading this book with a couple of concerns. First, all the code examples were written in Java, and I haven't written much Java in the last couple of years. Secondly, the books seventeen chapters were written by seven different authors. In my experience, most books with this many authors are at best a collection of uneven chapters, or even worse a morass of redundancy and contradictions. In the end, neither of these concerns proved to be a problem. Instead they demonstrated the authors' point - that clean code is readable code.
  
  The book's main premise is that clean code results from paying attention to the small details (details that are often overlooked in an effort to meet a deadline, or simply get the code working). This overriding theme allows for a seamless blending of each author's contribution into a cohesive readable whole. Where contradictions did occur, the authors not only acknowledged them, but successfully argued that they resulted not from conflicting ideas or approaches, but from differences in priority. Even the high quality of the editing, and typesetting silently reinforce this attention to detail and professionalism. Most computer books have several technical, typographical and grammatical errors in every chapter. I found only a single one in this book (several hundred pages in). This attention to detail silent reinforces the lessons presented in this book.
  
  What's Inside
  
  The book is divided into three parts. Part I (chapters 1-13) demonstrate what makes up clean code, what it looks like, and how to begin creating it (by picking better names, properly using comments, properly structuring your code etc.). By organizing this section into a series of small chapters the reader is able to begin applying these lessons from day one.
  
  Part II (chapters 14-16) contains a series of case studies demonstrating how to apply the rules and guidelines from part I. These case studies show that like refactoring, cleaning code is an iterative process. One that should be undertaken at every opportunity, because all code no matter how good can be improved.
  
  Part III (chapter 17) is a knowledge base. This section documents the rationale behind every change made to the code in the case studies. This final chapter shows that clean code requires both the ability to make the changes, and to know why they were needed.
  
  Final Impression
  
  No book alone can make you a better programmer, anymore than a screwdriver can make you a better carpenter. However, if you have the discipline to go beyond simply getting your code to work, and begin writing clean code, then this book can help you to become a better more professional programmer. If correctly applied over time, it can even serve as a bulwark against an increasingly fragile code base comprised of hacks, kludges and quick fixes. This book not only taught me how to improve my code, but demonstrated that its principals are both timeless, and language agnostic. I would recommend this book to anyone who writes code.
  
  
  Clean Code A Handbook of Agile Software Craftsmanship
  By Robert C. Martin
  Published by: Prentice Hall
  isbn: 0-13-235088-2
  ...more info
• Complilation of a lot of good advice, but be wary on when to use it
  I just finished Clean Code: A Handbook of Agile Software Craftsmanship. The book is compilation of patterns on writing clean/maintainable code and is written by uncle Bob and other folks from his consulting company Object Mentors including Tim Ottinger, Michael Feathers (author of Working Effectively with Legacy Code. This book is similar to Implementation Patterns by Kent Beck I also read recently. As opposed, this book is a lot more thick with seventeen chapters, however there are also lots of tedious listing of Java code.
  
  The first chapter gathers thoughts on good code from a number innovators and authors such as Kent Beck, Bjarne Stroustrup, Grady Booch, Dave Thomas, etc. They mention various attributes of good code such as easy to read, efficient, DRY, focused, literate, minimal, error handling and warn of bad code that leads to messy code or broken windows mentality.
  
  The chapter 2 talks about golden advice of using intention-revealing names to improve the readability and following principle of least surprise. This chapter denounces use of hungarian notation or member prefix such as _ or m_.
  
  The chapter 3 describes functions and methods and advices to use small, cohesive functions. It suggests using one level of abstraction to facilitate reading code from top to bottom. It also recommends using polymorphic methods as opposed to switch statement, if-else or functions that take flag/boolean arguments. The chapter discourages functions with side effects or the one that create temporarl coupling. This chapter also mentions an aged old advice of command query separation, though it skips its roots from Bertrand Meyer's design by contract. Finally, this chapter urges use of exceptions as opposed to error codes.
  
  The chapter 4 describes writing good comments that focus on intent and dissuades against redundant and misleading comments.
  
  The chapter 5 illustrates use of good formatting such as identation, horizontal, vertical spacing, etc.
  
  The chapter 6 describes use of objects and data structures. It encompasses advice on polymorphism, law of demeter, encapsulation, DTO/value objects, etc.
  
  The chapter 7 discusses error handling. Again it encourages use of exceptions rather than return codes or error codes. It prohibits use of checked exceptions as it violates open/closed principle. It also discourages returning or passing null and recommends exceptions or empty collection instead of returning null.
  
  The chapter 8 describes boundaries between components.
  
  The chapter 9 describes advice on unit testing such as TDD, keeping tests clean, one assert per test, single concept per test, etc.
  
  The chapter 10 is similar to chapter 6 and contains recommendations on writing classes such as encapsulation, classes should be small, single responsibility principle, cohesion, dependency inversion principle, etc.
  
  The chapter 11 encompasses advice on building systems and managing complexity. It suggests dependency injection and use of factories. It also advocates use of AOP for managing cross cutting concerns.
  
  The chapter 12 talks about emergent design, the concept I first heard from Andy Hunt. This chapter describes advice from Kent Beck: run all tests, refactoring, no duplication, express intents of the programmer and minize the number of classes and methods. This chapter advocates use of template methods to remove duplication and command/visitor patterns to express design to other developers.
  
  The chapter 13 discusses concurrency. It suggests use of single-responsbility principle to keep concurrent code separate from other code, limiting scope of data, keeping threads independent, and use of immutable oobjects or copies of data. It recommends keeping critical section small. The chapter also holds advice on testing threaded code and suggests making threaded code plugable.
  
  The chapter 14 encompasses an excercise on how to incrementally improve code.
  
  The chapter 15 describes JUnit framework and walks reader through improving tests.
  
  The chapter 16 walks reader through another refactor excercise.
  
  The chapter 17 encompasses a number of smells, heuristics and antipatterns. It deters use of poolrly written comments, builds/tests that require more than one step. The chapter prohibits passing too many arguments to functions or use of output/flag arguments to functions. It encourages testing boundrary conditions and respecting overridden safeties. It also proscribes writing code at wrong level of abstraction, i.e., exposing low-level logic through interface. The chapter also forbids exposing derivatives to base classes, having too much information in interface. Other smells include artifical coupling (sharing constants), feature envy (coupling formating logic), flag arguments. This chapter also holds advice of Kent Beck about using explanatory (local/temporary) variables. The chapter recommends use of constants, structure over convention, encapsulate conditionals, avoiding temporal couplings, keeping functions at same level of abstraction and keeping configurable data at high levels. The chapter also contains Java specific is advice such as avoiding wildcards in imports, avoiding use of interface to inherit constants, etc. Finally, the chapter cautions against insufficient tests, use of coverage tool, testing boundary conditions, etc.
  
  In conclusion, this book contains advice from wide range of authors on writing good maintainable code. Finally, I would also caution against using these practices mindlessly as another favorite rule of mine is that every practice or pattern depends on the situation. Unfortunately, there are lot of people in software industry including uncle bob who use these rules in draconian fashion such as always stressing on 100% test coverage or always keeping interfaces separate from implementation (DIP). Such advice may bring more money from consulting work or publication, but is disingenuous for practical use. ...more info
• Pragmatic Advice for Better Code
  The book is a great guide to the basic qualities of good code. While many of the guidelines were familiar, reading the book helped me reconsider some rules that I had followed out of habit, but which no longer make sense. Like many good books even if you know and agree what it says, reading the book can help you explain "the obvious" to others. Clean Code has all the qualities of a classic book.
  
  Bob does not just a list of rules for "good" code. He explains why following the rules makes for better code, and provides several examples of how following the rules make arguably good code (like JUnit) better. Buy this book if you write code or manage people who write code. This is a must read if you are developing a coding standard for your team. Even if you don't accept all of Bob's guidelines, reading this book will help you think about what standards make sense for your team. ...more info
• Good read.
  Although only halfway through the book, I can already say that it is a joy to read.
  In particular because the author doesn't just state what makes clean code but because he also takes time to explain why.
  
  Most of it makes a lot of sense and should lead to better maintainable code. In places I feel that the author takes it a bit to the extreme but exaggeration never hurt anybody.
  
  Definitely worth the price-tag....more info
• Clean Code
  Good set of rules for keeping your code up to high standards. But to be honest, most of the rules are common sense and not likely to surprise anyone who cares enough about his code to bother reading this book. Even so, the author's arguments are often not so convincing (i.e. based on anecdotal evidence and personal opinion). This is fine with rules with which you happen to agree, but don't expect this book to change your opinion in the few cases where you don't agree. Then there is also the issue that most bad code isn't bad because the programmers didn't know the proper rules, but because following the rules can be difficult. Most examples in the book are a bit simplistic, but in the second-to-last chapter the author walks us through a complete refactoring where he applies his rules to real code. This is a great idea, though the chapter ends up being a bit tedious. The last chapter contains a concise set of rules -- read this if all you have is five minutes.
  ...more info
• Instant Classic
  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....more info
• Finally, a book about code
  Since the rise of Design Patterns in the 90s, there has been a scarcity of books focused solely on good code. Good design with bad code is...bad code.
  
  This book contains a large number of specific guidelines about writing good code. Design is intimately involved, but the focus is on the code itself. The advice is explained by before/after snippets of code to show the effect of applying the advice.
  
  Near the end of the book are several longer sections where the author drives us through cleaning up some available open source code.
  
  This is a great replacement for _Code Complete_.
  
  Very easy to read (surprising for a book on code)......more info
• Java developers, buy this book
  This book belongs on the shelf of every java developer. Buy it. Not only does it cover "what" clean code is, it talks in great detail about "why" something is clean or not clean.
  
  This book has one tiny flaw: the font used for code is not the most readable. The publisher could learn a thing or two from O'Reilly, who uses much better fonts....more info
• Poorly structured mix with lots of Java code only
  Sadly, this book follows a trendy plan by which an intentionally good book about software development can be ruined.
  
  Have the book written independently by several authors. Give each a chapter or two but don't have any prior plan nor edit it afterwards. The result ? Poorly structured patchwork where each author speaks about different things in a different way or even overlaps with somebody else. Mix of old (some - very old) ideas, pieces of knowledge from all over the place, tales from the field, personal idiosynchrasies etc.
  
  Talking about "code" in general, stick to one language (Java, what else). Include code samples few pages long immediately followed with "you see ?". To be fair, you are warned upfront that you will have to read a lot of Java code:
  
  --- QUOTE ---
  You'll be reading code - lots of code. And you will be challenged to think about what's right about the code and what's wrong with it. [...] if you take the time to work through the case studies, following every tiny step, every minute decision [...] then you will gain a much richer understanding of those principles, patterns, practices and heuristics.
  --- /QUOTE ---
  
  But it doesn't work this way for me. I don't appreciate reading several pages of consecutive versions of somebody else's Java code. I would rather let the authors extract the mentioned principles and present them in some way easier to digest.
  
  To conclude, another quote:
  
  --- QUOTE ---
  So maybe there is a little new here, but in reading this book you will be challenged to take up good disciplines that you long ago surrendered to apathy...
  --- /QUOTE ---
  
  If you are up to taking a Java reading challenge, good luck....more info
• Excellent book
  Robert C. Martin is one of the most experienced developers in the world and tries to share his wisdom with the reader, and he does so in a very clear and well articulated way. He says clearly that the book is not THE answer, but rather a summary of his own opinions.
  
  The book focuses on making easily maintainable code....more info
• Must-Read Work on Software Craftsmanship
  Here's a rhetorical question: Should you work hard to ensure your software code is readable, well-structured, uncluttered with useless or flat-out wrong information, and is well designed? Rhetorical question #2: Should you spend time polishing code when you modify or maintain it to ensure you're improving the code you wrote earlier?
  
  "Uncle Bob" Martin's Clean Code is a book full of sage advice on being able to deal with both those questions. The book's broken into three separate sections: Good craftsmanship principles, case studies of refactoring code, and smells/heuristics in existing code. There's also an appendix on dealing with concurrency.
  
  Martin starts out with a frank example of how poorly written and maintained code can torpedo an entire company. A product that Martin and many others used in the late `80s began to lag with its release cycles, and bugs weren't being fixed in subsequent releases. The situation worsened, sales vanished, and the company eventually closed its doors. Martin recounts meeting one of the company's employees years later - and finding out that an unmaintainable codebase was the cause of all the woes.
  
  Clean Code is intended to help you avoid such a mess.
  
  The initial section covers such fundamental principles as naming conventions, function/method design and layout, use of comments, and a passle of chapters on design principles. There's a great wealth of things to get your mind rolling in this section, and you get a number of different voices/viewpoints as Martin brings in colleagues from ObjectMentor to write various chapters.
  
  The second section is made up of three refactoring walkthroughs. Martin shows the initial condition of each example (all real-world software), then goes into great detail of the small changes he makes to apply the principles from the first section. These three chapters are outstanding examples of putting the principles from the first section to work. Additionally, Martin's writing style makes it seem that you're sitting down with him for a pairing session as you read. Normally I hate these over-the-shoulder discussions because authors usually fail and end up with a sappy, overly chatty example. Martin's succeeded at this before as well with his example of a pairing session in Agile Principles, Patterns, and Practices in C#, another book you should run out and buy.
  
  The final section is one chapter with a large number of smells and heuristics you can apply as you're writing and refactoring your code. Each item is concise and to the point, some with terse but beautiful example code.
  
  The term software craftsmanship is generating a tremendous amount of discussion on blogs, articles, and podcasts. If you care at all about improving your skills and being a true craftsman, then you need to read this book.
  
  Also, if you don't follow "Uncle Bob" Martin on Twitter (@unclebobmartin), you should. You'll get a passle of insightful bits on software craftsmanship, find useful tools like Uladoo, and get some passionate views on politics and life mixed in with all that....more info
• Good Book That Will Help You Improve the Quality of Your code
  Clean Code is a good book for learning or reaffirming the fundamentals of writing efficient, object oriented code that is easy to read and easy to maintain.
  
  The thing that I liked the most about the book was that I could get through it in a 2 hour sitting. The Table of Contents is well organized and all chapters conform to a common format. There are multiple contributors to the work. Thus, working off a common format unifies the book and avoids the pitfall of a disjointed read which is a risk when publishing a book that has content from different authors.
  
  The chapters present topics progressively. In the beginning you start out with the topics that are general to all programmers-- proper naming, how to write well formatted code with competent commenting, how to write a well encapsulated function, etc...
  
  Eventually the book presents "bigger picture" concepts--favoring the use of exceptions, embracing test driven development and best practices with regard to object design, for example.
  
  There's a lot of code in the book. So, examples are not lacking. That the code examples are in Java limits the readership, as does using JUnit as the background against which testing concepts are presented. There are a lot of .NET programmers out there that could benefit from the book, but might feel a bit ignored due to the Java bias. The same can be said about developers using other testing frameworks such as Nunit, MBUnit and TestNG.
  
  The bottom line on this book is that you can use it immediately and quickly. The book shines when sticking to general, conceptual topics. It's the perfect gift that a senior developer can give to the any emerging developer on his or her team and expect to see significantly improved work almost immediately.
  ...more info
• Coding Practice Bible
  Very clear and thoughtful set of practices. My team began implementing the discipline described in this book, and the resulting code is easier to both maintain and transfer to new developers.
  
  My favorite part: The first few chapters give solid, practical reasons for good coding practices -- great ammunition for swaying other developers to follow practices you intuitively know work. :) ...more info
• Demanding and useful
  I am a front end web developer with a couple years experience and I purchased this book to get a better idea of how to generate more readable and understandable code. And this book satisfied that need. If you are a very novice coder, that is to say that you do not yet know your syntax and are unfamiliar with OOP, you will want to wait to pick up this book. Not that all of the examples and discussion are super technical, just that are many assumptions and no explanations of these subjects.
  
  One of the nice things about this book is its tone - it stays reasonably lighthearted, with a number of naive illustrations to maintain this feel. Nonetheless, it is abundantly clear that the author is fully versed and a master of code, ensuring that all the discussion is well considered and presented.
  
  I do find that the author seems to go a little far in defining his ideal, tho perhaps that is the purpose of an ideal - to guide one's daily path and provide some information as you build out your projects....more info
• Uncle Bob gets down and dirty with Clean Code
  Robert C. Martin, fondly know to many as "Uncle Bob," was one of the 17 people involved in the creation of the Agile Manifesto and has been a strong proponent of writing clean code for many years. He's also a well known and respected speaker and is actively involved in the agile community.
  
  In "Clean Code," Uncle Bob not only shows you what clean code looks like and why it is important, but how to take existing code and make it cleaner. This last part is invaluable because you get to see step by step improvement, which makes doing it with your own code much easier.
  
  "Clean Code" is organized into three parts. As it says in the introduction, part one "describes the principles, patterns and practices of writing clean code." Part two contains "several case studies" showing how to apply the knowledge from part one to actual working code. Part three (which is a single chapter) lists the "heuristics and smells gathered while creating the case studies."
  
  While the author warns us that there will be lots of code to read and that there's hard work ahead - I have to say that I found it all worthwhile and I think you will too.
  
  I found the book to be well written, and organized such that you can read it in small chunks - which is great for those of us who don't have large blocks of free time available.
  
  The beginning of chapter one sums it up nicely: "You are reading this book for two reasons. First, you are a programmer. Second, you want to be a better programmer."
  
  If you are a professional developer, or aspire to being one, then you owe it to yourself, your team, and your clients to read this book and take it to heart.
  
  [...]This is an excellent book, and I highly recommend it!
  Burk Hufnagel
  Lead Software Architect...more info
• Good advice delivered clearly and directly with examples
  While this book includes many things I already knew, such as the Law of Demeter, it touches on them in a thorough and interesting way. The examples are all in Java which, though not my primary programming language, carries many of the same benefits and pitfalls of any other OO language.
  
  This book is also great motivation. Many of us know that we need to write cleaner code, but the pressure of our peers or of timelines often makes us forget - or at least ignore - that impulse, often to our own detriment. I have it on my desk as I've not yet finished it, but even when I have a day where I don't read out of it having it there serves as a reminder of what I should be doing.
  
  If you want to make yourself a better programmer, this book will not disappoint....more info
• Reading Clean Code Will Make You A Better Programmer
  Reading Clean Code will make you a better computer programmer. Applying the programming techniques described in Clean Code to your work is like stripping layers of paint from fine wood work in an older home. You end up with improvements that make life better. Your source code will easier to understand, easier to test, and easier to maintain. Other programmers will be able to understand it.
  
  Clean Code has 17 chapters written by eight authors. Most of the chapters are written by the principal author, Robert Martin. With one exception, each chapter has a single author. Each chapter tackles a different subject and covers the topic by breaking it down into a cohesive set of paragraphs, with each paragraph having a meaningful subtitle. Even with eight authors, Clean Code reads like a book written by one voice. The authors wrote this book with the same care they apply to their computer programs, by reducing its complexity to a system of small parts. It is a seamless piece of work.
  
  Clean Code can be read three ways: 1) as a quick read, skipping most of the source code samples and case studies; 2) as the authors intended; 3) in a way not suggested by the authors-- read the text, skip large sections of Java code, and find your own examples and case studies to convert from messy code into clean code.
  
  The authors warn against the first option, "This is not a feel good book that you read on an airplane and finish before you land. ... You'll be reading code--lots of code. And you will be challenged to think about what's right about that code and what's wrong with it." The authors want you to study each and every line of Java code listed in the book, and this book is loaded with examples and case studies. They mean it. Reading and understanding all of the examples and case studies in this book is daunting.
  
  The problem for me, however, is that all of the examples are in Java and I'm a Delphi and a C++ programmer. I took the third approach. I studied the simple examples, but I glossed over the more complex case studies. Instead, I applied the techniques to a C++ program that I had already programmed--making that code much, much better. I worked quite hard at this, but not in the way the authors intended. This book is applicable to all object oriented programming languages, not just Java. It worked for me.
  
  Clean Code explains how to make your code more readable by giving all variables meaningful names. It explains how programs become polluted with out-of-date comments and how to write code that requires little or no comments. It explains how to design and program classes that are small and easy to understand . It is loaded with examples of refactoring complex code into more simple code. The authors speak from experience and all of their assertions are backed up with examples and case studies.
  
  This book is loaded with ways to write better code. Here are some examples:
  
  "The ideal number of arguments for a function is zero (niladic). Next comes one (monadic), followed closely by two (dyadic). Three arguments (triadic) should be avoided where possible. More than three (polyadic) requires very special justification--and then shouldn't be used anyway." (I particularly like the terms niladic, monadic, dyadic, triadic, and polyadic.)
  
  "Output arguments are harder to understand than input arguments. When we read a function, we are used to the idea of information going in to the function through arguments and out through the return value. We don't usually expect information to be going out through the arguments. So output arguments often cause us to do a double-take."
  
  "Flag arguments are ugly. Passing a Boolean into a function is a truly terrible practice. It immediately complicates the signature of the method, loudly proclaiming that this function does more than one thing. It does one thing if the flag is true and another if the flag is false!"
  
  "Clear and expressive code with few comments is far superior to cluttered and complex code with lots of comments. Rather than spend your time writing the comments that explain the mess you've made, spend it cleaning that mess."
  
  "The first rule of classes is that they should be small. The second rule is that they should be smaller than that."
  
  These quotes are only a small sample of better programming concepts that are so well described in this book. The booked is filled with similar tips to write better software. For example, Chapter 4: Comments, has the best advice for writing comments that I've ever read. The authors tell you what makes a bad comment and why most comments are, in fact, not very helpful. That chapter alone is worth the price of the book. Chapter 7: Error Handling, has a number of techniques on how to handle errors with "grace and style." These error handling techniques make sense and their use results in more robust programs.
  
  Even though all of the case studies and examples are in Java, reading this book should not be a problem for non-Java programmers. With careful reading you can follow the examples and you will learn some Java as you read the book. If you are not programming in an object oriented language, however, this book will make little sense. A pre-requisite to reading Clean Code is proficiency in object oriented programming.
  
  My one criticism of the book is that the authors are a bit dogmatic in saying that their techniques are the best. For example, they disdain switch statements. I didn't find their argument for their dislike of switch statements to be very compelling. I can accept and forgive this, however, as their collective experience is impressive. They speak from many years of experience.
  
  Chapter 15: JUnit Internals, has the best example. The author includes an example of high quality, clean code, taken from the Java framework. Then the authors improve the code, explaining all of their changes as they go. They call this the Boy Scout Rule: "Leave the campground cleaner than you found it." They visited the code, studied it, and improved it, showing that even good code can become better code. They left the code cleaner than they found it.
  
  As a final note, Clean Code has a Kindle Edition for reading on the Amazon Kindle.
  
  Michael Jablonski
  IEEE Computer Society Certified Software Development Professional (CSDP)
  
  
  
  ...more info
• Clean Code is a must have for any Developer
  This book is a must have for any software developer. It teaches the easiest, simplest way to design code in a way that anyone can understand. And it's definitely well worth the price!...more info
• Excellent Code Review Resource
  This is a really excellent handbook for use in Design and Code Reviews. After reading this very well written book it is much easier to be effective during code development and in code reviews by providing concise suggestions and being able to back them up with good rationale. The disappointment comes in finding out how poorly written the existing software base is when compared against this Clean Code standard. Even worse is developing new code which cannot meet the clean code standards for one reason or another.
  
  I highly recommend this book for everyone involved in software development. The very pragmatic and disciplined approach takes practice and skill but the rewards are well worth it. ...more info
• Software Engineering is a Craft! Thank you!
  Before I even read the book, I liked the fact that the title contained the words "software" and "craftsmanship" next to each other! This alone is a good reason for many programmers to keep this book where they can see it - every day. The book is well structured, it is well and thoughtfully written - something you would expect from a book of this kind. I am happy to see a book that - in clear and simple terms - promotes what the great Edsger Dijkstra (considered the Father of the Computing Science by many) had been advocating all his life: elegance, simplicity, and intellectual manageability of software. There have been many articles popping up here and there, addressing various aspects of coding standards and general quality of code. Such articles usually would result in heated discussions, mostly fueled by personal preferences, pride, unwillingness of some people to admit that they hadn't been doing things right always... A book like this was needed..
  
  It's good to see a serious book from a serious author who, for example, finally is not afraid to state: "Use unchecked exceptions. The debate is over". This is music to my ears. Surprisingly, however, the author uses checked exceptions in many of his examples! That seems like a really strange oversight. Any plans to fix that in the 2nd edition, Robert? Also, I think the author only scratches the surface explaining why checked exceptions are "not necessary". What is missing is the explanation why checked exceptions are not safe, in the first place. Most of us know that they result in bad and convoluted code. The bigger problem, however, is that they usually result in incorrect error handling in general. And there is quite a bit of confusion and misunderstanding when it comes to error handling among Java programmers - to this day. So, I am afraid, this particularly important advice from the book will be ignored by many programmers raised on checked exceptions - simply due to the lack of clear explanation and the confusing code examples that use checked exceptions.
  
  While I think it is a very good book, I generally agree with one of the earlier reviewers that some topics are covered without the depth necessary to fully illustrate the practice or issue in question.
  
  As one would reasonably expect, some recommendations may have to be taken with a grain of salt. For example, should we really never use HTML in javadocs? Most of us use IDEs that have excellent support for javadoc viewing via key-shortcuts - by simply pointing to the class or method's name anywhere in the code. I never pull up the method's source to read the in-line Javadoc for it as is. I place the cursor on the method name right where the method is referenced, and do Ctrl-Q in IntelliJ. The nicely formatted Javadoc appears in a pop-up window, so I actually like taking full advantage of any HTML formatting. Eclipse or NetBeans users use similar ways. So, I'd say, use common sense, and make sure the comments are informative, and neat. Which is pretty much what the book says anyway.
  
  By the way, speaking of comments, most code examples in the book contain none of those at all! How come? Another strange oversight... I certainly understand that the author assumes that there is no need for javadocs and comments in the sample code since he explains everything in the text of the chapter. However, consistency is another important rule that the author advocates, and I would prefer to see the sample code follow all the same rules the author is promoting in his book.
  
  One of my favorite parts of the book is Chapter 17 - "Smells and Heuristics". This is a great reference guide for any beginner or anyone who only now starts to show interest in writing quality code. Fortunately, most common IDEs today can be configured to inspect your code and look for each of the anomalies listed in that chapter. Turn those inspections on and never ignore them!
  
  The bottom line is that Software Engineering is a CRAFT, indeed. At the end of the day, a programmer should be able to look at his/her work and be proud of it. Those who don't care should probably find a different occupation. For everyone else, this book is a must-read.
  
  (Disclaimer: This review is based on the electronic copy of the book; the hard copy is still on its way from amazon.com at the time of this writing.)...more info
• Fantastic Book to increase Code Quality
  In Clean Code each chapter contains a different subject to enhance code quality.
  From the simple practices that are often overlooked, for example; naming conventions and formatting styles, through the classic tried and tested; Kent Beck's 4 Simple Rules of Design (Run all tests, contain no duplication, code to express intent and minimize the number of classes and methods); to some gems that can take years to uncover; such as bad practices for returning null (with the correct idiom) and good practices for testing threaded code.
  This reviewer certainly chuckled guiltily when reading some of the examples of code that could be written better ("Oh yeah, I remember doing that once!!").
  
  I was surprised to see a few reviews on other blog sites and amazon about the fact this was not written solely by Bob but by different authors at Object Mentor. I actually thought this was a good thing as each chapter is a separate concern and the writing styles differ so the reader can be engaged differently from one chapter to the next. Plus, there is a lot of Java and the change in temperament clears ones head after reading all that code.
  This book does not follow a specific 'project' throughout, like many other books today, but concentrates on real world examples to illustrate the different points made. This is not a book one can read quickly IF the reader wants to real get involved and practice what this book teaches.
  
  One may presume that my opening paragraph was negative on the amount of code in this book. On the contrary, I found this to be an excellent model to get, mainly inexperienced [Java], programmers to look at more code written by experienced experts and take a look at the internals of classes in popular frameworks such as JUnit and JCommon.
  
  Chapter 17 is a concise description of each of the smells and heuristics used throughout the book and if you think you have your coding practices down to a fine art, read through this - you never know where you can learn a new thing or two. Also, if you are still one of the few out there that are not performing Unit Tests (shame on you) then just the first four pages of chapter 9 (p 121 - 124) should sell it to you, and your manager if required.
  
  Now the bad! Maybe it's because we at Enerjy Software are so much into 'best' practices that a few things niggled me.
  There are a few contradictions in the book. Not only where the advise to never leave commented out code in your application is ignored, but in some cases (e.g. p66) some Catch blocks with no code contain a comment as to why they are empty, while some are indeed completely empty (no comment) - we believe this is not a good practice and is one of the few cases where a comment is indeed useful in a block of code.
  
  I also found a paragraph of slight Utopia-ism (is that a real word?). It is mentioned that programmers should not just get the code working but successfully refine working code before they move onto the next piece of functionality. Unfortunately I know of no customer who would be willing to pay for someone to sit and refactor code when it is functionally working correctly. This may sound contradictory on a Code Quality site but i think it is the real world. I think a better way of arguing this point is to define what is meant when a piece of functionality is 'done'. This would include the refinement (and documentation which is usually not evident) - maybe I'm just arguing semantics?
  
  In summary this book is a great resource of areas of good coding practices that each chapter has had many whole books dedicated to. I would like to see this book in Computer Science undergraduate courses as I feel to get these practices in early is only a good thing. For any professional, the information contained here in one book gives huge value to the reader....more info
• Your Coding Mentor in a Book
  I knew I was going to like this book after I read the Foreword and Introduction. I know not many people read those and as an author myself this bothers me, but it gives insight to why the author has written the book, which is a very important thing to understand. I was hooked by the affirmation that details are important and that the only meaningful metric is the number of "wtfs" per minute in a code review. For a long time I have kept my "profanities per test session" metric as a way to measure software usability.
  
  Long before I was a software testing guy, I was a coder. Back in those days it was common for rookie coders to sit next to guys with gray hair and bad breath (or if lucky next to ladies with better appearance and who smelled better) to learn the craft of writing code. Yes, coding was a craft before the attempt to make it an engineering discipline. Although there was a lot of bad code, there were plenty of people who took pride in how they coded. This book reminds me of what it was like to sit next to these intelligent
  people as mentors.
  
  I have often lamented that today's young coders don't have this mentor/apprentice relationship. A reasonable facsimile would be to read this book and practice these very sensible and helpful lessons in coding. As a testing guy who has been through those 30 wtf/hour code reviews, my bulletin to developers is that: Your code can be better! This book can show you how!
  
  Here's one example: Have meaningful names. Instead of a function named "int d", how about "int ElapsedTimeInDays;"? There's a whole chapter about naming things. It reminds me of the coder I knew that liked to label COBOL paragraphs after towns and cities in Kansas. Why? So he could write GOTOs that read "GOTO Topeka." He thought that was cute but the rest of us found it confusing and not-so-cute.
  
  I also appreciated the chapter on Unit Testing. As a tester, I love it when testing is mentioned, but Martin actually has specific guidance on what makes for good Test Driven Development and Unit Testing.
  
  This book is very readable, makes a lot of sense and would make most coders better. For testers that sit in on code reviews, this would be a great read for understanding how good code should be. I wish every coder in college or tech school would read this book before unleashing their creations upon the world.
  ...more info
• Interesting
  Interesting in the sense that it gives the foll reasoning behind pretty much every formatting construct you're supposed to use. Then eventually describes some useful java features that people are/aren't using explains their logic well enough that you can figure out yourself when to/not use them. Also gives reasonable tips on when/how to use exception handling and in class design.
  
  I would consider some of the tips suicidal in some situations though but still useful....more info
• Excellent resource
  Clean Code provides a good approach for refactoring existing code and provides systematic thinking for the design of new code....more info
• Robert Is Amazing!
  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....more info
• Full of examples
  This book is well written. It covers wide areas as naming up to concurrency. It is full of examples and should reside next to every developer. In contrast to Ford's the productive programmer is is more code centric which most reader will like....more info
• A Keeper That I Highly Recommend
  The software development industry is always maturing. The craft of coding is always advancing.
  
  The book starts with a great manifesto-ish cry for clean code and carries the reader through things to consider. Just reading 2 chapters got me to change the way I code. A book club got started where I work due to this book. It's that good.
  
  This book provides an up-to-date view of what works really well when coding / creating software solutions. This view is supported by a foundation of experience and best practices that have evolved over the years.
  
  What used to be great in the past is now refined and sometimes even backwards of what was once done. In those mind-jarring moments, an explanation is given in the book which really helps one see why they suggest what they do.
  
  The authors clearly have experience which they share in a clear and easy to understand manner.
  
  I highly recommend the book....more info