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.
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 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.
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.
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.
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.
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.
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.