The object-oriented programming language Java is receiving much attention and is likely to become a popular commercial programming language because of its regular structure, safety features and modern constructs. It presents a novel opportunity, because of this safety and potential popularity, to make orthogonal persistence defined by reachability widely available. We report on a design for a system that provides such persistence with no changes to the Java language. The design includes ambitious goals for transactional flexibility but also includes simple transactional behaviour sufficient for many applications. We report on several issues that were encountered during the design which as yet have no obvious solution. An outline of the proposed implementation is also given.

A transaction defines a locus of computation that satisfies important concurrency and failure properties; these so-called ACID properties provide strong serialization guarantees that allow us to reason about concurrent and distributed programs in terms of higher-level units of computation (e.g., transactions) rather than lower-level data structures (e.g., mutual-exclusion locks). This paper presents a framework for specifying the semantics of a transactional facility integrated within a host programming language. The TFJ calculus supports nested and multi-threaded transactions. We give a semantics to TFJ that is parameterized by the definition of the transactional mechanism that permits the study of different transaction models.

Abstract. A transaction defines a locus of computation that satisfies important concurrency and failure properties. These so-called ACID properties provide strong serialization guarantees that allow us to reason about concurrent and distributed programs in terms of higher-level units of computation (e.g., transactions) rather than lower-level data structures (e.g., mutual-exclusion locks). This paper presents a framework for specifying the semantics of a transactional facility integrated within a host programming language. The TFJ calculus, an object calculus derived from Featherweight Java, supports nested and multi-threaded transactions. We give a semantics to TFJ that is parameterized by the definition of the transactional mechanism that permits the study of different transaction models. We give two instantiations: one that defines transactions in terms of a versioning-based optimistic concurrency model, and the other which specifies transactions in terms of a pessimistic two-phase locking protocol, and present soundness and serializability properties for our semantics. 1

We present a design and implementation of transactions and general-purpose persistence for Java. These additions allow Java programmers to manipulate any Java object using transactions and provide resilience from machine failure for these objects. This extends the range of Java applicability into domains where reliability is of paramount concern; for example, network-based banking. Our design and implementation is a significant addition to Java. It extends Java's current emphasis on safety and reliability to the safe and consistent management of permanent state. Our additions take the form of syntactic extensions for transactions and runtime system support for durability and atomicity. Support for general-purpose persistence, the ability to arbitrary kinds of objects persistent, is a key aspect of the design. We provide orthogonal persistence, in which any object can be made persistent, without regard to type. We also provide persistence-by-reachability, in which an object becomes pe...

Abstract. There has been significant recent interest in exploring the role of coordination languages as middleware for distributed systems. These languages provide operations that allow processes to dynamically and atomically access and manipulate collections of shared data. The need to impose discipline on the manner in which these operations occur becomes paramount if we wish to reason about correctness in the presence of increased program complexity. Transactions provide strong serialization guarantees that allow us to reason about programs in terms of higher-level units of abstraction rather than lower-level data structures. In this paper, we explore the role of an optimistic transactional facility for a Linda-like coordination language. We provide a semantics for a transactional coordination calculus and state a soundness result for this semantics. Our use of an optimistic concurrency protocol distinguishes this work from previous efforts such as Javaspaces, and enables scalable, deadlock-free implementations. 1

One of the important tasks of exception handling is to restore program state and invariants. Studies suggest that this is often done incorrectly. We introduce a new language construct that integrates automated memory recovery with exception handling. When an exception occurs, memory can be automatically restored to its previous state. We also provide a mechanism for applications to extend the automatic recovery mechanism with callbacks for restoring the state of external resources. We describe a logging-based implementation and evaluate its effect on performance. The implementation imposes no overhead on parts of the code that do not make use of this feature.

The chief aim of this survey is to discuss exception handling models which have been developed for concurrent object systems. In conducting this discussion we rely on the following fundamental principles: exception handling should be associated with structuring techniques; concurrent systems require exception handling which is different from that used in sequential systems; concurrent systems are best structured out of (nested) actions; atomicity of actions is crucial for developing complex systems. In this survey we adhere to the wellknown classification of concurrent systems, developed in the 70s by C.A.R. Hoare, J.J. Horning and B. Randell, into cooperative, competitive and disjoint ones. Competitive systems are structured using atomic transactions. Atomic actions are used for structuring cooperative systems. Complex systems in which components can compete and cooperate are structured using Coordinated Atomic actions. The focus of the survey is on outlining models and schemes which combine these action-based structuring approaches with exception handling. In conclusion we emphasise that exception handling models should be adequate to the system development paradigm and structuring approaches used.

In this paper we design a language and runtime support for isolation-only, multithreaded transactions (called tasks). Tasks allow isolation to be declared instead of having to be encoded using the low-level synchronization constructs. The key concept of our design is the use of a type system to support rollback-free and safe runtime execution of tasks. We present a first-order type system which can verify information for the concurrency controller. We use an operational semantics to formalize and prove the type soundness result and an isolation property of tasks. The semantics uses a specialized concurrency control algorithm, that is based on access versioning.

... This paper introduces the pik-calculus and the pike-calculus, kernel programming languages for fault-tolerant distributed programming. The calculi incorporate various abstractions for fault tolerance, from which several forms of distributed transactions and optimistic computation may be built. As an example application, a calculus of atomic failures is presented, the atf-calculus, and its encoding in the pik-calculus used to verify a correctness property. The pik-

Applications are increasingly being developed over the Internet, and Internet programming languages seek new abstractions for programming what is in effect a "global computer." The characteristics of the evolving Internet environment have led to new ways of thinking about how to structure such global applications. We advocate a programming language approach to building Internet applications that reflects this change in viewpoint. This approach has a particular emphasis on the demands of fault-tolerant applications, while being centrally concerned with safeguarding security.