It's a powerful tool with some serious computer science work behind it; for example Dr Phil Bernstein's research added its distributed transactions, which are a fascinating solution to the pronblem of running ACID across arbitrary networks where latency is unknown and strong consistency is not guaranteed.
.NET Orleans
21–30 of 287 posts
Re: .NET Orleans
#22Link to the project on Githib https://github.com/dotnet/Orleans
Re: .NET Orleans
#23I'm a core developer on Orleans. Feel free to ask any questions here, or on gitter: https://gitter.im/dotnet/orleans
I gave a talk recently on how we use it at Microsoft: https://www.youtube.com/watch?v=KhgYlvGLv9c - the talk is very short and so it does not go into many details, but it gives an overview of some internal use cases.
Re: .NET Orleans
#24Orleans is awesome and the virtual aspect of the actor system is something that I have found to be missing from many alleged comparative libraries (Akka, Actix, etc.) It is really the key selling point: run an Orleans cluster and then you can forget about networking altogether (not entirely true, but truer than you may believe.) Just don't make any bugs in your code or you're in for a headache. The ergonomics of Orle…
> Just don't make any bugs in your code or you're in for a headache.
Have you taken a look at this? https://microsoft.github.io/coyote/ https://microsoft.github.io/coyote/learn/overview/what-is-co...
It's a tool by Microsoft Research to detect concurrency bugs in code.
Re: .NET Orleans
#25How does it compare to Akka?
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.
Re: .NET Orleans
#26looks like a healthy project judging by the stats [1], also a big list of users [2].
How big of a task would learning this framework be? Is the documentation good enough? Sounds like it could be a good option for a game's network backend.
1: https://github.com/dotnet/orleans/graphs/contributors
2: https://dotnet.github.io/orleans/Community/Who-Is-Using-Orle...
Re: .NET Orleans
#27I used Orleans for my last startup and really enjoyed it. The dev team is active and responsive to the community, as evidenced by Reuben Bond and perhaps others appearing in this thread.
You can read a bit about my use of it here: https://www.realartists.com/blog/ship-20.html
All the code is in GitHub, if anyone wants to take a look.
Re: .NET Orleans
#28Earlier quoted context omitted.
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.
Re: .NET Orleans
#29I'm a core developer on Orleans. Feel free to ask any questions here, or on gitter: https://gitter.im/dotnet/orleans I gave a talk recently on how we use it at Microsoft: https://www.youtube.com/watch?v=KhgYlvGLv9c - the talk is very short and so it does not go into many details, but it gives an overview of some internal use cases.
I mostly found out about Orleans through Joe Hegarty who worked on Orbit in Java (EA / BioWare) its been a while since I looked at both how closely would you say they are related to one another in terms of design today? What would you say are some of the key differences between the two? My understand at the time was they were closely related.
Re: .NET Orleans
#30Seems cool. What are some good use cases for this?
Distributed applications
There are a couple of types of distributed applications though, right?
There's the traditional client/server scenario where you distribute the load horizontally across many servers. If most of the server computation is stateless, and all the state is stored in the database, then you can use either the FaaS or the actor model.
Then there's the client/server scenario where the server computation is stateful, in which case you shouldn't use FaaS. You could still use actors though. Isn't this where Orleans sits?
Then there's the peer to peer architecture where all computers run the same code, whether they're in the cloud or on an end user's laptop or phone. Does Orleans make sense in this case?