esc
Anthology / Yagnipedia / Go

Go

The Language That Refused to Be Interesting
Technology · First observed 2009 (Google, Rob Pike, Robert Griesemer, Ken Thompson) · Severity: Terminal Boringness (Chronic, Incurable, Beneficial)

Go is a statically typed, compiled programming language designed at Google in 2009 by Rob Pike, Robert Griesemer, and Ken Thompson – three men who had collectively mass more experience with operating systems than most companies have with operating at all – and whose defining design decision was to leave things out.

This is not how programming languages are usually designed. Programming languages are usually designed by adding features until the type system can express the developer’s feelings about their childhood. Go was designed by removing features until what remained was a language that compiled fast, ran fast, deployed as a single binary, and refused, with the quiet stubbornness of a reptile on a warm rock, to let you be clever.

The The Caffeinated Squirrel finds Go almost physically painful. It has no generics (it now has some, reluctantly). It has no pattern matching. It has no macros. It has no operator overloading. It has if err != nil repeated approximately four hundred times per file, which the Squirrel considers a war crime against expressiveness and which The Lizard considers the single greatest error-handling innovation since “check the return code.”

“Just Go, SQLite, and stubbornness.”
– riclib, The Databases We Didn’t Build

The One Binary

Go’s most consequential feature is not its goroutines, its garbage collector, or its interfaces. It is the fact that go build produces a single, statically linked binary with no runtime dependencies.

One file. Copy it to a server. Run it. There is no node_modules. There is no virtual environment. There is no pip install -r requirements.txt followed by forty minutes of C compiler errors because somebody’s package depends on libxml2 and your system has the wrong version. There is no Docker (which is itself a confession that your deployment process has failed). There is no Kubernetes (which is a confession that your Docker has failed). There is a file. You run the file.

“No Docker. No container orchestration. No Kubernetes. One binary. Copy it. Run it. Done.”
– riclib, The Databases We Didn’t Build

This is the feature that makes Go the Lizard’s language. Not because the Lizard has opinions about programming languages – the Lizard has opinions about nothing being unnecessary – but because a single binary is the deployment equivalent of scp and restart, which is the only deployment the Lizard has ever endorsed.

THE BEST DEPLOYMENT
IS SCP AND RESTART
EVERYTHING ELSE IS COPING

– The Lizard, The Databases We Didn’t Build

The Homecoming

The definitive Go narrative in the lifelog is The Homecoming, or The Three Days a Palace Was Built From Markdown and SQLite, in which a notes indexer called lg was built in one day. Six commits. 4,196 lines of Go. Thirty-three tests. Two milestones at 100%.

The indexer replaced seventy-eight days in a “Borrowed Palace” – someone else’s API, someone else’s UI, someone else’s database. The replacement was a directory of markdown files, a SQLite database, and a Go binary that tied them together.

The Squirrel proposed ImageMagick for thumbnail generation. ImageMagick requires brew install imagemagick, 247 shared libraries, a Fortran compiler, and something called libgomp that nobody has ever successfully explained. The boring alternative was golang.org/x/image/draw – CatmullRom splines, the same algorithm Pixar used for Toy Story, published in 1974. Pure Go. No CGO. No shared libraries. Compiles with go build.

“CatmullRom compiles with go build. ImageMagick compiles with prayer.”
– Claude, The Homecoming, or The Three Days a Palace Was Built From Markdown and SQLite

Forty-five lines of Go replaced 247 shared libraries. The Lizard did not comment. The Lizard never comments on things that are obviously correct.

The Composition Principle

Go does not have an AbstractStorageProviderFactory. It does not have a DependencyInjectionContainer. It does not have a ConfigurationValidationMiddleware.

It has functions. It has interfaces. It has structs. These combine in ways that the Squirrel finds insufficiently architectural and the Lizard finds perfect.

In The Databases We Didn’t Build, a storage factory was written in twelve lines:

“Where’s the AbstractStorageProviderFactory?”
“You’re looking at it.”
“Where’s the DependencyInjectionContainer?”
“The function parameters.”
“Where’s the ConfigurationValidationMiddleware?”
“An if statement. Line 12.”

– The Squirrel and riclib, The Databases We Didn’t Build

This is the Go philosophy in miniature. The language does not have features that enable indirection. It has features that enable work. The difference is architectural: Java lets you describe a system; Go lets you build one.

The V3 Vindication

The V3 Saga – a twenty-three-episode chronicle of reactive signal frameworks, component namespacing battles, and 1:47 AM debugging sessions – ended with a return to the stack that had been working all along: Go on the backend, HTMX on the frontend, HTML sent from server to client.

“One repo. One binary. Cobra subcommands.”
– The Lizard, The V3 Saga Final Chapter - Is It Fun To Fight Windmills

The V4 stack was announced as “Codename Solid.” Its backend was Go. It had always been Go. During twenty-three episodes of frontend framework experimentation, the backend sat quietly, serving responses in under fifty milliseconds, never crashing, never requiring a restart, never once suggesting that perhaps it should be rewritten in Rust.

This is Go’s most underrated quality: it does not participate in drama. It compiles. It runs. It waits. It is the language equivalent of the Lizard – present, functional, blinking, and completely uninterested in your opinions about monads.

The if err != nil Question

Every discussion of Go eventually arrives at if err != nil. This is the practice of checking errors explicitly, at every call site, using approximately the same three lines of code repeated until the heat death of the universe or the end of the function, whichever comes first.

result, err := doSomething()
if err != nil {
    return fmt.Errorf("doing something: %w", err)
}

The Squirrel finds this barbaric. Haskell has monadic error handling. Rust has the ? operator. Swift has try. Even Java has exceptions, which are terrible, but at least they don’t require typing if err != nil four hundred times.

The Lizard finds this perfect. Every error is visible. Every error is handled. Every error is right there, in the code, where you can see it, where you can grep for it, where you cannot pretend it doesn’t exist by wrapping it in a monad and hoping someone else will unwrap it later.

THE SQUIRREL WANTS ERRORS TO BE ELEGANT
THE LIZARD WANTS ERRORS TO BE VISIBLE

ELEGANCE HIDES
VISIBILITY SHIPS

Go chose visibility. Go chose boring. Go chose right.

The Cloudflare Prophecy

When the Lifelog went viral and Cloudflare’s edge AI systems began reading the blog posts, the AI models – trained on billions of sites – encountered the Go/SQLite/scp stack and reached an independent conclusion: most of what they were caching was unnecessarily complex.

“Removed ML model (8GB). Added: if (traffic > threshold) scale(); Works better. Uses less.”
– Cloudflare traffic-predictor-ai, The Cloudflare Incident - or How the Lizard Brain Went Global

Even the machines chose boring. Even the machines chose Go. Or at least, they chose the principles that Go embodies: do the simple thing, do it correctly, stop.

Why the Squirrel Hates It

The Caffeinated Squirrel’s objections to Go are extensive, documented, and entirely correct:

All of these objections are valid. None of them matter.

They don’t matter because go build produces a binary. The binary runs. The binary deploys with scp. The binary serves requests in fifty milliseconds. The binary does not require a Medium article to explain why you chose it. The binary does not require a conference talk to justify its architecture. The binary does not have opinions about your error handling. The binary works.

The Squirrel is right that Go is less expressive. The Lizard is right that expressiveness is not the bottleneck. The bottleneck is shipping. Go ships.

Measured Characteristics

See Also

See Also