Browse Books

Reviewer: Fernando Berzal

A software factory is a "configuration of languages, patterns, frameworks, and tools that can be used to rapidly and cheaply produce an open-ended set of unique variants of an archetypical product." This somewhat intricate definition, though formally sound, can be misleading to the average software developer. More concisely, software factories boil down to automated software product lines, where automation is achieved through model-driven development. The first part of this outstanding book motivates and introduces software factories. Current software development projects encounter major problems when dealing with complexity and change. With respect to complexity, practitioners could use more powerful abstractions and let tools do more of the job; namely, they could resort to model-driven development. With respect to the change, iterative development, design patterns, and refactoring provide the means to prevent stagnation, brittleness, and fatigue, respectively. In practice, according to the book authors, domain-specific languages will help us raise our abstraction level when programming, while more advanced integrated development environments (IDEs) will deal with artifact synchronization and can facilitate constant change. Apart from the above-mentioned problems (complexity and change), one-off software development is terribly expensive and inefficient. Most software applications have more similarities than differences. These similarities make economies of scope possible. In economies of scope, not to be confused with economies of scale, multiple similar but distinct products are produced collectively. In software development terms, software product lines foster systematic reuse, help reduce overall development costs, and facilitate improvements in software quality. The second part of this book analyzes what the authors consider to be the critical innovations that make software factories possible. Model-driven development (MDD) plays a major role here. In MDD, models are first-class artifacts. They become the source code, actually. Thoughtful readers will find insightful discussions of a wide range of interrelated topics, from metamodels and aspects to model mappings, transformations, and code generation implementation alternatives. Less brilliant chapters discuss software product lines and development by assembly. Domain engineering and application engineering basics pave the way for the description of the activities involved in product line development, and product development in software product lines. Development by assembly, where frameworks provide an organizing architecture for software products, is also analyzed. The final part of the book provides a case study that outlines the product line development process, and a frequently asked questions final chapter. In this original closing chapter, software factories are presented as domain-specific research and development (RAD) environments for product lines. They are compared to model-driven architecture (MDA), agile modeling, computer-aided software engineering (CASE) tools, and fourth-generation languages. Concerning the comparison between software factories and MDA, a separate appendix elaborates the limitations of the unified modeling language (UML) in model-driven development. Briefly, UML works properly for communicating ideas, but fails miserably as a programming language, due to its lack of a well-defined semantics. Hence, MDA, which is based on UML, will need a major revision of the UML standard before it becomes an actual implementation alternative. In this sense, software factories encompass and extend MDA. In software factories, domain-specific languages play the role of the "universal programming language" that UML pretends to be in MDA, without having to wait for a new standard. This book describes what the next paradigm shift in software development might be. Maybe. Even though the software product lines and model-driven development concepts are not new, software factories take them one step further, along with patterns and frameworks. Furthermore, software factories are strongly backed by a major software tools vendor, namely, Microsoft (Microsoft, incidentally, employs all of the authors named on this book). Other vendors will probably follow. Because of this, software development professionals should read the book, in order to stay current and be prepared for the future. A final disclaimer: this book is not for fainthearted developers who are used to how-to handbooks. Some immunity to unclouded "buzzwordism" and casual hype is also desirable, in order to critically ponder what this book has to say from a keen point of view. Online Computing Reviews Service