Rating: 
Summary: Too obvious book
Review: I rate the book with two stars because the introductory part of the book brings you some good ideas and thoughts. From that point, the reference material is too simple.
Rating: 
Summary: Refactoring: Improving the Design of Existing Code
Review: This is a book where the title explains it all. There is no hype, no esoteric theory, no new age crystals or silver bullet tool being sold by this book. The methods explained in this book are clear, concise and immediately useful if you are a novice or a guru. I cannot even think of another book where that is true. Take your code to the next level and buy this book.
p.s. The hard cover and ribbon bookmark are a very nice and classy touch for a classic book.
Rating:
Summary: A must have for your programming bookshelf
Review: Refactoring definitely embodies the phrase "don't judge a book by its cover". Unfortunately I did this and missed out on a great book for too long. Franky, this thing looks like a text book... not something that would be an easy, enjoyable ready. However, this is exactly what it is.Fowler's conversational style keeps the book moving and very enjoyable. He opens with a refactoring walkthrough that introduces you to the general concepts. After this the book catalogs all of the refactoring methods and really becomes more of a reference. In about 30 minutes you can read the first few chapters and come away with a good appreciation for the book. If you've been programming for a while you'll probably find that you were already performing many of the refactorings. This book takes what you've been doing intuitively and formalizes it, much like Design Patterns. Those that are new to programming might find the book a bit confusing since many of the refactoring methods are opposites of each other. Experience really drives the decision of which refactoring to use. That said, Fowler does a good job of stating the intentions behind each and providing good examples (all in Java, but simple enough to be understandable even if you aren't familiar with the language).
Rating:
Summary: Required on any developer's bookshelf
Review: This is another fabulously written book by Martin Fowler. Concepts are described in excellent detail, yet simple to understand. The first chapter alone is worth the price of the book. It not only describes numerous means of improving existing code, it abets the understanding of the full potential of the object-oriented paradigm and will significantly improve the way you write new code as well.
Rating:
Summary: Must Buy - Extremely Useful
Review: Along with Design Patterns, Refactorings is a significant step forward in software engineering. I actually found this book to be more useful than the popular Design Patterns book. Most software developers do not write new code from scratch. Instead they have to enhance and maintain code written by other developers. This book provides many useful techniques to make this job easier. To some degree, I found I was already using techniques like these in my own day-to-day work. This book, like Design Patterns, collects these techniques and makes them available to everyone.
Rating: 
Summary: Too bad we actually seem to need this book...
Review: At first glance I wanted to give this book only three stars, since I still think that if "we" (designers, programers, etc.) would never need the stuff that is in this book as heavily (or at all) if we all would be doing our jobs as we should. Now that I have read almost all of it, the book is really more on par with the 'Gang of Four' design patterns book, but then not from a design point of view, but from the point of view of practical day to day programming, where almost always code you need to change is spagetti. Even the best designed software degenerates into spagetti very fast because of lack of documentation, lack of interest in other programmers that made changes to read documentation and just hack into the source code whatever is needed at that time, etc. In such a screwed up situation - which we should never get into, but in practice almost always are... - the information in this book can really help you. It might even merit 5 stars, but I refuse the give it that because I still think the book says "it's okay to screw up and not really do your job properly in the first place; you can always do a bit of refactoring if it gets too much out of hand" and I do not like that frame of mind at all. One of my pet peeves is that, because I work in a VisualBasic environment, the examples and indeed some of the refactorings themselves often lean somewhat heavily on Java and its features. That's no problem to me, but might be for "VB-only" programmers. But with a little more time (with .NET) this problem should vanish and this book should be even more useful to the VB community out there. Despite that I do not agree with the books premise, I still recommend it to all programmers.
Rating:
Summary: rare combo: authoritative, original, and well written
Review: I needed to buy the book, to begin to get serious about the topic. Since it is the original, I expected it to be authoritative and useful, but perhaps somewhat dense and a bit hurried. Well it's not. It's extremely well-conceived and well-executed. The language, organization, and scope are all excellent. Fowler begins with and continually provides good examples, and always chooses a clear narrative arc through the theory and practice of this new discipline. He makes a single book serve equally well as tutorial and reference, which is danged hard to do. The style of writing is confident, unpretentious, crisp as a Granny Smith apple, and occasionally witty. What issues he chooses to argue forcefully are few, and are not beaten to death. What a relief. As a result, the non-reference sections are a much quicker and easier read than I expected, and one can actually browse the reference on refactorings usefully. The net effect is quite a convincing case that software engineers will inevitably become expert with refactorings, as we are required more and more to design our code according to objective standards for excellence, keep our code maintainable, and review it among peers. In any case, I am now among the converts. If you found Fowler's UML Distilled to be well-written, you will like this one even better. I think it is a gem of a book. I will read it many times.
Rating:
Summary: A dose of uncommon common sense
Review: Much of what the author says is common sense in the OO field. Having said that, it is also true that common sense is not all that common in practice. This book does do a valuable service is in assembling the catalog of refactorings and naming them. Books like this and other books on design patterns (you know them) try to make a science out of an activity (design) that is essentially an art form. That is progress.
Rating:
Summary: Worth putting on the bookshelf
Review: I first encountered this book on the job. In combination with the other XP texts by the author and the contributors to "Refactoring", it helped shed light on the underpinnings of modern programming practice. The approach presented by these authors has a self-consistent logic that I find inspiring. Although I read several "XP books" on that job, this is the one that I'm buying for my own collection. The sheer volume of useful patterns in this text alone make it a valueable asset.
Rating:
Summary: Fantastic resource for developing quality code
Review: I would have to give 2 thumbs up to Martin Fowler's book on Refactoring. He has addressed so many common refactorings in such a simple and elegant way that many will benefit from his work (as well as the others that helped write this book). Martin's writing style is very relaxed and sincere. He's entertaining and doesn't complicate things as you can easily find what you need. You can tell he simply wants to make programming teams' lives easier and he has accomplished tenfold. He's not going to tell you that your an innately bad programmer or that he is a better one - he truely captivates that quality code is important and refactoring is that one big step that each organization and programmer must take to improve the quality of code. Some of the patterns that he identifies are very common - but for completeness' sake, he includes them. Others are very insightful such as Introducing Null objects, which I've used 5 times in a single application now since I've read this book. This is also an excellent book to accompany Design Patterns, as many of these refactorings will help you achieve design patterns in your code - it's like working them in your code in a different, systematic way. All in all, this is a fantastic contribution to improving code and developing quality programmers in the software development industry. I would recommend this to any software professional and especially university students (where quality code is not touched on at all). It's the will of the programmer to improve their code and this is one of those books to read if you want to do that. If you want to just be an average programmer, a following in your organization and not take responsibility - then don't read this book. If you want to truely be effective in your job or entrapreneural projects, add this book to your bookshelf and read it, use it and live it.
| 
