97 Things every JAVA Programmer should Know (Kevlin Henney, Trisha Gee)（Z-Library）

【One-Line Pitch】 A collection of 97 practical, opinionated essays from experienced Java developers covering everything from coding fundamentals and design philosophy to modern JVM features and testing strategies—ideal for working Java programmers who want to sharpen their craft and see how seasoned practitioners think about everyday problems. 【Book Arc】 - **Opening (~0%–10%)**: The book opens with a mix of project documentation advice (AsciiDoc), problem decomposition strategies, and the philosophy of writing code for future maintainers—setting the tone that this is about professional practice, not just syntax. - **Early (~10%–23%)**: Focus shifts to core Java-specific pitfalls and design principles: avoiding null parameters, understanding the null type in the JLS, handling legacy code with patterns like strangler fig, and using alternative JVM languages like Groovy for pragmatic solutions. - **Early (~23%–32%)**: Essays cover learning new ecosystems, improving code readability through speed-reading techniques for code, and emphasizing separation of concerns—with concrete examples like refactoring a fraction parser to make testing easier. - **Middle (~32%–42%)**: The book broadens into modern JVM topics: Kotlin coroutines for concurrency, container-based integration testing, and the importance of naming and code structure for maintainability. - **Middle (~42%–48%)**: Includes author biographies and index highlights, revealing the breadth of topics—from garbage collection and fuzz testing to JVM performance and multiparadigm programming—though the excerpts here are mostly structural rather than substantive. 【Key Takeaways】 - **Break problems into small, testable chunks** (Early): Write automated tests and commit frequently for each piece; this reduces cognitive load and gives you rollback points when things fail. - **Write code for the future restorer, not the original author** (Early): The best code is written with the next programmer in mind; haste leads to fragile systems that collapse under pressure, like overstretched trees. - **Avoid null parameters in public APIs** (Early): If a parameter is optional, create an overloaded method without it; null should only be an internal implementation detail, never leaked to callers, to prevent NullPointerExceptions. - **The null type is a real, unnamed type in the JLS** (Early): Understanding this from the Java Language Specification clarifies why `var v = null;` fails to compile—it's not just a "special literal" but a distinct type with no name. - **Legacy code deserves repair, not rewrite** (Early): The "broken windows" effect means quick fixes degrade systems, but full rewrites lose domain knowledge; the strangler pattern lets you incrementally replace legacy systems with pride. - **Separate concerns to improve testability** (Early): If a test is hard to write, it's a sign of poor coupling or separation; pulling out focused classes like a `FractionParser` makes code more modular, composable, and readable. - **Coroutines are lightweight threads for concurrency** (Middle): Kotlin's `runBlocking` and `launch` let you split work into simple tasks that appear concurrent on one thread—invaluable for Android's threading model and scalable servers. - **Use containers for integration testing** (Middle): Interact with container engines via APIs or CLI to write your own "container driver," but distinguish between starting a container and the readiness of the service inside it for testing. 【Reading Tips】 - **Skim the early essays for philosophy, deep-read the technical ones**: Pieces on "code restorer" and "broken windows" are mindset-setting; essays on null handling and separation of concerns have concrete code you should study. - **Treat this as a reference, not a linear read**: Each essay is self-contained (2–3 pages), so jump to topics that match your current pain points—whether that's legacy code, testing, or JVM performance. - **Pay attention to the JLS citations**: The essay on null type references Section 4.1 of the Java Language Specification; if you want to understand Java's type system deeply, follow these references. - **Look for cross-essay themes**: Many authors return to testability, readability, and maintainability; noticing these recurring values will help you internalize the book's core philosophy. - **Skip the author bios and index in the middle**: These are filler; the real content is in the essays themselves, so don't get distracted by the structural sections. 【Coverage Limits】 The excerpts cover roughly the first half of the book (0–48%), with substantial gaps in the later essays on garbage collection, fuzz testing, and JVM performance—these topics appear only in the index, not in the sampled content.