realfiction by Frank Quednau

Silencing macOS emoji suggestions

Thu, 07 May 2026 22:45:00 GMT

Apple OSX at some point got this idiotic suggested emojis feature which falls exactly into this category of UX labelled "meant to be helpful, doing the opposite".

There is a way to make it stop. Run this in a terminal:

defaults write /Library/Preferences/FeatureFlags/Domain/UIKit.plist emoji_enhancements -dict-add Enabled -bool NO

A reboot later and the suggestions are gone.

Note that writing to /Library/Preferences requires sudo — if the command above fails with a permission error, prefix it with sudo.

<Info> macOS updates can reset feature flags, so if the suggestions ever come back after an OS update, just run the command again. </Info>

Now, how to fix the other <u>347</u> issues that Tahoe has…

Shareholder value

Sun, 15 Feb 2026 22:15:00 GMT

This cartoon by Tom Toro is an absolute classic, and it really keeps growing on you. Indeed, for a teeny, tiny moment we had so much shareholder value!

The cartoon appeared in the New Yorker, and Tom Toro said himself in an interview that the image is from November 25th 2012.

What is (anti-)conservatism?

Tue, 27 Jan 2026 21:30:00 GMT

I have seen this quote go round here & there, and I simply want to recreate what appears to be a comment from Frank Wilhoit on a post from 2018, just in case it goes away for whatever reason (the blog I'm linking to is similarly old as mine, but we should cover our backs):

There is no such thing as liberalism — or progressivism, etc.

There is only conservatism. No other political philosophy actually exists; by the political analogue of Gresham’s Law, conservatism has driven every other idea out of circulation.

There might be, and should be, anti-conservatism; but it does not yet exist. What would it be? In order to answer that question, it is necessary and sufficient to characterize conservatism. Fortunately, this can be done very concisely.

Conservatism consists of exactly one proposition, to wit:

There must be in-groups whom the law protectes but does not bind, alongside out-groups whom the law binds but does not protect.

There is nothing more or else to it, and there never has been, in any place or time.

For millenia, conservatism had no name, because no other model of polity had ever been proposed. “The king can do no wrong.” In practice, this immunity was always extended to the king’s friends, however fungible a group they might have been. Today, we still have the king’s friends even where there is no king (dictator, etc.). Another way to look at this is that the king is a faction, rather than an individual.

As the core proposition of conservatism is indefensible if stated baldly, it has always been surrounded by an elaborate backwash of pseudophilosophy, amounting over time to millions of pages. All such is axiomatically dishonest and undeserving of serious scrutiny. Today, the accelerating de-education of humanity has reached a point where the market for pseudophilosophy is vanishing; it is, as The Kids Say These Days, tl;dr . All that is left is the core proposition itself — backed up, no longer by misdirection and sophistry, but by violence.

So this tells us what anti-conservatism must be: the proposition that the law cannot protect anyone unless it binds everyone, and cannot bind anyone unless it protects everyone.

Then the appearance arises that the task is to map “liberalism”, or “progressivism”, or “socialism”, or whateverthefuckkindofstupidnoise-ism, onto the core proposition of anti-conservatism.

No, it a’n’t. The task is to throw all those things on the exact same burn pile as the collected works of all the apologists for conservatism, and start fresh. The core proposition of anti-conservatism requires no supplementation and no exegesis. It is as sufficient as it is necessary. What you see is what you get:

The law cannot protect anyone unless it binds everyone; and it cannot bind anyone unless it protects everyone.

Experiences working with Claude Code

Sun, 21 Sep 2025 21:00:00 GMT

<Info icon={false} header="Clarifying my viewpoint on LLMs"> I sort of sit in a bubble on Mastodon where most people are heavily opposed to the current incarnation of AI: LLM-based technology.

I absolutely get it, while many would disagree, I share many values with those people.

There is a lot to criticize and I don't want to reiterate all the points that have already been made:

The way cheap labor (aka modern-day slavery) has been used to categorize the training data
The incredible amounts of electricity and other resources necessary to power the resulting models
The fact that it destroys the democratization of software development
The way how the most relevant players so easily bend the knee to the new US autocracy, which casts a dark shadow on how the technology is being used by the main players.
The way it is being used to put pressure on employees.
…

All of this is not wrong.

But I've lived half a century now. I don't hold humanity to a particularly high standard these days, myself included. As far as apes go, we've had an incredible run. I am actually positive towards the idea that we could develop some sort of new life-form, one that runs on thinking stones. Who am I to accuse and blame the modest, brutal and chaotic origins of something that at some point may become a new form of consciousness?

Oh, I'm with you, LLMs are not the singularity. We haven't yet built models that can keep training themselves, and they cannot experience reality through senses and interaction. These are absolute show-stoppers when it comes to exploring the solution space through Evolution.

But I certainly think it correct that we should keep trying. We humans are not the pinnacle of evolution.

(In fact, nothing ever is—as the solution space gets explored, who has the right to say that one exploration is better than the other?)

I also don't share the very generic sentiment that this technology is useless. Just yesterday, we took a photo my son's assignment, highlighted relevant parts of the text and verbally asked ChatGPT to help us understand and give us an example by solving the first task. The whole interaction worked flawlessly.

This is absolutely bonkers. So the tech makes mistakes? Big deal! It has always been and will be for the foreseeable future dangerous to take decisions made by software as some kind of ultimate truth. Is your software free of mistakes? In fact, is the way I live my life free of mistakes?

Since when do we take marketing claims of VC dudes like Sam Altman at face value and let them dictate what to expect of this new technology? This stuff is far from perfect and yet it enables interactions previously deemed impossible with satisfactory accuracy. It is necessary to start understanding its constraints and put in the work to navigate them. </Info>

For about 2 months I have been using Claude Code here and there at work and in private.

The background? About 25 years of work experience as consultant and later in product development. Most of my career I have been working with C#, HTML, CSS, JavaScript and TypeScript. Our product is now almost 8 years old, and for many things that happen in the system there is prior art.

First assignment

The first assignment I wanted to do with Claude to see how it fares was an Excel Importer for our product's new capability of importing users who are authenticated through our own IdP and not Entra. The task here was to add a new command to our admin console and use things that we already have in place these days and combine them such that we can create users from an Excel file that follows a template and is provided by a customer.

Whatever Claude generates gets a full code review as well as testing before committing the output.

This first usage went fairly well. One thing that I am happy about is that the tool can take certain chores away from me that I like thinking about, but at 50 I don't particularly look forward to coding them out.

I can ask the tool to perform refactorings like "extract the part where we provide a row object for each line into its own class named ExcelFileReader".

The truth is, the initial code is almost always not to the standard of quality I expect in our codebase. It usually does what you wanted it to do, but it will be up to me to bring it into the right shape. This would be annoying if you had to do it all by yourself, but with a combination of JetBrains Rider/ReSharper and telling Claude what refactoring to perform, you get to where you want. Also, the refactoring capabilities in the TypeScript part of the codebase are not as strong and Claude can perform such tasks.

Side note on speed of working

Am I faster now, having this tool? I don't know, probably not. But that to me is somewhat beside the point. Claude can be quite slow and for very small tasks I may end up just doing it myself, as the shuffling of tokens feels wholly inefficient in that situation.

However, the tool may lead me to tackle things that I deem useful but am too lazy to start.

What is the point then?

In my position, I actually end up reviewing far more code than I write myself. I am involved in a number of activities around the software lifecycle, and actually coding is often only a small part of it. So, when I tell Claude what to do, the end result pretty much exercises the same muscles that I am already using, namely code review and giving feedback on what to improve.

Intermezzo: Many customers want access to LLM tools

Truth is: Customers ask for AI tools. Our product is what was in another era called an Intranet. Many customers have tried ChatGPT privately or in their work and are often satisfied with the results.

How can this be?

Those people often work with facts well-known to them (intra-company facts). The fact-checking is trivially done. The LLM can for example help people who aren't used to writing craft a decent article in the tone they're aiming for.

A proof of concept to work on how we can leverage LLMs in our product

On this POC I use Claude regularly, especially for the stuff I don't care about, but is necessary for a nice POC, while focusing on what I do care about.

One comical error I did right when starting the POC was to ask too much in one go, like

Set up an Aspire project containing a minimal API ASP.NET project, a frontend SPA React project with Vite and a YARP-based BFF layer on top of the two projects.

This completely overwhelmed Claude and at some point it even forgot that the whole solution was meant to be set up in Aspire, deleted all Aspire dependencies and wanted to start orchestrating the processes with custom-written code. Hilarious!

Now I know better. The tasks need to stay crisp and clear and focus on specific outcomes. Makes absolute sense, right? I find Claude pretty bad at "architecting". And you know what? That's fine, that's my job after all.

Also, some hard coding stuff, e.g. a nested async iterator in the frontend to stream tokens into one message, while starting a new message with a function call request, I need to do myself. Also fine, I mean, I'm paid for the hard stuff, right?

Writing and Using MCP tools

In between I also wrote two MCP tools that

Start a work item in Azure DevOps and use the work item's content as task input.
Start a PR on a given branch and work item describing what changed.

This is the sort of thing where an LLM can lower the barrier to entry. Looking up the necessary queries and APIs and dependencies to talk to Azure DevOps? Not in this lifetime, I don't think so. Meanwhile, Claude was able to set this part up for me. I fully expect a connoisseur of the Azure DevOps API to look at the code and say things like "This can be simplified, there is a better API for that, etc.", but I understand the code, and the general quality is sufficient for its intended use and maintainability.

I would like to mention the MCP tool Context7, which has helped me perform certain code changes based on current documentation instead of whatever was used to train the current model in use.

What else have I used Claude for?

Code extraction refactorings
Tasks with prior art I can point to. A well-factored codebase is beneficial to good outcomes. "More of the same" works pretty well.
Writing certain tests of high complexity. Yes, some of our tests are ugly and complex, e.g. around sign-in. Yes, sometimes I code first and perform the testing steps afterwards, it happens. Claude can help write me tests, especially when I say what to test for.
Finding something back where I know there should be prior art. Claude can help me find it. "code that fits in your head" is a good mantra, but the totality of ahead's code does not fit in anyone's head at once, so sometimes the question is where we did a certain thing before.

What is crap?

I already mentioned some limitations. What is quite annoying is that in order to stay sharp, it makes sense to reset the context every so often. Then Claude has to spend some time again and again to "relearn" what it needs to know.

What is also often quite sad is that the technology is simply unable to learn from its mistakes. When it systematically fails at a specific problem, you can only hope that it surfaces to the developers at Anthropic at some point. You yourself can't do much about it. One could try to place a "reminder" in the claude.md file, but, well, that is most certainly a big limitation of this technology.

In Conclusion

There is an unfortunate tension that while LLM tools are useful, the usefulness has been dwarfed by investments undertaken by big tech. The limitations are clear by now, and once more, LLMs are no silver bullet. Why some in big tech keep pretending otherwise is probably more dictated by the high financial stakes involved rather than actual outcomes of using the technology.

From my perspective, the monthly subscription cost seems appropriate. I can use the tech when

I have clear directions to give
There is prior art
The code needs to do something concrete rather than focus mainly on maintainability or other non-functional metrics.

I don't get good results when

The directives are too vague
The thing that the code needs to do is non-trivial.

Carl Sagan's Cosmos in the archive

Thu, 26 Jun 2025 23:00:00 GMT

I saw today in a post that Carl Sagan's Cosmos has been made available on archive.org.

This show is about 45 years old and left a huge impression on me as a child. The narrator is Carl Sagan, to me one of our great mentors, an astute observer, a curious person, kind, thoughtful, someone I deeply admire.

The soundtrack contains classical music as well as beautiful songs from Vangelis. The title track of Cosmos is just beautiful and sets the tone of this show.

Here's the link.

The AI files - posts that are leaving an impression

Sat, 07 Jun 2025 19:00:00 GMT

I am not ready yet to form coherent thoughts on AI, or rather, the subject has an almost unfortunate depth as companies with a near-infinite war chest are pouring billions upon billions of cash into LLMs to make the subject completely unavoidable in tech, drowning any critical voices by the sheer mass that has been put into motion to only God knows which direction.

Of course, many people have been thinking about the subject and this post collect a number of articles from people who still try to retain their own voice within a vast growing sea of AI slop. This post is mostly a collection of links to articles that have me thinking about the current trends in IT tech.

People Are Losing Loved Ones to AI-Fueled Spiritual Fantasies

At Rolling Stone they wrote about people who seem to lose themselves in some alternate reality where LLMs sometimes seem all-too-capable to indulge you in whatever psychosis is becoming part of you.

Vibe coding may well destroy your ability to find solutions to problems out of your own intellect

This mastodon post describes a situation where a colleague is showing some strange behavior.

He basically rotted his own brain by compulsively using ChatGPT in lieu of actually thinking with most any of the projects he was working on. Instead of taking the time to read through code in our framework, look up documentation, or do any sort of debugging, he instead just begged and pleaded with ChatGPT to try and get somewhere because "it was faster."

What are addictive activities? Indeed, repeated actions with variable reward. Prompting a LLM chat window to solve a certain task does carry quite a bit of that, if you think about it.

But, read for yourself.

I Think I'm Done Thinking About genAI For Now

This is an account where the emotional reaction to the current crop of generative AI is strongly negative, alas the author attempts to understand his position and raises awareness to important issues.

I have been trying very hard to correct for this bias, to try to pay attention to the facts and to have a clear-eyed view of these systems’ capabilities. But the feelings are visceral, and the effort to compensate is tiring. It is, in fact, the desire to stop making this particular kind of effort that has me writing up this piece and trying to take an intentional break from the subject, despite its intense relevance.

The rise of Whatever

This was originally titled “I miss when computers were fun”. But in the course of writing it, I discovered that there is a reason computers became less fun, a dark thread woven through a number of events in recent history.

Where's the Shovelware? Why AI Coding Claims Don't Add Up

So if you're a developer feeling pressured to adopt these tools — by your manager, your peers, or the general industry hysteria — trust your gut. If these tools feel clunky, if they're slowing you down, if you're confused how other people can be so productive, you're not broken.

This article is again basically one data-point, but this person made the effort of estimating tasks and then throwing a coin whether he'd do it with AI or not, and then compare the outcome with his estimate. Absolutely interesting stuff.

So where's the shovelware?

I am certain I will add further updates to this post as interesting posts come along.

☁️ Agnostic – On gremlins and graphs

Sun, 04 May 2025 21:30:00 GMT

Time to look at what may be by far the most exotic technology choice in ahead: The use of a graph database in the form of the gremlin endpoint provided by Cosmos.

<figcaption>Speaking of graphs - Aspire allows you to see your Resources and their interdependencies as a graph</figcaption>

This decision was taken about 7 years ago – a good part of it was related to my excellent experiences with graph databases. Microsoft was already offering said endpoint for their Cosmos DB offering, and after some proof of concept we went in.

From today's perspective, I'd rather choose boring tech™ over superior tech™. Case in point, it took me quite some time to settle on what a dockerized version of ahead could use from the list of technologies showcased on the tinkerpop (tinkerpop the tech vs gremlin the language, I assume, although I've never been 100% clear on where to draw the line between the two terms) page.

Generally, the tech feels fairly far away from .NET, even though Gremlin.NET is a capable client to access gremlin-enabled databases.

After some back and forth I settled for Arcade DB. It is a multi-model database (much like Cosmos is) and offers Gremlin-related capabilities, documented here.

The infrastructure

The DB is also available as container – the following code shows how the resource is registered with Aspire:

There's a bit to unpack here:

In Aspire, we can define a connection string also as a resource. This method will then return the Graph DB resource as well as the connection string necessary to connect to it as a resource as well. This is done in the AppHost project as follows:

<Info> In the code you find traces of some conditional resource building - this felt particularly useful for when focusing work on a specific subset of resources. If you know your system well, you may not need to start all services to check on specific aspects of your application. Aspire will allow you to conditionally initiate and reference resources, since, at the end of the day, it is just c# code. </Info>

We can then reference the connection string from the project that needs it. The connection string will appear in the system as a connect string with the name given to the resource (GraphDbConnectionString.Name).

Where things went awry for me is that the documentation of Arcade DB for running it in a container says that you should bind a specific folder in order to have the database files stored beyond container restarts. However, the graph db-related plugin defined its own specific location that was not bound to an external volume and hence all data created while having the solution running was lost after a restart. To counter this behavior I made a copy of the original properties file governing the behavior of the gremlin db plugin:

docker cp ahead_graphdb:/home/arcadedb/config/gremlin-server.properties ./gremlin-server.properties

And then the file is adapted for the relevant setting to point to something in the folder already bound for database data.

gremlin.graph=com.arcadedb.gremlin.ArcadeGraph
gremlin.arcadedb.directory=/data/graph

<br/>

<Info>

If you wanted to have a look into the container's file system, you can do an interactive session with the container like so:

docker exec -it ahead_graphdb sh

provided you gave it the name ahead_graphdb

</Info>

The readme of the solution contains instructions if you want to connect to the database via an interactive console.

The usage

The basic abstractions to use the DB follow those that we established many years ago at ahead:

public interface IAheadGraphDatabase
{
    public Task RunJob(IGremlinJob job);
    public Task<T> RunJob<T>(IGremlinJob<T> job);
}

public interface IGremlinJob
{
    Task Run(IGraphContext graphContext);
}

public interface IGremlinJob<T>
{
    Task<T> Run(IGraphContext graphContext);
}

public interface IGraphContext
{
    Task Run(string query);
    Task<IReadOnlyList<TOut>> Run<TIn,TOut>(Func<GraphTraversalSource,GraphTraversal<TIn,TOut>> query);
}

This forces the packaging of database mutating & querying as jobs, where the constructor plays the role of accepting necessary parameters and the return value typically provides DTOs that are already useful for further processing.

The GraphTraversalSource and other Types come from the Gremlin.NET Nuget package, that also comes with the methods to write a so-called traversal (aka query).

<Info> Interestingly, I was able to use the latest version of Gremlin.NET, which is still not allowed to be used with Cosmos DB. This latest version allows eg to send the traversal request in a binary form, which presumably is more efficient to en- & decode than the usual JSON. </Info>

A simple usage example is implemented in the solution in the "Graph"-page:

Conclusion

After some searching and back & forth, I have a somewhat better feeling about how a migration could look like. Scaling could work with Arcade DB's clustering features or lean into things we've learned around using different resources for different tenants in order to support different data residencies in order to scale horizontally.

Even so, I am still thinking how a migration to a document database could look like - simply for reasons of using even more boring tech™, something a long-lived product can profit immensely from.

☁️ Agnostic – Intermezzo: Insightful spans with OpenTelemetry

Fri, 02 May 2025 19:00:00 GMT

Let's take a short break from looking at service replacements and marvel at the fun that is having good OpenTelemetry data.

When we started ahead many years, OpenTelemetry didn't exist yet. Aspire leans into it quite nicely, providing a dashboard in which captured open telemetry data is seen.

When you start a project from scratch, you may miss exposing open telemetry from your project. This is done through some adequate service registrations, which in the solution I have galvanized into a IHostApplicationBuilder extension method to be found here.

Much of what is encoded there comes directly from the official documentation.

The next challenge was seeing traces that span Frontend and Backend activities when it is correct to do so.

I wasn't quite sure what is going on with OTel support around RabbitMQ, so I decided to do the necessary boilerplate myself.

What I do on the sending side e.g. when enqueueing a message is to create a new Activity:

Let us revisit the sending of the message to RabbitMQ. We will send telemetry information alongside the message in the headers of the message:

What happens in TryInjectTraceContextIntoDictionary? Let's take a look:

The TraceContextPropagator is a helper class from the OpenTelemetry package(s). It helps to inject the proper information into the headers of the message which we will use on the "other side" to attach ourselves to the correct trace context:

This allows us to get traces that span our projects and provide us additional insights into what is going on:

<figcaption>Aspire OpenTelemetry trace of a queueing operation</figcaption>

Essentially the same was done for the Broadcasting part, which allows us to see who consumed a particular broadcast message:

<figcaption>Aspire OpenTelemetry trace of a publish operation</figcaption>

When having a solution spanning multiple processes these insights are extremely valuable in understanding the internal workings of the machine you're creating – a machine that will inevitably increase in complexity as your product grows to be successful with your customers.

☁️ Agnostic – Messaging between servers with RabbitMQ (Publish/Subscribe)

Fri, 25 Apr 2025 21:20:00 GMT

Time to look at the second messaging pattern. A message can have the notion of an event, where you want several systems to be notified.

RabbitMQ's approach here is to declare an Exchange. Every participant interested in messages posted to said exchange create a non-persistent, temporary queue tied to said exchange and dequeue incoming messages to handle them.

The following sequence diagram shows what happens, based on the example outlined in the Ahead.Dockerized solution.

sequenceDiagram
    participant Web
    participant RabbitMQ
    participant Backend

    activate Backend
    activate Web
    Web->>RabbitMQ: DeclareExchange(E)
    deactivate Web
    create participant NotificationGenerator
    Backend ->> NotificationGenerator: IHostedService
    NotificationGenerator->>RabbitMQ: DeclareExchange(E)
    NotificationGenerator->>RabbitMQ: DeclareTemporaryQueue(E)
    create participant SearchIndexUpdater
    Backend ->> SearchIndexUpdater: IHostedService
    deactivate Backend

    SearchIndexUpdater->>RabbitMQ: DeclareExchange(E)
    SearchIndexUpdater->>RabbitMQ: DeclareTemporaryQueue(E)

    activate Web
    Web->>RabbitMQ: Publish(E, M);
    deactivate Web
   
    RabbitMQ->>NotificationGenerator: Enqueue(M, Temporary Queue)
    activate NotificationGenerator
    NotificationGenerator->>NotificationGenerator: Handle message
    deactivate NotificationGenerator
    RabbitMQ->>SearchIndexUpdater: Enqueue(M, Temporary Queue)
    activate SearchIndexUpdater
    SearchIndexUpdater->>SearchIndexUpdater: Do work
    deactivate SearchIndexUpdater

<figcaption> In real life, our "Backend" is an azure functions host project. As such, it comes with many affordances like easy binding to queues on a function/endpoint level. This is represented here by IHostedService instances that run throughout the lifetime of the process. </figcaption>

The so-called BroadcastSender is fairly similar to the queue sender:

public class BroadcastSender(IConnection connection, ILogger<BroadcastSender> logger)
{
    public async Task Send<T>(string broadcastExchange, T message)
}

Then we declare the exchange to be used:

And use the channel once more to publish, this time with a specific PublicationAddress.

This class is then used in the following way:

routeBuilder.MapGet("/publish", async (BroadcastSender sender, Random random) =>
{
    await sender.Send(
        Constants.BroadcastExchanges.UserEvents,
        new PagePublishedEvent(random.Next(1, 1000).ToString()));
    return Results.Extensions.BackToHomeWithMessage("Page has been published!");
});

In the Backend the BroadcastListener also exposes a method to obtain an AsyncEnumerable (done again with a Channel).

The one major difference is the way we set up the queue that is being used.

declaring a queue without any parameters basically makes this a transient queue, with a randomly assigned name which we can pick up via tmpQueue.QueueName

Via injection we can then consume the same message in multiple places, for example like so:

public class SearchIndexUpdater(
    BroadcastListener<PagePublishedEvent> eventBroadcast, 
    ILogger<SearchIndexUpdater> logger) : IHostedService
{
    public Task StartAsync(CancellationToken token)
    {
        logger.LogInformation("Starting Search index updater");
        _ = Task.Run(async () =>
        {
            await foreach (var publishedEvent in eventBroadcast.StartListening(
                    Constants.BroadcastExchanges.UserEvents, 
                    nameof(SearchIndexUpdater), token))
                logger.LogInformation(
                    "Received page published event for page id {pageId}, will update the search index",
                    publishedEvent.PageId);
        }, token);
        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
}

With those infrastructure pieces in place, we leave the lovely world of message-passing with RabbitMQ.

☁️ Agnostic - Messaging between servers with RabbitMQ (Queueing)

Thu, 24 Apr 2025 21:20:00 GMT

Sending messages between processes is an ubiquitous pattern that has been in use for many decades - as such, the available alternatives are plenty.

In the past I have only heard good things about RabbitMQ. What I did not know before I looked at it is that it is able to cover both our Inter-process communication (IPC) requirements by using queues as well as providing a publish / subscribe model.

RabbitMQ as an Aspire resource

Support to use RabbitMQ within an Aspire solution is done via the Aspire.Hosting.RabbitMQ nuget package:

This references two secrets that are defined as ParameterResources:

All of this gets referenced by our two projects Web and Backend (here exemplified with the Backend project).

I only learned of WaitFor a little bit later - which is a very practical way to ensure that an infrastructure resource like RabbitMQ is already available once our own code starts running.

For our playground, I chose sending a queue message for triggering the making of a report and a page published event that in our real system is handled by multiple consumers to perform a number of tasks of which two here are exemplified.

<Info>

A word about RabbitMQ

From the time I've had to look into RabbitMQ, it appears to be a Swiss army knife of messaging.

Queues can take many forms (temporary or well-known, persistent or transient)
Exchanges can be defined and on top of this different strategies can be used to get the message as often and to as many locations as necessary.

If you have IPC demands maybe even between processes written in different programming languages, I suggest that you take a look at RabbitMQ, chances are that it will be able to cover your particular scenarios as it provides clients for a multitude of different environments.

The relevant .NET-specific documentation can be found here. </Info>

Using queues

Queues are a very useful pattern to offload work to a different process as well as helping to ensure that your compute resources don't get overwhelmed, as you have control over how many "workers" may dequeue messages.

<figcaption>Queues as a way to pass a message to a different process and control the workload at any given time</figcaption>

When using RabbitMQ, we should declare the queue we want to use from "both sides", after which we can perform en- & dequeue operations:

sequenceDiagram
    participant Web
    participant RabbitMQ
    participant Backend

    activate Backend
    Backend->>RabbitMQ: DeclareQueue(Q)
    activate RabbitMQ
    RabbitMQ-->>Backend: ok
    deactivate RabbitMQ
    deactivate Backend

    activate Web
    Web->>RabbitMQ: DeclareQueue(Q)
    activate RabbitMQ
    RabbitMQ-->>Web: ok
    Web->>RabbitMQ: Publish(M)
    activate RabbitMQ
    deactivate Web
    RabbitMQ->>Backend: Deliver(M)
    activate Backend
    deactivate RabbitMQ
    deactivate Backend

<figcaption>Declaring Queues is an idempotent operation and is used by "both sides" to ensure a queue</figcaption>

In order to use RabbitMQ, I used the Aspire.RabbitMQ.Client.v7 Nuget, and ensure that it gets set up correctly by adding it to the Services in Program.cs:

builder.AddRabbitMQClient(connectionName: "messaging");

The name messaging is related to how we defined the resource in the Aspire project (see above). By letting our projects reference the resource, the correct information to correctly set up a client is injected into our projects.

Enqueueing

Ahead.Web registers a QueueSender at startup with the following shape:

public class QueueSender(IConnection connection, ILogger<QueueSender> logger) {
    public async Task Send<T>(string queueName, T message)
}

Pretty much everything we want to do with RabbitMQ appears to have to be done with a Channel:

In this demo solution I did not bother making anything from RabbitMQ persistent, hence we do not have to ask for persistence guarantees. Note that…

An exclusive queue can only be used (consumed from, purged, deleted, etc) by its declaring connection

so that would be the wrong thing to use here. The passed in message gets serialized to a byte array (by serializing the message as JSON stored in a variable named body) and sent to the queue:

Dequeueing

A similar helper, but for dequeueing, is defined in the Ahead.Backend project and looks like this:

public class QueueListener<T>(IConnection connection, ILogger<QueueListener<T>> logger)
{
    public async IAsyncEnumerable<T> StartListening(
        string queueName,
        [EnumeratorCancellation] CancellationToken cancellationToken = default)
}

The IAsyncEnumerable needs to be built with the aid of the RabbitMQ client library and the trusty Channel abstraction that .NET provides:

Once more we declare the queue in much the same way as we did on the sending part.

Then we build a so-called consumer that allows us to provide a callback when something is being received:

<GHEmbed repo="ahead-dockerized" branch="snapshot_1" file="Ahead.Backend/Infrastructure/QueueListener.cs" start={28} end={29} /> <figcaption>I am trying to remember why I called the main input to the handling callback "ea" – bad name!</figcaption>

At the core of the handler we deserialize the message and pass it to the Writer part of a Channel instance.

In order to satisfy the signature of the method, we use the Reader part of the Channel:

line 52 also shows how the consumer is associated with the particular queue name.

Given all this Infrastructure we can enqueue a message like

routeBuilder.MapGet("/report", async (QueueSender sender, TimeProvider timeProvider) =>
{
    await sender.Send(
        Constants.QueueNames.Basic,
        new ReportRequest
        {
            Type = "onboarding",
            RelevantDate = timeProvider.GetUtcNow().Date
        });

    return Results.Extensions.BackToHomeWithMessage("Report sent!");
});

and dequeue it as

await foreach (var reportRequest in queue.StartListening(Constants.QueueNames.Basic, cancellationToken))
                logger.LogInformation(
                    "Report request of type {reportType} received for date {reportDate}", 
                    reportRequest.Type,
                    reportRequest.RelevantDate);

Let's put a ✅ on queueing, next will be publishing messages to which others may subscribe.