Categories

ai

• Reproducible, AI-driven large scale changes

  Making AI-driven large scale code changes deterministic, cheap, and auditable.

algorithms

• Binary Search Tree Runtime Complexities

  Building intuition for binary search tree complexities.

career

• Engineering resources from Google

  A collection of Google's public engineering resources.

• Reflecting on two years at Google

  Two years at Google.

• Reflecting on interviewing at Google

  Interviewing at Google.

crosspost

• Contexts and Structs

  Why context.Context belongs in a function argument rather than a struct field.

• Keeping Your Modules Compatible

  Evolving a Go module's API without breaking the compatibility promise.

• Go Modules: v2 and Beyond

  Releasing v2 and beyond of a Go module without breaking the people using it.

• Migrating to Go Modules

  Moving an existing project off GOPATH and onto Go modules.

• Resolving Problems From Modified Module Path

  Recovering when a module's path changes out from under its dependents.

• Multi-Module Repositories

  When to put multiple Go modules in a single repository.

• 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.

• HTTP/2: Smarter At Scale

  How HTTP/2's multiplexing, header compression, and flow control behave under real load.

• Which protocol should I use?

  Weighing REST, gRPC, and friends, and when each one is the right fit.

design

• Inlining function code

  When to inline code and when to extract it.

errors

• Wrapped errors are stacks

  Wrapped errors form a stack.

• Error unwrapping for library authors

  Go's Unwrap is part of your library's API.

go

• Running your own pkgsite

  Running pkgsite yourself against a private enterprise GitHub and goproxy.

• Interfaces in depth

  A deep dive into Go interfaces.

• Wrapped errors are stacks

  Wrapped errors form a stack.

• Error unwrapping for library authors

  Go's Unwrap is part of your library's API.

• Complex assertions

  Keeping assertions on large, nested structures readable and maintainable.

• testing in Go

  A case for testing Go with Go's testing.

• Contexts and Structs

  Why context.Context belongs in a function argument rather than a struct field.

• Stubbing gRPC clients in Go tests

  Stubbing gRPC clients in Go tests.

• Bad Times Initializing With Append

  Initializing a variable can be a bad idea.

• Designing CRUD operations in Go

  The design considerations that go into adding CRUD operations to a Go client library.

infrastructure

• Reproducible, AI-driven large scale changes

  Making AI-driven large scale code changes deterministic, cheap, and auditable.

• Queues in Postgres

  Building a distributed priority queue on Postgres.

• Graceful degradation with the logistic function

  Using the logistic function to shed load gradually.

jj

• 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.

• A jj plugin for bash-it

  A bash-it plugin that surfaces jj repository state in your shell prompt.

modules

• Storing protobuf-generated Go code without a registry

  Where to store protobuf-generated Go code without the buf BSR.

• Keeping Your Modules Compatible

  Evolving a Go module's API without breaking the compatibility promise.

• Go Modules: v2 and Beyond

  Releasing v2 and beyond of a Go module without breaking the people using it.

• Migrating to Go Modules

  Moving an existing project off GOPATH and onto Go modules.

• Resolving Problems From Modified Module Path

  Recovering when a module's path changes out from under its dependents.

• Multi-Module Repositories

  When to put multiple Go modules in a single repository.

protobuf

• Storing protobuf-generated Go code without a registry

  Where to store protobuf-generated Go code without the buf BSR.

• Generating protobuf-generated Go code without a registry

  Generating Go code from protobufs without the buf BSR.

protocols

• 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.

• HTTP/2: Smarter At Scale

  How HTTP/2's multiplexing, header compression, and flow control behave under real load.

• Which protocol should I use?

  Weighing REST, gRPC, and friends, and when each one is the right fit.

testing

• Spock gripes

  Gripes with Spock and the Groovy test framework.

• Complex assertions

  Keeping assertions on large, nested structures readable and maintainable.

• testing in Go

  A case for testing Go with Go's testing.

• Stubbing gRPC clients in Go tests

  Stubbing gRPC clients in Go tests.

tooling

• 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.

• A jj plugin for bash-it

  A bash-it plugin that surfaces jj repository state in your shell prompt.

• Running your own pkgsite

  Running pkgsite yourself against a private enterprise GitHub and goproxy.

• Docker in Docker

  What people actually mean by docker-in-docker.