More often than not, developers will stop a large project in the middle of the build stage to rethink and recode the software design so it's cleaner and more efficient. Known as "refactoring," this process eats up valuable time and money. To help offset refactoring, this book presents a new process called "prefactoring," the premise of which states that you're better off considering the best possible design patterns before you even begin your project.
Prefactoring, in essence, is the art of applying the insights gleaned from previous experience (whether yours or someone else's) when developing software to new projects. Doing so will likely save you from making costly design changes midstream--and maybe even save your job!
This practical, thought-provoking guide details prefactoring guidelines in design, code, and testing, each derived from the lessons of many developers over many years. With these guidelines, you're far more likely to create more readable and maintainable code before you reach the second-guessing stage.
To help communicate the many facets of this process, Prefactoring follows the example of a fictitious client, Sam, as he seeks to create a software system from beginning to implementation. Among the topics covered:
General development issues
Creating reports via separation of concerns
Associations and states
Creating and testing interfaces
If you understand object-oriented design, and you want to save time and money by considering more efficient designs before you begin your project, Prefactoring will show you the way. It won't guarantee that you'll never need to refactor your design or code again, but you're sure to cut down on the amount of refactoring you do.
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.