5 ms·

How does it compare to Akka?

lwansbrough 6y ago
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.
- acjohnson55 6y ago
  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.
  - lwansbrough 6y ago
    That sounds similar in concept, yeah. The brilliance of Orleans was doing it without introducing a new way of coding.
    - acjohnson55 6y ago
      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.
      - SergeyBykov 6y ago
        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.
        fgonzag 6y ago
        Since you're an expert on both, do you mind discussing which of the two you like better? And the reasons behind it?
        SergeyBykov 6y ago
        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.
        fgonzag 6y ago
        Awesome! Thanks for the quick comparison
keithnz 6y ago
Orleans and Akka guys did a comparison https://github.com/akka/akka-meta/blob/master/ComparisonWithOrleans.md https://github.com/akka/akka-meta/blob/master/ComparisonWith...
- reubenbond 6y ago
  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.
- manigandham 6y ago
  There's also Akka.NET which is probably a better comparison: https://getakka.net/ https://getakka.net/
deleted 6y ago
[deleted]
natdempk 6y ago
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#orleans 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.
- ktoso 6y ago
  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 :-)
Maarten88 6y ago
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.

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.

acjohnson55 6y ago
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.
- lwansbrough 6y ago
  That sounds similar in concept, yeah. The brilliance of Orleans was doing it without introducing a new way of coding.
  - acjohnson55 6y ago
    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.
    - SergeyBykov 6y ago
      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.
      - fgonzag 6y ago
        Since you're an expert on both, do you mind discussing which of the two you like better? And the reasons behind it?
        SergeyBykov 6y ago
        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.
        fgonzag 6y ago
        Awesome! Thanks for the quick comparison

keithnz 6y ago

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

reubenbond 6y ago
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.
manigandham 6y ago
There's also Akka.NET which is probably a better comparison: https://getakka.net/ https://getakka.net/

deleted 6y ago

[deleted]

natdempk 6y ago

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#orleans 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.

ktoso 6y ago
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 :-)

Maarten88 6y ago

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.