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:
- Complexity due to quality of service (QoS) requirements
-- Some system complexities arise because software is required to
perform efficiently, reliability, and consistently. Many of these
systems are "real-time" systems, e.g.,, they do not function
correctly if they incur too much latency.
- Complexity due to changes in functional and quality
requirements -- Some systems complexities are due to the need
to accomodate changing requirements in functionality and software
quality. Change is inevitable since users' requirements change,
component interfaces change, and developers' understanding of their
application domain changes. Well-designed software must evolve to
support these changes, especially in an increasingly competitive
environment.
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:
- Recognize the inherent and
accidental complexities involved with developing
communication software systems.
- Understand precisely how object-oriented techniques and
tools can and cannot help to alleviate this complexity.
- Apply key object-oriented design techniques (such as
patterns, frameworks, and components) to develop reusable
comunication software artifacts.
- Utilize CORBA, ACE, and C++ features to create efficient,
robust, reusable, and extensible communication systems.
- Understand advanced OS capabilities and use
them effectively to develop extensible, robust, reusable, and
efficient concurrent communication systems.
- 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:
- General object-oriented design and programming techniques
(such as modularity, information hiding, and design patterns)
- Fundamental OO programming language features (such as
classes, inheritance, dynamic binding, and parameterized
types) found in C++.
- Basic systems programming concepts (such as process/thread
management, synchronization, and interprocess communication)
- Networking terminology (such as client/server architectures
and TCP/IP)
Topic Outline
The tutorial is divided into the following four sections:
- Part 1: Overview of the Key Software Challenges Facing
Distributed System Developers -- The first part of the
tutorial focuses on object-oriented framework techniques for
addressing inherent and accidental complexities involved in selecting
and implementing appropriate models and mechanisms for handling:
distribution, communication, and cooperation; process/thread
management and synchronization; service naming, partitioning, and
placement; reliability and availability.
- Part 2: An Overview of the CORBA Component Model and
Enterprise Java Beans -- The second part of the tutorial
addresses the CORBA Component Model (CCM) and Enterprise Java Beans
(EJB) and how they extend and enhance conventional Distributed Object
Computing (DOC) models; how component middleware is being applied to
various types of distributed systems; an overview of component
middleware capabilities, such as containers, component servers,
deployment and configuration engines, Interface Definition Languages,
asynchronous method invocations, multi-threading, activation daemons,
load balancing, and fault tolerance.
- Part 3: Patterns and Performance of Middleware for
Distributed Real-time and Embedded Systems -- The third part
of the tutorial presents in-depth coverage of middleware for DRE
systems, including Real-time CORBA and Real-time Java, focusing on how
to apply patterns to create standards-based DRE applications.
- Part 4: Model-Driven Development of Distributed
Systems -- The fourth part of the tutorial presents an
overview of how model-driven development (MDD) techniques and tools
can be used to specify, analyze, optimize, synthesize, validate, and
deploy standards-compliant middleware and applications.
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