Review By: Scott Brookhart
06/26/2006"Prefactoring" is for the software developer looking for guidelines in best practices. The book examples are in Java, but the practices are easily adaptable to other programming languages. As other readers of this book have suggested, the title refers to refactoring, a practice of reworking written code that continues to perform the same functionality for purposes of maintenance or performance of the code. However, this book has less to do with refactoring and more to do with best practices and style. Many of the practices in this book are gleaned from experiences and insights and highlighted to make them easy to understand. Both Java code and Unified Modeling Language (UML) are used to help describe the process for developing software. An understanding of basic UML, an object-oriented language, and object-oriented practices is needed to best comprehend the guidelines.

The sample application--a CD rental store--is easily understood and allows the reader to focus on the software development process rather than learning the application requirements. The text varies between the descriptive narrative and dialogue between characters involved in developing the application. The book starts with some general guidelines of software development and then gets into the design and coding of the sample application. Attention given to eliminating duplications and is stated in different ways throughout the text. The appendices include a listing of the guidelines and principles provided throughout the book and the source code. This is a nice touch and a reference to be used later. Real world examples make this book more credible and more attractive to developers working in industry.

Overall, I enjoyed reading this book and found the author’s use of the word "prefactoring" novel, though I would argue that prefactoring is comparable to the design process using best practices. I was glad that the author defined the term early on to dispel any preconceived notions that would conflict with the similar term "refactoring." As an experienced developer, I like the appendix listing the guidelines. The guidelines themselves are pretty self-explanatory and have been covered in other texts.

This book is appropriate for developers who want to reduce the amount of refactoring in the implementation or maintenance phases of the software lifecycle. The writing style is light and easy to follow, though I could have done with a little less dialogue between the fictitious characters. The source code for the sample application is available on the Web site at examples.oreilly.com/prefactoring, which allows the developer to pay attention to the design, guidelines, and application rather than the tedious task of typing up the code.

"Prefactoring" is about eliminating duplication in different ways and considering guidelines for software development so that applications are simple, consistent, and readable. Developers experienced in object-oriented practices, object-oriented languages, and the UML will benefit most from the list of guidelines and principles offered in this concise listing.