Rating: 
Summary: Required reading!
Review: I can't help but add to the amazing number of five-star-reviews - this book definitely belongs in every software developer's library. Much of this enthusiasm is certainly due to the excellent readability - Martin Fowler really knows how to write.
Rating:
Summary: Wonderful, Practical, Readable...
Review: This book is the perfect complement to more theoretical approaches to OO. Wonderfully useful and fun to read. BUY THIS BOOK!!
Rating:
Summary: Practical Refactoring Guide with lots of examples
Review: Very understandable and lots of examples. This book gives you a nice hands-on toolset of how to improve the design of legacy code. It gives a nice alternative to haveing the "perfect" design and makes iterative programming legitimate.
Rating:
Summary: Sick of your old code?
Review: Finally I found the secret to revive my old code! Now I'm not afraid to begin with new projects. I know, I don't have to do it 100% perfect from start. Buy two copies of this book, one for yourself and one for a friend.
Rating:
Summary: If you buy only ONE OO book...
Review: ...buy Design Patterns. But if you buy a SECOND, get this book! I can't recommend it highly enough.
Rating:
Summary: Extremely Useful and Very Deep Insights
Review: READ THIS BOOK!!! It will make you a better programmer, definitely in Java or Smalltalk or C++ and probably in ANY language. It is fun to read and has the current thinking by the leaders of OO on how to make existing code "better" in dozens of ways.
Rating:
Summary: Extremely important to all Java programmers
Review: I simply can't say enough good things about this book. I've been promoting the process of refactoring for a long time, but I never had a reference to provide authoritative support. This book provides that and a whole lot more. By providing a concrete process and a wonderful set of examples that show how to turn mediocre code into great code this book can change the way people program. Considering how many mediocre Java programs are being written today, this book couldn't have arrived at a better time. One thing to emphasize is how important the chapter on JUnit is. Martin provides a firm foundation for refactoring by insisting that it always be done in the context of a complete set of tests. I've already recommended both the book and the framework to my consulting clients, and will continue to do so. Thanks Martin!
Rating:
Summary: Beware, paradigm shift ahead
Review: When I first started reading this book, I Laughed. Having garnered a reputation as a "Mad Slasher" of badly written code (say, 700 line programs down to 150 lines or less), it was wonderful to see the principles I'd learned over the years codified into a readable catalog of techniques that should be in everyone's arsenal. Required reading for those new to OO development, and a new vocabulary (similar to what "Design Patterns" did) for everyone to share their insights. BRAVO
Rating:
Summary: excellent addition to the OO/development literature
Review: It's great to read a book that adds something new, and something useful. Fowler puts down on paper the wisdom of experienced OO developers. The book lists a range of manageable changes that can significantly improve code quality. This neatly complements Arthur Riel's "Object Oriented Design Heuristics"
Rating:
Summary: Very valuable contribution towards Programming folklore.
Review: First one small complaint about this book: It introduces the notion of "bad smells in code" which are nothing but "Anti-patterns". Why introduce another new term? The notion of "Antipatterns" was introduced by another book with that title. That book too handled some of the issues of "Refactoring" although at different level and hence should have atleast been mentioned in the bibilography. Interesting thing is that the "Catalog of Refactoring" in this book is in inverse format of the "Catalog of Anti-Patterns". That is not a bad thing though. Many thanks to all these authors (like the GoF and Fowler-Beck-gang) who giving the OO programming world a higher level vocabulary, by giving names and cataloging simple types of changes that you make to your code to rejuvenate it. That is a very important contribution towards documenting valuable programming folklore. The book is pretty focused. The authors talk of little Refactoring. And don't digress into suggesting ways to handle Architectural or Infrastructural Refactorings (like say moving from Monoliths to N-Tiers). That makes it a fun yet valuable read. -------------------------------------- This are my own views not my employers
| 
