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

Process Quality Drivers: Stable, Incremental, Additive

“No ideal process, or set of processes, exists” “Software processes must be selected, adapted, and applied as appropriate for each project and each organizational context.” (SWEBOK Ch 1.1 intro). No one likes to hear “that’s just how we do it”. Process without understanding leads to frustrating lack of results. Understanding factors of good process is critical for effective work across projects and for continued improvement. My working hypothesis is that effective processes are incremental, stable, and additive.

February 25, 2022 · 6 min

Programming is Problem Modeling

Code is not the goal of programming. Programming is about understanding and representing problems. While this belief is expressed by many experts, the repercussions are many and nuanced. This is my latest attempt to communicate the idea clearly.

February 18, 2022 · 7 min

Design and Requirements as Negotiation

I finally got around to reading Getting to Yes, which several friends have recommended. It is a fantastic crash course in negotiation. I also couldn’t help but notice the similarities between negotiation and design.

April 23, 2021 · 4 min

Going Fast is Going Well

I want to directly address the idea that moving quickly means bad code. Heavy design process is also not the opposite of either speed or sloppy code. To go fast is to go well, and that means fast incremental design.

January 29, 2021 · 2 min

The Cycles of TDD Diagram

The Cycles of TDD by Robert Martin is the most wholistic explanation of TDD I’ve read. It helped me to put the pieces together and understand how TDD can drive a good design process from end-to-end. Here’s an attempt to visualize it.

November 13, 2020 · 1 min

Id Abstractions

I once worked for a company that exposed all of their entities IDs as integers. It’s common practice, but it bit them hard when they needed to adopt an offline-then-merge strategy for client data. This required switching ids to Guids all over the code base and it was an arduous undertaking. I’ve been trying and failing to simply abstract ID types since.

November 7, 2020 · 3 min

Result Types

I want to cleanly represent predictable failure states as part of my function contracts. This lets consumers know right away what scenarios they should expect without documentation or looking through code. F# encourages this pattern and normalizes it with the Result type. Representing the same idea in C#, however, is non-trivial.

October 30, 2020 · 11 min

Type Safety with Multiple Valid Input Types

Sometimes a constructor or function can naturally accept multiple types. The classic solution to this is overloading. The problem is overloading can combinatorially expand for every multi-typed parameter.

October 22, 2020 · 4 min

Functional Composition, Decorator, and Aspect-Oriented Programming

Aspect-Oriented programming has captivated my imagination for years. C#, however, does not support AOP. Even conceptually realizing benefits of the paradigm proved difficult. Then, I experienced functional composition.

October 16, 2020 · 7 min