TL;DR
Get business pricing on monitors, keyboards and dev gear
- Business-only prices and quantity discounts
- Tax-exempt purchasing
- Multiple users, one account, clear invoices
Developer Anton Zhiyanov has published ‘Go Concurrency Distilled’, a free online mini-book offering a rapid refresher on Go concurrency topics with runnable code examples. It spans 18 chapters from goroutines and channels to mutexes, atomics, scheduling and diagnostics, and is also available as a PDF.
Developer Anton Zhiyanov has published “Go Concurrency Distilled”, a free mini-book hosted on his site antonz.org that condenses Go’s concurrency model into a series of short chapters with runnable code examples. The book is aimed at programmers who already know the basics and want a quick refresher, and it covers eighteen topics ranging from goroutines and channels to race conditions, mutexes, semaphores, scheduling and diagnostics. A PDF version with static examples is also available.
The author describes the project as “a brief overview of many concurrency topics in Go” in which “each topic comes with interactive examples” that readers can experiment with by changing the code and clicking Run. The interactive format is the book’s distinguishing feature: rather than static listings, every concept is demonstrated in an embedded playground where the code can be modified and re-executed directly in the browser.
The table of contents lists the following chapters: Goroutines, Channels, Select, Pipelines, Time, Context, Wait groups, Data races, Race conditions, Mutexes, Semaphores, Signaling, Run once, Object pool, Atomics, Testing, Scheduling, Diagnostics, and closing thoughts. Together these map onto the core of Go’s concurrency toolkit: the language-level primitives (the go keyword, channels, select), the standard library’s synchronization package (sync.WaitGroup, mutexes, sync.Once), and the runtime tooling used to detect and debug concurrency bugs.
Zhiyanov is explicit about the book’s scope and audience. “This is a quick refresher on Go concurrency, not a beginner’s guide,” he writes, pointing readers who want to learn the subject from the ground up with practical exercises to his longer work, “Gist of Go: Concurrency”. He also states that “the book is AI-free,” a claim that signals the material was written without generative AI assistance.
The published excerpts show the book’s teaching style. The goroutines chapter explains that goroutines are functions started with the go keyword, that the Go runtime distributes them across operating-system threads, and that — unlike OS threads — they are lightweight enough that “you can create hundreds or thousands of them.” The channels chapter walks through unbuffered and buffered channels, closing semantics, range iteration, and directional channel types, including pitfalls such as the panic triggered by closing a channel twice or writing to a closed one. The text also notes a recently added convenience: WaitGroup.Go, which increments a wait group’s counter, runs a function in a goroutine, and decrements the counter on completion.
Why Go Developers Should Notice
Concurrency is the feature most closely identified with Go, and it is also where the language’s sharpest edges lie. Data races, deadlocks, leaked goroutines and misused channels are recurring sources of production bugs, and the book dedicates whole chapters to data races, race conditions and diagnostics — the tooling-facing side that many tutorials skip. A compact, example-driven reference that a working developer can scan in an afternoon fills a gap between lengthy courses and scattered documentation.
The interactive format lowers the barrier to experimentation: because each example runs in the page, readers can test variations — such as swapping an unbuffered channel for a buffered one — without setting up a local environment. For teams onboarding engineers into Go codebases, a free, single-page resource of this kind is a practical reference link rather than a course commitment.
The book also documents newer API surface, such as WaitGroup.Go, which means even experienced Go programmers may find material that postdates their own learning of the language. The author’s decision to label the work “AI-free” also reflects a current debate about machine-generated technical writing, where accuracy of small details matters.
“Go Concurrency Distilled” is published on antonz.org, the personal site of Anton Zhiyanov, who has written extensively on the Go standard library and idiomatic Go. His previous work includes “Gist of Go: Concurrency”, a longer beginner-oriented treatment with practical exercises, which the new mini-book explicitly references as the starting point for newcomers.
The mini-book follows the same publishing pattern Zhiyanov has used before: a free web version with interactive examples and a downloadable PDF with static code. The chapter structure moves from foundational primitives (goroutines, channels, select) through coordination tools (pipelines, context, wait groups) to correctness topics (race detection, mutexes, semaphores, atomics) and finally to runtime behavior and debugging (scheduling, diagnostics).
What the Announcement Leaves Open
Several practical details are not stated in the available material. The exact publication date of the book is not specified, only that it is currently available on antonz.org. It is not clear whether the PDF version is free or paid — the source confirms only that it exists with static examples. The book’s license terms, whether it will receive updates as the Go standard library evolves, and its total length beyond the listed chapters are also unstated.
The “AI-free” claim is the author’s own statement and cannot be independently verified. Additionally, only portions of the book’s early chapters were available in the source material; the content of later chapters such as Scheduling and Diagnostics could not be reviewed here, so their depth and quality are unassessed.
The book is available now at antonz.org/go-concurrency-distilled/, where readers can work through the interactive chapters or download the PDF. Given Zhiyanov’s pattern of maintaining and extending his published books, future revisions are plausible as Go’s concurrency APIs change — for instance, if the standard library adds new synchronization helpers like the recent WaitGroup.Go. Readers who find the refresher too compressed can turn to his fuller treatment, “Gist of Go: Concurrency”, which covers the same territory from the ground up with exercises. No roadmap or versioning plan for the mini-book has been announced.
Key Questions
What is “Go Concurrency Distilled”?
It is a free mini-book by Anton Zhiyanov, published on antonz.org, giving a brief overview of Go concurrency topics — goroutines, channels, select, pipelines, context, mutexes, atomics, scheduling, diagnostics and more — each with interactive, runnable code examples.
Who is the book for?
Per the author, it is “a quick refresher on Go concurrency, not a beginner’s guide.” It targets developers who already know the basics; newcomers are directed to his other book, “Gist of Go: Concurrency”, which teaches the subject from the ground up with practical exercises.
Is the book free, and is there a PDF?
The web version with interactive examples is freely available at antonz.org/go-concurrency-distilled/. A PDF version with static examples also exists; the source material does not state whether the PDF is free or paid.
How does the interactive format work?
Each topic includes a code example embedded in the page. Readers can modify the code and click Run to execute it directly in the browser, making it possible to experiment with variations without a local Go setup.
What does “AI-free” mean in this context?
It is the author’s statement that the book was written without generative AI assistance. It is a self-declared claim by the author and is not independently verifiable.
Source: hn
Fall Picks
fall essentials
As an affiliate, we earn on qualifying purchases.
