A Handbook of Agile Software Craftsmanship - Clean Code

As mentioned in other reviews, the book itself is low quality. The cover image is blurry, there is no print on the binding, and there are pointlessly large margins surrounding all of the text. On top of that, the printed font is grainy and difficult to read.

I would rather track down a proper printing of this product, than try to trudge through reading this. As a comparison, Code Complete is three times longer than this book. However, I was able to easily hold and read that book. This version of Clean Code feels like you are holding a ream of printer paper, with every page printed in portrait mode.

It is unwieldy to say the least.

This is Uncle Bob's first major title, focusing on writing clean, maintainable, and enjoyable code. Regardless of language, every programmer should read and apply this, especially who work with object oriented codebases. Most of the advice comes with explicit examples, and are largely things that you can start working on right away.

I seem to have received a bootleg copy. The cover is blurry, there is nothing printed on the spine or back cover of the book, and the text inside is grainy and difficult to read at times. I returned the item because it looks very poorly made and I was planning on giving it as a gift. Since others have experienced this problem, I recommend you save yourself the trouble and order it somewhere else.

When I first started reading, I found that I already knew much of the material--some of which I actually practiced. However, as I progressed into the book I found myself learning new methods of approaching code and new ways to apply old lessons. By the time I finished the book I found myself actively applying the techniques with renewed vigor and really enjoying writing code again.

Now that I've had a few months to let the advice sink in and use it on a couple projects and languages, I can safely say that I found the book on the whole to be an invaluable resource. I have integrated more of the material than I expected into my day-to-day coding practice, and I highly recommend it to my colleagues.

The content of this book is essential reading but I would suggest buying from somewhere else. The copy I received from the store was clearly a bootleg copy. The back cover was blank, the front cover looked like a low quality image stretched to fit the page, and the inside was barely readable at parts and had huge margins because it is a textbook size page printed on normal printer paper. Don't get scammed, buy somewhere else and make sure you get an official copy.

A really nice book that must be read and absorbed by anyone who works on a team and/or is looking to improve him/herself. When I read, I identified a lot of concepts/practices which relevance I already knew but I realized I was not really being pragmatic in adopting it.
The book is very clear on the concepts and explanations, has a lot of examples and is written by Robert Martin !
A must have (or read) by any serious software engineer.

Clean Code is a great supplement to any programmer's bookshelf. In fact, the ability to code cleanly is one of the most sought after traits in programmers.

If you're new to Software Engineering (Freshmen in University), read it: your instructors will love your code (at least relative to your peers). It might even get you some free points!

If you're an expert, you've probably gleaned a lot of the points of Clean Coded already through continual frustration with other's code. Sometimes we forget that our code isn't perfect either. Clean Code will at least be a good refresher, and you might pick up a few tricks. Introspection is key!

I also recommend reading The Pragmatic Programmer either before or after clean code. And if these two pique your interest, perhaps move onto Refactoring by Fowler or Code Complete by McConnell.

This book really solidifies your existing knowledge of software development and corrects your "what you think you know" assumptions. I have a few years of software development experience under my belt, but there were a lot of little things that this book covered that I actually never really thought about. I'm a C# developer, but this book was a breeze even though it's in Java.

30% education. 70% inspiration. I won't retread ground already covered by other reviewers. Simply put this text has enlightened me of new techniques, reminded me of things I've always known, but most importantly inspired me to do better.

If you want to become a better programmer, study this book. Don't just read it, do all of the exercises and do them several times until the ideas and techniques are second nature. The material is in-depth and requires time and patience to complete, but it is well worth the effort.

This book is excellent and I would highly recommend it for any coder wishing to improve their code in terms of simplicity, ease of use, and maintainability. To get the full benefit of the book requires some understanding of the Java programming language and some understanding of refactoring code. The book gives great examples and great principles to follow when re-factoring code. I have read this book, and am already noticing an increase in productivity in my Java coding at work. Whereas before I would just think about getting the code done, I now think about how to refactor it to make it better. The best rule I learned from this book is the 'boy scout rule' for coding: always leave code a little bit cleaner than when you found it. By doing this, code is continuously improving every time you write it, even if you only clean up a few things each time.

I seem to have received a counterfeit printing of this book. The margins are clearly too big and not as originally designed. The book is much larger than intended. The cover image has clearly been scaled up from a low resolution image. There are JPEG artifacts around the text edges and clear pixelization on the cover. My coworker appears to have a "legit" copy of the book and it is smaller, with no such cover image artifacts and a different font for the main text's body. I have included photos of the cover to illustrate the poor cover printing. I did not give 1 star because the content of the book is intact.

Stop reading reviews, start reading the book. Get the kindle edition so you can read it immediately. Get the print edition so you can loan it to other developers when you're finished.

I wish I would have read this book when I started programming, I would have far fewer as habits to break now.

Before reading this book I used to develop ad-hoc, repeated code several times across several modules. The architecture where I currently work doesn't help in the reusability matter, there isn't a common module. But anyway, this book has shown me the real cost of dirty code and how I wasn't helping at all my sucessors and team mates and above all it has shown me how I was acting unprofessionally.
The book, inside its medium constraints (display, formatting, page size, etc.) is very thorough into showing examples of bad coding and how to refactor them. It talks about some principles and practices which help into creating clean code, pherhaps others books elaborate those principles (Single Responsability for instance) in greater detail and the author gives references to those books. Of course each project has its own characteristics, it is up to developer to apply the practices according to the circumstances. You will have to think a lot to find out which patterns would achieve a cleaner code. But, at least for me, it has helped me building components that are easier to mantain and change. And when I write clean code it feels like the computer is working for me, what would first require several Ctrl+C and Ctrl+V to implement and much more keystrokes to change, now require just some refactoring (in Eclipse IDE) but also a lot of brainpower, which much better used at refactoring rather than in understanding (namely reading lots of classes, endless scrolling, remembering where is the function that you need,etc. just to understand a single method)
So, in short, it is a terrific starting point to produce clean code (easier to understand, change and mantain), that will not hinder yourself or your teamates later, but it is in no way a one-size-fits-all formula, In fact there isn't such thing, at least in my opinion.

A practical guide for writing cleaner code. A lot of the tips in here are common sense but you'd be surprised how few people actually follow them. If you want to write code that you can look at in 5 years and be proud of, this is a good read.

This rating is not a reflection of the content of the text. This book seems to be published and printed by amateurs. Pages have abnormally large margins, the print quality is very low, and the cover looks like a bad photocopy with no print on the spine. Not sure what happened here, but nothing good.