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

http://himmele.blogspot.de/2012/11/concurrent-hello-world-in-go-erlang.html

by DanielHimmelein • 14 years ago

8 15 14 years ago

himmele.blogspot.de

chrismorgan• 14 years ago

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.

DanielHimmelein5• 14 years ago

Oh, you are right with quitter. That is a typo. It will fix it. It used chan string just because it does not matter for this example :-).

genwin• 14 years ago

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

Tyr42• 14 years ago

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

codewright• 14 years ago

Seems pretty reasonable to me. I actually rather like the idea of taking the best of higher level languages that can't work for systems programming and stealing their ideas to the darker realms of C and C++.

zem• 14 years ago

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.

drivebyacct2• 14 years ago

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.

baobab• 14 years ago

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.

DanielHimmelein5• 14 years ago

Cool, looks much better :-). Normally, I really like Android's concurrency abstractions, but not for this one :-).

DanielHimmelein5• 14 years ago

But I have to admit that Android's concurrency framework is more about message passing and actors than about fibers or coroutines. The fiber implementation is much more readable here.

tqh2• 14 years ago

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/

DanielHimmelein5• 14 years ago

Hi that is funny. I knew that Dianne Hackborn brought Binder over to Android from BeOS and Palm. But I did not know that also the concurrency framework is from the Be guys. Thanks for sharing the link :-).

DanielHimmelein5• 14 years ago

Ah ok, I checked the Haiku source and I think this works like the original Binder concurrency stuff (see http://www.osnews.com/story/13674/Introduction_to_OpenBinder...). Android's concurrency framework (as well as Mindroid) is a refined version of Be's concurrency APIs.

tqh2• 14 years ago

Yes, it is like the original Be code. It was for showing the inheritage.

gizmomogwai• 14 years ago

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;
  }

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

Related Stories