Posts
- aiinfrastructure
Reproducible, AI-driven large scale changes
Making AI-driven large scale code changes deterministic, cheap, and auditable.
- infrastructure
Queues in Postgres
Building a distributed priority queue on Postgres.
- design
Inlining function code
When to inline code and when to extract it.
- jjtooling
A jj script to lint your entire graph
A small script that walks every mutable rev in the jj graph and lints as it goes.
- jjtooling
A jj plugin for bash-it
A bash-it plugin that surfaces jj repository state in your shell prompt.
- protobufmodules
Storing protobuf-generated Go code without a registry
Where to store protobuf-generated Go code without the buf BSR.
- protobuf
Generating protobuf-generated Go code without a registry
Generating Go code from protobufs without the buf BSR.
- testing
Spock gripes
Gripes with Spock and the Groovy test framework.
- gotooling
Running your own pkgsite
Running pkgsite yourself against a private enterprise GitHub and goproxy.
- career
Engineering resources from Google
A collection of Google's public engineering resources.
- go
Interfaces in depth
A deep dive into Go interfaces.
- infrastructure
Graceful degradation with the logistic function
Using the logistic function to shed load gradually.
- errorsgo
Wrapped errors are stacks
Wrapped errors form a stack.
- errorsgo
Error unwrapping for library authors
Go's Unwrap is part of your library's API.
- testinggo
Complex assertions
Keeping assertions on large, nested structures readable and maintainable.
- testinggo
testing in Go
A case for testing Go with Go's testing.
- gocrosspost
Contexts and Structs
Why context.Context belongs in a function argument rather than a struct field.
- testinggo
Stubbing gRPC clients in Go tests
Stubbing gRPC clients in Go tests.
- modulescrosspost
Keeping Your Modules Compatible
Evolving a Go module's API without breaking the compatibility promise.
- algorithms
Binary Search Tree Runtime Complexities
Building intuition for binary search tree complexities.
- modulescrosspost
Go Modules: v2 and Beyond
Releasing v2 and beyond of a Go module without breaking the people using it.
- tooling
Docker in Docker
What people actually mean by docker-in-docker.
- go
Bad Times Initializing With Append
Initializing a variable can be a bad idea.
- career
Reflecting on two years at Google
Two years at Google.
- career
Reflecting on interviewing at Google
Interviewing at Google.
- modulescrosspost
Migrating to Go Modules
Moving an existing project off GOPATH and onto Go modules.
- go
Designing CRUD operations in Go
The design considerations that go into adding CRUD operations to a Go client library.
- modulescrosspost
Resolving Problems From Modified Module Path
Recovering when a module's path changes out from under its dependents.
- modulescrosspost
Multi-Module Repositories
When to put multiple Go modules in a single repository.
- protocolscrosspost
gRPC on HTTP/2: Engineering a Robust, High Performance Protocol
Why gRPC is built on HTTP/2, and the protocol design decisions that make it robust.
- protocolscrosspost
HTTP/2: Smarter At Scale
How HTTP/2's multiplexing, header compression, and flow control behave under real load.
- protocolscrosspost
Which protocol should I use?
Weighing REST, gRPC, and friends, and when each one is the right fit.
subscribe via RSS