FRIENDS - A flexible architecture for implementing fault tolerant and secure distributed applications

FRIENDS is a software-based architecture for implementing fault-tolerant and, to some extent, secure applications. This architecture is composed of sub-systems and libraries of metaobjects. Transparency and separation of concerns is provided not only to the application programmer but also to the programmers implementing metaobjects for fault tolerance, secure communication and distribution. Common services required for implementing metaobjects are provided by the sub-systems. Metaobjects are implemented using object-oriented techniques and can be reused and customised according to the application needs, the operational environment and its related fault assumptions. Flexibility is increased by a recursive use of metaobjects. Examples and experiments are also described

Implementing fault tolerant applications using reflective object-oriented programming

Abstract: Shows how reflection and object-oriented programming can be used to ease the implementation of classical fault tolerance mechanisms in distributed applications. When the underlying runtime system does not provide fault tolerance transparently, classical approaches to implementing fault tolerance mechanisms often imply mixing functional programming with non-functional programming (e.g. error processing mechanisms). The use of reflection improves the transparency of fault tolerance mechanisms to the programmer and more generally provides a clearer separation between functional and non-functional programming. The implementations of some classical replication techniques using a reflective approach are presented in detail and illustrated by several examples, which have been prototyped on a network of Unix workstations. Lessons learnt from our experiments are drawn and future work is discussed

MELDing Multiple Granularities of Parallelism

We are developing an experimental programming language, MELD, that supports a range of concurrent styles by supporting multiple programming paradigms at multiple levels of granularity. MELD integrates three granularities of parallelism: macro dataflow among statements within a method or among methods for fine grain concurrency, synchronous or asynchronous message passing among local or remote objects for medium grain concurrency, and transactions for large grain concurrency among users

Object-Oriented Programming Language Facilities for Concurrency Control

Concurrent object-oriented programming systems require support for concurrency control, to enforce consistent commitment of changes and to support program-initiated rollback after application-specific failures. We have explored three different concurrency control models -- atomic blocks, serializable transactions, and commit-serializable transactions -- as part of the MELD programming language. We present our designs, discuss certain programming problems and implementation issues, and compare our work on MELD to other concurrent object-based systems

An Object Model for Shared Data

The classical object model supports private data within objects and clean interfaces among objects, and by definition does not permit sharing of data among arbitrary objects. This is a problem for certain real-world applications, where the same data logically belongs 10 multiple objects and may be distributed over multiple nodes on the network. Rather than give up the advantages of encapsulated objects in modeling real-world entities, we propose a new object model that supports shared data in a distributed environment. The key is separating distribution of computation units from information hiding concerns. We introduce our new object model, describe a motivating example from the financial services domain, and then present a new language, PROFIT, based on the model

An Abort Mechanism for Nested Distributed Transactions

A transaction processing facility must have a mechanism for aborting transactions on request. This paper describes a mechanism for aborting transactions that can be arbitrarily nested and/or distributed. The mechanism consists of an "abort protocol" plus an adjustment to the commit protocol. The abort protocol locates and terminates as many of the transaction's operations as it can. If after the protocol has finished it is still possible that orphaned operations exist, then a simple check during the prepare phase of the commit protocol ensures that no orphan commits. The mechanism has many advantages: provided that the communication subsystem provides prompt failure detection, there will be no orphans: a site can abort unilaterally: there is little overhead on transaction-operation messages, and relatively few and relatively minor restrictions on the transaction facility: no information need be maintained in stable storage: and the abort protocol never blocks. The primary disadvantages of the mechanism are that the abort protocol must be synchronous, that it may over-abort in some cases, and that - if the communication subsystem does not provide prompt failure detection - there is no limit on the extent or lifetime of orphaned computations

An Equational Theory for Transactions

Transactions are commonly described as being ACID: All-or-nothing, Consistent, Isolated and Durable. However, although these words convey a powerful intuition, the ACID properties have never been given a precise semantics in a way that disentangles each property from the others. Among the benefits of such a semantics would be the ability to trade-off the value of a property against the cost of its implementation. This paper gives a sound equational semantics for the transaction properties. We define three categories of actions, A-actions, I-actions and D-actions, while we view Consistency as an induction rule that enables us to derive system-wide consistency from local consistency. The three kinds of action can be nested, leading to different forms of transactions, each with a well-defined semantics. Conventional transactions are obtained as ADI-actions. >From the equational semantics we develop a formal proof principle for transactional programs, from which we derive the induction rule for Consistency

Effective information sharing using update logs

Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1996.Includes bibliographical references (leaves 80-88).by James William O'Toole, Jr.Ph.D

New Inheritance Models That Facilitate Source Code Reuse in Object-oriented Programming

Code reusability is a primary objective in the development of software systems. The object-oriented programming methodology is one of the areas that facilitate the development of software systems by allowing and promoting code reuse and modular designs. Object-oriented programming languages (OOPLs) provide different facilities to attain efficient reuse and reliable extension of existing software components. Inheritance is an important language feature that is conducive to reusability and extensibility. Various OOPLs provide different inheritance models based on different interpretations of the inheritance notion. Therefore, OOPLs have different characteristics derived from their respective inheritance models. This dissertation is concerned with solutions for three major problems that limit the utilization of inheritance for code reusability. The range of object -oriented applications and thus the usage of object-oriented programming in general is also discussed. The three major problems are: 1) the relationship between inheritance and other related issues such as encapsulation, access techniques, visibility of inheritance, and subtyping; 2) the hierarchical structure imposed by inheritance among classes; and 3) the accessibility of previous versions of the modified methods defmed in classes located at higher levels of the inheritance structure than the parent classes. 1be proposed solutions for these problems are presented as new inheritance models that facilitate code reuse and relax the restrictions imposed on inheritance models by languages. A survey and taxonomy of the conventional inheritance models, and a comparison and analysis of some of the common OOPLs are also presented in the dissertation.Computer Scienc