Component-Based Product Line Engineering with UML [Paperback]

Colin Atkinson (Author), Joachim Bayer (Author), Christian Bunse (Author), Erik Kamsties (Author), Oliver Laitenberger (Author), Roland Laqua (Author), Dirk Muthig (Author), Barbara Peach (Author), Jurgen Wust (Author), Jorg Zettel (Author)

Book Description

ISBN-10: 0201737914 | ISBN-13: 978-0201737912 | Publication Date: November 15, 2001 | Edition: 1st

A cutting-edge, UML-based approach to software development and maintenance that integrates component-based and product-line engineering methods. - ripe market: development of component-based technologies is a major growth area - CBD viewed as a faster, more flexible way of building systems that can easily be adapted to meet rapidly-changing business needs and integrate legacy and new applications (e.g. Forrester report in June 1998 predicted that by 2001 "half of packaged apps vendors will deliver component-based apps"; e.g. Butler Group Management Briefing (2000): "Butler Group is now advising that all new-build and significant modification activity should be based on component architectures...Butler Group belives that Component-Based Development is one of the most important events in the evolution of information technology" e.g. Gartner Group estimates that "by 2003, 70% of new applications will be deployed as a combination of pre-assembled and newly created components integrated to form complex business-systems. The book defines, describes and shows how to use a method for component-based product-line engineering, supported by UML. This method aims to dramatically increase the level of reuse in software development by integrating the strengths of both of these approaches. UML is used to describe components during the analysis, design & implementation stages and capture their characteristics and relationships.This method includes two new kinds of extensions to the UML: new stereotypes to capture KobrA-specific concepts and new metamodel elements to capture variabilities. The method makes components the focus of the entire software development process, not just the implementation and deployment phases. The method has grown out of work by two companies in industry (Softlab & Psipenta) and two research organizations (GMD FIRST & Fraunhofer IESE) called the KobrA project. It is influenced by a number of successful existing methods e.g. Fusion method, Cleanroom method, Catalysis & Rational Unified Process, integrated with new ideas in an innovative way. Benefits for the reader: - gain a clear understanding of the product-line and component-based approaches to software development - learn how to use UML to describe components in analysis, design and implementation of components - learn how to develop and apply component-based frameworks in product-lines - learn how to build new systems from pre-existing components and ensure that components are of a high quality The book also includes: - case studies: library system example running throughout the chapters; ERP/business software system as appendix or separate chapter - bibliography - glossary - appendices covering: UML profiles, concise process description in the form of UML activity diagrams, refinement/translation patterns AUDIENCE Software engineers, architects & project managers. Software engineers working in the area of distributed/enterprise systems who want a method for applying a component-based or product-line engineering approach in practice.

Editorial Reviews

From the Back Cover

Component-based development promises to revolutionize the way in which software is developed and maintained. However, contemporary component technologies, such as COM+/.NET, EJB/J2EE and CORBA, only support components in the final, implementation-oriented stages of development, leaving the earlier stages of analysis and design to be organized in largely traditional, non-component oriented ways.

This book describes the KobrA method, which supports a model-driven, UML-based representation of components, and a product line approach to their development and evolution. This enables the benefits of component-based development to be realized throughout the software life-cycle, and allows the reusability of components to be significantly enhanced.

It will provide you with the techniques you need to:

• Develop a Model-Driven Architecture in which the key features of a system are described independently of specific implementation platforms
• Efficiently and verifiably transform models into code
• Systematically reuse COTS components in new applications
• Improve the quality of components and the systems assembled from them

Features:

• A running example which illustrates the key ideas of the method in an integrated way
• Appendices with the KobrA metamodel and process reference guide.

0201737914B10012001

About the Author

Colin Atkinson is a professor of Software Engineering at the University of Kaiserslautern, Germany and a project manager at the affiliated FraunhoferInstitute for Experimental Software Engineering (IESE).At IESE he leads the KobrA method development team which specialises inLeading-edge software engineering technologies including object-orientedand component-based development, product line engineering and UML-basedmodeling.

0201737914AB10012001

See all Editorial Reviews

Product Details

• Paperback: 464 pages
• Publisher: Addison-Wesley Professional; 1st edition (November 15, 2001)
• Language: English
• ISBN-10: 0201737914
• ISBN-13: 978-0201737912
• Product Dimensions: 9.1 x 7.2 x 1 inches
• Shipping Weight: 2.1 pounds
• Average Customer Review: 4.0 out of 5 stars  See all reviews (2 customer reviews)
• Amazon Best Sellers Rank: #2,398,677 in Books (See Top 100 in Books)

Customer Reviews

Most Helpful Customer Reviews

9 of 9 people found the following review helpful:

5.0 out of 5 stars A primary text on CBSW with unique features, May 29, 2002

By 

Mike Tarrani "www.tarrani.com" (Deltona, FL USA) - See all my reviews
(COMMUNITY FORUM 04)    (REAL NAME)   

This review is from: Component-Based Product Line Engineering with UML (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.

3.0 out of 5 stars Maximizing reuse through components and product lines, April 14, 2006

By 

Fernando Berzal Galiano (Granada, Spain) - See all my reviews
(REAL NAME)   

This review is from: Component-Based Product Line Engineering with UML (Paperback)

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