Franz Puntigam

Types for Active Objects Based on Trace Semantics

Static typing and subtyping are useful for the support of incremental refinement and reuse in object-oriented languages. Although demanded, there is currently no appropriate type model for concurrent object-oriented languages that supports dynamic behavior modifications. We propose a type model based on a process calculus with trace semantics and demonstrate its use in a simple language. This model is an extension of conventional models for types and subtyping and ensures that all messages are processed even if object behavior is modified dynamically.

Coordination requirements expressed in types for active objects

An objects type is usually regarded as a contract between the object and each of its users. However, in concurrent (and sometimes also in sequential) systems it is more useful to regard a type as a contract between an object and the unity of all users: The users must be coordinated before sending messages to the object. Types in the proposed model express requirements on the coordination of users; objects must accept messages only in pre-specified orders. The model ensures statically that objects behave as specified by their types, and users are coordinated appropriately.

An Execution Model for Distributed Database Transactions and Its Implementation in VPL

We present an execution model for distributed transactions that can be employed for multidatabase systems. We use the Flex Transaction model that has been proposed as a highly general and flexible tool for the specification of distributed transactions and extend it by allowing nested and possibly recursive transaction specifications. We show how a given transaction specification and its execution model can be mapped into a representation in a new concurrent Prolog language, the VPL (Vienna Parallel Logic) language. The representation in VPL can be considered as an executable specification. We show some optimizations concerning this mapping and define a significant subclass of Flex Transactions with a declarative representation in VPL that can be modeled by AND/OR structures. We argue that it is more advantageous to use VPL directly for the transaction specification because it provides more flexibility and more control aspects than the Flex Transaction model.

Changeable interfaces and promised messages for concurrent components

Statically checked process types ensure that a server understands all messages sent by (concurrent) clients. although the acceptability of messages may change dynamically. But. as proposed so far, process types do not ensure that ser\‘ers return appropriate answers. In this paper an extension is proposed: Servers must send promised messages (to return results), possibly after receiving further messages. -4 type checker statically ensures that promised messages cannot be involved in deadlocks and lifelocks. The proposed type concept supports subtyping as well as separate compilation.

Non-regular Process Types

Process types specify sequences of acceptable messages. Even if the set of acceptable messages changes dynamically, a type checker can statically ensure that only acceptable messages are sent. As proposed so far, all message sequence sets specified by types can be generated by regular grammars. We propose to increase the expressiveness so that non-regular message sequence sets can be specified. Type equivalence and subtyping take possible type extensions into account.

Program Execution Environments as Contextual Values

Context-oriented programming (COP) provides a very intuitive way to handle run-time behavior varying in several dimensions. However, COP usually requires major language extensions and implies a considerable performance loss. To avoid language extensions we propose to specify program execution environments as contextual values in separate units. A tool translates such specifications into C++ classes usable in the rest of the program. Without the need of multiple dispatch, the performance can largely profit from simple caching. Furthermore, it is easy to support debugging and store contextual values in configuration files.

Dynamic type Information in Process Types

Static checking of process types ensures that each object accepts all messages received from concurrent clients, although the set of acceptable messages can depend on the object’s state. However, conventional approaches of using dynamic type information (e.g., checked type casts) are not applicable in the current process type model, and the typing of self-references is too restrictive. In this paper a refinement of the model is proposed. It solves these problems so that it is easy to handle, for example, heterogeneous collections.

Reliable Communication in VPL

We compare different degrees of architecture abstraction and communication reliability in distributed programming languages. A nearly architecture independent logic programming language and system with reliable communication, called VPL (Vienna Parallel Logic) is presented. We point out the contradiction between complete architecture independence and reliable high-level communication in programming languages. The description of an implementation technique of VPLs reliable communication on shared memory and distributed architectures comprises a major part of this paper. The reliable communication is based on the specification of consistent system states that must survive system failures.

Strong types for coordinating active objects

An object type is usually regarded as a contract between an object and each of its clients. However, in concurrent (and sometimes also in sequential) systems it is more useful to regard a type as a contract between an object and the set of all clients: when the object acts as a shared resource, the clients must be coordinated before sending messages to the object. Process types of active objects specify constraints on the ordering of messages. Static type checking ensures proper coordination of clients so that objects receive messages only in acceptable orderings. As presented in this article, the process type system is based on a simple computation model where active objects communicate via asynchronous message passing. Copyright

Types That Reflect Changes of Object Usability

Strong, static typing is useful because it can improve the readability, reliability and optimizability of programs. The usability of an object may change over time. However, conventional type systems for object-oriented languages presume that objects are always used in the same way. In this paper an extension of Adas type concept is presented: Possible changes of object usabilities can be specified as part of type declarations for passive and active objects. This extension is compatible with inheritance and supports static type checking.