Fault-tolerant programming languages / paradigms? 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)?
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.