Why Go Code Gets Bloated and How Blueprint Patterns Can Simplify It

The author reflects on the common problem of heavyweight Go code, especially among developers transitioning from Java or C++, and uses Mat Ryer’s Go Programming Blueprints to demonstrate a minimalist, engineering‑focused mindset.

Truth One: Interfaces as Behavior Plug‑ins

Instead of defining a broad User interface with many methods, the book introduces a narrow, purpose‑specific interface:

type Avatar interface {
    GetAvatarURL(u ChatUser) (string, error)
}

Three concrete types— AuthAvatar, GravatarAvatar, and FileSystemAvatar —implement this interface. A slice type TryAvatars []Avatar also satisfies Avatar, allowing the GetAvatarURL call to iterate over implementations until one succeeds. This demonstrates the principle of composition over inheritance and the importance of small, behavior‑focused interfaces.

Truth Two: Build Lego‑style CLI Components

In the domain‑lookup chapter, the author follows the Unix philosophy by breaking a complex service into five tiny command‑line tools, each doing one thing: synonyms – finds synonyms. sprinkle – adds prefixes/suffixes. coolify – transforms words to a “cool” form. domainify – sanitises strings into domain format. available – checks WHOIS registration.

These tools are chained with the pipe operator ( |) in a shell, and the main program uses Go’s os/exec package to orchestrate them, achieving clear separation between computation and orchestration, and enabling independent testing of each component.

Truth Three: Onion Model and Line‑of‑Sight Principle

The book’s Go‑kit example illustrates a clean three‑layer architecture for microservices:

Service layer – contains only pure business logic.

Endpoint layer – acts as an RPC adapter, converting service methods to a uniform (ctx, request) signature.

Transport layer – handles protocol specifics such as HTTP or gRPC.

The author also stresses the “Line of Sight” principle: keep the happy path code left‑aligned and handle errors early with guard clauses, e.g.:

if err != nil {
    return nil, err
}
// core business logic stays left‑aligned

Overall, the book teaches that Go should be treated like a precise surgical tool rather than a Swiss army knife, favouring small composable interfaces, simple CLI utilities, and layered microservice structures to build robust, long‑lasting backend systems.