Advanced Java Backend

• Explain heap, stack, GC and class loading with a simple diagram and draw first conclusions from a heap dump
• Choose between executors, CompletableFuture and virtual threads for a given problem and justify the choice
• Reproduce a race condition or deadlock with a test and a thread dump, then fix it
• Find N+1, lazy loading and transaction-boundary problems and resolve them at the JPA/SQL level
• Read an EXPLAIN plan and justify an index or query change with measurements
• Build a sensible test strategy made of unit, slice and integration tests
• Diagnose a production-like performance problem with logs, metrics and a profiler
• Present a Pull Request and review someone else's constructively

No education program can guarantee employment or a promotion.

1. 01

   The JVM and memory

   How the JVM manages code and memory, and how to investigate memory problems with measurements.

   • Heap, stack, metaspace and object lifetime
   • Garbage collectors (G1, ZGC) and the notion of pauses
   • Class loading and JIT compilation
   • Reading heap dumps and GC logs
   • Typical leak sources (caches, listeners, ThreadLocal)

   Hands-on lab: Analyse a service with a deliberate memory leak using a heap dump, locate the source and fix it.

2. 02

   Concurrency and virtual threads

   From the Java Memory Model to virtual threads: writing parallel code that is correct and safe.

   • Java Memory Model, happens-before and visibility
   • synchronized, Lock, atomics and concurrent collections
   • ExecutorService, CompletableFuture and structured concurrency
   • Virtual threads: when they help, and the pinning problem
   • Diagnosing deadlock, livelock and starvation
   • Reading thread dumps

   Hands-on lab: Create a race condition in code that updates a shared balance, reproduce it with a test, then fix it in two different ways and compare.

3. 03

   JPA and Hibernate in depth

   Safe work with JPA requires knowing how the persistence context, flush and lazy loading actually behave.

   • Persistence context, dirty checking and flush modes
   • Lazy versus eager loading and the N+1 problem
   • Fetch joins, entity graphs and projections
   • Batch insert/update and optimistic locking
   • Transaction boundaries and the causes of LazyInitializationException

   Hands-on lab: Measure an endpoint with an N+1 problem through SQL logs, fix it in three different ways and compare query counts.

4. 04

   SQL and query performance

   Finding out why a query is slow from its plan and choosing the right index.

   • Reading EXPLAIN / EXPLAIN ANALYZE
   • B-tree indexes, composite indexes and column order
   • Covering indexes and selectivity
   • Pagination: offset versus keyset
   • Isolation levels and locking behaviour

   Hands-on lab: Analyse a slow query on a large table with its plan, add an index, and present before/after measurements in a written note.

5. 05

   Testing strategy

   Deciding what to test at which level so that tests stay cheap and trustworthy.

   • The test pyramid and its limits
   • JUnit 5, Mockito and the over-use of mocks
   • Integration tests against a real database with Testcontainers
   • Slice tests (@DataJpaTest, @WebMvcTest)
   • Causes of flaky tests and how to remove them

   Hands-on lab: Write a test strategy document for an existing service and add a Testcontainers integration test for its critical flow.

6. 06

   Clean code in a growing codebase

   Managing structure, naming and dependencies as a codebase grows.

   • Package structure and dependency rules between layers
   • Separating the domain model from service code
   • Refactoring techniques and test-protected change
   • Designing exceptions and an error model
   • Making technical debt visible

   Hands-on lab: Split a complex service class into small parts with clear responsibilities while keeping the tests green.

7. 07

   Diagnosing production-like problems

   A systematic approach to slowness, memory growth and quiet failures.

   • Structured logging and correlation IDs
   • Micrometer metrics and the key signals
   • Reading profilers and flame graphs
   • Connection pool exhaustion and thread pool saturation
   • A hypothesis-driven diagnosis method

   Hands-on lab: Diagnose a deliberately broken service (pool exhaustion, slow query) using only logs, metrics and a profiler, and write up a postmortem.

8. 08

   Code review practice

   Review is both a skill and a team habit; we practise it from both sides.

   • Preparing small, well-explained Pull Requests
   • A review checklist: correctness, readability, tests, risk
   • Writing constructive feedback and responding to it
   • Security and performance signals in review

   Hands-on lab: Review a given Pull Request in writing, then answer the comments on your own Pull Request with reasoned replies.

Articles related to this program

• Java CoreChoosing the right Java collection
• Advanced JavaJava concurrency basics
• Java CoreThe equals and hashCode contract in Java
• Java CoreDesigning exceptions in Java services
• Advanced JavaJava memory and garbage collection for service developers
• Java CoreJava streams: readable pipelines and common pitfalls