Go Faster (Ollie Phillips)（Z-Library）

【One-Line Pitch】 A pragmatic, OOP-friendly introduction to Go that skips the basics you already know and focuses on the paradigm shifts, new features like Generics and Workspaces, and the mental models that make Go code readable and idiomatic — ideal for experienced developers (especially from Java/C#/Python) who want to get productive fast. 【Book Arc】 - **Opening (~0%–9%)**: Sets the book's philosophy — Go is simple (25 keywords), so the real challenge is unlearning OOP habits. Introduces the "values, not objects" mindset, exported/unexported visibility (replacing public/private), and the importance of treating errors as values rather than exceptions. - **Early (~9%–25%)**: Covers the Go toolchain and project setup: the CLI (go env, go mod), documentation via Godoc (including executable examples), and project organization — the special `internal` folder for hiding packages, the `cmd` folder for multiple executables, and best practices for structuring code outside GOPATH. - **Early–Middle (~25%–38%)**: Deep dive into dependency management: modules (go.mod/go.sum), the shift from GOPATH, vendoring, and the newer Workspaces feature (Go 1.18) for multi-module projects. Then moves to variables and constants — declaration styles, the `:=` shorthand, `iota` for constant sequences, and the compiler's strictness on unused variables. - **Middle (~38%–47%)**: Explores variable semantics (pointers vs. values), the three ways to get a pointer (`&`, `new`, `make`), and data types — including the gotcha of floating-point precision in comparisons, booleans, strings as byte slices, and aggregate types (arrays with fixed length as part of their type). - **Late (~47%–60%+)**: Continues into more advanced territory per the table of contents: control structures, error handling, logging, functions, memory management, receivers, interfaces, type assertion/reflection, and Generics — followed by concurrency (goroutines, context, waitgroups, mutexes, channels) and quality assurance (testing and benchmarking). 【Key Takeaways】 - **Unlearn OOP, embrace values** (Early): Go has no classes or objects — think in terms of types, values, and receivers. Errors are just values to check, not exceptions to throw; this verbosity improves readability. (Early) - **Visibility is about capitalization, not keywords** (Early): Uppercase first letter = exported (public), lowercase = unexported (private). This applies to variables, functions, types, and struct fields — a simple rule that replaces the public/private paradigm entirely. - **The toolchain is your friend** (Early): Godoc can turn code examples into interactive, runnable programs on the Go Playground — and these examples are actually tests (using `Example` prefix and `// Output:` comments), so documentation stays verified. - **Project structure has one special rule** (Early): The `internal` folder restricts package access to shared ancestors — perfect for hiding code you don't want to expose as a public API. Use `cmd` for multiple executables sharing common code. - **Modules and Workspaces changed everything** (Early–Middle): Since Go 1.13, modules (go.mod) let you organize projects anywhere, not just GOPATH. Workspaces (Go 1.18) handle multi-module development. go.sum locks dependency versions via checksums — never edit it manually. - **Pointers have three creation paths** (Middle): `&` for direct address-taking, `new` for zeroed structs, and `make` for reference types (slices, maps, channels). Understanding when to pass values vs. pointers is core to avoiding common mistakes. - **Floating-point comparisons are treacherous** (Middle): Two seemingly equal float64 values can fail `==` due to rounding precision. Always convert to the same precision explicitly, especially in unit test assertions. - **Arrays are rigid, strings are slices** (Middle): Array length is part of its type (`[5]int` ≠ `[6]int`), and strings point to backing byte slices — so slicing a string (e.g., `myString[6:]`) is really byte manipulation. 【Reading Tips】 - **Skim the early chapters if you're already comfortable with Go basics** — the book assumes you can set up an environment and know programming fundamentals. Focus on the paradigm-shift sections (visibility, errors as values) rather than syntax. - **Deep-read the dependency management and project organization chapters** — these cover modern practices (modules, workspaces, internal folder) that many older Go books miss, and they're critical for real-world projects. - **Pay special attention to the pointer/value semantics section** — it's flagged as core to avoiding common mistakes. Work through the examples with the Go Playground links to internalize when to use `&`, `new`, and `make`. - **Use the Godoc interactive examples as a learning tool** — run and edit them on the Playground to test your understanding of the standard library, rather than just reading the code. - **Don't skip the QA chapter** — testing and benchmarking are covered late but are essential for writing production-quality Go, and the book ties them back to earlier concepts like floating-point precision. 【Coverage Limits】 This guide synthesizes the book's philosophy, toolchain, project structure, dependency management, and core data/variable concepts from the excerpts. The later chapters on concurrency, generics, and testing are mapped from the table of contents but not detailed here — the excerpts do not cover their full content.