Constructing reliable distributed applications using actions and objects

PhD ThesisA computation model for distributed systems which has found widespread acceptance is that of atomic actions (atomic transactions) controlling operations on persistent objects. Much current research work is oriented towards the design and implementation of distributed systems supporting such an object and action model. However, little work has been done to investigate the suitability of such a model for building reliable distributed systems. Atomic actions have many properties which are desirable when constructing reliable distributed applications, but these same properties can also prove to be obstructive. This thesis examines the suitability of atomic actions for building reliable distributed applications. Several new structuring techniques are proposed providing more flexibility than hitherto possible for building a large class of applications. The proposed new structuring techniques are: Serialising Actions, Top-Level Independent Actions, N-Level Independent Actions, Common Actions and Glued Actions. A new generic form of action is also proposed, the Coloured Actions, which provides more control over concurrency and recovery than traditional actions. It will be shown that Coloured Actions provide a uniform mechanism for implementing most of the new structuring techniques, and at the same time are no harder to implement than normal actions. Thus this proposal is of practical importance. The suitability of new structuring techniques will be demonstrated by considering a number of applications. It will be shown that the proposed techniques provide natural tools for composing distributed applications.Science and Engineering Research Council

The Design and Implementation of a Framework for Extensible Software

This paper describes a model for constructing extensible software based upon this separation, and illustrates this with a software development system we have implemented which supports these ideas in C++. This software development system has been designed so that no modifications are required to either the compiler or operating system, hence making it portable. 1 Introductio

The Design and Implementation of a Framework for Configurable Software

Software systems are typically composed of numerous components, each of which is responsible for a different function, e.g., one component may be responsible for remote communication, while another may provide a graphical user interface. Different implementations of a component may be possible, with each implementation tailored for a specific set of applications or environments. Being able to reconfigure software systems to make use of these different implementations with the minimum of effect on existing users and applications is desirable. Configurable software systems are also important for a number of other reasons: additional components or modifications to those currently available, may be required. For example, new versions of software components may be necessary due to the discovery of design flaws in a component; a RPC which provides unreliable message delivery may be suitable for an application in a local area network, but if the application is to be used in a wide area network, a different RPC implementation, which guarantees message delivery, may be necessary. Therefore, software is often required to be configurable, enabling modifications to occur with minimal effect on existing users. To allow this configurability, components should only be available through interfaces that are clearly separated from their implementations, allowing users to be isolated from any implementation changes. Objectoriented programming techniques offer a good basis upon which this separation can be provided. This paper describes a model for constructing configurable software based upon this separation, and illustrates this with a software development system we have implemented which supports these ideas in C++

The Design and Implementation of a Framework for Extensible Software, Broadcast Project Technical Report, University of Newcastle upon Tyne

Software systems are composed of numerous software components. These components could be developed as a part of the system, or provided by a separate software development environment (e.g., a library which provides a graphical user interface). However, over the lifetime of the software, additional components or modifications to those currently available, may be required. For example, new versions of software components may be necessary due to bug fixes. Therefore, software is often required to be extensible, enabling modifications to occur with minimal effect on existing users. To allow this extensibility, components should only be available through interfaces that are clearly separated from their implementations, allowing users to be isolated from any implementation changes. Object-oriented programming techniques offer a good basis upon which this separation can be provided. This paper describes a model for constructing extensible software based upon this separation, and illustrates this with a software development system we have implemented which supports these ideas in C++. This software development system has been designed so that no modifications are required to either the compiler or operating system, hence making it portable.

The Design and Implementation of Arjuna

ABSTRACT: Arjuna is an object-oriented programming system, implemented entirely in C++, that provides a set of tools for the construction of fault-tolerant distributed applications. Arjuna exploits features found in most object-oriented languages (such as inheritance) and requires only a limited set of system capabilities commonly found in conventional operating systems. Arjuna provides the programmer with classes that implement atomic transactions, object level recovery concurrency control and persistence. These facilities can be overridden by the programmer as the needs of the application dictate. Distribution of an Arjuna application is handled using stub generation techniques that operate on the original C++ class headers normally used by the standard compiler. The system is portable