Rating: 
Summary: A must have for any OO programmer
Review: Even after working with OO technology for years, I got new insights into OO after reading this book and now write better code than every before. If you told me I could only keep one of my computer books (and I have a lot) this would be the one.Nicely organized into short (2-4 page) design patterns that describe step by step techniques for changing from a suboptimal design to a better one, you can learn a new technique that will immediately become part of your coding repertoire in just a few minutes. To increase the power of the techniques you learn, you can use some of the new coding tools (such as TogetherSoft or jBuilder with the Refactory add-in) that automate these refactorings, so you can transform a whole block of code with just a few keystrokes. Buy this book!
Rating: 
Summary: good but far from perfect...
Review: many of the advices the authors give are common sense techniques that every exp. Java programmer already knows. Especially, I refer to Calling Methods section. Some techniques are well explained and the book is easy to follow. Too expensive though.
Rating: 
Summary: not quite advanced enough
Review: A reasonable amount of the refactorings listed are helpful and I learned good things from reading about them. However, too many of them are basic programming heuristics that many of us know already. I would have liked the authors to spend more time on OO design centric refactorings or at least more advanced general programming refactorings. This book would be helpful to the beginner, but more experienced programmers probably already do many of these refactorings on their own.
Rating:
Summary: Essential guide to refactoring
Review: I had done refactoring before I had read this book.But I didn't know until I read the book that the technique I was using is called refactoring.Thus all those people out there who are code reviewers/analysts should read this book to get a sense of uniformity.
Martin Fowler has done a very good job in actually putting down some laws for OO programmers.But all these laws can also be applied to other languages(apart from Java in which most of the examples are written) too.Waste of effort in coding unnecessary lines can be prevented by following some of these laws.Code maintenance can be effectively made easy.Thus redevelopment time can be cut and therefore cost of design changes can be kept low in the long run.Repetition of code can be checked.
The book tries to bring to a form of template some loose comments about doing redesigning and rengineering of code.Another good thing about the book is that it tries to keep the examples simple and easy.Thus fundamentals are conveyed easily.Some of the examples can be confusing but most of them are crystal clear.I would recommend this book to both experienced and novice programmers.It is an essential guide to experienced ones because they can reengineer their attitude towards coding while the beginners can learn good things at the start itself.People who like me(I did refactoring in a project using Borland Pascal 7 for a billing application)have done refactoring before can read the book to discuss and open their mind to new ideas and maybe suggest some new good examples.
I would suggest that refactoring be followed in most B2B,B2E,B2C,J2EE projects mainly.Refactoring under structured methodology may not be very useful to do as it might not be very necessary and may not yield the same return it does in an OO environment.But still,good habits are not bad to follow whatever the environment is.
Rating:
Summary: Good tech ideas, bad writing style
Review: This books has alot of good information on Refactoring. Unfortunately the authors writing style is more appropriate for a novel or diary. There is way too much use of 'I', 'my', etc. You can talk to someone in person like that but that type of language in a technical book is out of place. Too bad his editor did not correct this early on. Otherwise, if you can wade past the 'me' drone, you will pickup some good stuff.
Rating:
Summary: An essential book for OO developers
Review: Refactoring is another must have book for any OO developer. As with other books like the Gang of Four "Design Patterns", Mr. Fowler has compiled, structured, and systematize a set of common practices that any OO developer does in his/her day-to-day work. Refactoring consist roughly in reshaping and evolving your code without changing its interfaces in order to improve its internal structure and functionality as well as other attributes. Every developer knows that is very difficult to hit the bull's eye at the first attempt and the code once written must be changed a number of times to accomodate new functionality or requirements or to allow the reuse. Mr. Fowler starts explaining what refactoring is using a pretty well documented and complete example, next he describes when, why, how, and where you must refactor your code and how to locate those pieces of your code that are suitable for refactoring and how to test those changes. Finally, the bulk of the book is devoted to a catalog that identifies and classifies the different refactorings. The book id full of code examples in Java, easy to read and right into target. From my point of view is a good investment for any developer.
Rating:
Summary: Good for programmers at any level
Review: Regardless of whether you adopt each and every one of the recommended practices, this book clearly and concisely presents each concept with simple examples, UML diagrams, and good explanations of the pros and cons of performing each refactoring, as well as when to use them. These are great techniques to add to your toolset as an object-oriented programmer. Be aware that as defined by the book, refactoring means changing a program without altering the behavior of the program ("Improving the design of existing code.") Refactoring is essential for any software that must be maintained or upgraded, so this book can be a great aid to anyone who works with code. As a Gang of Four affiliated book, it uses the concept of patterns and a catalog to efficiently present material. It also uses the concept of "smells" of code to bridge intuition and best practices. Overall, a worthwhile read.
Rating:
Summary: Must have
Review: If you are a Java developer and you either do not have access, own or have read this book you are not a Java developer.
Rating:
Summary: A beginner book
Review: First of all, this book is good to understand the meaning of refactoring and its techniques. If you are a beginner programmer, the book is quite helpful to know how to do refactoring, and why and when to do it. However, the problem is the book is a "book". Many programmers may feel familiar with stories and techniques in the book. The techniques in the book, though, are not exceptional, unfortunately. For example, the book explains how to make a temporary variable or how to eliminate it for a couple of pages! This kind of thing is a common work for programmers. Many don't have to learn that. One of problems of refactoring for experienced programmers is that refactoring means not add features but "change" existing code. Although giving benefits, refactoring gives some problem. For example, when working as team, it is hard to even change the name of method because the change often causes conflict among sourcecode. The book doesn't give any solution of this problem. In conclusion, I don't recommend this book for experienced programmers.
Rating:
Summary: Excellent, very important, but parts are somewhat obvious
Review: Refactoring is so important and many companies don't put enough emphasis on refactoring. This book provides a great introduction to what refactoring is and a great reference for how to refactor. The first few chapters are crucial for every computer programmer and project manager to read. These first chapters will clearly explain how and why you need to be refactoring. The later chapters go through various refactoring patterns. These later chapters will be very useful to programmers with less OO programming experience but may be less useful to many programmers. Regardless, the book is well worth it even if you only read the first few chapters.
| 
