Concurrent Hello World in Go, Erlang, and C++

Funny thing about the C++ example: The API Mindroid implements in C++ from Androids Java API, is actually from BeOS originally where it was C++. It still exists today in Haiku. So Mindroid has gone full circle C++ -> Java -> C++. Here is the Haiku versions for comparison: http://cgit.haiku-os.org/haiku/tree/src/kits/app/

almost like erlang (http://dlang.org/)

  import std.stdio;
  import std.concurrency;

  void world() {
    bool running = true;
    while (running) {
      receive(
        (Tid finished) { writeln("World"); send(finished, true); },
        (OwnerTerminated e) { running = false; }
      );
    }
  }
  void hello(Tid world, Tid finished) {
    for (int i=0; i<1000; i++) {
      write("Hello ");
      send(world, thisTid);
      receiveOnly!(bool)();
    }
    send(finished, true);
  }
  int main(string[] args) {
    auto world = spawn(&world);
    auto hello = spawn(&hello, world, thisTid);
    receiveOnly!(bool)();
    return 0;
  }

I couldn't bear looking at how bloated C++ implementation is, so I implemented it in C++11 based on boost.fiber library: https://gist.github.com/4015306. Now it looks very similar to Go language code.

Hey, I implemented it in C using just posix threads. It's my first time using posix threads, but I think it's not wrong. I tried to copy go's channels. https://gist.github.com/4012855

Why make a `chan string` rather than a `chan bool`?

Also, "quiter" would be better spelled "quitter".

It's a good demonstration of how nice Go can be for that sort of thing. Now I just want to see a Rust example.

Nice comparison. Anyone can now run the Go version in the Go Playground at http://play.golang.org/p/w0N-ZtBBw_

i miss erlang sometimes. sadly, the things it is good for are not the things i tend to be interested in exploring in my personal projects, but using it at work was a truly wonderful experience.

I think something other than "Hello World" would have been better. "WorldHandler" is awkward. The comparison is neat but do something more classically concurrent. even a simple producer consumer could probably be done with nearly a find and replace.