Tagged “golang”

Cross-Compiling Go For A Little ARM Box Without Losing My Mind

Go Generics, and the Quiet Question of Whether I Need Them

Threading context.Context Through, Properly This Time

A Week Spent Watching a Goroutine Count Climb

The Goroutine Leak Hiding in a Timeout

Threading context.Context Through, And Where It Goes Wrong

The Goroutine Leak That Hid In Plain Sight

Generics in Go: Do I Even Need Them?

context.context, and learning to thread it through

a small go daemon, actually finished

where the context goes, the cancellation follows

the day i deleted my logging wrapper

threading context.Context through, and finally understanding why

building once on my laptop, running on the arm box in the cupboard

the smallest useful daemon i've written this year

the allocation i couldn't see until i put it under load

log/slog, and the day go logging stopped being a religious argument

go generics, and the day i finally reached for them

generics in go, do i even need them

building once on the laptop, running on the pi

context.Context, and learning to thread it all the way through

building Go binaries for the little ARM box without the little ARM box

forty lines of go that earned their keep

every time I reach for interface{} I pay for it later

generics in go, two years on, do i reach for them

a small daemon, in go, actually shipped

the smallest useful daemon i've written this year

learning to thread context.Context everywhere, and why it's worth it

building go binaries for a box i can't compile on

i finally reached for go generics, and mostly didn't

every interface{} i ever wrote came back to bill me

pprof found the allocation i swore wasn't there

every time i reach for interface{} i live to regret it

threading context.Context through everything, and why it's worth it

stop reaching for context.Background() in the middle of things

deleting dep and never looking back

a forty-line go daemon that's earned its keep

interface{} is a promise I keep breaking

every interface{} i wrote came back to bill me

a tiny daemon in go, finally shipped

cross-compiling go for an arm box, the easy way and the cgo way

goroutines and the leak i didn't see

context.Context, and learning to thread it through

deleting Gopkg.toml and not missing it

threading context.Context through, properly this time

where the time actually went under load

the smallest daemon i could get away with

learning to thread context.Context all the way down

where a go service actually spends its time

forty lines of go that quietly do their job

a year on, where go generics actually earn their keep

learning to thread context.Context through everything

stop fighting context.Context and start threading it

pprof under real load, not in a benchmark

building go binaries for the little arm box in the cupboard

the goroutines that never came home

a hundred lines of go that replaced a cron job and a prayer

one line to build for the little ARM box

where the time actually went in a slow Go service

a tiny daemon in go, shipped

generics in go, and whether i actually wanted them

interface{}, and the regrets it left me

every interface{} is a promise i make to my future self and break

the smallest useful daemon i've written this year

structured logging in go that i can actually grep

logs you can actually query

finally on go modules, and saying goodbye to dep

cross-compiling go for the little arm box in the cupboard

pprof, a load test, and the allocation i couldn't see

deleting Gopkg.toml and not missing it

the goroutines that wouldn't die

the goroutines that never came home

building for the pi without building on the pi

a hundred lines of go that finally left my laptop

the goroutine leak that hid behind a healthy graph

making my peace with context.Context

interface{} and the type assertions i regret

the empty interface and my regrets

context.context, and learning to thread it through

finding where a go service actually spends its time

threading context through, and finally getting it

threading context.Context through everything, and why it earns its keep

cross-compiling Go for the little ARM box in the cupboard

interface{} and the bill it sends you later

interface{} was the easy answer, and i paid for it

where does this context.Context even go

pprof, a load test, and the allocation i couldn't see

structured logging in go, and learning to stop fighting it

structured logging in Go, finally sane

building go binaries for an arm box from my laptop

throwing out dep and letting go modules do its job

a hundred lines of go that just sit there and work

the context i kept ignoring until it bit me

building for the pi without touching the pi

building go binaries on my laptop and shipping them to an arm box

the goroutine leak that hid behind a tidy little channel

chasing latency in a go service that looked fine

building for the pi without ever touching the pi

the smallest useful daemon i've written, and how it got to production

interface{}, or how i learned to stop trusting myself

passing context.Context until it finally clicked

the goroutine leak that hid behind a channel nobody read

the goroutine leak that hid in plain sight

passing context through, and finally understanding why

interface{} got me out of a corner and then quietly furnished it

shipping a go binary to arm from a laptop that has never seen arm

building go binaries for the pi without a toolchain in sight

every interface{} i wrote came back to bite me

the context.Context habit i wish i'd picked up sooner

interface{} is not a type, it's a promise to deal with it later

the function signature that accepts everything and promises nothing

how interface{} crept through my codebase and what it cost

a hundred lines of go that replaced a cron job and a prayer

threading context.Context through, and finally understanding why

building for the pi without compiling on the pi

go modules are nearly here, and i am quietly retiring dep

passing context.Context everywhere, and why it's worth it

threading context through, and learning to stop fighting it

go is finally getting real dependency management

context.context, and learning to thread it through

a tiny daemon in go, and the joy of shipping a single binary

i shipped a forty-line daemon and it just runs

i want go to just solve dependencies

forty lines of go that quietly run my house

threading context through a worker pool, not just an http handler

the goroutine that never came home

a hundred lines of go that quietly renews our certs

getting go onto an arm box without dragging a toolchain along

cross-compiling go for an arm box, the easy way and the way i did it first

building Go on the laptop, running it on the Pi

the smallest useful daemon i've written in go

context.context, and finally threading it through everything

the goroutines that never came home

the goroutines i forgot to stop

building go binaries for the pi from my laptop

shipping a one-job daemon and resisting the urge to add features

the smallest daemon i could justify writing

the goroutine that wouldn't die

a tiny daemon in go, and the bits that aren't the code

cross-compiling go for an arm box, the long version

building go binaries for the pi without the pi

igmpqd