Programming Books C Java PHP Python Learn more Browse Programming Books
Clean Code: A Handbook of Agile Software Craftsmanship and over one million other books are available for Amazon Kindle. Learn more
  • List Price: $49.99
  • Save: $29.74 (59%)
Rented from apex_media
To Rent, select Shipping State from options above
Due Date: Dec 20, 2014
FREE return shipping at the end of the semester. Access codes and supplements are not guaranteed with rentals.
Qty:1
  • List Price: $49.99
  • Save: $11.97 (24%)
In Stock.
Ships from and sold by Amazon.com.
Gift-wrap available.
Add to Cart
Trade in your item
Get a $16.44
Gift Card.
Have one to sell? Sell on Amazon
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See all 2 images

Clean Code: A Handbook of Agile Software Craftsmanship Paperback – August 11, 2008

ISBN-13: 000-0132350882 ISBN-10: 0132350882 Edition: 1st

Buy New
Price: $38.02
Rent
Price: $20.25
50 New from $32.28 37 Used from $29.99
Rent from Amazon Price New from Used from
eTextbook
"Please retry"
Paperback
"Please retry"
$20.25
$38.02
$32.28 $29.99

Free%20Two-Day%20Shipping%20for%20College%20Students%20with%20Amazon%20Student



Frequently Bought Together

Clean Code: A Handbook of Agile Software Craftsmanship + Code Complete: A Practical Handbook of Software Construction, Second Edition + The Pragmatic Programmer: From Journeyman to Master
Price for all three: $104.67

Buy the selected items together

NO_CONTENT_IN_FEATURE

Save up to 90% on Textbooks
Rent textbooks, buy textbooks, or get up to 80% back when you sell us your books. Shop Now

Product Details

  • Paperback: 464 pages
  • Publisher: Prentice Hall; 1 edition (August 11, 2008)
  • Language: English
  • ISBN-10: 0132350882
  • ISBN-13: 978-0132350884
  • Product Dimensions: 9.2 x 7 x 1 inches
  • Shipping Weight: 1.5 pounds (View shipping rates and policies)
  • Average Customer Review: 4.4 out of 5 stars  See all reviews (182 customer reviews)
  • Amazon Best Sellers Rank: #6,672 in Books (See Top 100 in Books)

Editorial Reviews

About the Author

Robert C. “Uncle Bob” Martin has been a software professional since 1970 and an international software consultant since 1990. He is founder and president of Object Mentor, Inc., a team of experienced consultants who mentor their clients worldwide in the fields of C++, Java, C#, Ruby, OO, Design Patterns, UML, Agile Methodologies, and eXtreme programming.

Excerpt. © Reprinted by permission. All rights reserved.

Which door represents your code? Which door represents your team or your company? Why are we in that room? Is this just a normal code review or have we found a stream of horrible problems shortly after going live? Are we debugging in a panic, poring over code that we thought worked? Are customers leaving in droves and managers breathing down our necks? How can we make sure we wind up behind the right door when the going gets tough? The answer is: craftsmanship.

There are two parts to learning craftsmanship: knowledge and work. You must gain the knowledge of principles, patterns, practices, and heuristics that a craftsman knows, and you must also grind that knowledge into your fingers, eyes, and gut by working hard and practicing.

I can teach you the physics of riding a bicycle. Indeed, the classical mathematics is relatively straightforward. Gravity, friction, angular momentum, center of mass, and so forth, can be demonstrated with less than a page full of equations. Given those formulae I could prove to you that bicycle riding is practical and give you all the knowledge you needed to make it work. And you'd still fall down the first time you climbed on that bike.

Coding is no different. We could write down all the "feel good" principles of clean code and then trust you to do the work (in other words, let you fall down when you get on the bike), but then what kind of teachers would that make us, and what kind of student would that make you?

No. That's not the way this book is going to work.

Learning to write clean code is hard work. It requires more than just the knowledge of principles and patterns. You must sweat over it. You must practice it yourself, and watch yourself fail. You must watch others practice it and fail. You must see them stumble and retrace their steps. You must see them agonize over decisions and see the price they pay for making those decisions the wrong way.

Be prepared to work hard while reading this book. This is not a "feel good" book that you can read on an airplane and finish before you land. This book will make you work, and work hard. What kind of work will you be doing? 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. You'll be asked to follow along as we take modules apart and put them back together again. This will take time and effort; but we think it will be worth it.

We have divided this book into three parts. The first several chapters describe the principles, patterns, and practices of writing clean code. There is quite a bit of code in these chapters, and they will be challenging to read. They'll prepare you for the second section to come. If you put the book down after reading the first section, good luck to you!

The second part of the book is the harder work. It consists of several case studies of ever-increasing complexity. Each case study is an exercise in cleaning up some code--of transforming code that has some problems into code that has fewer problems. The detail in this section is intense. You will have to flip back and forth between the narrative and the code listings. You will have to analyze and understand the code we are working with and walk through our reasoning for making each change we make. Set aside some time because this should take you days.

The third part of this book is the payoff. It is a single chapter containing a list of heuristics and smells gathered while creating the case studies. As we walked through and cleaned up the code in the case studies, we documented every reason for our actions as a heuristic or smell. We tried to understand our own reactions to the code we were reading and changing, and worked hard to capture why we felt what we felt and did what we did. The result is a knowledge base that desribes the way we think when we write, read, and clean code.

This knowledge base is of limited value if you don't do the work of carefully reading through the case studies in the second part of this book. In those case studies we have carefully annotated each change we made with forward references to the heuristics. These forward references appear in square brackets like this: H22. This lets you see the context in which those heuristics were applied and written! It is not the heuristics themselves that are so valuable, it is the relationship between those heuristics and the discrete decisions we made while cleaning up the code in the case studies.

To further help you with those relationships, we have placed a cross-reference at the end of the book that shows the page number for every forward reference. You can use it to look up each place where a certain heuristic was applied.

If you read the first and third sections and skip over the case studies, then you will have read yet another "feel good" book about writing good software. But if you take the time to work through the case studies, following every tiny step, every minute decision--if you put yourself in our place, and force yourself to think along the same paths that we thought, then you will gain a much richer understanding of those principles, patterns, practices, and heuristics. They won't be "feel good" knowledge any more. They'll have been ground into your gut, fingers, and heart. They'll have become part of you in the same way that a bicycle becomes an extension of your will when you have mastered how to ride it.


More About the Authors

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

The book is written very clearly.
Tomer Ben David
The book's broken into three separate sections: Good craftsmanship principles, case studies of refactoring code, and smells/heuristics in existing code.
James Holmes
Like many good books even if you know and agree what it says, reading the book can help you explain "the obvious" to others.
Steve Berczuk

Most Helpful Customer Reviews

111 of 115 people found the following review helpful By Edelmiro Fuentes on September 23, 2008
Format: Paperback Verified Purchase
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!
9 Comments Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
83 of 86 people found the following review helpful By Matthew R. Heusser on August 21, 2008
Format: Paperback
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.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
731 of 800 people found the following review helpful By Wayne Bradney on May 22, 2009
Format: Kindle Edition Verified Purchase
[Kindle Version Review]

The one star is not a reflection of the content of the book, which is clearly a very fine treatise on coding practices, but of the fact that the Kindle version is almost impossible to read. Code samples are truncated, in a variable-width font, and have less-than and greater-than symbols missing. References in the text often refer to listings that are not closely located with that text (eg. "see Listing 4-7 on page 71" is almost impossible to find on a Kindle without single-paging).

This is a book that requires a lot of page flipping, and shouldn't be available on the Kindle unless the publisher is willing to put in some effort to address these readability issues.
35 Comments Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
35 of 35 people found the following review helpful By KW on February 24, 2011
Format: Paperback Verified Purchase
In response to the "Don't get the Kindle version" review -- the problems appear to be resolved now. It looks fine on my Kindle 3 (aside from using proportional fonts in code examples, but this isn't too bad once you get used to it). Also, as many other reviewers have pointed out, this is an excellent book. I really wish all of my colleagues, predecessors, and managers had read it. My job would be so much easier and more enjoyable if they had.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
26 of 28 people found the following review helpful By Jeanne Boyarsky on September 14, 2008
Format: Paperback
"Clean Code" focuses on how to write "good" code. Where "good" is defined as being easy for others to read and maintain. It's not that I disagree with the definition of "good" here. The quotes are because 'bad" code is easier to identify. Then there is "good" code and really "great" code. The code in this book is what we should aspire to write.

There are three main sections to the book. The first describes principles with examples. I liked this section best including the chapters written by other experts. The third is the actual "smells and heuristics." While they are good, they were so short they wound up being a summary.

The second section is the case studies. Martin warns up front that this will involve a lot of reading code and cross referencing. I had trouble with flipping back and forth between the chapter, rules and an appendix at the same time. So much flipping was disruptive to my train of thought - even with three bookmarks.

Martin is good about referencing other related titles such as "Implementation Patterns." If you haven't yet read "Implementation Patterns", I recommend starting with that title. It's easier reading which is helpful when newer to a topic. Also while both books are very good, I liked "Implementation Patterns" better. (see my review on that title for why)

The actual content was excellent. The book only loses a point for the logistical issues in reading it.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Customer Images

Most Recent Customer Reviews

Search