Taxonomy of Facets & Composites

[Ken Kahn]

MarkM wrote:
> Of course, as we've been discussing, an individual Actor isn't very
> interesting.  Even the most trivial interesting system would be a network
of
> Actors passing messages to each other.  Networks of Actors are
asynchronous
> and non-deterministic all the way down.  However, this pervasive
> non-determinism is specificational non-determinism.  Implementations that
> are much more predictable can nevertheless be valid implementations of
this
> massively non-deterministic spec.
>

This is often true for concurrent logic programming as well. If the language
doesn't require some kind of fairness in clause selection, then an
implementation could be very predicable and deterministic. Programs
shouldn't over specify since that unnecessarily constrains their
implementations. If you don't care which matching clause commits and runs,
then why should your programming language force you to choose?

> Designation in CLPs is by logic variables.  Although one certainly speaks
of
> networks of many logic variables and many processes, one still speaks of
an
> individual logic variable as an entity.  A logic variable is not normally
> seen as a degenerate singleton collection of logic variables.  Why is this
> not equally objectionable?
>

Your question is helping me be clear in my mind. Hopefully I'll be able to
communicate this.

A logic variable (or communication channel) is the most important building
block.  Or more accurately the send and receive rights on channels are the
basic building blocks. A collection of send rights isn't very different from
a collection of object references as your question implies.

But let's look at the receive rights. What is different about CLP is that an
individual process is very similar to (I think it is even indistinguishable
from) a collection of processes. An individual process might hold several
receiving ends of channels. It might react to individual messages on those
channels or it might wait for some subset. It can at any time receive new
channel receive capabilities or pass them along to others. In other words an
individual process behaves the same way a collection of processes do. The
parallel composition of 2 CLP processes is of type CLP process. But the
parallel composition of 2 actors isn't an actor - it's a composite that has
different semantics.

Best,

-ken