David Gardiner

Exceptional unit tests

2026-04-01T09:30:00.000+10:30

I was working on a .NET application that had a nice suite of unit tests, and pleasingly the tests were all passing.

While making a change to the code, one of the tests failed (which is the whole point of having tests!). To better understand the reason for the failure I re-ran the test in the Visual Studio debugger.

I noticed something strange - the system under test was throwing a NullReferenceException, which was then being caught (and effectively swallowed) by an outer try/catch block.

The surprising thing was that this test should not have been doing that - a pretty straightforward test of some business logic. It was just a coincidence that in this case the exception wasn't changing the observable behaviour of the code, which is why the test had previously been passing.

In this case, the underlying cause of the NullReferenceException turned out to be a missing mocked method on a dependency.

It did make me wonder though, are there other similar issues hidden elsewhere in the unit tests?

To find out, I opened up Visual Studio's Exception Settings window (Debug | Windows | Exception Settings), searched for 'NullReferenceException' and ensured that it was set to 'Break when thrown'

I then ran the entire test suite under the debugger (Test | Debug All Tests) and took note of each time the debugger stopped with a thrown exception. Some of these were other exception types that were expected (and I could turn off the 'Break when thrown' on those if they were too noisy).

I ended up finding a few other tests that had similar issues. There were also some paths in the application code where null handling could be made more robust.

The tests still pass, but they should now be a bit more reliable in the future for the next developer who is relying on them when making application code changes (which could be me!)

Delete old GitHub Actions artifacts with PowerShell

2026-03-21T16:00:00.000+10:30

I received an email from GitHub overnight saying:

You have used 90% of the Actions storage included for the flcdrg account

Your plan includes 2 GB of Actions storage per month at no extra cost. You have used 90% so far this billing cycle. 1.8 GB used / 2 GB included

Oh dear, that's not good. Time for some Spring (or Autumn as it is in Australia) cleaning!

I found a useful post by Elio Struyf - Clean up old GitHub Actions artifacts with a script, which contains a Bash script to delete old artifacts. PowerShell is my preferred scripting language so I first asked Copilot to convert the Bash script to PowerShell.

I then ran it on some repositories that I new had lots of artifacts, but noticed that the paging was not working quite right, and that it was skipping artifacts if it couldn't parse the date field.

I made two changes:

Read all the data in one go using the --paginate --slurp parameters. This solves the problem that I think was happening when you read a page of results, then deleted them, and then asked the API for the next page, but the counts would now be out due to the deleted items.
Ensure the date string is parsed using US date format (as it was defaulting to Australian format and then getting confused with dates that didn't make sense)

Here's the final script:

param(
    [Parameter(Position = 0)]
    [string]$Repo,

    [Parameter(Position = 1)]
    [int]$DaysOld = 5
)

if (-not (Get-Command gh -ErrorAction SilentlyContinue)) {
    Write-Error "GitHub CLI (gh) is not installed or not available in PATH."
    exit 1
}

$null = gh auth status *> $null
if ($LASTEXITCODE -ne 0) {
    Write-Host "Please authenticate with the GitHub CLI using 'gh auth login'."
    exit 1
}

if ([string]::IsNullOrWhiteSpace($Repo)) {
    Write-Host "Usage: .\delete-github-action-artifacts.ps1 <owner/repo> [days-old]"
    Write-Host "Example: .\delete-github-action-artifacts.ps1 owner/repo 5"
    exit 1
}

Write-Host "Cleaning up artifacts older than $DaysOld days for repository: $Repo"

$pagesResponse = gh api --paginate --slurp -H "Accept: application/vnd.github+json" "/repos/$Repo/actions/artifacts?per_page=100" | ConvertFrom-Json
$allArtifacts = @()

foreach ($pageResponse in @($pagesResponse)) {
    if ($null -ne $pageResponse.artifacts) {
        $allArtifacts += @($pageResponse.artifacts)
    }
}

if (-not $allArtifacts -or $allArtifacts.Count -eq 0) {
    Write-Host "No artifacts found."
}
else {
    foreach ($artifact in $allArtifacts) {
        $id = $artifact.id
        $name = $artifact.name
        $createdAt = $artifact.created_at

        if ($null -eq $id -or [string]::IsNullOrWhiteSpace($name) -or [string]::IsNullOrWhiteSpace($createdAt)) {
            $artifactJson = $artifact | ConvertTo-Json -Compress
            Write-Host "Skipping invalid artifact data: $artifactJson"
            continue
        }

        try {
            $createdAtUtc = [DateTimeOffset]::Parse($createdAt, [System.Globalization.CultureInfo]::InvariantCulture).UtcDateTime

            $ageDays = [int][Math]::Floor(([DateTime]::UtcNow - $createdAtUtc).TotalDays)

            if ($ageDays -gt $DaysOld) {
                Write-Host "Deleting artifact: $name (ID: $id, Age: $ageDays days)"
                $null = gh api -X DELETE "/repos/$Repo/actions/artifacts/$id" 2>$null

                if ($LASTEXITCODE -ne 0) {
                    Write-Host "Failed to delete artifact: $name (ID: $id)"
                }
            }
            else {
                Write-Host "Keeping artifact: $name (ID: $id, Age: $ageDays days, Created At: $createdAt)"
            }

        }
        catch {
            Write-Host "Deleting artifact: $name (ID: $id, Created At: $createdAt)"
            $null = gh api -X DELETE "/repos/$Repo/actions/artifacts/$id" 2>$null

            if ($LASTEXITCODE -ne 0) {
                Write-Host "Failed to delete artifact: $name (ID: $id)"
            }

        }

    }
}

Write-Host "Cleanup completed."

I've also published it as a GitHub Gist at https://gist.github.com/flcdrg/f204fc3f84247fe6247d654c0a673b73

Prevention

The main cause of accumulating artifacts is by using the actions/upload-artifact action in GitHub Actions workflows. I've now updated those actions to include the retention-days property so that artifacts are automatically deleted after a few days.

eg.

      - name: Upload wrangler.jsonc
        uses: actions/upload-artifact@v7
        with:
          name: wrangler.jsonc
          path: wrangler.jsonc
          retention-days: 2

Best of C# 14 - extension members

2026-03-17T08:00:00.000+10:30

Extension methods were introduced way back in 2007 with C# 3. But they only allowed you to add methods to an instance type. Extension Members, a new feature of C# 14, finally 'extend' this concept to properties and static members too.

The classic extension method definition looks like this:

public static class MyExtensions
{
    public static int WordCount(this string str) =>
        str.Split([' ', '.', '?'], StringSplitOptions.RemoveEmptyEntries).Length;
}

The class needed to be static, and the static method's first parameter needs the this modifier.

That style of extension method hasn't gone away, and you're free to keep doing it that way if you like.

But now we can create extension properties or extension methods on types. To do that there's a new extension keyword that is used to create extension blocks. You can use these for extension properties, and extension methods, and also for both of these for types in addition to instances.

public static class Enumerable
{
    // Extension block
    extension(string str) // extension members for string instances
    {
        // Extension method:
        public int WordCount() =>
            str.Split([' ', '.', '?'], StringSplitOptions.RemoveEmptyEntries).Length;

        // Extension property:
        public bool Is80CharsLong =>
            str.Length == 80;
    }    

    extension(string)
    {
        // extension method
        public static string ToTitleCase(string str) =>
            System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(str);

        // extension property
        public static string TwoSpaces => "  ";
    }
}

You use these extension members like this:

var sentence = "This is a sentence of words.";

int wordCount = sentence.WordCount();

var is80CharsLong = sentence.Is80CharsLong;

var title = string.ToTitleCase("hello world");

var indent = string.TwoSpaces;

It's another useful language tool. Used appropriately it could make your codebase easier to understand and allow you to separate concerns.

Possible reasons for not using an `extension` block

I've read that some library authors encountered issues when they migrated their old extension methods to extension blocks and the libraries were targeting older frameworks besides .NET 10. If you need to target older frameworks then test this thoroughly first.
If all you're doing is creating extension methods (no properties or type methods), then it's fine to stick with the old syntax.

Where did this new Files app come from?

2026-03-16T11:00:00.000+10:30

Recently when starting Windows 11 I noticed that a new icon had appeared on the taskbar. It wasn't too long after I'd upgraded to 25H2 so my first assumption was it was part of that. The annoying thing was there wasn't an obvious way to make it go away.

Right-clicking on the icon just gave an option to close the application, but it wasn't permanent. The next time I signed into Windows then there it was again. Kind of annoying.

On my computer, I searched in Windows Settings | Apps, but no 'Files' application was listed - very odd.

Searching online for "Windows 11 Files app" brings up heaps of results, but none matched the icon that I was seeing. So I decided to to a bit of detective work to see if I could figure out what this thing was and where it came from. I looked in Task Manager, and sure enough there's a Files.exe process running:

Ah interesting - there's "M365Companions" in the path. Maybe adding that to my online search keywords might help? Yes, that made all the difference!

I turned up this Overview of Microsoft 365 companion apps documentation. That's more of an IT admin page, but it links to a more end-user friendly Getting started with Microsoft 365 companions page.

That second page does say "You can unpin or remove the apps from your taskbar at any time." which is obviously not correct. Not sure if that'a bug in the software or the documentation.

So it turns out there's 3 of these 'companion' apps:

People companion: Find people in the organization (and others they have communicated with), pin close collaborators to accelerate workflows, and quickly learn about people in current meetings without disrupting workflow.
Files companion: Find your Microsoft 365 files, preview file contents, share files with colleagues, and access recently used documents.
Calendar companion: Access Microsoft 365 calendar, view upcoming events, join meetings, and search appointments directly from the taskbar.

I'm sure someone will find them useful, but for now I just wanted them to go away.

Armed with that extra information I went back to Windows Settings | Apps and this time searched for 'companion'. Sure enough there is a "Microsoft 365 companion apps" app listed.

Clicking on the "..." menu gives an option to Uninstall, or if you click on Advanced options you see something similar to this:

For now I toggled Files off, so it won't start automatically the next time I sign in.

Maybe in the future I might want to make use of these apps, but for now that will do.

Best of C# 14 - field keyword

2026-03-10T22:30:00.000+10:30

C# 14 shipped back in November last year along with .NET 10. I've already given a presentation a number of times on my highlights of .NET 10, which included three features of C# 14 that I think are particularly useful.

The first I'm going to focus on is the new field keyword.

The problem this solves is where you'd really like to avoid having to declare a backing field, but prior to C# 14 as soon as you wanted to include any kind of logic in a getter or setter, then you couldn't use auto properties, but instead you needed to provide a backing field and implement the getter and setter. eg.

private string _msg;
public string Message
{
    get => _msg;
    set => _msg = value ?? throw new ArgumentNullException(nameof(value));
}

Because we're adding validation to the setter, that forced us to introduce the _msg field. And if you can be disciplined that's fine, but the trap is there's nothing to stop other code in the same class from also referencing that, even if it shouldn't. The compiler won't stop you.

To help with scenarios like this, and to reduce the amount of code you need to write, C# 14 introduces the field keyword. It's a way to reference the compiler-generated backing field, but only within the property's getter and setter. Our code now becomes:

public string Message
{
    get;
    set => field = value ?? throw new ArgumentNullException(nameof(value));
}

Our line count is one less, plus we're now not exposing the backing field outside of the property.

Under the hood

When the C# compiler turns the original code into IL (Intermediate Language), it creates something like this:

.field private string _msg

That's how IL represents a regular field.

And if you search the IL generated by code that uses the field keyword, you'll still see a .field entry, but the name is a bit different:

.field private string '<Message2>k__BackingField'
    .custom instance void [System.Runtime]System.Runtime.CompilerServices.CompilerGeneratedAttribute::.ctor()
      = (01 00 00 00 )
    .custom instance void [System.Runtime]System.Diagnostics.DebuggerBrowsableAttribute::.ctor(valuetype [System.Runtime]System.Diagnostics.DebuggerBrowsableState)
      = (01 00 00 00 00 00 00 00 )

<Message2>k__BackingField is not a valid C# identifier, so there's no chance of being able to reference this field by name elsewhere in your C# code. That DebuggerBrowsableAttribute also means that your debugger will choose to not show the field.

But because the compiler knows the name it has assigned to the field, it generates the correct IL for you when you use the field keyword.

Here's the IL generated for the property setter:

IL_0000: ldarg.0      // this
IL_0001: ldarg.1      // 'value'
IL_0002: dup

IL_0003: brtrue.s     IL_0011
IL_0005: pop
IL_0006: ldstr        "value"
IL_000b: newobj       instance void [System.Runtime]System.ArgumentNullException::.ctor(string)
IL_0010: throw
IL_0011: stfld        string Stuff::'<Message>k__BackingField'
IL_0016: ret

The stfld instruction is saving the current value from the stack into the the compiler-generated backing field.

Reasons for not using `field`

If you have legitimate reasons for accessing the backing field elsewhere in the class (such as multiple properties that reference or share the same backing field).
Thread safety using volatile, Interlocked or lock patterns.
Lazy initialisation/caching patterns
Serialization or reflection that makes assumptions about field names

Upgrading Azure Database for PostgreSQL flexible server

2026-02-28T13:00:00.000+10:30

I was working on a project recently that made use of Azure Database for PostgreSQL flexible server. The system had been set up a while ago, and so when I was reviewing the resources in the Azure Portal, I noticed a warning banner for the PostreSQL server:

Your server version will lose standard Azure support on March 31, 2026. Upgrade now to avoid extended support charges starting April 1, 2026.

Terraform was being used for Infrastructure as Code, and it looked similar to this:

resource "azurerm_postgresql_flexible_server" "server" {
  name                              = "psql-postgresql-apps-australiaeast"
  resource_group_name               = data.azurerm_resource_group.rg.name
  location                          = data.azurerm_resource_group.rg.location
  version                           = "11"
  delegated_subnet_id               = azurerm_subnet.example.id
  private_dns_zone_id               = azurerm_private_dns_zone.example.id
  public_network_access_enabled     = false
  administrator_login               = "psqladmin"
  administrator_password_wo         = ephemeral.random_password.postgresql_password.result
  administrator_password_wo_version = 1
  zone                              = "1"

  storage_mb   = 32768
  storage_tier = "P4"

  sku_name   = "B_Standard_B1ms"
  depends_on = [azurerm_private_dns_zone_virtual_network_link.example]
}

As you can see from the code and screenshot above, the PostgreSQL version in use was 11. Doing a bit of research, I found version 11 was first released back in 2018, and the the final minor update 11.22 was released in 2023.

Azure provides standard support for PostgreSQL versions (documented at Azure Database for PostgreSQL version policy). There is also the option of paying for extended support, though in the case of v11 that only gets you to November this year, so just a few extra months.

In my case, I wanted to do a test of the upgrade process first, so I restored a backup of the existing server to a new resource. This essentially creates an exact copy of the server at the same version.

While we are using Infrastructure as Code, I decided to use the Azure Portal to test the upgrade, as I figured if there were any problems, they might be easier to understand, rather than try and interpret weird Terraform/AzureRM errors.

Following the upgrade documentation, I clicked on the Upgrade in the Portal.

This initiates a deployment, which depending on how much data you have and the particular SKU you're running on (eg. how fast the VM you're using is), this may take quite a while. One time it took over an hour (which was important as that may be longer than the default Terraform lifecycle, and also the pipeline job timeouts).

If that succeeds, then you should be good to try the real thing with IaC.

Upgrading with Terraform

To upgrade a major version with Terraform, you need to make a couple of changes to your azurerm_postgresql_flexible_server resource:

The version property should be updated to the desired version
The create_mode property should be set to Update (if it wasn't specified then the default is 'Default')

resource "azurerm_postgresql_flexible_server" "server" {
  name                              = "psql-postgresql-apps-australiaeast"
  resource_group_name               = data.azurerm_resource_group.rg.name
  location                          = data.azurerm_resource_group.rg.location
  version                           = "17"
  delegated_subnet_id               = azurerm_subnet.example.id
  private_dns_zone_id               = azurerm_private_dns_zone.example.id
  public_network_access_enabled     = false
  administrator_login               = "psqladmin"
  administrator_password_wo         = ephemeral.random_password.postgresql_password.result
  administrator_password_wo_version = 1
  zone                              = "1"
  create_mode                       = "Update"

  storage_mb   = 32768
  storage_tier = "P4"

  sku_name   = "B_Standard_B1ms"
  depends_on = [azurerm_private_dns_zone_virtual_network_link.example]
}

The weird thing (which I assume is a side-effect of Terraform state) is that even after you've completed the upgrade, you can't change create_mode back to Default - Terraform will throw an error if you try that. Instead you just need to leave it set to Update, but as long as the version property doesn't change then Terraform will leave it at the same version.

Adjust your timeouts

I was using Azure Pipelines, so I added a timeoutInMinutes property to the job and set it to 90 minutes. Be aware that there are different default and maximum timeouts depending on what kind of build agent you use.

Likewise the Terraform azurerm_postgresql_flexible_server resource has default timeouts. You may want to specify a timeout block to extend those values if necessary.

Gotchas

I hit some compatibility issues with the PostgreSQL instance I was attempting to upgrade. The Portal displayed the following error(s):

The major version upgrade failed precheck. Upgrading shared_preload_libraries library pg_failover_slots from source version 11 to target version 17 is not supported.;
Upgrading shared_preload_libraries library pg_failover_slots from source version 11 to target version 17 is not supported.;
Upgrading shared_preload_libraries library pg_failover_slots from source version 11 to target version 17 is not supported.;
Upgrading shared_preload_libraries library pg_failover_slots from source version 11 to target version 17 is not supported.;
Upgrading shared_preload_libraries library pg_failover_slots from source version 11 to target version 17 is not supported.;
Upgrading with password authentication mode enabled is not allowed from source version MajorVersion11. Please enable SCRAM and reset the passwords prior to retrying the upgrade.

There's two issues here:

The pg_failover_slots shared preloaded library is not supported for upgrading
Legacy MD5 passwords are deprecated in newer versions, and "SCRAM" needs to be enabled

How do we resolve these with Infrastructure as Code? In this case as we're using Terraform, we need to map/import those settings and then we can modify them. We make use of the azurerm_postgresql_flexible_server_configuration resource for this.

The value properties should initially match the existing values (eg. Make sure that Terraform thinks they are unchanged). A trick to get the existing values is to run the Terraform in 'plan' mode and take note of what values it can see from and then copy those into your code.

import {
  to = azurerm_postgresql_flexible_server_configuration.accepted_pasword_auth_method
  id = "${azurerm_resource_group.group.id}/providers/Microsoft.DBforPostgreSQL/flexibleServers/psql-postgresql-apps-australiaeast/configurations/azure.accepted_password_auth_method"
}

resource "azurerm_postgresql_flexible_server_configuration" "accepted_pasword_auth_method" {
  name      = "azure.accepted_password_auth_method"
  server_id = azurerm_postgresql_flexible_server.server.id
  value     = "md5"
}

import {
  to = azurerm_postgresql_flexible_server_configuration.password_encryption
  id = "${azurerm_resource_group.group.id}/providers/Microsoft.DBforPostgreSQL/flexibleServers/psql-postgresql-apps-australiaeast/configurations/password_encryption"
}

resource "azurerm_postgresql_flexible_server_configuration" "password_encryption" {
  name      = "password_encryption"
  server_id = azurerm_postgresql_flexible_server.server.id
  value     = "md5"
}

import {
  to = azurerm_postgresql_flexible_server_configuration.shared_preload_libraries
  id = "${azurerm_resource_group.group.id}/providers/Microsoft.DBforPostgreSQL/flexibleServers/psql-postgresql-apps-australiaeast/configurations/shared_preload_libraries"
}

resource "azurerm_postgresql_flexible_server_configuration" "shared_preload_libraries" {
  name      = "shared_preload_libraries"
  server_id = azurerm_postgresql_flexible_server.server.id
  value     = "anon,auto_explain,pg_cron,pg_failover_slots,pg_hint_plan,pg_partman_bgw,pg_prewarm,pg_stat_statements,pgaudit,pglogical,timescaledb,wal2json"
}

Once you've got those in place then you can make the changes to remove the upgrade block:

resource "azurerm_postgresql_flexible_server_configuration" "accepted_pasword_auth_method" {
  name      = "azure.accepted_password_auth_method"
  server_id = azurerm_postgresql_flexible_server.server.id
  value     = "md5,SCRAM-SHA-256"
}

resource "azurerm_postgresql_flexible_server_configuration" "password_encryption" {
  name      = "password_encryption"
  server_id = azurerm_postgresql_flexible_server.server.id
  value     = "SCRAM-SHA-256"
}

resource "azurerm_postgresql_flexible_server_configuration" "shared_preload_libraries" {
  name      = "shared_preload_libraries"
  server_id = azurerm_postgresql_flexible_server.server.id
  value     = "anon,auto_explain,pg_cron,pg_hint_plan,pg_partman_bgw,pg_prewarm,pg_stat_statements,pgaudit,pglogical,timescaledb,wal2json"
}

This will allow any existing MD5 passwords to continue to work, but any new passwords will use the more modern SCRAM-SHA-256.

For the shared_preload_libraries, we've removed the offending pg_failover_slots from the list.

Tips

Temporarily upgrade your server SKU to beefier hardware so the upgrade goes faster. If you're using IaC then make sure you use that to make the change.
Note that if you change the separate storage performance tier (IOPS), you will need to wait 12 hours before downgrading again.

Completion

If everything goes to plan, you should end up with your PostgreSQL resource upgraded to the version that you specified. Here's my resource upgraded to 17.7. v18 is actually available but I wasn't offered it due to 'regional capacity constraints', which explains why the 'Upgrade' button is now disabled.

I've published source code for a working example of Azure Database for PostgreSQL flexible server with an Azure Container app and using a VNet at https://github.com/flcdrg/terraform-azure-postgresql-containerapps

DDD Melbourne 2026

2026-02-23T17:30:00.000+10:30

On Saturday I attended DDD Melbourne 2026. It was great to be back again in Melbourne and attending a DDD conference (instead of organising one!). I got to catch up with some old friends, meet some people for the first time in person and hear some great talks.

SixPivot supported my travel and attendance, which was really appreciated. I also got to catch up with some of my colleagues, some at the conference and another later on Sunday.

I almost missed the start - turns out the curtains in my hotel room were extra effective at blocking out the light. I'd gone back to sleep a few times, figuring it was still too early and then finally I figured I better check what time it actually was, and it was just after 8am! A mad scramble to get showered and dressed and race out the door. Quickly grabbed breakfast from McDonald's and then just made it through registration and grabbed a seat for the start. Just as well my hotel was right around the corner from the conference.

The organising team did a fantastic job this year. The food was good and there was plenty of it - I'd learned from last year that there was no need to queue - they wouldn't run out!

I made handwritten notes for each talk I attended. I've transcribed them here as a more legible record. Even I struggle to read my handwriting, so better to attempt that now rather than later! The notes made sense to me at the time, but whether that's true post event is another question 😃

AI: it's our responsibility - Sreyna Rath

Sreyna gave the keynote presentation.

AI is like a villain developer. A "brilliant jerk" - no values or empathy. No awareness of damage.
Examples
- Gender bias baked in, racial bias
- Amazon hiring
- US Healthcare - used highest cost as proxy for health needs. Black people excluded more often
AI is a mirror
- Data reflects us
- Brilliant jerk culture
- Scale
AI family tree
- Dark side of the Internet
- Microsoft Tay
- Character.AI - suicide
Jaimee - built for women https://jaimee.ai/
How do we fix that?
Compassionate design
- Design for most vulnerable
- Who is most vulnerable?
- What's the worst thing feature?
- How do we prevent that harm?
- Ask right questions
Persona testing
- Test as different race, gender, age, abilities
- Different to you!
AI reviewing AI
- First AI optimised to be helpful
- Second AI reviews the first - optimised for safety
- Eg. Is output sexualised when not requested?
Your "Jedi" toolkit - what kind of Jedi will you be?
AI doesn't have values, it has patterns
The good news: the villain can be reformed
- Jerk => Jedi
"May the framework be with you"

Code is a Conversation: What Are You Really Saying to the Next Developer? - Joel Gallagher

Code is read more often than written
Cognitive load
eg. contrast "The DaVinci Code" (simple, short sentences) vs "A brief history of time" (did anyone ever finish or understand it)
Naming, structure, comments, commits
- Classes and variables = noun
- Functions = verb + noun
Watch out for reserved words
Function size and scope
- Refactor and extract methods
- Reduce depth/complexity
Comments
- Explain the why, not how
- Don't comment out code
Commits
Name, scope, flow, consistency
Tools
- Consistent standards
- Enforce standards
Recommended reading
- Clean code
- Pragmatic Programmer (latest edition)
- Make your code more "DaVinci"

Managing for Failure - Amy Norris

Failure is good
- Website hacked
- Practice recovery
What does failure mean?
- "An emotionally upsetting learning experience"
Why do you want failure?
Hidden risks of "perfect" teams
- Slow to learn, or averse
Feel more comfortable failing. What are you bad at
Example
- Rocket game with faulty controller handle
Rubber ducking
Dig deep
How to encourage teams to be more comfortable with failure
- Share personal failures
- Fire drills
- What not to do
  - Punish behaviours you don't want to see
  - Love your cool
  - Push people too hard
How to keep your boss happy
- Less downtime
- Problems solved faster
- More cohesive team
Alternatively - do whatever you want until someone yells at you!
Low risk
- Board games (make sure they understand it isn't a test)
- Internal projects
Remember people don't know how to fail
Helpful rule:
- THIRTY (minutes of no progress)
- FIFTEEN (minutes to do something else)
- FAIL (get fresh eyes)
Set failure as the goal. eg. "Get rejected by 10 conferences"
Over communicate
- Positive feedback
- Negative feedback
- Expectations
- Changes to plans (including why)
- Questions
Overt positivity
- "Good job me" (without irony)
Remember you're a trash can, not a trash can't

You Aren't Always Right: Resolving Technical Disagreements The Easy Way - Max Downey Twiss

Why is it important to resolve them?
How to we resolve them?
- Reduce scope of disagreement
- Compare reasoning
- Bring in another perspective
- Change the circumstances
- Realise you are wrong!
Techniques
- PR examples
How not to resolve

Designed To Fail: Building Resilient Applications - Callum Whyte

Cloudflare outage
CrowdStrike
Microservices or Monolith
Defining "healthy"
- 200 OK
- Requests/second
- Request performance (better)
Calling an API
- Retries
- Retry + Backoff
- Circuit breaker
  - Opossum
  - Polly
Critical path
- Ecommerce
- Move to event-driven/fire and forget process
Queues
Replicas
- Healthcheck
- Not always reliable though
"Stand-in" platform
- minimal platform running on failover cloud
OpenTelemetry
Chaos monkey/studio
- Polly - chaos simulator methods

The Billion Dollar Blindspot: What happens when everyone thinks alike - Amanda Pitcher

Systems thinker vs spacial specialist
DEIB - Diversity, equity, inclusion, belonging
Just having policy may not equate to true diversity
4 dimensions of diversity
- demographic (often covered by compliance/policy)
- cognitive
- functional
- behavioural
Boeing 737 MAX
- GroupThink
  - Confirmation bias risks
  - Just because everyone agrees doesn't mean they are correct
- Diversity sweet spot
What can we do?
Build psychological safety deliberately
- Set the stage
- Invite participation
- Respond productively - react constructively
Practical tools
Activity to address GroupThink
- Silent start - 5 mins quiet time to let people capture thoughts
- Non-confrontational assent - dot voting / secret ballot
- Separate generation from evaluation
- Team leader - be a puppet and represent quiet voices
- Time pressure kills
- Balance productivity and quality
- "Yes, and.." instead of "No, but.."

Hey LEGO robot, Grab me a Coke! - Daniel Fang

Daniel was the locknote speaker for the conference. I remember meeting Daniel when he spoke at DDD Brisbane

Lots of agents to make a Lego robot grab and move a can of coke.

That's a wrap

What a great team! Thanks again Bron and everyone.

Post-DDD

Sunday morning I grabbed some breakfast at a cute little cafe (Segovia) in an alleyway not far from where I'd been staying. Then I walked to the train station to head out to friends' church in the suburbs. It's a completely different style of worship to my own church, but that's half the fun. Went out to lunch with them and it was great catching up.

Thushan very kindly offered to pick me up and drive me to the airport, which also gave us a chance to chat along the way.

Flight was a little delayed leaving, but it was good to get home Sunday evening. What a great weekend!

A new year, and 5 years at SixPivot

2026-02-03T12:30:00.000+10:30

December and January have come and gone. What's been going on?

I had 3 weeks off over the Christmas/New Years break, which was much appreciated. We didn't go away, but it did give me a chance to do a few jobs around the house. We're renovating our laundry and there was some painting that needed to be done before the new cupboards get installed. The whole process has taken quite a bit longer than we'd hoped but it does feel like the end is in sight.

The Tour Down Under was on recently in Adelaide. On the second Saturday, the men's race came quite close to where we live. I met up with our friend Jane and we hung out at top the King of the Mountain stage finish to cheer all the riders on. If you were watching the TV broadcast I'm the yellow blob to the right of the arch, visible for about 0.2 seconds. That bright yellow 'DDD Adelaide 2025 Organiser' t-shirt comes in handy!

We've already had a number of days over 40°C - Summer is definitely here in Adelaide. On days like that the aim is to keep cool and try and protect our garden and animals from the heat as best we can. Old bedsheets are put to good use! There's actually a Mandarin tree hiding under there.

One other change for the Gardiner family is we've had some new additions:

Vanessa (a 1 year old tortoiseshell-coloured rescue cat) joined us back in May last year. She loves all the girls in the house but just puts up with me. More than once I've gone to start work in the morning (or returning after lunch) and discovered there's an extra "cushion" on my chair. Well I thought it was my chair but I think she has other ideas 😃.

And in early January our chook collection doubled. We're now looking after Peckachoo and Egglet, in addition to our two bantams. They belong to my son and daughter in-law, and needed a new home after friends who had been looking after them on their behalf moved to the country.

The new chooks are full-sized, so in comparison to the bantams they seem huge! But they're settling in well. We've kept them apart from the bantams for now. They're great layers - most days we get an egg from both. I'm hoping it will inspire our bantams (who are not the most reliable in that department) but so far not so much.

Adelaide .NET User Group

Recently the ADNUG organising team caught up for a meal and we started planning out the year. One minor issue we're still trying to solve is a venue. Normally we meet at the University of South Australia's City West campus. But UniSA has just merged with University of Adelaide to become 'Adelaide University' and that was causing a delay in us being able to book our regular room. Merging two large complex organisations is tricky at the best of times, so I can only imagine all the internal systems and processes they're trying to figure out. We've ended up with a different venue for February but hopefully we can be back at City West for April.

DDD Adelaide

I've also spent a bit of time editing some of the videos recorded at DDD Adelaide. I'm not giving up my day job just yet, but starting to figure out more about how to use DaVinci Resolve 😃. You can see the recordings that we've published so far at https://www.youtube.com/@DDDAdelaide.

5 year work anniversary at SixPivot

My first reminder of this was getting some LinkedIn notifications on the weekend. I continue to be grateful for working for a modern, people-focused company. Small enough that I know everyone, but large enough that there is a diverse range of experience and thinking.

After previously working with a few longer-term clients, I've been mixing it up a bit recently with some shorter engagements. I am enjoying the variety.

I've received 500 'good vibes' points for my 'workversary'! I'm due to get a new laptop this year, so I might put them towards that (which I may need to given the price of RAM these days!)

DDD Adelaide 2025

2025-11-23T18:00:00.000+10:30

Yesterday we ran DDD Adelaide 2025 - a community-driven conference for everyone involved in software development and related activities in Adelaide.

With an ever so slightly bigger attendance than last year, our venue again was the University of Adelaide. The delicious catering was provided by Cargo Catering and warm refreshments by B3 Coffee - both who have been with us since 2019.

I think we're starting to find our stride with organising the event. Setup on Saturday morning went smoothly and no major dramas to worry about was good. The only thing beyond our control was the weather. It rained most of the day but at least the 3 lecture theatres and the atrium (where sponsors and food and drinks were located) were all relatively close together, so it didn't put a damper on things 😃

One new thing this year that we're trialling is recording some of the presentations. We've partnered with TxRx Technologies on this and hope to be able to publish some of the sessions in the coming weeks.

Geoffrey Huntley was our keynote speaker. I particularly liked the fact that he came dressed exactly how he appeared in his promo image that we'd used before the conference.

Being one of the organisers, you don't always get a chance to sit in all the sessions, but with this year running smoothly I was able to relax a bit and enjoy some really interesting presentations.

Geoffrey Huntley's keynote

Morning tea and lots of discussions happening

I was then acting as room host for a couple of sessions, including James Bannan with a really interesting talk about the history of Steganography

And Ashley Mannix on Industrial strength testing for complex software

Then lunch! I'm not a vegetarian, but I picked that option as there were some spare ones, and it was really nice.

A few more sessions after lunch and then it was time for afternoon tea, and wow that was so yummy.

Last session I was back room hosting, and caught Samira talking about the challenges of introducing event-driven architecture.

The day finished with Andrew Best and myself hosting the closing prize draws and thank-yous. Another change we introduced this year was that to be eligible for the prizes you had to have submitted some feedback. Turns out that's a great incentive for people to give feedback!

Two bonus highlights for me for the day that I wanted to mention:

Catching up with Nigel Spencer who I worked with way back in 2010 and who is now based in the USA. He timed a trip back to Adelaide to visit family perfectly - or was it a visit to DDD Adelaide and a bit of family catch up on the side? 😃 Random fact: Nigel was a speaker at one of the original CodeCampSA events many years ago that were the predecessor of what is now 'DDD Adelaide'.
Meeting Melissa Houghton in person for the first time. I've known Melissa for a few years but this is the first time we've been in the same place at the same time. She's been involved with organising DDD Melbourne and now DDD Perth, so it was a lovely surprise to discover she'd 'popped' over from Perth to checkout the Adelaide event.

In the next few weeks the organising team will first (and most importantly!) catch our breath, then catch up to review all the feedback that has been submitted and do our final debrief. And then in the new year we'll start planning towards DDD Adelaide 2026!

Thanks to the awesome organising team Andrew, Claire, Harnoor, Isaac, Ryan and Will. What a great team to serve with planning and putting this event on together.

Extra special thanks to my family for stepping up to volunteer on the day. It's a very early start and a long day but they were wonderful.

Aspire with Python, React, Rust and Node apps

2025-11-17T08:00:00.000+10:30

Aspire (formerly .NET Aspire) is a great way to create observable, production-ready distributed apps by defining a code-based model of services, resources, and connections. It simplifies local development and debugging, as well as deployment.

By their very nature, distributed applications will have at least a few (if not a lot) of components. This presents a challenge both for the local developer experience and for deployment. Aspire seeks to simplify this by allowing you to model the services, resources, and connections in code. With one command you can then not only launch everything locally, but ensure that each service knows how to connect to the other services it needs to function.

You can use it for both development and deployment, or if you already have an existing deployment process you're happy with (eg. Infrastructure as Code/deployment pipelines) you can just use Aspire to simply your local development experience.

Check out my previous post Introducing Aspire for an overview of what Aspire is and how it works.

As part of this year's .NET Conf virtual conference, I presented a talk "Taking .NET out of .NET Aspire - working with non-.NET applications", in which I show how despite Aspire being written in .NET, it can integrate with a whole range of other software languages ecosystems. Here's the recording of that presentation:

One issue with the talk was that it had to be pre-recorded a couple of weeks beforehand, so it was done using the Aspire 9.5 bits. Now that Aspire 13.0 is out, some of the packages that I used from the Community Toolkit in the demo are no longer necessary as Aspire has improved the integration with Python and Node.js applications.

The source code for the demo can be found at https://github.com/flcdrg/aspire-non-dotnet. A quick glance and you might think "there's no .NET or Aspire in this repo" and if you just look at the main branch then you'd be right. There are separate branches where I incrementally integrate each component into Aspire.

The scenario I demo is a 'Pet supplies' e-commerce website, with a React front-end, Python backend API running with MongoDB. The Python backend also talks to a Rust-based payment gateway service, and as a bonus step right at the end I add a Node.js server app to provide random pet jokes!

The technology mix is not unheard of, particularly at some larger organisations where you may have different teams working on different features or services and sometimes they are allowed enough autonomy to choose their own technology stack. Whether this is a case of "using the right tool for the job" or "must use the current shiny new thing" isn't so important. The reality is that for good or other reasons you often find yourself in this situation.

MongoDB

MongoDB is supported out of the box in Aspire. The original process was to launch this via docker compose. Aspire actually supports compose files too (via the Aspire.Hosting.Docker package), but in this case I'm taking advantage of the Aspire.Hosting.MongoDB to configure the MongoDB service, database, and for bonus points, include the Mongo Express management UI. This will still run in a Docker container, but Aspire handles all the configuration for me.

var mongo = builder.AddMongoDB("mongo")
    .WithDataVolume()
    .WithMongoExpress();

var mongodb = mongo.AddDatabase("petstore");

WithDataVolume() means that a Docker volume is created to persist the database data between runs.

The original implementation also has a PowerShell script to populate the database with sample data. I wired up that script so that it gets run automatically when the MongoDB service starts up in Aspire.

var loadData = builder.AddExecutable("load-data", "pwsh", "../mongodb", "-noprofile", "./populate.ps1")
    .WaitFor(mongo)
    .WithArgs("-connectionString")
    .WithArgs(new ConnectionStringReference(mongo.Resource, false));
//.WithExplicitStart();

The script conveniently already had a parameter defined to pass in a connection string, so I take advantage of that.

If you'd prefer to just run the script manually (rather than every time you start Aspire) you could uncomment the .WithExplicitStart() method.

Rust

I've never used the Rust programming language before, but it is becoming increasingly popular, especially where you might previously have used C or C++. Rust uses Cargo as its package manager and build tool. Support for building and running Rust applications is provided by the Community Toolkit's CommunityToolkit.Aspire.Hosting.Rust package.

Configuring the Rust application is quite straightforward with the AddRustApp method. The application has a default port it listens on but allows that to be overridden via the PAYMENT_API_PORT environment variable. Aspire will set that to the appropriate port number by the call to WithHttpEndpoint.

var rust = builder.AddRustApp("rustpaymentapi", "../RustPaymentApi", [])
    .WithHttpEndpoint(env: "PAYMENT_API_PORT");

Node.js

JavaScript is well known as a front end language, but platforms like Node.js allow you to write server-side applications in JavaScript (and TypeScript) too. Aspire 13.0 introduces improved support for JavaScript apps via a new Aspire.Hosting.JavaScript package. This includes the ability to configure using pnpm or yarn package managers (the default being npm).

var nodeApp = builder.AddJavaScriptApp("node-joke-api", "../NodeApp", "start")
    .WithPnpm()
    // If you are using fnm for Node.js version management, you might need to adjust the PATH
    .WithEnvironment("PATH", Environment.GetEnvironmentVariable("PATH") + ";" + Environment.ExpandEnvironmentVariables(@"%USERPROFILE%\AppData\Roaming\fnm\aliases\default"))
    .WithHttpEndpoint(env: "PORT")
    .WithOtlpExporter();

I use fnm (Fast Node Manager) to manage my Node.js versions. This means that the actual node executable is not in the PATH by default, but rather is added (or updated) dynamically as I change directory via my PowerShell profile script. Because that script isn't run by Aspire, I explicity append the fnm default alias directory to the PATH environment variable so that node can be found.

Python

Python is an interesting ecosystem. There are a number of different package managers that will influence how you work with it. Aspire has first-class support for Python applications that use pip via the Aspire.Hosting.Python NuGet package. (See Python apps in Aspire for more details).

I recently worked on a client engagement where they were using uv with their Python applications. Aspire 13.0 now includes direct support for uv (via WithUv()) and uvicorn (with AddUvicornApp()):

var pythonApp = builder.AddUvicornApp("python-api", "../PythonUv", "src.api:app")
    .WithUv()
    .WaitFor(mongo)
    .WaitFor(rust)
    .WaitFor(nodeApp)
    .WithEnvironment("PYTHONIOENCODING", "utf-8")
    .WithEnvironment("MONGO_CONNECTION_STRING", new ConnectionStringReference(mongo.Resource, false))
    .WithEnvironment("PAYMENT_API_BASE_URL", new EndpointReference(rust.Resource, "http"))
    .WithEnvironment("NODE_APP_BASE_URL", ReferenceExpression.Create($"{nodeApp.Resource.GetEndpoint("http")}"))
    .WithHttpHealthCheck("/")
    .WithExternalHttpEndpoints();

We wait for the MongoDB service, the Rust payment service, and the Node.js joke service, so that they have all started before the Python app. We also set up environment variables to pass in the connection strings and endpoints that the Python app needs to connect to those services.

A Vite React Frontend web app

The same Aspire.Hosting.JavaScript package that we used to wire up the Node.js application can also be used for the frontend web app. Helpfully, it specifically includes support for Vite apps

var web = builder.AddViteApp("web", "../web-vite-react")
    .WithPnpm()
    // If you are using fnm for Node.js version management, you might need to adjust the PATH
    .WithEnvironment("PATH", Environment.GetEnvironmentVariable("PATH") + ";" + Environment.ExpandEnvironmentVariables(@"%USERPROFILE%\AppData\Roaming\fnm\aliases\default"))
    .WaitFor(pythonApp)
    .WithEnvironment("VITE_API_BASE_URL", new EndpointReference(pythonApp.Resource, "http"));

Again, because I use fnm to manage my Node.js versions, I need to append the fnm default alias directory to the PATH environment variable so that node can be found.

The frontend application only talks to the Python backend API, so we enusre that service has started first, and set up the VITE_API_BASE_URL environment variable so that the Vite app knows where to find the API.

And with that in place, we can run the entire distributed application locally with a single command:

dotnet run --project ./AspireAppHost/AspireAppHost.csproj --launch-profile http

Not all of the applications I'm using here support HTTPS self-signed development certificates, so I stick with running everything over HTTP for now. This is something that Aspire has improved on in 13.0. Obviously in a production deployment you'd want to use HTTPS everywhere. If I didn't need to set the launch profile, then I could use the Aspire CLI instead:

aspire run

The nice thing about all this is I didn't need to make any changes any of the front end or back end applications to get them to work with Aspire. All the configuration was done in the Aspire host application. This assumes that your applications have provided a 'seam' (eg. environment variables or command line arguments) to allow you to configure things like connection strings, ports, and endpoints.

Here's the final version of AppHost.cs:

var builder = DistributedApplication.CreateBuilder(args);

// MongoDB
var mongo = builder.AddMongoDB("mongo")
    .WithDataVolume()
    .WithMongoExpress();

var mongodb = mongo.AddDatabase("petstore");

var loadData = builder.AddExecutable("load-data", "pwsh", "../mongodb", "-noprofile", "./populate.ps1")
    .WaitFor(mongo)
    .WithArgs("-connectionString")
    .WithArgs(new ConnectionStringReference(mongo.Resource, false));
//.WithExplicitStart();

// Rust service
var rust = builder.AddRustApp("rustpaymentapi", "../RustPaymentApi", [])
    .WithHttpEndpoint(env: "PAYMENT_API_PORT");

// Node.js App
var nodeApp = builder.AddJavaScriptApp("node-joke-api", "../NodeApp", "start")
    .WithPnpm()
    // If you are using fnm for Node.js version management, you might need to adjust the PATH
    .WithEnvironment("PATH", Environment.GetEnvironmentVariable("PATH") + ";" + Environment.ExpandEnvironmentVariables(@"%USERPROFILE%\AppData\Roaming\fnm\aliases\default"))
    .WithHttpEndpoint(env: "PORT")
    .WithOtlpExporter();

// Python API
var pythonApp = builder.AddUvicornApp("python-api", "../PythonUv", "src.api:app")
    .WithUv()
    .WaitFor(mongo)
    .WaitFor(rust)
    .WaitFor(nodeApp)
    .WithEnvironment("PYTHONIOENCODING", "utf-8")
    .WithEnvironment("MONGO_CONNECTION_STRING", new ConnectionStringReference(mongo.Resource, false))
    .WithEnvironment("PAYMENT_API_BASE_URL", new EndpointReference(rust.Resource, "http"))
    .WithEnvironment("NODE_APP_BASE_URL", ReferenceExpression.Create($"{nodeApp.Resource.GetEndpoint("http")}"))
    .WithHttpHealthCheck("/")
    .WithExternalHttpEndpoints();

// Frontend
var web = builder.AddViteApp("web", "../web-vite-react")
    .WithPnpm()
    // If you are using fnm for Node.js version management, you might need to adjust the PATH
    .WithEnvironment("PATH", Environment.GetEnvironmentVariable("PATH") + ";" + Environment.ExpandEnvironmentVariables(@"%USERPROFILE%\AppData\Roaming\fnm\aliases\default"))
    .WaitFor(pythonApp)
    .WithEnvironment("VITE_API_BASE_URL", new EndpointReference(pythonApp.Resource, "http"));

builder.Build().Run();

To get the full benefit of Aspire you will want to take a look at adding OpenTelemetry instrumentation. If you already have that in place then there's probably nothing to change. Aspire will set a bunch of OpenTelemetry-related environment variables for each application. If that'a new thing then you'll get the double benefit of then being able to take advantage of that telemetry when your applications are deployed to production too!

Conclusion

Aspire has the potential to greatly simplify and improve the local development experience for distributed applications - potentially removing the need for numerous scripts and manual steps for a developer to get up and running much more quickly. It's also a tool that can benefit almost every development team, regardless of the technology stack they are using.