A core tenet of object-oriented programming is that objects encapsulate some state, plus some behavior, and that objects communicate with each other through messages: if object A wants to communicate with object B, then A sends a message to B.

This simple model of object communication, however, says nothing about where A and B might be located. If A and B both execute in the same address space, then A and B can exchange message via local method calls. In a concurrent, distributed environment, however, A and B might be located in different address spaces, even on different hosts. In that situation, A and B might communicate via distributed messages.

Some programming languages emphasize the difference between message-based vs function-invocation-based communication, writes Tony Arcieri, creator of the Reia language, in a recent blog post, Why I Don't Like Scala.

Scala's Actors, for example, provide three different models for objects to exchange messages:

Because the JVM isn't stackless and uses native threads as its concurrency mechanism, Scala couldn't implement Erlang-style lightweight concurrency, and instead compromises by implementing two types of actors. One type of actor is based on native threads. However, native threads are substantially heavier than a lightweight Erlang process, limiting the number of thread-based actors you can create in Scala as compared to Erlang. To address this limitation, Scala implements its own form of lightweight concurrency in the form of event-based actors. Event-based actors do not have all the functionality of thread-based actors but do not incur the penalty of needing to be backed by a native thread.

Should you use a thread-based actor or an event-based actor in your Scala program? This is a case of implementation details (namely the JVM's lack of lightweight concurrency) creeping out into the language design...

Scala leaves you with three similar, overlapping constructs to choose from when modeling state, identity, and concurrency in programs: objects, event-based actors, and thread-based actors. Which should you choose?

By contrast, Arcieri's language, Reia, which runs on the Erlang VM, turns all objects into Actors, in effect. At the same time, Reia introduces many notions of OO programming that developers may at first find strange.

What do you think of Arcieri's notion that concurrency should be modeled at the object level in a language?

for(int i = 0; i < MAX; ++i) {
   printf("result %i = %i\n", i, Int(2000000000).sum());
}

int results[MAX];
for(int i=0; i < MAX; ++i) {
   results[i] = Int(2000000000).sum();
}
for(int i = 0; i < MAX; ++i) {
   printf("result %i = %i\n", i, results[i]);
}

unique_future<int> results[MAX];
for(int i=0; i < MAX; ++i) {
   results[i] = Int(2000000000).sum();
}
for(int i = 0; i < MAX; ++i) {
   printf("result %i = %i\n", i, results[i].get());
}

> for(int i = 0; i < MAX; ++i) {
>    printf("result %i = %i\n", i, Int(2000000000).sum());
> }
> 

> int results[MAX];
> for(int i=0; i < MAX; ++i) {
>    results[i] = Int(2000000000).sum();
> }
> for(int i = 0; i < MAX; ++i) {
>    printf("result %i = %i\n", i, results[i]);
> }
> 

> unique_future<int> results[MAX];
> for(int i=0; i < MAX; ++i) {
>    results[i] = Int(2000000000).sum();
> }
> for(int i = 0; i < MAX; ++i) {
>    printf("result %i = %i\n", i, results[i].get());
> }
> 

int sum(int low, int high) {
  int ret = 0;
  for (int i = low; i < high; ++i)
    ret += i;
  return ret;
}

int sum(int low, int high) {
  int size = high - low;
  if (size < 5 /* arbitrary cutoff, must be >= 2 */) {
    int ret = 0;
    for (int i = low; i < high; ++i)
      ret += i;
    return ret;
  } else {
    int a = sum(low, low + (size/2));
    int b = sum(low + (size/2), high);
    return a + b;
  }
}

map<Key, Thing> stuff;
Thing foo(int x) {
  Key k(x, ...);
  Thing result = stuff[k];
}
void bar() {
  Thing result = foo(123);
  stuff.clear();
  ...
}

dispatch()
fnord() + 123 # waiting on message to continue
wait_and_dispatch()
bar() + 456 # waiting on message to continue
wait_and_dispatch()

> map<Key, Thing> stuff;
> Thing foo(int x) {
>   Key k(x, ...);
>   Thing result = stuff[k];
> }
> void bar() {
>   Thing result = foo(123);
>   stuff.clear();
>   ...
> }
> 

> dispatch()
> fnord() + 123 # waiting on message to continue
> wait_and_dispatch()
> bar() + 456 # waiting on message to continue
> wait_and_dispatch()
> 

class A {
   int data;

   void foo(B b) {
       data = 5;
       B.bar(this);
   }

   void bar() {
       data = 3;
   }
}

class B {
    void bar(A a) {
        a.bar();
    }
}

class /*actor*/ Map {
  map<Key, Thing> stuff;
public:
  Thing lookup(Key k) {
    return stuff[k];
  }
  void clear() {
    stuff.clear();
  }
};
class /*actor*/ Class1 {
  Thing foo(int x, Map & m) {
    Key k(x, ...);
    return m.lookup(k);
  }
};
class /*actor*/ Class2 {
  Map & m;
  Class1 & c;
  void bar() {
    Thing result = c.foo(123, m);
    m.clear();
  }
};

thread for    | thread for     | thread for
Class2	      | Class1	       | Map
enter "bar"   |                |
send "foo"    | enter "foo"    |
send "clear"  | send "lookup"  | did "lookup" or "clear" arrive first?

class A {
  int data;
  void set(int x) {
    data = x;
  }
  void do_stuff(B b) {
    int tmp = b.foo(data * 5);
    if (tmp < data) {
      ...
    }
    data = ...;
  }
};
class B {
  int foo(tmp) {
    /* something that has nothing at all to do with A */
  }
};

> class /*actor*/ Map {
>   map<Key, Thing> stuff;
> public:
>   Thing lookup(Key k) {
>     return stuff[k];
>   }
>   void clear() {
>     stuff.clear();
>   }
> };
> class /*actor*/ Class1 {
>   Thing foo(int x, Map & m) {
>     Key k(x, ...);
>     return m.lookup(k);
>   }
> };
> class /*actor*/ Class2 {
>   Map & m;
>   Class1 & c;
>   void bar() {
>     Thing result = c.foo(123, m);
>     m.clear();
>   }
> };
> 

> thread for    | thread for     | thread for
> Class2	      | Class1	       | Map
> enter "bar"   |                |
> send "foo"    | enter "foo"    |
> send "clear"  | send "lookup"  | did "lookup" or "clear"
> arrive first?
> 

> class A {
>   int data;
>   void set(int x) {
>     data = x;
>   }
>   void do_stuff(B b) {
>     int tmp = b.foo(data * 5);
>     if (tmp < data) {
>       ...
>     }
>     data = ...;
>   }
> };
> class B {
>   int foo(tmp) {
>     /* something that has nothing at all to do with A */
>   }
> };
>