Java Mastery Blueprint - A 24-Week Master-Level Syllabus¶

Authoring lens: Senior Staff Software Engineer / JVM Performance Architect. Target outcome: A graduate of this curriculum should be capable of (a) submitting non-trivial PRs against the OpenJDK (HotSpot, javac, or java.base), (b) owning a high-throughput JVM-based platform (Kafka-class, Cassandra-class, or a Spring/Quarkus control plane), or (c) operating a hyperscale fleet of JVM services with a coherent GC, JFR, and observability story.

This is not "Java in 24 Hours" stretched to weeks. It assumes the reader can already write a working program in some language. The premise: most Java bugs at scale are not language bugs - they are JIT, GC, classloader, and memory-model bugs in disguise, plus an industrial sediment of pre-Java-8 idioms still living in production. This curriculum surfaces all of those.

What you'll learn¶

A 24-week curriculum organized into six monthly modules, plus three reference appendices and a capstone catalog at the end.

How Each Week Is Structured¶

Every weekly module follows the same five-section format:

1. Conceptual Core - the why, with a mental model.
2. Mechanical Detail - the how, down to JVM source where relevant (hotspot/share/runtime/, hotspot/share/gc/, java.base/share/classes/).
3. Lab - a hands-on exercise that cannot be completed without internalizing the concept.
4. Idiomatic & Static-Analysis Drill - read 2–3 SpotBugs/ErrorProne/IntelliJ-inspection rules, refactor a sample to silence them, understand why each lint exists.
5. Production Hardening Slice - a JFR / jcmd / async-profiler / JMH micro-task that compounds into a publishable hardening template.

Each week is sized for ~12–16 focused hours. Skip the labs at your peril.

Progression Strategy¶

The phases form a dependency DAG, not a linear track:

Language & Toolchain ──► JVM & Bytecode ──► Memory & GC ──► Concurrency & Loom
        │                      │                  │                  │
        └──────────────────────┴────────┬─────────┴──────────────────┘
                                        ▼
                         Production & Distributed Systems
                                        │
                                        ▼
                              Capstone & Defense

The Production Hardening slice is intentionally orthogonal - it accumulates a hardening/ template that, by week 24, is a publishable JVM service starter (JFR profile, GC log parser, container-aware flags, k8s manifest, OpenTelemetry wiring).

Non-Goals¶

• This curriculum does not make Spring the protagonist. Spring Boot 3 and Quarkus appear in Month 5 as integration surfaces; java.net.http, jdk.httpserver, and the JDK's HTTP/2 client are sufficient through Month 4.
• Android Java is out of scope; the JVM here is HotSpot/GraalVM on the server, not ART on a phone.
• "Why Java is better than X" advocacy is explicitly avoided. The reader should finish the program able to argue against using Java when it is the wrong tool (cold-start-sensitive serverless without native-image; embedded/real-time without Azul Zing-class tooling; small CLIs where Go or Rust dominate).

Capstone Tracks (pick one in Month 6)¶

1. Distributed Storage Track - a Raft-replicated key-value store built on virtual threads with structured concurrency, linearizable reads, snapshot/restore, multi-region demo.
2. Service Mesh Track - a gRPC microservices mesh with a custom service registry, health checking, deadline propagation, outlier ejection, and OpenTelemetry spans end-to-end.
3. Streaming Pipeline Track - a Kafka-protocol-compatible ingestion + stream-processing pipeline with at-least-once delivery, replay, and JFR-driven backpressure tuning.

Detailed track briefs are in the capstone catalog.

Versioning Note¶

This curriculum targets Java 25 LTS as the baseline. By 25 LTS, the following are stable (no longer preview/incubator):

• Virtual threads (final since 21), structured concurrency (final by 25), scoped values (final by 25).
• Pattern matching for switch, record patterns, unnamed patterns/variables.
• Sealed classes, records, text blocks, var, switch expressions.
• Generational ZGC (default since 23+), ZGC as a first-class GC.
• The Class-File API (JEP 484) replacing internal ASM usage.
• The Foreign Function & Memory API (Panama) - replaces JNI for almost all new work.
• The Vector API (still incubating through 25 - flagged as such in Month 2).
• Compact object headers (JEP 450, stable by 24/25) - material to Month 3 sizing math.

Preview/incubator in the 25 timeframe (flagged when used): Vector API, Stable Values, Valhalla value classes (still preview at 25 - treat as "the future you should know about", not the daily driver).

Do not start this curriculum on a JDK older than 21 - too many of the modern idioms (virtual threads, pattern matching, records-as-DTOs, sealed hierarchies) will be unavailable, and you will accidentally learn 2014-era Java.

Legacy reality check: roughly half the Java code you will be paid to maintain is Java 8 or 11. The Legacy Java appendix is not optional - it is the field guide for the sediment.

Get started¶

Ready to begin? Start with the Prelude — philosophy, the mental model, and the reading list — then work Month 1 forward. The labs are the unit of mastery: do them.