Reviews for Refactoring: Improving the Design of Existing Code (Object Technology Series)

1. The best one in Refactoring

   Rated 5 out of 5 stars, March 12th, 2010

   I read this book in one day and recovered 360 of developement. I really appreciate this old book. It don't needs update, is already perfect. I really advice this book

2. Who cares if you "knew this already" ?!!

   Rated 5 out of 5 stars, December 12th, 2009

   Great ideas in software are often met with the "if you've been around as long as me, then you know this stuff already" line. WHO CARES?!! Often in fields involving know-how, the most "obvious" things (techniques, principles) *need* to be revisited, re-stated (out loud, as it were), just to plant our feet back on the ground, to reacquaint us with the foundations. I approached this book with scepticism but after reading a chapter and skimming through the rest, I was already re-enthused on a software project I had become disillusioned with. The results are an order of magnitude better: lean, clear, crisp, efficient. It'll make you proud to show your code to others!

3. Proceduralist Converted

   Rated 5 out of 5 stars, July 12th, 2009

   As someone from a procedural background, i've read books on OOP and tried to embrase it into my work but never really saw the point. This book has caused me to change my view of OOP entirely. At the time of reading this book i found myself needing to edit some old code i'd written, as is often the case the old code had grown uglier and uglier the more bits that got added to it, with lots of nested conditionals and a huge switch statement. With the help of what i learnt from this book, i converted the old code to a class heirarchy and reduced the amount of code by 500%, making it far easier to understand, and then add new features too.
   I'd recommend this book to anyone who want's to write cleaner code that's easier to maintain. Although the examples are in Java, it's easy to grasp the principles and apply them to PHP.
   I just wish i'd read this years ago, as i now want to rewrite everything i've ever done.

4. If you've been around for a while, very little of this will be new to you.

   Rated 2 out of 5 stars, April 12th, 2009

   If you have been around for a while, the reality is that most of this book, you will (or at least should) know already. Martin Fowler has a tendency to take existing paradigms and slightly re-jig or rename them, then present them as a ground breaking new approach. Some of his ideas have a lot of merit, and that goes for some of this book too - but you'll find yourself time and time again thinking "well, that's obvious", or "I already do that", or "well that's such and such by another name", and you'll find yourself learning a few useful techniques along with an awful lot of new terminology for existing 'patterns' that have been around since the year dot. Worthy of note is that (inevitably) all of the examples are Java. Syntactically this shouldn't be a massive problem for a C# developer, but the usefulness and applicability of some of the *ideas* to the world of the CLR, frankly, varies.
   
   That's not to say that this wouldn't be an interesting read for a developer with a couple of years under his belt, or a developer who's worked in environments where quality isn't the primary concern. But if you are in this position, and you're looking for a book on "how to write good code", get Code Complete: A Practical Handbook of Software Construction. That book should be on everyone's bookshelf, whereas this, whilst interesting in places, is far from the indispensable masterwork the evangelists crack it up to be.

5. It's always obvious in retrospect

   Rated 5 out of 5 stars, December 12th, 2008

   When I first read this book it described a whole lot of practices that I'd been following for years, I just hadn't call it refactoring. I'd find some piece of code that didn't feel right and then I'd tinker with it to improve it. I'd rename variables and methods and rearrange stuff and so on until I felt it was right. I just didn't have a vocabulary to describe what I was doing.
   As with other classics the situations and methods that are described here are now considered obvious and simple by many, but that wasn't always the case. This book defined the terms that are now in common use, the code smells, the refactorings, even the word itself. It has provided modern software development with a knowledge and understanding that code isn't developed perfect the first time around, that it is ok to improve it and that it can be done in a safe and controlled manner.
   Every developer should read this book at least once. Personally it is one the books that I always keep with me when working.