Coding Militia

Well, this is a different and unexpected post, with a story of I what I can only describe as carelessness and incompetence at Buy Me a Coffee

Got the chance to talk about the transactional outbox pattern “On .NET Live”, sharing the recording here if anyone’s interested.

A quick post on adapting your approach to the problem at hand, not just following the same ideas indiscriminately.

An half-rant, half-reflection on the importance of professionalism, taking pride in one’s work, and the role of ambition in career growth.

Time for a quick post about Problem Details, and how we adopted it at work, in a way that’s actually useful.

This post is all about how I’ve been building APIs and microservices lately (using .NET and C#), what’s been making me productive, and how my approach has evolved over time.

Have you ever felt the need to automate the discovery of some information within a distributed system?

Time again for a rant adjacent post, on this occasion, about building applications following some domain-driven design ideas.

After talking about the outbox pattern so much, and implementing it from scratch a few times in a few different projects, finally figured it was high time for me to build something I could reuse.

In this post, we’ll take a very quick look at how to use the awesome FusionCache library, and how to observe its impact on our services.

Spent way too much time trying to get Testcontainers to work with Podman, to find out I just needed to set a flag 🙃.

Transactional outbox pattern and distributed tracing doesn’t seem like having much in common, right?

Quick post about a weird gotcha I found when using distributed tracing with OpenTelemetry .NET, in a system where not all services have otel setup

Quick post comparing the usage of different types as dictionary keys, including using custom types instead of only primitive types.

For some time now, I’ve been thinking about implementing a parallel Kafka consumer proof of concept in C#.

Using arrays as a dictionary key is not really something very common, but I had the need for it, so did some investigation to try and figure out a good way to do it.

Observability has been one of the hot topics, with the increasing complexity of knowing what is going on in our applications.

Making use of the type system is something I feel should be important when working in a strongly typed language like C#.

I’ve been trying to flee the over-engineered C# solution structures, with multiple projects, with related code scattered around.

On the topics of domain-driven design and event-driven architecture, something that’s been on my mind for quite some time, is the process of handling domain events, as well as potentially translating them into integration events.

Recently there was a need to use a hierarchy in a domain model, and there was a question about which of the available approaches to use - table per hierarchy (TPH), table per type (TPT) or table per concrete type (TPC).

This will be a very brief post, just as a reminder that we need to give things a good thought, trying to limit our biases (I’ll focus on software development, but it’s applicable to everything really).

In C# and .NET land, we’re pretty heavy on the code first approaches, with the odd exception.

I’m pretty late to the C# source generator party, but hey, better late than never 😅.

The boxes developers put themselves into is something I’ve given some thought over time.

I’ve had some of thoughts not exactly résumé-driven development, but more importantly, how engineers, can remain up to date and relevant in the job market, and a recent discussion on LinkedIn reminded me about it.

I’ve been using C# records a lot since the feature was introduced.

Another video on using change data capture (often referred to as CDC), to hook up into the database transaction log, forwarding incoming entries to the outbox table.

I’ve been noticing in recent chats that folks have difficulty explaining why do we use async/await, tasks and related, when building ASP.NET Core applications.

Wanted to very briefly share a tool I’ve come across a couple of months ago: DevToys.

Time for one more video on messing with System.Text.Json, this time to get polymorphic (de)serialization going.

Let’s take a quick look at OpenAPI extensions (which I discovered were a thing last week 😛) and how to add them to our API description using ASP.NET Core and Swashbuckle.

Ah, the joys of integrating with third-party APIs… We always end up having to hammer something to get things working 🤣.

Quick video with an interesting approach to implement the publisher part of the outbox pattern.

This is a tale of a good amount of hours of wasted time, so I’m going to document it so I remember it in the future.

Quick little video about an interesting new logging related feature coming in .NET 6, compile-time logging source generation, as well as related high-performance logging features, which were already present but probably not very well known.

Distributed tracing isn’t a new subject by any means, but there are some more recent developments, namely in terms of standards like W3C Trace Context and OpenTelemetry, that are worth a look.

The upcoming release of ASP.NET Core 6 brings a pretty interesting feature set referred to as “Minimal APIs”.

Don’t know about you, but when I build console applications, pretty is not a word I use to describe them.

As much as it would be simpler, software isn’t something we can ship and forget about, or even just keep adding features without revisiting architecture and design.

Lately I noticed I’m essentially treating virtual methods as a code smell, so thought it could result in an interesting blog post.

Building on the work from the previous post, in this one we make use of GitHub Actions to setup workflows for easy setup and tear down of a demo environment in Azure.

As I’m preparing some demos using Azure services, wanted to have things in place so I can easily setup the whole environment.

In the past two posts on the path to publish a NuGet package, we started by setting up the build with NUKE and running it with GitHub Actions.

In a previous post, we started to prepare the build pipeline for a new library, using NUKE.

I know I’m late to the party, but just recently had the opportunity to start using nullable reference types more seriously, so thought of gathering the first steps taken to go all-in with it.

.NET Conf 2020 is done and .NET 5 is finally here!

Let’s take a look at NUKE, a cross-platform build automation system with C# DSL.

Almost two years have passed since I started the “ASP.NET Core: From 0 to Overkill” series.

Sharing my experience about my path to learn about Kubernetes and prepare for the Certified Kubernetes Application Developer (CKAD) exam.