I have been meaning to post a review of Software Factories: Assembling Applications with Patterns, Models, Frameworks, and Tools for some time.

 

This book in my mind represents the state of the art in software engineering today.  The book is based upon the concept of building families of similar, but distinct products, which have been around for years in other engineering disciplines such as civil, mechanical and electronics engineering.  These concepts promote the systematic reuse of like components and factored out variable components for customization in order to produce products that were similar but yet each one being unique.  This is commonly known as mass customization, something that is very new to the software world, but old hat for other industrialized engineering industries.

 

I know Software Factories is an overloaded term, but consider this definition: a factory is a highly organized production facility that produces members of a product line using standardized parts, tools and production processes.  The factory term is common in the industrialized engineering world, but extremely uncommon in our un-industrialized software development world.

 

Jack and Keith initially introduce us to dealing with complexity and change, which are the two fundamental problems in designing and constructing quality software of any size.  Anyone that has read the Standish Groups CHAOS report understands our incredibly poor track record in dealing with these fundamental problems, regardless of programming languages, platforms or methodologies used.  The following chapter on Paradigm Shift assists the reader in understanding these problems as well as the critical innovations that solves these problems.

 

Software Factories goes on to explain their concept of what is a Software Factory within the context of economies of scale and scope.  This is the most critical point of the book to understand, Economies of scale arise in production, while economies of scope arise in development.  Economies of scale arise when multiple identical instances of a single design are produced collectively.  Economies of scope arise when multiple similar but distinct designs and prototypes are produced collectively rather than individually.  This fundamental concept is absolutely key in understanding the how Software Factories pave the road to the industrialization of software.  The authors could have spent more time on this subject at it is the most confusing concept for any software or non-software person to understand and represents the barrier to understanding that software development is no different than any other traditional engineering development process.

 

The next 3 chapters delve into Models and Patterns, Programming with Models and Language Anatomy and how these approaches raise the level of abstraction so that models can be used as first class development artifacts.  Essentially how Domain Specific Languages (as opposed to general purpose languages) converges the gap between requirements (problem input) and executables (the solution).

 

The following 7 chapters cover in detail the concepts above by discussing Families of Languages, Systematic Reuse, Software Product Lines, Platform-Based Abstractions, Components and Services, Mappings and Transformations, and Generating Implementations.  Incredibly well done and I cannot do these chapters justice in this short review.

 

Chapter 16 demonstrates a concrete example of a Software Factory using all of the concepts, techniques and best practices described previously in the book.  Jack and Keith show how the methodology can be implemented now, that it can be widely used to complement and eventually replace existing practices, and that it can help move the software industry toward maturity.  This chapter alone is worth the price of the book.

 

Finally, a section on Frequently Asked Questions compares Software Factory approach to what we know about software development, before Software Factories.  This puts into great perspective the differences between Software Factories and the current state of the art, which is commonly referred to as custom one-off software development.

 

I cannot recommend this book highly enough.  As someone who came from the R&D electronics world 20 years ago where I (and the rest of the electronics industry) routinely used product line engineering development practices, I thought when I joined the software world 15 years ago this approach would be the norm.  How nave was I.  This book should not only be required reading for anyone practicing software development, but also mandatory reading in every Computer Science program.  Then maybe we will see the industrialization of software development become common practice as it currently is in other industrialized engineering disciplines.