aceld/golang: A Chinese Deep-Dive Book and Video Series on Go Internals

A Book Repository, Not a Framework or Library

aceld/golang is a collection of long-form markdown articles organized as a book. It is not executable software. The repository contains chapter files for a publication titled 'Golang修养之路' (The Road to Mastery in Golang), which was later issued as a print book under the title 'Deep Understanding of Go' ('深入理解Go语言'). The print edition is sold at major Chinese book retailers including JD.com, Dangdang, Tmall, and Xinhua bookstores.

The author, Liu Danbing (known online as Aceld), has published related material on Yuque, a Chinese knowledge-base platform, and has produced companion video series on Bilibili, Douyin, and YouTube. The repository is the source of record for the text; the Yuque edition at yuque.com/aceld provides a formatted reading interface.

The intended audience is Go developers who already write Go and want to understand the runtime, not beginners learning syntax. The book description in the repository states it targets deep, specialist topics in Golang and aims to produce a thorough understanding of the platform's internals.

Three-Part Structure: Internals, Interviews, and Distributed Design

The repository is organized into three named parts, each a separate markdown index file that links to individual chapter files.

Part 1 (Golang修养必经之路, 'The Essential Path to Golang Mastery') has eight chapters. The first covers practical debugging methods for Go programs and performance issues. The second covers the GMP scheduler design in detail, including the model of goroutines, machine threads, and processors. The third chapter analyzes escape analysis: when a variable is allocated on the stack versus the heap. Chapter four compares make and new. Chapter five provides a full analysis of the three-color mark-sweep GC algorithm and the hybrid write barrier. Chapter six addresses interface internals from an object-oriented design perspective. Chapter seven covers seven essential behaviors of defer. Chapter eight covers Go module dependency management.

Part 2 (Golang面试之路, 'The Golang Interview Path') has six chapters on topics that appear frequently in technical interviews: data type definitions, arrays and slices, maps, interfaces, channels, and WaitGroup.

Part 3 (Golang编程设计与通用之路, 'Golang Programming Design and General Knowledge') has seven chapters on broader software design topics: I/O streams and epoll, distributed systems theory from ACID through CAP and BASE, the difference between processes and threads and goroutines at the OS level, goroutine count limits, concurrent server models, TCP TIME_WAIT semantics, and a dynamic worker pool design pattern.

The structure reflects two distinct reading modes. Part 1 is a self-study track for developers who want to understand Go's runtime deeply. Part 2 is a focused preparation track for technical interview candidates. Part 3 extends beyond Go into networking and distributed systems, which the author treats as background knowledge a senior Go developer should hold.

GMP, the Hybrid Write Barrier, and Practical Debugging

The central technical content of the book clusters around three topics that the repository description names explicitly: the GMP scheduler, the GC algorithm, and performance tuning.

The GMP chapters cover the scheduling model that Go uses to map goroutines onto OS threads via a set of processor contexts. This is one of the more complex parts of the Go runtime and is not covered in depth by introductory Go materials. The README lists a dedicated video series on this topic available on Bilibili (BV19r4y1w7Nx) and Douyin.

The GC chapters cover the three-color marking algorithm and the hybrid write barrier introduced in later Go versions to reduce pause time. Go's GC is incremental, and the write barrier coordinates between the concurrent mark phase and running goroutines. The repository lists a second video series on this topic (BV1wz4y1y7Kd on Bilibili).

The debugging chapter in Part 1 addresses practical methods for tracking down bugs and performance problems. The README does not list the specific tools covered in that chapter, but the framing is practical rather than theoretical.

A third video series covers Linux I/O multiplexing and epoll-based concurrency models (BV1jK4y1N7ST on Bilibili), which corresponds to the I/O chapter in Part 3.

Accessing the Content: GitHub, Gitee, and Yuque

The repository can be cloned from GitHub:

git clone https://github.com/aceld/golang

After cloning, the top-level directory contains individual markdown files named after each chapter (in Chinese), a SUMMARY.md index, and a book.json configuration file that suggests the material was originally prepared for the GitBook platform. Reading the files requires a markdown viewer or any text editor.

A mirror is maintained on Gitee at gitee.com/Aceld/golang, which is a common choice for readers in mainland China who face inconsistent access to GitHub.

The Yuque reading version at yuque.com/aceld presents the same content in a web interface with better formatting than raw GitHub markdown rendering. The README links to yuque.com/aceld as the author's main knowledge base, which also includes other works such as '8小时转职Golang工程师' (8 Hours to Becoming a Golang Engineer) and the Zinx TCP framework documentation.

The repository does not include a compiled PDF or ebook. The print edition is the only version with final editorial review; the repository version is the working text.

Limitations: Chinese-Only Content and No Version Tags

All chapter prose is written in Chinese. Technical terms, code identifiers, and Go package names remain in their original Latin form because they are part of the Go language itself, but every explanation, analysis, and commentary is Chinese. Readers who do not read Chinese cannot use this material.

The repository has no GitHub releases and no version tags. The last push was on 2026-05-04. There is no changelog, and the relationship between the GitHub repository content and the print edition text is not formally documented. The print edition may differ from the repository at specific points.

The GPL-3.0 license applies to the text. This license requires that derivative works be distributed under the same terms and that source (the markdown files) be made available. For a reader who only wants to read the book, the license imposes no obligations. For anyone who wants to republish adapted chapters in a closed or proprietary context, the GPL terms restrict that use.

The book.json file indicates GitBook was used as the build tool, but no build instructions are in the repository. The markdown files can be read individually without building the GitBook project.

Scope Gaps: What aceld/golang Does Not Cover

The repository covers Go runtime internals and concurrency theory, but it does not cover several areas that Go engineers also encounter. Web framework usage, database drivers, gRPC, microservices patterns, and cloud deployment are absent. The scope is deliberately narrow: internal mechanics of the language runtime, interview preparation, and foundational distributed systems theory.

Part 2 is framed as interview preparation. The chapters cover data structures and concurrency primitives at a conceptual level, which is appropriate for that purpose but is thinner than the Part 1 chapters on the same topics. A developer who wants a complete treatment of channels, for example, would need to read the Part 1 scheduler chapters in combination with the Part 2 channel chapter.

The companion videos on Bilibili and Douyin are external resources; the repository links to them by URL but does not embed or reproduce their content. If those video platforms become unavailable or remove the content, the video component of the material disappears. The YouTube mirror (listed for the GC video series) provides some redundancy for international readers.

Official Go Documentation as the English-Language Comparison

The Go team publishes the official Go documentation at go.dev and maintains the Go Blog at go.dev/blog. Both are in English and cover some of the same internals: the Go Blog has detailed posts on the garbage collector design, the scheduler, and memory management. The official documentation includes the 'Effective Go' guide, the specification, and package reference material.

The key difference is depth and organization. The official blog posts are individual articles written at different times, with no unified structure that guides a developer from basic to advanced topics. aceld/golang presents a curated progression across three parts, with related video content tied to specific chapters.

For readers who want a single Chinese-language resource that covers GMP, GC internals, and concurrent server design in a structured sequence, the official documentation is not a substitute. For readers who want English content on the same topics, the Go Blog and the book 'The Go Programming Language' by Donovan and Kernighan (which covers the language design in English) are the standard references. aceld/golang's print and repository content are not translated.

Editorial conclusion

Intermediate Go developers who read Chinese and want methodical coverage of the GMP scheduler, garbage collection internals, and concurrent server design in one place will find aceld/golang a focused reference. English-only readers will find the prose inaccessible; all chapter content is written in Chinese. The print edition titled 'Deep Understanding of Go' represents the edited version, while the GitHub repository at github.com/aceld/golang is the source the author continues to update. Clone the repository to read the markdown files offline, or open the Yuque edition at yuque.com/aceld for a formatted reading experience.

Frequently asked questions

Official sources

1. aceld/golang on GitHub
2. Issues
3. License: GPL-3.0
4. README