[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.

  1. Fundamentals — syntax, types, variables, operators, strings, arrays, control flow, packages, access modifiers, static/final, pass-by-value, null, BigDecimal
  2. OOP — classes/objects, the four pillars, inheritance, interfaces vs abstract classes, overloading/overriding, static vs dynamic binding, nested classes, equals/hashCode
  3. Generics — type parameters, bounded types, wildcards, type erasure
  4. Collections — List/Set/Map/Queue/Deque, implementation tradeoffs + Big-O, Iterator, Comparable/Comparator
  5. Functional Programming — functional interfaces, lambdas, method references, the Stream API, higher-order functions, Optional
  6. Exceptions — checked vs unchecked, the hierarchy, custom exceptions, try-with-resources
  7. Modern Java — records, sealed classes, pattern matching, var, text blocks, switch expressions
  8. 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.

  1. JVM Internals — class loading, bytecode, JIT, memory areas, garbage collection, tuning
  2. Concurrency — threads, the memory model, java.util.concurrent, locks, atomics/CAS, shutdown
  3. Virtual Threads — Project Loom, structured concurrency
  • Exercises — unsolved, runnable reps (bounded blocking queue, token-bucket rate limiter)

03 — Tooling

Building, wiring, testing, and observing.

  1. Build Tools — Maven, Gradle, Bazel, the wrapper, project structure
  2. Dependency Injection — IoC, DI styles, Spring’s container
  3. Lombok & Builders — @Data/@Builder, DTOs, the builder pattern
  4. Testing — JUnit, Mockito, and the TestNG/Cucumber/REST Assured/JMeter landscape
  5. Logging & Observability — SLF4J, Logback, Log4j2, the log-table pattern, metrics

04 — Persistence

  1. JDBC & Data Modeling — HikariCP, Flyway, SQL, primary-key design, normalization
  2. 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.

  1. Spring Boot — DI, the controller/service layering, validation, @Async, @Scheduled
  2. Web Frameworks — the Spring/Quarkus/Javalin/Play landscape
  3. 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.

  1. Messaging with RabbitMQ — queues, DLQs, backpressure, competing consumers
  2. ID Generation & Idempotency — collision math, UUID/Snowflake/ULID, idempotent pipelines
  3. Batch Processing & Performance — streaming vs batching, JDBC batch inserts, bulk-load tuning
  4. Docker for Java Apps — multi-stage builds, dev compose, resource limits
↑ Back to Languages