Component-based Product Line Engineering with UML (Component Based Development Series) [Paperback]

Until I read this book my primary text on the topic was "Component Based Software Engineering" by Heineman and Councill. This book now shares the distinction of being a primary source of information and deservedly so.

Where most books on the subject cover the component-based development life cycle at a high level with an emphasis on the development, deployment and QA aspects, this one is about requirements and design. That is what sets it apart and an important work. It becomes even more important if you are using or trying to adapt the Unified Process to a component-based environment. Obviously if your environment also includes product line development the value of this book increases even more.

The book contains five parts which build upon each other. Part 1 is a thorough, 60-page introduction that compares and contrasts development life cycles, summarizes the approach the book proposes, and the concepts, artifacts and process associated with "KobrA" (a German abbreviation for "Component-based application development".

Part 2 is devoted to component modeling based on the KobrA component model, and covers all aspects in 153 pages. This part ends with an excellent introduction to patterns and UML, which lays the groundwork for the next part. The information in this part drills down into requirements and specifications, which is one of the reasons I cited above that sets this book apart.

In Part 3 (Embodiment) refinement and translation, component reuse and incremental development are covered in detail. Part 4 introduces and covers product line, framework and application engineering. It is here that the KobrA foundation laid in the previous parts begins to become coherent and the viability of the approach becomes apparent.

Part 5 is my favorite because, like Part 2, it gives a view of component-based development that most books gloss over. In particular, the chapters on maintenance and QA are filled with information that reflects the realities of component-based development, and the chapter on quality modeling is among the best treatments of the topic in any book or paper I've recently read. The 60 pages of appendices are also valuable sources of information and knowledge about metamodels, maintenance and process. I found this book to be an invaluable reference and recommend it to anyone who is heavily involved in component-based software engineering in conjunction with product line development.

For software companies, the main challenge in application development resides in maximizing reuse as a means to optimize return on investment. Component technology and product line engineering are two promising techniques that intend to facilitate more cost-effective software development.

This book, written by ten authors from the Fraunhofer Institute for Experimental Software Engineering, presents a systematic approach for component-based product line development: the KobrA method [KobrA stands for Komponentenbasierte Anwendungsentwicklung, "component-based application development" in German].

Most current methodologies specify a set of tools and techniques suitable for efficient application development, but they do not provide an algorithmic procedure for materializing the artifacts needed to build enterprise software systems. As Derek Coleman says: "If you want to know how to approach developing component-based architectures in a systematic manner, I cannot think of a better place to start."

The first part of the book motivates the use of components, design patterns, and product line engineering in order to improve the software development process. The proposed methodology has its roots in object-oriented methods (such as OMT, Fusion, and ROOM), component-oriented methods (Catalysis, Select Perspective, and UML Components), and product line-oriented methods (FODA, FAST, and PuLSE, in particular). Method frameworks, such as RUP and OPEN, are also discussed since KobrA can be applied within them. Cleanroom, an older methodology, is at the heart of the KobrA approach (KobrA takes it tree-based structure from the box-structured Cleanroom method).

KobrA claims to be simple, systematic, precise, prescriptive, scalable, incremental, practical, and compatible with as many technologies as possible. In KobrA, components are the logical building blocks of software systems, in contrast to the physical view of component technologies such as CORBA, EJB, and .NET. That is the reason why the authors prefer to use the word Komponent instead of Component.

KobrA follows a top-down design perspective which is organized attending to three orthogonal dimensions: abstraction, genericity, and composition. These dimensions give rise to three kinds of transformations (embodiment, instantiation, and decomposition, respectively), which are treated in detail in subsequent parts of the book, separating artifacts (what) from processes (how).

The first dimension analyzed in this book is the composition dimension, which deals with component modeling. In KobrA, this involves the generation of a containment tree of components, decomposing a software system using a top-down strategy that is complemented by a bottom-up component reuse policy.

The transformation associated to the abstraction dimension, i.e. embodiment, consists of producing concrete executable artifacts from the abstract models generated during component modeling. It should be noted that this embodiment transformation is split into separate refinement and translation steps. The authors propose the use of UML implementation profiles and transformation patterns in order to achieve an efficient and verifiable implementation strategy. Unfortunately, the book is not completely self-contained with respect to this topic and the interested reader will have to look for detailed information elsewhere.

Finally, the genericity dimension and its related instantiation transformation, is at the basis of product line engineering. Two kinds of artifacts are discussed: framework and applications. Framework engineering identifies commonalities and variabilities in product lines through the use of the <<variant>> stereotype in UML diagrams and decision models. Application engineering performs the framework instantiation process using decision resolution models. Framework engineering builds the infrastructure that application engineering customizes.

The evolution of product lines and applications is included in a fourth dimension: the supporting activities common to any software development effort. This is the topic of the last part of the book, which comprises configuration management and quality assurance issues.

Two appendices, which are available on-line, summarize the KobrA methodology and include a comprehensive overview of KobrA concepts and process model. This metamodel could be helpful for those who want to establish a prescriptive and systematic heavy-weight process in their development organizations, taking into account some of the modern software development best practices KobrA is based on.

The KobrA approach described in this book, which is based on the incremental development of component-based product lines, could be suitable for software companies that prefer to follow a methodology "by-the-book", although it may be unduly prescriptive for agile development. It might also be inadequate for projects where contractual requirements cannot be baselined and adaptive project management is a must, since KobrA incremental nature is tied to the component-based structure of the system rather than to its use cases. In any case, KobrA provides a sound component-based software development approach which might find its niche in large projects with well-known requirements (i.e. when the project can be nicely decomposed into components with stable interfaces).