The VTK Users's Guide is a companion text to The Visualization Toolkit text. While The Visualization Toolkit stresses algorithmic and data structure details, the VTK User's Guide stresses how to use the software. The VTK User's Guide includes a CD-ROM of VTK 3.1.

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.

If you would like understand how to use the VTK software, you should purchase The Visualization Toolkit User's Guide. This companion book is updated for each major release of VTK, and contains many detailed examples.

Russell Windle