Software reuse is a long-sought goal in software engineering, and software product lines (SPLs) are the pinnacle of software reuse. With SPLs, large-scale software reuse, including the reuse of design and test components, as well as software subsystems, can be achieved. Software reuse at this level offers possibilities for significant gains in development and maintenance costs, time to market, and reliability. This book is a compelling look at how SPLs have been used in the real world to achieve these goals.

The book well serves its intended audience: managers and technical personnel interested in the practical aspects of starting or improving a product line engineering program; both business and technical issues are addressed. Prior knowledge of product line engineering is not assumed; the necessary background is provided.

The book’s 20 chapters are divided into three parts. The six chapters of Part 1 are a fairly complete introduction to SPLs. The first chapter briefly provides the motivation for SPLs, a short history, and a look at the fundamentals of the SPL engineering approach. The business, architecture, process, organization (BAPO) model, used throughout the book, is described. The next four chapters describe each of these four components in detail. The last chapter in Part 1 presents the family evaluation framework (FEF), which is a Capability Maturity Model (CMM) like method for evaluating and describing SPLs along the four dimensions of the BAPO model.

The real meat of the book is the experience studies in Part 2. These case studies cover a range of software producers in terms of organization size and maturity, type of software, and reasons and goals for moving to SPL engineering. The eight companies portrayed include large consumer products (such as Nokia mobile phones and Philips television software), medical systems demanding high reliability and assurance (Siemens Medical Solutions and Philips Medical Systems), platform developers (Nokia systems), and custom applications such as the analysis and display of financial data or fish-farming management systems. There is a good mix in organization size, with two companies having only ten-to-25 software developers, while the rest split roughly into medium size (100-to-250) and large (1,000 or more). Often, the companies had very different goals in adopting product line engineering. Sometimes the goals were limited to one part of product development, such as testing. One case study shows how Nokia mobile phones used the product line engineering approach to specify the security properties of its product architecture. The approaches were generally evolutionary, though in one case the product line was essentially developed from scratch.

Part 3 is made up of three chapters that summarize the case studies and the state of SPL engineering. An analysis of the ten case studies uses the previously introduced FEF framework. This chapter nicely summarizes the trends visible from the case studies. One thing missing that would help organize the results is a table listing the studies, the attributes of the organizations and their products, and the main findings of each study. A side-by-side listing of this kind would allow the reader to easily see both the similarities and the differences brought out by the case studies.

The next-to-last chapter contains advice on starting a product line engineering program. This is extremely valuable information, based on the conclusions drawn from the case studies, and will be invaluable to any organization pursuing product line engineering. The final chapter summarizes the current state of product line engineering, both in practice and in terms of where further work and research is needed. A glossary, index, and over 150 references are included.

Overall, the authors are practical and realistic in their approach and in their assessments. SPL engineering is not presented as a silver bullet, and the authors appropriately point out its weaknesses, problems, and where it does not apply. The text could have been improved with editing for English usage; the phrasing is awkward in places.

For practicing software developers, or managers considering SPL engineering, this book is highly recommended. The case studies provide excellent examples, and the summary chapters will be invaluable in planning or starting a SPL. The book is not a detailed “how to” with step-by-step instructions; it wisely notes that each situation is different. It will, however, show readers what works and why, what you must have and what you don’t need to worry about, and how others have fared. The diversity of companies, approaches, and experiences, along with the extensive references, should also make this a valuable resource for researchers in SPL engineering.