Learning Test-Driven Development A Polyglot Guide to Writing Uncluttered Code (Saleem Siddiqui)（Z-Library）

# Learning Test-Driven Development: A Polyglot Guide to Writing Uncluttered Code ## 【One-Line Pitch】 A hands-on, three-language (Go, JavaScript, Python) guide to mastering test-driven development through a single, progressively complex money-management project—perfect for developers who know basic programming and want to internalize TDD as a daily practice rather than a theoretical concept. ## 【Book Arc】 - **Opening (~0%–10%)**: Establishes why TDD matters despite decades of evidence supporting it, addresses common objections (fear, lack of guidance, schedule pressure), and positions the book for developers who already know at least one language—this is not a programming primer. - **Early (~10%–23%)**: Sets up the project structure (tdd-project with go/, js/, py/ folders), compares the three languages' testing ecosystems (Go's built-in testing, JavaScript's assert package, Python's unittest), and walks through the first Red-Green-Refactor (RGR) cycle with a simple Dollar class. - **Early (~23%–32%)**: Deepens the RGR practice by tackling the "money problem"—building a multicurrency spreadsheet tool—and demonstrates how to handle the refactoring stage, including removing duplication and logical coupling between tests and code. - **Middle (~32%–48%)**: Expands the domain model with Money objects carrying both amount and currency, introduces Portfolio as an aggregation concept, and shows how TDD guides design decisions (like overriding Python's __eq__ for value-based comparison). - **Middle (~48%–end)**: Continues through advanced topics including hash maps for currency conversion, error handling, and redesign—all driven by tests, with each chapter ending in a commit and a "Where We Are" checkpoint. ## 【Key Takeaways】 - **TDD is a skill to be learned, not a talent** (Early): The book explicitly addresses why developers avoid TDD—lack of awareness, fear, schedule pressure—and argues that like any skill, it requires deliberate practice and external support to master. - **The Red-Green-Refactor cycle is the core discipline** (Early): Every feature starts with a failing test (red), moves to minimal passing code (green), then cleans up duplication and coupling (refactor)—a rhythm that becomes smoother with repetition but never disappears. - **Hardcoding is a legitimate first step** (Early): The book shows you can reach green by returning a hardcoded "10 USD" value; the refactoring stage then reveals the subtle duplication between test and code, teaching you to see coupling that isn't obvious at first glance. - **Language differences shape TDD practice** (Early): Go's static typing and built-in testing package, JavaScript's dynamic typing with the assert package, and Python's unittest with __eq__ overrides—each language requires slightly different TDD approaches, and the book demonstrates all three side by side. - **Domain knowledge drives implementation choices** (Middle): When Go's integer division fails for fractional amounts, the fix isn't just changing types—it's recognizing that multipliers are integers (share counts) while amounts can be fractional (prices), then converting accordingly. - **Tests guide design, not just verification** (Middle): The Portfolio class emerges naturally from writing tests for adding multiple Money objects, showing how TDD helps you discover the abstractions your domain actually needs. - **Continuous integration is a natural TDD companion** (Throughout): The folder structure (tdd-project with separate language folders) is designed to support CI adoption, and each chapter ends with committing changes—making TDD and version control inseparable practices. ## 【Reading Tips】 - **Skim the language comparison tables** (Early): The Go/JavaScript/Python feature comparison (Table P-2) gives you a quick reference for how each language handles typing, exceptions, and testing—useful for deciding which language to follow first. - **Deep-read the first RGR cycle** (Early ~29%–32%): The first full cycle with the Dollar class is the most detailed and slowest-paced; master this and subsequent chapters move faster with less hand-holding. - **Follow one language, then the others**: The book's structure lets you follow Go, JavaScript, or Python consistently; pick one for your first pass, then return for the others to see how TDD principles translate across ecosystems. - **Pay attention to the "Where We Are" checkpoints**: Each chapter ends with a summary of what's been built and what's next—use these to orient yourself if you get lost in the details. - **Set up the project structure exactly as described**: The tdd-project folder with go/, js/, py/ subfolders and the TDD_PROJECT_ROOT environment variable will save you countless command-line headaches throughout the book. ## 【Coverage Limits】 This guide covers the book's opening through the middle sections (approximately 0–48%), including setup, the first RGR cycles, Money and Portfolio classes, and early refactoring. The later chapters on hash maps, error handling, and redesign are mentioned but not detailed. ##