Home

Zhanyin

Ren Hongchang / Software Engineer

Notes on software, design, and the occasional detour. Quiet, opinionated, built to last.

A road lined with cherry blossoms

Writing

Selected writing
and notes

When to Define Interfaces in Go Go interfaces should be defined at the consumer side and extracted only when there are at least two real implementations — not reserved for 'future extension.' Two rules that clarify when to use them and when not to. 2026

The Architecture of Zhanyin The complete design of a self-built blog system — from the compiler, template engine, and build pipeline to CI/CD, and the reasoning behind every decision. 2026

When the Service Layer Adds Value, and When It's Just Air If a Service layer just copies Repository methods, it adds no value — it only adds a layer of air to the call chain. The Service layer's value is in orchestration and coordination: composing multiple data operations into a business-meaningful flow, or applying constraints and side effects. 2026

Why Error Handling Is Architecture, Not Just Code Many systems don't fail because the happy path is poorly written — they fail because the failure paths are like shacks thrown together at the last minute. Error handling isn't what you write after `if err != nil`; it's the system's ability to stay predictable, recoverable, and explainable when facing failure. 2026

How to Actually Prioritize Technical Debt Technical debt isn't 'ugly code' — it's when today's decisions reduce future change velocity or increase fix costs. Prioritize using three dimensions: does it block evolution, does it affect correctness, does it weaken observability. Not all debt must be paid, but all debt must be visible. 2026

State Transition Rules Need a Home When inheriting an unfamiliar system, you always end up opening three or four files, reverse-engineering a state diagram from scattered if/else statements — a diagram that should already be in the code, but isn't. Making state transition rules explicit, even as a simple table, contributes more to system correctness than many heavyweight architectures. 2026

Entries

Archive

2026

Why Software Systems Become Harder to Change Over Time 2026.06.12
ADR Isn't Documentation Tax 2026.06.11
When to Define Interfaces in Go 2026.06.04
The Architecture of Zhanyin 2026.06.03
When the Service Layer Adds Value, and When It's Just Air 2026.06.02
Why Error Handling Is Architecture, Not Just Code 2026.06.01
How to Actually Prioritize Technical Debt 2026.06.01
Why "For Future Extension" Is Usually a Bad Reason 2026.06.01
State Transition Rules Need a Home 2026.05.25
Wait for the Second Use Case Before Abstracting 2026.05.22
Microservices or Modular Monolith: The Real Costs 2026.05.22
When Monitoring Isn't Enough: Understanding Observability 2026.05.22
Cross-Domain Identity Matching: Not Sharing Data, but Building Verifiable Correspondence 2026.05.21
How This Blog Works 2026.05.21
The Last Protocol That Doesn't Ask Who You Are 2026.05.21
Hello. 2026.05.20
Don't Rush to Crop — Another Approach to Native Ad Image Management 2026.05.20