Distributed programming in Argus

  title={Distributed programming in Argus},
  author={Barbara H. Liskov},
  journal={Commun. ACM},
  • B. Liskov
  • Published 1 March 1988
  • Computer Science
  • Commun. ACM
Argus—a programming language and system developed to support the implementation and execution of distributed programs—provides mechanisms that help programmers cope with the special problems that arise in distributed programs, such as network partitions and crashes of remote nodes. 

Figures and Tables from this paper

Combining tasking and transaction

This position paper discusses the issues in design and development of a transaction support for Ada 95 and possible ways of integration are presented, and implementation problems are discussed.

Object-Oriented Distributed Programming in BETA

This paper describes abstractions that have been designed to support distributed programming in the object oriented programming language BETA by demanding for type orthogonal persistence and distribution.

PANDA - Supporting Distributed Programming in C++

The paper discusses the design rationales underlying the PANDA system, and the fundamental features of PANDA are surveyed, and their implementation in the current prototype environment is outlined.

RPC-level support for object-oriented distributed programming

The design of an RPC system for building object-oriented distributed software systems to provide mechanisms for supporting use of inheritance, polymorphism, dynamic binding, and modular development in implementing distributed softwareSystems.

Preventing recursion deadlock in concurrent object-oriented systems

Two language-independent, system-level mechanisms are proposed: a novel technique using multi-ported objects, and a named-threads scheme that borrows from previous work in distributed computing.

Design of a Remote Procedure Call System for Object-Oriented Distributed Programming

The functionalities of this RPC system to support mechanisms for supporting inheritance, polymorphism, dynamic binding, and modular development in implementing distributed software systems are presented.

The PANDA system architecture-a pico-kernel approach

The goal of PANDA is to provide an environment for parallel and distributed programming in C++ that consists of a small operating system kernel, and a runtime package located in user space.

An Orthogonal Distribution Language for Uniform Object-Oriented Languages

On one side the complexity of the design of distributed application systems is usually reduced significantly by using a distributed programming model that abstracts from the actual distribution and

ABC-a new approach to distributed programming

  • D. CohnA. Banerji
  • Computer Science
    [1991] Proceedings The Fifteenth Annual International Computer Software & Applications Conference
  • 1991
The new model, realized as ARCADE-Based C, or ABC, extends C to include the creation and invocation of remote functions; blocking/nonblocking function calls, and distributed shared variables.

Promises: linguistic support for efficient asynchronous procedure calls in distributed systems

A new data type called a promise is described that was designed to support asynchronous calls that allow a caller to run in parallel with a call and to pick up the results of the call, including any exceptions it raises, in a convenient and type-safe manner.



Guardians and Actions: Linguistic Support for Robust, Distributed Programs

The language addresses the writing of robust programs that survive hardware failures without loss of distributed information and that provide highly concurrent access to that information while preserving its consistency.

Avalon : language support for reliable distributed systems

This paper presents an overview of the novel aspects of Avalon/C++: support for testing transaction serialization orders at run-time, and user-defined, but system-invoked, transaction commit and abort operations for atomic data objects.

Rationale for the design of the Ada programming language

This book discusses classical programming, general program structure - visibility and overloading, and representation classes and machine dependences in the context of knowledge representation.

Crash Recovery in a Distributed Data Storage System

An algorithm is described which guarantees reliable storage of data in a distributed system, even when different portions of the data base, stored on separate machines, are updated as part of a


Argus is an experimental language/system designed to support the construction and execution of distributed programs that make use of on-line data that must remain consistent in spite of concurrency and hardware failures, and provide services under real-time constraints that are not severe.

Implementation of resilient, atomic data types

This work defines what it means for abstract data types to be atomic and resilient, and discusses issues that arise in implementing such types, and describes a particular linguistic mechanism provided in the Argus programming language.

Nested Transactions: An Approach to Reliable Distributed Computing

The method for implementing nested transactions is novel in that it uses locking for concurrency control and the necessary algorithms for locking, recovery, distributed commitment, and distributed deadlock detection for a nested transaction system are presented.

Abstraction mechanisms in CLU

This paper provides an introduction to the abstraction mechanisms in CLU and illustrates the utility of the three kinds of abstractions in program construction and shows how CLU programs may be written to use and implement abstractions.

Camelot : a distributed transaction facility for mach and the internet - an interim report

A number of latency experiments are reported on to show the overhead of Camelot Release 0.4(22) and should not be interpreted as representing the official policies, either expressed or implied, of any of the sponsoring agencies or the United States government.

Notes on Data Base Operating Systems

  • J. Gray
  • Computer Science
    Advanced Course: Operating Systems
  • 1978
This paper is a compendium of data base management operating systems folklore and focuses on particular issues unique to the transaction management component especially locking and recovery.