Tagged “programming”

Blinking An LED On An STM32 With Embedded Rust

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

How The 2018 Edition Quietly Fixed My Rust

Parsing Without the Regret, Using nom

Trait Objects vs Generics, With Numbers

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

Fighting the Borrow Checker, and Losing Gracefully

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

Losing Gracefully To The Borrow Checker

The Goroutine Leak That Hid In Plain Sight

How We Did Rust Error Handling Before anyhow Saved Us All

I Benchmarked Trait Objects Against Generics So You Don't Have To

The Edition That Quietly Reshaped How I Write Rust

Generics in Go: Do I Even Need Them?

I Rewrote a Shell Script in Rust, and I'd Do It Again

context.context, and learning to thread it through

rewriting a shell script in rust, and counting the cost

the borrow checker was right and i was tired

losing to the borrow checker, then thanking it

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

two years of rust in production, and an honest tally

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

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

how we did rust error handling before anyhow turned up

async/await landed and i rewrote everything

go generics, and the day i finally reached for them

i rewrote a 40-line bash script in rust, here's the honest tally

generics in go, do i even need them

parsing a config format with nom

blinking an LED the hard way, in Rust

the borrow checker was right and i was wrong, again

parsing a config format with nom, one combinator at a time

how i learned to lose to the borrow checker gracefully

trait objects vs generics, with actual numbers

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

the 2018 edition changed how i write rust

forty lines of go that earned their keep

the async rewrite i swore i wouldn't do

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

i rewrote a 40-line shell script in rust and i'd do it again

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

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

the rust i write now started with the 2018 edition

how we handled rust errors before anyhow saved us

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

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

what two years of rust in production actually taught me

pprof found the allocation i swore wasn't there

dyn or not: i finally benchmarked it

i rewrote a thirty-line shell script in rust

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

two years of rust in production, the honest ledger

every interface{} i wrote came back to bill me

a little cli in rust, and whether the borrow checker earned its keep

a tiny daemon in go, finally shipped

the borrow checker was right and i was the bug

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

two years of rust in production, the honest ledger

deleting Gopkg.toml and not missing it

threading context.Context through, properly this time

where the time actually went under load

the great async rewrite, and what it actually cost me

the smallest daemon i could get away with

learning to thread context.Context all the way down

i benchmarked dyn vs generics so you can stop arguing about it

parsing a config format with nom, and learning to think in combinators

dynamic dispatch isn't as slow as you've been told

where a go service actually spends its time

forty lines of go that quietly do their job

how rust 2018 quietly rewired my instincts

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

parser combinators finally clicked, thanks to nom

pprof under real load, not in a benchmark

trait objects vs generics, a real benchmark

building go binaries for the little arm box in the cupboard

the goroutines that never came home

nom finally made parsing feel less like a chore

how we did rust errors before anyhow and thiserror turned up

what rust error handling felt like before anyhow turned up

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

blinking an led on an stm32 the hard, satisfying way

what rust error handling felt like before anyhow turned up

one line to build for the little ARM box

where the time actually went in a slow Go service

i rewrote a service in async rust and learned what coloured functions cost

nll, no extern crate, and how rust started feeling easy

a tiny daemon in go, shipped

rust in production, two years of regrets and wins

generics in go, and whether i actually wanted them

when every crate brought its own error type

i benchmarked dyn vs generics so you don't have to

async/await finally clicked, so I rewrote everything

interface{}, and the regrets it left me

i rewrote a futures-combinator mess into async/await and regret nothing

i benchmarked dyn versus generics so i could stop guessing

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

i wrote a small cli in rust and i'm still arguing with myself about it

rewriting it all for async/await

how the 2018 edition quietly retrained my hands

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

nom made me stop hand-rolling parsers, mostly

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

async/await in rust, and the rewrite i couldn't resist

the goroutines that wouldn't die

parsing a config format with nom, and liking it

rewrote a ten-line shell script in rust, regret nothing

blinking an led on an stm32 in rust, and being surprised it worked

i lost an argument with the borrow checker, and it was right

losing to the borrow checker, gracefully

the goroutines that never came home

i rewrote a tiny shell script in rust and i regret nothing

building for the pi without building on the pi

one more note on the async port: select! is sharper than you think

async/await is stable, and i went and rewrote the lot

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

dyn or generic? i finally measured instead of guessing

context.context, and learning to thread it through

a year with async/await, and the rewrite I do not regret

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

the borrow checker was right and i was wrong, again

fighting the borrow checker and losing gracefully

interface{} and the bill it sends you later

error handling before anyhow existed

async/await finally clicked, so naturally i rewrote the lot

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

rust errors back when you wrote every From by hand

where does this context.Context even go

blinking an led the hard way, in rust

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

error handling before anyhow existed

i rewrote a shell script in rust and i'm not sorry

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

what the 2018 edition quietly fixed

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

the borrow checker was right and i was tired

chasing latency in a go service that looked fine

async/await is nearly here and i couldn't wait

the 2018 edition quietly rewired my rust habits

parsing without regret, using nom

building for the pi without ever touching the pi

what rust error handling felt like before the crates showed up

the borrow checker was right and i was tired

the error said "no such file" and not which one

the error type i wrote forty times before i learned the trick

i rewrote a 40-line shell script in rust and i'd do it again

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

what rust error handling felt like before anyhow turned up

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

i rewrote a thirty-line shell script in rust, and mostly enjoyed it

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

rust feels different since the edition landed

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

parsing a config format with nom, and learning to think in combinators

building go binaries for the pi without a toolchain in sight

the borrow checker was right and i was being stupid

the small joys of the 2018 edition

every interface{} i wrote came back to bite me

the borrow checker was right and i was wrong, again

i wrote a 200-line tool in rust to avoid a 20-line shell script

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

parsing a daft little config format with nom

i rewrote a 40-line shell script in rust, and i'd do it again

the function signature that accepts everything and promises nothing

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

i rewrote a shell script in rust and i have feelings

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

i rewrote a tiny shell script in rust, here's the honest accounting

threading context.Context through, and finally understanding why

building for the pi without compiling on the pi

the borrow checker was right and i was wrong, again

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

parsing a config format with nom, and learning to think in combinators

parsing a log line with nom, and why i stopped reaching for regex

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

the borrow checker was right and i was wrong, again

fighting the borrow checker and losing gracefully

threading context through, and learning to stop fighting it

a small parser, written with nom

go is finally getting real dependency management

parsing a log format with nom, and learning to think in combinators

context.context, and learning to thread it through

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

the borrow checker was right and i was wrong, again

i shipped a forty-line daemon and it just runs

i want go to just solve dependencies

the .context() helper i keep copying between rust projects

losing to the borrow checker, then realising it was right

a christmas-break rust cli, and the honest cost of it

error handling in rust, the year before anyhow saved us all

another small rust cli, and the part i keep getting wrong

forty lines of go that quietly run my house

when rust error handling meant rolling your own

a rust tool to find duplicate files, and whether it earned the build time

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

i tried to mutate a vec while iterating it, and rust said no

the goroutine that never came home

a hundred lines of go that quietly renews our certs

the borrow checker was right and i was holding a reference too long

the borrow checker was right and i was tired

the day the borrow checker was right and i was wrong

a weekend rust cli, and whether the borrow checker earned its keep

the one-liner that talked me out of rust

another small tool, another afternoon in rust

getting go onto an arm box without dragging a toolchain along

the borrow checker was right and i was tired

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

another small rust cli, and the parts i'd do differently

context.context, and finally threading it through everything

rolling your own error type in rust, the long way round

the goroutines that never came home

the borrow checker was right and i was wrong

the goroutines i forgot to stop

the borrow checker won, and i'm fine with it

building go binaries for the pi from my laptop

the borrow checker was right and i was wrong

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

the smallest daemon i could justify writing

a tiny cli in rust, and whether it earned its keep

a little cli in rust, was it worth it

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

i rewrote a shell script in rust and i'm not sorry