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).
