Christian Heinlein

Workflow and process synchronization with interaction expressions and graphs

Current workflow management technology does not provide adequate means for inter-workflow coordination as concurrently executing workflows are considered completely independent. While this simplified view might suffice for one application domain or the other, there are many real-world application scenarios where workflows, though independently modeled in order to remain comprehensible and manageable, are semantically interrelated. As pragmatical approaches, like merging interdependent workflows or inter-workflow message passing, do not satisfactorily solve the inter-workflow coordination problem, interaction expressions and graphs are proposed as a simple yet powerful formalism for the specification and implementation of synchronization conditions in general and inter-workflow dependencies in particular. In addition to a graph based semi-formal interpretation of the formalism, a precise formal semantics, an equivalent operational semantics, an efficient implementation of the latter, and detailed complexity analyses have been developed, allowing the formalism to be actually applied to solve real-world problems like inter-workflow coordination.

Inheriting from a Common Abstract Ancestor in Timor

A particular case of multiple inheritance, involving a family of related types with a common abstract ancestor, is examined, and a substantial example, involving five abstract and nine concrete collection types, is presented. The separation of types and implementations, together with the separation of subtyping and code re-use, results in a clearly structured and easily intelligible type library which allows extensive polymorphic use of collections at the type level. A full implementation of only one of these types, together with a few additional trivial code units, can be re -used to implement all nine concrete types. The paper concludes by describing how the binary methods and constructors can also be easily and efficiently designed and implemented.

Qualifying Types Illustrated by Synchronisation Examples

Qualifying types represent a new approach to modifying the behaviour of instances of other types in a general way, in the form of components which can be designed and implemented without a prior knowledge of the types to be modified or their implementations. This paper illustrates the idea by showing how they can be used to program various standard synchronisation problems, including mutual exclusion, reader-writer synchronisation and several variants of the bounded buffer problem.

MPEG-L/MRP: implementing adaptive streaming of MPEG videos for interactive internet applications

Existing multimedia streaming technologies offer no specific support for user interaction like jumping to bookmarks in a video, or switching to reverse play. When the users, e.g., jump to a bookmark, the player requests frames for the new presentation point from the server and resumes playing only when the data has arrived. Our solution for this problem is the client prefetching the buffering strategy, MPEG-L/MRP, that ensures that the frames which are needed for a response to a possible user interaction are already in the clients buffer, which leads to qucik and smooth reaction to user interactions. In case of variable bandwidth, our MPEG-1 streaming approach selects only a subset of all frames to be fetched from the server and supports a smooth presentation at a reduced frame rate with correct timelines.The technical demonstration shows the interactive streaming of MPEG-videos and illustrates our buffering and prefetching strategy.

A Conceptual Approach to an Open Hospital Information System

A concept for an open hospital Information System integrating heterogeneous components is proposed. The approach is object-oriented, but is not built directly upon object-oriented database management Systems. Basic ideas are a Software bus, Workflow management with extended transaction concepts, and integrated knowledge-based modules. From the application perspective, conventional and problem-oriented views, support of complex medical and organizational pro-cesses including scheduling, and integrated clinical guidelines are important features.

Representation of medical guidelines using a classification-based system

Medical guidelines play an increasing role in selecting diagnostic and therapeutic steps under the aspects of effectiveness, invasiveness, and costs. To work directly on patient data already available in electronic form, they should be integrated into a medical information system. In order to develop a “medical guideline module” (MGM) managing and applying guidelines to patients, a “knowledge level” representation of guidelines is necessary which reflects the structure of medical knowledge and matches medical processes. Furthermore, a direct transformation to the “symbol level” is needed. We use a nested, frame-like structure on the knowledge level and show that a classification-based knowledge representation system (CBKRS) is principally well suited for the symbol level. To facilitate the usage and to be independent of a particular CBKRS, we introduce an intermediate level called “intelligent object system” (IOS). It is developed by augmenting a simple data model for describing complex objects with prototypes and implications as a means to classify objects and to draw inferences based on this classification. Finally, the transformation of guidelines to prototypes and implications is described.

Concept and implementation of C+++, an extension of C++ to support user-defined operator symbols and control structures

The first part of this report presents the concepts of C+++, an extension of C++ allowing the programmer to define new operator symbols with user-defined priorities by specifying a partial precedence relationship. Furthermore, so-called fixary operator combinations consisting of a sequence of associated operator symbols to connect a fixed number of operands as well as flexary operators connecting any number of operands are supported. Finally, operators with lazily evaluated operands are supported which are particularly useful to implement new kinds of control structures, especially as they accept whole blocks of statements as operands, too. In the second part of the report, the implementation of C+++ by means of a “lazy” precompiler for C++ is described in detail.

Safely Extending Procedure Types to Allow Nested Procedures as Values

The concept of nested procedure values, i. e., the possibility of using nested procedures as values of procedure types, is a useful and powerful concept. Nevertheless, it is not allowed in languages such as Modula-2 and Oberon(-2), because it creates a serious security hole when used inappropriately. To prevent such misuse while at the same time retaining the benefits of the concept, alternative language rules as well as a small language extension for Oberon-2 are suggested, which allow nested procedures to be safely used as values of procedure types and especially to pass them as parameters to other procedures.

Global and Local Virtual Functions in C

Global virtual functions (GVFs) are introduced as C++ functions defined at global or namespace scope which can be redefined later similar to virtual member functions. Even though GVFs are a relatively simple concept, hardly more complex than ordinary C functions, it is shown that they subsume object-oriented single, multiple, and predicate-based method dispatch as well as aspect-oriented before, after, and around advice. Furthermore, the well-known “expression problem” can be solved in a simple and natural way. Local virtual functions are a straightforward extension of GVFs allowing temporary redefinitions during the execution of some other function or part of it. Amongst others, this is quite useful to simulate “cflow join points” of aspect-oriented languages. The implementation of global and local virtual functions by means of a precompiler for C++ is briefly described.

Reuse Variables: Reusing Code and State in Timor

The standard approach to code reuse in object oriented languages is via inheritance. This is restrictive in a number of ways. For example, it leads to well known conflicts between subtyping and subclassing. Furthermore, where no type relationship exists, programmers must resort to inefficient techniques such as delegation to achieve code reuse. In the paper it is described how the language Timor decouples subtyping and code reuse and presents a new concept known as reuse variables, showing how these can be used to eliminate such restrictions in object oriented and component oriented contexts.