Essays
Writing
Essays on building software, and on building it alongside language models.
25 September 2026
Clean Abstractions Around Libraries
A library boundary owns the application's contract even when its terms match the library's. It contains provider types, validation, failures, and configuration, and keeps replacement possible.
25 September 2026
Intentional Model Design
A model should express required fields, genuine absence, and distinct variants in its type. Python unions and C# records encode those promises, while boundaries check external values.
25 September 2026
Jev: A Practical Reference
Jev makes bounded semantic judgments with Choice, Score, and Noul; code handles exact work and policy, while evaluation and confidence gates determine when to act or escalate.
12 September 2026
Skills versus Controlled Workflows
When a useful answer is enough, and when you also have to demonstrate that a prescribed procedure was followed.
19 August 2026
The AI-Native Lifecycle
What it takes to engineer both gates rather than widen them, when generation runs at machine speed and trust is the thing in short supply.
17 July 2026
Stampede at the Gates
AI did not break the software lifecycle. It removed the speed limit that was concealing how fragile the lifecycle already was.
6 February 2022
Prefer Composition Over Inheritance
Composition keeps a configuration provider's capabilities limited to what its project needs. The refactor uses self-contained settings providers, a shallow base, and restrained reuse.
17 January 2021
Always Use the "as" Operator? No Thank You!
Use a cast instead of `as` when the type is expected, so a mismatch raises InvalidCastException. Use `is` when the type genuinely varies and keep only guards backed by a real case.
20 December 2020
Validating Formal Arguments? No Thank You!
Validate and clean data at the front and back doors; skip checks on internal formal arguments. Immutable DTOs preserve trust, one exception reports all errors, and black box tests exercise the doors.
5 December 2020
Separate State from Behavior? Yes Please!
Separating state from behavior simplifies object-oriented systems: immutable DTOs carry data, while managers compose collaborators and make operations explicit at call sites.
25 May 2020
Design Nugget: Evolution To Strategy
Build a working baseline, then change the design for a concrete benefit; a log parser evolves through a switch, delegates, and Strategy to test that judgment.
12 October 2019
Mocking? No Thank You!
Test whole features through the public surface so regression tests survive later design changes. Class mocks bind tests to internals; transport doubles cover rare external failures.
6 October 2019
Dependency Injection? No Thank You!
Dependency injection exposes private collaborators to callers when used for every internal relationship. Keep classes self-contained and let business code choose real variation.
21 September 2019
Interfaces? No Thank You!
C# interfaces do not inherently create contracts or loose coupling. Composition handles hierarchy conflicts; capability interfaces and structural typing let consumers see only what they need.
20 September 2019
Extension Methods? No Thank You!
Keep project-specific helpers as static methods: extension methods hide behavior behind namespaces and can change meaning with imports. Use them when they serve the wider C# community.
10 September 2019
Factory Pattern: The Enabler of Polymorphism
A Factory selects and constructs a member of a class family from meaningful input, letting clients use the shared contract while the Factory owns recurring implementation choices.
11 August 2019
The Configuration Provider: An Abstraction With Roles and Responsibilities
A Configuration Provider hides the source, returns typed settings, validates required values, and reports useful errors. Composed providers let each system select its settings.
10 February 2013
Factory Method Pattern: The Most Beautiful Pattern We Lost
Factory Method lets consumer subclasses choose dependencies through an overridable creation hook. C# member managers and Windows Forms show its two class families, distinguishing it from a Factory.