Not just...
An attempt at making something amusing by reusing snippets of AI-generated text. Read blog post
einarwh
Latest posts
Are we focused yet?
What, if anything, has the impact of OKRs been for software teams that have adopted the practice? Read blog post
What to say
If you want to do a talk at a software conference, it’s not enough to figure out what you want to talk about. You also need to figure out what you want to say. Read blog post
I refuse to play the imitation game
Playing Turing’s imitation game 24/7 sucks. But the good news is we don’t have to. We can just walk away and do our thing. Read blog post
The asymmetry of politeness
Politeness is supposed to be symmetric. That is, reciprocal between people. But unfortunately it’s not always like that. Read blog post
Toe tags for JSON blobs
How do we deal with schemaless JSON documents in applications that continually evolve? I propose attaching a toe tag to each document, linking it to an explicit and immutable schema. Read blog post
How you will leave
I accidentally discovered a poem about human connection in the middle of all the abstracts submitted to a conference. Read blog post
Ask yourself if they could already know
I propose a radical new heuristic to be applied before replying to things online: ask yourself if the original poster could already know. Read blog post
The problem of the pages
Book clubs are great in theory, but they’re hard to do in practice. The reason is simple: they don’t make the problem of having to read the book go away. Read blog post
Nullable vs nullable in C#
In C#, nullable means something very different for reference types and value types, but the syntax is the same for both. That’s bound to lead to problems. Read blog post
Disentangling intertwingled magicks in ASP.NET Core Web APIs
The typical ASP.NET Core Web API relies heavily on at least two kinds of “magick”: model binding and generation of OpenAPI documents. They are joined at the hip through C# type declarations, which are the sources of OpenAPI schemas and the targets of model binding. In this blog post, I take a look at the gotchas and caveats and shortcomings of this arrangement. Read blog post
Book heuristics
You can’t read every book. Which ones can you safely ignore? This blog post contains a handful of heuristics for dodging boring books and finding something interesting to read. Read blog post
Socio-technical is a big word
When someone uses a big word like socio-technical, you would think it would be a starting point for discussing interconnectedness, adaptivity, non-linearity and emergence in those systems. Alas, Read blog post
What's a tomato?
Sometimes a tomato is just a tomato. Most times even. When is a tomato not just a tomato? Almost never. Read blog post
Socio-technical API patterns
When we connect software systems through APIs, we also connect the people who work on those systems. Socio-technical forces tend to favor certain patterns of relationships between provider and consumer. This blog post describes four patterns that I have observed many times in my career: The Millstone, The Mountain (or the Volcano), The Rapids (with or without Beaver Dams) and The Sock Puppet. Read…
The banana test for AI-generated artifacts
The banana test is a simple heuristic to distinguish gimmicks from lasting value. Read blog post
The AI puppet dance
What’s the opportunity cost of being swept up in hype? Read blog post
Inspirational math
A few words about self-help math. Read blog post
Drift into debt
The passing of time is the greatest unsolved problem in software. Technical debt is not an option, it is the inevitable by-product of change and inertia. Over time, we will drift into debt. Read blog post
Don't settle for a playground
What is autonomy for a software team? What do we want it for? Do we really want it? Read blog post
Dragging a dead priest: programs and programmers in time
Code, alas, is dead. It falls upon the poor programmers to make it appear to be alive. Read blog post
NO! Programming as other
Let’s never discuss if programming is art or science again. Read blog post
Programmer vs developer
I am coming to terms with being a programmer. Read blog post
Multiselfing
On identity and context-switching during the pandemic. Read blog post
Conway's mob
How and why intra-team mobs can help fight the rigidity of many software organizations and their code. Read blog post
Into the tar pit
A critique of “Out of the Tar Pit”. Read blog post
Proper JSON and property bags
JSON data can be represented in many different ways in a .NET application (e.g. explicit JSON model, JSON-friendly DTOs and plain old dictionaries). Each representation has their own characteristics in terms of flexibility, readability and verbosity. In this blog post I look at the trade-offs involved and make some recommendations. Read blog post
On the complexity of JSON serialization
We’ve messed up JSON serialization in .NET. In an effort to make it easy and magical, we have turned something simple into something complicated and error-prone. To fix it, we must get rid of accidental complexity and let the serialization process be as simple and stupid as possible. Read blog post
Death of a craftsman
A description of my identity crisis as a programmer, why I’ve rejected craftsmanship and crafting, and what I think we should do instead. Read blog post
Function application in la-la land
The world of programming contains realms of strange values for things that may happen or may have happened, collections of things, things that may or may not be things, and so forth. How do you work with such values in a uniform way? Read blog post
How to reduce bunches of things
What does adding or multiplying integers, concatenating strings, appending lists and composing functions have in common? Read blog post
LINQ to Nullable
What does it take to enable LINQ syntax for Nullable? I consult the C# specification and write some unusual code. Read blog post
Picture combinators and recursive fish
An implementation of Peter Henderson’s Functional Geometry in F#, with a step-by-step guide to make an SVG reproduction of Escher’s Square Limit. Read blog post
Donkey code
A fable about how code quickly can deteriorate under new requirements if we don’t have a conceptual model with the right abstractions to express both new and old requirements. Read blog post
Something for nothing
The problem with null. Read blog post
Pragmatism is poison
Appeal to pragmatism is a logical fallacy. We should make better arguments. Read blog post
Strings with assumptions
A string in a program is never just a string. There are always assumptions about what kind of string it’s going to be. Read blog post
Technical debt isn't technical
Technical debt is a symptom. Read blog post
Thinging names
We’ve got it backwards when we say that “naming things is hard”. The problem isn’t naming, the problem is in coming up with the right things to name. Read blog post
Diamond mirrors
An implementation of the Diamond code kata in F#. Read blog post
Aspects without aspects
Using extension methods in C# to implement a poor man’s version of aspect-oriented programming. Read blog post
Rethrow recoil
Fixing an issue with rethrows in the approach described in the previous blog post. Read blog post
LINQ to Exceptions
A way to attach and compose exception handling blocks to Funcs using extension methods. Read blog post
Another wild tail chase
Read blog post
Chasing your tail with bytecode manipulation
Read blog post
Shrink-wrapped Mkay
Read blog post
Self-referential validation in Mkay
Read blog post
Mkay: One validation attribute to rule them all
Read blog post
Yes, it's an animated Hama bead Larry
Read blog post
The hawk and the tower
Read blog post