Premium add-onComing soon
Advanced Java Memory & Performance Engineering
Have an edge in interviews. Stand out from the crowd. SDE II → Staff
Deep dives into JVM internals, heap-dump forensics, GC-log analysis, profiling and production troubleshooting. The depth senior Java interviews look for, from SDE II to Staff.
- 8 in-depth sectionsA structured path, in order
- 54 planned topicsDrawn from real production issues
- Interview edgePitched at SDE II to Staff
- Curated referencesJDK docs plus HeapHero, Datadog, New Relic
Course overview
The core Java course gets you interview-ready: you can explain the heap, garbage collection, heap dumps and thread dumps, and you know where to start when memory misbehaves.
This track picks up where that stops. We take real evidence (heap dumps, GC logs, thread dumps, flame graphs, container metrics) and reason through it the way you would during an incident, then turn that reasoning into answers that sound like someone who has been on call.
- Go beyond surface-level answersExplain the why behind GC behaviour, memory retention and JVM performance, with diagrams and annotated output.
- Reason through real debugging scenariosRead heap dumps, thread dumps, GC logs and profiler output, and say what the evidence does and does not prove.
- Master the diagnostic toolboxjcmd, JFR, async-profiler, Eclipse MAT, Native Memory Tracking and GC logs, each with a safe, version-aware workflow.
- Build senior-level technical depthConnect JVM internals to latency, throughput, reliability and the trade-offs you weigh in production.
Course curriculum
8 sections · 54 topics · planned
01OutOfMemoryError deep diveEvery kind of OOM, what causes it, which evidence it leaves and how to fix it.
- Java heap space vs GC overhead limit exceeded
- Metaspace and compressed class space
- Direct buffer memory
- Unable to create native thread
- StackOverflowError
- Container OOM kills vs JVM OOMs
- Why raising -Xmx can make things worse
- Building an incident timeline
02Heap-dump forensicsCapture safely, then find what is holding the memory.
- Capture strategy, safety and storage
- Shallow vs retained size
- Dominator trees
- Paths to GC roots
- Comparing dumps over time
- OQL queries
- Working with very large dumps
- Leak vs high live set vs churn
03GC log forensics & collector behaviourRead the logs, understand the collector, tune against a measured goal.
- Unified logging with -Xlog:gc*
- Allocation rate and promotion pressure
- G1 regions, mixed collections and humongous objects
- ZGC and Shenandoah in practice
- Parallel GC and throughput
- Pause vs throughput trade-offs
- Tuning only after a baseline
04Native memory, off-heap & MetaspaceWhy the process is bigger than the heap, and where the rest goes.
- Heap vs RSS vs container limit
- Direct buffers and MaxDirectMemorySize
- Metaspace and class loading
- Thread stacks
- Native Memory Tracking and its limits
- JNI and native libraries
05Memory leak patterns in real servicesThe leaks that actually reach production, and how each one looks in a dump.
- Unbounded caches and maps
- ThreadLocal in thread pools
- Listeners and callbacks
- Static collections
- Classloader leaks on redeploy
- Long-lived request and session state
06Thread dumps & JVM failure diagnosisFrom one snapshot to a sequence that tells the story.
- Taking dump sequences safely
- Deadlocks and lock cycles
- Thread-pool starvation
- Lock contention and convoys
- Virtual thread pinning (Java 21)
- Blocking I/O hiding in plain sight
07Profiling & performance diagnosisMeasure first, then explain what the profile really says.
- JFR recordings and key events
- async-profiler: CPU, allocation, wall-clock and lock
- Reading and diffing flame graphs
- JMH and benchmark traps
- JIT, deoptimisation and the code cache
- Object layout and false sharing
08Production incidents & observabilitySymptom-led investigations that tie every signal together.
- Rising latency and high CPU
- Repeated GC and memory growth
- Intermittent 5xx and thread starvation
- Correlating metrics, logs, traces and dumps
- Examples with Datadog, New Relic and Splunk
- jcmd and jstat command handbook
- Case studies: evidence vs hypothesis
What you’ll learn
- Tell a heap leak from a high live set, allocation churn or a container memory limit, using evidence rather than guesses.
- Walk through a heap dump: dominators, retained size, paths to GC roots and comparing dumps over time.
- Read G1, ZGC and Parallel GC logs and explain allocation rate, promotion pressure and pause behaviour.
- Explain why the process uses more memory than -Xmx, and where the rest goes.
- Diagnose deadlocks, pool starvation and lock contention from a sequence of thread dumps.
- Profile with JFR and async-profiler, read flame graphs correctly and avoid common benchmark traps.
- Run a symptom-led investigation from rising latency or an OOM kill to a verified fix.
- Turn all of it into a calm, structured interview answer.
Who it’s for
- SDE II engineersPreparing for senior loops where “how would you debug this?” follows every JVM question.
- Senior engineers aiming for StaffWho need to show production judgement, not only definitions.
- Backend and on-call engineersWho want a calm, repeatable workflow the next time memory or latency goes wrong.
Best after Module 06 JVM Internals & Memory and Module 07 Java Performance Engineering of the core course. Those modules keep their introductory heap-dump, thread-dump and GC-log lessons.
Questions
Is this part of the Java Pass?
No. It is a separate, optional add-on. The Java Pass keeps everything it covers today, including the introductory heap-dump, thread-dump and GC-log lessons.
When does it open?
It is being written now. Press Notify me on the pricing page while signed in and we will email you the day it opens.
Do I need the core Java course first?
It helps. Each section assumes you know the JVM basics from Module 06 and Module 07. You do not need to finish every module.
Are there hands-on labs?
No labs or sandboxes. You get written walkthroughs, hand-drawn diagrams, annotated tool output, commands you can run yourself and real incident timelines.