The year on a Go book’s cover tells you less than one line in its companion code: the go directive in go.mod. That line decides how the compiler treats loop variables and which language features the code may use, so two good Go books printed a year apart can behave differently when you run their samples.
This list covers the seven best Go books for beginners and for developers who already write Go, from a first book through concurrency, cloud services and performance work. We pulled each edition from Amazon’s catalog and the publisher, then type-checked and vetted the companion code of five of them (for Go in Action, only its module chapters). Every run here used Go 1.27.2 as the tested build, with Go 1.21.13 alongside for one comparison, on a Fedora 45 VM and a Mac in October 2026, and you’ll find the results in the lab section near the end.
Pick a Go Book by Where You Are
Most readers need one book to learn the language and a second for the kind of Go you will write at work. Start from where you are now:
- Best first Go book: Learning Go, Second Edition
- Newest edition, for developers switching from another language: Go in Action, Second Edition
- Best second book: 100 Go Mistakes and How to Avoid Them
- Best for concurrency: Learn Concurrent Programming with Go
- Best for backend services: Cloud Native Go, Second Edition
- Best for performance work: Efficient Go
You will want a toolchain installed before the first chapter, because every one of these books expects you to type the examples and run them. We have install guides for Go on Ubuntu 26.04, Rocky Linux and AlmaLinux and Fedora, and each takes about five minutes.
How We Picked and Tested
We searched Amazon’s catalog by publisher (O’Reilly, Manning, No Starch Press, Packt, Addison-Wesley, Pragmatic Bookshelf and Apress) as well as by keyword, because a keyword search for Go books returns plenty of short self-published titles and books about the board game. Each pick had to be a print edition sold new on Amazon in October 2026. Contents come from the publisher’s page or the book’s companion repository on GitHub, and each repository’s go.mod told us which Go version the code was written against.
For the lab we cloned a Fedora 45 VM, installed Go 1.27.2 and Go 1.21.13 from the official tarballs, and ran every package in four companion repositories through go vet, which type-checks the code and runs the standard analyzers. We used vet rather than go build on purpose. Many book repos hold snippet packages that declare package main without a main function, and those fail at the link step even though the code is fine. We vetted Go in Action’s module chapters (6, 8, 9, 10 and 11) the same way afterwards, on a Mac with the same Go 1.27.2 toolchain. Its other chapters (1 to 5 and 7) are loose files meant for go run, with no module to vet. We did not build Mastering Go or Efficient Go, so their sections lean on the catalog and the repository metadata.
A few well-known titles did not make the list:
- The Go Programming Language (2015), whose Amazon buy box was a used copy from a third-party seller when we checked
- Concurrency in Go (2017), still a first edition and in short supply
- Head First Go (2019), written before generics
- Learning Go, Third Edition, listed for preorder with a June 2027 date
The Go Programming Language deserves a word, because it was the default recommendation for years and still explains the core language with real care. It predates generics and modules, though, and Amazon’s buy box went to a used copy from a third-party seller, with other sellers’ new and used copies listed behind it. It works better as a cheap second reference than as the book you learn from.
Compare the Seven Books
The Go version column comes from each companion repository’s go.mod, and it matters more than the publication date because it decides how the language behaves when you run the samples:
| Book | Publisher, print date (Amazon) | Code targets | Pages | Best for |
|---|---|---|---|---|
| Learning Go, 2nd Ed | O’Reilly, February 2024 | go 1.19 to 1.21 | 491 | Learning the language properly |
| Go in Action, 2nd Ed | Manning, September 2026 | go 1.22 to 1.25.4 | 384 | Experienced developers new to Go |
| 100 Go Mistakes and How to Avoid Them | Manning, October 2022 | go 1.18 | 384 | Fixing habits after a few months of Go |
| Learn Concurrent Programming with Go | Manning, January 2024 | go 1.19 | 328 | Goroutines, locks and channels |
| Cloud Native Go, 2nd Ed | O’Reilly, December 2024 | go 1.24.0 | 539 | Building backend services |
| Mastering Go, 4th Ed | Packt, March 2024 | go 1.20 to 1.22.0 | 736 | Breadth: CLIs, databases, networking |
| Efficient Go | O’Reilly, December 2022 | go 1.20 | 499 | Benchmarking and profiling |
1. Learning Go, Second Edition
Jon Bodner’s book is the one to learn Go from if you already program in another language. It teaches Go the way Go developers write it, not as Java with different keywords:
The second edition came out in February 2024 and its chapter repositories declare Go 1.19 to 1.21, so generics, modules and workspaces are all in it. We ran six of its chapter repos (90 packages, covering generics, modules, concurrency and context) through vet on Go 1.27.2. Seven packages failed to type-check, and every one was a deliberate example. Two are lines the source marks “compilation error!” or “compile-time error!”, two are the generics chapter’s examples of a type its constraint rejects and a value of the wrong type, and three are an import cycle the modules chapter builds so you can watch the compiler refuse it. Nothing had rotted.
Its weak spot is timing. The book went to print before range-over-func iterators arrived in Go 1.23 and well before Go 1.27 added generic methods, so you’ll pick both up from the release notes. Amazon also lists a third edition for June 2027; if you are buying now, the second edition is the current one. It sold for $40 to $50 when we checked. Check the current price on Amazon.
2. Go in Action, Second Edition
Amazon lists the paperback of this rewrite for September 29, 2026, which makes it the newest edition on this list. Joel Holmes and Andrew Walker wrote it with William Kennedy, a coauthor of the first edition:
According to Manning, generics, fuzz testing, benchmarking, the log/slog structured logging package, and modules with multi-module workspaces are first-class topics rather than footnotes. It is written for developers who already know another language, and it spends real time on application structure, using hexagonal (ports and adapters) design. Two appendices build an AI pipeline in Go: vector search with Qdrant, embeddings, and LLM summarization with Ollama and LangChain for Go.
Its code lives in Joel Holmes’s go-in-action-code repository, linked from Manning’s page, and its modules declare Go 1.22 up to 1.25.4. Chapters 6, 8, 9 and 10 passed vet cleanly on Go 1.27.2. Chapter 11, a two-module workspace, does not build as shipped, and we hit three separate faults one after another. Go 1.27.2 first rejects its go.work, which declares go 1.22 while the newsroom module asks for 1.22.0. Fix that line and the api module’s require on the newsroom module at v0.0.0 sends Go off to GitHub for a path that doesn’t exist. Drop that require and the compiler stops on an unused import of the feed package in summary_handler.go. Vetting newsroom on its own also gives four “fmt.Println arg list ends with redundant newline” warnings. At about $60 with no discount, it had the highest Amazon price of the seven when we checked. Buy it if you want the most recent edition and you care about structuring a whole application; pick Learning Go instead if you want the language explained more slowly. Check the current price on Amazon.
3. 100 Go Mistakes and How to Avoid Them
Teiva Harsanyi’s catalog of mistakes is the best second Go book. Read it once you have written Go for a few months, when its examples look like code you have actually shipped:
The mistakes are grouped from types and strings through error handling, concurrency, the standard library, testing and optimization, and each one comes with the idiomatic fix. All 126 packages in its repository type-checked cleanly on Go 1.27.2. Vet flagged five of them, and each is code the book shows on purpose, such as copying a struct that holds a sync.Mutex or calling WaitGroup.Add inside the goroutine it is meant to track. That is a good sign for the book: the toolchain now catches several of its lessons automatically, as the lab section shows.
The language has also moved under a few of its chapters. Mistake 63, goroutines capturing a loop variable, cannot happen in a module that declares Go 1.22 or newer, and the repository still declares Go 1.18, so the old behavior reproduces only because of that line. Treat those pages as history for new code and as a warning for older modules you maintain. It sold for $40 to $50 when we checked. Check the current price on Amazon.
4. Learn Concurrent Programming with Go
James Cutajar’s book teaches concurrency itself, using Go as the vehicle, so it goes further into locks and memory sharing than the concurrency chapters of a general book:
It covers mutexes, readers-writer locks, semaphores, message passing, pipelines and worker pools, then atomic variables and futexes. Manning pitches it at readers with basic Go or any other C-style language. Its repository declares Go 1.19 and is large: 144 packages, all of which type-checked on Go 1.27.2. Vet raised one warning eight times, “using resp before checking for errors”, because the listings that fetch web pages discard the error from http.Get and then defer resp.Body.Close(). That keeps the listings short. Copy them into real code, though, and a failed request panics on a nil response, so check the error first.
Amazon’s offer when we checked came from a third-party seller with new copies, at $40 to $45. If it is gone, Concurrency in Go is the older alternative on the same ground. Check the current price on Amazon.
5. Cloud Native Go, Second Edition
Matthew Titmus builds a backend service across the book, which suits readers who want to write the kind of software that runs in a Kubernetes cluster rather than study the language in isolation:
The companion code grows a key-value store chapter by chapter, with HTTP handlers on gorilla/mux, a transaction log, PostgreSQL through lib/pq, gRPC and a hexagonal layout. Its repository was updated in February 2026 and now declares Go 1.24.0. Of its 40 packages, 39 type-checked on Go 1.27.2. The odd one out holds two alternative versions of the same program in one directory, so both files declare main; build them one file at a time.
Plan for one problem when you run the tests. Eight test files across chapters 5 and 8 write the same file, /tmp/create-logger.txt, so a plain go test ./... runs them in parallel and a few fail at random, while the same packages pass when run one at a time. It sold for $40 to $50 when we checked. Check the current price on Amazon.
6. Mastering Go, Fourth Edition
Mihalis Tsoukalos covers more ground than any other book here, which is the reason to buy it and also the reason not to start with it:
Its 736 pages run from the language basics into command-line tools with Cobra and Viper, SQLite, structured logging with log/slog, semaphores, errgroup and message queues, judging by the chapter folders in its repository. Its 18 module files declare Go 1.20 to 1.22.0, most of them 1.21, so it is current up to about the same point as Learning Go. We did not build its code.
Each topic gets a working example and then the book moves on. It reads best as a reference you return to when a project needs a database driver or a CLI framework. As a first book it is too wide to give you a feel for idiomatic Go. It sold for $35 to $40 when we checked, well below its list price. Check the current price on Amazon.
7. Efficient Go
Bartłomiej Płotka’s book is about making Go programs faster and lighter with measurements rather than hunches, and it is the one to read once your service works but costs too much to run:
The examples repository is organized around profiling, memory, pools, leaks, metrics and compiler optimizations, and the author says every example is built and tested in CI, with tests and microbenchmarks beside most of the code. It declares Go 1.20, and the method it teaches (measure, change one thing, measure again) does not age with the compiler, even if some of the specific numbers will.
Don’t buy it to learn the language, because it assumes you already write Go comfortably. It was printed in December 2022 and sold for $35 to $40 when we checked. Check the current price on Amazon.
Run Book Code on a Current Go Release
Book code from 2022 to 2024 still compiles on Go 1.27.2, because Go’s compatibility promise holds up well. What changes is behavior and tooling, and both are driven by the go line in each module. These are the vet results across the four repositories we ran on the Fedora VM:
| Repository | go.mod | Packages | Failed type-check | Vet warnings |
|---|---|---|---|---|
| Learning Go, 2nd Ed (6 chapters) | 1.19 to 1.21 | 90 | 7, all deliberate examples | 0 |
| 100 Go Mistakes | 1.18 | 126 | 0 | 5, all code the book shows on purpose |
| Learn Concurrent Programming with Go | 1.19 | 144 | 0 | 8, error ignored on http.Get |
| Cloud Native Go, 2nd Ed | 1.24.0 | 40 | 1, two programs in one folder | 0 |
The loop variable change is the one you will notice first, and you can see it in two minutes on your own machine. Learning Go keeps a small repository, goroutine_for_loop, that starts five goroutines inside a for range loop and prints what each one captured. Clone it and run it as published:
git clone https://github.com/learning-go-book-2e/goroutine_for_loop
cd goroutine_for_loop
go run .Its go.mod says go 1.21, so even the 1.27.2 compiler keeps the old rule of one variable shared by the whole loop. The goroutines race with the loop and typically read that variable after it has finished, so they print the last value:
20
20
20
20
20Raise the module’s language version to 1.22 and run it again:
go mod edit -go=1.22
go run .Now each iteration gets its own variable, so all five values come through. The order changes from run to run because the goroutines race to the channel:
20
8
4
12
16Same compiler, same source, different output. When a book’s sample does not do what the chapter describes, check that line in your copy before you suspect the code. With the module left at 1.21, go vet . points straight at the problem:
main.go:10:10: loop variable v captured by func literalVet itself has grown since these books were printed. Go 1.25 added a check for WaitGroup.Add calls made inside the goroutine they are meant to wait for, which is exactly mistake 71 in 100 Go Mistakes. Run against that example from the book’s repository, Go 1.21.13 reports nothing, while Go 1.27.2 prints:
src/09-concurrency-practice/71-wait-group/main.go:15:10: WaitGroup.Add called from inside new goroutineSo running go vet ./... on a current toolchain over a book’s repo works as a free review of the samples. In Learn Concurrent Programming with Go it flagged every listing that ignores the error from http.Get:
chapter3/listing3.4/charcounterconcurrent.go:21:11: using resp before checking for errorsFor Cloud Native Go, start from a clone of the examples repository:
git clone https://github.com/cloud-native-go/examplesChange into the new directory:
cd examplesThen run the chapter 5 tests one package at a time with -p 1, so the tests that share a file in /tmp cannot trip over each other:
go test -p 1 -count=1 ./ch05/...Every chapter 5 package passed that way except ch05_02, the folder with two main functions, which fails to build under any flag. The command therefore still ends with FAIL and a non-zero exit status, which is expected here.
Check a Book’s Go Version Before You Buy
A Go book ages more gently than most programming books, because old code keeps compiling. It ages in what it leaves out. Before you buy one, spend two minutes on its companion repository:
- Open
go.modand read thegoline - Below 1.18: no generics
- Below 1.22: old loop variable rules in its samples
- Below 1.23: no range-over-func iterators
- Below 1.27: no generic methods
- Check the date of the last commit, since a maintained repo fixes errata the print run cannot
By that test, start with Learning Go, then read 100 Go Mistakes once you’re writing Go every week. Add Learn Concurrent Programming with Go or Cloud Native Go depending on whether your trouble is goroutines or services, and if you’re also choosing a second language, our lists of Rust books and general programming books use the same approach. Much of the cloud-native stack is itself written in Go, so pairing these with our pick of Kubernetes books lets you read the code you deploy.
