Saltar a contenido

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.

Repository Layout

File Purpose
00_PRELUDE_AND_PHILOSOPHY.md The "Java-ness" of Java; the JVM-as-platform mindset; the cost model; reading list.
01_MONTH_LANGUAGE_AND_TOOLCHAIN.md Weeks 1–4. Modern syntax, records, sealed types, pattern matching, build tools, JPMS, JUnit 5.
02_MONTH_JVM_AND_BYTECODE.md Weeks 5–8. Class loading, bytecode, tiered JIT (C1/C2/Graal), AOT (Leyden), GraalVM native-image.
03_MONTH_MEMORY_AND_GC.md Weeks 9–12. Heap layout, compact object headers, G1, ZGC (generational), Shenandoah, JFR-driven tuning.
04_MONTH_CONCURRENCY_AND_LOOM.md Weeks 13–16. JMM, java.util.concurrent, virtual threads, structured concurrency, scoped values, VarHandle.
05_MONTH_PRODUCTION_DISTRIBUTED.md Weeks 17–20. Spring Boot 3 / Quarkus, Micrometer + OpenTelemetry, gRPC, resilience, hardened testing.
06_MONTH_CAPSTONE.md Weeks 21–24. Consensus, distributed storage, perf tuning, capstone defense.
APPENDIX_A_PRODUCTION_HARDENING.md jcmd, JFR, async-profiler, heap dumps, JMH, GC logs, container-aware flags.
APPENDIX_B_LEGACY_JAVA.md The sediment: Vector/Hashtable, Date/Calendar, raw types, Thread-spawning, finalize, JNI, JUnit 4, J2EE → Jakarta, removed features.
APPENDIX_C_CONTRIBUTING_TO_OPENJDK.md JBS, mailing lists, jcheck, Skara, webrev, first-patch playbook.
CAPSTONE_PROJECTS.md Three terminal projects: Raft KV store on virtual threads, gRPC mesh, streaming pipeline.

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.

Details in CAPSTONE_PROJECTS.md.

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. APPENDIX_B_LEGACY_JAVA.md is not optional - it is the field guide for the sediment.

Print this path

Want to read offline or archive? Open the printable version - every section of this path concatenated into one page, styled for paper. Use your browser's Print → Save as PDF.

Worked examples

Concrete walkthroughs that pair with the senior weeks - real code, narrated line by line, with the trap and an exercise. Different shape than the syllabus chapters; designed to be read after (or before) the matching week.