Gert Florijn

Tool support for object-oriented patterns

A software (design) pattern describes a general solution for a recurring design problem. The solution is mostly described in terms of an abstract design structure expressed in design elements such as classes, methods and relationships (inheritance, associations).

Variability Issues in Software Product Lines

Software product lines (or system families) have achieved considerable adoption by the software industry. A software product line captures the commonalities between a set of products while providing for the differences. Differences are managed by delaying design decisions, thereby introducing variation points. The whole of variation points is typically referred to as the variability of the software product line. Variability management is, however, not a trivial activity and several issues exist, both in general as well as specific to individual phases in the lifecycle. This paper identifies and describes several variability issues based on practical experiences and theoretical understanding of the problem domain.

ARIADNE and HOPLa: Flexible Coordination of Collaborative Processes

The Ariadne system and its modeling language HOPLa aim to provide generic support for hybrid collaborative processes, i.e. complex information processing tasks involving coordinated contributions from multiple people and tools. Ariadne should be usable for a wide variety of such processes and actively support people working in them and defining and managing them. The basic concept in Ariadne is that of a process. It combines a shared workspace with mechanisms to control the growth and evolution of this workspace. The workspace holds tree-shaped data and is selfdescriptive, in the sense that it holds the actual data but also the constraints (i.e. type definitions) that govern its structure. Nodes in the workspace can be marked as tasks to be performed and coordination operators and constraints, e.g. on the deadline or performer of a task, can be attached. Ariadne manages active processes and provides the interaction with the outside world. When tasks are enabled, actors are notified and results of their actions are stored in the workspace. A key issue for Ariadne is flexibility. It should be easy for users to model and create new kinds of processes even if this happens during the work in the process itself. This is addressed in two ways. First, process workspaces can be adapted arbitrarily within the limits of typedefinitions stored within them. Second, both process descriptions and running processes are HOPLa programs. This means that a running process can be stopped, arbitrarily modified (through editing of the program text) and continued whenever exceptions make this necessary and without the loss of any data that had already been produced.

Implementation Techniques for Integral Version Management

Version management services have traditionally focussed on versioning individual objects, and especially text files. This approach ignores the fact that (versions of) different objects are not independent from each other, and introduces the problem of finding consistent version combinations. One way to alleviate these problems is by expanding the unit of versioning, i.e. by applying integral version management to collections of objects.

Object Protocols as Functional Parsers

A service definition is an abstract specification of the behavior of a software component. It provides the interface between the users of an object and its (hidden) implementation. A protocol can be a part of a service definition. It captures the conditions under which interface operations can be invoked. This is of use for the designers of clients, but also for implementers of the service, at least if the protocol mechanism provides automatic (static or dynamic) acceptability checking of invocations or messages. Existing protocol formalisms are mostly based on finite state machines that describe legal orderings of messages. This is too limited, however, to model more complex services or to handle conditions that go beyond the ordering (such as access-control or time-dependencies) without referring to a service implementation.In this paper we explore a grammar-based approach to protocol definition, i.e. we define protocols as non-deterministic grammars extended with provisions for parallellism. The resulting protocols not only define legal message sequences but can also impose context-sensitive constraints on properties of messages, like its sender or a time stamp. Protocotols are truly abstract, i.e. independent of the implementation of a service. Since we want to investigate the kinds of constructs needed in specifying protocols we do not introduce a new notation, but instead express protocols as parsers written in a lazy functional language using a technique called combinator parsing. Besides giving a complete picture of the semantics of the constructs this also allows us to show how dynamic protocol checking can be provided. The approach is illustrated through several examples and its potential and limitations are discussed.