Back to EuroPLoP Writers Workshop page.
Peter L. Weibel
In the context of a highly reactive multi-threaded system it is dangerous and error prone to use physical references to relocatable and deletable objects. The Decoupled Reference Pattern offers not only a logical reference, which is effectively validated and mapped at runtime, but also enables programmers to introduce a controlled way of error handling and exception raising through polymorphism. Operations do not only have short time knowledge of pointers through the Decoupled Reference but also they are invoked on NULL-objects, when the logical reference is not valid anymore.
Antonio Rito Silva, Joao Pereira and Jose Alves Marques
This paper describes the Object Synchronization pattern which decouples object synchronization from object concurrency and object functionality (sequential part). This pattern supports several synchronization policies and their customization. This pattern is used when invocations to a shared object need to be controlled in order to preserve its consistency. The solution described by this pattern provides encapsulation, modularity, extensibility and reuse of synchronization policies.
(Pattern name: Distributed Symmetric IPC - DSIPC) Dr. Ilir Kondo, Omer Karacan
Design pattern distributed symmetric inter process communication (DSIPC) encapsulates the connect-accept asymmetry by the startup stage of an application consisting of Peers. That means, the asymetric pair {connect,accept} reduces to only one (symmetric) connect call. DSIPC provides solutions for runtime broken connection and application partial recovery.DSIPC considers an application with an arbitrary point-to-point configuration of IPC, which may be distributed, as well. There should be no predefined rule for the startup sequence of processes. Connection will be realised with connection-oriented protocols, and no server is to be used. We provide a solution for these problems by introducing the Client-Server Rule (C-S Rule) and the DSIPC design pattern.
Bjoern Eiderbaeck
The development of a distributed applications is well known to be a difficult task. The debugging, modification maintenance of such applications are even harder. Another difficulty is that the interface building techniques not are matured enough yet and even the most spread IBs are likely to be changed and improved. One way to overcome some of the difficulties is to develop one's own distributed interface builder - but if developing such tools not is your premiere issue then this certainly is a to big endeavour and if we also want to get benefits from standardised components this approach is even more insufficient. In this paper we will describe two different patterns. The first pattern is based on a builder pattern and is an essential component of some facilities that utilizes the application building tools of Visual Works by augmenting them with mechanisms to develop distributed applications. The other one is a pattern that could be used to solve problems with dangling references. We will in particular describe how we can use this pattern to solve a problem that is introduced by the first pattern in accordance to restriction we have made to the dynamics of the implementation.
Douglas C. Schmidt
This paper describes the Connector and Acceptor patterns. The intent of these patterns is to decouple the active and passive connection roles, respectively, from the network services performed once connections are established. Common examples of network services that utilize these patterns include remote login, file transfer, World-Wide Web applications, and object request brokers. This paper explains how the use of the Connector and Acceptor patterns help decouple the connection-related processing from the service processing, yielding more reusable, extensible, and efficient communication software. When used in conjunction with related patterns like the Reactor and the Active Object patterns, the Acceptor and Connector patterns enable the creation of highly extensible and efficient communication software frameworks.
Chrystalla C. Alexandrou, George A. Papadopoulos
This paper describes the Multimedia Data Exchange Agent pattern, which itself describes the decoupling of the communication mechanisms from the actual implementation of two multimedia components. The general model of Producer (Source), Filter, Consumer (Sink) that is used for the modeling of temporal media types as components is enhanced by this decoupling. The components must have the ability to connect to each another. This connection could be modeled as a simple relationship between the two components. This solution requires that the implementation of this relationship is the responsibility of either or both of the components and will also be visible by the application. This pattern proposes the separation of the implementation of this relationship into a different class and also proposes customization via a hierarchy that will produce different in usage and characteristics connectors.