Tutorial Scope

Developing high quality communication software is hard; developing high quality reusable communication software is even harder. The principles, methods, and skills required to develop reusable software cannot be learned by generalities. Instead, developers must learn through experience how reusable software components and frameworks can be designed, implemented, optimized, validated, maintained, and enhanced by applying good development practices and patterns.

The goal of this tutorial is to provide an active learning context where developers can significantly improve their skills related to building reusable software assets. This course emphasizes hands-on exercises and analysis of case-studies to help developers create effective reusable communication software. The main theme of this course is that deep knowledge of architectures, patterns, components, and frameworks can significantly improve communication software reuse.


Tutorial Description

This course describes component middleware and model-driven development (MDD) techniques that can reduce the complexity of developing distributed systems, including online transaction processing, telecom/datacom data and control planes, process control and automation, aerospace/defense systems, and medical systems, among others. Two types of software complexity are addressed in this course: To address the software complexities described above, the course illustrates by example how to significantly simplify and enhance the development of software that effectively utilizes concurrent and distributed services via the use of component-based techniques, such as patterns, layered modularity, and information hiding; language features, such as abstract classes; inheritance, dynamic binding, and parameterized types; platforms, such as communication frameworks, request brokers, and service-oriented architectures; tools, such as Eclipse Modeling Framework (EMF), Corona, and the Generic Modeling Environment (GME), advanced operating system mechanisms, such as event de-multiplexing, multi-threading, multi-processing, and dynamic linking; and standards for distributed computing, such as the OMG CORBA Component Model (CCM), Java 2 Enterprise Edition (J2EE), Real-time Java, and Real-time CORBA.

Tutorial Objectives

Upon completing this tutorial, attendees will be able to:

  1. Recognize the inherent and accidental complexities involved with developing communication software systems.

  2. Understand precisely how object-oriented techniques and tools can and cannot help to alleviate this complexity.

  3. Apply key object-oriented design techniques (such as patterns, frameworks, and components) to develop reusable comunication software artifacts.

  4. Utilize CORBA, ACE, and C++ features to create efficient, robust, reusable, and extensible communication systems.

  5. Understand advanced OS capabilities and use them effectively to develop extensible, robust, reusable, and efficient concurrent communication systems.

  6. Know where to find additional sources of information on how to successfully apply object-oriented techniques to communication systems.


Who Should Attend

The tutorial is intended for software developers who are designing and implementing communication systems, such as telecommunication systems, multimedia services, network management applications, personal communication systems, client/server management information systems, WWW servers, avionics systems, and upper-layer communication protocols.

Participants should be familiar with the following:

  1. General object-oriented design and programming techniques (such as modularity, information hiding, and design patterns)

  2. Fundamental OO programming language features (such as classes, inheritance, dynamic binding, and parameterized types) found in C++.

  3. Basic systems programming concepts (such as process/thread management, synchronization, and interprocess communication)

  4. Networking terminology (such as client/server architectures and TCP/IP)


Topic Outline

The tutorial is divided into the following four sections:


Tutorial Notes

The following are preliminary versions of the tutorial handouts (the final versions handed out at the course may be different and not all topics may be covered depending on attendee interests):

Pattern-Oriented Software Architecture and Model-Driven Development

Patterns, Frameworks, and Components for Distributed Systems

Component Middleware for Enterprise and DRE Systems

Software Design and Implementation Concepts and Principles


Instructor Profiles