17 ms·
.NET Orleans
- rattray 6y ago> It was created by Microsoft Research and introduced the Virtual Actor Model as a novel approach to building a new generation of distributed systems for the Cloud era. Okay, sounds like an academic, Microsofty take on Erlang's Actors? But from docs, sounds like it's at least used in practice at MSFT: > Since 2011, it has been used extensively in the cloud and on premises by several Microsoft product groups, most notably by game studios, such as 343 Industries and The Coalition as a platform for cloud services behind Halo 4 and 5, and Gears of War 4, as well as by a number of other companies. > Orleans was open-sourced in January 2015, and attracted many developers that formed one of the most vibrant open source communities in the .NET ecosystem.
- oldmanhorton 6y agoIt also underpins Service Fabric Actors, I believe
- keithnz 6y agothe actor model isn't erlangs, it's actually a surprisingly old idea ( 1973 ). The virtual actor model is an interesting spin on the idea that simplifies a few things. Orleans itself is quite nice, I've used it a few times on some smallish things. Looking at using it in anger for a large distributed backend system in the nearish future.
- picodguyo 6y ago"Looking at using it in anger..." Orleans DDoS?
- jolux 6y ago"in anger" typically means for a real-world, serious project.
- picodguyo 6y agoThanks, first encounter with this expression.
- chrisseaton 6y agoIs this a Britishism? I find Americans often are confused by it when I use it.
- swyx 6y agoi first heard about "in anger" from David Nolen, an American https://www.youtube.com/watch?v=8o01g6C7jWg&feature=emb_title https://www.youtube.com/watch?v=8o01g6C7jWg&feature=emb_titl...
- thom 6y agoI use it too much and it has caused consternation with both American and Egyptian colleagues. Not sure what to reprogram my brain to use because it’s pretty ingrained at this point.
- keithnz 6y agoI'm from New Zealand, so maybe! never knew it was not a thing in America.
- contextfree 6y agoAs an American I realize I've only ever encountered it (that I remember) in the context of software development libraries and tools.
- ldayley 6y agoOr perhaps rather they were referring to the classic Erlang in Anger document: https://erlang-in-anger.com/ https://erlang-in-anger.com/
- to11mtm 6y agoAcademically (And, to some extent, practically speaking) Orleans Virtual actors aren't the same as Erlang (or Akka) actors. Major differences: - Normal actors are pretty flexible, can work in local or remote contexts. Orleans is probably best described as Sharded Actors, It's a 'guided' implementation of Actors compared to Erlang or Akka where you are given a toolkit and have to build out what you intend to do. - Orleans doesn't have any ordering guarantees. While this is not a firm requirement of the Actor model itself, both Erlang and Akka guarantee ordering between a given Sender-receiver pair (i.e. messages sent from A to C will be sent in order) - Akka and Erlang have the concept of Supervision. i.e. An actor may have a child, and if that child crashes, the (parent) is notified and may choose how to react (restart child, don't restart child, crash itself) - Orleans may allow more than one activation of the same grain at the same time. A stable and properly configured Akka Shard cluster will never have more than one of the same entity actor alive at a time. - Orleans can magically scale out with the cloud (If you're running them on Azure.) Erlang/Akka you'll have to deploy your new nodes.
- Jtsummers 6y ago> - Orleans doesn't have any ordering guarantees. While this is not a firm requirement of the Actor model itself, both Erlang and Akka guarantee ordering between a given Sender-receiver pair (i.e. messages sent from A to C will be sent in order) I thought Erlang only guaranteed that if the processes are on the same node. Is that not correct?
- ramchip 6y agoIt’s true even with distribution, see e.g.: http://erlang.org/faq/academic.html#idp33052176 http://erlang.org/faq/academic.html#idp33052176 http://erlang.org/pipermail/erlang-questions/2017-September/093666.html http://erlang.org/pipermail/erlang-questions/2017-September/...
- to11mtm 6y agoHuh. Never actually looked into HOW it worked in erlang, but basically it looks like it works the same way as Akka/AkkaDotNet; VM skates on top of the underlying transport's ordering guarantees. For a long time I was curious how Akka Artery preserved message ordering for it's 'dedicated large message' lane. in short it really just means you are dedicating a specific TCP or Aeron connection dedicated to those actors, there's no magic ordering sauce underneath. (just a little disappointed to find that out, but appreciate the simplicity upon consideration.)
- gmaster1440 6y agoIt's very interesting to see a solution that tackles the problem of identity and state while continuing to embrace OOP. This is in contrast to the philosophy of many functional programming languages, like Clojure, that avoid[0] this by design. [0] - https://clojure.org/about/state#actors https://clojure.org/about/state#actors
- Thaxll 6y agoEA/BioWare created an equivalent for some of their online services on the JVM: https://github.com/orbit/orbit https://github.com/orbit/orbit
- noworriesnate 6y agoI wonder, what would it be worth to the world if there were an actor framework for multiple languages that offered interopability between languages? IIRC Akka.net and Akka aren't compatible with each other.
- motives 6y agoDapr is designed to offer this afaik (https://github.com/dapr/docs/blob/master/concepts/actors/README.md https://github.com/dapr/docs/blob/master/concepts/actors/REA...). It uses GRPC and HTTP to allow clients and services of the virtual actors in various languages (C#, Java etc.) to communicate.
- manigandham 6y agoAlso ProtoActor which uses GRPC to be cross-platform between C#, Go and Kotlin: https://proto.actor/ https://proto.actor/
- the_duke 6y agowasCC [1] goes in that direction. It supports all languages that compile to wasm. Very early stage project, though. [1] https://wascc.dev/ https://wascc.dev/
- The_rationalist 6y agoHow does it compare to Akka?
- lwansbrough 6y agoHaving 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 agoThat 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 agoThat sounds similar in concept, yeah. The brilliance of Orleans was doing it without introducing a new way of coding.
- acjohnson55 6y agoYeah, 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
- kirillzubovsky 6y ago`Orleans builds on the developer productivity of .NET` - could someone familiar with NET development specify what those things might be? I've never used .Net and would love to find out what it does better/worse/different than other frameworks. Thanks!
- moron4hire 6y agoLet's see: - best in class IDE - best in class debugger - excellent cross platform support - very fast compilers - a robust library ecosystem - no arguments over how to publish or import those libraries - a build system that just works - and all without having to install tons of third-party, fly-by-night projects. I've worked in lots of different environments. .NET is the only one I've been able to leave, come back to after some time, and get back running in minutes. JavaScript, Python, and Ruby were all rickety houses of cards in comparison. C++ is just inscrutable. And Java might get the closest, but it still feels like being perpetually 5 years behind .NET.
- kirillzubovsky 6y agoThanks!
- danielbarla 6y agoAs a developer mainly in the .Net ecosystem for about 20 years now, I frequently see "best in class IDE" as a headline feature. I've spent the past year with Rider as my main IDE, and surprisingly there have been very few things that I miss from Visual Studio (mostly related to profiling tools). On the other hand, there are several irritations in VS that make it feel decidedly not best in class, for me at least (extreme slowness on startup, but also on a variety of frequent tasks such as switching between files, compiler getting out of sync with reality and listing errors that have been fixed minutes ago, the WinForms editor refusing to open a screen for whatever reason, etc). While it's a decent IDE for sure, I'm not sure I'd rate it all that high, and would argue that at least the JetBrains family are on par in most cases. So an honest question: what exactly do people see in VS as being so outstanding, that other IDEs lack?
- qz2 6y agoI’ll give it three hours before the emperor is found naked, like COM, DCOM, DNA, windows.net, Patterns and Practices, Enterprise Library, Remoting, AppFabric, WCF.
- FridgeSeal 6y agoIt's a "Microsoft Framework", it's going to be enterprise-y Design-Patterns, convoluted abstractions, Dependency-Injection-on-Dependency-Injection and MS specific code/libs all the way down.
- manigandham 6y agoNone of the Microsoft frameworks are like that, especially compared to the enterprise mess of Java or constant spaghetti of JS/Go.
- strangeattractr 6y ago> constant spaghetti of JS/Go. I've written a lot of Go and there are plenty of faults but I'm curious why you consider it 'constant spaghetti' apparently in the same class as JS.
- manigandham 6y agoLack of higher-level language features requiring code duplication/generation, a lean standard library usually necessitating 3rd-party packages, and an utterly terrible module system and fragile tooling setup. Go is still far better than JS, but both are behind in modules, packaging and overall structure as compared to .NET. gofmt is nice though, more languages should have that.
- FridgeSeal 6y agoFor all it's other woes, I've had like 80% fewer issues with Go's tooling than .Net's. - Getting packages installed: trivial - Getting clean builds: trivial - Build and run works near perfectly In comparison .net seems designed to be used _only_ via Visual Studio: - Why does it re-download the packages each time I ask it to build? - Why does VS freak out sometimes when there's a terminal window left over from a previous run? - Why does VS freak out so thoroughly when something changes under it. - Sometimes it just caches your previous build and thinks it's perpetually broken no matter how many changes you make, restarting seems to be the only option. - Getting dotnet tools to work from the command line (the way Cargo/Yarn/Julia/Pipenv/etc do) was a confusing affair fraught with instructions like "oh you've got to into this XML file and set these random configs and tell it where x/y/z dll is". That's before we get to the whole disaster that is "add this as a reference to your project". No programming language has caused me quite as much frustration as C#/.net manages to.
- deleted 6y ago[deleted]
- xyst 6y agoLost me at .NET
- lwansbrough 6y agoOrleans 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 Orleans are so nice in fact, it inspired me to try to achieve a similar effect (any POCO can be invoked across the network) by using IL weaving. It worked, but it's SCARY.
- Izikiel43 6y ago> 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/ https://microsoft.github.io/coyote/learn/overview/what-is-coyote https://microsoft.github.io/coyote/learn/overview/what-is-co... It's a tool by Microsoft Research to detect concurrency bugs in code.
- withinboredom 6y agoI feel like the documentation (or something) could be improved there. I've never been able to get it to find a bug. That said, there's also https://github.com/Azure/azure-functions-durable-extension https://github.com/Azure/azure-functions-durable-extension which seems closely related to Orleans, but for serverless.
- popinman322 6y agoDurable Functions are not in the same category as actors. Each durable function exists to serve a single request; the model is request partitioned instead of data partitioned. Durable Functions are great for deterministic synchronization across calls to other Azure Functions. Fan-out, fan-in, function chaining, and similar tasks are best done using Durable Functions[0]. Could you build an actor model on top of Durable Functions? Possibly. I'm not sure why you would do that, though. Azure Functions are already pretty expensive. [0]: https://docs.microsoft.com/en-us/azure/azure-functions/durable/durable-functions-overview?tabs=csharp#application-patterns https://docs.microsoft.com/en-us/azure/azure-functions/durab...
- jayd16 6y agoSeems cool. What are some good use cases for this?
- redisman 6y agoDistributed applications
- noworriesnate 6y agoThere 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?
- SergeyBykov 6y agoCase 2 is the most popular one. Sometimes people migrate from Case 1 when they start hitting performance bottlenecks of hitting database on every request or/and experience congestions from uncoordinated concurrent writes. Orleans doesn't make a lot of sense for Case 3 IMO. Peer-to-peer is not a good environment for forming stable clusters and making resource management decision the way the are done in the traditional server-side case.
- swyx 6y agosome history: - 2016 hn thread https://news.ycombinator.com/item?id=12108336 https://news.ycombinator.com/item?id=12108336 - the famous Halo 4 talk: https://vimeo.com/111287292 https://vimeo.com/111287292 - core dev talk: https://www.youtube.com/watch?v=tsolQ4pKM6U https://www.youtube.com/watch?v=tsolQ4pKM6U
- sbisson 6y agoIt'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.
- whycombagator 6y agoLink to the project on Githib https://github.com/dotnet/Orleans https://github.com/dotnet/Orleans
- reubenbond 6y agoI'm a core developer on Orleans. Feel free to ask any questions here, or on gitter: https://gitter.im/dotnet/orleans https://gitter.im/dotnet/orleans I gave a talk recently on how we use it at Microsoft: https://www.youtube.com/watch?v=KhgYlvGLv9c 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.
- munchbunny 6y agoWow, amazing to see this after a whole decade! I worked on this as an intern way back when it was a nascent project in MSR. Going through the documentation, this is a complete trip. I see some of the original concepts are still intact, but the ergonomics are completely different now. Awesome!
- giancarlostoro 6y agoI 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.
- ryanjshaw 6y agoI spent a fair amount of time doing a POC on Orleans but ultimately went with SF Reliable Actors due to some issues I couldn't resolve with a custom Streams implementation (Kafka subscriber/publisher). I really enjoyed the simplistic development model of Orleans compared to SF, and I want to give streams a second chance on a personal project, but I'm concerned that both Orleans and SF RA will be superseded by SF Mesh - do you have any thoughts on this?
- emmanueloga_ 6y agolooks 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 https://github.com/dotnet/orleans/graphs/contributors 2: https://dotnet.github.io/orleans/Community/Who-Is-Using-Orleans.html https://dotnet.github.io/orleans/Community/Who-Is-Using-Orle...
- dodyg 6y agohttps://github.com/dodyg/practical-aspnetcore/tree/3.1-LTS/projects/5-0/orleans https://github.com/dodyg/practical-aspnetcore/tree/3.1-LTS/p... I am learning Orleans at the moment. I've created about 12 sample projects in Orleans as I am learning the concepts. Most of the samples are very small and can be run in one program thanks to the ability to host Orleans and ASP.NET Core Web server together.
- kogir 6y agoI 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 https://www.realartists.com/blog/ship-20.html All the code is in GitHub, if anyone wants to take a look.
- Erwin 6y agoI only ran into the Orleans Virtual Actor model a few days ago. I have an application I long wanted to move to a distributed model, and I've been struggling with seemingly to reinvent everything due to an unusual execution model. So it was quite an eye opener to read about how Orleans introduced Virtual Actors, activations and placements of actors and how these are exactly the things I've thought about over the years. I've read about e.g. the classic Erlang actors, but the concept of virtual actors in Orleans really fit my model. I'll be sticking with Python, but starting with the Orleans paper has lead me to quite a few similar systems: https://www.researchgate.net/publication/233416056_Orleans_Cloud_Computing_for_Everyone https://www.researchgate.net/publication/233416056_Orleans_C... that reference it.
- SergeyBykov 6y agohttps://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/Orleans-MSR-TR-2014-41.pdf https://www.microsoft.com/en-us/research/wp-content/uploads/... is a later paper that is much closer to what got open-sourced.
- Diederich 6y agoDang could you https that? It works fine.
- reubenbond 6y agoIf the link is being updated, I think the github repository provides a much better overview: https://github.com/dotnet/orleans/ https://github.com/dotnet/orleans/
- Quarrelsome 6y agoI'm getting seriously bad .NET Remoting flashbacks. Someone tell me how this is different and won't hide important transactional boundaries.
- reubenbond 6y agoAll communication in Orleans is asynchronous, similar to communication in gRPC, so in .NET world, you're using async/await with methods that return Task/Task<T>/etc. The boundary there is hopefully apparent: async calls can incur IO and have a cost and the 'async' keyword can hopefully make that cost apparent to the developer. References to grains are represented by interfaces and if the machine you're communicating with fails, the grain will be re-activated on a surviving host the next time you need to call it. In other words, they are location transparent and the application won't get stuck in some failure state when a machine crashes.
- Quarrelsome 6y agoI guess there's a lot to be said in regards to the rest of the .NET changes since 2001. There's no more blocking and spinning forever on a sync called from A to B and perhaps fail over is thought of better. Also it seems to architecture is basically forcing the "good path" of every service being instance based and throw away whereas .NET Remoting offered dark, unscaling singleton paths of dark doom.
- ourmandave 6y agoIt was created by Microsoft Research and introduced the Virtual Actor Model as a novel approach to building a new generation of distributed systems for the Cloud era. Hmmm, getting a very strong Microsoft Enterprise Library vibe. The Microsoft Enterprise Library is a set of tools and programming libraries for the Microsoft .NET Framework. It provides APIs to facilitate proven practices in core areas of programming. Packed full of Best Practices and more Enterprisey than Kirk, it was inscrutable to me. Based on the novel Virtual Actor Design model, I assume Orleans is Design Patterns all the way down.
- zbowling 6y agoWow... I haven't thought about `Microsoft Enterprise Library` in years. That awoke a long forgotten memory.
- reubenbond 6y agoMy opinion is biased, as a core developer, but I do not think it's packed full of design patterns. Orleans and the core team are relatively unopinionated on design patterns that developers employ. I'm much more concerned with developers writing code which cannot perform well at scale, or which becomes unreliable at scale, where machine failures are common, than I am with whether or not something fits some set of prescribed design patterns.
- brknckspd 6y ago> I'm much more concerned with developers writing code which cannot perform well at scale, or which becomes unreliable at scale, where machine failures are common Would you mind expanding (or linking to a documentation) on how Orleans enables reliable systems? I watched this talk (https://www.youtube.com/watch?v=9OMXw0CslKE https://www.youtube.com/watch?v=9OMXw0CslKE) that uses an example web application called Smilr to demonstrate some of the features of Orleans. However, that talk doesn't really go into detail on how failures are handled. For example, in the Smilr app, each 'Event' grain is responsible for notifying an 'Aggregator' grain whenever it comes into existence (or an existing one has its updated). What happens when a call from Event grain to Aggregator grain fails? Who is responsible for retrying? Link to the code - https://github.com/benc-uk/smilr/blob/master/orleans/Grains/EventGrain.cs#L48 https://github.com/benc-uk/smilr/blob/master/orleans/Grains/...
- joshsyn 6y agoNo F# support :O
- FridgeSeal 6y agoMicrosoft? Do something to meaningfully and significantly improve F# instead of leaving it in the corner and occasionally tossing it things? You must be joking. I'm mostly convinced F# is there so MS can say "you can do functional things, yeah!" without needing to make a meaningful effort.
- reubenbond 6y agoThere are developers using Orleans with F#, so it does work. It is not as nice of an experience as it ought to be, though. For example, it requires a dummy C# project to hold the generated RPC/serialization code. PRs to improve the experience for F# developers are greatly appreciated.
- deleted 6y ago[deleted]
- Nuzzerino 6y ago> Orleans builds on the developer productivity of .NET As someone who has developed with .NET (using VB, C#, F#) for almost 15 years, I am not sure if I would still advertise .NET as something focused on developer productivity, when in the context of introducing bleeding edge tech. It is a great framework, but I've found much more productivity with Elixir after just 1 year of using it. C# still suffers from statefulness, null references, and boilerplate code, even after newer versions of the language provide some tools to reduce those. F# is a good alternative to C# if you want to stay in the .NET ecosystem and reap the benefits of functional programming, but I found the compiler to be very slow, 3rd libraries poorly documented, the language excessively complex, and 3rd party IDE support to be limited (as of version 2.0 anyway). Is developer productivity still a focus of .NET?
- lwansbrough 6y agoAsking developers to learn an entirely new language or ecosystem isn't exactly my idea of productive. ;)
- x0n 6y agoI think maybe you stepped out of .net at the wrong time. Pattern matching, records, discriminated unions (c# 10) etc are here and on they way. Lots of functional features being integrated into C# with every update.
- ricksharp 6y agoI’ve been using C# since 2003, but I’m still 5 times faster in typescript & react. Besides that the typescript type system is insane. It’s cool to hear about discriminated unions though.
- x0n 6y agoThe more haste, the less speed! Yeah, I get ya. Love me some typescript.
- atraac 6y agoI'm using new c#/.net core professionally and I still think it's far less productive than elixir/phoenix in general. Also c#'s pattern matching is nothing when compared to elixir ones. They are very different languages though and that's fine, most people are familiar with OO, not with FP so for them, it might be more productive(at least in certain types of applications).
- tmpz22 6y agoI spent some time learning dotnet core this year and with the slow-grind progress Microsoft has made it really does look like the technology stack might start to replace Java, Go, Rails, NodeJS, over the next decade. You can really feel Microsoft's experience in language development and enterprise software development coming together to provide better ecosystem ergonomics than other frameworks and toolchains. Specifically I'm talking about tools like LINQ, dotnet core libraries, VS and VS Code integration, and the standard library and common library packages. I still think it has a long way to go but its still a huge potential upside, which is to say nothing of how its coming to dominate the games industry as well.
- dmitryminkovsky 6y agoNot sure this will happen given Node/Typescript/VSCode (also Microsoft, fun how they’ve taken over Node right?) but the dotnet platform sure is rich. I had the opportunity to work with it this year and I found it to be very nice! Not surprised to see it gaining more and more momentum with libraries like this.
- tmpz22 6y agoThe coup de grace is functioning and sane server side rendering of ReactJS apps by c# applications. If Microsoft can make that easy and simple it will lead to a huge churn as many software companies replace less efficient nodeJS applications for that use case. Typescript will always have its placed client-side but there will be huge user benefits if we can have more and better server side rendering.
- dmitryminkovsky 6y agoI really enjoy how TS is the same on server and client. The C# runtime is way richer, but I like the TS type system more. Not sure I’d want to use different platforms on backend/front end even if C# did server rendering like React.
- manigandham 6y ago
- nimish 6y agoI remember using this in 2013/2014 and there were some serious bugs and issues with silos at load. I'm assuming it's proven scalability? The grain/silo virtual actor model was always cool though the project abandoned it in the end.
- banq 6y agoanother EJB?
- FooBarWidget 6y agoI'm involved in a project that uses Orleans. Conceptually and technically it's very interesting. Nodes automatically cluster together to form a big distributed system, and the concept of "virtual actors" make it possible to represent individual entities in the data model directly as actors, without worrying whether everything fits in memory at the same time. However, Orleans doesn't seem to play very well with Kubernetes. Kubernetes pods can be uncleanly terminated at any time for any reason. Orleans really doesn't like unclean shutdowns: it will leave behind dead entries in the membership tables, which then cause problems in the future because new nodes would contact dead members and run into errors. The clustering protocol also seems to assume that all members have stable identities and IP addresses, but that's obviously not the case in Kubernetes, where each new pod has a new identity and new IP address. This can cause members to fail uncleanly, which in turn pushes the clustering protocol into an infinite loop. Orleans was introduced by one person who has a background in distributed computing. Unfortunately, he's the only one in the organization with such a background. After he left, nobody could debug clustering problems.
- reubenbond 6y agoThere is a new package which adds improved Kubernetes integration and fixes the issues you mentioned specifically. It's in beta right now, but we expect a stable release soon. Feel free to contact me and I can help you with running Orleans on Kubernetes
- bobuk 6y agoI'm interested, is there any urls to read about this package?
- greyhoundracing 6y agoYou can read more about it here: https://github.com/dotnet/orleans/pull/6707 https://github.com/dotnet/orleans/pull/6707
- deleted 6y ago[deleted]
- SmartE03 6y agoHaters can continue hating(or decide to grow up). Truth is I've found no ecosystem more productive than .NET in all of my coding. The only problem with .NET is the sheer amount of haters and we fare very well even though. You all screaming performance and techempower stats don't even realise that C#(ASP.NET Core) is 6th placed on techempower's list when you check the composition of all the various benchmarks. All of these without sacrificing readability, compile times, verbosity etc. Or do you want to talk about the agility of the framework, speedy bug fixes, endless innovations and all. Don't even get me started on the tooling. It's unmatched in all of programming. VS2019, VS Code, Rider, dotnet cli etc. Ever heard about Roslyn? Drop your hatred and check out dotnet's current state before jumping into conclusions. C'mon, let's be real. .NET is supreme in the streets of code.