{"@attributes":{"version":"2.0"},"channel":{"title":"Mike Hadlow","link":"https:\/\/mikehadlow.com\/","description":"Recent content on Mike Hadlow","generator":"Hugo","language":"en-us","lastBuildDate":"Wed, 15 Apr 2026 00:00:00 +0000","item":[{"title":"Running individual Bun tests with Zed tasks","link":"https:\/\/mikehadlow.com\/posts\/2026-04-15-running-individual-bun-tests-with-zed-tasks\/","pubDate":"Wed, 15 Apr 2026 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2026-04-15-running-individual-bun-tests-with-zed-tasks\/","description":"

I’m a big fan of the Zed<\/a> editor. It’s been my daily driver\n(when I’ve had a choice) for around a year now. It runs like butter on an\nancient nine-year-old Dell XPS that’s been my Arch Linux hobby machine for a while.\nBack when I was a Windows guy coding in Visual Studio, one of my favourite tools\nwas TestDriven.NET, an open source test runner by Jamie Cansdale. A superpower\nof TestDriven.NET was its ability to run unit tests, or any function, under the\ncursor. It was a simple but immensely powerful\ntool<\/a>.\nI was musing that something similar for Zed would be a fantastic addition. There\ndidn’t appear to be an extension that did what I wanted, and I even considered\ngetting Claude to attempt to write such an extension in Rust, but while\nprompting Claude for how it could work, it suggested an alternative path, Zed\nTasks.<\/p>"},{"title":"Book Review: Vibe Coding by Gene Kim and Steve Yegge","link":"https:\/\/mikehadlow.com\/posts\/2026-02-23-vibe-coding\/","pubDate":"Mon, 23 Feb 2026 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2026-02-23-vibe-coding\/","description":"

For myself and many others, everything changed around November last year. I’d just started to use Codex and Claude Code when Anthropic’s Opus 4.5 was released. It was immediately apparent that this was a step change, both in the capabilities of the models themselves and the tooling that enabled a deep interaction with the CLI. I’d experimented with IDE plugin chatbots and code completion previously, but found it little better than simply asking questions in the web UI. The code completion was too annoying, too often wrong, and interfered with the language-server completions, so I turned it off. The genius of Claude Code was that it meets engineers where they are happiest and most productive, in the CLI. It also seems to play off the strengths of LLMs, in that they are fundamentally text-engines, and what could be more text based than a CLI?<\/p>"},{"title":"Vibe-Coding BlueSky Comments","link":"https:\/\/mikehadlow.com\/posts\/2026-01-30-bluesky-comments-for-hugo\/","pubDate":"Fri, 30 Jan 2026 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2026-01-30-bluesky-comments-for-hugo\/","description":"

I’ve vibe-coded a new commenting system for this blog using BlueSky as the backend. At the bottom of the page\nyou’ll see a call to action to “Join the conversation on BlueSky” which takes you to\na BlueSky post. Any replies to that post will also appear at the bottom of the page, there\nmight even be some there now.<\/p>"},{"title":"Avoid IaaS Lock-In With a SAML Proxy","link":"https:\/\/mikehadlow.com\/posts\/2025-07-17-avoid-identity-vendor-lock-in\/","pubDate":"Thu, 17 Jul 2025 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2025-07-17-avoid-identity-vendor-lock-in\/","description":"

TL;DR Adopting an Identity As A Service (IaaS) provider can save huge\ntime and effort when implementing a B2B SaaS product, but it can also result in\ndeep lock-in with the provider. I explain how deploying a SAML Proxy can\nmitigate this, and provide a case study of migrating hundreds of customers from\none IaaS provider to a competitor instantly and with near zero disruption. I\nalso introduce my new open source SAML\nProxy<\/a>, a fully functional demo that\nyou can try out yourself and modify for your own custom scenarios.<\/em><\/p>"},{"title":"Syncing a Google Docs Spreadsheet to a GitHub Hosted Blog","link":"https:\/\/mikehadlow.com\/posts\/2025-05-09-simple-script-for-a-book-review-blog\/","pubDate":"Fri, 09 May 2025 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2025-05-09-simple-script-for-a-book-review-blog\/","description":"

I read a lot<\/em>. Every year I get through 15 to 20 books, mostly non-fiction, and particularly history. I keep a spreadsheet with a record of the book title and author, and when I started and ended reading it. When I complete a book, I write a short review, usually not more than a paragraph or so. A few years back I also started a music review blog, hosted with GitHub pages, and built using the excellent static site engine Hugo<\/a>. After an initial bout of enthusiasm, it was largely neglected. I am a very lazy man, and even the effort of creating a new markdown file and doing a quick commit proved enough to ensure I didn’t bother with it. But the book review spreadsheet worked, I’ve been pretty good at maintaining it, simply because it’s so little effort. So why not sync the spreadsheet with the review blog? A quick chat with Gemini (my LLM of choice) revealed that it should be a straightforward thing to enable.<\/p>"},{"title":"About","link":"https:\/\/mikehadlow.com\/top\/about\/","pubDate":"Wed, 30 Apr 2025 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/top\/about\/","description":"

\"Mike\"<\/p>\n

Hello! I am Mike Hadlow. I am a software engineer, based in the UK. I’ve been building software professionally for over 20 years. The majority of my career was with Microsoft development tools and technologies and since 2002 primarily with .NET. But for the last 3 years I’ve been working mostly with Node and TypeScript (and a little bit of Elm). During that time I’ve worked on a large range of projects in many different industries, ranging from finance and insurance to the music business. I’ve specialized in large scale software development and focussed particularly on distributed event driven architectures. I’ve worked on diverse platforms including on-premise, Kubernetes, and AWS serverless. My role has varied from software developer to chief software architect along with a small number of non-coding consultancy engagements.<\/p>"},{"title":"Emojis As Favicons","link":"https:\/\/mikehadlow.com\/posts\/2025-05-09-super-simple-svg-favicon\/","pubDate":"Thu, 09 May 2024 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2025-05-09-super-simple-svg-favicon\/","description":"

I’m no designer, and I like to keep things simple and easy to configure. So for the various websites I create I like to have an easy way to create a favicon icon. To do this I use a reusable snippet of SVG that I can customize to have a different color and characters for each site. Here is the SVG for the favicon for this site:<\/p>\n

<svg<\/span> viewBox<\/span>=<\/span>"0 0 100 100"<\/span> xmlns<\/span>=<\/span>"http:\/\/www.w3.org\/2000\/svg"<\/span>>\n<\/span><\/span> <rect<\/span> width<\/span>=<\/span>"100"<\/span> height<\/span>=<\/span>"100"<\/span> fill<\/span>=<\/span>"none"<\/span> rx<\/span>=<\/span>"15"<\/span> \/>\n<\/span><\/span> <g<\/span> transform<\/span>=<\/span>"translate(0, 30)"<\/span> fill<\/span>=<\/span>"white"<\/span> font-size<\/span>=<\/span>"60"<\/span> font-family<\/span>=<\/span>"sans-serif"<\/span>>\n<\/span><\/span> <text<\/span> x<\/span>=<\/span>"0"<\/span> y<\/span>=<\/span>"40"<\/span>>\u2705<\/text<\/span>>\n<\/span><\/span> <\/g<\/span>>\n<\/span><\/span><\/svg<\/span>>\n<\/span><\/span><\/code><\/pre><\/div>
You can customize it for your own site by just replacing the tokens below:<\/p>"},{"title":"Book Review: D3 Start To Finish by Peter Cook","link":"https:\/\/mikehadlow.com\/posts\/2022-06-28-d3-start-to-finish\/","pubDate":"Wed, 13 Jul 2022 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2022-06-28-d3-start-to-finish\/","description":"
In a traditional .NET distributed application, application services (not to be confused with the Kubernetes ‘service’ object) would either be written as IIS hosted web applications or Windows Services. When building .NET (micro)services to be deployed in a Kubernetes<\/a> cluster pretty much every facet of the service needs to be reconsidered, not only the hosting environment but the way configuration is accessed, how logging and monitoring work, and the options for state management and memory considerations. In this post I’ll bring my experience of migrating .NET applications to Kubernetes to enumerate some of the main ways that you’ll need to change the way you write them.<\/p>"},{"title":"Book Review: Team Topologies by Skelton and Pais","link":"https:\/\/mikehadlow.com\/posts\/2022-04-29-team-topologies\/","pubDate":"Fri, 29 Apr 2022 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2022-04-29-team-topologies\/","description":"
This is my book review of Team Topologies<\/a> by Matthew Skelton and Manuel Pais.<\/p>\n
Conway’s Law<\/a>, coined by computer scientist Melvin Conway states:<\/p>\n
\n
Any organization that designs a system (defined broadly) will produce a design whose structure is a copy of the organization’s communication structure.<\/p>\n<\/blockquote>\n
This book is a distillation of Skelton and Pais’s experiences helping teams execute the “reverse Conway maneuver”; using the insight of Conway’s law to structure teams more effectively for software delivery. They present a framework and taxonomy for thinking about teams and their interactions that is immensely helpful for anyone tasked with creating a software organization.<\/p>"},{"title":"C#: Add event handlers dynamically using reflection","link":"https:\/\/mikehadlow.com\/posts\/2022-04-28-event-handlers-by-reflection\/","pubDate":"Thu, 28 Apr 2022 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2022-04-28-event-handlers-by-reflection\/","description":"
Recently I had a situation where I needed to test a class with dozens of event handlers. Rather than manually write the repetitive code to attach the handlers I decided to cheat and use reflection. Since there wasn’t anything immediately available online that I could find, I’m sharing an example here to show how to do it.<\/p>"},{"title":"Book Review: Code That Fits In Your Head by Mark Seeman","link":"https:\/\/mikehadlow.com\/posts\/2022-03-22-code-that-fits-in-your-head\/","pubDate":"Tue, 22 Mar 2022 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2022-03-22-code-that-fits-in-your-head\/","description":"
This is my review of Mark Seemann’s<\/a> new book, Code That Fits In Your Head - Heuristics for Software Engineering<\/a> .<\/p>"},{"title":"How to use Google.Protobuf without code generation in C#","link":"https:\/\/mikehadlow.com\/posts\/2022-03-18-use-google-protobuf-without-code-generation\/","pubDate":"Fri, 18 Mar 2022 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2022-03-18-use-google-protobuf-without-code-generation\/","description":"
The Google.Protobuf<\/code><\/a> NuGet package is the recommended protobuf<\/a> serializer for .NET. The documented way of using it is to code gen both C# models and serializers from .proto<\/code> files using the protoc<\/code> tool. However, sometimes it’s more convenient to do serialization\/deserialization on an ad-hoc basis without code generation. The Google.Protobuf<\/code> NuGet package provides APIs to do this, but they are poorly documented. This post gives a code example for a simple “no-code-gen” serializer.<\/p>"},{"title":"Blocking XREAD From A Redis Stream Using StackExchange.Redis","link":"https:\/\/mikehadlow.com\/posts\/2022-02-18-xread-from-a-redis-stream-using-stackexchange-redis\/","pubDate":"Fri, 18 Feb 2022 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2022-02-18-xread-from-a-redis-stream-using-stackexchange-redis\/","description":"
The StackExchange.Redis<\/a> NuGet package is the most popular .NET client for Redis<\/a>. It’s stable, high-performance, with a great community and wide usage. One of it’s most interesting features is the way it does network multiplexing<\/a>. This allows multi-threaded applications to use a single TCP\/IP connection without blocking. Unfortunately this also means that the library does not support blocking operations such as XREAD BLOCK<\/code>, which is important if you want to leverage Redis Streams<\/a> on .NET. This post offers a work-around for this.<\/p>"},{"title":"Large Numbers of Bindings With RabbitMQ","link":"https:\/\/mikehadlow.com\/posts\/2021-08-19-large-numbers-of-bindings-with-rabbitmq\/","pubDate":"Thu, 19 Aug 2021 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2021-08-19-large-numbers-of-bindings-with-rabbitmq\/","description":"
RabbitMQ (or more specifically the AMQP protocol) provides a degree of flexibility over other message-queue solutions with its exchange-binding-queue model. Some possible solutions to scaling or business issues result in large numbers of bindings being created, perhaps thousands per queue. We tested RabbitMQ to find out what the binding performance limits were and present the results in this post. It seems that large numbers of bindings are not in themselves a performance issue, but on a RabbitMQ cluster, “binding churn” the rate at which they are created and destroyed can have a large impact on message delivery and because bindings can take time to propagate through the cluster there is the possibility of message loss.<\/p>"},{"title":"Register a Microsoft.Extensions.Logging.ILoggerProvider with EasyNetQ","link":"https:\/\/mikehadlow.com\/posts\/2021-08-13-easynetq-iloggerprovider\/","pubDate":"Fri, 13 Aug 2021 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2021-08-13-easynetq-iloggerprovider\/","description":"
EasyNetQ<\/a> is an opinionated fully featured client API for RabbitMQ<\/a>. It provides extensive diagnostic logging capabilities via LibLog<\/a> a logging abstraction that provides support for many common logging libraries. Unfortuntely LigLog doesn’t support Microsoft.Extensions.Logging<\/code>, but this post provides an adaptor, EasyNetQMicrosoftExtensionsLogProvider<\/code> that will allow EasyNetQ to log to a Microsoft.Extensions.Logging.ILoggerProvider<\/code>.<\/p>"},{"title":"How to create a standalone ConsoleLoggerProvider","link":"https:\/\/mikehadlow.com\/posts\/2021-07-21-standalone-consoleloggerprovider\/","pubDate":"Tue, 27 Jul 2021 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2021-07-21-standalone-consoleloggerprovider\/","description":"
If, for whatever reason you want to create a stand alone instance of ConsoleLoggerProvider<\/code> without having to leverage dependency injection and the full Hosting framework, you’ll find that the ConsoleLoggerProvider<\/code>’s constructor requires an instance of an IOptionsMonitor<T><\/code>, the only instance of which OptionsMonitor<T><\/code> in turn has a complex constructor with many dependencies. This all seems like a failure of design on Microsoft’s part. Here I give a simple no-op IOptionsMonitor<T><\/code> implementation to allow one to easily create a ConsoleLoggerProvider<\/code>.<\/p>"},{"title":"Microsoft.Extensions.DependencyInjection object graph writer","link":"https:\/\/mikehadlow.com\/posts\/2021-07-20-service-collection-object-graph-writer\/","pubDate":"Tue, 20 Jul 2021 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2021-07-20-service-collection-object-graph-writer\/","description":"
It’s very useful sometimes to be able to quickly view the object graph created by a dependency injection (or IoC) container, especially when you’re a new starter on an existing project. I was recently attempting to get up to speed on a .NET Core project, but I couldn’t find anything that would output an object graph from the Microsoft.Extensions.DependencyInjection<\/code> IServiceCollection<\/code>, so I wrote a simple class that reads the graph and outputs a basic representation. I’m sharing it here for my own benefit, but also as a starting point if anyone else needs something similar.<\/p>"},{"title":"A Simple Console Periodic Loop in C#","link":"https:\/\/mikehadlow.com\/posts\/2021-07-09-simple-console-loop\/","pubDate":"Fri, 09 Jul 2021 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2021-07-09-simple-console-loop\/","description":"
I found myself writing the same code several times for a simple console periodic loop, so I’m posting the framework here mainly for my own benefit. This uses C# 7’s new async Main entry point and avoids the need to spawn a new thread for the loop. Worth noting though that each iteration after the Task.Delay<\/code> will run on a threadpool thread.<\/p>"},{"title":"Contact","link":"https:\/\/mikehadlow.com\/top\/contact\/","pubDate":"Tue, 06 Jul 2021 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/top\/contact\/","description":"\n \n \n \n \n \n \n 
Service<\/th>\n Address<\/th>\n <\/tr>\n <\/thead>\n 
Email<\/td>\n mike@suteki.co.uk<\/a><\/td>\n <\/tr>\n 
BlueSky<\/td>\n @mikehadlow.com<\/a><\/td>\n <\/tr>\n 
GitHub<\/td>\n @mikehadlow<\/a><\/td>\n <\/tr>\n <\/tbody>\n<\/table>"},{"title":"Welcome To My New Blog","link":"https:\/\/mikehadlow.com\/posts\/2021-07-06-welcome-to-my-new-blog\/","pubDate":"Tue, 06 Jul 2021 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2021-07-06-welcome-to-my-new-blog\/","description":"
I’ve been blogging since 2005 and have written hundreds of posts in that time, but my blogging output has declined somewhat over the last few years. That’s partly laziness on my part, and partly because Twitter provides a much more convenient platform for the quick take, but it’s also because there’s too much friction in publishing a post on my long running Google Blogger<\/a> site Code Rant<\/a>. Google has done little to update the ancient Blogspot platform over the years and it’s showing its age. The effort required to upload and format a blog post is too high, and has effectively disincentivised me from blogging. In the last few years I’ve sometimes managed just a single post per year. So, long overdue, I’ve decided to start a new blog here at mikehadlow.com<\/strong> using modern developer platform technologies. This is the first post.<\/p>"}]}}
This is my review of D3 Start to Finish<\/a> by Peter Cook<\/a>. Peter is a well known author and educator in the world of data visualisation as well as being an in-demand software developer. This is his introductory tutorial to D3<\/a>, a Javascript library used primarily for targetting SVG<\/a> for browser native data visualisations. D3 is a very powerful tool, as a quick browse of the website<\/a> will demonstrate. This book evolved from Peter’s courses on D3 and aims to teach you all you need to know to produce professional D3 based data visualisations.<\/p>"},{"title":"Writing .NET Application Services for Kubernetes","link":"https:\/\/mikehadlow.com\/posts\/2022-06-24-writing-dotnet-services-for-kubernetes\/","pubDate":"Fri, 24 Jun 2022 00:00:00 +0000","guid":"https:\/\/mikehadlow.com\/posts\/2022-06-24-writing-dotnet-services-for-kubernetes\/","description":"