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.
You can download individual papers, or all papers assigned to one workshop. The paper formats are PDF, PostScript, HTML, or MS Word. (To make sure you can read all papers, we have added PDF files to papers that the authors provided as PostScript files. The PostScript versions may be of better quality, though.)
| Author | Title / Abstract |
| Joseph Bergin | Fourteen Pedagogical Patterns
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. |
| Diethelm Bienhaus | Human oriented Information Presentation
This pattern deals with the problemof effective communication and representation of information. If human specific abilities in information retrieval are not considered, information consumption is inefficient. To solve this problem, aspects of human specific ways of information perception, storage and retrieval have to be considered. The solution takes limitations of human short term memory and primary spatial perception of information into account. |
| José Manuel Burgos-Ortiz
Javier Galve-Francés Julio García-Martín |
From Problems to Programs:
A Pattern Language to Go from Problem Requirements to Solution Schemas
in Elementary Programming
The "From Problems to Programs" pattern language is an intent to formalize to a certain extent, via patterns, the programming process to go from the problem to the program. It outlines a common instructional framework to categorize, specify and solve the problems commonly taught in an introductory programming course. The language helps those educators interested on an organization of information for teaching a programming course which puts primary interest on the structure of and relationships between a problem, a program and a solution schema. The language can also help to see how formal specification concepts are related with programming. |
| Jutta Eckstein | Learning to Teach and Learning to Learn
- Pedagogical and Social Issues in Education
The paper describes a pattern language for educators who care not only about what they are teaching but also on how they are mediating the topics. The paper wants to address the learning part on the students' side as well as the teaching part on the educator's side. The first pattern "Open the door" addresses the problem on how to start a course. "Ask your neighbour" and "Challenge" could be used several times during the course, where as "Wrap Up the day" either concludes a session or a whole course. "Do you remember" is used for repetition after a break. |
| Mary Lynn Manns
Linda Rising |
Evolving a Patterns Culture
Organizations in the knowledge business realize that their future depends on keeping their employees up to date in the latest technology. Some of us are trying to introduce new technologies in our workplaces. Some of our efforts have been successful and some have not. The patterns described in this paper are the beginning of a pattern language for introducing new technology into the workplace. The contributors to this pattern language are from organizations all over the world. What we have found is a close connection between our experiences, which is reflected in the patters we have written. |
| Christoph Steindl | Self Test (Pedagogical Pattern)
Self tests can be used during exercise courses to let the students determine whether they have understood the theory of the accompanying lecture. First the students try to answer the questions on a questionnaire. Then these questions are solved in a team-work manner. So the students learn by repetition. The important point is that they evaluate their knowledge and get feedback before the repetition. |
| Markus Völter
Astrid Fricke |
SEMINARS
This pattern language is intended for those instructors in the industry, who are not studied educators. We wrote it especially for those, who feel that something is going wrong with their seminars – perhaps they are even frustrated and don’t know what to change or what the reasons could be. This pattern language gives some hints how the situation can be improved, i.e. how you can run better seminars. In addition to describing the patterns themselves, the pattern language also tries to explain some of the biological, anthropologic and pedagogic background. It covers all aspects of a seminar from preparation till exams. |
Workshop B: Reengineering
& Culture
| Author | Title / Abstract |
| Alan O'Callaghan | Patterns for Architectural Praxis
The patterns below are patterns which extend the ADAPTOR (Architectural and Patterns-based Techniques for Object Re-engineering) patterns to encompass the architecting of Greenfield developments also. These patterns selected for review because they each are examples of different categories of patterns that make up the language. ‘Keeper of the Flame’ is an organizational/role pattern; ‘Mile-Wide,Inch-Deep’ is a philosophical pattern (of the kind of which Alexander’s “Gradual Stiffening” is an example) while ‘Archetype’ is a pattern which reveals a technique for modeling software architectures. |
| Serge Demeyer
Stephane Ducasse Oscar Nierstrasz Serge.Demeyer@uia.ua.ac.be,
|
A Pattern Language
for Reverse Engineering
Since object-oriented programming is usually associated with iterative development, reverse engineering must be considered an essential facet of the object-oriented paradigm. The reverse engineering pattern language presented here summarises the reverse engineering experience gathered as part of the FAMOOS project, a project with the explicit goal of investigating reverse and reengineering techniques in an object-oriented context. Due to limitations on EuroPLOP submissions, only part of the full pattern language is presented, namely the patterns describing how to gain an initial understanding of a software system and one pattern preparing subsequent reengineering. |
| Stephane Ducasse
Oscar Nierstrasz |
Tie Code And Questions: a Reengineering
Pattern
The reengineering pattern presented in this paper shows how you can support your understanding during system reengineering by linking your questions or information about the code in the code itself. |
| Wolfgang Keller | The Bridge to the New Town - A Legacy System
Migration Pattern
If you manage large application portfolios like for a bank or an insurance you are often faced with the challenge to replace a monolithic application system with newer systems. Bridge to the New Town is a low risk, incremental migration strategy that allows you to stepwise replace an existing legacy with newer components by "eating up the legacy" one part after the other. Bridge to the New Town is really a very common migration pattern. |
| Oemer Karacan
Gerhard Ackermann |
Organizational Patterns - Virtual
Organizations Pattern Language
To increase productivity and product quality in software development, companies invest in qualification of their engineers, improvement of their development processes and many other approaches. We believe, that another, much more powerful way to go in the above direction is to try new complementary organizational forms of how people work together . Specifically the network form seems to fit modern daily practice and surrounding conditions. The patterns described in this paper are a group of selected patterns of a pattern language which is still in progress in our company. The central pattern „Virtual Organisation Units“ was first introduced and reviewed in the „Pattern Writing Workshop at the University of Vienna ‘99“ with Coldewey, Coplien, Keller, Schwanninger, the others have been developed since then. |
| Oscar Nierstrasz
Stephane Ducasse |
Transforming Conditionals
We describe several related reengineering patterns concerned with removing conditionals from object-oriented code. Transform Conditional to Subclassing makes a class more extensible by transforming complex conditional code that tests immutable state into a single polymorphic call to an operation which will be implemented by a different subclass for each case of the conditional. Transform Conditional to Polymorphism transforms conditional code that tests the type of an object into a polymorphic call to a new method, thereby reducing client/provider coupling. |
| Gustavo Rossi
Fernando Lyardet Daniel Schwabe gustavo@sol.info.unlp.edu.ar
|
Patterns for E-Commerce
Applications
In this paper we present some patterns we found in E-commerce applications. First, we briefly characterize these applications as a particular case of Web applications. We next review some Web patterns that can be used in E-commerce applications. Finally, we present five new patterns: Opportunistic Linking, Advising, Explicit Process, Secure Backtrack and Push Communication. |
Workshop C: Architecture
& Design
| Author | Title / Abstract |
| Peter Gassmann | A Unit Testing Pattern Language
Unit Testing is a software development practice which has recently gained acceptance through a new development methodology called eXtreme Programming (XP). The success of unit tests in a project depends on well defined structures of the code. This paper identifies such structures which have been used successfully, and documents them in the form of a pattern language. In addition, important process patterns are identified which help using unit tests successfully. |
| Thierry Geraud
Alexandre Duret-Lutz |
Generic Programming Redesign of Patterns
Generic programming is a recent paradigm, in which most classes and procedures are parameterized, thus leading to the construction of general and efficient software components. In this paper, we demonstrate that some design patterns from Gamma et al. can be translated into this paradigm. Although these patterns highly rely on dynamic binding, we show that, in the context of generic programming, the resolution of method calls in these patterns can be performed at compile-time, which is of prime importance for numerical computing. To this end, we make intensive use of parametric polymorphism. |
| Pavel Hruby | Pattern for Structuring UML-Compatible Software
Project Repositories
Have you ever tried to describe your software system with UML and struggled to get an overview of the completeness and consistency of the specification? Has your software development method sometimes forced you to create development artifacts you did not need? I will illustrate a pattern of development artifacts that allows the UML specification to be contracted or extended in a predictable way, if you want to specify an unusual feature in the system. It enables you to customize the size of the specification, so it matches the size of the problem and stays consistent. |
| Prashant Jain
Michael Kircher Prashant.Jain@mchp.siemens.de,
|
Lookup
The Lookup design pattern got discovered in the field of software architecture, more specifically in the field of distributed object computing. It describes how to find and retrieve initial references to distributed objects and services. The proposed solution is to provide a Lookup service with a well-defined access point. Services register references of themselves with it, which are retrieved by clients wanting to access these services. To find the Lookup service itself it is suggested to design a bootstrapping protocol. |
| Matthias Jung
Ernst W. Biersack |
Order-Worker-Entry: A System of
Patterns to Structure Communication Protocol Software
We present a system of architectural design patterns for the implementation of flexible, extensible, and maintainable application tailored network protocol software in end-systems. The pattern system mainly follows a vertical structuring approach. "Outsourced De-Multiplexing" reduces cross-talk between different protocol sessions. "Data-Path Reification" assures service extensibility and quality of service control for protocols. "Data Path Partitioning" assures the re-usability of protocol components and allows for easy modification and configuration. "Data Path Classification" enables application and network to flexibly interact with a protocol environment without compromising the protocol's autonomy. |
| Nuno Meira
Ivo Conde e Silva Alberto Silva napfm@camoes.rnl.ist.utl.pt,
|
An Agent Pattern Language for
a More Expressive Approach
In this paper, we present a set of Agent Patterns, maintaining a tighter connection with the real world. In the real world there are many pattern behaviors, good solutions, that if transported to agent systems will increase not only its capabilities and potential, as well as, possessing more expressiveness since they translate familiar concepts, make this emerging technology more easily accepted by the programming community. |
| James Noble
Charles Weir |
Small User Interfaces
In many cases, especially in interactive systems, memory requirements cannot really be predicted in advance, because they depend critically on what users choose to do with the system. If you try to produce a generic memory budget, you will over-allocate the memory requirements for some parts of the program, and consequently have to under-allocate memory for others. Being able to use a system to do a variety of jobs without running out of memory is sufficiently important that you can risk making other aspects of the interface design more complicated if it makes this possible. This is especially important because a system's users presumably know how they will use the system when they are actually using it, even through the system's designer may not no know this ahead of time. These patterns are part of an ongoing project to capture and document techniques for the design and construction of systems that must function under tight memory constraints. The patterns will eventually be published in book form in the Addison-Wesley Software Patterns Series. |
| Charles Weir
James Noble |
Process Patterns for Small Systems
In many projects it's clear from the outset that the development team will have to spend at least some time and effort satisfying the system's memory limitations.You have to cut your coat to fit your cloth. Yet if the team just spends lots of effort optimising everything to work in very limited memory, they'll waste a lot of time or maybe produce a product that could have been much better. Worse still the product may fail to work at all because they have been optimising the wrong thing. So, how should you approach the process of designing a small system? These patterns are part of an ongoing project to capture and document techniques for the design and construction of systems that must function under tight memory constraints. The patterns will eventually be published in book form in the Addison-Wesley Software Patterns Series. |
Workshop D: Design
& Programming
| Author | Title / Abstract |
| Julio García-Martín
Miguel Sutil-Martín |
Virtual Machines and Abstract Compilers
- Towards a Compiler Pattern Language
Because of the increasing gap between modern high-level programming languages and existing hardware, it has often become necessary to introduce intermediate languages and to build virtual machines on top of the hardware. This paper describes the COMPILER pattern, a proposal that captures the essential features underlying compilation processes. Based on staging transformation of virtual machines, and having as support the VIRTUAL MACHINE pattern [4], we set out the task of compiling as a stepwise-refinement process, so that the piecemeal acquisition of high-performance properties is posed in terms of relationships between intermediate virtual machines. Each stage compilation stage makes explicit some new features that are added to the global compilation process. The equivalence between one machine and the next is preserved thought the process. |
| Koen Hendrikx | Managing Shared Resources
When applications share data or resources, a number of conflicting forces must be resolved: scalability, consistency and concurrency. The paper presents a small set of patterns that each address these forces in different ways. A general ideom used in resource management is the Wrapper ideom or Handle/Body ideom [Coplien 1998], which can be used to further disconnect the resource from how and when it is used. The Synchroniser pattern describes how a shared resource can be synchronised by sequential isolation by a semaphore. A Resource Pool allows us to control sequential versus spatial isolation. Finally, three flavours of Transaction achieve a different balance of sharing, isolation and replication to achieve a middle ground at the expense of greater complexity. |
| Kevlin Henney | C++ Patterns: Executing Around Sequences
Sequential control flow forms the backbone of any procedural program. Just as common function, data, and structure in a C++ program can be factored out using functions, classes, and templates, common control flow schemas can also be named and abstracted. One such recurring schema, or programmatic turn of phrase, is the embracing of a sequence by a pair of actions, such as resource acquisition and release operations executed around the actual resource usage code. The patterns in this paper document idiomatic practices for abstracting such control flow in C++. They are connected together as a language and explored through a narrative example. |
| Manfred Lange | A Collection of Patterns for Object-Oriented
Databases
Object-oriented databases have been around for a while. Still, it does not appear that they have found widespread use. Many applications are still developed base on relational database systems. For these, pattern languages have been developed over a couple of years. For object-oriented database systems however dedicated papers describing related patterns are rare. This paper tries to fill the gap. At least to some extend, as it does not provide a complete set of patterns, but only a collection. All patterns presented here have been successfully applied to different projects, having built a solid backbone for high availability solutions. |
| Klaus Marquardt | Patterns for Object Transport
In distributed systems, objects can be transported and addressed via network connections. Object transport patterns help to cross the mismatch between objects and a flat transport presentation, and support incremental development. Peripheral Protocol Definition describes a process how to define the protocol per class and how to allow extending the distributed application during development. Protocol Backbone is an anti-pole to this, resolving similar forces to a different solution. Several process patterns help with compromising between these poles. For the implementation of a peripheral protocol, Transparent Remote Access describes a technical framework for message definition, and transparent sending and receiving. |
| Oliver Vogel | Generic Factory
The Abstract Factory pattern is a solution often used for isolating clients from the construction of concrete objects. Normally a new concrete factory class is developed for each concrete product family. Therefore new specific construction code has to be written each time a new product family needs to be supported. This approach influences software productivity negatively as it does only cover the reuse of design ideas. In order to minimize the effort involved in supporting a new product family, the reuse of code should also be achieved. A configurable factory as described in the implementation section of the Abstract Factory pattern would be an appropriate solution. This would result in less implementation effort and thus in an increased software productivity. The Generic Factory pattern describes how to realize a configurable factory. |
| Markus Völter | Metacommand
Metacommand enhances the Command pattern by providing a facility to enhance or modify the common behaviour of the command classes used in a system at any time without modifying the command classes themselves. It achieves this by wrapping another layer of commands, called the MetaCommands, around the command classes themselves, that defines the common behaviour. The wrapping is done by a system wide set factory. |
| Uwe Zdun
Michael Goedicke Gustaf Neumann |
Object System Layer
Advanced object-oriented techniques help us to design and implement complex software systems. Often (parts of) the design/implementation have to be done in languages that do not implement the object-oriented paradigm or that do not language support the desired functionalities. But these base languages are chosen for important technical or social reasons, like legacy integration, existing developer's expertise, or customer demands. A solution is to introduce an Object System Layer, that implements the desired object-oriented functionalities on top of the used base language. Object-oriented applications can then be build upon the Object System Layer, while non-object-oriented base language components can easily be integrated. Examples of popular Object System Layers are object-oriented scripting languages, libraries implementing an object-system, and object systems of key technologies. |