Hacker News Reader

Comment by The_rationalist | Hacker News Reader

How does it compare to Akka?

Orleans and Akka guys did a comparison https://github.com/akka/akka-meta/blob/master/ComparisonWith...

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.

There's also Akka.NET which is probably a better comparison: https://getakka.net/

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.

That sounds similar in concept, yeah. The brilliance of Orleans was doing it without introducing a new way of coding.

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.

Since you're an expert on both, do you mind discussing which of the two you like better? And the reasons behind it?

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.

Awesome! Thanks for the quick comparison

I wrote a bit about Orleans here (and also Akka if you scroll up a bit): http://dist-prog-book.com/chapter/3/message-passing.html#orl...

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.

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.

Reply on news.ycombinator.com