Learn Go, one byte at a time
251 free, in-depth articles on writing production-grade Go.
Get better at Go, one email at a time
Practical Go articles like these, straight to your inbox. Join 5,000+ Go developers.
One useful email at a time — no spam, unsubscribe anytime.
-
Advanced TopicsHow godiff Parses Large Git Patches Fast in Go
A look at godiff's Go internals: bufio.Scanner buffer limits, single-pass patch parsing, and bounded word-level diffs.
· 6 min read
-
Advanced Topicskube-bmc: Modeling Server Hardware as Kubernetes CRDs in Go
How kube-bmc exposes IPMI and Redfish baseboard controllers as Kubernetes objects, and which Go API patterns transfer well to other operators.
· 7 min read
-
Advanced TopicsTesting a Stellar Corridor Monitor in Go: Snapshots, Injected Clocks, and Exit Codes
Three tricks stellar-pathfinder uses to keep a Stellar corridor monitor testable in Go: recorded HTTP snapshots with hashes, clocks passed as arguments, and exit codes that mean something.
· 6 min read
-
Advanced TopicsHow uptimy/agent Builds Its HTTP API with net/http, ServeMux Patterns, and Context Keys
No router library, no framework. Just net/http and a few patterns from uptimy/agent worth copying: method-aware routes, a typed context key, a login that does the same expensive password work for unknown users, and one blank import that saves you a production bug.
· 7 min read
-
Advanced TopicsHow Gemini-Config-Checker Uses Go to Find and Drive a Chromium Browser
The Go patterns behind Gemini-Config-Checker: injecting os.Getenv and exec.LookPath so path discovery is unit-testable, build tags for the registry lookup, and why the configs stay as maps.
· 6 min read
-
Advanced TopicsServing RFC 9110 Range Requests in Go Without an io.ReadSeeker
How kofiadeyemiq/byterange parses HTTP Range headers, caps range counts so a tiny request can't trigger a huge multipart response, and serves 206s from any Open(offset, length) source.
· 7 min read
-
Advanced TopicsArch-Specific SIMD in Go 1.27: Using the archsimd Package
Go 1.27 extends the archsimd experiment to arm64 and wasm. Picking the right intrinsic is the easy part; the Go you write around it is what decides whether the thing is fast.
· 7 min read
-
Advanced TopicsAgentbox: the Go CLI patterns behind a self-hosted Claude Code and Codex workspace
How agentbox dispatches subcommands before flag.Parse, guards key rotation with syscall.Flock, and hides Claude Code and Codex behind one Go interface.
· 7 min read
-
Advanced TopicsHow gchat-go Structures a WebSocket Hub in Go
A walkthrough of akkovman/gchat-go: two goroutines per connection, ping-pong deadlines, and why http.Server.Shutdown leaves WebSockets running.
· 8 min read
-
Advanced TopicsAgent Tincan in Go: Cobra Exit Codes, Context Deadlines, and MCP Config Discovery
A read through agent-tincan's Go CLI: typed errors mapped to exit codes, best-effort network calls capped at 5 seconds, and config sniffing that reads before it parses.
· 8 min read
-
Advanced TopicsGo 1.27 Size-Specialized Allocation: Why Small Allocations Got Faster
Go 1.27 ships specialized mallocgc functions for allocations of 80 bytes or fewer. How size classes work, why 80 was the cutoff, and what the change means in practice.
· 7 min read
-
Advanced TopicsWriting Portable SIMD in Go with the Experimental simd Package
Go 1.27's experimental simd package keeps vector width out of the type system entirely. What that buys you, what it costs, and how to test code you can't run on real hardware.
· 7 min read
-
Advanced TopicsThe Go Memory Model in Practice: Happens-Before Rules for Everyday Concurrency
Go's happens-before rules for goroutines, channels, mutexes, atomics, and init — and the everyday idioms that quietly violate them.
· 8 min read
-
Advanced TopicsRate Limiting Go Services with golang.org/x/time/rate
Choose between Allow, Reserve, and Wait, size bursts deliberately, scope limiters per client, and test refill behaviour without slow sleeps.
· 8 min read
-
Getting StartedHow io.Reader and io.Writer Keep Go APIs Composable
Partial reads, EOF handling, io.Copy's fast paths, TeeReader and MultiWriter, buffering, and testing streams.
· 10 min read
-
Best PracticesTable-Driven Tests in Go: Subtests, Parallelism, and Keeping the Table Readable
Structuring Go table tests so failures tell you which case broke: t.Run naming, parallel subtests, t.Helper, golden files, and the point where a plain test function wins.
· 8 min read
-
Advanced TopicsGo 1.27: Generic Methods, encoding/json/v2, and What Actually Changes in Your Code
Generic methods, nested struct literal keys, encoding/json/v2, a uuid package, cheaper small allocations. What to use, what to test before you ship the upgrade.
· 7 min read
-
Advanced TopicsGo Build Constraints: //go:build Syntax, Filename Suffixes, and Custom Tags
How go:build expressions and filename suffixes decide which Go files compile, plus custom tags, cgo constraints, and testing across platforms.
· 7 min read
-
Best PracticesTesting HTTP Handlers in Go with httptest: Recorders, Servers, and Table Tests
Testing Go HTTP handlers with httptest.ResponseRecorder and httptest.NewServer: JSON bodies, headers, middleware, failure paths, and the mistakes that make tests hang.
· 8 min read
-
Advanced TopicsStructured Logging in Go with log/slog: Levels, Attrs, Groups, and Handlers
How to configure log/slog in a real service: runtime-switchable levels, attrs and groups, context-aware handlers, source locations, and the allocation traps.
· 6 min read
-
Advanced TopicsReuse http.Transport in Go: Connection Pools, Idle Limits, and Safe Customization
Creating a new http.Transport per request throws away Go's connection pool. A look at pooling, idle limits, and why you have to drain response bodies.
· 7 min read
-
Advanced TopicsAtomic Operations in Go: When a Mutex Is Still Clearer
How to use Go atomic counters, booleans, and atomic.Pointer safely, plus the cases where sync.Mutex is the clearer and more verifiable choice.
· 7 min read
-
DebuggingGoroutine Leak Profiles in Go 1.27: Finding Permanently Blocked Goroutines
Go 1.27 makes the goroutineleak pprof profile generally available for finding goroutines permanently blocked on channels and sync primitives. Here's how its GC-based detection works and where it stops.
· 7 min read
-
Advanced TopicsQuerying the pkg.go.dev API from Go: A Typed Client Walkthrough
pkg.go.dev finally serves JSON. Here's a typed Go client for it, plus the two API design decisions that break naive implementations.
· 7 min read
-
Advanced TopicsGo Error Chains: How errors.Is, errors.As, and errors.Join Actually Work
Go's wrapping contract is three lines of documentation. Here's what falls out of it: sentinel matching, typed extraction, and the multi-error trees errors.Join builds.
· 7 min read
-
Advanced TopicsWorker Pools in Go: Bounded Concurrency Without Goroutine Leaks
A Go worker pool that cancels cleanly, pushes back on the producer, and gets its errors out. Plus how to write a test that proves it didn't leak.
· 9 min read
-
Advanced TopicsGo select Statements: Timeouts, Cancellation, and Fan-In Patterns
When several select cases can proceed, Go chooses one uniformly at random. Here's what that means for timeouts, cancellation, non-blocking sends, fan-in, and nil channels.
· 8 min read
-
Advanced TopicsFuzz Testing in Go: Finding Edge Cases Your Table Tests Miss
Native Go fuzzing, end to end: picking a seed corpus that actually helps, reading the engine's output, and turning a crash into a permanent regression test.
· 8 min read
-
Advanced TopicsGraceful Shutdown for Go HTTP Servers: Signals, Draining, and Deadlines
A graceful shutdown sequence for Go HTTP servers: signals, readiness, request draining, deadlines, and a bounded wait for background workers.
· 11 min read
-
Advanced TopicsWhen sync.Pool helps in Go (and when it makes things worse)
sync.Pool can reduce allocations in the right workload, but misuse adds complexity for little or no gain. Here's how to decide.
· 5 min read
-
Advanced TopicsThe nil interface trap in Go will bite you eventually
A Go interface holding a typed nil pointer isn't nil. Here's how that breaks error handling and what to do about it.
· 5 min read
-
Advanced TopicsCVE-2019-17596: How a Malformed Certificate Could Crash Your Go Program
A malformed DSA public key could make Go's signature verification panic. Here's where the bug appeared, how Go fixed it, and what to check.
· 3 min read
-
Advanced TopicsHow database/sql manages your connection pool (and how to tune it)
How Go's database/sql connection pool works, what its settings control, and how to tune it from production data.
· 6 min read
-
Best PracticesThe default Go HTTP client can wait forever. Here's how to fix it.
Go's default HTTP client has no overall request timeout. Learn how client, context, and transport timeouts work together without breaking long-running responses.
· 5 min read
-
DebuggingHow to profile Go programs with pprof
Learn how to capture and read CPU, memory, goroutine, block, and mutex profiles with net/http/pprof and go tool pprof.
· 6 min read
-
Advanced TopicsMutexes in Go: when to use sync.Mutex vs sync.RWMutex
When to reach for sync.Mutex, sync.RWMutex, atomics, or channels in Go, plus the pitfalls that trip up experienced developers.
· 6 min read
-
DebuggingHow to find data races in Go with the race detector
Go ships a race detector that finds data races at runtime. Here's how to use it in tests, CI, and staging.
· 5 min read
-
Getting StartedGo channels: send, receive, close, and range without surprises
Channel ownership, closing rules, buffered vs unbuffered, and the failure modes that cause deadlocks or panics in Go.
· 6 min read
-
Advanced TopicsHow Riptide builds a terminal speed test with Go and Bubble Tea
Riptide is a Go CLI that measures bandwidth with a polished TUI. Here's how it uses Bubble Tea, build tags, and platform-specific monitoring.
· 5 min read
-
Advanced TopicsA Go-Powered Desktop GUI for Sliver C2 Using Wails and gRPC
How sliver-gui skips the REST proxy and speaks gRPC directly to Sliver C2 from a native desktop app built with Wails and Go.
· 6 min read
-
Advanced TopicsNox: A Modular Go Framework for Recon and Vulnerability Scanning
How Nox uses worker pools, modules, workflow stages, and clean package boundaries to build a large Go security tool.
· 6 min read
-
Advanced TopicsA 2D Wind Tunnel in Go with Ebitengine and Lattice Boltzmann
Kutta simulates airflow over airfoils using Go, Ebitengine, and lattice Boltzmann methods. Here's how it works.
· 5 min read
-
Advanced TopicsSpoofDB: One Go binary that fakes Postgres, MySQL, ClickHouse, and Redis
SpoofDB speaks real wire protocols so your tests hit a fake database instead of a real one. Here's how it works in Go.
· 5 min read
-
Advanced TopicsHeimdall: a Go terminal dashboard for hardware monitoring
Heimdall is a cross-platform hardware monitor written in Go. Its daemon, hub, dashboard, helper, and adapter boundaries are worth studying.
· 6 min read
-
Advanced TopicsLibrarry: How a Go Backend Manages Ebooks with Resilient Metadata
Librarry is a self-hosted ebook and audiobook manager written in Go. Here's how its backend keeps metadata, acquisition, and Readarr compatibility separated.
· 6 min read
-
Advanced TopicsTokenCode burns 1,000 agents in parallel — here is how it does it in Go
TokenCode's `/race` mode can fan one task out to as many as 1,000 isolated agents. The interesting part is that it does so with bounded concurrency and git worktrees, not chaos.
· 5 min read
-
Advanced TopicsHow Terraform models your infrastructure as a Go graph
Terraform Core uses typed addresses, a DAG walker, and a plugin protocol. Here's the part worth studying as a Go developer.
· 5 min read
-
Advanced TopicsKonflate: a Go tool that diffs your Flux pull requests before they hit the cluster
Konflate renders FluxCD HelmRelease and Kustomization diffs for PRs. Here's how its Go code fits together.
· 5 min read
-
Advanced TopicsHow Wellcake structures its Kubernetes operator API in Go
Wellcake is a Go-based Kubernetes operator for Valkey. Here's how it defines CRDs, handles API versioning, and wires controllers.
· 5 min read
-
Advanced TopicsBaidu built a network monitoring toolkit in Go — here is how it works
A tour of Baidu's nettools repo: raw ICMP probing, UDP echo diagnostics, TCP SYN scanning, and the Go patterns behind them.
· 5 min read
-
Advanced TopicsHow Take-Over Uses Go to Find Subdomain Takeover Vulnerabilities
Take-Over is a small Go scanner that checks targets against service fingerprints. The useful lesson is how much you can do with plain files, net/http, and careful matching.
· 4 min read
-
Advanced TopicsLagodev: A Laravel-style Go framework that ships with an ORM and CLI
Lagodev ports Laravel's conventions to Go — migrations, seeders, factories, and an Eloquent-style ORM. I dug into how it pulls that off.
· 5 min read
-
Advanced TopicsSenPaiScanner: How a Cloudflare IP Scanner Uses Go Concurrency
A walkthrough of SenPaiScanner's internals — goroutines, channels, Bubble Tea TUI, and how they all fit together.
· 5 min read
-
Getting StartedSubwayCLI: Rendering video frames as ASCII art in Go
SubwayCLI plays Subway Surfers in your terminal by embedding an MP4, decoding it with FFmpeg pipes, and converting frames to ASCII. Here's how the Go code works.
· 6 min read
-
Advanced TopicsNovaRadar: How a Go + React IP Scanner Does Two-Phase Verification
NovaRadar scans Cloudflare IP ranges using Go's net and crypto/tls packages. Here's how it works.
· 6 min read
-
Advanced TopicsEasySNI: How a Go tool rewrites TLS packets to bypass censorship
EasySNI uses raw sockets and TLS manipulation in Go to get around network censorship. I dug into how it's built.
· 6 min read
-
Advanced TopicsCrossLink: a Go proxy gateway for LLM APIs worth reading
CrossLink is a Go gateway that proxies LLM APIs with load balancing, rate limiting, and budget controls. Here's how it's built.
· 5 min read
-
Advanced TopicsHermes: Policy-Driven Lazy Loading for Container Images in Go
Hermes uses a Go controller and containerd snapshotter daemon to make SOCI lazy loading policy-driven on Kubernetes.
· 4 min read
-
Advanced TopicsGo might finally get generic methods
The accepted Go proposal for generic methods is now tracked for Go 1.27. Here's what it changes, and what it deliberately leaves alone.
· 4 min read
-
Advanced TopicsGo 1.24 finally makes HTTP/2 cleartext easy
Go 1.24 adds native net/http support for unencrypted HTTP/2 with prior knowledge. Here's the useful bit, and the gotchas.
· 3 min read
-
Advanced TopicsLeoflow: a GitOps workflow orchestrator built on Go containers
Leoflow is a container-native workflow orchestrator in Go that speaks the Airflow UI's language. Here's what's going on under the hood.
· 6 min read
-
Advanced TopicsHow Bumblebee scans your dev machine fast with Go concurrency
Bumblebee inventories packages across ecosystems for supply-chain security. Here's how its Go architecture makes it fast.
· 5 min read
-
Advanced Topicsgo-argus: A zero-dependency struct validator built on pure Go patterns
go-argus is a Go struct validator with no third-party dependencies, cached rule plans, a zero-reflection string path, and built-in translations.
· 5 min read
-
Advanced TopicsFinding Real IPs Behind Cloudflare with Go
cfsearch is a single-file Go CLI that hunts down origin IPs hiding behind CDNs. I break down how it uses Host headers, goroutines, and the standard library to pull it off.
· 6 min read
-
Advanced TopicsComview: a Go TUI for reading diffs that actually makes sense
Comview turns unified diffs into an interactive terminal review UI using vaxis, Chroma, cached syntax lexers, inline diff spans, and local review comments.
· 6 min read
-
Advanced TopicsNanotDB: An append-only time-series database written in Go
NanotDB is a tiny Go time-series database built for sensor data on weak hardware. I dug into how its storage engine is put together.
· 6 min read
-
Advanced TopicsHow Octo Matter structures a Go microservice around Gin, LLM clients, and clean layers
A look at Octo Matter's Go service architecture: Gin routing, service boundaries, MySQL repositories, LLM function calling, and safe async notification delivery.
· 8 min read
-
Advanced TopicsGograph: a Go CLI that parses your codebase for AI agents
Gograph builds a local AST-aware map of a Go repository so coding agents can query packages, symbols, calls, tests, config reads, and code-quality signals without reading every file.
· 5 min read
-
Advanced TopicsParsing Norton Ghost disk images in pure Go
nyarime/gho is a pure Go parser for Norton Ghost GHO disk images. No CGo, no dependencies — just binary parsing and compression.
· 6 min read
-
Advanced TopicsHow Karpov Gateway structures a multi-service Go API gateway
Karpov Gateway splits auth, billing, and proxying into separate Go binaries. Here's how its codebase is organized.
· 5 min read
-
Advanced TopicsHow fsnotify gives Go programs cross-platform file watching
fsnotify wraps inotify, kqueue, and ReadDirectoryChangesW behind one Go API. Here's how it works.
· 5 min read
-
Advanced TopicsHow mhr-cfw-go Uses Go to Route Traffic Through Domain Fronting
A Go proxy that bypasses DPI using domain fronting, MITM TLS, and HTTP/2. Here's how it works.
· 5 min read
-
Advanced TopicsNUMA-aware CPU scheduling in Go for 128-core Kubernetes nodes
How NexusFlow uses Go, Linux sysfs, cgroups v2, taskset, numactl, and gRPC to keep high-core workloads close to their memory.
· 6 min read
-
Advanced TopicsGooseRelayVPN: Tunneling TCP through Google Apps Script with Go
GooseRelayVPN builds an AES-256-GCM encrypted SOCKS5 proxy that tunnels through Google's infrastructure using Go. Here's how it works.
· 6 min read
-
Advanced TopicsStash gives AI agents persistent memory with Go and Postgres
Stash is a single Go binary that gives AI agents long-term memory backed by Postgres. Here's how the code is organized and why it works.
· 5 min read
-
Advanced TopicsFlowDriver: a Go transport that treats Google Drive as a queue
FlowDriver is a research transport that carries SOCKS5 traffic through Google Drive files. The Go lessons are virtual connections, binary envelopes, polling/flush loops, custom HTTP transport, and quota-aware design.
· 3 min read
-
Getting StartedGova: declarative desktop UI with plain Go structs
Gova is an early-stage Go GUI framework built around components, explicit scopes, state helpers, Fyne rendering, and native platform integrations.
· 2 min read
-
Advanced TopicsWave Terminal: where Go sits inside an AI-aware terminal app
The repo behind this post is Wave Terminal, a cross-platform terminal with a Go backend and TypeScript/Electron shell. The Go lessons are service lifecycle, generated schemas, connection testing, and helper commands.
· 3 min read
-
Getting StartedA small Go backend lab: the useful parts are the boring ones
golang-engineering-lab is a compact net/http service. Rather than pretending it is a concurrency showcase, this post looks at its package boundaries, context usage, middleware, and database access.
· 3 min read
-
Advanced TopicsCrabTrap: a Go proxy for putting policy in front of AI agents
CrabTrap is a Go MITM proxy for outbound agent traffic. The useful Go lessons are in its approval pipeline: static rules, LLM judging, request buffering, SSRF protection, and audit logs.
· 7 min read
-
Advanced TopicsZa-go: what an unofficial messaging client looks like in Go
Za-go wraps Zalo web/mobile behaviour behind a Go API. The useful parts are session state, service grouping, event channels, QR login helpers, and the risks of unofficial APIs.
· 2 min read
-
Advanced Topicssni-spoof: reading a Go TCP forwarder that works below TLS
sni-spoof is a small Go port of a DPI research tool. The useful Go details are raw packet access, TCP checksum construction, handshake tracking, and careful relay startup.
· 3 min read
-
Advanced Topicsxnew: deduplicating huge line-based files in Go
xnew is a small Go CLI for appending only unseen lines to large files. Its custom hash set shows a useful memory tradeoff for high-volume line processing.
· 5 min read
-
Advanced TopicsXata: Go services around a cloud-native Postgres platform
Xata's open-source platform is more than a Postgres operator. Its Go code shows service wrappers, Cobra command wiring, OpenAPI boundaries, Kubernetes types, and auth claims around CloudNativePG and OpenEBS.
· 2 min read
-
Advanced TopicsAList: what a Go file server looks like when storage providers are the product
AList is a Go file-listing server that wraps many storage backends. The useful parts are its Cobra commands, Gin server setup, provider registry, and protocol boundaries.
· 3 min read
-
Advanced TopicsTailVNC embeds WireGuard and VNC in a single Go binary — here is how
TailVNC bundles a WireGuard peer and RFB server into one Go binary. Here's what makes the Go engineering interesting.
· 8 min read
-
Advanced TopicsQuien: A Go-powered WHOIS alternative that does way more than WHOIS
Quien is a Go CLI that combines WHOIS, DNS, RDAP, TLS, DMARC, SPF, DKIM, BGP, and more into one tool. Here's how it works under the hood.
· 7 min read
-
Advanced TopicsBuilding Behavior Trees in Go with go-bt
How go-bt models behavior trees with generic commands, explicit context, composite nodes, and small leaf actions.
· 2 min read
-
Advanced TopicsGecit: How a Go tool bypasses DPI censorship with eBPF and TUN interfaces
Gecit fragments TCP packets to slip past DPI censorship — using eBPF on Linux and TUN on macOS/Windows. Here's how it works under the hood.
· 7 min read
-
Advanced TopicsStart WebRTC in the browser, run it somewhere else — with Go
How pion/handoff negotiates WebRTC in the browser then moves the live connection to a remote server, and what the Go code actually looks like.
· 6 min read
-
Advanced TopicsBuild an AI Wiki from Your Notes with Go and sage-wiki
sage-wiki turns your messy research pile into a structured wiki using LLMs. Here's how the Go code works.
· 8 min read
-
Advanced TopicsA spreadsheet in your terminal, written in Go
Sheets is a terminal spreadsheet built with Go and Bubble Tea. Here's how it works and what Go patterns it uses.
· 6 min read
-
Advanced TopicsTracing Goroutines in Realtime with eBPF
How to use eBPF uprobes to watch goroutine creation, scheduling, and blocking in live Go programs — no code changes required.
· 8 min read
-
Getting StartedLearn Go by Building Things, Not Reading About Them
The Go Engineer repo teaches Go through actual projects — concurrency, design patterns, data structures — not another TODO app tutorial.
· 7 min read
-
Advanced TopicsCompozy: an AI development workflow tool written in Go
Compozy is a Go CLI and daemon for AI-assisted development workflows. The useful lessons are ACP runtimes, markdown artifacts, daemon state, reviews, and extensions.
· 3 min read
-
Advanced TopicsBuilding a Figma MCP Server in Go
How figma-mcp-go uses Go to give AI agents full read/write access to Figma designs through the MCP protocol — and why the architecture is worth studying even if you don't care about Figma.
· 8 min read
-
Advanced TopicsBuilding a Customer Service Quality Agent in Go with AI
A Go project that uses AI agents to score chat quality on Facebook Messenger and Zalo — and the patterns worth borrowing.
· 8 min read
-
Advanced TopicsCut your p99 latency in Go with hedged requests
How hedge wraps http.RoundTripper and gRPC unary calls to make adaptive hedged requests based on per-host latency sketches.
· 3 min read
-
Advanced TopicsBuilding a WeChat Bot Platform in Go: How Openilink Hub Does It
A look at how Openilink Hub uses Go for self-hosted WeChat bot management — WebSockets, webhooks, retry logic, and AI auto-reply.
· 6 min read
-
Advanced TopicsBuilding WebAssembly Modules in Go for Real Performance Gains
How to compile Go to WebAssembly, shrink those bloated binaries, and actually call Go functions from the browser without losing your mind.
· 7 min read
-
Best PracticesStop shipping Go binaries by hand – use GoReleaser
GoReleaser automates building, packaging, and publishing Go modules. Here's how to set it up and what Go patterns make it work.
· 7 min read
-
Advanced TopicsStop Committing YAML Blindly: Debug GitHub Actions Locally with Go
ci-debugger lets you set breakpoints in GitHub Actions workflows and debug them locally with Docker. Here's how it works under the hood.
· 7 min read
-
Advanced TopicsBuild a Terminal Screensaver in Go with Drift
Drift is a Go terminal screensaver that uses tcell, braille character rendering, and goroutines for idle-triggered animations. Here's what makes the code interesting.
· 7 min read
-
Advanced TopicsHow Prometheus uses Go to build a time-series database
Prometheus is written in Go. Here's how it uses Go's concurrency, interfaces, and standard library to power monitoring at scale.
· 8 min read
-
Getting StartedLearning Go in 2026; From Beginner to Senior
We all learn differently and at different paces. Finding content that is right for us is challenging. Below is my attempt to curate all the great content I have come across over the years into one place to hopefully help folks advance their Golang journey to the next step.
· 13 min read
-
Advanced TopicsGitea is written in Go — here's what you can learn from its codebase
Gitea is a self-hosted Git server written in Go. Let's look at how it uses Go patterns for routing, middleware, and package registries.
· 6 min read
-
Advanced TopicsRclone is written in Go — here is what you can learn from it
Rclone syncs files to about 70 cloud backends from a single Go codebase. Here's what its source can teach you about interface design.
· 7 min read
-
Advanced TopicsGo Ethereum: How Geth Uses Go to Power the Ethereum Network
How Go Ethereum (geth) uses Go's concurrency, networking, and interfaces to implement the Ethereum protocol.
· 8 min read
-
Advanced TopicsPocketBase is written in Go — and you can use it as a framework
PocketBase is a Go backend with auth, realtime, and SQLite. Here's how to use it as a Go framework, not just a standalone binary.
· 7 min read
-
Advanced TopicsRunning Go apps on Unikraft Cloud: Unikernels for Go developers
Go's static binaries are a natural fit for unikernels. Here's how to get a Go service running on Unikraft Cloud, and where the sharp edges are.
· 6 min read
-
EditorialMemos: the self-hosted note-taking app written in Go
Memos is a lightweight, self-hosted note-taking tool built with Go and React. Here's why it matters and how it works under the hood.
· 6 min read
-
Advanced TopicsAWS nested virtualization is here - what it means for Go developers
AWS finally supports nested VMs on EC2. Here's why Go devs should care and how to use it.
· 4 min read
-
Advanced TopicsWhy MinIO chose Go for S3-compatible storage at scale
S3-compatible object storage you can run anywhere, written in Go. A look at why the language fits the job.
· 4 min read
-
Advanced TopicsThe distributed key-value store that powers Kubernetes
Every piece of Kubernetes cluster state lives in etcd. Here's how to use this Go-powered key-value store, and what it teaches about distributed systems.
· 4 min read
-
Advanced TopicsTraefik: The reverse proxy that makes Kubernetes ingress simple
Traefik watches your infrastructure and routes traffic for you. Here's why that beats hand-editing nginx configs for Go microservices.
· 4 min read
-
Getting StartedAwesome Go: The Go resource list you need to bookmark
A practical tour of awesome-go: what the curated Go list actually contains and how I use it when starting a new project.
· 4 min read
-
Getting StartedLazygit: The terminal UI that makes git actually usable
Lazygit is a Go-powered terminal UI for git. It makes complex git operations simple and visual.
· 4 min read
-
Advanced TopicsDid you know you can run your own Base node with Go?
Coinbase's Base L2 runs on Go. Here's how to run your own node and what it teaches you about Go infrastructure.
· 3 min read
-
Getting StartedGin: The Go framework that makes APIs feel effortless
Why Gin is the Go framework most people reach for, what it does well, and the pitfalls to avoid when building APIs with it.
· 4 min read
-
Getting StartedThe CLI tool every developer should know: fzf
fzf is a fast fuzzy finder written in Go. Here's how to wire it into your shell, your Git workflow, and your editor.
· 4 min read
-
Advanced TopicsWhy Caddy might be the fastest Go web server you can run
Automatic HTTPS was why I tried Caddy. The performance is why I stayed. Here's what's going on under the hood.
· 3 min read
-
Advanced TopicsDid you know Docker is actually built on Moby?
Moby is the open-source project behind Docker containers. Here's what Go developers should know about it.
· 3 min read
-
Advanced TopicsWhy frp is the reverse proxy you should know about
Expose local servers through NAT and firewalls with frp, a self-hosted reverse proxy written in Go.
· 4 min read
-
Advanced TopicsSyncthing: The P2P file sync tool written in Go
Syncthing syncs files between your devices with no cloud in the middle. It's open source, peer-to-peer, and around 200,000 lines of well-written Go.
· 8 min read
-
Getting StartedHugo: A Go-powered static site generator worth knowing
Hugo is the world's fastest static site generator. Here's why it's built in Go and how to test your Hugo themes.
· 4 min read
-
Advanced TopicsExploring Kubernetes: A Go Library Worth Knowing
Kubernetes isn't just a deployment target. Here's how to program against it with the client-go library.
· 3 min read
-
Advanced TopicsExploring the Go Repository: Understanding How Go Is Built
What's actually inside the official Go repository, how to build Go from source, and how to make your first contribution.
· 3 min read
-
Advanced TopicsThe Best Way to Learn Go? Read the Source Code
A tour of the golang/go repository: how it's laid out, what to read first, and why it will make you a better Go developer.
· 4 min read
-
Getting StartedExploring Ollama: Running LLMs Locally with Go
How to run DeepSeek, Gemma 3, Llama 3 and other LLMs on your own machine with Ollama and its official Go client library.
· 5 min read
-
Best PracticesMastering Enums in Go: Best Practices and Implementation Patterns
Go doesn't have traditional enums, but we can implement powerful enum-like patterns. Learn how to create robust, type-safe enumerations in Go.
· 6 min read
-
SecurityUnderstanding SBOM in Go: Why It Matters and How to Generate One
A deep dive into Software Bill of Materials (SBOM), its importance in Go projects, and how to generate one using CycloneDX.
· 2 min read
-
AIBuilding Model Context Protocol Servers in Go: Enhancing AI Tools with Your Data
Learn how to build MCP servers in Go to connect your private data sources to AI tools like Cursor for more powerful coding experiences.
· 9 min read
-
Best PracticesBuilding Native Desktop Apps with Go and Wails: A Quick Dive
Did you know you can build native desktop applications with Go? See how here!
· 4 min read
-
Getting StartedFilter a slice in Golang
Slices are a cornerstone of Go programming, offering a flexible way to work with sequences of data. One common task is filtering a slice—selecting elements that meet specific criteria. Let's see how to do that
· 4 min read
-
Advanced TopicsThe Go Scheduler: How I Learned to Love Concurrency in 2025
If you’ve wondered how Go manages thousands of goroutines while other languages struggle with threads, this post is for you.
· 5 min read
-
EditorialBest Golang books available on Amazon
Looking for the best Golang resources on Amazon? Discover the top-rated books, learn why Go is so popular, and find exactly what you need to master this powerful programming language.
· 7 min read
-
Getting StartedA Simple Guide to Switch Statements in Go
Do you ever get tired of writing multiple `if-else` statements in your Go code? **Golang case** statements (also known as switch statements) can make your logic clearer, faster, and easier to maintain. In this post, I'll walk you through how to use a switch statement in Go to simplify your code.
· 3 min read
-
Advanced TopicsA round up of Go 1.24's performance improvements
Go 1.24 boasts improvements for everyone, without doing anything. Let's see how.
· 3 min read
-
Advanced TopicsTesting Concurrent Code Using the Experimental 'testing/synctest' Package
Concurrent code is notoriously difficult to test. Let's see how the new version of Go helps us here.
· 2 min read
-
Advanced TopicsIntroducing weak pointers in Go 1.24
Weak pointers can make certain classes of program much faster. Let's see how.
· 3 min read
-
Best PracticesGo 1.24's New Benchmark Function; a better way to benchmark
An in-depth look at Go 1.24's new testing.B.Loop method for writing better benchmarks
· 2 min read
-
Advanced TopicsMaps are faster in Go 1.24
...at least for most use cases. Read on to find out more!
· 4 min read
-
Best Practicesomitzero in Go1.24: tips and gotchas!
Go 1.24 is going to make working with JSON much better. Let's see how.
· 3 min read
-
CLIUnderstanding the New JSON Output in ‘go build’ and ‘go test’ Commands in Go 1.24
Because machine-parsable output is always welcome.
· 3 min read
-
Best PracticesHow to Use the New tool Directive in Go 1.24
managing tools has always been challenging in Go. The Go 1.24 release makes it much simpler. Let's see why.
· 2 min read
-
Advanced TopicsExploring Generic Type Aliases in Go 1.24
Go 1.24 introduces generic type aliases, enabling you to define type aliases with their own type parameters. This change allows more flexible and maintainable code, especially during refactoring.
· 2 min read
-
Editorial10 years of functional options and key lessons Learned along the way
Functional options are a powerful Golang pattern that can be used to write small and flexible APIs. Here's some Lessons Andrea learnt the hard way of how and when to use them.
· 13 min read
-
Getting StartedCommon Goroutine Leaks in Go and How to Avoid Them
Learn to identify, prevent, and fix goroutine leaks in Go applications. Understand common patterns that cause leaks and best practices for writing leak-free concurrent code.
· 5 min read
-
Getting StartedError Handling Best Practices in Go
Learn how to handle errors effectively in Go with best practices, custom error types, error wrapping, and practical patterns for production code.
· 4 min read
-
EditorialAOC 2024, Day 25: Locks, Keys and Stars!
Let's solve the last day of Advent of Code 2025 and collect all 50 stars!
· 3 min read
-
EditorialAOC 2024, Day 24: Ripple Carry Adder
Let's solve Advent of Code 2024 Day 24 by fixing a faulty Ripple Carry Adder!
· 8 min read
-
EditorialAOC 2024, Day 23: Bron–Kerbosch Algorithm
Let's solve Advent of Code 2024 Day 23 with Bron–Kerbosch Algorithm!
· 3 min read
-
EditorialAOC 2024, Day 22: Maximum Bananas
Let's solve Advent of Code 2024 Day 22!
· 5 min read
-
EditorialAOC 2024, Day 21: Keypad Madness
Let's solve Advent of Code 2024 Day 21, a very tough puzzle indeed!
· 8 min read
-
EditorialAOC 2024, Day 20: Manhattan Distance to the Rescue
Let's solve Advent of Code 2024 Day 20 using Manhattan Distance!
· 5 min read
-
EditorialAOC 2024, Day 19: Designing Towels
Let's solve Advent of Code 2024 Day 19 with recursion!
· 4 min read
-
EditorialAOC 2024, Day 18: Falling Walls
Let's solve Advent of Code 2024 Day 18 with Dijksta's Algorithm!
· 3 min read
-
EditorialAOC 2024, Day 17: Implementing a Quine
Let's solve Advent of Code 2024 Day 17 and learn about Quine!
· 6 min read
-
EditorialAOC 2024, Day 16: Fun with Dijkstra
Let's solve Advent of Code 2024 Day 16 with Dijkstra algorithm!
· 4 min read
-
EditorialAOC 2024, Day 15: Moving Boxes
Let's solve Advent of Code 2024 Day 15 by moving boxes in a 2D grid!
· 8 min read
-
EditorialAOC 2024, Day 14: Christmas Tree Hunt
Let's solve Advent of Code 2024 Day 14 and learn about image entropy!
· 5 min read
-
EditorialAOC 2024, Day 13: Solving Linear Equations
Let's solve Advent of Code 2024 Day 13 with highschool maths!
· 4 min read
-
EditorialAOC 2024, Day 12: Counting Corners
Let's solve Advent of Code 2024 Day 12 with some polygon math!
· 7 min read
-
EditorialAOC 2024, Day 11: Memoisation FTW
Let's solve Advent of Code 2024 Day 11 with memoisation!
· 4 min read
-
EditorialAOC 2024, Day 10: Part 2 easier than part 1?
Let's solve Advent of Code 2024 Day 10!
· 4 min read
-
EditorialDeploying gRPC Applications Using Sevalla
If you have spent any time in the Javascript ecosystem, you will have found you can often deploy entire apps just by pushing to GitHub. Go is fairly easy to deploy generally, but it is still not quite as simple as that...until now.
· 5 min read
-
EditorialAOC 2024, Day 9: Bonus Heaps!
Let's solve Advent of Code 2024 Day 9 and then optimise it with heaps!
· 8 min read
-
EditorialAOC 2024, Day 8: Reading Comprehension
Let's solve Advent of Code 2024 Day 8, but first let's understand the problem correctly!
· 4 min read
-
EditorialAOC 2024, Day 7: Recursion to the Rescue
Let's solve Advent of Code 2024 Day 7 with recursion!
· 4 min read
-
EditorialAOC 2024, Day 6: Escaping & Adding Obstacles
Let's find the path for the guard to solve Advent of Code 2024 Day 6!
· 6 min read
-
EditorialAOC 2024, Day 5: Custom Sort
Let's solve Advent of Code 2024 Day 5 and use Golang's custom sort!
· 6 min read
-
EditorialAOC 2024, Day 4: Find the X
Let's solve a couple of word puzzles with Advent of Code 2024 Day 4!
· 3 min read
-
EditorialAOC 2024, Day 3: All About Regex
Let's solve Advent of Code 2024 Day 3 with regex!
· 4 min read
-
EditorialAOC 2024, Day 2: Slice Internals Reminder
Let's solve Advent of Code 2024 Day 2 and revisit slice internals!
· 5 min read
-
EditorialAOC 2024, Day 1: Missing abs() for integers
Let's solve Advent of Code 2024 Day 1 and investigate about the missing function to calculate absolute for integers!
· 5 min read
-
Getting StartedMastering String formatting in Go
Formatting strings is a fundamental aspect of programming, and Go provides an easy way to do this via the `fmt` package. Whether you're constructing user-facing messages, logging debug information, or building complex output for APIs, understanding string formatting in Go is crucial.
· 3 min read
-
JSONJSON to Struct in Go: Decoding, Validation, and Common Mistakes
Decode JSON into Go structs safely with field tags, unknown-field checks, body limits, trailing-data validation, and useful error handling.
· 3 min read
-
Getting StartedConverting byte to string in Go
This is fundamental in Go, let's learn how to do it!
· 4 min read
-
EditorialThe Evolution of the Go Programming Language | A Comprehensive Overview
It’s no surprise that Go has become a favorite among developers. Let's learn why!
· 6 min read
-
gRPCgRPC use cases
Unlocking the Power of High-Performance Communication
· 6 min read
-
Getting StartedExplaining Go Interfaces | What They Are and Why They Matter
Interfaces are essential in Go for building testable systems. Let's see why
· 7 min read
-
gRPCEnhancing gRPC Security | Best Practices for Secure Communication in Microservices
Keeping gRPC services secure is essential. Lets learn how to do that
· 6 min read
-
gRPCgRPC Load Balancing | The Essential Guide to Scalability and Efficiency
In today’s world of distributed systems, handling large volumes of traffic without a hitch is crucial. Let's see how to do it with gRPC
· 6 min read
-
gRPCBoosting gRPC Performance | A Practical Guide for High-Throughput Applications
In the world of microservices, distributed systems, and real-time applications, performance can be the deciding factor between a successful system and one that struggles under load.
· 6 min read
-
Getting StartedGolang continue: Simplifying Your Loop Logic for Cleaner Code
When it comes to programming, loops are the backbone of repetition, data processing, and efficient workflows. In Go, loops are straightforward, yet powerful.
· 7 min read
-
gRPCUnderstanding gRPC Middleware: Enhance Your gRPC Applications
gRPC middleware is essential to keeping your code DRY and secure, lets see how.
· 4 min read
-
Getting StartedGetting Started with Go: Write Your First Hello World Program in Go
Writing Hello World is a rite of passage for all programmers. Let's see how to do it in Go!
· 6 min read
-
REST APIBuild a REST API in Go with net/http
Build a small production-minded Go REST API with method-aware routes, JSON validation, server timeouts, tests, and graceful shutdown.
· 4 min read
-
gRPCHow to Use gRPC Effectively: Best Practices You Should Follow
Efficient communication between services is crucial, especially when building distributed systems. let's learn why!
· 7 min read
-
gRPCUnderstanding gRPC vs. HTTP: Key Differences and Use Cases
Selecting the appropriate communication protocol is essential for today’s application development.
· 5 min read
-
Getting StartedGo certificates, courses, and learning paths: what actually matters
There is no official Go certification from the Go project. Here is how to think about course certificates, portfolios, and practical proof of Go skill.
· 3 min read
-
Best PracticesMastering gRPC Error Handling: Best Practices and Key Strategies
As microservices architecture becomes the backbone of modern development, gRPC has emerged as a powerful tool for building high-performance, scalable services. Learn more!
· 5 min read
-
Getting StartedRead & Write CSV Files in Go: The encoding/csv Guide
A practical guide to Go's csv.Reader and csv.Writer: read files line by line, handle headers and custom delimiters, map rows to structs, and avoid common errors.
· 4 min read
-
Getting StartedGo Type Alias vs Type Definition: What's the Difference?
type A = B and type A B do very different things in Go. Learn what a type alias is, how it differs from a type definition, and exactly when to use each.
· 6 min read
-
Getting StartedThe magic of the internal folder
The internal folder in Go is one of the few "magic" features in the Go language where if you use it, you get a bunch of benefit without having to do too much.
· 2 min read
-
Getting StartedGo flag Package: Parse Command-Line Arguments in Golang
Parse command-line flags and arguments in Go using only the standard library: string, int and bool flags, custom types, subcommands, and usage messages.
· 2 min read
-
Getting StartedReading Files Efficiently in Go
When working with file operations in Go, you should consider reading files line by line. This is especially useful when dealing with large files where loading the entire file into memory would be a bad idea.
· 2 min read
-
Advanced TopicsSecuring gRPC Services with JWT Authentication in Go
gRPC provides several mechanisms to enhance the security of your services. In this blog post, we'll explore how to implement authentication in gRPC, focusing on interceptors, metadata, and JWTs (JSON Web Tokens) as the authentication mechanism.
· 9 min read
-
Getting Startedgo:embed Explained: Embed Files & Directories in Go Binaries
Learn Go's embed directive with real examples: embed single files, whole directories, and templates at compile time to ship one portable, self-contained binary.
· 3 min read
-
Advanced TopicsImplementing Sets in Golang
A set is a collection of distinct elements that allows you to easily check for membership, add elements, and remove them without worrying about duplicates. While Go doesn’t have a built-in set type like Python or other languages, we can implement one using Go's map type.
· 3 min read
-
Getting StartedInterfaces in Go
Interfaces are one of the most powerful features in Go, but they can be confusing at first given their implicit nature.
· 5 min read
-
ContextContext in Go: Cancellation, Timeouts, and Values
Learn how Go context handles cancellation, deadlines, and request-scoped values without leaking goroutines or hiding dependencies.
· 3 min read
-
Getting StartedGo time Package Explained: Format, Parse & Compare Time in Golang
Everything you need to work with time in Go: time.Time, formatting with reference dates, parsing, timezones, durations, and how to write testable time-based code.
· 5 min read
-
Getting StartedHow to defer in Golang like a pro
The defer keyword in Go offers a way to ensure that resources are properly released and that certain actions are performed, no matter how a function exits.
· 3 min read
-
Getting StartedWhy You Should Think Twice Before Using the init Function in Go
The init function in Go is a powerful feature that allows developers to perform initialization tasks before the program starts executing. While it might seem convenient, relying heavily on the init function can lead to code that’s difficult to understand and maintain (and may not work how you want).
· 4 min read
-
Getting StartedLet's Map This Out
one of the most powerful and flexible data structures is the map. Whether you’re a experienced developer or new to Go, understanding how to effectively use maps can enhance the efficiency and clarity of your code.
· 3 min read
-
GenericsGenerics in Go: Type Parameters, Constraints, and Practical Patterns
Learn Go generics with compiling examples covering constraints, type inference, comparable values, generic data structures, and common mistakes.
· 3 min read
-
Getting StartedExploring the Golang Playground: A Go Developer’s Essential Tool
The Golang Playground is an amazing resource for developers working with Go (or Golang). Whether you’re new to Go or an experienced programmer, this browser-based tool allows you to write, share, and run Go code quickly without needing to set up a local development environment.
· 3 min read
-
Getting StartedInstalling Go: Let's get Started!
Learn how to install Golang (Go) on Windows, macOS, and Linux. This beginner-friendly guide walks you through each step to get started with Golang quickly.
· 3 min read
-
Getting StartedWhat is a switch Statement in Golang?
When programming in Go (or any language for that matter), decision-making is a core part of building applications. Let's see how to do that in Go.
· 4 min read
-
Getting StartedConvert Int to String in Go: strconv.Itoa, Sprintf & FormatInt
The three correct ways to convert an int to a string in Go — strconv.Itoa, fmt.Sprintf, and strconv.FormatInt — with examples and the pitfall of string(n) explained.
· 2 min read
-
Getting StartedUnderstanding Enums in Golang
Enums (short for enumerations) are a useful feature in many programming languages, allowing developers to define a set of named constants that represent unique values.
· 2 min read
-
gRPCgRPC vs REST
At some point in a growing company, the debate between gRPC and REST becomes a focal point. Both technologies allow communication between distributed systems, yet they differ significantly in their design, functionality, and use cases.
· 7 min read
-
Getting StartedEverything You Need to Know About for Loops in Go
For Loops are useful in any language, let's see how they work in Go.
· 4 min read
-
Getting StartedEverything you need to know about rubber-duck debugging for Go
As a Go developer, have you ever found yourself stuck on a bug for hours, only to have that “aha” moment when explaining the problem to someone else? This problem isn’t new, and it’s at the heart of what we call Rubber Duck Debugging.
· 4 min read
-
Getting StartedHot Reload for Golang with Go Air
Hot Reload to make developing Go fast!
· 3 min read
-
gRPCWhat is gRPC Anyway?
Chances are you have heard people mention gRPC, but what really is it and what's it useful for?
· 4 min read
-
gRPCUsing Status Codes for gPRC
People are often used to REST status codes and have experience using them (even if they are still often abused), but status codes in gRPC work a little bit differently and do not follow the same numeric range as REST status codes. Let's see how they are used!
· 4 min read
-
gRPCWhy gRPC and Go are a Match Made in Heaven
Unless you have been living under a rock, chances are you have heard of gRPC. It's also rare to hear gRPC to be mentioned and not for Go to be.
· 2 min read
-
Getting StartedExploring the New Unique Package in Go 1.23
The Go programming language continues to get better all the time, bringing with it new features and improvements aimed at improving performance and developer productivity.
· 3 min read
-
Getting StartedExploring the New Features in Go 1.23: Iterators and Enhancements to the Slices & Maps Packages
In a previous post we introduced iterators, a new feature in the Go language added in Go 1.23. In this blog post, we will look into the enhancements made to the slices and maps packages. These changes are built on top of iterators, so would not be possible before this release.
· 4 min read
-
Getting StartedIterators in Go 1.23
The Go programming language, renowned for its simplicity and efficiency, has changed quite a bit in the last couple of versions, with generics being one of the bigger changes.
· 4 min read
-
Getting StartedGenerating A CLI Application with Cobra in Golang
In this blog, we are diving deep into the world of developing advanced command-line applications using the popular CLI framework, Cobra.
· 4 min read
-
Best PracticesWriting Idiomatic Go CLIs
How to structure small Go CLIs with the standard flag package, custom flag values, clear help output, and useful exit behaviour.
· 6 min read
-
CLIStructuring Go Code for CLI Applications
This article is a guide on the first steps of creating a new Go CLI application, beginning with some of the most popular ways to structure code
· 6 min read
-
Getting StartedSetting up the Go Debugger in GoLand
The debugger is one of Go's best features. Let's set it up in GoLand this time
· 2 min read
-
Getting StartedSetting up the Go Debugger in VSCode
The debugger is one of Go's best features. Let's set it up together
· 2 min read
-
LoggingEverything You Need to Know about Logging in Go
In this blog post, we'll dive into the world of logging and logging strategies for Go Engineers.
· 12 min read
-
EditorialWhich Environment Variable Libraries do Golang engineers Prefer?
I asked hundreds of Gophers what their favorite way to manage environment variables and configuration was for their Go projects.
· 2 min read
-
LoggingWhich log library should I use in Go?
I asked thousands of Gopher's what log library they used with Golang, and was really surprised by the results!
· 1 min read
-
EditorialYou should probably be using sqlc
Go being type safe is probably one of the biggest benefits that attracted you to the language. However if you ask any Go developer and they will tell you about some pain they experienced writing to SQL Databases.
· 2 min read
-
Getting StartedInterface Guards In Go
Here's a cool trick to force a compile-time check that a struct satisfies an interface in Go. We call it an interface guard.
· 1 min read
-
Getting StartedLearning Go in 2024; From Beginner to Senior
We all learn differently and at different paces. Finding content that is right for us is challenging. Below is my attempt to curate all the great content I have come across over the years into one place to hopefully help folks advance their Golang journey to the next step.
· 11 min read
-
Advanced TopicsGarbage Collection In Go
For most of us, garbage collection is something we have heard of but never need to pay attention to.However, one of the reasons golang is so efficient and easy to learn is due to its excellent GC.
· 1 min read
-
Best PracticesPair Program More
This is not a Go specific tip and applies to any programming language.
· 2 min read
-
EditorialHow I keep myself Alive using Golang
In this blog I explore how I use an incident management mindset to manage a complex medical condition. I hope you enjoy it!
· 19 min read
-
DebuggingWhy is Using the Debugger so Controversial?
It turns out using the debugger is somewhat controversial, who would have thought it?! Let's explore why
· 5 min read
-
EditorialOne Billion Rows Challenge in Golang
The One Billion Row Challenge (1BRC) is intended to be a fun exploration of how far modern Java can be pushed for aggregating one billion rows from a text file. But what happens if you do it in Go?
· 13 min read
-
Advanced TopicsMy favorite Go package: errGroup
errGroups are probably my favourite golang package, come and see why!
· 1 min read
-
EditorialA Little Experiment; Code Review with Jon Calhoun & Matt Boyle
Reviewing code and getting your code reviewed is a great way to learn. We have ran a little experiment and we need your feedback!
· 2 min read
-
Advanced TopicsAn overlooked Go Package: Single Flight
Singleflight is a really interesting package that 'provides a duplicate function call suppression mechanism.' It is rarely used but very powerful!
· 2 min read
-
Getting StartedEverything you need to know about Go 1.22
Go 1.22 was released on February 7th, 2024. It's a major release with some significant quality-of-life improvements over Go 1.21. Let's go through them!
· 2 min read
-
EditorialA Brief History of Dependency Management in Go
For those of you newer to Go, it might surprise you to know that go modules was not always part of the language. When Go launched in 2009, it did not have any dependency management solution as Google had no need for one.
· 2 min read
-
Getting StartedContext Should Probably be the First Argument of your Go Functions
In golang, the context package plays a big role in controlling the lifecycle of your code, especially when it comes to handling timeouts, cancellation signals, and passing request-scoped values.
· 1 min read
-
ObservabilityGetting Started with Tracing & Open-Telemetry Locally Using Go
Whilst working on the Debugging course, I needed to get tracing & open-telemetry working in docker-compose. Here is how you can do it too!
· 1 min read
-
gRPCgRPC & Go
You have probably heard of gRPC if you haven't used it. It is particularly popular for inter-service communication due to its efficiency, language agnostic nature and support out of the box for things like MTLS. Here's a really simple example of how you can get started with gRPC and hopefully highlights some of the benefits.
· 2 min read
-
Best PracticesThe Functional Options Pattern in Go
The functional options pattern in Go offers a flexible and readable way to configure your structs without exposing internal fields.
· 1 min read
-
Best PracticesHow to build a production Docker Image for Go
In this post we'll explore how to make a production ready container image using Go.
· 2 min read
-
Advanced TopicsEnsuring the Go Tool Chain is Verifiable and Reproducible
In Go 1.21, truly reproducible builds were added to Go. Read this blog post to understand why that is important and you should care.
· 1 min read
-
Getting StartedRead More Go Code!
People often give the advice that the best way to get better at any programming language is to write more programs. This is true at the start, but as you begin to get more comfortable with the language, the best way to improve is to read lots of other peoples code too.
· 1 min read