CS 562: Course Synopsis

Course Synopsis

CS 562 provides an intensive focus on advanced design and implementation of distributed object computing (DOC) software. Key topics covered in this course include:

Reuse of design patterns and software architectures
Developing communication applications using OO languages (C++), OO frameworks (ACE), and CORBA (TAO).

Design and implementation based on design patterns and frameworks are central themes to enable the construction of reusable, extensible, efficient, and maintainable DOC software. In addition, abstraction based on design patterns and OO techniques (such as separation of interface from implementation) will be the central concepts and principles throughout the course. These concepts and principles will enable you to construct reusable, extensible, efficient, and maintainable communication software.

Design patterns will be taught so that you will have good role models for structuring their own designs, as well as to clearly articulate the tradeoffs of alternative methods for designing systems. OO techniques will be taught so that you will learn by example how to build highly decentralized communication software architectures that decouple inter-dependencies between components.

We will construct communication software components and applications using popular programming tools available in the modern operating systems, such as make, emacs, dbx, gprof, CVS, C++, CORBA, ACE, and TAO. You are expected to be familiar with C++ and UNIX.

Course Contents

The following is a more detailed overview of the course contents. Lecture material for each section are available as online handouts.

Background material
- Overview of software design concepts and principles
  - Decomposition
  - Abstraction
  - Information Hiding
  - Modularity
  - Virtual machines
  - Hierarchies and relationships
  - Policies and mechanisms
  - Commonality/variability analysis
  - Program families and product lines
  - Patterns
  - Frameworks
  - Components
  - Software architectures
- Overview of key language features
  - e.g., classes, dynamic allocation, inheritance, dynamic binding, and templates
- Overview of key concurrency and networking principles, concepts, and tools
Patterns
- Overview and motivation
- Tactical patterns
  1. Bridge
  2. Iterator
  3. Adaptor
  4. Strategy
  5. Template Method
  6. Factory Method
  7. State
  8. Singleton
  9. Facade
- Strategic patterns for communication systems
  1. Reactor
  2. Reactor
  3. Proactor
  4. Acceptor and Connector
  5. Active Object
  6. Half-Sync/Half-Async
  7. Service Configurator
  8. Double-checked Locking Optimization
  9. Publisher/Subscriber
  10. Broker
  11. Layered Architecture
  12. Pipes and Filters Architecture
Introduction to Frameworks and Components
- Overview
- Comparison of frameworks, components, class libraries, and subroutine libraries
- Implementing and documenting frameworks and components with patterns
- Framework usage rules
- Developing frameworks and components for communication systems
Introduction to Communication Middleware and Communication Service Architectures
- Distributable components
- Interface Definition Languages
- Object References
- Object Request Brokers (ORBs)
- Object Adapters
- Objects and Servants
- Interoperability Protocols
- Communication Service architectures
- Metrics for measuring performance and predictibility
Case Studies Developing Applications using Reuseable Patterns, Frameworks, and Middleware
The following case studies will be used in class to illustrate the OO design and programming process:
- Distributed Logging Service
- Telecommunication Gateway
- Web Server
- Real-time ORB

Back to CS562 home page.