BenchmarkDotNet VS Fusion

Let’s look at the first example you see, when you open up BenchmarkDotnet’s website, or Github page.

Or use BenchmarkDotNet which, among other things to get an accurate benchmark, does JIT warmup outside of measurement.

( https://github.com/dotnet/BenchmarkDotNet ).

You can also do proper statistically correct benchmarking by using - https://github.com/dotnet/BenchmarkDotNet. This will run warmup the jit, gauge the overheads, and run your function many times to give you proper data.

take a look at: https://benchmarkdotnet.org/

Yes, weak references are slower than direct calls. How much slower? Heck if I know offhand. But it's usually pretty easy to set up something with Benchmark .NET and find out if it hurts your use case.

For this purpose we are going to use our beloved BenchmarkDotNet tool.

To quantify and compare the performance of the object mapping strategies discussed earlier, we can employ BenchmarkDotNet.

BenchmarkDotNet is a popular open-source library that, as stated in the repo's README.md, helps us to transform methods into benchmarks, track their performance, and share reproducible measurement experiments. Using BenchmarkDotNet feels similar to writing unit tests. It's very important to note that the library only works with console apps. Finally, we can visualize the results in the terminal where the benchmark ran or in user-friendly formats such as markdown, HTML and CSV. We will explore examples of there formats later in the article.

However, obviously this prevents parallelism within the lock, so this only makes sense if you do some other expensive operation in the parallel loop and the string builder is only a small part of it. Performance wise, it may be better to concatenate the results together after the parallel operation, instead of locking inside the loop. You'll have to benchmark it to know for sure.

We’re of course going to be using BenchmarkDotNet for our benchmarks, and you can find all of the code for these over at GitHub. To start, we need an entry point hook for our single Benchmark class that will be defining the permutations of scenarios that we’d like to run. This will be relatively basic as follows:

- Even frequent exchanges like, “Hey, I’m heading to Costco, need anything?” where the follow-up is easier spoken than typed, or may require a brief brainstorming - “Oh, remember our neighbors are visiting us on Sunday?”

That’s how 8 years later (2 years ago) me and my co-founder decided to implement a new chat app.

— Technology —

To make it short, I’ll post just one point here: Actual Chat is based on Fusion (https://github.com/servicetitan/Stl.Fusion) - think MobX / computed observables, but distributed. In Actual Chat, the state it manages spans from our servers to every client app, creating an eventually consistent “state mesh”. The unified state management, where clients and servers use exactly the same abstraction to “observe” the changes happening to any bit of content, is quite a challenge from the technology standpoint. IMO it alone deserves a brief look.

P.S. Thank you for reading up to this point!

P.S. The app is created with Fusion, which is another cool thing for Blazor: https://github.com/servicetitan/Stl.Fusion

So there are different ways how you can do this, there are multiple different protocols for Unity, for example. There is also this more generic state replication framework.

There is this lib: https://github.com/servicetitan/Stl.Fusion

The library benchmarked in the article is Stl.Fusion: https://github.com/servicetitan/Stl.Fusion. I've only learned about it today, and the documentation is a bit messy, but that seems to be a really interesting project. The author describes it as a .Net library to quickly develop efficient, distributed, real-time web applications.

Disagree with every "no" here :) The answer is yes, but you need a fairly fancy "extra": https://github.com/servicetitan/Stl.Fusion/