Tutorial 4: Applying Patterns for Concurrent and Distributed Components
Frank Buschman
Siemens ZT
Overview
Component-based software is a promising technology for increasing
developer productivity and software quality. Unfortunately, many
components do not meet their users' expectations, even when they are
based on popular component middleware, such as EJB, COM+, or the CORBA
Component Model (CCM). The reason is simple: middleware component
models only provide the infrastructure that forms the basic
building blocks for large-scale systems. In particular, the internal
design of components, particularly the aspects related to component
evolution, component configuration, distribution, concurrency, and
scalability, are not addressed by conventional component models.
Handling these issues effectively remains the responsibility of
component developers. In addition to providing the ``right''
functional abstractions and services, the ``correct'' resolution of
these issues is critical for a component's success.
With help of a real-world telecommunication network managament case
study, this tutorial demonstrates how patterns help researchers and
developers design and implement components that adapt readily to
evolution and change, employ distribution and concurrency effectively,
and which scale up gracefully as systems grow in scope and complexity.
The patterns explained and used in this tutorial include Wrapper
Facade, Strategy, Visitor, Interceptor, Abstract Factory, Service
Configurator, Scoped Locking, Strategized Locking, Thread-Safe
Interface, Double-Checked Locking, Active Object,
Publisher-Subscriber, and Half Object plus Protocol, which are
available in the books Pattern-Oriented Software
Architecture, volumes 1 and 2 (John Wiley & Sons), Design
Patterns: Elements of Reusable Software Architecture
(Addison-Wesley) and in the various volumes of the Pattern
Languages of Programming Design series (Addison-Wesley).
We will generalize from the specifics of the case study in the
tutorial to derive guidelines for applying patterns and discuss how
patterns can help in building high-quality software components with
predictable performance properties and qualities. The tutorial
concludes with a summary of our experiences from several distributed
object computing system projects in which we applied patterns, i.e.,
what worked, what could be improved, and how to leverage this
experience in your projects.
Who Should Attend
Researchers and developers with solid knowledge of OO design and
programming, and basic knowledge of patterns and UML notation, who are
interested in seeing how patterns and framework components can be
applied to develop object-oriented and component-oriented
communication software systems.
Speaker Bio
Frank Buschmann is Software Engineer at Siemens Corprate Technology in
Munich, Germany. His research interests include object technology,
software architecture, application frameworks, and patterns. He has
published widely in all these areas, most visibly as a co-author of
Pattern-Oriented Software Architecture: A System of Patterns.
In his development work, Frank has lead the design and implementation
of several large-scale industrial software projects, including
business information, industrial automation, and telecommunication
systems. Frank is currently co-authoring the second volume of
Pattern-Oriented Software Architecture: Patterns for Concurrent
and Distributed Objects, to be published in fall 2000 by Wiley &
Sons.