[erlang-questions] How small could an Erlang emulator be?

[Vlad Dumitrescu]

Hi all,

Maybe I am off-track here, but I feel there is some level of confusion
here, not everybody is talking about the same thing when saying
"erlang".

IMHO there are at least three separate things that may be the target:

* the "lightweight isolated processes with message passing and
monitoring" model (LIP)
* any VM that implements the above model
* any source level language that can be run on any of the VMs above

In my mind, the above are orthogonal (or almost) and it may be
important to specify which one is meant in a specific context. Most of
the times it doesn't matter much, because there is only one VM (in
current use) and only one language, but as it was pointed out before
there are other groups that recognize the usefulness of the model and
are beginning to have working implementations (see scala actors, for
example).

Personally, I think it is the model that is the most important part,
as I don't really care how it is implemented or what language it is
programmed in, as long as it works as advertised. I believe it was the
same thing that Richard was aiming at with the question.

In this light, what I see as a future path to take is to abstract away
the "process managing machinery" from the actual "code running". Then
we could have a world filled of "process containers" (the Erlang nodes
of today) that would run on large and small CPUs and would run code
implemented in pC, pJava, pRuby or even pINTERCAL (where the 'p'
prefix is referring to a parallel extension of the respective language
supporting the LIP model).

Returning to the question at hand, it becomes then
  - can the LIP part be cleanly separated from the VM proper? (I believe it can)
  - if yes, how small could a minimal LIP implementation be?
Then add the size of a Forth VM :-)

best regards,
Vlad