Managing project tools with Go
Comparing approaches for managing non-application tool dependencies in Go projects, including go tool, tools.go, and go run.
Recent Posts
Manually install and auto-switch Golang versions
A custom shell-based solution for automatically installing and switching Go versions when changing directories.
Go Concurrency Patterns
Essential Go concurrency patterns including goroutines, channels, mutexes, and common synchronization techniques.
Bitwise Operations in Go
Using bitwise operators in Go to manipulate individual flags within a single integer for compact state management.
Programming at the edge with Fastly Compute
A hands-on guide to building and deploying edge applications with Fastly Compute using JavaScript, Go, or Rust compiled to Wasm.
Go Typed Nil
Why an interface holding a nil pointer is not itself nil in Go, and how typed nils can cause unexpected behavior.
Continuous Integration and Deployment to multiple environments with Terraform Cloud and GitHub Actions
Implementing CI/CD across dev, stage, and prod environments using GitHub Actions with Terraform Cloud for state management.
The Power of OpenAPI: Simplifying API Design and Documentation
A comprehensive guide to designing, documenting, and validating APIs using the OpenAPI specification.
Beginner's guide to creating a Terraform Provider
A step-by-step guide to writing a custom Terraform provider in Go using the terraform-plugin-sdk.
Rust Smart Pointers
A reference guide to Rust's smart pointer types: Box, Rc, Arc, Cell, and RefCell, with usage notes and trade-offs.
New Laptop Configuration (Second Edition)
Updated guide for setting up a new macOS laptop including GPG/SSH key backup, Homebrew, Zsh, Neovim, and password store configuration.
Manage multiple versions of the Go programming language
How to install, manage, and switch between multiple Go versions using official tools and custom shell functions.
Setting up Neovim for Rust and Go development
Configuring Neovim with LSP support for Rust and Go development, including required executables and plugin setup.
Fix broken Vim Themes
A working solution for fixing broken Vim colour themes using Neovim, a proper terminal, and correct tmux configuration.
Developer Tools
An overview of my current developer toolchain including Ghostty, Neovim, Zsh, and a curated set of CLI utilities.
Go Style Guide
A personal Go style guide covering naming, error handling, interfaces, slice gotchas, and function design patterns.
GitHub Actions
A comprehensive guide to building CI/CD pipelines with GitHub Actions, covering workflows, jobs, steps, and reusable patterns.
Advanced Vim topics, tips and tricks
A deep dive into powerful Vim features including macros, global commands, substitutions, quickfix lists, and autocomplete without plugins.
Rust Ownership, Borrowing, and Lifetimes
A practical explanation of Rust's memory management model covering stack vs heap, ownership rules, borrowing, and lifetimes.
Reflection in Go
A practical walk-through of Go's reflect package using a real CLI flags library as the guiding example.
Tips for Comparing Code Libraries
A structured approach to evaluating and comparing external code libraries using a comparison matrix of key properties.
Rate Limiting at the CDN Edge
Implementing rate limiting at the CDN edge for public-facing services, covering algorithms and practical trade-offs.
Git Internals
A deep dive into the .git directory, plumbing vs porcelain commands, and how git works under the hood.
Python 101: Context Managers
Understanding Python context managers: what they are, why they matter for resource cleanup, and how to implement them.
Python 101: iterators, generators, coroutines
A step-by-step guide to understanding iterators, generators, and coroutines in Python, building from first principles.
Understanding the purpose of tox.ini
What the tox tool is, how to configure tox.ini, and why its config file is used by other Python tools like flake8 and pytest.
Python Management and Project Dependencies
How to manage multiple Python versions, set up virtual environments, and handle project dependencies on macOS.
Guide to Concurrency in Python with Asyncio
A guide to Python's asyncio module covering async/await, event loops, tasks, and when to use asyncio vs threading or multiprocessing.
Go Arrays and Slices
A deep dive into how Go arrays and slices work, including memory layout, append behavior, and capacity gotchas.
Staying Anonymous
Tools and techniques for limiting your online exposure, covering encrypted DNS, VPNs, Tor, and browser privacy.
HTTP Caching Guide
A practical guide to HTTP caching covering Cache-Control, Surrogate-Control, and caching strategies at client and proxy layers.
New Laptop Configuration
Step-by-step guide for setting up a new macOS development environment with Homebrew, Git, Python, Go, Vim, and tmux.
Multiple Branches in Git
How to use git worktrees to work on multiple branches simultaneously without stashing.
Algorithms in Python
Implementations of merge sort, quick sort, binary search, BFS, DFS, and Dijkstra's algorithm in Python.
Remote Working
Lessons learned from years of remote working, covering routines, communication, impact, health, and building relationships.
Mocking in Python
A practical guide to mocking resources in Python tests using unittest.mock, covering decorators, patching, and common pitfalls.
Calculating Big-O
A quick reference for calculating Big O time complexity by identifying dominant operations in an algorithm.
Algorithmic Complexity in Python
An introduction to Big O notation and algorithmic time complexity with Python examples for common operations.
Data Types and Data Structures
A high-level overview of scalar, composite, and abstract data types along with common data structures like arrays, linked lists, trees, and hash tables.
Python Code Design and Dependency Management
Python development practices for 2019 including type hints, static analysis with mypy, interfaces, and dependency management.
Modern JavaScript: Webpack and Babel
How to set up and configure Webpack and Babel for writing cross-compatible modern ES2015+ JavaScript code.
Engineer to Manager
A guide for software engineers considering the transition to engineering management, covering responsibilities, communication, and motivation.
Interview Techniques
How to conduct architecture interviews effectively, why whiteboard interviews are not inherently bad, and what to look for in candidates.
Post Mortems
How to run effective blameless post-mortems, including scheduling, invitees, attitude, and a reusable template.
OpsBot: Operations Slackbot
Building a Slackbot for incident management that creates channels, auto-invites responders, and looks up service runbooks.
Thinking about Interfaces in Go
A practical guide to designing flexible Go code using interfaces, dependency injection, and programming to abstractions.
Multigrain Services
Defining the spectrum from monolith to nano services and when each granularity of service architecture is appropriate.
Authentication with AWS Cognito
A deep dive into AWS Cognito covering user pools, identity pools, and building an authentication system for web applications.
A Guide to Effective 1:1 Meetings
Practical advice for managers and reports on running meaningful one-to-one meetings that build trust and drive career growth.
Project Management in Five Minutes
A concise project management checklist covering roles, priorities, user stories, and rollout planning for technical leads.
Engineering and Tech Recommended Reading List
A curated list of recommended books covering programming, architecture, testing, management, and communication.
Security with Python
Building a Python encryption library using scrypt for key derivation, covering KDF, PBKDF2, and digest generation.
Static Search With Lunr.js
How to add fast, free, client-side search to a static site using Lunr.js without any server-side dependencies.
Interview Topics
Key topics and questions to cover when interviewing at a new company, from culture and process to tech stack and vision.
Go Reverse Proxy
Building a reverse proxy in Go using httputil.ReverseProxy, from simple single-origin to configurable multi-route setups.
Hashing, Encryption and Encoding
A concise reference explaining the differences between hashing, encryption, and encoding with practical examples.
Computers 101: terminals, kernels and shells
An explanation of how terminals, kernels, and shells relate to each other and how programs interact with them.
Statistics and Graphs: The Basics
A beginner-friendly introduction to statistics covering data types, frequency, averages, distributions, and graph visualisation.
NSQ Queue Reader Best Practices
Practical guidelines for building performant and reliable NSQ queue reader services in Python.
Observability and Monitoring Best Practices
Best practices for application monitoring covering metrics, alerting strategies, data aggregation, and graph selection.
Load Testing Guidelines
A concise set of guidelines for running effective load tests, covering real datasets, traffic distribution, and tooling.
Logging 101
A practical guide to application logging covering log levels, structured logging, and choosing between logs and metrics.
Fastly Varnish
A deep dive into how Fastly's CDN works, covering Varnish internals, clustering, shielding, and edge programming gotchas.
Profiling Python
Techniques and tools for profiling Python applications including timers, cProfile, line_profiler, memory_profiler, and pyflame.
Profiling Go
Techniques and tools for profiling Go applications including pprof, benchmarks, and memory management analysis.
Dev Environments Within Docker Containers
How to use Docker containers as clean, isolated development environments for Python and Go projects.
Key Architecture
An overview of a layered personal security architecture using GPG keys, encrypted password stores, and SSH key management.
Hitchhikers Guide to Go
A comprehensive cheat sheet covering Go fundamentals, from types and control flow to concurrency and testing.
Concepts From the C Programming Language
Key concepts from learning C including compilation, memory management, pointers, and how higher-level languages abstract these details.
Understanding Man Pages
How to navigate Unix manual page sections, sub-sections, and search across them effectively.
Syscalls and C
Explaining the difference between Linux system calls and C library wrapper functions, and where to find documentation for each.
Bits and Bytes
A tour through bits, bytes, RAM, base number systems, and binary encoding fundamentals for newcomers to computing.
Terminal Password Manager
Setting up Pass, a GPG-based command-line password manager, as a free and secure alternative to GUI tools like 1Password.
Terminal Debugging Utilities
An overview of command-line debugging tools like tcpdump, telnet, netstat, and others for diagnosing network and application issues.
GitHub Pull Request Formatting
Best practices for writing clear, well-structured pull requests including size, process, and description formatting.
Big O for Beginners
A gentle introduction to Big O notation covering logarithms, factorials, and how to reason about algorithm growth rates.
The Perfect Developer Qualities
A list of ideal qualities for software developers including humility, patience, analytical thinking, and clear communication.
Git Merge Strategies
Explains the differences between git merge, rebase, and squash strategies with practical examples.
gRPC for Beginners
An introduction to Google's gRPC framework covering Protocol Buffers, service definitions, and building clients and servers.
Bash Watchtower
A simple Bash script that monitors web pages for failures and sends Slack notifications when endpoints return non-200 status codes.
RPC Variations in Go
Exploring different RPC implementations in Go including net/rpc, JSON-RPC, and gRPC with Protocol Buffers.
Understanding Golang's Func Type
How Go's http.HandlerFunc adapter uses a func type to satisfy the Handler interface and enable flexible HTTP routing.
Multiple SSH Keys for Different GitHub Accounts
How to configure multiple SSH keys on one machine to work with separate GitHub accounts.
HTTP/2
A quick introduction to HTTP/2 covering persistent connections, multiplexing, header compression, and server push.
Building Systems With Make
An introduction to using GNU Make as a modern build and automation tool, with practical Makefile examples.
Client Cert Authentication
How to configure nginx with client certificate authentication using Docker, including CA and CRL setup.
DNS 101
A comprehensive guide to how the Domain Name System works, covering IPv4, IPv6, DNS resolution, and record types.
Security basics with GPG, OpenSSH, OpenSSL and Keybase
A hands-on guide to cryptographic keys, PKI, GPG, OpenSSH, OpenSSL, and Keybase for encrypting and signing data.
Setting Up Nginx With Docker
A walkthrough of configuring nginx as a reverse proxy inside Docker containers to serve a backend application.
Designing for Simplicity
Lessons from building high-traffic systems at BBC News on complexity, caching, automation, and keeping software simple.
Thread Safe Concurrency
An exploration of shared memory vs message passing concurrency models including threads, locks, actors, and CSP.
GitHub Workflow
A team workflow for GitHub PRs using interactive rebase, squash commits, and cherry-pick merges.
Functional Recursive JavaScript Programming
Exploring recursion in JavaScript, the tail call optimisation problem, and techniques like trampolining to work around stack limits.
Refactoring Techniques
A summarised reference of commonly used refactoring techniques distilled from Fowler and Beck's Refactoring books.
MVCP: Model, View, Controller, Presenter
A breakdown of the MVC pattern and its evolution into MVCP with a dedicated Presenter layer for cleaner separation of concerns.
Basic Shell Scripting
A beginner-friendly guide to common unix shell commands and scripting fundamentals for everyday use.
Clean Coder
Key takeaways from Robert C. Martin's Clean Coder on professionalism, responsibility, testing, and time management.
Message Passing in Object Oriented Code
How thinking in terms of messages rather than method calls improves OO design, illustrated with Ruby's Proxy pattern.
Object Oriented Design
Distilled principles of good OO design from Sandi Metz covering dependencies, interfaces, duck typing, and inheritance.
Git Tips
A collection of useful Git commands and tips for everyday version control tasks.
JavaScript 101
A beginner-friendly introduction to JavaScript covering syntax, terminology, data types, and core language features.
Maintainable CSS with BEM
A quick introduction to writing maintainable CSS using the Block, Element, Modifier (BEM) naming convention.
Host Methods vs Native Methods
Understanding the difference between native ECMAScript methods and host environment methods, and how to detect each reliably.