By John Mylchreest

Rebuilt the Blog. Again.

Putting It Together: A Worked Inventory Replication Example

Constructing It Client-Side, and the Blueprint Surface

FastArraySerializer: Replicating Lists Without Resending Everything

Custom NetSerialize: Packing Your Fields by Hand

USTRUCTs as Network Payloads, and Exposing Them to Blueprints

Breaking Up Data Objects to Send Across the Network in Unreal

The Day I Took Down My Whole Network With One DNS Change

Blinking An LED On An STM32 With Embedded Rust

A KVM Over IP I Built From A Spare Pi

The Afternoon A Full /var Took The Service Down

The Bug That Refused To Exist Under strace

Watching A Cloud Region Wobble In Real Time

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

How The 2018 Edition Quietly Fixed My Rust

Fine-Tuning a Small Model to Do One Dull Thing Well

Klipper Turned My Slow Printer Into a Fast One

Multi-WAN Failover That Actually Fails Over

Parsing Without the Regret, Using nom

The Deprecation That Caught The Whole Timeline Off Guard

The Bug That Only Existed When I Was Not Looking

A Spare GPU and a Model That Lives in My House

Trait Objects vs Generics, With Numbers

A Systemd Unit That Refused To Stay Dead

Too Many Dashboards And Not Enough Sense

The Day It Was, In Fact, DNS

Printing the Parts That Fix the Printer

The Keynote Everyone Has Already Decided About

The Launch Everyone Is Pretending To Have Opinions About

The Deprecation Nobody Read the Email About

The systemd Unit That Refused to Stay Dead

Designing the Bracket Instead of Buying One

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

Cache Misses, and Why the Fast Version Was Slow

KVM Over IP, Built From a Pi

Reflashing a Router I Should Have Left Alone

A Memory Leak That Was a Map I Never Cleared

A Shell Prompt That Tells Me What I Need

Moving Services Off the Cloud and Back Home

Fighting the Borrow Checker, and Losing Gracefully

How fzf Quietly Rewired the Way I Use a Terminal

Moving Root Onto ZFS

Threading context.Context Through, Properly This Time

A Cheap Logic Analyser and Finally Seeing the Bus

QoS for a Household That Streams Absolutely Everything

The Service That Wouldn't Stay Stopped

A Week Spent Watching a Goroutine Count Climb

The Goroutine Leak Hiding in a Timeout

How tmux Stopped Me Losing Work to a Dropped SSH Connection

A Kernel Panic I Could Actually Reproduce

Three Days Lost to a Race I Couldn't Reproduce

Finally Understanding Unreal's Gameplay Framework

A Book That Changed How I Think About Systems

Backups I Actually Test Now

The Router That Took Two Flashes to Forgive Me

Reflashing a Router I Should Have Left Alone

A Shell Prompt That Tells Me What I Need

The Announcement Everyone's Arguing About, And What It's Really For

TrueNAS and the Great Disk Shuffle

Threading context.Context Through, And Where It Goes Wrong

Multi-WAN Failover That Actually Fails Over

My Dotfiles, Finally In Order

A Prompt That Tells Me What I Actually Need

Fixing A PSU Instead Of Binning It

The Big Launch, And Why I'm Not Rushing To Migrate

A Runaway Process, And The cgroup That Caught It

Losing Gracefully To The Borrow Checker

The Goroutine Leak That Hid In Plain Sight

The Keynote Everyone Has An Opinion On

Klipper, and a Printer That Suddenly Flew

A Cheap Logic Analyser and Finally Seeing the Bus

Running My Own Recursive Resolver

The Five Git Aliases I'd Miss Most

Too Many Dashboards, and the Slow Walk Back

TrueNAS and the Great Disk Shuffle

When A Bug Gets A Logo Before It Gets A Patch

How We Did Rust Error Handling Before anyhow Saved Us All

The Five Git Aliases I'd Miss On A New Machine

When a Tool You Depend On Gets Bought

The Helpful Assistant That Confidently Deleted My Branch

Reliable Does Not Mean What You Think In Unreal RPCs

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

The Book That Made Me Stop Drawing Boxes and Start Drawing Loops

Running a Local LLM on Hardware That Should Have Said No

The Edition That Quietly Reshaped How I Write Rust

Running llama.cpp on a Machine That Should Know Better

How to Move House Without Losing the Homelab

A Weekend Where Nobody Paged Me

The Off-by-One That Three of Us Approved

I Printed the Bracket Instead of Ordering It

When logrotate Wins the Rotation but Loses the Logs

cgroups v2 and a Runaway Process

The Bug Was in My Head, Not the Function

Everyone Has a Take on the Keynote, Here's Mine

Generics in Go: Do I Even Need Them?

It Was the MTU. It's Always the MTU.

tcpdump Saved Me Again

tmux, and Never Losing a Session Again

Another Week, Another Disclosure, and the Same Tired Scramble

I Wired an LLM Into My Shell, Here's Where It Went Wrong

IPv6 at Home, Eventually

The Sci-Fi Film I Was Sure I'd Hate

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

The Off-By-One That Three of Us Approved

The Bug I Solved Halfway Up a Hill

Reflashing a Router I Should Have Left Alone

When the Code Was Right and I Was the Bug

The Bug Was in My Assumptions, Not the Code

Working From Home, the Honest Version

the leak was a map that only ever grew

the garage rack, two years on, regrets included

bgp in the homelab, because why not

context.context, and learning to thread it through

a keyboard you build is mostly a firmware project with switches attached

when the tool you depend on gets bought, and what you do next

how I bricked a router, and the long way back to a working one

the query that was fine until it wasn't

my prompt earns its keep

a tiny model on a tinier machine

the router that worked fine until I touched it

i let the agent type, but i keep my hand on the wheel

ipv6 at home, after years of putting it off

when in doubt, watch the wire

the llm in my shell, and where it drew blood

ipv6 at home, after years of meaning to

the cupboard model, one card and one prompt

the film i was sure i'd hate

a spare gpu, a quiet llm, and a weekend gone

the session that survived the dropped connection

the fast version was slower, and the cache was why

i finally stopped typing grep -r

a spare 3060 and an evening with ollama

what a syscall actually costs, with numbers

rewriting a shell script in rust, and counting the cost

half the internet leaned on one region, and it showed

a weather station that's right about everything except the rain

the borrow checker was right and i was tired

the cron job that fired twice and told no one

i put bgp in the spare room and i regret nothing

bringing it all back home, one service at a time

how cgroups v2 caught a runaway before it took the box down

a full walkthrough of fine-tuning a small model for one dull task

fine-tuning a tiny model to do one dull job well

keeping the telly happy when everyone's online at once

losing to the borrow checker, then thanking it

making peace with rootless podman

how much swap, and why i stopped arguing about it

the tmux setup that means i never lose work to a dropped ssh again

a kernel panic that finally held still long enough to catch

three days lost to a gap between two lines

when journald quietly ate forty gigabytes

a shell prompt that tells me what i actually need

a five pound capacitor versus a new power supply

the keynote everyone has already decided about

bgp in the homelab, because why not

qos for a household that streams everything

moving root onto zfs and not regretting it

tailscale, and finally giving up on port forwarding

a backup you've never restored is just a hope

one compose file to rule the homelab

is multi-material printing actually worth the faff?

search that understands what you meant, running on the laptop

i built fourteen dashboards and look at none of them

i don't reach for grep first anymore

the day journald quietly ate forty gigabytes

the quiet cost of a licence change nobody asked for

when journald quietly ate twelve gigs

my first proper fight with unreal's replication

a small go daemon, actually finished

the backup you never restore is just hope on a disk

nextcloud, for the third time, and the setup that finally stuck

the ssh drop that finally made tmux stick

the cron job that ran twice and told no one

running a 7b model on hardware that should know better

how much swap, finally answered for my own boxes

watching an outage land while the status page stayed green

the first few prints, and the first few failures

the makefile as a memory aid, not a build system

moving root onto zfs without losing my nerve

the cron job that fired twice and told no one

it was the mtu, it's always the mtu

pulling a few things back off the cloud

perf top on a box that had no business being busy

making peace with the first layer

where the context goes, the cancellation follows

i built nineteen dashboards and looked at two

the day i deleted my logging wrapper

threading context.Context through, and finally understanding why

mikrotik or pfsense? a year on, the verdict is "it depends" and i mean it

the year i stopped writing iptables rules by hand

moving twelve terabytes without losing my nerve

letting the robot drive, with my hand near the wheel

how home assistant quietly colonised my free time

multi-material printing, and the honest cost of those colours

what a syscall actually costs you, with numbers

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

klipper turned my slow printer into a fast one overnight

my first rag pipeline retrieved confidently and answered wrong

making peace with the first layer

a kvm over ip i could actually trust, built from a pi

i found my old film camera and it found my weekends

the unreal rpc reliability flag that quietly ate my events

the book that taught me to stop blaming the operator

how much does crossing into the kernel actually cost

working from home, the bits nobody puts in the LinkedIn post

the leak was a cache that only ever grew

letting an agent touch the code, with the safety on

a small agent that books its own train tickets

replacing every disk in the pool without losing my nerve

a prompt that earns its keep

putting a spare gpu to work as a private model server

working from home, with the gloss taken off

bringing the small things back home from the cloud

making multi-wan failover do the one thing it promises

when the writeback storm hits and everything stalls

the smallest useful daemon i've written this year

forty minutes in cad beats a fortnight waiting for a bracket

two years of rust in production, and an honest tally

building multi-WAN failover that fails over when you're not watching

real certificates for services that never touch the internet

poking at a usb-c charger until it gave me 20 volts

the average is lying to you, look at p99

a year of MikroTik after a decade of pfSense

the router worked fine until i decided to improve it

a tiny model that does one dull thing well

fzf, and the slow death of remembering exact filenames

the printer printing its own spare parts

i fired my ISP's DNS and ran my own resolver instead

building a keyboard was the easy bit, the firmware was the fun bit

watching syscalls without a debugger holding the door open

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

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

the query that wasn't slow, it was just run a million times

how we did rust error handling before anyhow turned up

which local model actually helps me write code

a cheap logic analyser, and finally seeing the bus

another quiet deprecation, another loud morning

a weather station that is right most of the time

a year on mikrotik, and i'm not going back to pfsense

the process that ate a box and the cgroup that didn't

the unreal rpc that arrived sometimes, eventually

persuading a usb-c charger to hand over 20 volts

another drive, another episode i didn't mean to finish

i built an agent that does the boring bits, and learned where the seams are

the bracket didn't exist, so i drew it

the router that worked fine until i improved it

five hours of motorway and the back catalogue of a podcast i'd been ignoring

one compose file to rule the homelab (and the regret that followed)

running a 7b model on a thin client i bought for a tenner

lessons from the second pi-kvm i built

a pi-kvm in a 3d-printed box, finally

qos for a house that never stops streaming

stopping journald from eating the disk

the service that wouldn't die, and the restart loop that hid it

async/await landed and i rewrote everything

chasing a race condition for three days

four hours of motorway and one very good podcast

letting an agent touch the code, but never on its own

go generics, and the day i finally reached for them

the second draft of my little agent

the fast version was slower, and the cache told me why

the ssh dropped, and my work was still there

fzf, or how i stopped remembering paths

the dotfiles repo i should have made years ago

a weekend with the pager switched off

making peace with the first layer

a small agent that does the boring bits

three days for a missing lock

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

the smallest agent loop that earned its keep

the average response time that hid a fire

ripping out openvpn and not missing it

the query that was quietly killing us

three days chasing a bug that only existed sometimes

switching editors one keybinding at a time

when a licence change costs more than money

the multiplayer prototype that put me firmly in my place

the bracket I printed instead of bought

fzf quietly rewired how I use the terminal

an esp32 weather station that mostly works

generics in go, do i even need them

reverse proxy, certs, and let's encrypt at home

the cost of a syscall, measured

the vulnerability industrial complex

the slow joy of reading on paper again

the day dns took down everything

poking at io_uring for an afternoon

i ran kubernetes at home, and mostly regret it

my first rag pipeline retrieved confidently wrong things

parsing a config format with nom

a language model lives in my terminal now, and mostly that's fine

blinking an LED the hard way, in Rust

a year on MikroTik after a decade on pfSense, the honest verdict

moving root onto zfs without losing my nerve

the query that was fine until it wasn't

backups you haven't restored are just wishes

the rollback that turned a bad upgrade into a non-event

a tiny agent, a tool loop, and a healthy fear of let-it-rip

the borrow checker was right and i was wrong, again

a weekend where my phone was just a phone

the prompt earns its place on every line

the resolver lives here now

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

fuzzy finding is now muscle memory

when everything works except the big stuff

everyone's talking about the same model again

my first proper fight with unreal replication

how i learned to lose to the borrow checker gracefully

makefiles for things that aren't c

the spare gpu finally earns its keep

the ssh dropped and i didn't care

the cron job that ran twice and told no one

when the thing you depend on gets bought

mtu, the silent killer

my first proper fight with unreal's replication

an acquisition lands on a tool i actually use

nextcloud, again, but properly this time

taming journald disk usage

trait objects vs generics, with actual numbers

the afternoon i broke dns and then couldn't look up how to fix it

docker compose for the whole house

printing parts to fix the printer

the backup that overlapped itself and nobody noticed

building once on the laptop, running on the pi

picking up the film camera again after a decade in the cupboard

when someone buys the tool you depend on

i found my film cameras again, and i'm glad i did

how much swap, and the answer nobody on the internet agrees on

pulling vlans through a network that had none

the book that taught me to look for the constraint

letting an agent touch the code, with the safety on

a small agent that earns its keep

kubernetes in the spare room, and why i kept some of it

the day fzf quietly took over my shell

what local code models are actually good for, after a month of trying

the printer that prints its own spare parts

cutting a flat home network into vlans without taking it all down

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

i had eleven dashboards and could not tell you if anything was broken

reliable does not mean ordered, and other ways unreal rpcs lied to me

an llm in my shell, and the handful of times it bit me

first prints, first failures, and the slow road to a clean benchy

home assistant ate my evenings, and i let it

the bracket that didn't exist, so i made it

running containers rootless without it ruining my week

tmux, and the day i stopped losing my work to a dropped ssh

a year on mikrotik, would i go back to pfsense

why i finally left esxi for proxmox

the router that fought back

a weather station held together with an ESP32 and optimism

bringing it all back home

the dotfiles repo i should have made a decade ago

the leak was a map, and the map was me

putting a runaway process back in its box with cgroups v2

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

the homelab as one stack, profiles and all

a pi cluster that taught me nothing useful but was fun

chasing a race condition for three days

one compose file to rule the homelab

a heated chamber for abs, eventually

fzf rewired how i use the terminal

moving to neovim, slowly

the 2018 edition changed how i write rust

the bug that only existed when nobody was watching

four hours of motorway and a head full of someone else's ideas

i thought multiplayer was just sending the player's position

my third nextcloud install, and the first one i trust

i solved it on the bike, not at the desk

i finally bought a logic analyser, and the bus stopped lying to me

a makefile is just a phone book for your project

the code was fine, i was the bug

the fast version was slower, and the cache told me why

small packets fine, large packets gone: it was the mtu

my first rag pipeline was confidently useless

everyone's waiting on a keynote, and i'm waiting to be unsurprised

small packets fine, large packets gone: an mtu story

keeping the calls clear when the house won't stop streaming

the august keynote everyone's arguing about, and the bit i actually cared about

speaking bgp to my own cupboard

it was never the database, it was dns

everyone's talking about the new flagship, i'm thinking about the supply chain

when the box freezes for a second, look at dirty_ratio

the leak was a map, and the map was me

a sitcom that knew where the bodies are buried

reliable does not mean what you think in unreal

forty lines of go that earned their keep

one compose file to run the house

bringing it all back home

when the writeback stalls everything

the async rewrite i swore i wouldn't do

the grinder rabbit hole

a kvm over ip for the price of a pi

my first rag pipeline was confidently wrong

four hours of motorway and a podcast that earned it

a tv show that nailed what the job actually feels like

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

the cron job that ran twice and told no one

the day my homelab lost its name

watching a cloud region wobble from the cheap seats

bringing a dead sensor board back with a soldering iron

a kernel panic i could actually reproduce

cache misses, and why the fast version was slower

kvm over ip, built from a pi for the price of a takeaway

perf top on a box that should have been idle

the leak was a map i forgot to empty

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

a pi-shaped kvm for the machine in the cupboard

putting a spare 3090 to work as a local llm box

my printer hates the first layer and so do i

the homelab moved house and so did i

bringing it all back home

i built a raspberry pi cluster and learned nothing useful, and i'd do it again

first prints, first spaghetti

an open model the size of a house, and what i actually think

a keyboard, soldered by hand, and the firmware that nearly beat me

a small daemon, in go, actually shipped

bringing a dead board back with a soldering iron and some stubbornness

how a bag of beans led me into the grinder rabbit hole

bringing a dead board back with a soldering iron and stubbornness

it was never the network, it was always dns

the keynote everyone has an opinion on, and why mine is boring

the smallest useful daemon i've written this year

ipv6 at home, eventually

rediscovering an old hobby

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

a thirty-quid kvm over ip from a pi and a hdmi grabber

the outage was a full disk, the disk was full of logs about the outage

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

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

a dead monitor, two bulging capacitors and a soldering iron

the day klipper made my old printer feel new

the rust i write now started with the 2018 edition

microsoft blinked on recall, and the argument is the interesting part

how we handled rust errors before anyhow saved us

i have too many dashboards and not enough alerts

the code was fine, my mental model was the bug

everyone's talking about apple intelligence and i mostly want the boring bits

i went in cynical and came out quiet

i run bgp at home now and i regret nothing

moving house when you own a small datacentre

the backup that ran on two boxes and nobody noticed

the bug i solved by leaving the keyboard

i stopped trusting other people's dns and ran my own

when journald ate half my root partition

the weather station on my shed roof, and the bits that lie to me

i finally stopped typing grep -r

a weekend where nothing paged me, and what i did with it

the book that rewired how i see systems

a language model in my terminal, and the days it turned on me

everyone is holding their breath for wwdc, and the ai noise is deafening

nextcloud, again, properly this time

moving the homelab off esxi and onto proxmox

my first rag pipeline was a confident liar

the makefile as a project's front door

when packets vanish and it's just the mtu

a cold joint, a magnifier, and a board that lived again

ibm bought hashicorp, and i went and looked at my terraform state

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

bricking a perfectly good router for no good reason

the unreal gameplay framework finally clicked, here's the map

the backup you have not restored is a rumour

i swapped pfsense for a mikrotik a year ago, here is the honest scorecard

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

the film i went into expecting to hate

four raspberry pis, a stack of jumper wires, and zero lessons learned

how i moved every disk in my nas without losing a byte

a kernel panic i could actually reproduce

on-device embeddings, or how i stopped paying per search

the flamegraph that pointed at the wrong hero

home assistant ate my evenings

i didn't need a bigger model, i needed a smaller, dumber one

sniffing a £6 bluetooth thermometer to find its secret

what two years of rust in production actually taught me

the query that wasn't slow, it was just always running

a spare 3060 and an evening with ollama

everyone's talking about gpt, i'm thinking about the boring bits

what's actually happening on the CC line when your charger negotiates

i built a raspberry pi cluster and learned almost nothing

io_uring, and the joy of not making a syscall per read

bringing it all back home

the garage rack, and what i'd do differently

how a cup of coffee cost me three hundred quid

a spare gpu, a quantised model, and lower expectations

my prompt earns its keep now

the bug i fixed without touching the keyboard

pprof found the allocation i swore wasn't there

i can't go back to grep -r anymore

the leak was a map i forgot to delete from

the day i pulled esxi out of the rack

dyn or not: i finally benchmarked it

fzf quietly rewired how i use the shell

a year on mikrotik after a decade on pfsense

bringing the services home again

nextcloud, again, and this time it sticks

a prompt that earns its keep

the makefile is just a menu

the day i resilvered the wrong pool

the bug that only happened when nobody was watching

i rewrote a thirty-line shell script in rust

bringing it all back home

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

the xz backdoor, and the volunteer who happened to be paying attention

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

nextcloud, the third attempt, and the one that actually stuck

the multiplayer prototype that ate my weekend and my ego

the router that was working fine until i improved it

a spare gpu, ollama, and a model that runs on my own metal

a long drive and a good podcast

ipv6 at home, eventually

mtu, the silent killer

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

multi-wan failover that actually fails over

my dotfiles, finally in order

rootless containers, and making peace with subuid

it's always dns, and this time it really was

how a single full filesystem took down a perfectly healthy service

rebuilding a truenas pool one disk at a time

a database query that was quietly killing us

deleting dep and never looking back

multi-material printing, and the long argument with myself about whether it earns its place

the book that ruined "it's working fine" for me

perf top on a box that shouldn't be busy

truenas and the great disk shuffle

the status page was green and the service was on fire

a makefile is a fine task runner, actually

reflashing a router I should have left alone

the multiplayer prototype that put me firmly in my place

when the network goes down, everyone discovers their dependencies

a dead psu, one swollen capacitor, and forty pence

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

interface{} is a promise I keep breaking

reverse-engineering a usb-c charger that lied to me

i went in to be polite and stayed for the whole thing

keeping the video call alive when the house is streaming

everyone's posting the video clips, i'm thinking about the plumbing

the cron job that ran twice and told nobody

too many dashboards and not enough alerts

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 bug that needed an hour on the bike

it was the mtu, it's always the mtu

the llm in my terminal is brilliant until it confidently isn't

the process that ate the box, and the cgroup that fenced it in

cutting out the middleman with my own resolver

when the logs lie, the wire doesn't

i built a keyboard and then spent a week on the firmware

one compose file to rule the homelab

everyone has an opinion about the gemini rename

the book that taught me to leave slack in the system

the query that was fine until it wasn't

the app that kept writing to a deleted log file

a rack in the garage, regrets and all

the password reset bug nobody wants to admit they ship

the prompt that earns its keep

the dead psu was a forty pence capacitor

the pi cluster that taught me nothing useful but was fun

a shell prompt that tells me what i need

ipv6 at home, eventually

nftables instead of iptables, finally

i went in cynical and came out quiet

the borrow checker was right and i was the bug

a year of running mikrotik next to pfsense, and which one stayed

when the app, the logs and the dashboards all lied, tcpdump didn't

the cron job that ran twice and told no one

opentofu ships 1.0, and i'm quietly relieved

why i finally moved the homelab off esxi and onto proxmox

my first rag pipeline retrieved confidently wrong things

an esp32 weather station that mostly works

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

goroutines and the leak i didn't see

the average latency was fine, which is why everyone was angry

yes i still run swap, even with plenty of ram

when the page cache fights back

the bug i fixed forty miles from my keyboard

my first rag pipeline retrieved confidently wrong answers

the outage that was just a disk quietly filling up

context.Context, and learning to thread it through

first prints, first failures, and a lot of wasted plastic

klipper, and the printer that suddenly learned to fly

the afternoon i poked at a usb-c charger with a logic analyser

bgp in the homelab, because why not

how btrfs snapshots gave me my weekend back

my dotfiles, finally in a state i'm not ashamed of

ripgrep, fd, and quietly giving up on the old tools

btrfs snapshots saved my weekend

coffee, and the rabbit hole of grinders

the keynote that everyone has an opinion on

the launch that's dominating tech this week

a prompt that earns its width

the makefile as a project's front door

multi-wan failover that actually fails over

the dead psu that only needed a 30p capacitor

which local model actually helps me write code

bringing the small stuff back home from the cloud

the one television show that gets the on-call dread right

how a single smart plug became a second job

two years of rust in production, the honest ledger

deleting Gopkg.toml and not missing it

rewriting the firewall in nftables

the box that was busy doing nothing

the film i went in resenting and came out quiet

threading context.Context through, properly this time

bringing the small stuff back home

the multiplayer prototype that humbled me

the backups i actually restore from now

klipper, and a printer that suddenly flew

where the time actually went under load

a prompt that earns its space

semantic search for my notes, all on the laptop

the four git aliases i'd miss the most

running a 7b model on a laptop that should know better

keeping the video call alive while everyone else streams

the day i deleted every port forward and slept better

the ssh dropped and i didn't lose a thing

i went in to be polite and came out genuinely moved

i put klipper on the old printer and it stopped being old

when a busy box stalls every thirty seconds, look at dirty_ratio

another provider had a bad day, and so did the rest of us

the great async rewrite, and what it actually cost me

i picked up the film camera again, and it slowed me right down

the bug that only existed when nobody was watching

the garage rack, and what i'd do differently

a keynote, and the quiet question nobody on stage answered

when the app won't reopen its logs

tls on the home network without the faff

i finally threw out openvpn

rebuilding nextcloud and meaning it this time

the idle box that wasn't

the day i stopped forwarding ports

four hours of motorway and one very good podcast

the multiplayer prototype that took me down a peg

the smallest daemon i could get away with

i finally moved the firewall to nftables

the runaway process that cgroups v2 quietly contained

multi-wan failover that fails over before anyone notices

the day journald ate the root partition

a shell prompt that earns its keep

the systemd unit that would not stay dead

a makefile is the readme nobody updates but everybody runs

the map that ate all the memory

the off-by-one three of us missed

learning to thread context.Context all the way down

running my own recursive resolver at home

four hours of motorway and a podcast i didn't want to end

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

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

the loop that processed every day except the last one

running a 13b model on a laptop that cost less than the gpu i wanted

which local model is any good at code, actually

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

the off-by-one three people signed off on

poking at a £6 bluetooth thermometer until it talked

real certificates for things that never touch the internet

cutting a flat network into vlans without taking everything down

the flame graph that pointed at a function i'd forgotten existed

perf top, and an idle box that wasn't

what actually owns what in unreal's gameplay framework

how home assistant quietly stole a fortnight

the day klipper made my old printer fast

where a go service actually spends its time

putting root on zfs, and why i would do it again

four raspberry pis, one bad idea, no regrets

the service that would not die

a small agent that does the boring bit for me

putting a leash on a process that ate the box

when the tool you depend on gets bought, what actually changes

semantic search that never leaves the laptop

poking at a four-quid bluetooth thermometer

the day i stopped losing my shell

four hours of motorway and one good episode

i put a server rack in the garage, and i'd do it again (mostly)

running bgp at home, which i will not pretend i needed to

the great disk shuffle, or how i rebuilt a pool without losing my nerve

forty lines of go that quietly do their job

how rust 2018 quietly rewired my instincts

the night a logfile took the service down

a prompt that earns its keep

the rpc that worked on my machine and nowhere else

a language model on the gpu that was gathering dust

the rare gift of a kernel panic that reproduces on demand

the connection that hung at exactly the wrong size

when logrotate quietly stops working because the app won't reopen

bricking a router that was working perfectly well

a year on, where go generics actually earn their keep

dotfiles that survive a new laptop in one command

bringing a dead board back with a soldering iron

how tmux stopped me losing work to dropped ssh

a backup you have not restored is a rumour

rootless podman, and the uid map that finally clicked

the first time unreal's replication made sense to me

learning to thread context.Context through everything

getting multi-WAN failover to actually fail over

stop trusting someone else's dns

the day klipper made my old printer fast

when logrotate and your app disagree about SIGHUP

what a syscall actually costs you

a keyboard build, and the part where the firmware fought back

bringing it all back home, one service at a time

how much swap does a homelab actually need

the leak that was just a map nobody ever emptied

the disclosure everyone's forwarding, and the boring bit underneath

an esp32 weather station, mostly working, which is the best kind

my dotfiles, finally in some kind of order

stop fighting context.Context and start threading it

when logrotate and a deaf daemon disagree

a weekend the pager stayed quiet

parser combinators finally clicked, thanks to nom

search that understands me, running on my own laptop

a week of stringing, warping, and one good print

i was certain it was a race condition

watching an outage from the cheap seats

the backups i finally bothered to test

a btrfs snapshot bought back my saturday

when the write cache fights back: tuning dirty_ratio

when a tool you depend on gets bought, and the quiet dread that follows

watching someone else's outage from the cheap seats

prising open a £6 bluetooth thermometer

i built a four-node pi cluster and learned almost nothing

the day fzf quietly rewired my terminal habits

running code models on my own gpu, a fair-ish comparison

poking at a cheap bluetooth gadget until it confessed

the half-hour my homelab lost dns to itself

the flamegraph that pointed at logging, of all things

pprof under real load, not in a benchmark

i finally tore out openvpn and the house got quieter

everyone is talking about the same release, so here is what i actually think

i wired an llm to my shell and it mostly behaved

stop letting journald eat your root partition

how much does a syscall actually cost?

the service that would not die

how home assistant quietly took over my evenings

i finally stopped reaching for grep and find

working from home, three years in and no rose tint

coffee, and the rabbit hole of grinders

flamegraphs and a hot path i never suspected

kubernetes at home was a mistake (mostly)

reflashing a router i should have left alone

the cost of a syscall, measured

trait objects vs generics, a real benchmark

building go binaries for the little arm box in the cupboard

the day klipper made my old printer fast

the average latency that lied to my face

making the second internet line earn its keep

the bug that only existed when nobody was watching

the goroutines that never came home

rootless podman without the rage

real certificates for things that never touch the internet

a language model on the spare gpu, and what it's actually good for

the day i deleted every port forward and didn't miss them

i am now running bgp at home and i regret nothing

the flamegraph that pointed at the wrong file entirely

a makefile is just a list of things you keep forgetting

i put a proper rack in the garage and i have feelings about it

make is a fine task runner if you stop pretending it isn't

nom finally made parsing feel less like a chore

four hours of motorway and one very good episode

the optimisation that made everything slower

the bug i fixed forty minutes after closing the laptop

the leak was a map nobody ever deleted from

the morning a single file grounded a country

stopping journald from eating the disk

replacing every disk in a pool without losing the pool

how we did rust errors before anyhow and thiserror turned up

the logic analyser that ended weeks of guessing at i2c

making the wifi survive four people streaming at once

the slim book i keep pressing on people

when one process ate the box, and cgroups v2 finally fenced it in

i finally stopped poking holes in my firewall

the off-by-one that three of us missed

running bgp at home, purely to learn it

running a model on the spare 3090, and what it actually costs

one compose file to rule the house

the flamegraph pointed somewhere stupid

i finally gave up on port forwarding

fixing a psu instead of binning it

reverse proxy, certs, and let's encrypt at home

the spare gpu earns its keep

btrfs snapshots saved my weekend

kvm over ip, built from a pi

running a local llm on a spare gpu

a fence round the process that kept eating the box

the bug i solved twelve miles from my desk

what rust error handling felt like before anyhow turned up

it was the mtu, it's always the mtu

the bracket i couldn't buy, so i drew one

putting a language model on the spare gpu in the cupboard

moving root onto zfs and not regretting it

a vulnerability with a logo and a website

printing parts to fix the printer

running a local llm on a spare gpu

tmux, and never losing a session again

a back-garden weather station, held together with hope and a BME280

bed levelling, or how i stopped trusting paper

home assistant ate my evenings

the service that resurrected itself every ten seconds

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

blinking an led on an stm32 the hard, satisfying way

i finally stopped reaching for grep and find

what rust error handling felt like before anyhow turned up

the connection that worked until the payload got big

the log file that grew forever because nobody told the app

when a licence change quietly costs you a dependency

nextcloud, the third install and the one that stuck

putting a language model on the gpu that was just sitting there

moving root onto zfs and not regretting it

the one everyone's calling "the next log4shell"

when everything works except the things that don't

a language model of my very own

the long road to an enclosure for abs

i put a server rack in the garage and i have notes

i finally moved off iptables

one line to build for the little ARM box

small packets fine, big packets gone

the code was correct, my mental model wasn't

an esp32 weather station, and the lies sensors tell

the small fuzzy finder that quietly took over my shell

two colours of plastic and a lot of wasted filament

where the time actually went in a slow Go service

i went in to be polite and stayed for the whole thing

a keyboard i built, and the firmware that made it mine

one compose file to run the whole house

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

the afternoon one PHP worker tried to eat the box

a language model on the spare GPU, and what it was actually good for

the average was fine and the customers were furious

logrotate did its job, the app kept writing to a deleted file

every exporter i installed and the one metric i should have started with

the query that was fine until it wasn't

soldering switches is the easy half

i ran kubernetes in my house for two years, here is the bill

i had forty grafana dashboards and looked at three

a backup you haven't restored isn't a backup

when in doubt, watch the wire

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

a licence change that broke the internet's trust

a rack in the garage, regrets and all

a tiny daemon in go, shipped

making the wifi fair when everyone is buffering at once

i finally rewrote my firewall in nftables

rootless containers without losing my mind

rust in production, two years of regrets and wins

the keynote that everyone has an opinion on

four hours of motorway and one episode that stuck

the runaway process that cgroups v2 caught for me

make is a task runner that happens to compile C

i stopped trusting someone else's dns

the optimisation that made everything slower

a week of spaghetti and warped corners

what nobody tells you about replicated variables

the day my homelab dns ate itself

i have built too many grafana dashboards

when packets vanish: an mtu mystery

one compose file to rule the house

the average latency is lying to you

the logic analyser, or finally seeing what the bus was doing

leaving vim behind, one config line at a time

the query that only got slow once it mattered

generics in go, and whether i actually wanted them

a year on mikrotik, and what i miss from pfsense

poking at a cheap ble thermometer until it talked

making peace with the first layer

when every crate brought its own error type

talking to a tenner's worth of bluetooth

when the company that owns your tooling changes hands

the log that wouldn't rotate

reliable doesn't mean what you think in unreal

the journal grew until the disk noticed

the outage that was just a full /var

working from home, minus the linkedin gloss

the rollback that turned a disaster into a five minute job

the unhurried migration from vim to neovim

stop journald from eating the disk

making peace with unreal's gameplay framework

everyone's posting about the same release again

the show that made my on-call flashbacks worse

getting gpt-j to talk on an old gpu

first prints, first failures

makefiles for things that aren't c

a telescope, a deadline, and the cost of doing it right

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

bed levelling, the eternal war

the cost of a syscall, measured

the joy of a quiet weekend with no oncall

the dotfiles finally make sense

rootless containers, and the few things that bite

the unreal rpc that quietly didn't arrive

the prompt earns its keep

ripgrep, fd, and finally letting grep retire

bringing a dead board back with a soldering iron and stubbornness

ebpf, or how i stopped guessing and watched the kernel

a dead psu, a swollen capacitor, and one evening with a soldering iron

my first proper fight with unreal's replication

the sitcom that got working in it uncomfortably right

when a bug gets a logo before it gets a patch

the day klipper made my printer fast

replacing every disk in a pool, one at a time

reverse proxy, certs, and let's encrypt at home

running a local llm on a spare gpu

taming journald disk usage

why i moved the homelab from esxi to proxmox

reflashing a router i should have left alone

the swap debate, settled for my homelab

running kubernetes at home was mostly a mistake

getting rootless containers working without losing my mind

the outage that was just /var filling up

async/await finally clicked, so I rewrote everything

klipper turned my slow printer into a fast one

i finally moved off iptables, and it was overdue

bringing a dead board back with a soldering iron and stubbornness

the multiplayer prototype that taught me humility

latency, p99, and the averages that lie to you

interface{}, and the regrets it left me

poking at usb power delivery with a logic analyser

i finally stopped fighting bed levelling

i don't reach for grep and find any more

when the box freezes for a second every minute

when half the internet leans on the same control plane

three days for a bug that only happened when nobody was looking

multi-material printing, and the maths that put me off

the quiet cost of a relicence, and why my stack got nervous

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

it wasn't the database, it wasn't the network, it was dns again

i benchmarked dyn versus generics so i could stop guessing

the book that taught me to look for the loops

a language model on the spare gpu in the cupboard

i stopped trusting someone else's resolver and ran my own

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

the first week with a 3d printer is mostly failure

a year on mikrotik, and what i miss about pfsense

i stopped trusting other people's dns

making peace with a bed that won't stay level

caging a runaway process with cgroups v2

ebpf, or finally being able to ask the kernel a question

how much swap, and why i stopped arguing about it

a btrfs snapshot turned a wrecked upgrade into a five-second rollback

the app that politely ignored logrotate

the makefile as a project's front door

the night /var filled and took everything with it

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

the flamegraph pointed at the one function i'd ruled out

a spare gpu and a language model that runs in my own house

the ssh dropped and my work was still there

the off-by-one we all signed off on

rewriting it all for async/await

getting IPv6 working at home, finally

i finally ripped out openvpn for wireguard

the bicycle that had been gathering dust

tcpdump saved me again

the quiet weekend

taming writeback with dirty_ratio

the rare luxury of a kernel panic that came back on demand

when the thing you depend on gets bought

cutting a flat homelab into vlans without burning it down

four hours of motorway and one very good podcast

i ran kubernetes at home and mostly regret it

how the 2018 edition quietly retrained my hands

the outage was just /var being full

the weekend i tried to add multiplayer and learned to respect it

the off-by-one we all read and nobody saw

running the whole house from one compose file

nextcloud, the fourth attempt, the one that stuck

a weather station held together by hope and a bme280

the backups i now bother to restore

why my homelab moved off esxi onto proxmox

the day i deleted every port forward and felt better

the smallest useful daemon i've written this year

a year of mikrotik and pfsense, and which one i kept

the router that worked fine until i improved it

structured logging in go that i can actually grep

the disclosure everyone's forwarding around this week

the bits of root-on-zfs nobody warns you about

moving root onto zfs and not regretting it

two colours, twice the headache

a language model on the gpu i forgot i had

logs you can actually query

when the application logs lie, the wire doesn't

the year i finally let ipv6 into the house

bringing it all back home

the code was fine, i was wrong

my multiplayer prototype, and the lie of "it works on my machine"

the off-by-one four of us read and none of us saw

running bgp at home, for reasons i can mostly justify

the cron job that ran twice and told nobody

i went in to mock it and came out quiet

the day i put a server rack in the garage

three days for a bug that lived in a missing word

running bgp at home because i could not help myself

the rewrite that was meant to be faster, and was not

finally on go modules, and saying goodbye to dep

tmux, or how i stopped mourning dropped ssh sessions

another log4j point release, and what that month taught me

making multi-WAN fail over before anyone notices

getting gpt-j to talk on a spare gpu, and why it's harder than the demos suggest

how much swap, and why i stopped arguing about it

a makefile is just a list of things i keep forgetting how to do

how much swap, and why i finally stopped arguing about it

nom made me stop hand-rolling parsers, mostly

log4shell, and the long week of finding out where java was hiding

when logrotate works but the app keeps writing to the deleted file

when the logs lie, tcpdump tells the truth

the query that was quietly killing us

the sysadmin sitcom that hit too close

the fast version was slower, and the cache told me why

the printer that prints its own spare parts

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

moving to neovim, slowly, and on purpose

nextcloud, again, properly this time

soldering a dead board back to life

bpftrace, and finally being able to ask the kernel a question

i finally bare-repo'd my dotfiles and i'm annoyed it took this long

rpcs in unreal, and the reliable/unreliable footgun

i thought i had a coffee problem, turns out i had a grinder problem

a dead power supply, two bulging capacitors and a soldering iron

the long version: why your write-heavy box stalls, and how to stop it

a dead power supply, two bulging caps, and a soldering iron

i ran kubernetes at home and mostly regretted it

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

the page cache was lying to me about disk writes

building a box so abs would stop curling

the average is fine, the p99 is on fire

i picked up the pencils again

i finally stopped reaching for grep and find

the cron job that ran twice and told no one

when the bug gets its own brand

small packets fine, big packets gone

i finally ripped out openvpn

the bug that only happened when nobody was watching

read the vector, ignore the logo

an ESP32 in a jam jar that thinks it's a weather station

picking up a thing i'd quietly put down

when the CVE has better branding than your product

the region went away and so did half my afternoon

deleting Gopkg.toml and not missing it

the query that was fine until it wasn't

when a snapshot turned a ruined saturday into a five-minute rollback

one compose file to run the entire flat

a tenner of capacitors versus a new power supply

i designed the bracket instead of buying it

putting root on zfs, and what i actually gained

the day i stopped losing my work to a dropped ssh connection

the day my whole house lost dns, and it was me

i built a four-node pi cluster and learned almost nothing

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

moving house when you've a homelab to carry

the service that wouldn't stay stopped

keeping a video call alive whilst the house streams

i finally stopped reaching for grep

working from home, the honest version

the goroutines that wouldn't die

bringing it all back home

the idle box that was pegging a core

nextcloud, the third time, done properly

when journald quietly ate a third of the disk

i finally made my peace with swap

parsing a config format with nom, and liking it

a fencepost error nobody saw because it looked right

the off-by-one that three of us signed off on

the outage wasn't the cloud's fault, mostly

perf top on a box that should have been idle

i built a four-node pi cluster and learned nothing, gladly

proper https for everything on the home network

bringing a dead board back with a steady hand and flux

it was dns, it is always dns

a pi cluster that taught me nothing useful but was fun

bed levelling, the eternal war

the runaway process, revisited: cpu and io weights in cgroups v2

a rack in the garage, regrets and all

cgroups v2 and a runaway process

docker compose for the whole house

soldering a keyboard, then flashing the firmware that makes it mine

i deleted every port forward and the homelab got better

everyone has a windows 11 take and most of them are about the taskbar

the grinder matters more than the machine

make is a fine task runner if you stop pretending it builds c

the printer printed the parts to fix itself

the fencepost that three of us read and none of us saw

small packets fine, big packets gone, and a tunnel in the middle

the makefile is just a list of things i keep forgetting

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

the flamegraph that pointed at the one function i trusted

the router that was fine until i improved it

when nothing was down except the names

the bug that only existed when nobody was looking

the first layer is always lying to you

i had forty dashboards and no idea if anything was broken

another keynote, another timeline of hot takes

the pipeline ransomware is a billing-system story, not a hacker-movie one

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

an idle box at forty percent cpu, and what perf top told me

when the writeback stalls everything

the cron job that ran twice and told nobody

running the whole house on one docker-compose file

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

half the requests worked, which is how i knew it was the mtu

the bed is never quite level

a runaway process and the cgroup that caught it

home assistant ate a fortnight of my evenings

the hobby i'd quietly put down

the show that understood the on-call pager

losing to the borrow checker, gracefully

the goroutines that never came home

the multiplayer prototype that humbled me

yes, i run bgp at home

is multi-material printing actually worth the bother?

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

building for the pi without building on the pi

the network was fine until the packets got big

what does a syscall actually cost?

three hundred miles and an episode i didn't want to end

the breach was in the tool that watches the build

the disk wasn't full, /var was

the day i actually understood unreal replication

i built a raspberry pi cluster and learned absolutely nothing, which was the point

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

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

one compose file to run the whole house

soldering a keyboard, then arguing with qmk

a hundred lines of go that finally left my laptop