Designing Software Product Lines with UML From Use Cases to Pattern-Based Software Architectures

by Gomaa, Hassan

• ISBN13: 9780201775952
• ISBN10: 0201775956
• Edition: 1st
• Format: Paperback
• Copyright: 2004-07-07
• Publisher: Addison-Wesley Professional

Summary

Take software design and efficiency to the next level by leveraging the promise of software product lines and the practicality of the UML.

Author Biography

Hassan Gomaa, Professor of Software Engineering at George Mason University in Fairfax, Virginia, is an internationally acknowledged authority on the software design of distributed and real-time systems. Hassan's career in software engineering spans both industry and academia, and he develops concurrent, distributed, and real-time applications in industry; designs software development methods and applies them to real-world problems; and teaches short courses to professional software engineers around the world. He has a B.Sc. in electrical engineering from University College, London, and a Ph.D. in computer science from Imperial College, London.

Table of Contents

Foreword	xv
Preface	xvii
Acknowledgments	xxvii
Part I Overview	1	(62)
1 Introduction	3	(16)
1.1 Software Reuse	4	(1)
1.2 Software Product Lines	5	(2)
1.3 Modeling Requirements Variability in Software Product Lines: Feature Modeling	7	(1)
1.4 Modeling Design Variability in Software Product Lines	8	(2)
1.5 Reusable Design Patterns	10	(1)
1.6 Modeling Single Systems with UML	11	(1)
1.7 COMET: A UML-Based Software Design Method for Single Systems	12	(2)
1.8 Modeling Software Product Lines with UML	14	(1)
1.9 UML as a Standard	14	(2)
1.10 Related Texts	16	(1)
1.11 Summary	17	(2)
2 Design Concepts for Software Product Lines	19	(24)
2.1 Object-Oriented Concepts	19	(3)
2.2 Information Hiding	22	(4)
2.3 Relationships between Classes	26	(5)
2.4 Dynamic Modeling	31	(1)
2.5 Sequential and Concurrent Applications	32	(2)
2.6 Software Architecture and Components	34	(7)
2.7 Summary	41	(2)
3 Software Product Line Engineering	43	(20)
3.1 Evolutionary Software Product Line Engineering Process	44	(1)
3.2 Software Product Line Engineering Phases	45	(4)
3.3 Forward and Reverse Evolutionary Engineering	49	(2)
3.4 Integration of PLUS with the Spiral Model	51	(2)
3.5 Integration of PLUS with Unified Software Development Process	53	(4)
3.6 Requirements, Analysis, and Design Modeling in Software Product Lines	57	(3)
3.7 Software Product Line Scoping	60	(1)
3.8 Summary	61	(2)
Part II Requirements, Analysis, and Design Modeling for Software Product Lines	63	(282)
4 Use Case Modeling for Software Product Lines	65	(30)
4.1 The Use Case Model in Single Systems	66	(3)
4.2 The Use Case Model for Software Product Lines	69	(2)
4.3 Identifying Use Cases	71	(1)
4.4 Documenting Product Line Use Cases	72	(1)
4.5 Example of a Use Case Description	73	(1)
4.6 Modeling Variability in Use Cases	74	(1)
4.7 Modeling Small Variations	75	(2)
4.8 Modeling Variability with the Extend Relationship	77	(7)
4.9 Modeling Variability with the Include Relationship	84	(5)
4.10 Use Case Development Strategies	89	(3)
4.11 Summary	92	(3)
5 Feature Modeling for Software Product Lines	95	(24)
5.1 Introduction to Feature Analysis	96	(1)
5.2 Commonality/Variability Feature Analysis	97	(4)
5.3 Features and Use Cases	101	(6)
5.4 Feature Modeling with UML	107	(3)
5.5 Feature Groups	110	(5)
5.6 Advanced Feature Modeling with UML	115	(3)
5.7 Summary	118	(1)
6 Static Modeling in Software Product Lines	119	(22)
6.1 Modeling Commonality and Variability in Product Lines	120	(1)
6.2 Static Modeling of the Software Product Line Problem Domain	121	(1)
6.3 Static Modeling of the Software Product Line Scope	122	(8)
6.4 Static Modeling of Entity Classes	130	(6)
6.5 Modeling Application Classes and Objects	136	(4)
6.6 Summary	140	(1)
7 Dynamic Interaction Modeling for Software Product Lines	141	(28)
7.1 Dynamic Modeling in Single Systems	142	(5)
7.2 Evolutionary Dynamic Modeling in Software Product Lines	147	(1)
7.3 Kernel First Approach	148	(3)
7.4 Software Product Line Evolution Approach	151	(4)
7.5 Message Sequence Numbering on Interaction Diagrams	155	(3)
7.6 Example of Evolutionary Dynamic Analysis for the Microwave Oven Product Line	158	(10)
7.7 Summary	168	(1)
8 Finite State Machines and Statecharts for Software Product Lines	169	(36)
8.1 Finite State Machines for Kernel and Single Systems	170	(6)
8.2 Hierarchical Statecharts	176	(4)
8.3 Finite State Machines and Statecharts for Software Product Lines	180	(1)
8.4 Inherited State Machines in Software Product Lines	181	(7)
8.5 Parameterized State Machines in Software Product Lines	188	(4)
8.6 Comparison of Approaches	192	(1)
8.7 Kernel First Approach: State-Dependent Dynamic Analysis	193	(4)
8.8 Software Product Line Evolution Approach	197	(2)
8.9 Dynamic Analysis with Communicating State-Dependent Objects	199	(5)
8.10 Summary	204	(1)
9 Feature/Class Dependency Modeling for Software Product Lines	205	(300)
9.1 Classes and Variation Points	206	(7)
9.2 Class Reuse Categorization for Software Product Lines	213	(4)
9.3 Feature/Class Dependencies	217	(2)
9.4 Feature-Based Impact Analysis	219	(4)
9.5 Feature/Object and Feature/Class Dependency Modeling in UML	223	(7)
9.6 Summary	230	(1)
10 Architectural Patterns for Software Product Lines	231	(48)
10.1 Categorization of Software Patterns	232	(1)
10.2 Software Architectural Structure Patterns	232	(21)
10.3 Software Architectural Communication Patterns	253	(16)
10.4 Software Architectural Transaction Patterns	269	(6)
10.5 Documenting Software Architectural Patterns	275	(1)
10.6 Applying Software Architectural Patterns	275	(3)
10.7 Summary	278	(1)
11 Software Product Line Architectural Design: Component-Based Design	279	(40)
11.1 Software Architecture Issues	280	(1)
11.2 Configurable Architectures and Software Components	281	(1)
11.3 Steps in Designing Distributed Applications	281	(1)
11.4 Design of Software Architecture	282	(3)
11.5 Design of Component-Based Software Architecture	285	(5)
11.6 Separation of Concerns in Component Design	290	(3)
11.7 Aggregate and Composite Subsystems	293	(1)
11.8 Component Structuring Criteria	294	(6)
11.9 Design of Server Components	300	(5)
11.10 Distribution of Data	305	(1)
11.11 Design of Component Interfaces	306	(5)
11.12 Design of Components	311	(5)
11.13 Summary	316	(3)
12 Software Application Engineering	319	(26)
12.1 Phases in Software Application Engineering	320	(3)
12.2 Software Application Engineering with the USDP	323	(2)
12.3 Application Deployment	325	(3)
12.4 Tradeoffs in Software Application Engineering	328	(1)
12.5 Example of Software Application Engineering	329	(15)
12.6 Summary	344	(1)
Part III Case Studies	345	(268)
13 Microwave Oven Software Product Line Case Study	347	(94)
13.1 Problem Description	348	(1)
13.2 Use Case Modeling	348	(9)
13.3 Feature Modeling	357	(5)
13.4 Static Modeling	362	(5)
13.5 Dynamic Modeling	367	(13)
13.6 Software Product Line Evolution	380	(28)
13.7 Feature/Class Dependency Analysis	408	(10)
13.8 Design Modeling	418	(21)
13.9 Software Application Engineering	439	(2)
14 Electronic Commerce Software Product Line Case Study	441	(64)
14.1 Problem Description	442	(1)
14.2 Use Case Modeling	443	(4)
14.3 Feature Modeling	447	(4)
14.4 Static Modeling	451	(11)
14.5 Dynamic Modeling	462	(5)
14.6 Software Product Line Evolution	467	(10)
14.7 Feature/Class Dependency Analysis	477	(3)
14.8 Design Modeling	480	(23)
14.9 Software Application Engineering	503	(2)
15 Factory Automation Software Product Line Case Study	505	(108)
15.1 Problem Description	506	(4)
15.2 Use Case Modeling	510	(6)
15.3 Feature Modeling	516	(9)
15.4 Static Modeling	525	(10)
15.5 Dynamic Modeling	535	(6)
15.6 Software Product Line Evolution	541	(31)
15.7 Feature/Class Dependency Analysis	572	(15)
15.8 Design Modeling	587	(23)
15.9 Software Application Engineering	610	(3)
Appendix A Overview of the UML Notation	613	(18)
A.1 UML Diagrams	614	(1)
A.2 Use Case Diagrams	614	(1)
A.3 Classes and Objects	615	(1)
A.4 Class Diagrams	616	(2)
A.5 Interaction Diagrams	618	(2)
A.6 Statechart Diagrams	620	(2)
A.7 Packages	622	(1)
A.8 Concurrent Communication Diagrams	622	(3)
A.9 Deployment Diagrams	625	(1)
A.10 UML Extension Mechanisms	626	(2)
A.11 Conventions Used in This Book	628	(2)
A.12 Summary	630	(1)
Appendix B Catalog of Software Architectural Patterns	631	(24)
B.1 Software Architectural Structure Patterns	631	(9)
B.2 Software Architectural Communication Patterns	640	(11)
B.3 Software Architectural Transaction Patterns	651	(4)
Glossary	655	(20)
Bibliography	675	(12)
Index	687

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 systemsthat 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 viewsuse case modeling, static modeling, dynamic state machine modeling, and dynamic interaction modelingis 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 archit