Writing
Articles
Long-form pieces on architecture decisions and the reasoning behind them.
28 articles
- C# & .NET7 min read
I or No I, and the Naming of Interfaces
An opinion on why the "I" prefix convention for C# interfaces exists, where it causes harm, and what better naming discipline actually looks like in practice.
- csharp
- interfaces
- dotnet
- code-quality
- C# & .NET8 min read
.NET DI — Service Assignment
Three progressively better approaches to injecting specific interface implementations into particular services using ActivatorUtilities, without registering concrete types in the DI container.
- dotnet
- dependency-injection
- csharp
- design-patterns
- Software Architecture14 min read
Designing a Complex Software System
A structured approach to software architecture using vision, boundaries, and contracts as the three pillars of design, with practical tooling examples from wiki to prototype.
- architecture
- design-patterns
- workflow
- career
- Language Design7 min read
Lezer: A Complex Number Grammar
A walkthrough of building a Lezer parser grammar for complex numbers, explaining the shift/reduce LR algorithm, token definitions, and the whitespace handling trade-offs involved.
- parsing
- language-design
- code-quality
- C# & .NET10 min read
Advanced C# — Controlling Dependencies with Assemblies
How splitting a .NET solution into purposeful abstraction, implementation, and client assemblies isolates change, reduces dependency surface area, and keeps teams unblocked.
- csharp
- dotnet
- assemblies
- architecture
- design-patterns
- Developer Practices10 min read
A Response to "Stop Using If-Else Statements"
An expansion on the popular advice to avoid if-else statements, covering state machines, early returns, object typing via DI, and the cases where if-else is still the right tool.
- design-patterns
- csharp
- code-quality
- dependency-injection
- C# & .NET12 min read
Let's Do Better with Log Messages, Pretty Please
A practical case for designing logging and exception handling strategies early, with context-rich messages that help developers self-correct production issues.
- dotnet
- logging
- csharp
- code-quality
- Developer Practices8 min read
In that Programming Rut…
A reflection on the comfortable patterns experienced developers fall into and how defining your own quality metrics is the first step to breaking out.
- career
- design-patterns
- interfaces
- code-quality
- C# & .NET11 min read
The Self-Identifying Identifier
Why namespaced, path-style identifiers make data more predictable, reduce join complexity, and unlock scalable patterns in both SQL and NoSQL systems.
- database
- architecture
- design-patterns
- sql
- Software Architecture14 min read
Building a Platform: Part 4
How to implement and test platform contracts using test-first development, in-memory implementations, and a single shared test suite run against multiple concrete implementations.
- architecture
- testing
- interfaces
- design-patterns
- C# & .NET7 min read
C# Tip: SQL Executor Service — Extending Functionality
How to use the decorator pattern with a simple ISqlExecutor interface to add cross-cutting concerns like performance logging, exception handling, and multi-tenancy without changing existing code.
- csharp
- dotnet
- dependency-injection
- design-patterns
- database
- Developer Practices10 min read
The True Way to Software Mastery
Why software mastery is a lifelong journey across many disciplines, not a single certification or language expertise.
- career
- code-quality
- design-patterns
- architecture
- Software Architecture26 min read
Building a Platform: Part 3
How to design and prioritize the contracts that hold a software platform together, from stakeholder requirements to APIs, libraries, and data storage.
- architecture
- interfaces
- design-patterns
- database
- C# & .NET7 min read
C# Tip: Formatting Inline SQL
Practical tips for writing readable inline SQL in C# using verbatim strings, keyword capitalization, indentation, and proximity to execution code.
- csharp
- sql
- code-quality
- database
- C# & .NET7 min read
C# Tip: SQL Executor Service — Dependency Injection
Shows how to wire a scoped SQL transaction across multiple repository calls in ASP.NET Core using a transaction accessor service, a resource filter, and a clean IServiceCollection extension method.
- csharp
- sql
- dependency-injection
- dotnet
- Developer Practices16 min read
Following the Rules as a Developer
Uses the Dreyfus model of skill acquisition to argue that coding rules like YAGNI and KISS are essential guardrails for beginners but become flexible guidelines for proficient and expert developers who can weigh the cost of change.
- career
- code-quality
- architecture
- design-patterns
- Software Architecture22 min read
Building a Platform: Part 2
Defines the core vocabulary of platform architecture — modules, distributables, abstractions, contracts, and implementations — and prescribes concrete assembly naming and monorepo structure guidelines for .NET platforms.
- architecture
- assemblies
- interfaces
- dotnet
- C# & .NET16 min read
Advanced C# — Custom Workflow Engine
A step-by-step walkthrough of building a custom workflow engine in C# using activity interfaces, a shared context object, a collection builder, and support for conditionals, loops, and exception handling.
- csharp
- workflow
- design-patterns
- interfaces
- dependency-injection
- C# & .NET10 min read
C# Problem: Alternative Builder Patterns
Explores two C# builder pattern approaches — the traditional build-step pattern and the container/extension-method pattern — and explains when each is the right tool.
- csharp
- design-patterns
- interfaces
- dependency-injection
- Software Architecture12 min read
Building a Platform: Part 1
Covers five types of generalization in software — storage, model, service, contract, and process — and when to apply a bottom-up versus top-down approach to building abstractions.
- architecture
- design-patterns
- interfaces
- csharp
- C# & .NET14 min read
Advanced C# — Common SQL Table Structures
How to design a shared base table structure for multiple entity types and build a generic C# repository framework around it using Dapper, custom attributes, and a SQL statement builder.
- csharp
- sql
- database
- design-patterns
- Software Architecture13 min read
Building a Platform: Part 0
An introduction to Standard Abstraction Layers and what defines a software platform, using the vehicle analogy to map abstraction levels from hardware to systems.
- architecture
- design-patterns
- interfaces
- assemblies
- C# & .NET6 min read
C# Simple Interfaces: Containers
How container interfaces — interfaces that are simply a typed list — enable massively scalable systems through extension methods, as demonstrated by .NET's own IServiceCollection.
- csharp
- interfaces
- dependency-injection
- design-patterns
- Developer Practices8 min read
"That's just my coding style," he replied.
Why "coding style" is never a personal matter on a team, and how the handwriting analogy exposes the difference between messy, clever, and clean code.
- code-quality
- career
- csharp
- C# & .NET9 min read
In-Memory Repositories: A Forgotten Design Tool
How building in-memory repository implementations first — before touching SQL — accelerates design, drives out business rules through TDD, and simplifies the eventual database translation.
- csharp
- testing
- design-patterns
- database
- C# & .NET6 min read
Advanced C# — SQL Server Bulk Upload
Techniques for bulk uploading correlated data collections to SQL Server in a single round-trip using Dapper, User-Defined Table Types, and the MERGE statement.
- csharp
- sql
- database
- dotnet
- C# & .NET4 min read
C# Simple Interfaces: Service
How to design minimal service interfaces in C# and use extension methods to layer friendly method signatures on top without bloating the core contract.
- csharp
- interfaces
- design-patterns
- dependency-injection
- C# & .NET4 min read
C# Problem: Sql Executor Service
How to eliminate SQL connection boilerplate in C# repositories by wrapping Dapper in a reusable ISqlExecutor service.
- csharp
- sql
- dependency-injection
- design-patterns