To enroll please contact shortcourses@uclaextension.edu (310) 825-3344
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
Dr. Douglas C. Schmidt
is the Deputy
Director of Research and Chief Technology Officer at the Software Engineering Institute,
which is a federally funded research and development center
headquartered on the campus of Carnegie
Mellon University. He is on research leave from Vanderbilt University, where he
is a Full Professor in the Electrical Engineering and
Computer Science Department, the Associate Chair of Computer
Science and Engineering, and a Senior Researcher at the Institute for Software
Integrated Systems (ISIS). Dr. Schmidt is an internationally
renowned
and widely
cited researcher whose work focuses on
patterns, optimization
techniques, and empirical analyses of
object-oriented and component-based frameworks and model-driven engineering
tools that facilitate the development of distributed real-time and
embedded (DRE) middleware and applications on parallel platforms running over high-speed networks and embedded system
interconnects. He has published 10
books and over 475 papers in top IEEE, ACM, IFIP, and USENIX technical journals, conferences, and books that
cover a range of topics, including high-performance communication
software systems, parallel processing for high-speed networking
protocols, real-time distributed computing with CORBA, Real-time Java, object-oriented patterns
for concurrent and distributed systems, and model-driven engineering
tools.
Dr. Schmidt co-authored several books in the Pattern-Oriented Software Architecture series for
Wiley & Sons edited by Frank Buschmann of Siemens, including Patterns for Concurrent and Networked Objects,
A Pattern Language for Distributed
Computing, and Patterns and Pattern
Languages. He has also co-authored two books for Addison-Wesley
on the topic of C++
Network Programming edited by Bjarne
Stroustrup of AT&T Labs. He was a member of the writing team for
the book Ultra-Large-Scale
Systems: Software Challenge of the Future. In addition, he has
co-editored the first volume of the Pattern
Languages of Program Design series by Addison-Wesley and the Object-Oriented
Application Frameworks: Applications & Experiences series for
Wiley & Sons.
Dr. Schmidt has served as guest editor for feature topic issues on Model-Driven Engineering for IEEE
Computer magazine, middleware technologies for future
communication networks for IEEE
Networks magazine, Distributed Object
Computing for the IEEE Communications
Magazine, Distributed Object
Computing for the USENIX
Computing Systems Journal, and the Communications of the ACM
special issues on Design Patterns and Object-Oriented Frameworks. Dr. Schmidt
has also served as the editor of the C++
Report magazine and the Patterns++ section of C++ Report. Along
with Steve Vinoski
(Chief Architect of IONA
Technologies' Orbix Object Request Broker), Dr. Schmidt co-authors
the Object Interconnections column on
distributed computing middleware for the C/C++ Users Journal.
Dr. Schmidt has served as a Program Manager in the DARPA Information eXplotation Office
(IXO) and Information Technology
Office (ITO), where he led the national effort on
QoS-enabled component middleware research in the Program Composition for
Embedded Systems (PCES) program. In addition, he served as the
co-chair for the Software Design and
Productivity (SDP) Coordinating Group of the Federal government's
multi-agency Information Technology Research and Development (IT R&D)
Program, the collaborative IT research effort of the major Federal
science and technology agencies. The SDP Coordinating Group
formulates the multi-agency research agenda in fundamental software
design. Dr. Schmidt has also served as the Deputy
Director of the DARPA Information Technology Office
(ITO), where he helped to set the national IT research and
development agenda and manage the autonomous systems, network-centric
command and control systems, distributed real-time and embedded
systems, and augmented cognition.
He was formerly an Associate Professor in the Electrical and Computer Engineering
department at the University of
California, Irvine and an Associate Professor and Director of the
Center for Distributed Object Computing
in the Department of
Computer Science and in the Department of Radiology at Washington University in St. Louis, Missouri, USA. He
has also served as the Chief
Technology Officer for PrismTech and the Chief
Technology Officer at Zircon
Computing, where he was responsible for the companies' technical
vision, strategic directions, and growth.
Dr. Schmidt has served as the general co-chair for the DEBS 2009
conference; general chair for the IEEE/ACM 2007 MODELS conference;
program co-chair for the 2006 ACM GPCE conference; program chair for
the ACM OOPSLA 2004 conference; vice chair for the middleware track at
the 2004 IEEE Real-time Systems Symposium; general co-chair for the
2004 IEEE Real-time Technology and Application Symposium; program
co-chair for 2003 IEEE Real-time Technology and Application Symposium;
the program co-chair for the 2003 IFIP/ACM/USENIX Middleware
International Conference on Distributed Systems Platforms; area
vice-chair and session chair for Middleware at the 2003 IEEE
International Conference on Distributed Computing Systems (ICDCS);
Program co-chair for the 2002 International Symposium on Distributed
Objects and Applications; Program Co-chair for the 2001 International
Symposium on Distributed Objects and Applications; Area vice-chair and
session chair for Middleware at the 2001 IEEE International Conference
on Distributed Computing Systems (ICDCS); co-chair of the 2000 OMG
Workshop on Real-time and Embedded CORBA; general chair of the 2000
IFIP/ACM International Middleware Conference; program chair for the
1996 USENIX Conference on Object-Oriented Technologies and Systems
(COOTS); and the 1996 Pattern Languages of Programming conference. He
has presented over 350 keynote addresses, invited talks, and tutorials on reusable patterns, concurrent
object-oriented network programming, and distributed system middleware at dozens of
conferences, including OOPSLA, the USENIX general technical
conference, USENIX COOTS, ECOOP, IEEE Local Computer Networks, ACM
PODC, IEEE ICNP, IEEE GLOBECOM, Object Expo, Component Users
Conference, OOP, and C++ World.
In addition to his academic research, Dr. Schmidt has two decades of
experience developing DRE middleware and model-driven engineering
tools. He has led the development of the ADAPTIVE
Communication Environment (ACE), which is a widely used, freely-available
object-oriented framework that contains a rich set of components that
implement patterns for high-performance DRE systems. Dr. Schmidt and
the members of his research group in the Distributed Object Computing (DOC) Group at
Institute for Software
Intensive Systems (ISIS) at Vanderbilt University have used ACE to
develop a high performance, real-time CORBA ORB endsystem called The ACE ORB (TAO), which is a real-time
ORB endsystem that supports end-to-end quality-of-service
guarantees over high-speed networks. In turn, ACE and TAO form the
basis for the Component-Integrated ACE ORB
(CIAO), which is a real-time CORBA Component Model
(CCM) implementation built by the DOC Group. Most recently, the DOC
Group has developed CoSMIC, which is
a collection of domain-specific
modeling languages and their associated analysis/synthesis tools
that support various phases of DRE system development, analysis,
configuration, and deployment.
ACE, TAO, CIAO, and CoSMIC have been used successfully
by thousands of developers at hundreds of companies world-wide. In
collaboration with his colleagues, Dr. Schmidt has applied these
middleware platforms and tools on large-scale projects at many
companies, including BBN, Boeing, Cisco, Ericsson, Kodak, Lockheed
Martin, Lucent, Motorola, Nokia, Nortel, Raytheon, Qualcomm, SAIC,
Siemens, Sprint, and Telcordia. These projects involve
telecommunications systems, medical imaging systems, real-time avionic
systems, and distributed interactive simulation systems.
Dr. Schmidt received B.S. and M.A. degrees in Sociology from the College of William and Mary in
Williamsburg, Virginia, and an M.S. and a Ph.D. in Computer Science from the University of California, Irvine (UCI)
in 1984, 1986, 1990, and 1994, respectively. His Ph.D. advisor was Tatsuya Suda. Dr. Schmidt is a
member of the IEEE, ACM, and USENIX.
In his ``spare'' time, Dr. Schmidt enjoys Corvettes and
weight lifting.
Back to Douglas C. Schmidt's tutorials WWW page.
Last modified 11:34:29 CDT 28 September 2006