Java — Advanced
Understand Java deeply enough to optimize, secure, and operate it: the object and memory model, bytecode, reflection-driven design, the Java Memory Model, lock-free concurrency, virtual threads, GC and performance method, high-performance I/O, real loopback networking, persistence and distribution concepts, security, observability, and a production-grade capstone.
Who this course is for
Learners who finished Java — Intermediate and want JVM-level understanding: why Java behaves the way it does under load, concurrency, and failure — and how to engineer around it.
What you will be able to do
- Explain and exploit Java's object model: initialization order, identity, records, sealed types
- Read and reason about bytecode, constant pools, and compiler-generated constructs
- Design type-safe generic APIs with variance, capture, and recursive bounds
- Build metadata-driven systems with runtime annotations and reflection (a real mini DI container)
- Apply the Java Memory Model: happens-before, volatile, safe publication, final-field semantics
- Diagnose and fix races with locks, conditions, atomics, and CAS (including ABA)
- Scale I/O-bound work with virtual threads and know when they do not help
- Reason about allocation, reachability, and GC behavior; use weak references deliberately
- Profile-by-reasoning with measurement discipline: warmup, JIT, and noise awareness
- Implement advanced structures: tries, union-find, heaps, graph algorithms
- Write real TCP clients/servers over loopback with correct framing and timeouts
- Process files with NIO.2 channels and buffers, including memory-mapped reads
- Design transactional persistence with isolation levels and optimistic concurrency
- Apply distributed-systems primitives: idempotency, retries with backoff, circuit breaking
- Harden code: password hashing, secure randomness, input validation, SSRF/path-traversal defense
- Instrument services with structured logs, metrics, and health checks; run graceful shutdown
- Ship a production-grade capstone integrating every layer of the course
The Advanced Object Model
Initialization order observed, records/sealed as algebraic design tools, and aliasing control at every boundary.
JVM Architecture & Bytecode
Runtime data areas, class-initialization triggers, constant-pool identity, boxing caches, synthetic members, and stack frames.
The Java Memory Model
Happens-before edges, volatile semantics, safe publication, and latch-choreographed determinism instead of timing luck.
Locks, Conditions & CAS
ReentrantLock's superpowers, per-predicate Condition queues, ConcurrentHashMap's atomic compute family, and CAS with ABA.
Executors & Virtual Threads
Executor lifecycle, CompletableFuture composition, virtual threads verified in-sandbox, pinning, and when VTs do not help.
Generics & the Type System
Erasure vs reified arrays, wildcard capture, recursive self-types, and Class-token APIs.
Reflection & the Mini-DI Container
Class metadata, runtime annotations, and a dependency-injection container built from the JDK alone.
Memory, GC & Runtime Internals
Reachability observed through its effects, allocation identity, and a GC-backed TTL cache.
Performance Measurement
nanoTime and warmup discipline, bounded bytecode claims, and an honest micro-benchmark harness.
Files & NIO
Path arithmetic, tree walking with globs, atomic moves, explicit charsets, and a JSONL journal.
Sockets & the Wire
Loopback TCP: streams without boundaries, framing, timeouts, half-close, and a KV protocol.
Async & Deadlines
Injected executors, exception-combinators, time-bounded futures, and deadline-scoped fan-outs.
Security & Threat Modeling
Canonicalization, constant-time auth, allowlists, least privilege, and threat models you can argue with.
Observability & Diagnosis
Structured logs, request context, metric primitives, and incident triage as pure functions.
Capstone: The Ledger Service
Pluggable storage engines, an append-only JSONL truth, and byte-identical polymorphic reports.