The Well-Grounded Java Developer, 2nd Edition (Benjamin J. Evans, Martijn Verburg, Jason Clark) (Z-Library)

# The Well-Grounded Java Developer, 2nd Edition — Reading Guide ## 【One-Line Pitch】 A practical, deep-dive guide for intermediate Java developers who want to understand the JVM from the inside out—covering modules, bytecode, concurrency, performance, and alternative JVM languages—so you can write robust, modern Java for the next decade. ## 【Book Arc】 - **Opening (~0%–9%)**: Introduces the book's mission—turning you into a "Java developer for the next decade"—and clarifies the Java language vs. platform distinction, the dynamic nature of the JVM, and the shift to a time-based release model starting with Java 10. - **Early (~9%–25%)**: Dives into the Java module system (JPMS), explaining how modules replace the old `rt.jar` approach, how to build modular applications, and the practical limitations of tools like `jlink` when dependencies aren't fully modularized. - **Early–Middle (~25%–38%)**: Covers modern language features—records, sealed types, and pattern matching—along with class loading internals, including the delegation model, common exceptions like `ClassNotFoundException` vs. `NoClassDefFoundError`, and an introduction to bytecode. - **Middle (~38%–47%)**: Explores bytecode in depth, teaching you to disassemble classes with `javap`, understand opcodes and the runtime environment, and then transitions into concurrency fundamentals—threads, locks, monitors, and the design forces (safety, liveness, performance, reusability) that shape concurrent systems. - **Late (~47%–end)**: Continues with advanced concurrency via `java.util.concurrent`, performance tuning, build tools (Maven/Gradle), CI/CD, containerized JVM deployments, and alternative JVM languages like Kotlin and Clojure. (Excerpts thin out here; later chapters are summarized from the book's stated contents.) ## 【Key Takeaways】 - **Java is both compiled and interpreted** (Early): The source compiler `javac` creates class files, but the real work happens via JIT compilation at runtime—the JVM is far more dynamic than it appears. Understanding this duality is foundational for everything else in the book. - **The module system changes how you structure and deploy Java apps** (Early): Modules provide explicit dependency metadata, enabling efficient loading and custom runtime images via `jlink`. However, `jlink` only works with fully modularized code—a major real-world constraint. - **Records are data carriers with a contract** (Early): Records auto-generate boilerplate and enforce an `equals()` invariant (copying all components must yield an equal instance). They're a design pattern, like enums, not just syntax sugar. - **Class loading failures have distinct meanings** (Middle): `ClassNotFoundException` means the class was unknown to the JVM; `NoClassDefFoundError` means the JVM knew of it but couldn't find its definition. Knowing the difference is critical for debugging. - **Bytecode is an intermediate representation, not machine code** (Middle): Loops and other high-level constructs are compiled away into branch instructions. Using `javap -c -p` to disassemble classes is the key skill for understanding what your code actually does. - **Reflection enables frameworks that work with unknown types** (Middle): By manipulating objects without static types, you can build libraries that handle types that didn't exist when your code was written—a cornerstone of modern Java tooling. - **Concurrency design forces often conflict** (Middle): Safety, liveness, performance, and reusability (catalogued by Doug Lea) are the recurring concerns in concurrent systems. Java's low-level thread-and-lock model is powerful but hard; `java.util.concurrent` exists to make it more manageable. ## 【Reading Tips】 - **Skim the opening chapters** (~0–9%) if you're already comfortable with Java basics—the release model and language/platform distinction are useful context but not the meat of the book. - **Deep-read the module system chapters** (~9–25%): Build the sample modular app yourself, and deliberately break the module descriptor to see the compiler errors. The `jlink` limitations section is essential for real-world planning. - **Take your time with bytecode** (~38–44%): This is the hardest section. Run `javap` on your own classes, work through the examples slowly, and revisit the earlier example after finishing the opcode catalogue—the chicken-and-egg problem resolves on a second pass. - **Treat concurrency as a design problem, not just an API** (~44–47%+): Focus on the design forces (safety, liveness, performance, reusability) before diving into `java.util.concurrent` APIs. Understanding *why* concurrency is hard matters more than memorizing classes. - **Use the later chapters as reference** (47%+): Performance tuning, build tools, and containerization are covered, but the excerpts don't detail them—skim for what you need when you need it. ## 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book (through concurrency fundamentals). Later chapters on `java.util.concurrent` details, performance tuning, Maven/Gradle, CI/CD, containers, and Kotlin/Clojure are summarized from the book's stated contents but not deeply analyzed here. ##