[Beginner → Advanced] — the language, the JVM, and the backend ecosystem built on top of it. Part of the languages course.
The reading order runs top to bottom through six themed sections: the language itself → how it runs (JVM + concurrency) → the tooling around it → persistence → web/API → applied systems built from real projects.
Where the content comes from
Two threads run through this domain, and it’s worth being honest about which is which:
- Project-grounded notes are distilled from two things actually built during SIWES @ IT Consortium: a Spring Boot payment sandbox (
direct-debit-sandbox-java) and a high-throughput CSV→MySQL pipeline over RabbitMQ (record-id-generator-java). These carry a Source line and real code. The full project-embedded originals (with debugging narratives this domain trims) still live under record-id-generator-java/learning/ and direct-debit-sandbox-java/learning/. - Reference notes fill the roadmap.sh Java topics the two projects never exercised (generics, the collections framework, GC internals, testing, ORM, virtual threads, …). These are marked [reference — not yet exercised] where honest, and tied back to project code wherever the link is genuine rather than forced. Reading about them is not the same as having reps — see the concurrency exercises for where that distinction bites.
Sections
01 — Language
The language itself, beginner to fluent.
- Fundamentals — syntax, types, variables, operators, strings, arrays, control flow, packages, access modifiers,
static/final, pass-by-value,null,BigDecimal - OOP — classes/objects, the four pillars, inheritance, interfaces vs abstract classes, overloading/overriding, static vs dynamic binding, nested classes,
equals/hashCode - Generics — type parameters, bounded types, wildcards, type erasure
- Collections —
List/Set/Map/Queue/Deque, implementation tradeoffs + Big-O,Iterator,Comparable/Comparator - Functional Programming — functional interfaces, lambdas, method references, the Stream API, higher-order functions,
Optional - Exceptions — checked vs unchecked, the hierarchy, custom exceptions, try-with-resources
- Modern Java — records, sealed classes, pattern matching,
var, text blocks, switch expressions - Core APIs — date/time, regex, IO/NIO, files, networking, modules, annotations, cryptography
02 — JVM & Concurrency
How Java actually runs — the section that matters most for a low-latency/systems target.
- JVM Internals — class loading, bytecode, JIT, memory areas, garbage collection, tuning
- Concurrency — threads, the memory model,
java.util.concurrent, locks, atomics/CAS, shutdown - Virtual Threads — Project Loom, structured concurrency
- Exercises — unsolved, runnable reps (bounded blocking queue, token-bucket rate limiter)
03 — Tooling
Building, wiring, testing, and observing.
- Build Tools — Maven, Gradle, Bazel, the wrapper, project structure
- Dependency Injection — IoC, DI styles, Spring’s container
- Lombok & Builders —
@Data/@Builder, DTOs, the builder pattern - Testing — JUnit, Mockito, and the TestNG/Cucumber/REST Assured/JMeter landscape
- Logging & Observability — SLF4J, Logback, Log4j2, the log-table pattern, metrics
04 — Persistence
- JDBC & Data Modeling — HikariCP, Flyway, SQL, primary-key design, normalization
- ORM: JPA & Hibernate — JPA, Hibernate, Spring Data JPA, Ebean
05 — Web & API → moved to backend/frameworks/java/
These three notes were moved, not duplicated — languages/ teaches the language, backend/frameworks/ teaches the frameworks built on it. Signpost page.
- Spring Boot — DI, the controller/service layering, validation,
@Async,@Scheduled - Web Frameworks — the Spring/Quarkus/Javalin/Play landscape
- API Design & Documentation — RestTemplate, config-resolution patterns, OpenAPI/springdoc
06 — Applied Systems
The project-grounded high-throughput work — the strongest “real engineering” signal in the domain.
- Messaging with RabbitMQ — queues, DLQs, backpressure, competing consumers
- ID Generation & Idempotency — collision math, UUID/Snowflake/ULID, idempotent pipelines
- Batch Processing & Performance — streaming vs batching, JDBC batch inserts, bulk-load tuning
- Docker for Java Apps — multi-stage builds, dev compose, resource limits
Related
- languages course map
- backend — the Node.js/Express/Nest equivalent
- DSA — language-agnostic algorithms behind collections
- design patterns
- Docker
Software engineering
Infrastructure & security
Computer science
Hardware & engineering