100 Go Mistakes and How to Avoid Them (Teiva Harsanyi) (Z-Library)

【One-Line Pitch】 A practical field guide to the 100 most common mistakes Go developers make, organized by language area so you can spot and fix them in your own code. Best for developers already comfortable with Go who want to write more idiomatic, efficient, and production-ready code. 【Book Arc】 - **Opening (~0%–10%)**: Frames the book's premise—Go is simple to learn but hard to master—and introduces the taxonomy of mistakes, then moves into code and project organization: variable shadowing, package structure, interfaces, generics, and init functions. - **Early (~10%–30%)**: Covers project organization best practices (project-layout, /cmd, /internal, /pkg), functional options pattern, documentation, and tooling such as linters (vet, shadow) to catch issues automatically. - **Middle (~30%–50%)**: Dives into data types—integer overflow detection, slice internals (growth by doubling, backing arrays, slicing), nil vs. empty slices, map initialization and bucket overflow, and comparison pitfalls with `==` vs. `reflect.DeepEqual`. - **Late (~50%–80%)**: Moves into control structures, strings, error handling, and concurrency—the areas where idiomatic Go diverges most from other languages. - **Ending (~80%–100%)**: Closes with optimization, production-readiness, testing quality, and deeper runtime topics such as stack vs. heap and garbage collection behavior. 【Key Takeaways】 - **Mistakes are the fastest path to mastery** (Opening): The book's core thesis is that seniority in Go comes from making and learning from mistakes, not from memorizing syntax—so each chapter is framed as a fixable error rather than abstract theory. - **Interfaces belong on the consumer side** (Early): Returning interfaces from constructors creates awkward dependency directions and cyclic-dependency risks; keeping interfaces minimal and consumer-defined improves composability. - **Generics need constraints, not guesswork** (Early): Custom constraints using union operators and `~` (underlying-type matching) let you restrict type parameters precisely—knowing when *not* to reach for generics matters as much as knowing how. - **Slices hide allocation and aliasing traps** (Middle): Growth doubles until 1,024 elements then grows by 25%; slicing shares the backing array, and nil vs. empty slices differ in allocation cost—favor returning nil slices to avoid needless allocations. - **`==` is limited; `reflect.DeepEqual` is slow** (Middle): `==` fails on slices and maps, while `reflect.DeepEqual` is roughly 100× slower and distinguishes nil from empty collections—a custom comparison method can be ~96× faster than reflection. - **Linters catch what humans miss** (Early): Tools like `vet` and `shadow` detect subtle issues such as unintended variable shadowing automatically, making them essential for most Go projects. - **Project layout is a convention, not a rule** (Early): The community project-layout (`/cmd`, `/internal`, `/pkg`, `/test`) is worth adopting for larger projects but may be overkill for small ones or teams with existing standards. - **Production readiness spans testing, optimization, and runtime understanding** (Ending): The later sections tie code-level fixes to broader concerns like GC behavior and stack vs. heap allocation, connecting micro-mistakes to system-level performance. 【Reading Tips】 - **Skim the opening chapters if you're already fluent in Go project structure**—the organization and interface advice will feel familiar, but the specific mistake framings are still worth a quick scan. - **Deep-read the data types and concurrency sections**—slice internals, map bucket behavior, and comparison performance are where even experienced developers get surprised. - **Treat it as a reference, not a novel**—each mistake is self-contained, so jump to topics relevant to your current codebase rather than reading linearly. - **Run the linter suggestions immediately**—the book's tooling advice (vet, shadow) pays off fastest when applied to your own projects while reading. - **Pay attention to the "why" behind each fix**—the book emphasizes context-dependent solutions, so avoid cargo-culting fixes without understanding the trade-offs. 【Coverage Limits】 The excerpts cover organization, data types, and comparison topics in reasonable depth, but the excerpts do not cover the full concurrency, error handling, testing, and optimization chapters in detail—those sections are referenced but not substantially excerpted here.