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)?

  • $\begingroup$ 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. $\endgroup$
    – Gopi
    Nov 22, 2011 at 12:55
  • 1
    $\begingroup$ Look up 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. $\endgroup$ Nov 22, 2011 at 13:56

1 Answer 1


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. 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.
  • The numerous investigations into exceptions and exception handling, with a famous early publication being Randell's System Structure for Software Fault Tolerance. The literature on this subject is too large to survey.
  • Another strand of research is work on recovery oriented programming.
  • $\begingroup$ 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. $\endgroup$
    – jkff
    Nov 22, 2011 at 18:35
  • $\begingroup$ @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.) $\endgroup$ Nov 23, 2011 at 12:39

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.