Excerpts

Overview This book describes an evolutionary software engineering process for the development of software product lines, which uses the Unified Modeling Language (UML) notation. A software product line (or product family) consists of a family of software systems that have some common functionality and some variable functionality. The interest in software product lines emerged from the field of software reuse when developers and managers realized that they could obtain much greater reuse benefits by reusing software architectures instead of reusing individual software components. The field of software product lines is increasingly recognized in industry and government as being of great strategic importance for software development. Studies indicate that if three or more systems with a degree of common functionality are to be developed, then developing a product line is significantly more cost-effective than developing each system from scratch. The traditional mode of software development is to develop single systems--that is, to develop each system individually. For software product lines, the development approach is broadened to consider a family of software systems. This approach involves analyzing what features (functional requirements) of the software family are common, what features are optional, and what features are alternatives. After the feature analysis, the goal is to design a software architecture for the product line, which has common components (required by all members of the family), optional components (required by only some members of the family), and variant components (different versions of which are required by different members of the family). Instead of starting from square one, the developer derives applications by adapting and tailoring the product line architecture. To model and design families of systems, the analysis and design concepts for single product systems need to be extended to support software product lines. This book is intended to appeal to readers who are familiar with modeling and designing single systems but who wish to extend their knowledge to modeling and designing software product lines. It is also intended to appeal to readers who are familiar with applying UML to the modeling and design of single systems but not with developing software product lines. What This Book Provides Several textbooks on the market describe object-oriented concepts and methods, which are intended for single systems. Very few books address software families or product lines; and of those that do, even fewer use UML. This book provides a comprehensive treatment of the application of UML-based object-oriented concepts to the analysis and design of software product lines. In particular, it does the following: Describes fundamental concepts and technologies in the design of software product lines. Describes, in considerable detail, a UML-based object-oriented analysis and design method for software product lines. It examines how each of the UML modeling views--use case modeling, static modeling, dynamic state machine modeling, and dynamic interaction modeling--is extended to address software product lines. Each UML modeling view is extended to reflect the commonality and variability of the product line. A new view, the feature modeling view, is added to explicitly model the commonality and variability of software requirements. Uses the Object Management Group (OMG) concept of model-driven architecture to develop a component-based software architecture for a product line. The product line architecture is expressed as a UML platform-independent model, which can then be mapped to a platform-specific model. Describes how architectures for software product lines are developed through the consideration of software architectural patterns in relation to the characteristics of the product line. The product line architecture is component-based and explicitly models the commonality and variability of the product line. Presents three case studies illustrating how a software product line architecture is developed, starting with use cases and feature modeling in the requirements modeling phase, static and dynamic modeling in the analysis modeling phase, and the development of the component-based software architecture in the design modeling phase. The case studies focus on a microwave oven product line, an electronic commerce product line, and a factory automation product line. Includes a glossary, a bibliography, and two appendices, which provide (1) an overview of UML 2 notation and (2) a catalog of software architectural patterns for product lines. The PLUS Advantage The UML-based software design method for software product lines described in this book is called PLUS ( P roduct L ine U ML-Based S oftware Engineering). The PLUS method extends the UML-based modeling methods that are used for single systems to address software product lines. With PLUS, the objective is to explicitly model the commonality and variability in a software product line. PLUS provides a set of concepts and techniques to extend UML-based design methods and processes for single systems to handle software product lines. In particular, for modeling software product lines, PLUS provides the following additions to the process of modeling single systems: Software Product Line Requirements Modeling Use case modeling. Model commonality and variability in the use case model. For this purpose, PLUS provides an approach to modeling kernel, optional, and alternative use cases, as well as an approach to modeling variation points in use cases. Feature modeling. Model product line features. Feature modeling is a key concept in software product lines. PLUS provides an approach for modeling common, optional, and alternative features, an approach for deriving the feature model from the use case model, and an approach for representing features with the UML notation. Software Product Line Analysis Modeling Static modeling. Develop a product line context model for the product line boundary. Determine kernel, optional, and alternative external classes. Develop a product line information (entity class) model: determine kernel, optional, and alternative entity classes. Dynamic interaction modeling. Develop interaction diagrams to realize kernel, optional, and alternative use cases. Use evolutionary development: the kernel first approach is applied to determine product line commonality, followed by product line evolution to determine variability. Dynamic state machine modeling. Develop kernel, optional, and alternative statecharts. Manage state machine variability through inheritance and parameterization. Feature/class dependency modeling. Determine how the common, optional, and alternative features of the product lines depend on the kernel, optional, and variant classes. Software Product Line Design Modeling Software architectural patterns. Determine the software architectural structure and communication patterns that are most appropriate for the product line given the catalog of architectural patterns. Component-based software design. Develop a component-based software design for the product line, which models kernel, optional, and variant components, as well as their ports and provided and required interfaces. Design the component-based architecture that explicitly models the components and their interconnections. Software Application Engineering Develop a software application that is a member of the product line by using the feature model to derive the application from the product line architecture and components. Intended Audience This book is intended for both professional and academic audiences. The professional audience includes analysts, software architects, software designers, programmers, project leaders, technical managers, program managers, and quality assurance specialists who are involved in the design and development of large-scale software product lines in industry and government. The academic audience includes senior undergraduate- and graduate-level students in computer science and software engineering, as well as researchers in the field. Ways to Read This Book This book may be read in various ways. It can be read in the order it is presented, in which case Chapters 1 and 2 provide introductory concepts, Chapter 3 provides an overview of product line engineering and the PLUS process, Chapters 4 through 12 provide an in-depth treatment of designing software product lines with PLUS, and Chapters 13, 14, and 15 provide detailed case studies. Alternatively, some readers may wish to skip some chapters depending on their level of familiarity with the topics discussed. Chapters 1 and 2 are introductory and may be skipped by experienced readers. Readers familiar with software design concepts may skip Chapter 2. Readers particularly interested in product line development can proceed directly to the description of PLUS, starting in Chapter 3. Readers who are not familiar with UML, or who are interested in finding out about the changes introduced by UML 2.0, can read the appropriate sections in Appendix A in conjunction with reading Chapters 4 through 12. Experienced product line designers may also use this book as a reference, referring to various chapters as their projects reach a particular stage of the requirements, analysis, or design process. Each chapter is relatively self-contained. For example, at different times you might refer to Chapter 4 for a description of use cases, Chapter 5 for developing the feature model, Chapter 7 for dynamic interaction modeling, Chapter 8 when designing statecharts (skip for non-state dependent product lines), Chapter 10 and Appendix B when referring to software architectural patterns, Chapter 11 for distributed component-based software design, and Chapter 12 for application engineering. You can also increase your understanding of how to use the PLUS method by reading the case studies, because each case study explains the decisions made at each step of the requirements, analysis, and design modeling processes. Annotated Table of Contents Chapter 1: Introduction This chapter presents an introduction to software product lines, a discussion of software reuse issues, and an overview of object-oriented analysis and design with UML. Chapter 2: Design Concepts for Software Product Lines This chapter discusses and presents an overview of key design concepts and technologies for software product lines, including object-oriented technology, software architecture, and the software component technology. Chapter 3: Software Product Line Engineering This chapter introduces the software product line design method, which is described in much greater detail in subsequent chapters. One of the goals of this method is to be capable of extending other design methods, such as the author's COMET method ( C oncurrent O bject M odeling and Architectural Design M et hod) to model and design software product lines. The acronym for the method is PLUS (Product Line UML-Based Software Engineering). However, the term PLUS is also intended to mean that other methods can be extended to support product lines such as COMET, ROPES, or RUP/USDP. There are two main strategies for developing a software product line, referred to as forward evolutionary engineering and reverse evolutionary engineering . Forward evolutionary engineering is best used when a new product line is being developed with no previous systems to guide the development. Reverse evolutionary engineering is best used when the product line development begins with existing systems that are candidates for modernization and inclusion in a project to develop a product line. Chapter 4: Use Case Modeling for Software Product Lines This chapter describes how use case modeling concepts are extended to address software product lines--in particular, how the common and variable functionality of the product line is modeled with kernel, optional, and alternative use cases, and how variation points are used to model variability. Chapter 5: Feature Modeling for Software Product Lines This chapter describes feature modeling--a concept used widely in software product lines but not addressed by UML. The discussion covers how feature modeling concepts can be incorporated into the UML and how features can be determined from use cases. Chapter 6: Static Modeling in Software Product Lines This chapter describes how static modeling concepts are extended to address software product lines--in particular, to address modeling the boundary of the software product line and modeling entity classes, which are informationintensive classes. Also discussed is the categorization of application classes from two perspectives: the role the class plays in the application and the reuse characteristic of the class. Chapter 7: Dynamic Interaction Modeling for Software Product Lines This chapter describes how dynamic interaction modeling concepts are extended to address software product lines. Communication diagrams are developed for each kernel, optional, and alternative use case. Dynamic interaction modeling to address use case variation points is also covered. The kernel first approach is used for dynamic modeling, followed by the product line evolution approach. Chapter 8: Finite State Machines and Statecharts for Software Product Lines This chapter describes how finite state machine and statechart modeling concepts are extended to address software product lines. In particular, each state-dependent control class--whether kernel, optional, or variant--needs to be modeled with a finite state machine and depicted as a statechart. It is also possible to model variability using inherited state machines and parameterized state machines. Chapter 9: Feature/Class Dependency Modeling for Software Product Lines This chapter describes how to determine which classes from the analysis model are needed to support the features from the feature model. Product line classes are categorized as kernel, optional, and variant classes. Modeling class variability using both inheritance and parameterization is described. Feature-based dynamic modeling and static modeling are also covered. Chapter 10: Architectural Patterns for Software Product Lines This chapter describes a range of software architectural patterns that are particularly useful in the design of software product line architectures. Both architectural structure and communication patterns are described. Architectural structure patterns address the overall structure of the software architecture. Architectural communication patterns address the ways in which distributed components can communicate with each other. This chapter also describes how product line architectures can be built from these patterns. Chapter 11: Software Product Line Architectural Design: Component-Based Design This chapter describes how a product line architecture is designed as a component-based architecture. Separation of concerns in component design is an important issue. Components are categorized according to their roles in the software architecture. The design of component interfaces is described. The chapter also discusses how component-based software architectures can be depicted with the structured class and composite structure diagram notation introduced in UML 2, which allows components, ports, connectors, and provided and required interfaces to be depicted. Chapter 12: Software Application Engineering This chapter describes the process for deriving a member of the software product line from the product line architecture and components. This is a tailoring process involving selection of the appropriate components and setting of the parameter values for individual components to include in the product line member. The chapter covers how the feature model is used to help in this process. Chapter 13: Microwave Oven Software Product Line Case Study This chapter describes how the PLUS software product line method is applied to the design of a microwave oven software product line. Because this is a new product line, the forward evolutionary engineering product line development strategy is used, in which an iterative approach is used to determine the kernel functionality of the product line before the variable functionality is modeled. Chapter 14: Electronic Commerce Software Product Line Case Study This chapter describes how the PLUS software product line method is applied to the design of an e-commerce application product line. Because there are two main systems--business-to-business (B2B) and business-to-consumer (B2C)--in the electronic commerce product line, the reverse evolutionary engineering product line development strategy is applied first to each type of system, from which the product line commonality is determined first, followed by the product line variability. Chapter 15: Factory Automation Software Product Line Case Study This chapter describes how the PLUS software product line method is applied to the design of a factory automation product line. Because this product line starts with existing factory automation systems that are candidates for modernization and inclusion in the product line, the reverse evolutionary engineering product line development strategy is applied. Appendix A: Overview of the UML Notation This appendix provides an overview of the different UML 2.0 diagrams used by the PLUS method. The differences between the UML 2.0 notation and UML 1.x notation are also explained, as are the conventions used in this book. Appendix B: Catalog of Software Architectural Patterns In this appendix the software architectural structure and communication patterns, originally described in Chapter 10, are documented alphabetically in a common template for easy reference. Contact For questions or comments, please contact me at hgomaa@gmu.edu . Hassan Gomaa George Mason University, June 2004 http://mason.gmu.edu/~hgomaa/index.htm Excerpted from Designing Software Product Lines with UML: From Use Cases to Pattern-Based Software Architectures by Hassan Gomaa All rights reserved by the original copyright owners. Excerpts are provided for display purposes only and may not be reproduced, reprinted or distributed without the written permission of the publisher.