25 August 2025
Expert Generalists
Nice description of someone who is an export, but without being restricted to a specific area. For example, someone who can join a Python project as an export, but without being an expert in Python specifically. Read the article to understand better. I think I would put myself in this category.
Bloom Filters by Example
A Bloom filter is a data structure designed to tell you, rapidly and memory-efficiently, whether an element is present in a set.
We all know that hashes are used to do this, but how is the hash used, what hash algorithm is best, and other questions.
Augmented Coding: Beyond the Vibes
In vibe coding you don’t care about the code, just the behavior of the system.
In augmented coding you care about the code, its complexity, the tests, & their coverage.
Rejigs: Making Regular Expressions Human-Readable
Looks good! Instead of writing this email validation regex:
1
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
you can write this:
1
2
3
4
5
6
7
8
9
10
var emailRegex =
Rejigs.Create()
.AtStart()
.OneOrMore(r => r.AnyLetterOrDigit().Or().AnyOf("._%+-"))
.Text("@")
.OneOrMore(r => r.AnyLetterOrDigit().Or().AnyOf(".-"))
.Text(".")
.AnyLetterOrDigit().AtLeast(2)
.AtEnd()
.Build();
It generates the same regex, so runtime performance is the same.
How To Review Code
A nice viewpoint about how to look at the bigger picture and not be a jerk.
HTTP/1.1 must die
A list of problems with HTTP/1.1. The protocol is fundamentally flawed and can’t be fixed. HTTP/2 is the solution.
Summarized in the site http1mustdie.com:
attackers can create extreme ambiguity about where one request ends, and the next request starts. HTTP/2+ eliminates this ambiguity
But you need it all the way through from the origin server to the client, so let’s get started!
Supercharge your EF Core debugging with Query Tags
Nice tip - use TagWith to add comments to the generated SQL.
1
2
3
4
5
var expensiveOrders = context.Orders
.TagWith("Finding orders over $1000 for quarterly report")
.Where(o => o.Total > 1000)
.Include(o => o.Customer)
.ToList();
This generates SQL that looks like this:
1
2
3
4
5
-- Finding orders over $1000 for quarterly report
SELECT [o].[Id], [o].[CustomerId], [o].[Total], [c].[Id], [c].[Name]
FROM [Orders] AS [o]
INNER JOIN [Customers] AS [c] ON [o].[CustomerId] = [c].[Id]
WHERE [o].[Total] > 1000.0
which can then easily be tied back to the code that generated it.