Language runtime systems are increasingly being embedded in systems to support runtime extensibility via mobile code. Such systems raise a number of concerns when the code running in such systems is potentially buggy or untrusted. While sophisticated access controls have been designed for mobile code and are shipping as part of commercial systems such as Java, there is no support for terminating mobile code short of terminating the entire language runtime. This paper presents a concept called “soft termination ” which can be applied to virtually any mobile code system. Soft termination allows mobile code threads to be safely terminated while preserving the stability of the language runtime. In addition, function bodies can be permanently disabled, thwarting attacks predicated on system threads eventually calling untrusted functions. We present a formal design for soft termination and an implementation of it for Java, built using Java bytecode rewriting, and demonstrating reasonable performance (3-25% slowdowns on benchmarks).

The experience of applying the principles of orthogonal persistence to the Java programming language is described in the context of the PJama prototype implementation. The model for checkpointing the state of a computation, including live threads, is analyzed and related to a transactional approach. The problem of dealing with state that is external to the PJama environment is explained and the solutions outlined. The difficult problem of system evolution is identified as the major barrier to deploying orthogonal persistence for the Java language.

The PerDiS (Persistent Distributed Store) project addresses the issue of providing support for distributed collaborative engineering applications. We describe the design and implementation of the PerDiS platform, and its support for such applications. Collaborative engineering raises system issues related to the sharing of large volumes of ne-grain, complex objects across wide-area networks and administrative boundaries. PerDiS manages all these aspects in a well dened, integrated, and automatic way. Distributed application programming is simplied because it uses the same memory abstraction as in the centralized case. Porting an existing centralized program written in C or C++ is usually a matter of a few, well-isolated changes. We present some performance results from a proof-of-concept platform that runs a number of small, but real, distributed applications on Unix ? This work was supported by Esprit under the PerDiS project (n o 22533), http://www.perdis.esprit.ec...

Several techniques have been proposed for adding persistence to the Java language environment. This paper

The design and implementation of the initial release of class evolution technology for PJama persistent language is described. This technology supports modifications to individual classes, class hierarchy, and user-defined conversion of data contained in class instances when a modification to this class leads to the change of instance format. PJama evolution technology was evaluated on an application of considerable size and proved to be very helpful for a PJama programmer. 1 Introduction In this paper we report on the issues raised when investigating the ways of and developing the mechanisms for class evolution in PJama. The PJama project, a collaboration between Sun Microsystems Laboratories and the University of Glasgow, is building an orthogonally persistent platform for Java [1, 2]. PJama is the implementation of the programming language Java with mechanisms embedded into the runtime system that support indefinite lifetimes for a program's data. In fact, not all the data of some...

We present the object-oriented multi-tier application framework OMS Java which is independent of the underlying database management system (DBMS). We detail the storage management component and sketch which part of the framework has to be extended when introducing a new DBMS. We compare versions of OMS Java using the persistent storage engine ObjectStore PSE Pro for Java, the object-oriented DBMS Objectivity/DB, the objectrelational DBMS Oracle and the proprietary DBMS Berkley DB. 1 Introduction Most applications create data that extends the life of an application process making it necessary that application objects can be stored in and retrieved from non-volatile storage. Furthermore, looking at pure object-oriented applications, i.e. applications developed entirely using an objectoriented language environment such as Java [KA96], application objects typically refer to many other application objects resulting in complex object hierarchies. It is therefore crucial to find mechan...

A metasystem allows seamless access to a collection of distributed computational resources. It is desirable to access metasystem services as easily as they are accessed in a single computer. Checkpointing is one of these services, which is a potentially important feature in high throughput computing, especially for process migration and recovery after system crash. This article describes the experiences and preliminary results on incorporating checkpointing and recovery facilities in a Javabased metasystem. Our case study is suma, a metasystem for execution of Java bytecode, with additional support for scientic computing.

. Persistent programming offers the prospect of seamless integration of programs with long-lived data, offering the prospect of constructing systems that allow more rapid program development, and also simplifying the process of writing applications whose purpose is to handle long-lived data. While there have been some previous attempts to produce persistent functional languages, the majority of these have been interpreted, and performance has generally been seriously compromised. It has therefore become something of a shibboleth that persistence cannot be implemented efficiently in a purely functional language. This paper offers the first systematic study of this claim. This paper describes the first-ever implementation of orthogonal persistence for a compiled purely functional language, based on an existing St Andrews persistent object store. Preliminary performance results show that it is possible to implement orthogonal persistence efficiently and there is hope that the result is mo...

This paper describes PJRMI: support for remote method invocation in the context of the object-oriented, orthogonally-persistent system of the PJama project. It examines the issues raised by combining orthogonal persistence with distribution. An evaluation is made of the current implementation and an indication is made of the challenges ahead. 1. Introduction Remote method invocation (RMI) is the object-oriented equivalent of RPC, the well-known procedural model of inter-process communication [5]. Java RMI is an example of an RMI implementation [18]. It supports the calling of a method of an object instantiated in one Java Virtual Machine (JVM), from the code of another object, instantiated in a different JVM. The two JVMs involved in the call may be on the same or on different host machines. The PJama project has developed an implementation of orthogonal persistence for Java [3, 10]. It supports persistence of objects by reachability and automates the propagation of new and updated ...

This paper describes why Object-Serialization is not appropriate for providing persistence in Java. With numerous code examples, Object-Serialization is shown to be easy to work with initially which seduces the developer into relying on it for persistence within more complex applications. The advanced use of object-serialization requires significant work from the programmer, something that is not apparent at first. The use of object-serialization together with static and transient fields and within multi-threaded programs is discussed together with the “big inhale problem”: the need to read in the entire object graph before processing over it can commence. The complexity of using object-serialization within a distributed environment, when evolving classes and when using specialised classloaders is also discussed. The paper compares the performance of serializing and deserializing a byte array and binary tree of the same data size to and from an NFS mounted disk and two kinds of local disk. Alternative solutions to object-persistence in Java are presented at the end of the paper. 1