If you have a paper at the conference, you'll find that your paper has been assigned to one of these four writers' workshops. Please take the time to read the other papers assigned to that workshop before the conference (one or two days before the conference is best), so that we can have a lively discussion of all papers at the conference.
If you don't have a paper of your own, reading papers in advance still is a good idea.
Everybody should read Alan O'Callaghan's paper Three Patterns from the ADAPTOR Pattern Language. It will be discussed in the demo writers' workshop in the welcome session.
You can download individual papers, or all papers assigned to one workshop. The paper formats are PDF, PostScript, or MS Word.
Workshop A:
Architecture & Design
| Author | Title / Abstract |
| Alan O'Callaghan | Three Patterns from the ADAPTOR Pattern
Language
This paper details fourteen patterns that form the beginning of a pattern language for course development in Computer Science. The patterns are intended for educators designing and running individual courses (not curricula). The patterns are not all at the same level of scale, with some speaking to the overall course design and others to the daily actions of the instructor and students. It is not claimed that these yet form a pattern language, but the goal is to develop them into a more coherent whole. The patterns have been submitted to the Pedagogical Patterns Project. This paper presents three further patterns from the ADAPTOR pattern language in addition to those workshopped at EuroPlop '99 and EuroPlop 2000. ADAPTOR stands for Architecture-Driven And Patterns-based Techniques for Object Re-engineering. Two of the papers are role patterns: Mercenary Archaeologist can be considered a specialisation of Coplien's Mercenary Analyst applied to legacy system migrations; similarly, in that context, an application of his Gatekeeper and Firewall patterns leads to the ADAPTOR pattern, Technology Reception Committee. The final pattern, Modello, is one of the set of "problem-setting" patterns that are the most developed part of ADAPTOR. This pattern mandates that the architectural visualisation be separated from any diagrams that can in any way be considered blueprints of the system being developed.. |
| Klaus Marquardt | Dependency Structures Patterns: Symptoms,
Aetiology, and Therapies
Large software systems have an internal dependency structure that tells about their architecture, flexibility and extensibility. Recurring structure elements and patterns exhibit some of these properties, allowing judgement about the systems qualities and offering measures to improve the system architecture. |
| Pavel Hruby | Create a Development Method On-the-Fly
Have you ever tried to apply a standard development method, and realized that you do not always perform all the activities in the specified order? Did you sometimes you wanted to specify something interesting about the system, but the method did not suggest any suitable work product, diagram or document, for your specific information? Instead of specifying a firm development method, it might help to describe a process framework and customize it to fit each specific development problem. This paper describes how to create and use such development process framework. The Rational Unified Process and Extreme Programming are used as illustrative examples of the process framework. |
| Ademar Aguiar
Alexandre Sousa Alexandre Pinto ademar.aguiar@fe.up.pt
|
Use Case Controller
The Use case Controller pattern deals with the problem of quickly and efficiently mapping use cases specifications to code. The pattern delegates to a use case controller the responsibility of controlling the execution flow of a use case, thus localizing this knowledge and possible changes on a single object. A use case controller provides a uniform way of coordinating actor events, user interfaces and system services. Additionally, a use case controller enlarges the variability of use cases, either by plug-in of use case extensions and inclusions, or by replacement of user interface components and system components. |
| Macario Polo Usaola
Mario Piattini Velthuis Francisco Ruiz González |
Reflective CRUD (RCRUD: Reflective Create,
Read, Update & Delete)
The paper presents a method to generate persistent methods in runtime, using the API Reflection defined in the Java language. All persistent methods are generated in runtime by a class named "Yet". Domain classes must only inherit from Yet to have complete persistent functionality. Through the use of Yet we have the advantages of the combined use of a "Template method" class/pattern (but with the implementation of all the methods in the superclass, which is in interesting additional benefit) and of the "Pure fabrication" pattern (because all responsibilities related to persistence all delegated to another class that, in this case, is the superclass). Designs obtained with Yet have a very high degree of cohesion (because no methods related to persistence are implemented in domain classes) and a very low degree of coupling with the database (only Yet knows it). Moreover, Yet allows other facilities, as the very easy connection with classes in the Presentation layer, also very cohesioned and low coupled. After presenting Yet and some samples of its code, the paper explains some industrial experiences of its use, as well as its relation with the Presentation layer. |
| Frank Buschmann | A Pattern Language for Distributed Object
Computing
This paper presents the first version of some of the patterns from the book "Pattern-Oriented Software Architecture -- Patterns for Concurrent and Networked Objects" in Alexandrian form, connected to a pattern language. This language is intended to highlight the tight integration of these patterns, a picture that likely gets lost when reading the full-fledged developer-centric pattern descriptions from the original source. The language is not intended to replace these patterns' existing descriptions, but to complement them with an additional perspective. |
| Kristian Elof Sørensen | Sessions
This is a small pattern language or a subset of a pattern language. Sessions: How to tie calls to a system to the user who initiated them using a stateless protocol. Session specific namespaces: How to create pseudo namespaces for each user in a multi user system. Big tree: A large group of non-technical users has to author, edit and maintain a large body of text and image data. How can we make it possible for them to navigate the vast amount of ever changing data in a way they are comfortable with when they are new users of the system, a way they can work effectively with when they get more experienced and without requiring them to take a training course on the system. |
| Kristian Elof Sørensen | Window to the World
This pattern describes a way to test your systems interaction with other systems when you have no or inadequate control over the other systems. |
Workshop
B: Distribution & Components
| Author | Title / Abstract |
| Markus Völter | Server-Side Components: A Pattern Language
Enterprise-level component-based development is an important topic in today's software industry. Several technologies for components on the server exist, among them EJB, CCM and COM+. Although these technologies have significant differences, they are all built on the same core concepts. This paper captures these concepts in the form of a pattern language in Alexandrian style. The patterns are useful for people who have to understand the concepts behind these technologies in order to develop better applications, to develop their own component architectures, or to evaluate the three competing architectures on the market today. |
| Oliver Vogel | Service Abstraction Layer
Building extensible and scalable systems is a challenging task. Nowadays, different clients communicating over different channels, like HTTP or WAP, must be offered with the same set of business services. Only by providing services, which can be accessed from anywhere, clients get the added value they demand from state-of-the-art software systems. This, in return, leads to a close customer relationship and therefore to an increased customer satisfication. The number of channels which have to be supported and the number of demanded services increases over time. This has to be considered during the development of such a system as the architecture must support new channels and services seamlessly. Thus, every architect is faced with the question: "How do you develop a system which can fulfill requests from different clients communicating over different channels without having to modify your business logic each time a new channel has to be supported or a new service is added?" Service Abstraction Layer gives an answer. |
| Koen Hendrikx | Component Architectures for Evolvable
XML Applications
This paper contains part of a pattern language for XML processing applications. It first contrasts XML with more traditional approaches to language processing. Second, the main processing paradigms for XML are briefly discussed, with a number of example applications. Several forces that influence how XML is processed or generated are identified and discussed. Then three design patterns are presented that each resolve these forces in different ways. The main objective of the patterns is to realise component-based architectures: systems in which all dimensions of variability can be realised by adding or substituting components. |
| Michael Kircher
Prashant Jain Michael.Kircher@mchp.siemens.de
|
Ad Hoc Networking Pattern Language
Ad hoc networking is based on the principle of spontaneous addition, discovery, and usage of services in a network. Various technologies such as JiniTM [Sun01], UPnP [Micr01], and .NET are built around the concept of ad hoc networking. While each technology is either platform or language dependent, they share a common underlying architecture which can be expressed using a pattern language. The pattern language abstracts away from any specific language, platform, or domain. We present this pattern language here with primary focus on resource management patterns. |
| Michael Kircher | Lazy Acquisition
The Lazy Acquisition pattern applies to systems that need to be highly scalable and robust while managing a restricted set of resources. The pattern solves the problem of resource shortage by defering resource acquisitions to the latest possible point in time during system run-time in order to optimize resource usage. It is an abstraction of many existing patterns, that follow the same principle. |
| Ali Arsanjani | A Pattern Language for Component-based
Development and Integration
Component-based development and integration is a promising new paradigm of building application systems through assembly. Because of their high level of composability from prefabricated parts, these application systems tend to be more resilient to change and reuse [Jacobson et al 97] ; adaptable enough to be reusable and composable in new contexts. The scope this paper will be more on guiding the project manager, architect, business sponsor and analyst in understanding the issues and challenges that they will face attempting to web-enable their already functioning back-end legacy systems. Although the general pattern language includes the steps, paths and the trade-offs that have been effective in executing component-based development and integration projects in both “green field” (new development) efforts and those in which legacy systems are salvaged and refactored. |
| Thomas Neumann | Business Component System
The Business Component System Pattern is used to structure a given system from the commercial environment into reusable pieces of software that are build using component technology. An emphasis is put on a loosely coupled design, that enables the different parts of the system to evolve on their own. |
Workshop C:
Programming & Design
| Author | Title / Abstract |
| Kevlin Henney | C++ Patterns: Reference Accounting
Object-oriented systems represent their information and express their behavior through networks of objects. Some objects, such as value-based objects, are strictly owned, managed, and contained within functions or other objects. Other kinds of objects are more loosely associated, and do not necessarily participate in simple, hierarchical relationships with their dependents. The indirection often leads to sharing, which raises questions of constraint management. What if there is an upper limit to the number of dependents an object should have? How can the end of a shared object's life be constrained to coincide with the end of its last dependent? In C++, the issues are normally couched in terms of memory management, and the solution in terms of reference counting - normally a given author's preferred reference-counting scheme. In truth, there is both more to reference counting than memory management, more to memory management than reference counting, and more to the implementation of any reference accounting scheme than personal preference. Different contexts give rise to different forces, and different implementations have different consequences. A fuller understanding of the problem solved and solution proffered is needed to determine the most appropriate design. The patterns in this paper document idiomatic practices for managing indirection-based objects in C++, by counting or otherwise tracking the references made to them. They are connected into a language. |
| Arno Haase | Java Idioms: Code Blocks and Control Flow
It is sometimes desirable to treat a piece of code as an object in order to parameterize an operation, thus abstracting and encapsulating control flow and making it reusable. This paper introduces two Java idioms that use anonymous local inheritance to implement this behavior. |
| Joseph Bergin | Coding at the Lowest Level: Coding Patterns
for Java Beginners
This is a long elementary pattern langauge intended for programming novices in languages like Java. Many of the individual patterns have appeared before and are by other authors, especially Kent Beck. The attempt here, however, is to provide in one place advice about how to approach programming if you haven't done it before. Some of the patterns are Java specific, but most are not. |
| Alexander Horoshilov | Patterns for Polymorphic Operations:
Three Small Object Structural Patterns for Dealing with Polymorphism
Polymorphism is one of main parts of object paradigm. It is considered to be a requirement of any true object-oriented programming language. Polymorphism means possibility of derived classes to change functionality while satisfying some protocol (also called interface) defined in base class. In "common" programming languages like C++ or Java polymorphism is implemented via virtual methods (in Java all methods are initially virtual). Derived class defines member with the same signature to change behavior. The article describes the usage of polymorphism to address to different needs. While most part of discussion is related to C++, the patterns with some modifications can be applied to wide range of OO-languages. |
| Yun Mai
Michel de Champlain |
Reflective Visitor Pattern
The Visitor pattern wraps associated operations performed on the elements of an object structure into a separate object. It allows the software designers to define new kinds of operations over the object structure without changing the classes of this structure. But a well-known drawback of this standard Visitor structure is that extending the object structure is hard. This paper presents a flexible Visitor pattern implementation based on reflection technique, named Reflective Visitor pattern. The reflection technique enables the Visitor performing the run-time dispatch action itself. So the extention of the object structure becomes easy and the cyclic dependencies between the Visitor and the object structure are removed. As a result, the reusability and extensibility of the system are improved. |
| Uwe Zdun
Michael Goedicke Gustaf Neumann |
Message Redirector
Many object-oriented applications require explicit control over the message flow to support e.g. flexible wrapping, interceptions, modifications of messages, traces, etc. In object systems this control can also be used to express architectural semantics across several objects or classes. But most programming languages do not support such techniques as native language constructs. Therefore, build an explicit Message Redirector instance to control the method calls to (and within) the affected subsystems. Callbacks can be invoked during redirection to modify or extend dispatch-related semantics. |
| Saluka R. Kodituwakku | APLRAC: A Pattern Language for Designing
and Implementing Role-Based Access Control
The Object-Oriented paradigm approaches the software development by representing real world entities into classes of software objects. Interactions between classes can be captured by patterns. A pattern language is a collection of patterns composed to solve a complex design problem. This paper presents a collection of object-oriented design patterns structured to form a pattern language for Role Based Access Control (RBAC). A hypothetic banking application is used to describe how these patterns support the design and implementation of RBAC models. |
Workshop
D: Design & User Interfaces
| Author | Title / Abstract |
| Dietmar Schütz | De-Centralized Locking
The De-Centralized Locking design pattern provides fast acquisition and release of locks without network communication even in distributed systems build around a central lock server. Instead of plain locks, the server manages "permits to lock", and passes them to those clients which probably need the lock next. If a client hosts a permit, the associated lock can be acquired immediately without server interaction. |
| Juha Pärssinen | Patterns Language for Protocol Systems
When dealing with the specification, design, or implementation of a communication protocol, common parts can be found. These parts can be specified as design patterns which are independent from particular protocol specification, its implementation details, or used implementation language. It is the goal of this paper to present these parts, which are extracted from protocol specifications, designs, existing implementations, and data communication literature. These patterns provide common principles for understanding protocols and their parts, or implementing new ones. This paper can be read as a baðsic presentation of protocol design and implementation structure, but also advanced readers can get benefit from it. In this paper four design patterns for a protocol system architecture are presented. These patterns are tightly related to each other. They are part of a pattern language for protocol implementation which the authors have developed during last years. The Protocol Patterns presented in this paper include the Protocol System pattern which models a protocol system in general level, the Protocol Entity pattern which models active parts of a system, the Protocol Behavior pattern which models communication between parts of a protocol system, the Protocol Message pattern. A basic model of communication protocol implementation and two implementation frameworks are presented in this paper to give background information. The Unified Modeling Language (UML) is used in the class diagrams of this paper, and the UML pattern notation is used to describe roles of an individual pattern. |
| Sherif Yacoub | A Versatile Filter Pattern
The design of many software systems often involves the manipulation and processing of digital media or digital content. For instance, the ability to deliver e-services through internet-based delivery channels requires that printed material such as books or articles be converted into forms suitable for electronic distribution and fulfillment. This type of processing often includes -among others- preprocessing of the digital media, transformation from one format to another, extraction of meta-data information about the digital media, segmentation of content, and in many cases verification and validation of the resulting data. These types of systems among others could be thought of as the integration, composition, and cascade of processing modules or units. We call these processing modules filters. Each filter manipulates input data and delivers output data to other filters after executing certain data processing functionality. This type of applications is usually useful in systems that manipulate large volume of digital media such as images or streams of data. The architecture of such systems could be implemented using the Pipes and Filters architecture pattern [Buschmann+96], which provides a design of the system as a cascade of sequential processing steps implemented as filters connected by pipes. In this article, we discuss a Versatile Filter design pattern that integrates the benefits of four well-known design patterns: Strategy pattern [Gamma+95], Pipes and Filters [Bushmann+96], Cascade pattern [Mark98], and Composite pattern [Gamma+95]. This integration provides a robust versatile design solution for applications that requires different type of data filtering. |
| Pascal Costanza
Arno Haase |
The Comparand Pattern
The Comparand Pattern provides a means to interpret different objects as being identical for certain contexts. It does so by determining an attribute in each class of interest - the comparand - and using it for comparison. Identification of different objects is needed when more than one reference refers to the (conceptually) same object. In distributed systems, the Comparand Pattern provides for efficient comparison of remote objects. |
| James Noble
Charles Weir |
A Window in your Pocket: Some Small
Patterns for User Interfaces
Pocket computers (palmtops, sub-sub-notebooks, PDAs, organisers, communicators, tricorders) are becoming more common, and real alternatives to PCs for many purposes. Unfortunately, because they are physically smaller, user interfaces for pocket computers are much harder to design than those for larger machines. This paper presents some patterns for designing user interfaces for pocket computers. Programmers and designers can use these patterns to design interfaces that will better suit small computers, resulting in applications that are more usable. |
| Fernando Lyardet
Gustavo Rossi |
Web Usability Patterns
The patterns included in this work do not address the general problem of how to design a complex interactive software artifact. Rather than focusing on the design of traditional user interfaces, video games, and other such things, these patterns cover specific issues found in the interaction with web information systems(WIS). The patterns included in this work do not attempt to address detailed implementation issues, however. |
| Gustavo Rossi | Patterns for Personalized Web Applications
Building personalized Web applications, i.e. those applications that are responsive to the individual needs of each user or group of users, is a challenging task. It involves a myriad of different technologies that range from simple database views to software agents and collaborative filtering algorithms. In this paper we present some patterns we mined in Web applications that present some kind of personalized structure or behavior. We first introduce the growing need to include personalization features in Web applications and present a taxonomy for reasoning about design structures for personalization. Finally, we present 4 personalization patterns: Link Personalization, Content Personalization, Structure Personalization and Remote Personalization. |
Workshop E:
Management & Processes
| Author | Title / Abstract |
| Wolfgang Keller | A few Patterns for Managing Large Application
Portfolios
Merger mania hits the corporate world as a side effect of globalization. Most mergers of companies in the same industries are followed by mergers of their information systems. This paper presents some frequent problems and frequently used solutions to help you manage such information system mergers. The examples are mostly taken from „elephant mergers” of corporations with application portfolios of well over 100,000 function points for the core systems alone. Such marriages typically appear in the financial industry. The patterns are also useful for companies which have more than one information system for the same business function and want to consolidate their systems. |
| Christian Wege | Steps out of Integration Hell
As a typical IT user (not an IT producer) we in our company more and more try to base our application systems development on the integration of existing components rather than on custom made solutions. The pattern "Protocol interception wrapper" described in this paper is the first one found during the integration work of different components. It is inteded to help you if you need to understand the protocol between the system under development and a plugged-in component for which you don't have the source code. Other planned patterns are "Isolation test suite", "Everything in the debugger", and "Disclose specification by decompilation". |
| Daniel May | Building the Cultural Artifacts of the Organization
The culture of an organization can be grown and disseminated by infusing it in the artifacts of the organization. These artifacts can be physical things, informational objects or conceptual artifacts. as people internal and external to the organization encounter these artifacts, they also encounter the culture. This paper focuses on conceptual artifacts – such as stories, metaphors, activities, patterns – that are constructed and used in the life of the organization’s culture. It presents a collection of patterns that discuss how to create and apply conceptual artifacts in growing an organization’s culture. |
| Klaus Marquardt
Jutta Eckstein Markus Völter |
Patterns for Experiential
Learning
This pattern language under construction contains patterns from the PPP effort which were refactored into Alexanderian form, to support integration into a pattern language. |
| Tanya Linden
Jacob Cybulski |
Facilitating Reuse in Multimedia
Development
This paper describes a systematic approach to multimedia application development that emphasises reuse of multimedia objects and at the same time addresses quality and productivity of the development process. The approach is described with the aid of a process quality pattern Analyse Organise Synthesize. The pattern describes a methodology that addresses issues of multimedia product development and discusses maintenance of a multimedia repository. By applying this pattern developers may improve their productivity and enhance quality of individual components and entire multimedia products. |
| Thomas Vestdam | Writing Internal Documentation
Internal documentation of software projects maintains the understanding of the program under development. Internal documentation is useful both for current and future developers. For example, current developers can be reminded of the rationales behind the program, and future developers can gain enough understanding of the program in order to perform maintenance. However, the production of internal documentation is not easy. Programmers often have a hard time figuring out what, how and when to document. However, a number of reoccurring problems and solutions concerning this have been identified and are presented in this paper as a collection of 20 patterns. |
| Manfred Lange | It's Testing Time!
The paper presents patterns for testing software. The patterns are derived
from practical work on large projects.
|