matthewedmondson.com

Matt Edmondson

Producer · Game Developer · Software Engineer · Melbourne, Australia

Notes on game production, engineering, and the places they meet. More about me →

Writing

  • Set Semantics and Deferred Execution in LINQ Except

    A close look at how LINQ's Except works, why it never delegates to the collection's Contains, and how that changes when to materialize a query and which container to use.

  • AI-Assisted Coding vs Vibe Coding

    Two fundamentally different ways to use AI for code. In one, the human is the author and AI accelerates the work. In the other, AI is the author and the human accepts output they may not fully understand. Both have a place. The real problem is not knowing which one is happening.

  • Documents as Bridges: Turning Pressure Into Structure

    External pressure plus internal disagreement is the most common situation a producer faces. The approach I trust most is to turn it into a written document that frames the urgency and preserves the plan, so the argument happens against the document rather than against each other.

  • Crisis-Mode Composure: Authoring Postmortems, Not Pointing Fingers

    Two infrastructure crises played out the same way. Stay calm, work the problem, communicate steadily, recognize the people who got through it alongside the team, and write the postmortem rather than pointing fingers. A producer's playbook for crisis composure as a learnable practice.

  • Design Principles Behind the ktsu.dev .NET Library Catalog

    ktsu.dev is the open-source .NET project I have been building since 2023. The libraries vary in size and scope, but they share four principles that govern what I will build and what I won't. This is the design philosophy underneath the library catalog.

  • Atomic Configuration Persistence for .NET Desktop Applications

    Persisting application config is the kind of work every project does, every project gets slightly wrong, and every project regrets having rolled its own. ktsu.AppDataStorage is the small library I built so I would never write that code again (safe writes, debounced saves, automatic backups, and a one-line API).

  • Type-Safe Strings, Paths, and Physical Quantities in .NET

    Primitive obsession is the bug class where everything is a string or a double and the compiler can't help. ktsu.Semantics is the library I built to make domain types impossible to misuse. Email addresses, file paths, temperatures, and user IDs become first-class types with built-in validation and zero runtime cost over their primitives.

  • Build Infrastructure for 79 .NET Repositories with a Custom MSBuild SDK

    How a custom MSBuild SDK, topological dependency sorting, automated versioning, and cross-repo synchronization keep 79+ independent .NET libraries building and publishing consistently.

  • A Layered Security Architecture for .NET Data Processing

    A layered security architecture for .NET data processing systems: input validation, JWT auth, role-based access, rate limiting, encryption, and security headers with working code.

  • Distributed Tracing and Structured Logging in .NET

    A scientific approach to debugging .NET systems: correlation IDs for request tracing, structured logging, Activity-based distributed tracing, and practical patterns for finding bugs faster.

  • Reducing GC Pressure in .NET with ArrayPool and Span

    Practical techniques for reducing GC pressure in .NET: object pooling, Span<T>, ArrayPool, LOH management, and continuous memory monitoring.

  • Threading and Synchronization Patterns in Production .NET Libraries

    Practical threading patterns from production .NET code, including lock objects as parameters, thread dispatch queues, ReaderWriterLockSlim vs Lock, and how to actually test for thread safety.

  • Eliminating Primitive Obsession in C# with Semantic Types

    How wrapping strings and paths in semantic types catches entire categories of bugs at compile time, and a look at the CRTP-based approach used in the ktsu.dev Semantics library.

  • Enforcing Using Directive Grouping with IDE0055 in C#

    How C#'s IDE0055 formatting rule behaves with using directives, why some formatting problems never trigger a violation, and how to work around it.

  • Object Initialization Order in C# and How to Design Around It

    How C# object initialization order works, why object initializers run after the default constructor, and how to design types around that behavior.

  • Duplicate Project GUIDs and MSBuild Build Server State

    Debugging a cryptic .NET restore error that turns out to expose a design flaw in MSBuild's GUID-based project identity system, and why it bites anyone using Git worktrees or forks.

ktsu.dev GitHub LinkedIn NuGet