Gopher Reading List 
Here is a reading list of blog posts about Go. It aspires to include only the most useful and relevant material that anyone writing Go should eventually read. By definition, the list is a work in progress.
Rather than being comprehensive, the list is a curated selection fixed at 200 entries.
Go is growing fast and so are the number of blog posts about it. If an interested reader knows of a great post not on this list, please open an issue with a link to the post. Not every blog post linked in an issue will make its way into the list. Nonetheless, the issue list (both open and closed) is a good source of additional reading material.
NOTE: Any new additions will need to replace something else on the list to keep it at a fixed length.
Start Here
- Why should you learn Go?
- An Intro to Go for non-Go developers
- How to Write Go Code
- A Tour of Go
- Frequently Asked Questions
- Go Koans
- Go by Example
Online Books
See Go Books for a longer list of books, both free and paid.
Beginner
Some basics
- Understand Go pointers in less than 800 words or your money back
- Channel Axioms
- Golang channels tutorial
- Understanding Go panic output
- Common Gotchas in Go
- 50 Shades of Go: Traps, Gotchas, and Common Mistakes for New Golang Devs
- Slices from the ground up
- 6 Tips for Using Strings in Go
- Go Defer Simplified with Practical Visuals
Worth reading, again and again
- Effective Go
- Visualizing Concurrency in Go
- Strings, bytes, runes and characters in Go
- Arrays, slices (and strings): The mechanics of 'append'
Organization and Style
- Practical Go: Real world advice for writing maintainable Go programs
- Less is exponentially more
- Go Proverbs
- Code Review Comments
- Idiomatic Go
- Error handling and Go
- Go's Error Handling is Elegant
- Working with Errors in Go 1.13
- When Should I Use One Liner if...else Statements in Go?
- Five Suggestions for Setting up a Go project
- The One with the Directory Structure and Manual Wiring
- Structuring Tests in Go
- Organizing Go Code
- The anatomy of a Go project
- Standard Package Layout
- Structuring Applications in Go
- Style guideline for Go packages
- Package names
- For Range Semantics
- How to use interfaces in Go
Web
- Creating My First Web Application with Go
- Making a RESTful JSON API in Go
- Serving Static Sites with Go
- An Intro To Templates in Go
- JSON APIs Are Just Web Applications
- Writing middleware in #golang and how Go makes it so much fun
- Go and JSON
- Learn Web Programming in Go by Examples
- Accessing data in Go
Concurrency
- Learning Go's Concurrency Through Illustrations
- Data races in Go(Golang) and how to fix them
- Go’s append is not always thread safe
- Golang channels tutorial
Go Modules
Intermediate
Code Design
- Go best practices, six years in
- Aspects of a good Go library
- Solid Go Design
- Go for Industrial Programming
- Failure is your Domain
- What “accept interfaces, return structs” means in Go
- How to Use Go Interfaces
- Pitfalls of context values and how to avoid or mitigate them in Go
- How to organize the go struct, in order to save memory
- How to ship production-grade Go
- Loose Coupling in Go lang
- Self-referential functions and the design of options
- Functional Options for Friendly APIs
- Functional Options on Steroids
- Object Oriented Inheritance in Go
- Error handling in Upspin
- Iterators in Go
Concurrency
- Concurrency Patterns
- Stopping goroutines
- Make Ctrl+C cancel the context.Context
- How to correctly use context.Context in Go 1.7
- Using contexts to avoid leaking goroutines
- Go Concurrency Patterns: Pipelines and cancellation
- Tutorial: Synchronizing State with Mutexes in Go
- Context and Cancellation of goroutines
- Dancing with Go's Mutexes
- GoRoutines, Channels, and Proper Exits
- Buffered channels in Go: Tips & Tricks
- How to Block Forever in Go
- Mutex Profile
- Sane Concurrency with Go
- Error handling patterns in Go
- Does the race detector catch all data races?
- Interesting ways of using Go channels
Testing
- Testing Web Apps in Go
- An Introduction to Testing in Go
- 5 simple tips and tricks for writing unit tests in #golang
- 5 Advanced Testing Techniques in Go
- Interfaces and Composition for Effective Unit Testing in Golang
- Go Testing Technique: Testing JSON HTTP Requests
- Acceptance Testing Go Web Applications with Cookies
- Testing Your (HTTP) Handlers in Go
- Go test your tests in Go with go test
- Learn Go with tests
- Lesser-Known Features of Go Test
- When Writing Unit Tests, Don’t Use Mocks
Web
- Go for Cloud
- Exposing Go on the Internet
- The complete guide to Go net/http timeouts
- HTTP(S) Proxy in Golang in less than 100 lines of code
- Write a Kubernetes-ready service from zero step-by-step
- A brief intro of TCP keep-alive in Go’s HTTP implementation
- Go JSON Cookbook
- Build a Web Crawler in Go
- Your pprof is showing: IPv4 scans reveal exposed net/http/pprof endpoints:
- HTTP Request Contexts & Go
- Using Object-Oriented Web Servers in Go
- Handle HTTP Request Errors in Go
- Go json.Decoder Considered Harmful
- Building High Performance APIs In Go Using gRPC And Protocol Buffers
- Don't use Go's default HTTP client (in production)
- Writing an API Client in Go
- Seeking around in an HTTP object
- Using Functions Inside Go Templates
- Writing a Data Mapper in Go without an ORM
- Practical Persistence in Go: Organising Database Access
- How I write Go HTTP services after seven years
- Make resilient Go net/http servers using timeouts, deadlines and context cancellation
Tools
- An Overview of Go's Tooling
- Go tooling essentials
- Profiling Go Programs
- Go Tooling in Action
- Using Go as a scripting language in Linux
- Statically compiling Go programs
Trivia
- 10 things you (probably) don't know about Go
- Gopher Puzzlers
- Advanced Go Tips And Tricks
- Golang slices gotcha
Diagnostics
- Diagnostics
- Profiling Go
- Five things that make Go fast
- Practical Go Benchmarks
- Debugging Go Applications using Delve
Language
- Golang: pass by pointer vs pass by value
- There is no pass-by-reference in Go
- Variadic functions in Go
- Function Types in Go (golang)
- research!rsc: Go Data Structures
- The Relationship Between Interfaces and Reflection
Miscellaneous
- Always Be Closing
- Don't defer Close() on writable files
- How to Use go:generate
- Writing worker queues, in Go
- Job Queues in Go - OpsDash
- Reading files in Go
- Vanity Go Import Paths
- Tags in Golang
Advanced
Low Level Concerns
- Go's work-stealing scheduler
- The Go scheduler
- Illustrated Tales of Go Runtime Scheduler
- Go Assembly by Example
- Address Alignments in Go
- Hacking the Scheduler
- Scheduling In Go - Part II
- Anatomy of a function call in Go
- Scheduler Tracing in Go
- unsafe.Pointer and system calls
- Type-Unsafe Pointers
- Looking at your program’s structure in Go 1.7
- Managing Syscall Overhead with crypto/rand
- Optimized abs() for int64 in Go
- Golang escape analysis
Performance
- Allocation Efficiency in High-Performance Go Services
- Handling 1 Million Requests per Minute with Go
- Go code refactoring : the 23x performance hunt
- A Million WebSockets and Go
- go-perfbook
- Simple techniques to optimise Go programs
- High Performance Go Workshop
Garbage Collection
- Avoiding high GC overhead with large heaps
- Golang's Real-time GC in Theory and Practice
- How to Optimize Garbage Collection in Go
- Go memory ballast: How I learned to stop worrying and love the heap
- Garbage Collection in Go
Concurrency
- Advanced Go Concurrency Patterns
- The X-Files: Avoiding Concurrency Boilerplate with golang.org/x/sync
- Golang lock-free values with atomic.Value
- Share Memory by Communicating
- Concurrency is not parallelism
- Go Concurrency Patterns: Context
- Go Concurrency Patterns: Timing out, moving on
- Concurrency, Goroutines and GOMAXPROCS
- Locking in crypto/rand
- Stateful locks in Go