Progressive Design

Choosing the right amount of process is an art. Too much process is smothering and too little is a mess. However, I think incremental, stable, and additive processes naturally start simple and mature progressively with our demands.

March 4, 2022 · 4 min

DDD Reading Review

It’s easy to see how Domain Driven Design (DDD) by Eric Evans was such a seminal work. It presents a holistic development process that seems to have predicted the next two decades of development trends. Here are some of my key takeaways from the book.

May 7, 2021 · 5 min

Accessors: Services, Not Servants

I’ve been on a long journey of meshing IDesign with Clean Architecture. Managers, engines, and utilities fit nicely, but accessors seemed too substantial for an adapter and not independent enough for a true service. At last, I’ve realized the place of accessors by building off their relationship to utilities. Accessors are independent services, not servants to managers.

January 1, 2021 · 15 min

Incremental Accessors

I’ve been on a long journey of meshing IDesign with Clean Architecture. Accessors have been a conceptual sticking point.

December 25, 2020 · 2 min

Ports and Adapters

Understanding Clean Architecture has transformed my approach to architecture. Now I feel like my understanding has evolved one step further by understanding its parent pattern’s name, Ports and Adapters.

December 19, 2020 · 4 min

Clean Architecture+: Check-in and Benefits

I posted about Synthesizing Project Organization Methods a few months ago. Well… I’ve been busy putting it to practice in my own code, and the results have been been beyond my expectations!

September 17, 2020 · 7 min

Async Task Refactor Case Study

I’ve been unhappy with the async/background work model in my system for a while. The async logic always seems excessively complex, either entangled with business logic or creating opaque coupling between flows. However, my recent breakthrough on code structure suggested a clear path to adding background work in an aspect-oriented style. Let’s examine a refactor that helped me prove decorator-style async communication.

September 11, 2020 · 6 min

System Language

The Language of the System by Rick Hickey is an illuminating talk about why systems differ from programs. It provides a clear framework for understanding and addressing the differences. I believe these same ideas underpin some of the recent movements in software design philosophy. Let’s explore.

September 4, 2020 · 6 min

Notification Refactor Case Study

A general design for integrating notifications (email, text, push, etc) has long eluded me. However, a recent refactor using the concepts of Synthesizing Project Organization Methods has settled my search. Here I’ll explore my refactoring experience and why the conceptual shift is generically more stable.

August 14, 2020 · 7 min

Why Static Structs are Better Than Enums

C# (and Java) offer a type call enum (aka enumeration). It represents a fixed list of possible values and is a powerful tool for communicating intentions through the type system. However, a recent legacy project forced me to face the shortcomings of enums and realize an even more powerful pattern, struct named constants.

August 7, 2020 · 6 min