FT Languages Home Page

The University of Arizona, Computer Science Department
Research Projects

The fault-tolerant languages projects aim at enhanced programming language support for distributed programs that have fault-tolerance requirements. Most current high-level programming languages lack adequate support for constructing fault-tolerant distributed programs, especially at the systems level. The three specific projects, FT-SR, FT-Linda, and FTAG, were aimed at improving this situation.

  • FT-SR: is a concurrent programming language that supports fault tolerance. FT-SR is based on the SR concurrent programming language. FT-SR is unique in that it has been designed to support equally well any of the programming paradigms that have been developed for fault-tolerant distributed systems, including the object/action model, the restartable action paradigm, and the replicated state machine approach. To do this, the language is designed to support the implementation of systems modeled as collections of fail-stop atomic objects. Such objects execute operations as atomic actions except when a failure or series of failures cause underlying implementation assumptions to be violated; in this case, notification is provided. Specific language features include provisions for encapsulation based on SR resources, resource replication, recovery protocols, synchronous failure notification when performing interprocess communication, and a mechanism for asynchronous failure notification. An x-kernel based prototype running on a network of Sun 3 workstations was implemented and tested.

  • FT-Linda: The second language-oriented effort investigated the use of more non-traditional languages and notations for performing fault-tolerant distributed programming. One part of our work in this area concentrated on extending the well-known Linda coordination language to facilitate programming of fault-tolerant parallel applications. Key features include:

    • A guarded atomic statement to allow multiple tuple space operations to be executed atomically.

    • Provisions for multiple tuple spaces, including shared stable tuple spaces that are resilient to failures.

    • Move and copy primitives to transfer tuples between tuple spaces.

    • The system design is based on using ordered atomic multicast in the runtime system, a strategy that allows efficient implementation of stable tuple spaces as replicated state machines.

  • FTAG: A second line of language work concerned the use of non-imperative programming models for fault tolerance, in particular, development of a functional and attribute based model called FTAG. This model offers several advantages when compared with imperative languages, including a declarative style, separation of semantic and syntactic definitions, and the simplicity of a functional foundation. While important for any type of programming, these advantages are especially pronounced for writing fault-tolerant programs that involve the use of state rollback.

Project Members
  • Richard Schlichting, Professor

  • Vic Thomas, PhD Student, currently at Honeywell Research Center

  • David Bakken, PhD Student, currently at BBN

  • M. Suzuki

  • T. Katayama


This research was supported by the National Science Foundation (NSF) and the Office of Naval Research (ONR).

back to Cactus home page

Last updated March 2, 1998
Richard D. Schlichting (rick@cs.arizona.edu)