|
This web page abstracts the papers presented and reviewed at EuroPLoP '97 and provides links to them.
Please observe that all papers on this page are copyrighted
by their respective (first) author. Papers are provided as pdf
files. The conference proceedings appeared as a Siemens technical
report. Articles from the report can be cited like this:
Francisco Assis Rosa and Antonio Rito Silva. "Component
Configurer: A Design Pattern for Component-Based Configuration."
In Proceedings of the 2nd European Conference on Pattern Languages
of Programming (EuroPLoP '97). Siemens Technical Report 120/SW1/FB.
Munich, Germany: Siemens, 1997.
You need Acrobat Reader 3.0 or higher to view the pdf files.
In case of questions, don't hesitate to contact me.
Dirk Riehle (program chair).
General Design Patterns
Distribution Patterns
More Interesting Patterns
Component Configurer: A Design Pattern for Component-Based Configuration
Francisco Assis Rosa and Antonio Rito Silva (ffjar,arsg@albertina.inesc.pt)
This paper presents a design pattern for component-based configuration.
The pattern focuses on allowing the configuration of components
along with its inter-component connections. It allows component
creation, destruction and migration without a ecting other components.
The pattern promotes a decoupling between components and components
connection, aiming at supporting ad-hoc dynamic reconfiguration
and the migration of components with state transferring.
Available as pdf.
Requested Interface
Ullrich Köthe (koethe@egd.igd.fhg.de)
This paper introduces the Requested Interface pattern which
describes ways to implement truly independent software components
that can be plugged together as needed in order to make reuse
more attractive than reimplementation. It encourages components
to delegate subtasks to collaborating servers so that they can
be adapted to a new context by simply exchanging those subtask
servers. The delegating objects must specify minimal and abstract
requested interfaces that describe the subtasks independ-ently
of existing server interfaces. An adaptation layer mediates between
the requested interface of a client and the offered interface
of a server implementing the subtask.
Available as pdf.
Error Detection
Klaus Renzel (Klaus.Renzel@sdm.de)
Before we can handle an error or failure we have to detect
it. Error Detection shows how to install error detectors within
your software: it enriches the code with a number of run-time
checks. Those checks are a prerequisite for handling software
faults successfully and to avoid system crashes.
Available as pdf.
Undertaker
Björn Eiderbäck and Jiarong Li (bjorne, li@nada.kth.se)
In this paper we will describe the pattern Undertaker aimed
at handling dangling references to objects which not are recognized
as garbage by the environments ordinary reclamation facilities.
The context of the work is an environment which comprises a garbage
collector, as Smalltalk or Java, but we believe that this pattern
more generally could be applicable to environments without such
services, as C++.
Available as pdf.
Architecture Pattern Language
Gerard Meszaros
This pattern language is a first crack at capturing the key
concepts and processes of defining an architecture for a computer
system. It captures the experiences of the author based on well
over ten years of building complex systems in a variety of domains
including fault-tolerant systems, telecommunications, real-time
databases and distributed object client/server computing.
Not available as postscript or gzipped pdf.
Network: A Pattern for Composing Computation
Henning Andersen (HEA@oticon.oticon.dk400.dk)
In Oticons software product for fitting hearing aids OtiSet
there's a need to simulate the digital hearing aids performance
under different conditions (traffic noise, loud speech etc.).
Simulating the hearing aids implies simulation of discrete components
organized in a network through which the representation of sound
i.e. the signal propagates. Each component performs a computation
on the signal e.g. filtering (of frequencies), Volume Control
(amplification) etc. It's desirable if the software were capable
of reusing the components.
Available as pdf.
Compiler Construction
Christine Schwanninger (swng@keba.co.at)
Every computer scientist learns several techniques for building
syntax-directed compilation during his or her studies. Few of
them ever build a whole compiler. But there are many problems
besides building compilers that can be solved using the techniques
of formal language analysis. Some practical examples for the applicability
of lexical and syntactical analyzers are user input checking,
tools for code and text analysis, readers for file exchange formats
or ASCII object file formats. The analysis techniques are well
known, but applying them isn't easy for the occasional compiler
constructor. The following patterns are a modest start for a compiler
building pattern language and can only be considered as basis
for a comprehensive language on compiler construction. This paper
is directed at people who have already learned about compiler
construction and formal languages, but don't have much experience
in this field. The reader should know about the structure of a
compiler and what are attributed grammars, otherwise I recommend
reading [Aho, Sethi, Ullman] or [Fischer, LeBlanc]. This is no
course in compiler construction or formal languages.
Available as pdf.
Abstract Session
Nat Pryce (np2@doc.ic.ac.uk)
Object-oriented frameworks are structured in terms of client/server
relationships between objects; an object's services are invoked
by client objects through the operations of its interface. A common
design requirement is for a server object to maintain state for
each client that it is serving. Typically this is implemented
by returning handles or untyped pointers to the client that are
used to identify the per-client data structure holding its state.
The lack of strong typing can lead to obscure errors that complicate
debugging and maintenance. This paper presents the Abstract
Session pattern which allows objects to maintain per-client
state with full type safety and no loss of efficiency.
Available as pdf (after conference
revision).
Half-Object Assembly--A Pattern System for Distributed Domain Objects in Business Applications
Fridtjof Toenniessen (toenniessen@sdm.de)
Distributed systems are a widely discussed topic in today's
software engineering practice. They complement or sometimes even
replace traditional approaches that employ central mainframe architectures.
Very often the distributed architectures go hand in hand with
object oriented modeling and these models have been augmented
by design patterns in recent years. Half-Object Assembly is a
system of special purpose patterns for distributed business information
systems. It helps to form the communication layer between the
clients and servers assuming the client/server cut is made through
the application kernel to maximize flexibility in application
design:
- Presentation Layer - GUI Elements
- Dialog Control - Use Case Controllers
- Database Access Layer
The patterns consider high transaction rates combined with
low bandwidth networks by transmitting only those parts of business
objects that are of interest and by offering flexible transaction
and caching mechanisms.
Available as pdf (after conference
revision).
Synchronizer--An Object Behavioral Pattern for Concurrent Programming
Ennio Grasso (ennio.grasso@cselt.it)
This paper describes the Synchronizer pattern, a specialization
of the Active Object pattern described in [SCHM96a]. The intent
of the Active Object pattern is the decoupling of method execution
form method invocation to simplify synchronized access to shared
objects by different threads. By assigning one thread to a shared
object, the Active Object does not provide the maximum amount
of concurrency that could be achieved. The Synchronizer specializes
the Active Object by allowing many concurrent threads to access
a shared object.
Available as pdf.
Passive Replicator: A Design Pattern for Object Replication
Teresa Goncalves and Antonio Rito Silva (ftsg,arsg@albertina.inesc.pt)
This paper describes a pattern for passive object replication
in distributed systems. The pattern provides support for the representation
of replicated objects, the management of replicated objects and
the implementation of several replication policies. It decouples
replication from functionality and distribution. It supports different
replica consistency criteria.
Available as pdf.
A Pattern Language For Improving the Capacity of Layered Client/Server Systems with Multi-Threaded Servers
Dorina Petriu and Gurudas Somadder (petriu,gurudas@sce.carleton.ca)
The paper describes a set of patterns that extend the pattern
language proposed in [Meszaros96] for improving the capacity of
reactive systems. The intent of these patterns is to identify
some specific causes that limit the efficiency of a distributed
layered client-server system with multi-threaded servers, and
to find appropriate corrective measures. The type of systems considered
here is a subclass of the larger category of reactive systems,
and the new patterns are dealing with their specific performance
characteristics. The effects of the patterns are illustrated with
performance measurements conducted on a layered client-server
system.
Available as pdf.
Architectural Styles for Distribution--Using Macro-Patterns for System Design
Charles Weir
This paper highlights the problem of describing the software
architecture of a distributed system, and introduces the Architectural
Styles proposed by Shaw&Garlan as a possible solution. Using
a pattern template, it explores four major styles for distribution
architecture: Host-Terminal, Client-Server, Broadcast Data and
Batch Communication.
Available as pdf.
Patterns for Layered Object-Oriented Applications
Mauricio J. Vianna e Silva, Sergio Carvalho, and John Kapson
(mauricio@lmf-di.puc-rio.br, sergio@inf.puc-rio.br, kapson@netcom.com)
Three-layered architectures (presentation, business and persistence
levels) are sometimes recommended when developing object-oriented
applications. Using the increasingly popular fourth generation
languages, however, layering is difficult: business rules are
usually embedded in use interfaces, which may also directly access
databases. In this paper, we present three patterns useful in
the construction of object oriented applications accessing relational
databases via fourth generation languages.
Available as pdf.
A Pattern Language for Writers' Workshops
James O. Coplien (cope@bell-labs.com)
Peer review is a crucial element of the quality improvement
process for any document and more broadly for any intellectual
work. Most intellectual disciplines rely on a peer review culture
for the advancement of knowledge, and those disciplines often
focus more on content than on expression. Design reviews and code
walk-throughs focus on what might be broken, not on what works.
Most refereed journals scrutinize works first against standards
of formalism and second, if at all, for readability. The pattern
community is less interested in the advancement of knowledge than
in the broad dissemination of sound practice, and is equally concerned
with content and expression. Writers' workshops, which come from
the creative literature community, provide an alternative to prevailing
peer review practice that is well-suited to the needs of the pattern
community. Writers' workshops follow a collection of normative
behaviors designed to give authors constructive feedback on their
work while protecting their dignity. The following patterns document
those normative behaviors and the structures that support them.
Available as pdf.
Tower Patterns for Web Hyperdocument Framework Design
R. V. Snytsar (roy@rrg.msk.su), V. B. Filatov (vf@rrg.msk.su)
Development of an advanced Web-based information system of
demands introduction of several new document types. To introduce
a new document type, system designer need to develop a couple
of applications responsible for different aspects of document
manipulation, namely, storage, authoring, retrieval, and browsing,
and therefore do a lot of programming. The objective of this paper
is to provide recipes for reduction of programming efforts in
hypermedia system design.
Available as pdf.
Form-Based User Interface--The Architectural Patterns
Jens Coldewey (jensc@sdm.de) and Ingolf Krüger (kruegeri@informatik.tu-muenchen.de)
Despite all the benefits of object-oriented user interfaces,
there are still domains that call for a form-based user interface.
Business information systems that support fast processing of few,
well-defined use cases are typical examples. This pattern language
helps to develop the software architecture for such systems.
Available as pdf.
Mapping Objects to Tables--A Pattern Language
Wolfgang Keller (100655.566@compuserve.com)
Mapping Objects to Tables is a problem that has occurred as
long as people want to program in an object oriented language
but have to use relational instead of object oriented databases
for some reasons. Mapping Objects to Tables is only one family
of problems that occurs in object/relational access layers. The
whole context of object/relational access layers has been described
by many authors (see [Bro+96, Col+96]) and is subject of our own
future work.
Available as pdf.
GOF Patterns for GUI Design
James Noble (kjx@mri.mq.edu.au)
The Design Patterns book introduced twenty-three patterns for
object oriented software design. These patterns are used widely,
but only in their intended domain of software design. We describe
how six of these patterns can be used for the conceptual design
of graphical user interfaces. By using these patterns, designers
can produce interfaces which are more consistent, make good use
of screen space, and are easier to use.
Available as pdf.
Basic Relationship Patterns
James Noble (kjx@mri.mq.edu.au)
Relationships between objects are almost as important to designs
as objects themselves. Most programming languages do not support
relationships well, so programmers must implement relationships
in terms of more primitive constructs. This paper presents five
basic patterns which describe how objects can be used to model
relationships within programs. By using these patterns, programs
and designs can be made smaller, more exible, and easier to understand
and maintain.
Available as pdf.
Patterns of Project Management Risk Reduction
Alistair Cockburn (arc@acm.org)
Risk reduction would be the favorite pattern among project
managers, if only we could figure out how to describe it. I put
forward a format for capturing risk reduction patterns with six
less obvious patterns and a table indexing situations into documented
patterns.
Available as pdf.
|