Kafunk | Rebus | |
---|---|---|
1 | 16 | |
159 | 2,235 | |
- | 0.5% | |
1.7 | 8.4 | |
- | 12 days ago | |
F# | C# | |
- | GNU General Public License v3.0 or later |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
Kafunk
-
Walmart is migrating the remaining F# code into Java
Performance.
Generally speaking, F# was actually very fast, and had nice concurrency support, but there were times that wasn't the case.
For example, in 2016 I was part of the initiative to rewrite the ad feed. We had to read in several Kafka topics, do some joining on our end, and emit to a separate Kafka topic. This isn't terribly hard to write, but we were dealing on the order of about ~100gb of data being pushed into memory. This is hardly "big data" stuff, but it's enough to highlight some issues.
Specifically, the built F# persistent map structure was simply too slow to get the performance we wanted. I really like that structure, it's really handy and nice, but I ended up having to make heavy use of the ConcurrentDictionary that was built into .NET. This wasn't that hard or anything, but it made me a little sad that I had to move to a mutable store to get the performance I needed.
There was also the fact that the `async` monad, while generally very good and useful, had bizarre bottlenecks that were hard to measure. It was difficult to know when the async task was actually started, and when you tried to measure performance bottlenecks you were really only measuring the scheduler, not the actual performance. This isn't really F#'s fault, this is an issue with any kind of cooperative scheduling system, but occasionally to get the performance we needed we'd have to move to lower level threads instead of the pretty monadic stuff. Microsoft eventually released the Task monad which generally performed a bit better.
There were other things here and there; the Kafka client libraries for .NET simply aren't as good as the Java ones. Jet actually open-sourced their own (https://github.com/jet/kafunk) which did make it a bit more functional and nice, but it had performance issues as well, so a lot of us ended up using Confluent.
There were little annoyances specific to F# as well; there's no real concept of a monad transformer, so if you wanted to do something like, for example, combine an Option and an Async into generalized syntax, you'd have to write your own wrapper monad thing, which wasn't that hard but was sort of ad hoc.
The general rule of thumb was that the first draft of software, we would try and keep as functional and pretty. If that was too slow, we allowed mutation but only within a function. If that was too slow, we'd allow global mutation but only with thread-safe stuff.
Rebus
-
Message Queueing
I can recommend Rebus: https://github.com/rebus-org/Rebus β itβs the one I know best, because I made most of it π€ and it even has a Pro option, if you feel like upgrading in that direction too some time in the future.
-
how do you develop locally using Azure Service Bus?
The whole trick is that that's the headache of the implementor of the abstraction π (e.g. me, if you're using Rebus).
-
Agnostic Messaging Provider - Azure/Google/AWS
Rebus (https://github.com/rebus-org/Rebus)
- Which library do you use for message bus abstraction?
-
Pub Sub Framework Recomendations?
For multiprocess application (multiple services, containerized and also natives) I've used ReBus (https://github.com/rebus-org/Rebus) which was is API-compatible (for some version) with NServiceBus. We first used NServiceBus with RabbitMQ (Sagas stored in SqlServer) and then after migration to ReBus also messages and queues were in SqlServer.
-
Long-running business processes in F# with Rebus on Azure
Then we add the Rebus and Rebus.ServiceProvider NuGet packages to each project, giving us something like this:
What are some alternatives?
NetMQ - A 100% native C# implementation of ZeroMQ for .NET
MassTransit - Distributed Application Framework for .NET
Hangfire - An easy way to perform background job processing in .NET and .NET Core applications. No Windows Service or separate process required
NServiceBus - Build, version, and monitor better microservices with the most powerful service platform for .NET
RawRabbit - A modern .NET framework for communication over RabbitMq
RabbitMQ.NET - RabbitMQ .NET client for .NET Standard 2.0+ and .NET 4.6.2+
Kafka Client
EasyNetQ - An easy to use .NET API for RabbitMQ
Confluent's .NET Client for Apache KafkaTM - Confluent's Apache Kafka .NET client
CAP - Distributed transaction solution in micro-service base on eventually consistency, also an eventbus with Outbox pattern