Clean Code: A Handbook of Agile Software Craftsmanship - Differentiator?

Hi Robert Martin
What differentiates this book from the following:
Code Complete 2 by Steve McConnell
Martin Fowler's - Refactoring: Improving the Design of Existing Code.
Pragmattic Junit Testing - Andrew Hunt and David Thomas
Practices of Agile Developer - Venkat Subramanian and Andy Hunt
Effective Java - Joshua Bloch
Avoid singletons as in http://c2.com/cgi-bin/wiki?SingletonPattern

Is there details about what is the right way to manage dependencies, how it should be passed around or it is good to use IOC, when to use one over the other, do you touch up on these.
Couldn't find more on this from Safari

What will be the most important take for developers from this, if they have already familiarized with what is specified in above books and topic relating to them?

Thanks,
Vijay Venkataraman

Pragmattic Junit Testing - Andrew Hunt and David Thomas
Effective Java - Joshua Bloch

These two are way different. Even the titles are quite specific.

Hi Adeel Ansari,
The books "Clean Code" seems to touch on topic from all the books i quoted.

I am quite aware and it is quite obvious that these two books talk about different aspects.
Pragmatic JUnit Testing - Andrew Hunt and David Thomas
Effective Java - Joshua Bloch

My question was - The book we are talking about seems to touch up different topics in all the books i have mentioned.

Let me rephrase - how is it specifically different from parts of the contents that have been already dealt in these books.
Eg - Exception and Threading has been dealt in Effective Java
Refactoring - In Martin Fowler's Refactoring
Testing is well talked about in Pragmatic JUnit Testing
Naming,functions and looping and much much more in Code Complete II

I have read all the book i mentioned and much more, so what is new and very important learning it will impart?

What makes it different from all of those mentioned?

It will be great to know about it.

Thanks,
Vijay Venkataraman

Martin Fowler's - Refactoring: Improving the Design of Existing Code.

Refactoring is more about how to change existing code, whereas I guess Uncle Bob's book is more about writing new code.

Pragmatic Junit Testing - Andrew Hunt and David Thomas

I don't think JUnit/testing is in scope of Clean Code. So probably quite orthogonal.

Practices of Agile Developer - Venkat Subramanian and Andy Hunt

As far as I remember, many if not most of the practices in this book don't have to do with code at all.

Originally posted by Ilja Preuss:

I don't think JUnit/testing is in scope of Clean Code. So probably quite orthogonal.

Actually, chapter 9 is on unit testing, and chapter 15 is on JUnit internals.

Originally posted by Alaa Nassef:

Actually, chapter 9 is on unit testing, and chapter 15 is on JUnit internals.

Thanks for pointing that out. Apparently, the table of contents on Amazon.com is far from being complete. Bummer...

The Table of Contents I linked to in the Welcome thread is better than Amazon's one.

Chapter 9 is about testing, but it's about writing clean tests. Where as the titles about about testing cover testing in a lot more depth because there is a different goal.

Chapter 15 uses a part of the JUnit as a case study example for refactoring to make code cleaner. It's not actually about JUnit.

Thanks for pointing that out.

Hi Jeanne Boyarsky, Alaa Nassef and Ilja Preuss
Thanks for taking time to respond.

The table of contents with more information is better in safari than posted in the original link.
http://my.safaribooksonline.com/9780136083238?tocview=true

I think it will be very interesting see what is in these chapters:
Chapter 8. Boundaries
Using Third-Party Code
Exploring and Learning Boundaries
Learning log4j
Learning Tests Are Better Than Free
Using Code That Does Not Yet Exist
Clean Boundaries
Bibliography

Chapter 13. Concurrency
Why Concurrency?
Challenges
Concurrency Defense Principles
Know Your Library
Know Your Execution Models
Beware Dependencies Between Synchronized Methods
Keep Synchronized Sections Small
Writing Correct Shut-Down Code Is Hard
Testing Threaded Code
Conclusion
Bibliography

Is there more information about these chapter. I did get a peek on this in safari, but would be nice to see more information on it.

Thanks,
Vijay Venkataraman

The table of contents with more information is better in safari than posted in the original link.
http://my.safaribooksonline.com/9780136083238?tocview=true

This explains my previous question. Bad code versus clean code. Thanks Vijay.

What differentiates this book from the following:
Code Complete 2 by Steve McConnell
Martin Fowler's - Refactoring: Improving the Design of Existing Code.
Pragmattic Junit Testing - Andrew Hunt and David Thomas
Practices of Agile Developer - Venkat Subramanian and Andy Hunt
Effective Java - Joshua Bloch
Avoid singletons as in http://c2.com/cgi-bin/wiki?SingletonPattern

I would also add books like Bitter Java, Bitter EJB, etc.
[ September 24, 2008: Message edited by: arulk pillai ]

Hi Rulk pillai
Glad to hear that it helped.

I would also add books like Bitter Java, Bitter EJB, etc.

Thanks for pointing to me other books. I looked at the different reviews it has, look very impressive.

Should grab Bitter Java and start with it very soon.

EJB 1.x to 2.x is bitter. After looking into hibernate and spring i don't think i will think of EJB.

And for other, who believe in agile programming and TDD and are always looking to do good development, many things will be repetition.

For anyone who has been following books and writings by Kent Beck ,Martin Fowler and the agile group, most of what is said in the book will be obvious.

Nothing like following it and finding out for oneself.

Thanks,
Vijay Venkataraman

Originally posted by Vijay Venkat:
After looking into hibernate and spring i don't think i will think of EJB.

You should take a look at EJB3 and the JPA specification. They're totally different form EJB 2.x, and I'm sure that you'll be impressed

Originally posted by Vijay Venkat:
Hi Robert Martin
What differentiates this book from the following:
Code Complete 2 by Steve McConnell
Martin Fowler's - Refactoring: Improving the Design of Existing Code.
Pragmattic Junit Testing - Andrew Hunt and David Thomas
Practices of Agile Developer - Venkat Subramanian and Andy Hunt
Effective Java - Joshua Bloch
Avoid singletons as in http://c2.com/cgi-bin/wiki?SingletonPattern

Is there details about what is the right way to manage dependencies, how it should be passed around or it is good to use IOC, when to use one over the other, do you touch up on these.
Couldn't find more on this from Safari

What will be the most important take for developers from this, if they have already familiarized with what is specified in above books and topic relating to them?

Thanks,
Vijay Venkataraman

The primary differentiator is that we get very specific about the way WE write code. We put a stake in the ground and say: "This is how we do it. You may not agree. You may not like some of our conventions. But we do it this way, and you can probably learn from what we do, even if you still don't agree when you are done reading."

So, for example, we say that hungarian notation is an abomination. We say that functions should be so small they can't have more than one level of indent. We say that short names are OK in short scopes, but long scopes need long names. We say that functions should not pass more than 3 arguments, and it would be better if they passed none. etc. etc.

The other big differentiator is that we show a LOT of code, and we show how that code can be improved.