As people are becoming increasingly dependent on computerized systems,
%from life critical systems to long-running scientific computations,
the need for these systems to be dependable is also increasing.
However,
programming dependable systems is diffcult,
especially when parallelism is involved.
This is due 
in part to the fact that very few high-level programming languages support
both fault-tolerance and parallel programming. 

This dissertation addresses this problem by presenting
FT-Linda, a high-level language for programming
fault-tolerant parallel programs.
FT-Linda is based on Linda,
a language for programming parallel applications whose most 
notable feature is a distributed shared memory called tuple space.
FT-Linda extends Linda by providing support 
to allow a program to 
%make progress in the face of 
tolerate 
failures in the underlying computing platform.
The distinguishing features of FT-Linda are stable tuple spaces
and atomic execution of multiple tuple space operations.
The former is a type of stable storage in which tuple values
are guaranteed to persist across failures, while the latter allows 
collections of tuple operations to be executed in an all-or-nothing 
fashion despite failures and concurrency.
Example FT-Linda programs are given for both dependable
systems and parallel applications.

The design and implementation of FT-Linda are presented in detail.
The key technique used is
the replicated state machine approach
to constructing fault-tolerant distributed programs.
Here, tuple space is replicated to provide failure resilience,
and the replicas are sent a message describing the 
atomic sequence of tuple space operations to perform.
This strategy allows an efficient implementation in which only a
single multicast message is needed for each atomic sequence of
tuple space operations.

An implementation of FT-Linda for a network of workstations is also 
described.
FT-Linda is being implemented using Consul,
a communication substrate that supports fault-tolerant distributed
programming.
Consul is built in turn with the {\it x}-kernel,
an operating system kernel that provides support for composing
network protocols.
Each of the components of the implementation has been built and tested.