Cruising Along with Java (Venkat Subramaniam)（Z-Library）

【One-Line Pitch】 A practical field guide to the modern Java language (versions 9–24) that shows working developers how to write concise, expressive, and safer code using type inference, text blocks, records, sealed classes, pattern matching, and modularization. Best for Java 8-era programmers and teams who need to catch up without wading through spec documents. 【Book Arc】 - **Opening (~0%–10%)**: Frames why Java moved to a six-month release cadence and what that means for developers; sets expectations that the book is a hands-on tour of features from Java 9 through 24, requiring Java 24 to run all examples. - **Early (~10%–30%)**: Covers day-to-day conciseness features — `var` type inference (what it is, what it is not, and its pitfalls), lambda parameter inference, and text blocks with smart indentation and escape handling for embedding XML/JSON. - **Middle (~30%–50%)**: Moves into object-oriented design upgrades — records as lightweight immutable data carriers, their generated `toString`/`equals`/`hashCode`, reflection over record components, custom canonical constructors, and sealed classes for controlled inheritance hierarchies. - **Late (~50%–75%)**: Shifts to control-flow and functional expressiveness — switch expressions and pattern matching to reduce verbosity and hidden errors, plus gatherers for extending functional pipelines with custom intermediate operations. - **Ending (~75%–100%)**: Applies the same capabilities to larger architectural concerns — modularizing code for security and dependency clarity, and using modules to discover services more dynamically. (Excerpts do not cover the final chapters in detail.) 【Key Takeaways】 - **`var` is syntax sugar, not a type** (Early): The compiler infers and stores the real type; there is no "var type." Understanding this prevents confusion when reading bytecode or debugging inferred locals. - **Type inference has deliberate limits** (Early): Java forbids `var` on fields, method parameters, and return types, unlike Scala or Kotlin. Knowing these boundaries helps you avoid compile errors and appreciate Java's conservative design. - **Inference can change behavior** (Early): Replacing an explicit `Collection<Integer>` with `var` and `new ArrayList<>` can silently change which overload or method is selected. Use `var` where the type is obvious, not where it hides intent. - **Text blocks solve multiline string pain** (Early): Smart indentation, incidental trailing-space removal, and escapes like `\s` and `\` make embedded XML, JSON, and formatted messages readable without concatenation noise. - **Records are more than boilerplate killers** (Middle): They generate `toString`, `equals`, and `hashCode` based on components, support interfaces, and expose components via reflection. Custom canonical constructors let you validate and normalize data at construction time. - **Sealed classes close inheritance hierarchies** (Middle): The `sealed` keyword plus `permits` (or same-file subclasses) gives compile-time control over who may extend a type — valuable for libraries and plugin architectures where runtime failures are costly. - **Switch expressions and pattern matching reduce error surface** (Late): They make branching more expressive and less prone to fall-through or casting mistakes, aligning control flow with modern Java's emphasis on safety. - **Gatherers extend the functional pipeline** (Late): Custom intermediate operations let you go beyond built-in stream steps, making functional-style code adaptable to domain-specific transformations. 【Reading Tips】 - **Deep-read the type inference and text block chapters** if you are coming from Java 8; these are the features you will use daily and where subtle mistakes happen. - **Skim the release-cadence discussion** in the opening if you already follow Java's six-month cycle; the value is in the feature chapters, not the history. - **Type the examples yourself** — the book is example-driven, and many pitfalls (especially with `var` and records) only become clear when you compile and inspect bytecode with `javap`. - **Treat records and sealed classes as design tools**, not just syntax. Pause to consider where immutability and closed hierarchies fit your domain before applying them broadly. - **Use the modularization material as a migration checklist** if you maintain a large codebase; the excerpts suggest it is aimed at practical dependency and security concerns. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book; later chapters on switch expressions, pattern matching, gatherers, and modularization are referenced but not detailed in the source material. Specific chapter titles, code listings, and advanced examples beyond those excerpts are not covered here.