Aran Wilkinson
github bluesky twitter strava calendar linkedin
/about/posts/now/resume Light Dark
Entries tagged :: golang
  • 2026-05-27

    Introducing Headcode: A Unified API for UK Rail Data

    Headcode is a unified, developer-friendly JSON API that takes the fragmented, legacy feeds of the UK rail network and turns them into clean, enriched real-time data.
    Read more ⟶
  • 2026-05-16

    Introducing jjw: a workspace manager for jj

    Introducing jjw, a small Go CLI for managing jj workspaces with bookmarks and lifecycle hooks, built to make parallel LLM coding agent workflows easier.
    Read more ⟶
  • 2026-05-13

    Why I built a reference Go project (and taught an AI agent to clone it)

    Why I built a reference Go project that doubles as a template an AI agent can clone, customise, and scaffold into a new service.
    Read more ⟶
  • 2025-10-17

    Using CUE to unify IoT sensor data

    How CUE schemas eliminate type assertion boilerplate when handling multiple IoT sensor types in a home automation system
    Read more ⟶
  • 2025-09-30

    Building an MQTT client in Go

    Build a production-ready MQTT client in Go with real examples from a Home Assistant smart home setup. Covers concurrent processing and device integration.
    Read more ⟶
  • 2025-01-31

    Go 1.24's new tool directive in go.mod

    Go 1.24 adds a tool directive to go.mod, replacing the old tools.go workaround. Learn how to declare, install, and run project tools directly through the module system.
    Read more ⟶
  • 2025-01-10

    Processing UK rail data in real-time

    A Go service for consuming real-time UK railway data from Kafka, with table partitioning and integration testing using Docker
    Read more ⟶
  • 2024-12-18

    PostgreSQL table partitioning with Go

    Practical guide to PostgreSQL table partitioning using date-based range partitions. Covers partition creation, automatic routing, query performance, and automating partition management with Go.
    Read more ⟶
  • 2024-12-09

    YAML configuration: an unexpected bug

    How an unexpected bug slipped into my YAML configuration library and the debugging process that uncovered it.
    Read more ⟶
  • 2024-11-23

    YAML configuration: the best of a bad bunch

    Why YAML remains the least painful option for application configuration, despite its quirks. A look at the alternatives and why they're all worse in different ways.
    Read more ⟶
  • 2024-06-24

    Why Go uses composition over inheritance

    Go doesn't have class inheritance, and that's by design. Learn how Go's structs, embedding, and implicit interfaces give you the flexibility of inheritance without the fragile base class problems.
    Read more ⟶
  • 2024-05-14

    yamlcfg: a Go library for YAML and environment variable config

    yamlcfg is a Go library that merges YAML configuration files with environment variables. Supports default values, type coercion, and nested configuration structures.
    Read more ⟶
  • 2024-05-08

    Encrypting and decrypting with Go's crypto/aes and crypto/cipher

    A practical walkthrough of Go's crypto/aes and crypto/cipher packages. Covers AES-GCM encryption, key sizing, NewCipher usage, and common pitfalls with working code examples.
    Read more ⟶
  • 2024-04-16

    You probably don't need to mock

    Go's testing tools are powerful enough that mocking is often unnecessary. Learn when to skip mocks and use real implementations, httptest, and integration tests instead.
    Read more ⟶
  • 2024-03-11

    Continuous deployment with Go and GitHub Actions

    Automate Go deployments to staging and production using GitHub Actions and Fly.io. Covers pipeline configuration, environment separation, and deployment safeguards with working workflow examples.
    Read more ⟶
  • 2024-02-11

    Building your Go toolkit

    learn how to build your own personal golang toolkit to help you become a more productive developer
    Read more ⟶
  • 2024-02-06

    Continuous integration with Go and GitHub Actions

    Set up a complete CI pipeline for Go projects with GitHub Actions. Covers linting with golangci-lint, running tests, handling private modules, and workflow configuration with real examples.
    Read more ⟶
  • 2024-02-03

    Getting started with Go and Kafka using franz-go

    Build Kafka producers and consumers in Go using the franz-go library. Covers Kafka architecture, topic management, message serialisation, and practical examples for real-time data streaming.
    Read more ⟶
  • 2024-01-11

    Building a future-proof data pipeline with Go and Kafka

    Explore our journey in revolutionising device data processing using Golang and Kafka, where we tackled high-frequency data challenges, improved throughput, and laid the groundwork for future scalability and efficiency.
    Read more ⟶
  • 2023-06-23

    Exploring Go 1.21: generics in the standard library and more

    What's new in Go 1.21: generics support in the standard library, the log/slog structured logging package, slices and maps packages, and toolchain management changes.
    Read more ⟶
  • 2023-06-10

    Using Go private modules with GitHub Actions

    Configure GOPRIVATE, SSH authentication, and GitHub Actions to work with private Go modules. Covers local development setup and CI pipeline configuration with step-by-step examples.
    Read more ⟶
  • 2023-03-31

    Understanding Go's sync.Cond

    A practical look at sync.Cond, Go's condition variable for coordinating goroutines. Covers Signal, Broadcast, and Wait with examples showing when to use it over channels or sync.Mutex.
    Read more ⟶