Go Programming Language The Addison Wesley Professional Computing

Getting Started with Go: A Practical Guide

If you're looking to learn Go, the Addison-Wesley book by Alan Donovan and Brian Kernighan is one of the few resources that actually works. I picked it up around 2016 when I was trying to figure out why my Go projects kept having initialization issues. Most tutorials skip the parts that actually matter once you hit production code. The book isn't flashy. It doesn't try to impress you with dramatic success stories about how Go saved some company millions. It just walks through the language methodically, starting with the basics and getting progressively more useful. The chapter on interfaces alone is worth the purchase price, but you have to actually read it rather than skimming.

Go Programming Language The Addison Wesley Professional Computing

Here's what the book covers and how it lines up with real-world usage. You'll start with variables, types, and functions. That's standard stuff, but the explanations are tight. Then you move into structs and methods, which is where things start getting interesting. Go doesn't have classes, and the book doesn't waste time pretending it does. It explains why the language is built the way it is instead. The concurrency section comes next. This is where most people either love Go or walk away completely frustrated. The book handles channels and goroutines properly, showing you not just the syntax but the patterns that actually work in practice. I remember spending a weekend debugging a deadlock that came from a goroutine leaking because I forgot to close a channel in an error path. The book's examples don't make that mistake, which is itself a point in its favor.

How to Actually Use This Book

Don't just read it. Run the examples. The repository at github.com/gopl.io has all of them, and they still compile on current Go versions. If you're following along and something breaks, check the repo first before assuming the book is outdated. The code is maintained separately and updated more frequently than the printed pages. I'd recommend working through it in order. There are exercises at the end of chapters, and they're not filler. The one about implementing a union-find data structure taught me more about Go's type system than anything else I'd read. Skip those and you'll miss half the value.

What the Book Doesn't Cover Well

For all its strengths, it's not a complete reference. It barely touches on generic types since those didn't exist when it was written. If you're working with Go 1.18 or later, you'll need supplementary material for generics. The official Go blog and the spec page fill this gap reasonably well. It also doesn't cover testing patterns in depth the way you'd need for a professional environment. The book shows basic testing, which is fine for learning the syntax, but when I was building services that needed proper test coverage, I had to look elsewhere for mocking strategies and table-driven test conventions. The go-testing wiki on GitHub and recent blog posts from the Go team cover what's missing. There's also minimal content on tooling beyond the basics. If you want to actually be productive in Go, you need to understand modules, profiling with pprof, and the race detector. The book mentions these in passing but doesn't give you the hands-on experience you'd get from working through real projects.

Where to Get It

The book is available on Amazon, from the publisher directly, and on most major book retailers. The online version at gopl.io is free to read, though the physical copy has nicer formatting for the code examples. If you're serious about learning Go, the physical copy makes sense. If you're just curious whether Go fits your needs, the free online version is sufficient. One thing I'd suggest: pair the book with actual project work. Reading about concurrency models won't stick until you've written code that deadlocks and then fixed it. The book gives you the foundation, but the foundation only matters if you build something on top of it.