Java for Staff Engineers

The parts

1. Part I · Java Foundations From an empty file to a running program — the platform, the types, the control flow, and the first objects. The bedrock every later Part stands on, taught on Java 25 LTS with nothing assumed.
2. Part II · Objects, Classes & Interfaces How Java models the world — state and behavior, the contracts an object must honour, and the four ways one type can stand in for another. Object orientation done the idiomatic way , with every sharp edge named.
3. Part III · Records, Sealed Types & Pattern Matching The modern data layer — concise value types, closed hierarchies the compiler can reason about, and pattern matching that takes them apart. Java's algebraic data types , and the language's biggest leap in a decade.
4. Part IV · Generics & the Type System Parametric types that catch errors at compile time — bounds, wildcards, and the variance rules that trip everyone up — plus the erasure underneath that explains every sharp edge. The type system, demystified .
5. Part V · Functional Java & Streams Functions as values, and the lazy pipeline that processes data declaratively — lambdas, the stream model, the Collectors toolkit, and Gatherers. The half of modern Java that reads like what , not how .
6. Part VI · Collections & Data Structures The containers you reach for every day — their implementations, their Big-O, and the one that fits the job — plus the idioms and traps that separate working code from correct, fast code. Choosing the right structure is half of performance.
7. Part VII · Exceptions, I/O & Core Library Handling failure well, talking to the filesystem, and the everyday standard library — exceptions done right, NIO.2, the modern date-time API, regex, and big numbers. The toolkit you reach for between the clever parts.
8. Part VIII · The JVM: Class Loading & Execution Under the hood — what a .class file really is, how the stack machine runs bytecode, and how classes are found, linked, and initialized. The layer beneath the language, where "magic" turns into mechanism.
9. Part IX · JIT, Compilation & Code Internals How the JVM makes bytecode fast — tiered compilation, the optimizations that matter, and the dynamic machinery behind lambdas and high-speed field access. From interpret to native , and why it sometimes goes backwards.
10. Part X · Memory & Garbage Collection Where objects live and how they die — the heap, object headers, the generational collectors, and the reference types that tune reachability. Automatic memory, made legible and tunable, on Java 25's modern GCs.
11. Part XI · Threads, the Memory Model & Locks Where correctness gets hard — platform threads, the rules of visibility , and the locks that tame shared state. The Java Memory Model is the contract beneath every concurrent program; learn it before you trust a single shared field.
12. Part XII · Executors, Atomics & Concurrent Collections Concurrency you can actually compose — pools instead of raw threads, futures instead of callbacks, lock-free atomics, and collections built for many hands. The java.util.concurrent toolkit that lets you stop hand-rolling locks.
13. Part XIII · Virtual Threads & Structured Concurrency Project Loom delivers the dream — millions of cheap threads, blocking code that scales. Write thread-per-request again, structure concurrent work like a code block, and pass context without ThreadLocal. The biggest shift in Java concurrency since java.util.concurrent.
14. Part XIV · Performance Engineering Make it fast — but only after you measure. Benchmark without fooling yourself, read flame graphs and flight recordings, and know the pitfalls that quietly cost throughput. Performance is a discipline of evidence, not a collection of folklore.
15. Part XV · Native Interop & Acceleration Reaching beyond the JVM — call C without JNI's pain, exploit SIMD lanes, and weigh native images and value types. The Panama and Valhalla frontier, where Java meets the machine for raw speed.
16. Part XVI · Modules, Build & Packaging From source to shippable artifact — strong encapsulation with modules, reproducible builds with Maven and Gradle, and lean runtimes with jlink and jpackage. How real Java ships , from module graph to container image.
17. Part XVII · Testing, Quality & Correctness Confidence you can ship — the testing pyramid, doubles and mocks, property-based and mutation testing, and the static analysis that catches bugs before they run. Quality is built in , not inspected in.
18. Part XVIII · Design, Architecture & Patterns Designing software that survives change — SOLID and composition, the patterns modern Java makes obsolete, hexagonal boundaries, and the art of the trade-off . Where a staff engineer earns their title: decisions, not just code.
19. Part XIX · Java in Production: Frameworks & Services How Java actually runs the world — the framework landscape, persistence and transactions, messaging and resilience, observability and deployment. The ecosystem a staff engineer must navigate to ship real services.
20. Part XX · Security, Reliability & the Staff Dimension The non-functional concerns that decide whether a system survives contact with the real world — defensive security, reliability under failure, and the human craft of operating as a staff engineer: influence , decisions, and leading change.
21. Part XXI · Capstone & Reference Everything, brought together — a JDK-only concurrent service built from the ground up, a Part-by-Part skills map, master cheat sheets, the canon, and the landmark JEPs. From foundations to mastery, in one running program and one reference shelf.