We study a language construct superimpose for methodcall interception (MCI). The construct enables a programmer to attach additional functionality to certain join points along the execution of specified method calls. This is done in a completely type-safe manner where the additional functionality shares its state with the registry location. We present the static and the dynamic semantics of MCI. We use a disciplined style of Natural semantics for an accessible specification of MCI. We organize the constructs in a design space so that we can add expressiveness to a simple objectoriented language core in a stepwise fashion. It is one simple extension to enable interactive MCI, that is, MCI code can interact with the objects involved in a method call. Another simple extension is to allow for collective MCI by using patterns for the calls to be intercepted.

Object-oriented distributed computing is becoming increasingly important for critical infrastructure in society. In standard object-oriented models, objects synchronize on method calls. These models may be criticized in the distributed setting for their tight coupling of communication and synchronization; network delays and instabilities may locally result in much waiting and even deadlock. The Creol model targets distributed objects by a looser coupling of method calls and synchronization. Asynchronous method calls and high-level local control structures allow local computation to adapt to network instability. Object variables are typed by interfaces, so communication with remote objects is independent from their implementation. The inheritance and subtyping relations are distinct in Creol. Interfaces form a subtype hierarchy, whereas multiple inheritance is used for code reuse at the class level. This paper presents the Creol syntax, operational semantics, and type system. It is shown that runtime type errors do not occur for well-typed programs.

The term rule-based program is meant to include definite clause programs, SOS specifications, attribute grammars, and conditional rewrite systems. These setups are widely used for the executable specification or implementation of language-based tools, e.g., interpreters, translators, type checkers, program analysers, and program transformations. We provide a pragmatic, transformation-based approach for expressing and tracking changes in rule-based programs in the course of program evolution. To this end, we design an operator suite for the transformation of rule-based programs. The operators facilitate steps for clean-up, refactoring, and enhancement. We use SOS-based interpreter examples to illustrate evolution of rule-based programs. We use logic programming to execute the examples, while the relevant evolution operators are made available as logic meta-programs.

This paper considers an integration of asynchronous communication, virtual binding, and multiple inheritance. Object orientation is the leading paradigm for concurrent and distributed systems, but the tightly synchronized RPC communication model seems unsatisfactory in the distributed setting. Asynchronous messages are better suited, but lack the structure and discipline of traditional object-oriented methods. The integration of messages in the object-oriented paradigm is unsettled, especially with respect to inheritance and redefinition. Asynchronous method calls have been proposed in the Creol language, reducing the cost of waiting for replies in the distributed environment while avoiding lowlevel synchronization constructs such as explicit signaling. A lack of reply to a method call need not lead to deadlock in the calling object. Creol has an operational semantics defined in rewriting logic. This paper considers a formal operational model of multiple inheritance, virtual binding, and asynchronous communication between concurrent objects, extending the semantics of Creol.

Object-orientation supports code reuse and incremental programming. Multiple inheritance increases the power of code reuse, but complicates the binding of method calls and thereby program analysis. Behavioral subtyping allows program analysis under an open world assumption; i.e., under the assumption that class hierarchies are extensible. However, method redefinition is severely restricted by behavioral subtyping, and multiple inheritance often leads to conflicting restrictions from independently designed superclasses. This report presents an approach to incremental reasoning for multiple inheritance under an open world assumption. The approach, based on a notion of lazy behavioral subtyping, is less restrictive than behavioral subtyping and fits well with multiple inheritance, as it incrementally imposes context-dependent behavioral constraints on new subclasses. We formalize the approach as a calculus, for which we show soundness.

In this work we study a semantics for the continuation of parallel activities: the automatic continuation. The principle of the automatic continuation was first introduced for Eiffel// model. In this article, we generalize and formalize the automatic continuation in an operational style. We propose two strategies for that. One of these strategies, more asynchronous (i.e. increase the degree of the asynchronism), is formally specified. Such a strategy allows to avoid some deadlock situations that we can qualify as excessive deadlocks. However it transforms some others into livelocks. Thus we give a technique permitting both to detect these situations and delay maximally the deadlock. This work is part of more ambitious project whose goal is the automatic (or semi-automatic) parallelization of object-oriented programs.

From an object-oriented programming perspective, an important class of aspects (in the sense of aspect-oriented programming) can be modelled via method call interception (MCI). This concept allows us to intercept transitions from a caller to a callee in a way that extra functionality can be superimposed on the actual method call. We describe fundamental language constructs for MCI. The style of Natural semantics is used to specify the meaning of the constructs. The semantical formulation (as opposed to a formulation based on program transformation) shows that static type safety and separate compilation can be preserved when MCI is added to an object-oriented language. 1.

Natural semantics specifications have become mainstream in the formal specification of programming language semantics during the last ten years. In this paper, we set up sorted natural semantics as a specification framework which is able to express static semantic information of programming languages declaratively in a uniform way and allows at the same time to generate corresponding analyses. Such static semantic information comprises context-sensitive properties which are checked in the semantic analysis phase of compilers as well as further static program analyses such as e.g. classical data and control flow analyses or type and effect systems. The latter require fixed point analyses to determine their solutions. We show that, given a sorted natural semantics specification, we can generate the corresponding analysis. Therefore, we classify the solution of such an analysis by the notion of a proof tree. We show that a proof tree can be computed by solving an equivalent residuation problem. In case of the semantic analysis, this solution can be found by a basic algorithm. We show that its efficiency can be enhanced using solution strategies. We also demonstrate our prototype implementation of the basic algorithm which proves its applicability in practical situations. With the results of this paper, we have established natural semantics as a framework which closes the gap between declarative and

We compare three specification frameworks for the operational semantics of programming languages, abstract state machines (ASMs) and the two incarnations of natural semantics, big-step and small-step semantics, with respect to two criteria: the range of imperative programming languages to which they are applicable and the way the program is used in the specifications and treated during the thereby defined execution. To reveal the fundamental differences between these three mechanisms, we investigate if there are automatic transformations between them. As a side effect, this leads to new insights concerning the classification of big-step and small-step semantics.

www.cwi.nl/˜paulk