As people are increasingly dependent on computers,
from life critical systems to 
long-running parallel scientific computations,
the need for such systems to be dependable increases.
However,
programming such dependable systems is diffcult,
especially when parallelism is invovled.
This is due partly to a lack of support for both fault-tolerance
and parallel programming in high-level languages.

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 failures in some of 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.

The design and implementation of FT-Linda is presented in detail.
It is based on the replicated state machine approach,
where 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 collection of
tuple space operations.
Example FT-Linda programs are given for both dependable
systems and parallel applications.

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