Great to see further progress on CHERI!

See the following for theoretical foundations for the work:

Linux 60th Anniversary Keynote

https://t.co/IRe3vpMlWn

Your research on actor-based programming models has nothing to do with C/C++ spatial and temporal memory safety.

Foundation is about rigorously specifying the general Laws of Locality for Actor systems that CHERI implements.

CHERI is not an actor system. It is a capability system aimed at memory protection. It can be used, like any other architecture, as a basis upon which to build an actor-based framework/system, but it is no more of an actor system than, say, x86. The concepts are deeply rooted in the capability system literature.

ActorsTheory serves as the rigorous mathematical foundations of capability systems.

Interesting article.

Mathematical foundations are needed that are much more suitable to modern Computer Science than using "universes".

For an example see the following article:

https://papers.ssrn.com/abstract=3603021

Also, see the following video:

https://www.youtube.com/watch?v=AJP1VL7shiI

Computer science theory didn't get harder.

Instead, education became weaker :-(

See following link for foundations of computer Science:

https://www.youtube.com/watch?v=AJP1VL7shiI

The Actors Abstraction does not require specification of

computer boundaries.

Unless I’m missing something this is exactly what I was saying? I’m open to the possibility I’m missing something, but my understanding is that Actor boundaries are messenger boundaries and they can be remote, or local processes, or event loop routines, or plain local functions with no real concurrency. The abstraction/model only enforces that communication between them is consistent no matter the actor’s environment.

The Actors Abstraction is foundational for computer science

analogous to the Natural Numbers in classical mathematics.

Probably not a good idea to burden application programmers

with having to annotate each message send with whether the

receiver is on the current computer or another one in a

Citadel.

Since Actors can move between computers in a Citadel, such

annotations are infeasible in practice.

Of course, modularity, security, and performance should not be

ignored.

This notion of an agent moving between computers has always been problematic for me to understand. If we accept that an agent ("actor") is a combination of code and state, and that code and state are both reducible to data, then an agent moving between computers is no more noteworthy than saying data moved between computers and that move engendered computation based on and over that data, which is a defined sequence of RPC calls: send code; send data; execute(code, data). What distinguishes an "actor" from passing scripts in RPC calls? I think it is a false conceptual paradigm: "actors" in general conceptual world carry their own processing ("mind") unit. This attribute is not reproducible in software.

So, if the Actor Model is in fact reducible to a complex RPC framework, the question remains if we should distinguish between RPC and local PC without throwing ~mystical bits about actors into the question.

In any event, I was wrong in my OP about Swift's approach: it is in fact the Waldo approach with distinct treatment of remote ops, except instead of annotations, it is language level support and instead of instrumenting existing code (ala Java byte codes), it is the compiler that writes the boiler plate for the underlying RPCs.

See the following for a rigorous definition of the Actors Abstraction:

https://papers.ssrn.com/abstract=3418003

Probably can't make much progress without a scientific foundation including the Actors Abstraction.

The Actor Paradigm is much more widespread with offerings from Microsoft, Lightbend, etc.

I fondly remember Joe Armstrong, who was a good friend.

However, not having a mathematical foundation has been a

severe limitation for Erlang.

The Erlang community is trying to dig its way out with

modifications and extensions. Still have a long way to go.

Of course, no Actors framework is perfect.

Many important implementations have been done Erlang.

Also, significant Erlang projects are ongoing to good effect.