Image for post
Image for post

Fusion — a small library created as an attempt to challenge the existing architecture of high-load and real-time apps — is going to be 4 months old soon. Here is what happened over these months:

  • We’ve got 300+ stars on GitHub
  • Total # of downloads of “Stl.Fusion” NuGet package approaches 14K.
  • Fusion Samples — initially a single Blazor WASM app project — got hybrid mode (WASM + Server-Side Blazor), authentication, and session tracking. …


The same day .NET 5 was released I shared a single screenshot showing how much faster .NET 5 is relatively to .NET Core 3.1. I promised to share more data later — and here it is.

1. Fusion’s Caching Test — running on Ubuntu + Intel and AMD CPUs

Code: https://github.com/servicetitan/Stl.Fusion.Samples , see “Caching Sample” section there.

Overall, these tests stress an API endpoint fetching a small object from SQL database, the only difference is how it is exposed (locally or via HTTP) and if Fusion is used there to provide transparent caching.

My initial test was performed on Window & AMD CPU, but almost every production service runs on Linux nowadays, so I decided to fix this and add Intel-based system to the test. …


I migrated Fusion to .NET 5 today — and honestly, I was absolutely astonished by the performance boost it brings:

Image for post
Image for post

The output is produced by Fusion’s “Caching” sample, which uses EF Core 5 and ASP.NET Core. The speed on tests producing 20M+ operations/s (#1, #3) is mainly constrained by Fusion’s logic and Castle.DynamicProxy. And tests producing around 100K operations/s are constrained by either EF & SQL Server (#2, #5) or ASP.NET Core (#4 — it’s ~ the same as #5, but relying on Fusion’s caching features). All of this means that:

  • You may expect +20% speed boost in “normal” apps
  • And it can go up to +100%, if we’re talking about relatively fast ASP.NET …


Image for post
Image for post

Even though Amazon’s example isn’t unique in the context of this post, I’ll use it as a first example of efficiency of a modern web service:

Image for post
Image for post

Fetching an HTML of a product page on Amazon — even if you did the same just a fraction of second ago (so nothing really changed), requires 1.3 seconds. And that’s on 1000Gbps AT&T Fiber + WiFi 6 in Los Angeles:

Image for post
Image for post

Amazon servers spend 1.3 seconds to “render” and send you ~ 1MB of text (209KB compressed), or ~ 773KB / second. How good this result is?

I know it’s totally not apples-to-apples comparison, but I still want to illustrate how small this number…


Disclaimer: I am the author of Stl.Fusion — an open-source library helping to address the long-standing problem described in this post. But the problem is real, and the post is relevant even if this library won’t exist.

What’s the biggest difference between the modern and the future web apps?

To answer this question, let’s ask the opposite one first: what’s the most rudimentary UX feature used by almost any web app today?

I nominate this button:

Image for post
Image for post
“Refresh” button in Edge


Image for post
Image for post
The picture there must be

A very short description first:

  • Imagine you could create a Knockout model that includes every piece of data you have — not on a single client, but on every one of your servers and clients! And once something changes there, any client (or server) that has a replica of this piece gets notified about the change.
  • This is what Fusion offers. And surprisingly, it’s not a toy concept — it’s designed to scale nicely.

Now, let’s talk about specific differences. I assume you already know Fusion abstractions support thread-safety, immutability, async support, etc. — in other words, the “must-have” features for server-side scenarios are there. …


Image for post
Image for post
Every post needs a picture :)

Even though both libraries are targeting similar problems (they help to write real-time apps faster), they do this quite differently:

  • SignalR offers an API helping to deliver server-side notifications to the clients (and vice versa). It’s ~ a layer above WebSockets,that helps your server-side code to track clients, group them, and send messages to either individual clients, a group of them, or all the clients connected to hub (~ SignalR server). Besides that, SignalR has clients written in several languages, and I guess they implement connection resilience and some of other must-have features any production app needs.
  • And Fusion, even though it also uses WebSockets, solves a very different problem: it lets you find out when a piece of data you requested earlier gets changed. Fusion’s main selling points are:
    a) it largely automates this complex task by tracking dependencies between such pieces of data
    b) it is capable of doing this even if the data you consume is remote — and that’s exactly what enables Fusion-based real-time UI to work. Fusion offers a “replica service” abstraction, which looks identical to a similar server-side service, but instead of computing the output of any of its methods locally, it invokes a remote counterpart that does this and wires up everything needed to invalidate the replica as soon as matching remote value gets invalidated. …


Yesterday I announced Fusion — a library helping to implement real-time UIs much faster, but more importantly, differently from how it’s done today. And Fusion’s documentation — with pages like Overview and Tutorial — is definitely useful for someone who has already decided to learn it, but a really simple explanation of what Fusion does is missing there. So here it is.

As a bonus, you’ll learn a lot about CAD systems and modern-day manufacturing.

What’s common between Fusion and Incremental Builds?

If you’re a developer knowing about incremental builds, this is the only section you need to read.

Fusion is like an incremental build system, but for any value your code…


Time to announce an open-source project I worked on over the last few months:

Image for post
Image for post

Have you ever dreamed to have an abstraction that magically delivers every change made to you server-side data to every client that displays it? Or a caching API that automatically evicts a cached entry right at the moment it becomes inconsistent with the ground truth?

Stl.Fusion solves both these problems — moreover, it does this almost transparently for you, so most of your code won’t even change.

Fusion in action, syncing server-side state to 3 different clients (instances of the same Blazor app) running in their own browser…


Image for post
Image for post

I decided to write a short post explaining how to estimate the cost of a large event in terms of new COVID-19 infections —to consider whether it makes sense to cancel it or not.

Let’s assume we’re talking about a large contest for kids — let’s say, we expect to see ~250 kids and ~250 parents, all of them are from random parts of California.

As of today, there are 79 confirmed COVID-19 cases in California; combined with ~10 explosion of the number of cases in the U.S. over the last week and ~ a week of a no-symptom period for the infected ones, the multiplier for yet unconfirmed cases might be 10x or more. …

Get the Medium app

A button that says 'Download on the App Store', and if clicked it will lead you to the iOS App store
A button that says 'Get it on, Google Play', and if clicked it will lead you to the Google Play store