Resources
Discover useful tools, tutorials, and helpful resources organized by category
Blog Dave Cheney
Dave Cheney's blog, subtitled The acme of foolishness, is a long-running collection of writing about the Go programming language. Posts range from deep dives into the compiler and runtime, such as how Go 1.16 changed heap allocation size classes and how diamond interface composition works in Go 1.14, to short pop quizzes about defer and pointer comparisons. The site also hosts two larger resources, Practical Go, a guide to writing maintainable Go programs, and the High Performance Go workshop on optimization. New posts are infrequent now, the latest being from late 2025, but the archive is still widely referenced. A valuable read for Go developers who want to understand why idiomatic Go looks the way it does.
Blog Filippo Valsorda
words.filippo.io is the blog of Filippo Valsorda, a cryptography engineer and open-source maintainer who works on Go's cryptography libraries through Geomys. He writes about cryptography, Go and the practice of maintaining open source. Go-specific posts include The 2025 Go Cryptography State of the Union, go.sum Is Not a Lockfile, Inspecting the Source of Go Modules and a proposal for a passkey API in Go. Other recent posts cover quantum computing timelines from a cryptography engineer's perspective, Turn Dependabot Off and Vulnerability Reports Are Not Special Anymore. Worth following for Go developers who care about security, dependencies and how the standard library's crypto packages evolve.
Book Let's Go Further
Let's Go Further is a book by Alex Edwards on advanced patterns for building APIs and web applications in Go, and the sequel to Let's Go. It guides the reader through the start-to-finish build of a JSON API, covering project structure, JSON requests and responses, SQL migrations, filtering, sorting and pagination, full-text search, rate limiting, background tasks, graceful shutdown, sending email, authentication and permission-based authorization, CORS, metrics and deployment to a live server. The book is written for Go 1.27, was last updated on October 3, 2026, and comes in HTML, PDF and ePUB formats with a free sample. It is a paid book. A good fit for developers who know Go basics and want a complete, current reference for production web services.
Tutorial Uber Go Style Guide
The Uber Go Style Guide documents the patterns and conventions used in Go code at Uber. It was originally created by Prashant Varanasi and Simon Newton to bring colleagues up to speed with Go and has been amended over the years based on feedback. The guide is organized into Guidelines, Performance, Style, Patterns and Linting, with concrete rules such as verifying interface compliance, using defer to clean up, handling errors once, avoiding mutable globals and not firing off goroutines without managing their lifetime. Most rules come with paired bad and good code examples. The repository is Apache-2.0 licensed and links to community translations. Handy for teams that want a ready-made baseline for Go code review.
Book Let's Go
Let's Go by Alex Edwards is a start-to-finish guide to building web applications with Go. The book walks through the build of a complete working application and covers best practices, project structure and practical code patterns. Topics include starting a server, creating handlers and routing requests, organizing a scalable project structure, managing dependencies with Go modules, handling configuration with command-line flags and dependency injection, and logging and error handling. The book is sold through the author's site, which offers a free sample. It suits developers who know some Go and want to build production-ready web applications.
Blog Eli Bendersky's website: Go
This is the Go section of Eli Bendersky's website, a blog that began in 2003 and is now mostly an outlet for technical, math and programming posts written in his free time. The Go articles include multi-part series such as Implementing Raft and Concurrent Servers, whose Go instalment appeared in August 2026, along with pieces on consistent hashing, Bloom filters, ranging over functions in Go 1.23, building static binaries on Linux and running Go in the browser with WebAssembly. There is also a run of posts on using LLMs from Go. It suits Go developers who like worked examples with complete, readable code.
Tutorial Learn Go with Tests
Learn Go with Tests teaches the Go language through test-driven development: each chapter introduces a language feature or concept by writing a failing test first and then the code to make it pass. It gives readers a grounding in TDD alongside Go fundamentals, in small, structured lessons that build toward writing robust, well-tested programs. The book is free, MIT-licensed and translated into more than ten languages. Ideal for developers learning Go who also want good testing habits from the start.
Book Go in Action
Go in Action is a practical, example-driven guide that takes an intermediate developer from the basics of the Go programming language through its idiomatic use in real applications, covering key concepts like the language’s syntax, type system, concurrency primitives, channels, and testing while showing how to build real-world software such as web services and network servers; it focuses on understanding how Go works under the hood and how to use its features effectively to write reliable, high-performance code.
Book The Complete Guide to Go Programming
“The Complete Guide to Go Programming” is a comprehensive introduction to the Go language that starts with its history and installation, then walks through core syntax (variables, types, control flow, functions, structs, interfaces, collections), practical error handling, and Go’s powerful concurrency model with goroutines and channels. It goes on to cover advanced topics such as reflection, generics, testing, performance profiling, and build tools, and includes practical examples and best practices to help readers move from beginner to proficient Go developers.
Blog Go Optimization Guide
GoPerf.dev is a Go Optimization Guide — a hands-on, technical resource for Go developers focused on writing high-performance, efficient applications by applying practical patterns and measurable techniques rather than guesswork. It organizes content into sections on common performance patterns (like memory management, concurrency, I/O optimization, and compiler tuning) and practical networking patterns (including benchmarking, high-throughput services, and protocol-level tuning). The guide emphasizes real-world examples, profiling, and performance-centric design for services that handle substantial load, making it especially useful for engineers building backend systems, latency-sensitive services, or high-throughput networked applications with Go.
Podcast Devtrovert
Hey mate! I'm Phuong, and here I turn complex low-level and also Go concepts into things you can actually see and feel.
Blog research!rsc
research!rsc is the personal technical blog of Russ Cox, a veteran programmer and contributor to the Go programming language, where he writes thoughtful essays and deep dives on programming, software tools, debugging, language design, testing, open-source issues, and related topics. The posts range from practical techniques like differential coverage debugging and Go testing tips to broader reflections on software dependencies, compiler behavior, telemetry, and historical insights, all aimed at helping developers think more clearly about software problems and systems design.
Book The Go Programming Language
The Go Programming Language (by Alan Donovan and Brian Kernighan, published by Addison-Wesley/O’Reilly online library) is regarded as the authoritative introduction to Go. Written by two highly respected computer scientists, it provides a clear and thorough exploration of Go’s syntax, concurrency model, standard library, and idiomatic practices. The book blends theory with practical examples, giving readers not just the mechanics of the language but also how to write clean, efficient, and maintainable Go code. It’s widely considered a must-read for anyone serious about mastering Go.
Tutorial Go by Example
Go by Example is an interactive online resource that teaches Go (Golang) through concise, runnable code examples. Each page walks you through a specific Go concept—like loops, slices, maps, channels, or interfaces—showing real code you can edit and run immediately in the browser. It’s especially great for learners who prefer “learning by doing” and want to see how Go’s features behave in practice rather than just reading theory.
Tutorial A Tour of Go
The Go Tour shows the organized set of lessons and modules available (such as basics, methods, concurrency, generics, etc.). It helps guide learners through Go’s core features step by step, from fundamentals like variables and loops, through slices, maps, interfaces, and concurrency, up to newer features like generics. It’s a well-structured roadmap for both newcomers and intermediate Go users to follow a coherent learning path.
Blog Destel
Destel is Viktor Nikolaiev’s personal tech blog focusing largely on Go (Golang), backend engineering, concurrency, and system design. The posts go deep into topics like preserving ordering in concurrent Go apps, real-time batching, timeout middleware, and performance optimizations, often with code examples, benchmarks, and real trade-off discussions. It’s a mix of thoughtful essays, practical tips, and explorations of side projects—ideal for engineers who like to peel back layers and see how things work under the hood.
Podcast Go Time
The Go Time podcast (hosted on Changelog) is a long-running show (340 episodes over 8 years) focused on discussing the Go programming language, tooling, practices, community, and ecosystem. Its episodes span from deep technical topics (e.g. execution traces, debugging, generics) to community discussion and broader software philosophy. In December 2024, the team announced that Go Time would retire its weekly production as part of a refocus on the main Changelog show, with plans for a spin-off podcast “Fallthrough” to carry forward Go-centric conversations.
Book Go 101
Go 101 is an unofficial but comprehensive knowledge base for learning Go (Golang), aimed at both beginners and experienced developers. It organizes content into well-structured “books” like Go (Fundamentals) 101, Go Generics 101, Go Optimizations 101, and Go Details & Tips 101, covering syntax, runtime internals, generics, performance, idiomatic tips, and more. The site even supports offline access via a local tool — you can install it (go install go101.org/go101@latest) and run the site on your machine. It’s a go-to resource for those who want to dive deep into Go beyond the basics, combining reference material, explanations, quizzes, and nuanced insights.
Tutorial Effective Go
Effective Go is a guide published by the Go team that shares practical advice for writing Go code that is clean, idiomatic, and efficient. It complements the Tour and the Go language specification by showing best practices around naming, formatting (via gofmt), error handling, use of interfaces, package structure, comments, and other stylistic conventions that help Go code be more readable and maintainable. It’s especially useful for those who already know Go basics and want to adopt the standard conventions used throughout Go’s ecosystem.
Blog Alex Edwards’ Blog
Alex Edwards’ blog is a well-crafted resource for Go developers, with posts that mix practical tutorials, opinion pieces, and deep dives into idiomatic Go code. Recent topics cover everything from test assertions minimalist style, configuration management, project and middleware structure, to handling panics properly in web applications. Each post tends to be clear, example-driven, and focused on helping go-developers write robust, maintainable, and well-architected software with minimal dependencies.
Blog The Ardan Labs Blog
The Ardan Labs Blog is a high-quality technical resource focused on Go, Rust, Kubernetes, and production software engineering practices. Posts are authored by experienced practitioners (notably Bill Kennedy and others at Ardan Labs) and dive into topics like garbage collection pacing in Go, error handling using interfaces, performance optimization, code design, language internals, and more. Readers will often find both conceptual discussions and practical examples, making it useful for developers who want to deepen their understanding of building reliable and efficient systems in Go (and related ecosystems).
Blog Miguel Young de la Sota’s site
mcyoung.xyz is the personal blog of Miguel Young de la Sota, who works in Google and writes in depth about compilers, performance, programming languages (especially Go and Rust), and quirky or “fun” topics in software.
Blog The Go Blog
The Go Blog keeps Go programmers updated on the language’s evolution, tools, and ecosystem through official posts by the Go team.
Blog Melatoni
Melatoni is a technical blog by nghiant3223, focused on software engineering topics, especially around Go and MySQL. Recent posts include deep dives like “Go Scheduler”, exploring how Go handles concurrent tasks; “Deadlock in MySQL”, which discusses causes and fixes; and “Prepared Statement in MySQL and Go”, showing how those two techs interact. The writing is practical and insightful, geared toward developers who want to understand internals and avoid pitfalls in real-world systems.
