Writing

A reading map through the articles behind JBCT and the broader convergence in software design. Start where the question lands for you.

These pieces connect. Each addresses a different reader at a different moment — someone looking for a method, someone looking for evidence, someone looking for the reason the method works. They were written independently, over several months, and together form a coherent account of why software design has been quietly shifting away from entity-first modeling and toward process-first design with semantically meaningful types.

Start here depending on your question

Is this convergence real?

Six practitioners across F#, Rust, TypeScript, Scala, C#, and Java independently arrived at process-first design. Evidence, not manifesto.

The Quiet Consensus

Dev.to · Medium

Why does the convergence matter?

Types can carry business meaning, not just machine scaffolding. The compiler becomes a participant in the domain conversation. A middle ground between OO and pure FP.

When Types Become the Business Language

Dev.to · Medium

How do I actually design with this?

Carrying a feature from requirements to working code. The design process that produces code matching the business process, step by step.

Java Backend Design Technology: A Process-First Methodology

Dev.to · Medium

What are the structural patterns?

Six shapes that cover every business process: Leaf, Sequencer, Fork-Join, Condition, Iteration, Aspects. Named for what stakeholders already recognize.

The Six Patterns That Cover Everything

Dev.to · Medium

How does a request flow through all this?

Request processing as composable transformations. The lifecycle the six patterns operate on.

The Underlying Process of Request Processing

Dev.to · Medium

How big should a service be?

Slices as the natural unit of decomposition — smaller than services, larger than classes. The architectural scope the patterns live in.

Slices: The Right Size for Microservices

Dev.to · Medium

Series: We Should Write Java Code Differently

A running series on specific frictions in Java practice and what changes when you reach for a different tool. Each piece stands alone; together they sketch a different default posture for writing Java code.

Less Language, More Business

Cutting language features so business intent surfaces. What you stop using matters more than what you start using.

Dev.to · Medium

Frictionless Prod

Production-readiness without ceremony. What "it works in prod" looks like when the code wasn't designed for dev-comfort first.

Dev.to · Medium

The DI Confusion

Dependency injection has two jobs: assembling internal components and provisioning external resources. Conflating them creates most DI framework pain. Separating them dissolves it.

Dev.to · Medium

A suggested reading order

If you're new to this work and want a single path through:

  1. The Quiet Consensus — establishes that the shift is real and broad, not one person's opinion.
  2. When Types Become the Business Language — the philosophical case for the alternative.
  3. Java Backend Design Technology — how to actually work in this style, step by step.
  4. The Six Patterns That Cover Everything — the structural vocabulary the method uses.
  5. The Underlying Process of Request Processing — how requests compose through the patterns.
  6. Slices: The Right Size for Microservices — where these pieces live architecturally.

The ordering goes from is this real? through why?, how?, and where does it live? The "Write Java Differently" series can be read in any order alongside the main path.