Tag
Building applications and tools with the Go language.
There are 18 posts with this tag.
Architecture decisions stay true on the wiki and rot in the code. I built archlint: a standalone Go CLI that enforces the layer boundaries in architecture.json on every commit — with go/parser, no model, in CI. Here's why I built it this way.
In a polyglot repo, 'domain must not import infrastructure' is the same rule in every language — only how the import resolves differs. I added TypeScript and Python to archlint: one architecture.json enforces all three in CI.
I added a deterministic flaky-test filter to CommitBrief. Instead of asking the LLM, it catches hard-coded sleeps and unseeded randomness in changed test files at commit time — no model. Here's why I chose static analysis over an LLM prompt.
Two new commands landed in CommitBrief: summary briefs a change and its history, and remote pr reviews a PR from the terminal, leaving its comments before the human does. To clear the way for the human reviewer, not replace them.
Three months ago I built a tool to audit my own diffs. This post is not about the 'why' but the 'how much': which workflow layers it plugs into, the numbers behind the speedup, the bug patterns it keeps catching — and where it hits its limits.
One afternoon I ran headfirst into the limits of self-review, so I wrote a tool that audits my own diff right from the terminal: CommitBrief. A note on why I built it, how it works, and what problem it actually solves.
How becoming a multi-language developer turned into a supposed goal, why it never really was one, and how I actually got there.
A hands-on look at just how much mileage Go's rich standard library gives you, and a principled approach to deciding when to reach for an external dependency.
The hidden cognitive overhead of working in multiple languages simultaneously, and how I manage it.
A hands-on introduction to Go's standard testing package and the table-driven test pattern, embracing the language's minimal testing philosophy.
A reflection on how moving between PHP, Go, Python, and TypeScript within a single year shaped the way I think about software.
Go 1.18's generic support shows how a language can be reshaped thoughtfully. First impressions and trade-offs.
Personal notes on why mastering multiple programming languages is a matter of tool selection, not identity.
A practical approach to embracing error handling as a language idiom in Go, a language with no exception mechanism.
I explore what you get — and what you don't — when building a small HTTP service with Go's net/http package, and where the framework threshold sits.
A hands-on look at Go's concurrency model — goroutines and channels — and what changes when you come from PHP's process model.
I reinforced my newly learned Go skills by building a real CLI tool — here's what the language feels like in practice and how far the standard library can take you.
After more than a decade with PHP, why did I decide to pick up a second language — and why Go?