<p>A good place to start looking for work coming from the PL community could be the following.</p>

<ul>
<li>Joe Armstrong's work on Erlang, see e.g. his <a href="http://www.erlang.org/download/armstrong_thesis_2003.pdf">PhD thesis</a>. This work continues to have a profound influence on programming language design, with Scala's integration of the Akka stack being a recent example. </li>
<li>David Walker and his group's <a href="http://www.cs.princeton.edu/~dpw/research_topics.htm#Zap">work on fault tolerance</a>.</li>
<li>The numerous investigations into exceptions and exception handling, with a famous early publication being Randell's <a href="http://www.cs.ncl.ac.uk/publications/inproceedings/papers/341.pdf">System Structure for Software Fault Tolerance</a>. The literature on this subject is too large to survey.</li>
<li>Another strand of research is work on <a href="http://roc.cs.berkeley.edu/">recovery oriented programming</a>.</li>
</ul>

CC BY-SA 3.0
2011-11-22T18:35:59.077Z
Thanks - I actually came across ROC a while ago, but I was a little bit disappointed by what I found - it was basically a set of advice on overall system design rather than an attempt to build a new computing paradigm. I'll look at your other links later, I'm sure there'll be something interesting there.
jkff
CC BY-SA 3.0
2011-11-23T12:39:23.310Z
@jkff. It is possible to use typing  system or compile-time meta-programming to support ROC. This has not been done to the best of my knowledge, but could be. More substantially, it might be the case that fault-tolerance is very problem specific, and there's little general structure to fault-tolerance that could/should be baked into programming languages. (See for example the ongoing debate whether exceptions are a good thing or not.)
Martin Berger
CC BY-SA 3.0
2011-11-22T16:40:44.747Z
2011-11-22T16:47:14.363Z
2011-11-22T16:47:14.363Z
Martin Berger
<p>I've been passively thinking for a long time, what could be the foundation for programming systems that can tolerate their own and other systems' bugs (not even speaking of environmental conditions such as hardware errors).</p>

<p>The thing is, I don't believe that it's possible to eradicate programming errors, and the fabric of current programming languages and systems is too brittle - a system can completely stop operating because of an off-by-one-error or a race condition (or a distributed race condition between several systems), which seems stupid if you think about it - we don't see the universe halt because of an explosion somewhere, or a society halt because of a typo in a law.</p>

<p>Therefore, it seems to me that type systems, formal verification are <em>not</em> the way to go - they merely protect the brittle systems instead of making them robust. Neither are fault-tolerant distributed protocols, since they assume that at least the protocol is implemented perfectly correctly, and that participants aren't making the same error.</p>

<p>I wonder, what has the PL community invented so far in this area?</p>

<p>Is there hope for a solution, or is this problem equivalent to building "strong AI" (could be, since living systems recover from transient errors by having goals and employing intelligence)?</p>

CC BY-SA 3.0
2011-11-22T12:55:46.060Z
I don't know about the PL community, but there is a lot of work on fault-tolerance done by the algorithmic community, which is helped by the work on fault-detection from the hardware/software community.
Gopi
CC BY-SA 3.0
2011-11-22T13:56:25.833Z
Look up http://en.wikipedia.org/wiki/Deontic_logic (Deontic logic).  This is what you need to speak about fault tolerance.  I don't think I have seen deontic logic used in any PL semantics.  Then look up the joint work of Tom Maibaum and Pablo Castro.
Jacques Carette
<reference-request><pl.programming-languages><fault-tolerance>
Fault-tolerant programming languages / paradigms?
jkff
# Fault-tolerant programming languages / paradigms?

(Asked by: username_0 on 2011-11-22)

I've been passively thinking for a long time, what could be the foundation for programming systems that can tolerate their own and other systems' bugs (not even speaking of environmental conditions such as hardware errors).

The thing is, I don't believe that it's possible to eradicate programming errors, and the fabric of current programming languages and systems is too brittle - a system can completely stop operating because of an off-by-one-error or a race condition (or a distributed race condition between several systems), which seems stupid if you think about it - we don't see the universe halt because of an explosion somewhere, or a society halt because of a typo in a law.

Therefore, it seems to me that type systems, formal verification are *not* the way to go - they merely protect the brittle systems instead of making them robust. Neither are fault-tolerant distributed protocols, since they assume that at least the protocol is implemented perfectly correctly, and that participants aren't making the same error.

I wonder, what has the PL community invented so far in this area?

Is there hope for a solution, or is this problem equivalent to building "strong AI" (could be, since living systems recover from transient errors by having goals and employing intelligence)?

**Tags:** reference-request, pl.programming-languages, fault-tolerance
> **Comments:**
> **username_1**: I don't know about the PL community, but there is a lot of work on fault-tolerance done by the algorithmic community, which is helped by the work on fault-detection from the hardware/software community.  
> **username_2**: Look up http://en.wikipedia.org/wiki/Deontic_logic (Deontic logic).  This is what you need to speak about fault tolerance.  I don't think I have seen deontic logic used in any PL semantics.  Then look up the joint work of Tom Maibaum and Pablo Castro.  

---

## 1 answers

### Answer by username_3 on 2011-11-22. Score: 10 | Accepted answer

A good place to start looking for work coming from the PL community could be the following.

* Joe Armstrong's work on Erlang, see e.g. his [PhD thesis](http://www.erlang.org/download/armstrong_thesis_2003.pdf). This work continues to have a profound influence on programming language design, with Scala's integration of the Akka stack being a recent example.
* David Walker and his group's [work on fault tolerance](http://www.cs.princeton.edu/~dpw/research_topics.htm#Zap).
* The numerous investigations into exceptions and exception handling, with a famous early publication being Randell's [System Structure for Software Fault Tolerance](http://www.cs.ncl.ac.uk/publications/inproceedings/papers/341.pdf). The literature on this subject is too large to survey.
* Another strand of research is work on [recovery oriented programming](http://roc.cs.berkeley.edu/).

> **Comments:**
> **username_0**: Thanks - I actually came across ROC a while ago, but I was a little bit disappointed by what I found - it was basically a set of advice on overall system design rather than an attempt to build a new computing paradigm. I'll look at your other links later, I'm sure there'll be something interesting there.  
> **username_3**: @jkff. It is possible to use typing  system or compile-time meta-programming to support ROC. This has not been done to the best of my knowledge, but could be. More substantially, it might be the case that fault-tolerance is very problem specific, and there's little general structure to fault-tolerance that could/should be baked into programming languages. (See for example the ongoing debate whether exceptions are a good thing or not.)  

---

