-
How 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.
-
A 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.
-
Nox: 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.
-
A 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.
-
SpoofDB: 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.
-
Heimdall: 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.
-
Librarry: 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.
-
TokenCode 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.
-
How 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.
-
Konflate: 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.
-
How 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.
-
Baidu 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.
-
How 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.
-
Lagodev: 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.
-
SenPaiScanner: 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.
-
SubwayCLI: 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.
-
NovaRadar: 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.
-
EasySNI: 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.
-
CrossLink: 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.
-
Hermes: 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.
-
Go 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.
-
Go 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.
-
Leoflow: 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.
-
How 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.
-
go-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.
-
Finding 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.
-
Comview: 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.
-
NanotDB: 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.
-
How 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.
-
Gograph: 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.
-
Parsing 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.
-
How 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.
-
How fsnotify gives Go programs cross-platform file watching
fsnotify wraps inotify, kqueue, and ReadDirectoryChangesW behind one Go API. Here's how it works.
-
How 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.
-
NUMA-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.
-
GooseRelayVPN: 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.
-
Stash 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.
-
FlowDriver: 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.
-
Gova: 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.
-
Wave 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.
-
A 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.
-
CrabTrap: 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.
-
Za-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.
-
sni-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.
-
xnew: 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.
-
Xata: 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.
-
AList: 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.
-
TailVNC 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.
-
Quien: 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.
-
Building Behavior Trees in Go with go-bt
How go-bt models behavior trees with generic commands, explicit context, composite nodes, and small leaf actions.
-
Gecit: 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.
-
Start 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.
-
Build 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.
-
A 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.
-
Tracing 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.
-
Learn 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.
-
Compozy: 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.
-
Building 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.
-
Building 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.
-
Cut 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.
-
Building 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.
-
Building 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.
-
Stop 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.
-
Stop 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.
-
Build 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.
-
How 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.
-
Learning 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.
-
Gitea 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.
-
Rclone is written in Go — here is what you can learn from it
Rclone is a powerful cloud storage sync tool built in Go. Let's look at the Go patterns and interfaces that make it work.
-
Go 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.
-
PocketBase 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.
-
Running Go apps on Unikraft Cloud: Unikernels for Go developers
Deploy Go apps as unikernels on Unikraft Cloud. Learn how Go's static binaries make it a perfect fit for unikernel deployment.
-
Memos: 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.
-
AWS 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.
-
Why MinIO chose Go for S3-compatible storage at scale
MinIO delivers blazing fast object storage with S3 compatibility. Here's how Go makes it possible.
-
The distributed key-value store that powers Kubernetes
Etcd is the backbone of Kubernetes. Here's how this Go project handles distributed consensus.
-
Traefik: The reverse proxy that makes Kubernetes ingress simple
Learn how Traefik simplifies routing in Go microservices with automatic service discovery and Let's Encrypt integration.
-
Awesome Go: The Go resource list you need to bookmark
Discover awesome-go, the definitive curated list of Go libraries, frameworks, and tools for every Go developer.
-
Lazygit: 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.
-
The Ultimate Bookmark Every Go Developer Needs
Discover awesome-go, the community-curated list of Go libraries, frameworks, and tools you'll reference daily.
-
Did you know you can run your own Base node with Go?
Run your own Base L2 node using Go. Learn how base/node works and why Ethereum scaling chose Go.
-
Gin: The Go framework that makes APIs feel effortless
Learn why Gin is the most popular Go web framework and how to build fast, clean APIs with it.
-
The CLI tool every developer should know: fzf
fzf is a blazing fast fuzzy finder written in Go. Here's why it should be in your toolkit.
-
The only Go bookmark you actually need
Awesome Go is the ultimate curated list of Go libraries and tools. Here's how to use it effectively.
-
The fuzzy finder that changed how I use the terminal
fzf is a blazing-fast fuzzy finder written in Go. Here's how to use it.
-
Why Caddy might be the fastest Go web server you can run
Caddy delivers serious performance with automatic HTTPS and zero config. Here's how it works under the hood.
-
Did 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.
-
Why frp is the reverse proxy you should know about
Expose local servers through NAT and firewalls with frp - a blazing fast Go-powered reverse proxy.
-
Syncthing: The P2P file sync tool written in Go
Syncthing syncs files between devices without a cloud. It's open source, peer-to-peer, and built entirely in Go.
-
Hugo: 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.
-
Exploring Kubernetes: A Go Library Worth Knowing
Discover how Kubernetes uses Go and how you can interact with it programmatically using the client-go library.
-
Exploring the Go Repository: Understanding How Go Is Built
Dive into the official Go repository to understand how the language is built, contribute, and learn from world-class code.
-
The Best Way to Learn Go? Read the Source Code
Discover the Go programming language source code, its architecture, and what makes it worth exploring.
-
Exploring Ollama: Running LLMs Locally with Go
Learn how to use Ollama to run DeepSeek, Gemma 3, Llama 3, and other LLMs locally with Go's official client library.
-
Mastering 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.
-
Understanding 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.
-
Building 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.
-
Building Native Desktop Apps with Go and Wails: A Quick Dive
Did you know you can build native desktop applications with Go? See how here!
-
Filter 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
-
The 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.
-
Best 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.
-
A 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.
-
A round up of Go 1.24's performance improvements
Go 1.24 boasts improvements for everyone, without doing anything. Let's see how.
-
Testing 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.
-
Introducing weak pointers in Go 1.24
Weak pointers can make certain classes of program much faster. Let's see how.
-
Go 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
-
Maps are faster in Go 1.24
...at least for most use cases. Read on to find out more!
-
omitzero in Go1.24: tips and gotchas!
Go 1.24 is going to make working with JSON much better. Let's see how.
-
Understanding the New JSON Output in ‘go build’ and ‘go test’ Commands in Go 1.24
Because machine-parsable output is always welcome.
-
How 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.
-
Exploring 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.
-
10 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.
-
Common 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.
-
Error 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.
-
AOC 2024, Day 25: Locks, Keys and Stars!
Let's solve the last day of Advent of Code 2025 and collect all 50 stars!
-
AOC 2024, Day 24: Ripple Carry Adder
Let's solve Advent of Code 2024 Day 24 by fixing a faulty Ripple Carry Adder!
-
AOC 2024, Day 23: Bron–Kerbosch Algorithm
Let's solve Advent of Code 2024 Day 23 with Bron–Kerbosch Algorithm!
-
AOC 2024, Day 22: Maximum Bananas
Let's solve Advent of Code 2024 Day 22!
-
AOC 2024, Day 21: Keypad Madness
Let's solve Advent of Code 2024 Day 21, a very tough puzzle indeed!
-
AOC 2024, Day 20: Manhattan Distance to the Rescue
Let's solve Advent of Code 2024 Day 20 using Manhattan Distance!
-
AOC 2024, Day 19: Designing Towels
Let's solve Advent of Code 2024 Day 19 with recursion!
-
AOC 2024, Day 18: Falling Walls
Let's solve Advent of Code 2024 Day 18 with Dijksta's Algorithm!
-
AOC 2024, Day 17: Implementing a Quine
Let's solve Advent of Code 2024 Day 17 and learn about Quine!
-
AOC 2024, Day 16: Fun with Dijkstra
Let's solve Advent of Code 2024 Day 16 with Dijkstra algorithm!
-
AOC 2024, Day 15: Moving Boxes
Let's solve Advent of Code 2024 Day 15 by moving boxes in a 2D grid!
-
AOC 2024, Day 14: Christmas Tree Hunt
Let's solve Advent of Code 2024 Day 14 and learn about image entropy!
-
AOC 2024, Day 13: Solving Linear Equations
Let's solve Advent of Code 2024 Day 13 with highschool maths!
-
AOC 2024, Day 12: Counting Corners
Let's solve Advent of Code 2024 Day 12 with some polygon math!
-
AOC 2024, Day 11: Memoisation FTW
Let's solve Advent of Code 2024 Day 11 with memoisation!
-
AOC 2024, Day 10: Part 2 easier than part 1?
Let's solve Advent of Code 2024 Day 10!
-
Deploying 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.
-
AOC 2024, Day 9: Bonus Heaps!
Let's solve Advent of Code 2024 Day 9 and then optimise it with heaps!
-
AOC 2024, Day 8: Reading Comprehension
Let's solve Advent of Code 2024 Day 8, but first let's understand the problem correctly!
-
AOC 2024, Day 7: Recursion to the Rescue
Let's solve Advent of Code 2024 Day 7 with recursion!
-
AOC 2024, Day 6: Escaping & Adding Obstacles
Let's find the path for the guard to solve Advent of Code 2024 Day 6!
-
AOC 2024, Day 5: Custom Sort
Let's solve Advent of Code 2024 Day 5 and use Golang's custom sort!
-
AOC 2024, Day 4: Find the X
Let's solve a couple of word puzzles with Advent of Code 2024 Day 4!
-
AOC 2024, Day 3: All About Regex
Let's solve Advent of Code 2024 Day 3 with regex!
-
AOC 2024, Day 2: Slice Internals Reminder
Let's solve Advent of Code 2024 Day 2 and revisit slice internals!
-
AOC 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!
-
Mastering 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.
-
JSON 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.
-
Converting byte to string in Go
This is fundamental in Go, let's learn how to do it!
-
The 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!
-
gRPC use cases
Unlocking the Power of High-Performance Communication
-
Explaining Go Interfaces | What They Are and Why They Matter
Interfaces are essential in Go for building testable systems. Let's see why
-
Enhancing gRPC Security | Best Practices for Secure Communication in Microservices
Keeping gRPC services secure is essential. Lets learn how to do that
-
gRPC 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
-
Boosting 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.
-
Golang 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.
-
Understanding gRPC Middleware: Enhance Your gRPC Applications
gRPC middleware is essential to keeping your code DRY and secure, lets see how.
-
Getting 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!
-
Build 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.
-
How to Use gRPC Effectively: Best Practices You Should Follow
Efficient communication between services is crucial, especially when building distributed systems. let's learn why!
-
Understanding gRPC vs. HTTP: Key Differences and Use Cases
Selecting the appropriate communication protocol is essential for today’s application development.
-
Go 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.
-
Mastering 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!
-
Mastering CSV Handling in Go: A Comprehensive Guide to the Golang CSV Reader
When working with data in Go, CSV (Comma-Separated Values) files are among the most popular formats for storing and exchanging information. Go’s rapid development and the new features introduced in recent versions enhance its capabilities for handling various data formats.
-
Golang Type Alias: Simplifying Code and Enhancing Readability
let's learn what a type alias is, and when you might want to use it.
-
The 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.
-
A Comprehensive Guide to the Flag Package
Reading command line arguments is a common use case for both CLI and API applications - Go makes this very easy to do using just the standard library via the flag package. Let's see how.
-
Reading 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.
-
Securing 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.
-
Using Go Embed
The go:embed feature simplifies the inclusion of static assets in your Go applications. By embedding files and directories at compile time, you can create more portable and self-contained binaries.
-
Implementing 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.
-
Interfaces in Go
Interfaces are one of the most powerful features in Go, but they can be confusing at first given their implicit nature.
-
Context in Go: Cancellation, Timeouts, and Values
Learn how Go context handles cancellation, deadlines, and request-scoped values without leaking goroutines or hiding dependencies.
-
Working With Time in Golang
Time is one of the most challenging things to work with in any programming language. Go makes it as easy as possible. In this blog we'll teach you everything you need to know about working with time and how to write testable time-based code.
-
How 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.
-
Why 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).
-
Let'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.
-
Generics 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.
-
Exploring 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.
-
Installing 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.
-
What 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.
-
How to convert an int to string in Golang
Let's master the basics of Go
-
Understanding 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.
-
gRPC 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.
-
Everything You Need to Know About for Loops in Go
For Loops are useful in any language, let's see how they work in Go.
-
Everything 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.
-
Hot Reload for Golang with Go Air
Hot Reload to make developing Go fast!
-
What is gRPC Anyway?
Chances are you have heard people mention gRPC, but what really is it and what's it useful for?
-
Using 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!
-
Why 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.
-
Exploring 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.
-
Exploring 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.
-
Iterators 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.
-
Generating 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.
-
Writing Idiomatic Go CLIs
How to structure small Go CLIs with the standard flag package, custom flag values, clear help output, and useful exit behaviour.
-
Structuring 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
-
Setting up the Go Debugger in GoLand
The debugger is one of Go's best features. Let's set it up in GoLand this time
-
Setting up the Go Debugger in VSCode
The debugger is one of Go's best features. Let's set it up together
-
Everything 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.
-
Which 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.
-
Which 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!
-
You 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.
-
Interface 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.
-
Learning 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.
-
Garbage 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.
-
Pair Program More
This is not a Go specific tip and applies to any programming language.
-
How 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!
-
Why is Using the Debugger so Controversial?
It turns out using the debugger is somewhat controversial, who would have thought it?! Let's explore why
-
One 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?
-
My favorite Go package: errGroup
errGroups are probably my favourite golang package, come and see why!
-
A 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!
-
An 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!
-
Everything 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!
-
A 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.
-
Context 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.
-
Getting 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!
-
gRPC & 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.
-
The 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.
-
How to build a production Docker Image for Go
In this post we'll explore how to make a production ready container image using Go.
-
Ensuring 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.
-
Read 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.