Virtual machines (vms) have enjoyed a resurgence as a way of allowing the same application program to be used across a range of computer systems. This flexibility comes from the abstraction that the vm provides over the native interface of a particular computer. However, this also means that the application is prevented from taking the features of particular physical machines into account in its implementation. This dissertation addresses the question of why, where and how it is useful, possible and practicable to provide an application with access to lower-level interfaces. It argues that many aspects of vm implementation can be devolved safely to untrusted applications and demonstrates this through a prototype which allows control over run-time compilation, object placement within the heap and thread scheduling. The proposed architecture separates these application-specific policy implementations from the application itself. This allows one application to be used with different policies on different systems and also allows nave or premature optimizations to be removed.

We present an operational semantics and type safety proof for multiple inheritance in C++. The semantics models the behavior of method calls, field accesses, and two forms of casts in C++ class hierarchies exactly, and the type safety proof was formalized and machine-checked in Isabelle/HOL. Our semantics enables one, for the first time, to understand the behavior of operations on C++ class hierarchies without referring to implementation-level artifacts such as virtual function tables. Moreover, it can—as the semantics is executable—act as a reference for compilers, and it can form the basis for more advanced correctness proofs of, e.g., automated program transformations. The paper presents the semantics and type safety proof, and a discussion of the many subtleties that we encountered in modeling the intricate multiple inheritance model of C++.

Abstract. In this paper we briefly present some solution strategies for situations in which it is necessary to transform multiple inheritance schemes into single inheritance or non-inheritance “equivalent ” schemes. The strategies are divided into basic strategies and combined strategies. The mechanisms presented are comparatively analyzed in the light of some ideal characteristics to be accomplished by hierarchy transformation strategies. 1

The presence of Multiple Inheritance in a language raises subtle problems related to possible ambiguities. To avoid handling these difficulties, many languages, including Java, do not support multiple inheritance.

Object based, imperative languages with delegation (eg SELF) support exploratory programming: composition of objects, sharing of attributes and modification of objects' behaviour at run-time are easily expressible.

We present an extension for a Java like language with a mechanism for dynamically extending object behaviors. Our approach consists in moving the addition of new features from class (static) level to object (dynamic) level: the basic features of entities (representing their structure) are separated from the additional ones (wrapper classes whose instances represent run-time added behaviors). At run-time, these entities can be dynamically composed by instantiating wrapper objects which are attached to basic entities. We formalize our extension by adding the new constructs to Featherweight Java; the core language so extended (Featherweight Wrap Java) is type safe.

While there exists a fair number of partial solutions to enabling dynamic updating in arbitrary applications, none of them have proved to be superior. This paper does not suggest "yet another " dynamic updating system that no one will use in the end anyway. Instead, we dig deep into the heart of software development, and examine what dynamic updating and static evolution is all about. We identify bottle necks and sources of complications, and come up with suggestions as to how these can be fundamentally solved. We present two novel concepts that could improve the updatability and adaptability of applications; the sequence model for dealing with code, and entity-oriented programming for dealing with data and object-orientation. In order to demonstrate these, as well as tie in even more improvements for updatability and general programming flexibility, we introduce an updatable programming language. Some of the previous work in the field has developed dynamic updating systems by refining some existing programming language. Our approach is not just "our own " implementation of such an approach. Our approach is different and novel, because it constructs the whole programming language from ground up based on updatability demands. To ensure that this language is useful enough, we make it superficially look like popular object-oriented languages. This paper is a revision of the Master's thesis "Rethinking Software Updating; Concepts for Improved Updatability".

been issued as a Research Report for early dissemination of its contents. In view of the transfer of copyright to the outside publisher, its distribution outside of IBM prior to publication should be limited to peer communications and specific requests. After outside publication, requests should be filled only by reprints or legally obtained copies of the article (e.g., payment of royalties). Copies may be requested from IBM T. J. Watson Research Center, P.

This work has been partially supported by the MIUR project EOS-DUE. We present a language extension, which integrates in a Java like language a mechanism for dynamically extending object behaviors without changing their type. Our approach consists in moving the addition of new features from class (static) level to object (dynamic) level: the basic features of entities (representing their structure) are separated from the additional ones (wrapper classes whose instances represent run-time added behaviors). At run-time, these entities can be dynamically composed by instantiating wrapper objects which are attached to basic entities. Wrappers permit specializing (wrapping) methods at run-time: the method of the wrapper will be automatically executed after the method of the wrapped objects, using a delegation mechanism. Furthermore, wrapped methods can return values and values returned by the wrapped methods are transparently made available in the wrapper methods. We formalize our extension by adding the new constructs to Featherweight Java and we prove that the core language so extended (Featherweight Wrap Java) is type safe. 1

CentiJ is a software synthesis system that, until recently, used synchronous, semiautomatic static proxy delegation to help in the automation of the creation of distributed Java programs on NOWS (Networks of Workstations). This paper reports our recent extension to CentiJ so that invocations are asynchronous. Further, we have achieved transparency with respect to local vs. non-local asynchronous invocations so that software can be properly tested in a local mode.