EuroPLoP 1997 (Revised) Papers

Home - Sitemap - About » Community Service - Hillside Group
Computer Science
Research, Industry Work,
Programming
Community Service
Hillside Group, CHOOSE,
Stanford GSA
The Serious Side
Business School,
Learning Chinese
Humorous Takes
Switzerland, United States,
Software, Fun Photos
Travel Stories
Europe, United States, Asia
  
Living Places
Berlin (+ Gallery), Zürich
Boston, S.F. + Bay Area

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.

Copyright (©) 2007 Dirk Riehle. Some rights reserved. (Creative Commons License BY-NC-SA.) Original Web Location: http://www.riehle.org