Scaffolding an existing SQL database with Entity Framework Core in 5 minutes
How to move data from MSSQL to ElasticSearch at galactic speeds
How to add JWT Bearer auth to GraphQL subscriptions on ASP.NET Core 2.1?
How to create GraphQL data loaders for Entity Framework?
Representing coordinates in a human readable way
In an attempt to make coordinates legible without resorting to maps I have tried an approach where I describe the position relative to a know point, such as a city, mountain top, or other landmark.
How can I use cursor based pagination on SQL Server with C#?
Implementing pagination with GraphQL.NET and Relay
I describe the implementation of a cursor based GraphQL API following the Relay specification. Everything is covered, the specification, query composition, and even a real-world sample.
How to automatically load graph types in the DI container.
Entity Framework Core: insert or update, the lazy way
How to send emails from asp.net core using Razor templates?
Asynchronous streams in C# and scrolling through ElasticSearch with NEST
GraphQL.NET: Runtime object type is not a possible type for interface
An algorithm for interpolating or extrapolating two lists
Having my brain eat itself while trying to interpolate two data sets to one another I came up with this working, though overly complicated solution. It works, but can be implemented in a much less convoluted mess.
Hiding React component props within a shadow state
How to add build information to a dockerized React app? (Docker Hub)
Change tracking on detached entities using Entity Framework Core
Accessing the filesystem with an asp.net core app run on Docker
I ran a bunch of experiments to figure out how to access the filesystem from a .NET app running on Docker.
Similar string search with the Levenshtein distance on SQL Server
Recently I have been looking for more flexible ways to search through text within a SQL database, and I stumbled upon a suggestion which indicated to use the so called Levenshtein distance.
Rolling back migrations to a previous version of Entity Framework Core
I discovered there was a dependency incompatibility between EF Core 5 and SqlKata. I weighted my options, and decided it would be easier to revert back to EF Core 3, than to solve this dependency compatibility issue in another way.
React forms on steroids
If there is one thing I hate about web development it is creating input forms. In this post I'm about to explore some techniques to make form creation using React somewhat easier.
Expose a secret as file in Traefik via Helm to configure ACME DNS
How to set up Traefik on Kubernetes?
Recently I started playing around with Traefik on Kubernetes and wanted to request wildcard LetsEncrypt certificates.
Creating event sourced aggregates with C#
The aggregate is a well understood concept within DDD practices. The addition of event sourcing to the mix might however complicate things, and the once pretty domain is now in shambles. In this post I'll cover the addition of ES, while keeping the awesomeness of DDD in place.
Coarse commands emitting granular events
In order to allow an event sourced software system to evolve I believe it to be important to issue coarse commands emitting granular events. In this post I explain why.
Can I map one command to multiple events?
Since it would be beneficial for commands to be able to issue multiple events reflecting its behaviour I modified an earlier approach to event sourced aggregates to allow this use-case.
More transparent command to event transformation
An improvement upon the previously proposed event sourced aggregate where command provides type information about its returned domain events.
What makes an event sourced domain?
In an effort to generalize event sourcing to the whole domain I try to adapt concepts previously developed for aggregates to other domain objects such as services, process managers, sagas and repositories.
How are domains and actor systems related?
A software domain and an actor system both solve specific problems, and yet they complement each other in the creation of scalable and yet testable system. Some thoughts about how they interact.
Using focal points to describe code behaviour
Looking at code through the 'focal points' of the component might clarify a mismatch between the expected behaviour and that what is actually implemented. Organizing code accordingly to these focal points might provide a huge cognitive benefit to maintainers.
Domain integration of external interactions
More often than not a software domain is required to deal with external components and service these must integrate with. Here are some considerations around these integration tasks.
Interaction with and integration of software domains
A software domain has the privilege to live in total isolation from any other component in the codebase, though it must be consumed by other components. By generalizing the interaction pattern to the domain one can greatly simplify these integration points.
How code quality positively impacts the accuracy of estimates
How complex software impacts your cognitive abilities
My presentation on DDD Europe 2022.
The importance of time and coherence in event sourced systems
To make a system more maintainable its temporal characteristics should mimic the way humans perceive the passing of time. Coherence should bind the past and the future through the present, whereas continuity should explain the present by the past.
What is Event Sourcing?
This post attempts to explain event sourcing through examples showing what it is and what it is not, while highlighting some of the strengths and reasons for using it.
How to effectively observe the runtime behaviour of your core domain
Logging statements have no place in the domain. There are multiple better alternatives you should use instead!
There are problems in the software industry that have been solved a hundred-thousand times, and will be solved a hundred-thousand more. Rather than re-inventing solutions to these common problems we should be engaging in a discussion about meta-development practices instead.
The benefits of constraints in a layered architecture
I hypothesize that a codebase which can be navigated by logical rules provides greater accessibility than one that must be navigated through memorization. This is one of the reasons why small teams could benefit from a layered architecture.
Noisy language models
Please no LLMs interfere in my note taking process.