Archive
Everything I've written, newest first.
We picked practices by weighing cost against benefit, and AI has changed both sides of the scale. A tour of which practices get cheaper, which feed the model's context and tools, and where to be careful.
Vague claims like some users are affected need enough context before they can support a decision.
The actor model is old, simple and rarely used. Its two primitives, how it handles concurrency, and how I used it in Akka.NET to build a small monitoring tool for on-premise installations.
Building the right software has more to do with telling than with programming. Every story manipulates a little, so own the story and pick the tool that fits your context, from impact mapping to the C4 model.
Complexity feeds on our decisions, and we make the biggest ones when we know the least. Some real examples of keeping it in check, from a stream on top of SQL Server to an outbox in a 20-year-old legacy system.
Practical tips for running Event Storming sessions, from treating the format as flexible to thinking in business facts instead of domain events and practicing before facilitating.
Where validations belong when using MediatR and Clean Architecture, from controllers to use cases to entities, and how to handle UX needs without breaking the boundaries.
Testing is about confidence and money, not dogma. Know the whole spectrum of techniques so you can pick the ones your context needs, from where your tests start to golden masters on legacy code.
Most team knowledge travels by word of mouth, and that doesn't scale. Techniques for writing it down without burying the team in documents, from the README to ADRs, incident reports, Event Storming, and tests that check your conventions.
The small recipes I keep coming back to when doing TDD, from naming tests like business scenarios to building test data and keeping database tests fast.
Legacy software that still pays the bills is a lucky thing to have. Where the pain comes from, why rewriting is rarely the answer, and three anti-corruption layer strategies for growing new software around the old.
Three questions for basing development decisions on data instead of hunches, with examples from a Big Brother website, a legacy product, a slow CI pipeline, and cloud bills.
Dusting off the blog to look back on a year of personal and job changes, joining the Agile Spain board, far too many events, and plans for 2018.
Using an object-oriented language doesn't mean we're doing object-oriented programming. The common ways we get it wrong, where they come from, and what I keep in mind to avoid them.
Message passing as the heart of Alan Kay's object-oriented programming, the kinds of messages objects exchange, and a quick note on classes as blueprints for objects.
What encapsulation really means, why it isn't the same as visibility, how objects retain state, and what that implies for anemic models and properties in C#.
How my idea of object-oriented programming moved past the classic mantras of classes, encapsulation, inheritance and polymorphism, and why nobody quite agrees on what OOP is.
We hold conversations with our code all the time, from the folder structure to the logs in production and the commit history. A tour of where those conversations go wrong, and why business naming matters in all of them.
Why software architecture should be a skill the whole team practices rather than a role reserved for one architect, using the rogue from AD&D 2nd edition as an analogy.
How, what, and with whom to learn once your career has started, from Shuhari and an overflowing cup of tea to mentors, kindred spirits, and choosing the right company.
Leaving the code a little better with every story and bug fix beats piling up technical debt, plus some thoughts on simple design and the cost of undoing.
Even if you don't deploy with Docker, official images let you run Redis, Mongo or even Oracle locally without cluttering your machine.
A personal look back at two years with Codesai on a project in Las Palmas, thanks to the people who made it special, and why I'm moving on.
BenchmarkDotNet measurements of direct, virtual, interface, abstract class, and reflection method calls in .NET, and what the nanosecond differences look like.
A recap of a Twitter debate on primary keys, covering mutable vs immutable keys, natural vs surrogate keys, and when to use GUIDs, sequences, HiLo or an external generator.
From "extreme" programming to freelance to Software Craftsmanship, arguing about loaded words instead of practices gets us nowhere, so give useful feedback instead.
Three common mistakes with test data, repeated values, unnecessary fields and misleading specific values, and how to avoid them to get clearer, more reliable tests.
After a year on a project that pairs a lot, my take on what pair programming does well, what makes it hard, and when it's worth it.
Teams keep decisions long after forgetting why they made them; go back to the principles behind practices and pin down the real problem before solving it.
Why throwing NotImplementedException or returning null to get your first red in TDD defeats its purpose, and how to get a red that actually verifies the test.
A small PowerShell function that uses Marshal.SecureStringToBSTR to turn a SecureString read from the console into plain text for an external program.
Keep Web API actions testable by receiving request data as parameters, first with a custom value provider and then with a cleaner parameter binding attribute.
A tiny in-process event bus built on Reactive Extensions, and how exposing IObservable<T> lets you filter and compose events, using WPF notifications as the example.
How to write a PSTypeConverter and register it with a ps1xml file so PowerShell's Extended Type System converts a custom .NET type into DirectoryInfo.
Using .NET's System.IO.Path.IsPathRooted from PowerShell to detect whether a path parameter is relative and join it with the current directory.
A tour of handy PowerShell automatic variables like $?, $Error, $LastExitCode, $MyInvocation, $PSBoundParameters and $PSScriptRoot, and their gotchas.
An empty pipeline result and a plain $null both look like $null in PowerShell, but wrapping them in @() gives arrays of different lengths.
Using Test-Path with the variable: drive to check whether a script-scoped PowerShell variable exists before using it under Set-StrictMode.
Returning an empty array from a PowerShell function gives you $null unless you use the unary comma trick in the return statement.
Typing PowerShell variables and parameters, like [array] for Get-ChildItem results or DirectoryInfo for paths, avoids surprising behavior.
PowerShell switch parameters aren't booleans but SwitchParameter objects, so check them with IsPresent or ToBool(), especially in Pester tests.
Comparing two identical arrays with -eq in PowerShell doesn't return $true, because the operator filters collections instead of comparing them.
A short pipeline script that generates a .psd1 manifest for every PowerShell module in a folder tree, plus a one-liner to unload modules by company.
How Set-StrictMode -Version 2 catches typos and C#-style function calls in PowerShell scripts, and how typed parameters bring it closer to TypeScript.
Import-Module raises a non-terminating error when the module is missing, so the script keeps going; setting $ErrorActionPreference to Stop fixes it.
Two regular expressions for Visual Studio's find and replace that strip every
Topshelf turns a console application into a Windows service you can debug, run on its own, or install with a single parameter, with far less hassle than the Visual Studio template.
What I liked and disliked about Exceptionless for exploring logs and exceptions, plus the API URL gotcha when hosting it on your own server.
How to tweak a Windows Store app's .csproj so every build outside Visual Studio produces an Appx package for sideloading, with a stable file name per platform.
Invoke-WebRequest downloads in PowerShell can be several times slower because of the progress bar; setting $ProgressPreference to SilentlyContinue fixes it.
The differences between portable class libraries, universal libraries, and shared source projects in .NET, and when each one fits for sharing code across platforms.
Fluent Migrator 1.4 silently ran no migrations because an older 1.3 migrate.exe on the PATH was being used instead of the matching version.
How to load sample data into a WPF ViewModel only at design time, so the XAML designer shows real-looking lists while you adjust styles and layout.