UML 2001 Conference,
Distributed, and Real-Time Applications
Instructor: Dr. Hassan Gomaa
Department of Information and Software Engineering
George Mason University
Fairfax, Virginia 22030-4444
Phone: (703) 993-1652
Fax: (703) 993-1638
Tutorial Length: Half Day
Level of Tutorial: Intermediate / Experienced
This tutorial is intended for software designers and programmers who wish to understand how to design concurrent, distributed and real-time applications using a UML-based software design method.
The intended audience is professionals responsible for designing, implementing, or managing the design of concurrent applications, in particular, client/server, distributed, and real-time applications.
This tutorial will be presentation based.
Copy of instructor's viewgraphs.
This tutorial describes the object-oriented analysis and design of concurrent applications, in particular real-time, client/server, and distributed 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.
Most books and courses on object-oriented analysis and design only address the design of sequential systems or omit the important design issues that need to be addressed when designing real-time and distributed applications. It is essential to blend object-oriented concepts with concurrency concepts to successfully design these applications. As the UML is now the standardized notation for describing object-oriented models, this tutorial uses the UML notation throughout. This tutorial is based on the instructor’s new book entitled “Designing Concurrent, Distributed, and Real-Time Applications with UML”, published by Addison Wesley in August 2000. Information on the book is provided at:
COMET is a Concurrent Object Modeling Method for the development of concurrent applications, in particular real-time and distributed applications. The COMET Object-Oriented Software Life Cycle is a highly iterative software life cycle, which is based around the use case concept. The Requirements Modeling phase view 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 created. Object structuring criteria are used to determine the problem domain objects to be considered for the Analysis Model. The static model defines the structural relationships among problem domain classes. The dynamic model refines the use cases to show the objects that participate in each use case and the sequence of interactions between these objects. State dependent objects are defined using statecharts.
In the Design Modeling phase, an Architectural Design Model is developed, 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 vs. distribution of data and control and the design of message communication interfaces, including synchronous, asynchronous, brokered, and group communication. Each subsystem is then designed. For the design of concurrent systems, in particular real-time systems, the emphasis is on object-oriented and concurrent tasking concepts. Task communication and synchronization interfaces are described. The performance analysis of real-time designs based on the SEI's rate monotonic analysis approach is also addressed. The concepts will be illustrated by means of examples.
Introduction to Software Design. Software design concepts: object-oriented concepts, information hiding, classes, inheritance. Concurrent tasking concepts. Overview of UML notation.
Object-Oriented Software Life Cycle; Object-Oriented Requirements Modeling; Object-Oriented Analysis Modeling, Object-Oriented Design Modeling. Incremental software construction and integration.
Requirements modeling. The use case modeling. Use cases, actors, use case relationships. Use case descriptions. Special considerations for real-time and distributed applications.
Analysis modeling. Static modeling. Objects, classes, and relationships. Static modeling of problem domain.
Object and class structuring. Object structuring; class categorization using stereotypes.
Finite state machines. State transition diagrams. Hierarchical statecharts. Developing statecharts from state dependent use cases.
Dynamic modeling. Object interaction, message sequencing. Dynamic analysis – from the use case model to the object interaction model.
Design modeling for real-time and distributed applications:
Subsystem Architecture Design. Developing the overall software architecture from the analysis model. Separation of concerns in subsystem design. Subsystem structuring.
Design of Distributed Applications. Distributed subsystem structuring criteria. Defining subsystem interfaces - synchronous, asynchronous, brokered, and group communication. Client/server applications. Subsystem design. Distributed system configuration.
Concurrent Task Structuring. Task
structuring criteria. Mapping the
analysis model to a task architecture. Task Interfaces - message
communication, event synchronization, information hiding classes. Task behavior specifications.
Information hiding class design. Refining the static model. Designing class operations. Use of inheritance in software design. Class interface specifications.
Detailed concurrent design. Integrating tasks and information hiding object. Access synchronization. Design of connector classes.
Performance Analysis of Real-Time Designs. Real-time scheduling; rate monotonic analysis, scheduling of periodic and aperiodic tasks, priority ceiling protocol; event sequence analysis; application to real world problems.
Examples will be selected from the following case studies: Client/Server Banking example, Distributed Elevator Control System example, Cruise Control System, Distributed Factory Automation example, Electronic Commerce Example.
Hassan Gomaa presented a half-day tutorial at UML 2000, York, entitled “Designing Concurrent, Distributed, and Real-Time Applications with UML”. As with this tutorial, the UML 2000 tutorial was based on my book, “Designing Concurrent, Distributed, and Real-Time Applications with UML”, published by Addison Wesley in August 2000.
Hassan Gomaa has considerable experience in teaching courses and tutorials on software design methods. He has taught industrial courses and tutorials based on his latest book, “Designing Concurrent, Distributed, and Real-Time Applications with UML”, published by Addison Wesley in August 2000. The tutorials were at the International Conference on Software Engineering, Limerick, Ireland, in June 2000, the Workshop on Software Performance, Ottawa, Canada, in September 2000, and the UML Conference, York, England, in October 2000. He also taught a one-day ACM professional development seminar based on his book in Washington, December 2000. He has also taught multi-day versions of a course based on his book to Hitachi (July 2000) and NASA (March 2001).
Previously, he presented a tutorial on "Software Design Methods for Concurrent and Real-Time Systems" at the European Software Engineering Conference, Garmisch, in September 1993, and at the SEI Software Engineering Education Conference, San Antonio, in January 1994. He presented a Professional Development Seminar on the same topic for the Washington chapter of the ACM in November 1993 and April 1995. He has also presented a tutorial on "An Ada-based Software Design Method for Concurrent and Real-Time Systems" at the Washington Ada Symposium, in June 1993 and at Tri-Ada 93 in Seattle, September 1993. In March 94, he presented a Professional Development Seminar on "Software Design for Distributed Applications" for the Washington chapter of ACM. In July 1994, he was an invited speaker at CASE Japan 94 on the topic of "Object-Oriented Design Methods for Concurrent and Real-Time Systems". In November 94, he presented a tutorial on "Software Design Methods for Reusable Concurrent and Real-Time Systems" at the Third International Conference on Software Reuse and a tutorial on "A Software Design Method for Ada-based Concurrent, Real-Time, and Distributed Applications" at Tri-Ada 94. In 1995, he presented a tutorial on "Software Design Methods for Concurrent and Real-Time Systems" at the International Conference on Software Engineering, Seattle, in April 95 and at the IEEE International Conference on the Engineering of Complex Computer Systems in November 95. He also presented a tutorial on "Object-Oriented Analysis and Design for Concurrent and Real-Time Systems" at OOPSLA 95 in October 95. In 1996, he presented a tutorial on "Software Design Methods for Concurrent and Real-Time Systems" at the International Conference on Software Engineering, Berlin, in March 1996, an ACM Professional Development seminar on “Client/Server Systems: Technology and Application Development”, in April 1996, and a tutorial on “Software Design of Client/Server and Distributed Applications” at the IEEE International Conference on the Engineering of Complex Computer Systems, in October 1996. In 1998, he presented an ACM Professional Development seminar on “Object-Oriented Analysis and Design for Client/Server and Distributed Applications”.
He has taught several in-depth industrial courses on software design in North America, Europe, and Japan, at the Software Productivity Consortium (for SPC’s member companies including Boeing, Rockwell, Lockheed, Grumman, Harris, Loral), Mitre Corporation, NASA, LCC, Pragmatics, Nokia, Philips Research Labs, and Hitachi Institute of Technology. He has prepared a three hour introductory videotaped course on ADARTS. He has also co-presented a two day video course for the National Technical University on "Software Design Methods and CASE Tools for Concurrent, Real-Time and Distributed Systems". He has also prepared several videotaped lectures on software design for the Software Engineering Institute, Carnegie Mellon University.
Hassan Gomaa is a Professor in the Department of Information and Software Engineering at George Mason University, Fairfax, Virginia and Associate Director of the Center for Information Systems Integration and Evolution. He has over 25 years experience in software engineering, in both industry and academia, and has published over 100 technical papers and two textbooks.
He received his B.Sc. (Eng.) in Electrical Engineering with First Class Honors from University College, London University, and his D.I.C (equivalent to a Masters Degree) and Ph.D. in Computer Science from Imperial College of Science and Technology, London University.
His book, "Software Design Methods for Concurrent and Real-Time Systems", is published by Addison Wesley as part of the Software Engineering Institute Series on Software Engineering, and had its fourth printing in 1999. His new book entitled “Designing Concurrent, Distributed, and Real-Time Applications with UML”, was also published by Addison Wesley in August 2000 and will have its second printing in July 2001.
He is the developer of the DARTS, ADARTS, CODARTS, and COMET software design methods for concurrent, real-time, and distributed applications. He has taught several short courses for industry and academia, in person and televised, on Software Design Methods for Concurrent, Real-Time and Distributed Systems, Object-Oriented Analysis and Design, and Client/Server Systems. He also consults in both the technical and management aspects of software engineering.
His research has been funded by DARPA, NASA, NSF, Hughes Applied Information Systems, Siemens, Software Productivity Consortium, Virginia Center of Innovative Technology, Virginia Center of Excellence in Software Reuse, CTA, and Grumman.
His current research interests include software engineering methods and tools, object-oriented analysis and design for concurrent, real-time, and distributed applications, client/server systems, domain analysis and design, software architecture, software product lines, software agents, and software performance.
Previously, he held faculty positions at the Wang Institute of Graduate Studies, where he was Professor of Information Technology, and at Imperial College of Science and Technology, London University, where he was a lecturer in the Department of Computing. He also has several years industrial experience, most recently at General Electric, where he was responsible for defining software requirements, software architectures, prototypes, and software testing environments for distributed computer integrated manufacturing and robot controller systems.