Jay Nelson, in the comments to Damien Katz’s Lisp as Blub:
The two relevant issues are system granularity and garbage collector behavior (if it is related to memory and garbage collection).
Erlang encourages an architecture of many small-granularity processes. To the extent that this approach is followed, failures are localized. It is possible to do this with other languages, but erlang does encourage the approach more so than other languages.
The other difference is that erlang uses a single-threaded garbage collector per process. This makes the garbage collection process simpler, more finely grained and distributed. Smaller processes mean less complicated memory structures, and thus the language encourages a simpler model with localized garbage collection failure. Determining the cause of overburdened memory usage (or any other resource because of the localized nature of small processes) becomes easier.
An erlang system can get wedged, but following the principle of many small processes makes it less likely to happen than in other languages which encourage large processes with shared memory structures.
It strikes me that this is a sort of CGI’ish view of the world (well except for the garbage collector). CGI scripts run, use (non-shared) resources, release them all and die. The entire post and comment thread is worth some pondering.
As much as it’s shared nothing, CGI has something in common with Erlang processes, but Erlang processes don’t have to perform one operation and then die and they can communicate with each other, so there’s a lot that to the Erlang model that’s not even close to the CGI model.
But it is true that that they share(!) the shared-nothing increases in isolation-based reliability.
Pingback: JavaOne 2008: Part 2 at Ted Leung on the Air