Learn Go with Pocket-Sized Projects (Aliénor Latour, Donia Chaiehloudj etc.) (Z-Library)

【One-Line Pitch】 A hands-on Go tutorial that teaches professional habits—testing, documentation, architecture, and maintainability—by building eleven small, self-contained applications. Best for developers who already program in another language and want to learn Go by shipping working code rather than reading theory. 【Book Arc】 - **Opening (~0%–15%)**: Introduces Go's philosophy, tooling, and setup, then eases you in with a "Hello, earth!" program that grows into a multilingual greeter using maps, flags, and table-driven tests. Solves the cold-start problem of writing and testing your first idiomatic Go code. - **Early (~15%–30%)**: Builds core language fluency through small utilities—a JSON-driven "bookworm" digest with loops and maps, a reusable logging library that introduces packages, interfaces, and the functional options pattern, and a terminal word game (Gordle) covering runes and input handling. - **Middle (~30%–50%)**: Moves into real-world concerns: a currency converter that confronts floating-point money representation and HTTP calls, plus concurrency fundamentals explored through a goroutine-based maze/treasure search with channels and cancellation. - **Late (~50%–75%)**: Shifts to services and cloud patterns—a gRPC-based habits tracker with protobuf, generated mocks, unit and integration testing, and context handling, followed by an HTML templating front end that talks to the gRPC backend. - **Ending (~75%–100%)**: Explores Go beyond the server with WebAssembly and TinyGo for embedded targets, then closes with appendices on installation, formatting, zero values, benchmarking, pass-by-value vs. pointer, fuzzing, and database connectivity. 【Key Takeaways】 - **Projects are the teaching unit, not the reward** (Early): each chapter is a small, complete app that introduces one or two concepts, so you learn syntax and design together rather than in isolation. - **Testing is woven into every project** (Early): Example functions, Test functions, table-driven tests, mocks, integration tests, and fuzzing appear as first-class design tools, not afterthoughts. - **Idiomatic Go design emerges from constraints** (Middle): implicit interfaces, the functional options pattern, and package APIs are taught through refactoring real code, showing why Go favors composition over inheritance. - **Concurrency is introduced through a concrete search problem** (Middle): goroutines, channels, quit signals, and tracking in-flight work are explored via a maze/treasure scenario rather than abstract primitives. - **Money and floating point are treated as a design problem** (Middle): the converter project forces you to think about representing decimals and validating results, a lesson that transfers to any domain with precision requirements. - **Microservices are built incrementally** (Late): protobuf definitions, code generation, business/API layering, mocks, and context propagation are assembled step by step into a working gRPC service. - **Go reaches beyond the backend** (Ending): WebAssembly and TinyGo demonstrate that the same language can target browsers and microcontrollers, broadening your sense of Go's applicability. - **Appendices are a reference toolkit** (Ending): zero values, benchmarking, pass-by-value semantics, fuzzing, and database access are collected for lookup rather than linear reading. 【Reading Tips】 - Read sequentially: later chapters reuse code and concepts from earlier ones, so skipping ahead will leave gaps in the shared project lineage. - Deep-read the testing sections even if you already test in another language—Go's testing package, table-driven style, and fuzzing have specific idioms worth absorbing. - Treat the concurrency and gRPC chapters as the hard spots; budget extra time to run the code and experiment with cancellation and context behavior. - Skim the appendices on first pass, then return to them as reference when a project touches zero values, benchmarking, or database access. - Type the code yourself rather than downloading it; the book's value is in the decisions you make while building, not in the finished listings. 【Coverage Limits】 This guide is based on stratified excerpts covering the front matter, table of contents, and early chapters; detailed content of later projects is inferred from chapter titles and summaries, so specific implementation details beyond the excerpts are not covered.