11 June 2025
How Core Git Developers Configure Git
Nice description of some settings that you probably want to configure in your ~/.gitconfig file.
The Epochalypse Project
A couple of people trying to bring some urgency to the 2038 problem. It’s much worse than the Y2K problem and seems to not be getting the attention it deserves, especially considering that it’s only 12 years away.
Automapper and MediatR Going Commercial
Another OSS project that can’t sustain itself by being free. I guess the biggest surprise is how many OSS projects continue to be free.
The 13 Software Engineering Laws
13 famous and funny laws - described and illustrated with comics.
Behind the 6-digit code: Building HOTP and TOTP from scratch
A simple description of how OTPs work. Actually OTPs are pretty simple - you just need a key, an algorithm, and time.
And remember, having MFA is better than not having it, but OTPs are phishable.
Going beyond singleton, scoped, and transient lifetimes - tenant, pooled, and drifter
He briefly describes the three existing .NET Core DI scopes,
and then goes on to describe three theoritical new scopes.
He then goes further to implement the drifter scope - like a singleton,
but you get a new instance after a time interval.
It’s sad he chose that one to implement because I found the other two more interesting.
Although this blog is based on a podcast and blog that describes how to implement a
tenant scope,
so I guess there was no point repeating that.
Creating a ‘pooled’ dependency injection lifetime
nvm! Here’s an implementation of the other one.
Behind the scenes of the new field keyword in C# 14
This whole article is sprinkled with the idea of “idiomatic tension”, which basically means: “We already have too many ways to do this, and now there’s one more”. There were already six ways to define properties. This is a seventh.
As I understood it, it’s basically a way of using a backing field without having to define it, and without it being accessible outside of the field.
1
2
3
4
5
6
7
8
9
10
11
12
13
// adjusting value in the setter
public string? Name
{
get;
set => field = value?.Trim();
}
// default value
public string? Country
{
get;
set => field = value ?? "Unknown";
}
C# 14 – Exploring extension members
And another C# 14 feature. This makes extension methods a bit clearer to define IMO.
Old way:
1
2
3
4
5
public static class MyExtensions
{
public static IEnumerable<int> ValuesLessThan(this IEnumerable<int> source, int threshold)
=> source.Where(x => x < threshold);
}
New way:
1
2
3
4
5
6
7
8
public static class StringExtensions
{
extension(IEnumerable<int> source)
{
public string ValuesGreaterThan(int threshold)
=> source.Where(x => x > threshold);
}
}
But you can also group other extensions on the same type into the extension block.
And also define extension members (members don’t have a this parameter that you need in the old syntax):
1
2
3
4
5
6
7
8
9
10
11
public static class StringExtensions
{
extension(IEnumerable<int> source)
{
public string ValuesGreaterThan(int threshold)
=> source.Where(x => x > threshold);
public IEnumerable<int> ValuesGreaterThanZero
=> source.ValuesGreaterThan(0);
}
}
Using YARP as BFF within .NET Aspire
The title says it all, but it starts off with a list of reasons why you’d want to use BFF (Backend for Frontend) in the first place, in case you didn’t know already.
How Discord Indexes Trillions of Messages
This is an update to a post from 2017: How Discord Indexes Billions of Messages describing cracks started showing in the Elasticsearch and Redis infrastructure as they scaled up, and how they moved to smaller clusters of Elasticsearch and PubSub on Kubernetes.
Senior engineers should make side bets
Making the case that senior engineers (but not juniors) should work on side projects that might not have any value, but might be worth the risk.
This is basically what I’m doing here with R&D!
Side bets are risky, but if they fail, no-one notices and you’ve “wasted” some time. But a successful bet pays off big time.
How JavaScript Works Behind the Scenes
A nice a clear description of a complex subject:
how JavaScript, which is single-threaded, can do async.
The secret is:
- Call Stack
- Web APIs
- Task Queue (aka Callback Queue)
- Event Loop
- Microtask Queue
- Promise-based APIs (Web APIs that return Promises)
And it’s all quite predicatable if you know how it works!