Check out Akka for Scala/Java - http://akka.io/

I am genuinely puzzled why people embark on building systems which they intend to be massively scalable using languages which don't have a technology like Erlang/OTP or Akka to support distribution across multiple boxes.

This.

The fact that, as opposed to to Goroutines, Erlang processes can be transparently running on some other node is the most important difference.

In Go, channels can be between boxes, so a channel could be used to trigger or communicate with Go code running on another box.

Oh, could you please show me some code that does this (a 'channel between boxes'), and supports sending of exactly the same data types that you send over a regular Go channel?

Using the old deprecated netchan package doesn't count ;).

There's gob ( http://golang.org/pkg/encoding/gob/ ). Not going to claim it's on the level of node communication in Erlang, but it does make data (de)serializaiton incredibly simple. With only a few lines of code you could have a channel reading from and writing to a socket to another machine.

I haven't done it myself. The idea is from the book The Go Programming Language Phrasebook. I've misplaced the book, but this link shows it's probably netchan: https://groups.google.com/forum/?fromgroups=#!topic/golang-n...

Akka does that as well, and you're right, it's very important for writing declarative, distributed logic. Akka's ActorRef abstracts over the physical location of the actor, just as Erlang's PIDs do.

So does Cloud Haskell (which borrows and improves on many ideas from Erlang/OTP).

http://haskell-distributed.github.com/documentation.html

There is nothing like the pleasure of using the right tool for the right job.

Using C++, Java or even Python for highly concurrent and fault tolerant systems is a bit like hammering screws into the wall. It can be done with enough effort -- but try a screw driver drill and see what a difference it makes.

The secret sauce is all about fault tolerance, everything else amazingly and logically leads from it: isolation, hot code reloading, distribution (running nodes on multiple machines)

You can use Python on top of Erlang.

A supervisor is easily implemented in Go: http://code.google.com/p/gosup/source/browse/supervisor/supe...

What happens if one of the children calls panic() ?

A Goroutine can catch any panic() via recover() and then signal bad health to the supervisor.