Quick Take
- Narration: Mark Thomas delivers a clean, technically precise reading that keeps pace with the dense material, he handles code-adjacent vocabulary without stumbling, and the chapters feel like structured lectures rather than recitations.
- Themes: Go language internals, concurrency as a design philosophy, idiomatic programming
- Mood: Focused and methodical, like a good workshop session
- Verdict: A strong intermediate-level Go companion that rewards listeners who already have some programming foundations, not the place to start from scratch.
I had my first real encounter with Go during a stint editing technical content for a software company whose engineers kept describing it as the language that gets out of your way. I didn’t fully understand what they meant until I spent time with Go in Action, which William Kennedy wrote alongside Brian Ketelsen and Erik St. Martin. The book kept coming up in forums and reading lists as the right second step for developers who’d worked through the official Tour of Go and wanted something with more structural depth. I finished the audiobook over the course of a working week, an hour at a time in the early morning before my inbox filled up.
The three authors bring different angles to the material. Kennedy is the blog-writer and community presence, Ketelsen and St. Martin are the organizers of GopherCon and co-authors of a Go-based framework. That combination gives the book a practical, community-facing sensibility. This isn’t a language reference manual dressed up as a tutorial. It’s an opinionated guide to how Go is actually used by people who’ve built things with it.
What the Table of Contents Doesn’t Convey
The chapter list, type system, concurrency, channels, testing, reads like any programming language book from the past decade. What distinguishes Go in Action is the weight it places on internals. When Kennedy explains Go’s slice type, he doesn’t just describe its behavior; he walks through the underlying memory model, the three-field header structure, the difference between length and capacity in practice. The same treatment applies to maps, goroutines, and the scheduler. This is the kind of material that doesn’t just help you use the language correctly. It helps you reason about why it behaves the way it does when something goes wrong.
One listener described it as a great second Go book, and that framing is exactly right. The concurrency chapter in particular assumes you’ve already encountered the concept and are ready to think about it structurally rather than syntactically. Hand-holding is minimal. If you’ve spent time with another systems language or have intermediate experience in something like Java or Python, the pace will feel brisk but appropriate. If you’re newer than that, you’ll want to supplement.
The Audiobook Format and Its Limits
A PDF companion is included with this Audible title, and I want to be direct about how much that matters: for Go in Action, the PDF is not optional. The book contains code samples that are load-bearing to the argument in several chapters, particularly the concurrency patterns section. Mark Thomas reads code blocks clearly and without rushing, which is to his credit, but following a goroutine example through your ears alone requires a level of working memory that most listeners will find taxing. Keep the PDF open. The chapters on arrays, slices, and maps especially benefit from the visual reference.
That said, Thomas’s narration works well for the explanatory prose, which constitutes the majority of the runtime. He doesn’t perform the text so much as deliver it, a distinction that matters here. Go in Action is not a book you’re meant to feel. It’s a book you’re meant to think with, and Thomas’s register matches that purpose.
Concurrency as the Book’s Real Subject
Concurrency occupies two chapters, and those chapters are where Go in Action earns its reputation. Most introductions to Go mention goroutines and channels as selling points and leave it there. Kennedy goes further, examining the patterns by which you compose concurrent code responsibly, the race conditions that appear when goroutines share state, the idiomatic use of channels to communicate rather than coordinate, the patterns like fan-out and fan-in that emerge from Go’s concurrency primitives.
What struck me about this section was its honesty about tradeoffs. Kennedy doesn’t treat Go’s concurrency model as a solution to all problems. He acknowledges the situations where it introduces complexity and where simpler sequential code would serve better. That intellectual honesty is rarer in technical literature than it should be, and it lifts the book above the promotional register of many language guides.
Who Should Listen, Who Should Skip
Go in Action is well matched for developers with experience in at least one other language who are trying to move beyond Go’s surface features into its actual idioms. It is particularly useful for engineers coming from Java or Python who want to understand how Go’s approach to type embedding, interface satisfaction, and concurrency differ in practice, not just in syntax. Beginners will find it moves too fast. Experienced Go engineers will likely know most of the material but may still value the internals sections. The five-and-a-half-hour runtime makes it manageable for a single focused week of commute listening, which is roughly how I consumed it.
Frequently Asked Questions
Can I follow Go in Action without any prior Go experience?
The book is explicitly positioned for developers with experience in other languages who want more than a syntax tour. If you have no Go background at all, the authors recommend starting with the official Go Tour or a more basic primer like Caleb Doxsey’s Introducing Go first. Multiple reviewers describe it as the ideal second Go book rather than a first one.
How essential is the PDF companion for audio listeners?
For the explanatory sections, you can follow the audio comfortably without it. For the code samples, particularly the concurrency patterns, slice internals, and testing chapters, the PDF is genuinely important. The code blocks are read clearly by Mark Thomas, but visual reference significantly reduces cognitive load when following multi-step examples.
Does the book cover Go’s standard library in useful depth?
There is a dedicated chapter on the standard library, but it functions more as an orientation than a comprehensive reference. Kennedy highlights the most commonly used packages and explains their design philosophy rather than cataloging every function. The focus throughout is on language internals and idiomatic patterns rather than API coverage.
Is Go in Action still relevant given how quickly Go has evolved?
The core material on Go’s type system, concurrency model, channels, and testing patterns remains accurate and useful. Some tooling details and module system information may reflect an older state of the ecosystem. For production Go development, you’ll want to supplement with current documentation on modules and generics, which postdate this edition.
