If you're an author, please check that your name, email address, abstract, and submitted material are ok.
If you're a shepherd, please make sure your assignment is ok and download
the material you're shepherding.
In case you have trouble printing the paper you're shepherding, please
contact the authors directly.
Please take a look at the shepherding guidelines
and Neil Harrison's Pattern Language for Shepherds
and Sheep.
| Author | Shepherd (PC Member) | Title / Abstract | Paper |
| Joseph Bergin | Neil Harrison
(PC: Jutta Eckstein) |
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. |
joseph-bergin.zip |
| Diethelm Bienhaus | Martine Devos
(PC: James Noble) |
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. |
diethelm-bienhaus.zip |
| Andrew Black | James Noble
(PC: Jutta Eckstein) |
Core/Support Split
When several concrete classes implement the same interface, the "rows and columns" argument says that while it is easy to add new representations, adding new operations is harder because it involves touching multiple classes. This patterns shows how, in one common situation, it is possible to use inheritance from an abstract superclass to define a new operation by adding a single method. The pattern works when it is possible to partition the set of messages understood by the abstraction into core messages and support messages. |
andrew-black.zip |
| José Manuel Burgos-Ortiz
Javier Galve-Francés Julio García-Martín |
Joseph Bergin
(PC: Martine Devos) |
Cebolla : A Pattern Language for Elementary Programming Instruction
The paper describes the Cebolla pattern language, a patterning proposal aimed to improve the effectiveness of programming instruction. The language provides a common instructional framework to categorize, specify, solve and implement the problems commonly taught in a CS1 programming course. |
burgos+galve+garcia.zip |
| Alan O'Callaghan | Frank Buschmann
(PC: James Noble) |
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. |
alan-o-callaghan.zip |
| Serge Demeyer
Stephane Ducasse Oscar Nierstrasz Serge.Demeyer@uia.ua.ac.be,
|
Mary Lynn Manns
(PC: Paul Dyson) |
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. |
demeyer+ducasse+nierstrasz.zip |
| Stephane Ducasse
Oscar Nierstrasz |
Neil Harrison
(PC: Christa Schwanninger) |
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. |
ducasse+nierstrasz.zip |
| Jutta Eckstein | Norm Kerth
(PC: Linda Rising) |
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. |
jutta-eckstein.zip |
| Javier Galve-Francés
José Manuel Burgos-Ortiz Julio García-Martín Miguel Sutil-Martín |
Andreas Rüping
(PC: Jutta Eckstein) withdrawn |
The Quantification Pattern
Problems that require a traversal on a collection of data can be specified as a mathematical quantification. This paper describes the Quantification pattern, a behaviour pattern that describes an object-oriented design to solve this sort of problems. |
galve+et-al.zip |
| Julio García-Martín
Miguel Sutil-Martín |
Andreas Rüping
(PC: Linda Rising) |
The Compiler Pattern: Designing Abstract Compilers by Stepwise Refinement
of Virtual Machines
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. |
garcia+sutil.zip |
| Peter Gassmann | Christa Schwanninger
(PC: Paul Dyson) |
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. |
peter-gassmann.zip |
| Thierry Geraud
Alexandre Duret-Lutz |
Andreas Rüping
(PC: Paul Dyson) |
Design Patterns for Generic Programming
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. |
geraud+duret.zip |
| Wolfgang Heinz | John Letourneau
(PC: Andreas Rüping) withdrawn |
Resting Points
"Resting Points" is a User Interface Pattern that deals with the complexity of parallelism in the work of a user, typically a clerk using a business support system. Problem: A business process takes a longer timespan for the user to accomplish, which means there may arise the need for interruption or suspension. How can we accomplish this in an orderly manner? Solution: Provide a well defined set of situations (resting points) in which the user can safely suspend the business process, perform other actions, and afterwards resume the process in an orderly manner. |
wolfgang-heinz.zip |
| Koen Hendrikx | John Letourneau
(PC: Paul Dyson) |
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 pattern language of four patterns each able to address these forces in different ways. The patterns are Resource Wrapper, Shared Resource, Resource Pool and Transactional Resource. A Resource Wrapper allows one to control the sharing versus the replication of a resource. A Shared Resource allows simple sequential isolation of transactions by a semaphore. A Resource Pool allows us to control sequential versus spatial isolation. Finally, a Transactional Resource combines sharing, isolation and replication to achieve a middle ground at the expense of greater complexity. |
koen-hendrikx.zip |
| Kevlin Henney | John Vlissides
(PC: Wolfgang Keller) withdrawn |
C++ Patterns: Expressive Values
Value objects represent the simple, granular pieces of information you find in a system - strings, dates, money, dimensions, colors, etc. - as opposed to strongly behavioral objects or those entities for which identity is significant. The patterns in this paper document idiomatic practices for expressing value types in C++. They are connected together as a language and demonstrated through a worked example. |
|
| Kevlin Henney | John Vlissides
(PC: Wolfgang Keller) |
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. |
|
| Kevlin Henney | John Vlissides
(PC: Wolfgang Keller) withdrawn |
C++ Patterns: Source Cohesion and Decoupling
Coupling and cohesion are non-functional properties of a system's built structure. They have measurable effects on the ease of comprehensibility, compilability, testing, and maintenance of any system. In C++, decoupling begins at a physical level with code structure. Surrounding the syntax, any system in development has a structure of source and header files that lives in a file system. This physical structure is often neglected to the detriment of any system: It is sometimes impressive (and depressive) to see a clean logical design crushed by the brute force of a poorly considered physical structure. The patterns in this paper document idiomatic practices for organizing C++ source and header files. They are connected together as a language. |
|
| Pavel Hruby | Paul Dyson
(PC: Wolfgang Keller) |
Pattern for Structuring UML Compatible Software Project Repositories
Have you tried to specify your software system with UML and later experienced problems with getting an overview about the completeness and consistency of the specification and with meeting demands for usability and quality of the software design? It might help to identify a suitable structure and relevant relationships between software development artifacts. I will illustrate a pattern of design artifacts that can be used for structuring project repositories containing UML diagrams. The pattern enables you to customize the size of the specification, so it matches the size of the problem and stays consistent. It allows the specification to be extended in a predictable way, if you want to specify something unusual or unexpected, such as information not covered in the UML notation guide or available literature. |
pavel-hruby.zip |
| Prashant Jain
Michael Kircher Prashant.Jain@mchp.siemens.de,
|
Bob Hanmer
(PC: Linda Rising) |
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. |
jain+kircher.zip |
| Matthias Jung
Ernst W. Biersack |
Peter Sommerlad
(PC: James Noble) |
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. |
matthias-jung.zip |
| Oemer Karacan
Gerhard Ackermann |
Ralph Cabrera
(PC: Andreas Rüping) |
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. |
karacan+ackermann.zip |
| Wolfgang Keller | Steve Berczuk
(PC: Christa Schwanninger) |
Pac Man Migration
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. Pac Man 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. Pac Man is really a very common migration pattern. |
wolfgang-keller.zip |
| Stefan Kovalovsky | Martine Devos
(PC: Linda Rising) |
Aha
In this paper, a pattern that provides a solution to the problem of getting "stuck" in a problem solving situation is described. |
stefan-kovalovsky.zip |
| Manfred Lange | Jens Coldewey
(PC: James Noble) |
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. |
manfred-lange.zip |
| Fernando Lyardet
Gustavo Rossi |
Jutta Eckstein
(PC: Andreas Rüping) withdrawn |
Web HCI Patterns
In this paper we present a set of HCI web design patterns in the context of an ongoing development of a hypermedia design pattern language. Rather than concentrating in the general problem of how to design a complex interactive software artifact, these patterns address specific interaction issues found in web information systems(WIS). |
lyardet+rossi.zip |
| Qusay H. Mahmoud | James Noble
(PC: Martine Devos) withdrawn |
Security Policy: a design pattern for mobile Java code
When users on the net visit a homepage that has an applet embedded into it, the applet's code is downloaded to the user's machine and executed there. In other words, the applet's code migrates from the host's machine to the user's machine, and it will run on the user's machine. In such an environment, we want to make sure that the code being downloaded does not do any harm to the system on which it will be executed. In such distributed environments, security is a major concern. This paper presents the Security Policy pattern, a design pattern that has been used in many contexts, and proved to be useful, to develop applications capable of securely loading classes off the network and executing them locally. The Security Policy pattern can be used either on the client- or server-side. While the pattern may sound Java-centric, it can however be implemented in other languages. |
qusay-mahmoud.zip |
| Mary Lynn Manns
Linda Rising |
Jim Coplien
(PC: Martine Devos) |
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. |
manns+rising.zip |
| Klaus Marquardt | Manfred Lange
(PC: Linda Rising) |
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 how to define the protocol per class and to allow extending the distributed application during development. Protocol Backbone is an anti-pole to this, resolving similar forces to a different solution. Several design patterns help with the implementation. Transparent Remote Access describes technical details how messages are initiated and received, and Synchronizer describes how consistent object state is maintained in different devices. |
klaus-marquardt.zip |
| Nuno Meira
Ivo Conde e Silva Alberto Silva napfm@camoes.rnl.ist.utl.pt,
|
Kevlin Henney
(PC: Christa Schwanninger) |
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. |
meira+conde+silva.zip |
| Oscar Nierstrasz
Stephane Ducasse |
Kevlin Henney
(PC: Andreas Rüping) |
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. |
nierstrasz+ducasse.zip |
| James Noble
Charles Weir |
Linda Rising
(PC: Wolfgang Keller) |
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. |
noble+weir.zip |
| Gustavo Rossi
Fernando Lyardet Daniel Schwabe gustavo@sol.info.unlp.edu.ar
|
Peter Sommerlad
(PC: Martine Devos) |
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. |
rossi+lyardet+schwabe.zip |
| Christoph Steindl | Linda Rising
(PC: Jutta Eckstein) |
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. |
christoph-steindl.zip |
| Oliver Vogel | Wolfgang Berger
(PC: James Noble) |
Generic Factory
The AbstractFactory 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. Although design reuse is an important and valuable factor for successful software development, it isn’t enough in the case of the AbstractFactory pattern. As described above, new construction code has to be implemented for each product family. 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 AbstractFactory pattern would be an appropriate solution. For every product family, a factory object could be instantiated and configured with the product family objects, so that the only code, that would have to be written, would be the one configuring the factory. This results in less implementation effort and thus in an increased software productivity. The GenericFactory pattern describes how to realize a configurable factory. Moreover, it shows how normal objects can become singletons at run time and how objects can be specified via an abstract or a concrete product identification. |
oliver-vogel.zip |
| Markus Völter | Wolfgang Keller
(PC: Christa Schwanninger) |
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. |
markus-voelter.zip |
| Markus Völter
Astrid Fricke |
Norm Kerth
(PC: Jutta Eckstein) |
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. |
voelter+fricke.zip |
| Charles Weir
James Noble |
Klaus Marquardt
(PC: Paul Dyson) |
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. |
weir+noble.zip |
| Uwe Zdun | Ralph Johnson
(PC: Christa Schwanninger) |
Foreign Object System
Advanced object-oriented techniques help us to design and implement complex software systems. Often (parts of) the design/implementation have to be performed in languages that do not language support the desired functionalities. We observed in several systems that foreign object systems, like object-oriented scripting languages or object-orientation libraries, were used to add object-oriented features to a system. Sometimes object-oriented techniques are introduced to languages that do not support object-orientation at all; sometimes existing object-oriented languages are enhanced with advanced functionalities, like reflection or dynamic typing. By being an indirection layer foreign object systems strongly influence the software architecture, they have certain commonalities in their internal design, they induce patterns to the development process, and they induce the usage of other object-oriented design pattern (like wrapper facades for wrapping up non-object-oriented parts of the system). In this paper we will focus on the internal design and on the impact on applications that are built upon foreign object systems. |
uwe-zdun.zip |
Last Update: Wed 2000-May-08 08:00 European Summer Time.