That document is outdated and was written with an Akka-centric view. The author from Akka's side of things, Roland Kuhn, has since moved on to Actyx, from what I can tell.
The doc predates ACID transactions support in Orleans, but it talks about the Virtual Actor model vs the Akka model in general.
Having spent a lot of time with Orleans but very little on Akka, I believe the key difference is the "virtual" part. When you write Orleans code, the presumption is it will be executed on a remote machine, but you don't have to address that machine. The Orleans host does the work of actually assigning ownership of grains and distributing the load between silo nodes. So in your .NET code you simply have to instantiate a grain like you would any other plain old C# class (actually there's usually a factory IIRC), and then you work with its async Task-based methods (a standard and boring concept in modern .NET) which may or may not communicate over the network.
That sounds a bit like Cadence/Temporal, the workflow programming platform. It doesn't really advertise itself as an actor framework, but it shares the concept of being able to run ordinary-looking functions as though they have a lifespan that isn't constrained to a single system or OS process.
Yeah, same with Cadence/Temporal. The one caveat is that you have to move all observable effects into activities so that they can be cached. Under the hood, the engine replays functions to rehydrate them, if necessary.
I'm also one of the core developers of Orleans. Ironically, I recently joined Temporal. There are definitely some similarities, but also major differences between the models, especially when it comes to the execution model and fault tolerance.
After more than a decade of working on Orleans and only three weeks on Temporal it's foolish of me to talk about what I "like better" :-). I'm working on a couple of conference talks to compare the two approaches.
In short, Orleans is biased towards quick low latency operations. Longer running workflow style operations are totally doable, but require extra application logic and thinking.
Temporal's main abstraction is a workflow. So, it's biased towards reliable execution (with retries if needed) of business processes that may take seconds or days/months.
Orleans executes application code within the runtime process. Temporal orchestrates execution of external application workers (processes) I started referring to it as Inversion of Execution.
Orleans is .NET. Temporal currently provides Go and Java SDKs.
These are just top-level differences that come mind. There are many others. But there are also major similarities.
At the end of the day, I think Orleans and Akka are conceptually different types/notions of what an actor framework is.
> Orleans uses a different notion of identity than other actor systems. In other systems an “actor” might refer to a behavior and instances of that actor might refer to identities that the actor represents like individual users. In Orleans, an actor represents that persistent identity, and the actual instantiations are in fact reconcilable copies of that identity.
Hi there (ex Akka core team here). Yeah there's slight differences what the main concept is in those libraries. It kind of boils down to Akka's concept of an actor being more low level, and then adding the capabilities that Orleans offers as "the way" in means of extensions.
A virtual actor is very similar to an entity in Akka that is running in cluster sharding and uses Akka persistence. It's just that it's not packaged up into the virtual actor concept by default. I would love Akka to provide a more hand-holding more Orleans style module to be honest, it's a great concept and way to think about systems :-)
It's the distributed networking equivalent of programming with managed versus unmanaged memory.
With Akka you manage objects actively, much like memory in C, with Orleans your objects behave much like normal Dotnet/Java objects, they are just distributed and must use async methods. Orleans adds a layer of management, where it will tear down and re-instantiate objects as required, distributes them in the cluster, etc. As a programmer you don't have to worry about it, it's all managed by the runtime.
