Register your product to gain access to bonus material or receive a coupon.
Designing Concurrent, Distributed, and Real-Time Applications with UML
- By Hassan Gomaa
- Published Aug 24, 2000 by Addison-Wesley Professional. Part of the Addison-Wesley Object Technology Series series.
Book
- Sorry, this book is no longer in print.
Description
- Copyright 2000
- Edition: 1st
- Book
- ISBN-10: 0-201-65793-7
- ISBN-13: 978-0-201-65793-7
In this book, renowned real-time software expert Hassan Gomaa adapts UML to the unique needs of the concurrent, distributed, and real-time applications -- helping developers leverage the powerful flexibility, reliability, and time-to-market benefits associated with UML. Gomaa starts by reviewing the key issues and concepts associated with analysis and design of distributed and real-time applications -- focusing not only on standard object-oriented concepts such as information hiding, classes, and inheritance, but also specialized issues such as finite state machines, concurrent tasks, and real-time scheduling. Next, he introduces the COMET (Concurrent Object Modeling and Architectural Design) Method, a UML-based object-oriented analysis and design method specifically created for concurrent, distributed, and real-time applications. The book presents detailed structuring criteria that assist the designer at every stage of the analysis and design process, and offers exceptional insight into dynamic modeling, concurrency, distributed application design, and performance analysis of real-time designs. Gomaa concludes with several detailed case studies covering a broad range of applications, including systems for banking, e-Commerce, cruise control, factory automation, and more.
Sample Content
Table of Contents
(Each Chapter concludes with a Summary.).
I. UML NOTATION, DESIGN CONCEPTS, TECHNOLOGY, LIFE CYCLES, AND METHODS.
1. Introduction.Object-Oriented Methods and the Unified Modeling Language.
Method and Notation.
Concurrent Applications.
Real-Time Systems and Applications.
Distributed Systems and Applications.
2. Overview of UML Notation.UML Diagrams.
. Use Case Diagrams.
UML Notation for Classes and Objects.
Class Diagrams.
Interaction Diagrams.
Statechart Diagrams.
Packages.
Concurrent Collaboration Diagrams.
Deployment Diagrams.
UML Extension Mechanisms.
The UML as a Standard.
3. Software Design and Architecture Concepts.Object-Oriented Concepts.
Information Hiding.
Inheritance.
Active and Passive Objects.
Concurrent Processing.
Cooperation between Concurrent Tasks.
Information Hiding Applied to Access Synchronization.
Monitors.
Design Patterns.
Software Architecture and Component-Based Systems.
4. Concurrent and Distributed System Technology.Environments for Concurrent Processing.
Runtime Support for Multiprogramming and Multiprocessing Environments.
Task Scheduling.
Operating System Input/Output Considerations.
Client/Server and Distributed System Technology.
World Wide Web Technology.
Distributed Operating System Services.
Middleware.
Common Object Request Broker Architecture (CORBA).
Other Component Technologies.
Transaction Processing Systems.
5. Software Life Cycles and Methods.Software Life Cycle Approaches.
Design Verification and Validation.
Software Testing.
Evolution of Software Design Methods.
Evolution of Object-Oriented Analysis and Design Methods.
Survey of Concurrent and Real-Time Design Methods.
II. COMET: CONCURRENT OBJECT MODELING AND ARCHITECTURAL DESIGN WITH UML.
6. Overview of COMET.COMET Object-Oriented Software Life Cycle.
Comparison of the COMET Life Cycle with Other Software Processes.
Requirements, Analysis, and Design Models.
The COMET in a Nutshell.
7. Use Case Modeling.Use Cases.
Actors.
Actors, Roles, and Users.
Identifying Use Cases.
Documenting Use Cases in the Use Case Model.
Use Case Relationships.
Use Case Packages.
8. Static Modeling.Associations between Classes.
Composition and Aggregation Hierarchies.
Generalization/Specialization Hierarchy.
Constraints.
Static Modeling and the UML.
Static Modeling of the System Context.
Static Modeling of Entity Classes.
9. Object and Class Structuring.Object Structuring Criteria.
Categorization of Application Classes.
Object Structuring Categories.
External Classes and Interface Classes.
Interface Objects.
Entity Objects.
Control Objects.
Application Logic Objects.
Subsystems.
10. Finite State Machines and Statecharts.Finite State Machines.
Events and States.
Finite State Machines and Objects.
Examples of Statecharts.
Events and Conditions.
Actions.
Modeling Different Aspects of the System.
Hierarchical Statecharts.
Concurrent Statecharts.
Guidelines for Developing Statecharts.
Developing Statecharts from Use Cases.
Example of Developing a Statechart from a Use Case.
11. Dynamic Modeling.Object Interaction Modeling.
Message Labels on Interaction Diagrams.
Dynamic Analysis.
Non-State-Dependent Dynamic Analysis.
Example of Non-State-Dependent Dynamic Analysis.
State-Dependent Dynamic Analysis.
Example of State-Dependent Dynamic Analysis: Banking System.
Example of State-Dependent Dynamic Analysis: Cruise Control System.
12. Software Architecture Design.Software Architectural Styles.
System Decomposition Issues.
Guidelines for Determining Subsystems.
Consolidated Collaboration Diagrams.
Subsystem Software Architecture.
Separation of Concerns in Subsystem Design.
Subsystem Structuring Criteria.
Examples of Subsystem Decomposition.
Static Modeling at the Design Level.
13. Architectural Design of Distributed Applications.Configurable Architectures and Software Components.
Steps in Designing Distributed Applications.
System Decomposition.
Designing Subsystem Interfaces.
Transaction Management.
Design of Server Subsystems.
Distribution of Data.
System Configuration.
14. Task Structuring.Concurrent Task Structuring Issues.
Task Structuring Categories.
I/O Task Structuring Criteria.
Internal Task Structuring Criteria.
Task Priority Criteria.
Task Clustering Criteria.
Design Restructuring by Using Task Inversion.
Developing the Task Architecture.
Task Communication and Synchronization.
Task Behavior Specifications.
15. Class Design.Designing Information Hiding Classes.
Designing Class Operations.
Data Abstraction Classes.
Device Interface Classes.
State-Dependent Classes.
Algorithm Hiding Classes.
User Interface Classes.
Business Logic Classes.
Database Wrapper Classes.
Software Decision Classes.
Inheritance in Design.
Examples of Inheritance.
Class Interface Specifications.
16. Detailed Software Design.Design of Composite Tasks.
Synchronization of Access to Classes.
Designing Connectors for Inter-Task Communication.
Task Event Sequencing Logic.
17. Performance Analysis of Concurrent Real-Time Software Designs.Real-Time Scheduling Theory.
Advanced Real-Time Scheduling Theory.
Performance Analysis Using Event Sequence Analysis.
Performance Analysis Using Real-Time Scheduling Theory and Event Sequence Analysis.
Example of Performance Analysis Using Event Sequence Analysis.
Example of Performance Analysis Using Real-Time Scheduling Theory.
Example of Performance Analysis Using Real-Time Scheduling Theory and Event Sequence Analysis.
Design Restructuring.
Estimation and Measurement of Performance Parameters.
III. CASE STUDIES IN CONCURRENT, DISTRIBUTED, AND REAL-TIME APPLICATION DESIGN.
18. Elevator Control System Case Study.Problem Description.
Use Case Model.
Static Model of the Problem Domain.
Object Structuring.
Dynamic Model.
Statechart Model.
Consolidation of Collaboration Diagrams.
Subsystem Structuring.
Structuring System into Tasks.
Design of Distributed Elevator Control System.
Design of Information Hiding Classes.
Developing Detailed Software Design.
Target System Configuration.
Performance Analysis of Non-Distributed Elevator Control System.
Performance Analysis of Distributed Elevator Control System.
19. Banking System Case Study.Problem Description.
Use Case Model.
Static Modeling.
Object Structuring.
Dynamic Modeling.
ATM Statechart.
Design of Banking System.
Consolidating the Collaboration Model.
Structuring the System into Subsystems.
Design of ATM Client Subsystem.
Design of Bank Server.
20. Cruise Control and Monitoring System Case Study.Problem Description.
Use Case Model.
Use Case Descriptions.
Problem Domain Static.
Dynamic Modeling.
Subsystem Structuring.
Refined Static Modeling.
Structuring the System into Tasks.
Information Hiding Class Design.
Developing Detailed Software Design.
Software Architecture of Distributed Automobile System.
21. Distributed Factory Automation System Case Study.Problem Description.
Use Case Model.
Conceptual Static Model of the Problem Domain.
Object Structuring.
Dynamic Model.
Subsystem Structuring.
Distributed Software Architecture.
System Configuration.
22. Electronic Commerce System Case Study.Electronic Commerce Problem.
Use Case Model.
Agent Support for Electronic Commerce System.
Object Broker Support for Electronic Commerce System.
Static Modeling of the Problem Domain.
Collaboration Model.
Distributed Software Architecture.
Appendix A: Conventions and Alternative Notations.Conventions Used in This Book.
Alternative Notation for Stereotypes.
Alternative Notation for Active Objects.
Glossary.Bibliography.
Index. 0201657937T04062001
Preface
The UML Notation and Software Design Methods
This book describes the object-oriented analysis and design of concurrent applications, in particular distributed and real-time applications. Object-oriented concepts are crucial in software analysis and design because they address fundamental issues of adaptation and evolution. With the proliferation of notations and methods for the object-oriented analysis and design of software systems, the Unified Modeling Language (UML) has emerged to provide a standardized notation for describing object- oriented models. However, for the UML notation to be effectively applied, it needs to be used in conjunction with an object-oriented analysis and design method.
The COMET Concurrent Object Modeling and Architectural Design Method
COMET is a Concurrent Object Modeling and Architectural Design Method for the development of concurrent applications--in particular, distributed and real- time applications. The COMET Object-Oriented Software Life Cycle is a highly iterative software life cycle, based around the use case concept. The Requirements Modeling phase views the system as a black box. A use case model is developed, which defines the functional requirements of the system in terms of actors and use cases.
In the Analysis Modeling phase, static and dynamic models of the system are developed. The static model defines the structural relationships among problem domain classes. Object structuring criteria are used to determine the objects to be considered for the analysis model. A dynamic model is then developed, in which the use cases from the requirements model are refined to show the objects that participate in each use case and their interactions with each other. In the dynamic model, state-dependent objects are defined by using statecharts. In the Design Modeling phase, the software architecture of the system is designed, in which the analysis model is mapped to an operational environment.
The analysis model, with its emphasis on the problem domain, is mapped to the design model, with its emphasis on the solution domain. Subsystem structuring criteria are provided to structure the system into subsystems. For distributed applications, the emphasis is on the division of responsibility between clients and servers, including issues concerning the centralization versus distribution of data and control. In addition, the design of message communication interfaces is considered, including synchronous, asynchronous, brokered, and group communication. Each subsystem is then designed. For the design of concurrent applications, including real-time applications, the emphasis is on object-oriented and concurrent tasking concepts. Task communication and synchronization interfaces are designed. The performance of the real-time design is analyzed by using the Software Engineering Institute's rate monotonic analysis approach.What This Book Provides
Several textbooks on the market describe object-oriented concepts and methods, intended for all kinds of applications. However, distributed and real-time applications have special needs, which are treated only superficially in most of these books. This book provides a comprehensive treatment of the application of fundamental object-oriented concepts to the analysis and design of distributed (including client/server) and real-time applications. In addition to the object-oriented concepts of information hiding, classes, and inheritance, this book also describes the concepts of finite state machines, concurrent tasks, distributed object technology, and real-time scheduling. It then describes in considerable detail the COMET method, which is a UML based object-oriented analysis and design method for concurrent, distributed and real-time applications. To show how COMET is applied in practice, this book also describes several comprehensive case studies, presented by application area: real-time software design, client/server software design, and distributed application design.
The following are distinguishing features of this book:
- Emphasis on structuring criteria to assist the designer at various stages of the analysis and design process: subsystems, objects, and concurrent tasks
- Emphasis on dynamic modeling, in the form of both object interaction modeling and finite state machine modeling, describing in detail how object collaborations and statecharts work together
- Emphasis on concurrency, describing the characteristics of active and passive objects
- Emphasis on distributed application design and the ways in which distributed components can communicate with each other
- Emphasis on performance analysis of real-time designs, using real-time scheduling
- Comprehensive case studies of various applications to illustrate in detail the application of concepts and methods
Organization of Book
The book is divided into three parts. Part I of the book provides a broad overview by describing concepts, technology, life cycles and methods for designing concurrent, distributed, and real-time applications. Chapter 1 starts with a brief description of the difference between a method and a notation, followed by a discussion of the characteristics of real-time and distributed applications. Chapter 2 presents a brief overview of the aspects of the UML notation used by the COMET method. Next, there is a description of the important design concepts (Chapter 3) and necessary technology support (Chapter 4) for concurrent and distributed systems. This is followed in Chapter 5 by a brief survey of software life cycles and design methods.
Part II of the book describes the COMET method (Concurrent Object Modeling and architectural design mEThod). In Chapter 6, there is an overview of the object-oriented software life cycle used by COMET. Chapter 7 describes the requirements modeling phase of COMET, in particular, use case modeling, and Chapters 8 through 11 describe the analysis modeling phases of COMET. Chapters 12-16 describe the design modeling phase of COMET. Chapter 17 describes the performance analysis of real-time designs using real-time scheduling--in particular, rate monotonic analysis.
Finally, in Part III, the COMET method is illustrated through five detailed case studies of concurrent application design: two real-time design case studies, one client/server case study, and two distributed application case studies. The real-time Elevator Control System case study is described in Chapter 18, with both non-distributed and distributed solutions presented. The client/server Banking System case study is described in Chapter 19. The real-time Cruise Control System case study is described in Chapter 20. The distributed Factory Automation case study is described in Chapter 21, and the distributed Electronic Commerce case study is described in Chapter 22.
Ways to Read This Book
This book may be read in various ways. Reading it in the order it is presented, Chapters 1-5 provide introductory concepts and technology, Chapter 6 provides an overview of COMET, Chapters 7-17 provide an in-depth treatment of designing applications with COMET, and Chapters 18-22 provide detailed case studies. Part I is introductory and may be skipped by experienced readers, who will want to proceed directly to the description of COMET in Part II. Readers familiar with the UML may skip Chapter 2. Readers familiar with software design concepts may skip Chapter 3. Readers familiar with concurrent and distributed system technology may skip Chapter 4. Readers familiar with software life cycles and methods may skip the survey in Chapter 5. Readers particularly interested in COMET may proceed directly to Parts II and III. Readers particularly interested in distributed application design should read Chapters 4, 12, and 13, the additional information on concurrent subsystem design in Chapters 14-16, as well as the distributed application case studies in Chapters 18, 19, 21, and 22. Readers particularly interested in real-time design and scheduling should read Chapters 4, 14-17, and the hard real-time design case studies in Chapters 18 and 20.
Experienced designers may also use this book as a reference, referring to various chapters as their projects reach that stage of the analysis or design process. Each chapter is relatively self-contained. For example, at different times, you might refer to Chapter 7 for a concise description of use cases, Chapter 10 when designing statecharts, Chapter 11 for developing the dynamic model, Chapter 13 for distributed component design, Chapter 14 when designing concurrent tasks, or Chapter 17 for real-time scheduling. You can also understand how to use the COMET method by reading the case studies, because each case study explains the decisions made at each step of the design process.
0201657937P04062001