Some readers might be put off by the cover, but it isn't all traditional hack-and-slash heroes - there are Valkyries on a modern fishing vessal, a cat who battles against the dark forces, and other wonderful adventures both serious and tongue-in-cheek. Great for fun, light reading that's a little thought provoking.

I found the book to be of great value, and the many beautiful photographs only make it better.

Refactoring is a book which details simple techniques of fixing your code to facilitate making changes.

The book's main feature is a large catalog of at least 50 refactoring patterns (presented in a similar way to Design Patterns) with a name, example, and motivation for using it. The patterns are described using UML. There are several other chapters of interest, including one on "Bad Smells" which lists many telltale signs of poor programming and how to fix them.

Maybe I'm just showing my lack of sophistication, but Design Patterns went over my head. I only "got" a few of the patterns. But this book is much more accessible to an intermediate programmer who wants to improve his coding style. If you've ever wondered how to write more maintainable code this is your book. One good thing about this book is it's directly applicable to almost every standard procedural or OO language, whereas Design Patterns are pretty much for OO programming only. Even if you are writing VBScript or Javascript for your web page you could use many of the techniques illustrated here.

Highly recommended. Buy this one.

However, Fowler doesn't stop there. He presents rationales for refactoring (with an eye towards making a case to management) and much detailed, practical insight that comes from experience, but is rarely expressed so concisely and elegantly. I also appreciated the importance Fowler placed on unit testing; in fact, using unit testing makes refactoring happen much more quickly, and leaves you with a lot more peace of mind besides.

I read the book cover to cover and enjoyed nearly every page. The book has added a lot to my value as a developer, and was a lot of fun in the bargain. I don't think a whole lot more needs to be said. Just buy it, you can thank everyone who told you to later.

Fowler suggests refactoring a program to simplify the addition of new functionality. The program should also be refactored to make it easier for human readers to understand at the same time.

He also insists that each step is small and preserves functionality, and on frequent unit testing with a comprehensive test suite.

Half of the book consists of a catalogue of refactorings. He gives each refactoring a memorable name, such as "Replace Type Code with Subclasses". He illustrates the design transformation with a pair of UML class diagrams, and has a standard set of sections: Motivation, Mechanics and Example.

The Motivation is a prose section that describes and justifies the refactoring, showing the relationship to other refactorings.

The Mechanics is a sequence of steps needed to carry out the refactoring, shown as a list of bullet points He expands on some points.

The Example is where the value of this book lies. Fowler takes a fragment of Java code, and takes us step by step through the refactoring. The code is small enough that he can show it all each step of the way without overwhelming us, but is large enough to be realistic.

The code is clear enough for non-Java programmers to follow. He explains his code well enough for the book to function as a Java tutorial where the meaning of the code is not obvious. One or two of the refactorings are specific to the Java object model, and do not apply to other languages. Other languages would benefit from similar treatment, but there are very few language-specific refactorings.

The book is very much of the Design Patterns movement, with frequent references to patterns. The aim of a factoring may be to achieve a particular pattern, or it may take advantage of a particular pattern. The book can be used as a tutorial on Design Patterns.

I have a small number of complaints. Fowler advocates the use of refactoring while studying code for a code review. One needs to be very sensitive to the feelings of the programmer here, especially if he or she is a novice. The reviewer should read the code with refactoring in mind, and possible refactorings recommended, but it is for the programmer to make the changes.

Reading this book has inspired me to refactor some of my own code. My mistakes underlined the need to take small steps, and to test frequently. I spent a day building a useful Delphi testing framework from the description Fowler gives of the JUnit testing framework. The one category of code that does not seem to lend itself to this approach is some highly coupled parsing code. While I can extract small blocks of code, they remain tightly coupled with each other, and it is hard to give them meaningful names. The answer here may be to use the top down approach of recursive descent, rather than the bottom up approach of refactoring. Perhaps recursive descent can guide refactoring. Refactoring is largely a local approach. One can almost say a pinhole approach. Sometimes a global view is needed.

In summary, I would say that this very good book would be of use to Java programmers who have some understanding and much bafflement. It is very good for us older dogs who have become a little jaded and need some new ideas and motivation.

This volume is has some decent material, but is marred by a tendecy to sloppiness.

Firstly, as other reviewers have noted, there are too many authors (count 'em - 16!), which is unnecessary, and leads to inconsistencies in presentation. The book could quite easily have been authored by a single writer. There are only a few chapters that required specialist knowledge.

For example, the early chapters are quite good at advising the reader on PHP settings. Since there's no option explicit in PHP,the author correctly advises the reader to increase their error setting to report unused variables. Later, however, much of the code uses uninitialised variables. This is particularly the case in the chapter on form handling, the approach to which is too crude, and uses form variables directly in code, whereas a better approach would be to capture them and process them using isset(). The isset() function isn't even covered in this chapter,but is used correctly in other chapters.

Secondly, while the converstational tone of Wrox books is often appealing, it can also be a problem at times. The presentation is not always comprehensive enough, and Wrox authors have a tendency to give overly clever examples.

Strangely, there's no reference section. I found some of the explanations sloppy and confusing, especially the section of session variables. (I still can't get the WAP application to work properly.)

Thirdly, the chapter on OO design leaves the reader stranded. After a decent theoretical discussion, the writer informs the reader that there will be no code examples, as the reader now knows enough theory to work an example out for themselves! If I've paid for the book, I don't really want to have it set homework for me.

Fourthly, there are an annoying number of errors in the code. Many of these are corrected in the online errata, but there are quite a few that aren't at present. Furthermore, some of them are not typos, but seem to be the result of misconceptions on the part of the writer. This tends to reinforce the impression that some of the authors are relatively inexperienced.

Lastly, there are a large number of errors in the downloadable code. I suppose supplied code should be seen as a bonus, but it's poor quality control, and greatly adds to the user's annoyance.