Go from the inside: generics, goroutines, and whether the language still has a ceiling

Elena Vasquez

Elena Vasquez

September 18, 2026

Go from the inside: generics, goroutines, and whether the language still has a ceiling

I write Go for a living and I still flinch when someone says it is “simple.” Simple is the marketing. Inside the repo it is a set of sharp defaults — goroutines that are cheap until they are not, a type system that used to make you copy-paste, and a culture that treats a ceiling as a moral victory.

The ceiling is real. It is also not where Twitter parked it in 2018. Generics landed. Iterators landed. The toolchain got faster. The question I actually get from leads is: can we keep putting domain services in Go, or is this still an infra language that we keep trying to promote?

I will give you the inside version. Not a tutorial. The bets I would still make, the generics I still will not write, and the concurrency bugs I have shipped under the story that “goroutines are easy.”

Goroutines are cheap. Coordination is not.

I still reach for a goroutine the way I reach for a thread pool in Java: when I have independent I/O. Fan-out to ten backends, wait with errgroup, cancel the context, go home. That shape is why I like Go more than I like Node’s implicit event loop or Java’s historical “don’t you dare block.”

The cheapness is the trap. Spawning is not the cost. The cost is:

  • A goroutine that outlives the request because you forgot to select on ctx.Done().
  • A channel you used as a mutex, or a mutex you used as a channel, and a teammate who cannot tell which you meant.
  • errgroup with no SetLimit against a downstream that has 200 connections and a personality.
  • Logging from a worker that you never joined, so shutdown looks clean and the process dies mid-write.

I have paged on a “simple” sidecar that leaked goroutines on a reconnect loop. The binary was 12MB. The goroutine count was not. Go’s runtime will let you be sloppy for a long time. That is not kindness. That is a delayed invoice.

Rules I write in the README of every Go service I start:

  1. Every goroutine has an owner and a stop condition that is a context or an explicit done.
  2. Channels are for signaling and pipelines, not for pretending we do not have mutexes. A sync.Mutex around a map is clearer than a channel ballet.
  3. The default HTTP server timeouts are not optional decoration. If you leave them zero, you have a slowloris volunteer program.

I like goroutines. I like them more when they are rare and named. “Just throw it in a goroutine” is how internal tools become haunted houses.

A quiet server bench with a small Go service laptop and network cables

Generics: I use them. I do not build a language with them.

Before 1.18 I lived in interface{} and code generation. After 1.18 I lived through a year of people writing Haskell in a constraints package. Both eras were embarrassing in different directions.

What I use generics for, without apology:

  • Containers and helpers that were obviously typed: a result type, a small set, a Map helper, a pool. slices and maps in the stdlib covered half of my old copy-paste.
  • A repository interface that is not interface { Get(ctx, id) (any, error) }.
  • sqlc-adjacent wrappers where the query is the interesting part and the type parameter is just the row.

What I still will not do:

  • A generic “service layer” that abstracts databases, caches, and HTTP into one Store[T]. You will invent a worse ORM and you will not have Hibernate’s twenty years of scars.
  • Constraint soups that exist to prove we can do type-level programming. If the function is harder to call than to implement, delete the parameters.
  • Exporting a generic API I cannot document with two examples. If I need a blog post to use F, I wrote a research project into a module.

The cultural hangover is people treating generics as either a betrayal of Go or as the feature that finally makes it “a real language.” Both takes miss the point. Generics removed a class of stupid. They did not add a class of expressiveness that should become the house style. I review PRs for that the way I used to review PRs for unnecessary interfaces: one is enough, a tree is a smell.

Iterators (the iter package, range-over-func) are in the same bucket. I will use them for a clean walk over a tree or a paged API. I will not rewrite every for-loop to look modern. Go’s for-loop was never the problem.

The ceiling I still hit

Go still hurts when the domain is a thick graph of rules. Sum types that are actually exhaustive, not a comment that says “don’t add a fourth kind.” Error values that carry structured context without becoming fmt.Errorf lasagna. A module that wants a bit of metaprogramming and gets go generate plus three tools in PATH.

Enums are better than they were and still worse than Kotlin’s. I write a sealed set of types by hand and a linter that greps for the switch. It works. It is not elegant. Elegant is not why I hired Go.

Dependency injection is another ceiling people pretend is a virtue. I like explicit NewServer(cfg, db, kafka). I do not like a 40-argument constructor that grew because we refused a little structure. Fx and Wire exist because the language will not help you. I use Wire when the binary has more than a handful of components. I do not use it so I can say we have “enterprise Go.”

The biggest ceiling is people. A Go codebase attracts engineers who like boring. That is an asset until the problem is not boring — a compiler-shaped transform, a UI-heavy product, a type-heavy financial DSL. Then the same culture that kept you safe will fight the right tool. I have been that culture. I have delayed a Rust parser by a year because “we can do it in Go.” We could. The tests were a novella. The Rust version was shorter and wrong less often. That year was my ceiling, not the compiler’s.

Hands writing Go concurrency notes next to a terminal window

What I still bet on

I bet on Go for:

  • Network appliances and sidecars. Proxies, agents, small control planes, anything that should be one binary and a unit file.
  • CLIs. cobra / cli, static binaries, boring flags. This is still the best everyday story.
  • Workers that chew Kafka or SQS, transform, write Postgres, exit cleanly. Context and errgroup fit this shape.
  • APIs that are CRUD-plus, not a 200-entity insurance core. Chi or Echo or stdlib, sqlc, a migration tool, OpenTelemetry. I can teach this in a week.

I do not bet on Go for a dense domain with a long-lived object graph. I do not bet on it for a GPU-adjacent numerical kernel. I do not bet on it when the team already thinks in the JVM and the problem is a business workflow. Promoting Go into those slots because the infra team likes it is how you get a second default and a hiring problem.

The toolchain is still a reason to stay. go test, go vet, staticcheck, a five-second compile on a service that is not a monorepo disaster. Rust’s compiler is smarter and slower. Java’s is fine and the build is rarely “just javac.” Go’s loop from idea to failing test is still the thing I miss in other languages. That is not a ceiling. That is the floor I refuse to give up for a prettier type system unless the type system is the job.

Concurrency and the standard library, 2026 edition

context is still the right request-scoped bag, and still the wrong place to hide a logger plus twelve values. I pass a logger explicitly when it matters. I put deadlines on outbound calls even if the inbound context already has one — the inbound one is a maximum, not a guess about the payment provider.

The standard library HTTP client is good enough that I no longer start with a wrapper framework. I do start with a wrapper for retries. The ecosystem’s retry libraries have opinions. I want mine: idempotent methods only, jitter, a budget, and metrics. Goroutines plus retries without a budget is how you DDoS yourself.

I have warmed up to slog. Structured logs without a church of zap-versus-zerolog is a gift. I still use zap when the hot path is a firehose. I do not start there.

Generics in the standard library changed my defaults more than generics in my own code. slices.Contains deleted a file I was tired of copying. That is the success story. Not a generic monad.

Does it still have a ceiling?

Yes. Every language does. Go’s is lower on expressive modeling and higher on operational boredom. If your product is a protocol, a pipe, a CLI, a worker, or a modest API, you are under the ceiling and I would stay there on purpose. If your product is a type-heavy domain or a place where “impossible states” are the actual risk, you are bumping it, and generics will not raise it enough.

The dishonest take is that Go is finished and we should all move. The other dishonest take is that Go’s limitations are a philosophy the rest of us should adopt. I like the language from the inside — the runtime, the compile, the way a small service stays small. I am still careful with generics because they are how we smuggle a second language in. I still treat goroutines as a resource with an owner.

What I would bet on next is not a revolution. More stdlib, fewer frameworks, better iterators where they replace a clunky callback, and teams that stop using Go as a personality. Use it where the binary and the on-call story win. When they do not, pick the language with the higher ceiling and do not apologize to the gopher.

More articles for you