Go Data Structures Explained A Practical Guide with Examples (William E. Clark)（Z-Library）

【One-Line Pitch】 A hands-on tour of Go's data structures that pairs each concept with runnable examples, from environment setup through concurrency and performance tuning. Best for developers who already know a little Go (or another language) and want a practical, example-driven reference rather than a theory-heavy textbook. 【Book Arc】 - **Opening (~0%–10%)**: Environment setup across Windows, macOS, and Linux, then Go syntax fundamentals — the `for` loop as the sole looping construct, basic types, and the motivation for studying data structures via Abstract Data Types (ADTs). Solves the "get running and oriented" problem. - **Early (~10%–32%)**: The built-in toolkit — arrays (fixed-size, contiguous, multidimensional), slices (pointer/length/capacity, `append`, `copy`, views into arrays), maps, and strings, plus a dedicated section on Go's explicit error-handling model (`error` interface, wrapping, panic/recover). Establishes the native structures everything else builds on. - **Middle (~32%–48%)**: Strings in depth (immutability, UTF-8 and runes, `strings.Builder`), then the transition to dynamic structures — pointers, runtime memory allocation, garbage collection, and the trade-offs between in-place mutation and copying collections. - **Late (~48% onward)**: Custom structures — linked lists, trees, hash tables, stacks, queues, heaps, and graphs — each with operations, algorithms, and use cases, followed by concurrency and sorting/searching algorithms. (Excerpts thin out here; the later chapters are described in the preface but not sampled in detail.) - **Ending**: Best practices for performance and debugging, closing the loop from fundamentals to production-minded code. 【Book Arc note】The progression is deliberately layered: native types first, then memory/pointer mechanics, then hand-built structures, then algorithms and concurrency on top. 【Key Takeaways】 - **ADTs separate behavior from implementation** (Early): the book frames structures by their operations (push/pop/peek for a stack) rather than their backing store, which is the mental model for choosing between array- and pointer-based implementations. - **Arrays are fixed and contiguous; slices are views** (Early): a slice is a pointer, length, and capacity over an underlying array, so slicing does not copy and mutations propagate — the single most important gotcha for newcomers. - **`copy` vs. assignment matters** (Early): plain assignment aliases the same backing array, while `copy` duplicates data; the book uses a side-by-side example to make the distinction concrete. - **Strings are immutable and UTF-8 encoded** (Middle): byte indexing can split multibyte characters, so character-level work requires `rune` conversion; heavy concatenation should use `strings.Builder` to avoid redundant allocations. - **Error handling is explicit by design** (Early): Go returns errors as values rather than throwing exceptions; the book compares explicit returns, wrapping, panic/recover, and custom error types with guidance on when each fits. - **Dynamic structures trade control for responsibility** (Middle): pointers and runtime allocation enable linked structures, but garbage collection does not excuse careless pointer assignments that retain unused memory. - **Mutation vs. copying is a design decision** (Middle): in-place edits save memory but risk side effects on shared data; fresh collections preserve immutability and ease debugging. - **Concurrency and algorithms cap the stack** (Late): concurrency patterns and sorting/searching are presented as advanced applications built on the structures covered earlier. (Excerpts do not cover these chapters in detail.) 【Reading Tips】 - **Skim the setup chapter** if Go is already installed; the Windows/macOS/Linux commands are reference material, not concepts. - **Deep-read the slices and strings chapters** — capacity behavior, aliasing, and rune handling are where most real bugs originate, and the examples are worth typing out rather than just reading. - **Treat the error-handling section as a style guide**: internalize "return errors, wrap for context, reserve panic for unrecoverable states" before moving to custom structures. - **Use the custom-structure chapters as a lookup**: read the linked list, tree, and hash table chapters when you need them, since each is self-contained with operations and use cases. - **Take away the selection framework**, not just the code: the recurring question is which representation fits the problem, and that judgment transfers beyond Go. 【Coverage Limits】 This guide is based on stratified excerpts concentrated in the opening through middle chapters (setup, syntax, arrays, slices, strings, error handling, memory). The later chapters on trees, hash tables, heaps, graphs, concurrency, and sorting/searching are described in the preface but not sampled in detail, so their treatment here is necessarily high-level.