TL;DR: I’m restarting my Java journey — but this time with a phased, deliberate roadmap instead of just picking up where I left off. Here’s the plan: seven core disciplines I’m rebuilding from the ground up — syntax and core APIs, design patterns, Spring Boot and microservices, JVM internals and performance tuning, concurrency and parallelism, modern language features, and cloud-native architecture — followed by three phases that turn the learning into something real and provable.
Generated AI image by Google Gemini Nano Banana
Introduction
My last post here was a tribute to The Java Story documentary — a trip back to my university days and the pioneers who shaped the language I first fell in love with. Writing it did something I didn’t expect: it left me wanting to build in Java again, this time with career capital behind it instead of academic capital.
That pull needed somewhere to go, so I went looking for what “building in Java again” should actually mean in 2026. That’s how I ended up watching Richard Fichtner’s JavaOne 2026 talk, “How to (Re)start Your Java Journey in 2026.” Fichtner is a Java Champion and JUG leader who’s been in the ecosystem for over 20 years, and his session was built for exactly the audience I fall into: not brand new to Java, but returning after a stretch away and needing to modernize the mental model, not just the muscle memory (see Youtube thumbnail below)
That framing landed hard. I’ve spent 20+ years as a polyglot engineer — Java, Python, TypeScript/Node, Go, Ruby — and some of my most production-critical work has been in Java microservices in enterprise environments, including designing and building the CI/CD pipelines and ETL application for a real-time payments platform rails. But over the last couple of years, my day-to-day gravity shifted toward other stacks. Java didn’t leave my toolkit, but it stopped being where I was pushing hardest.
So this isn’t a “brush up on syntax” post, and it isn’t nostalgia either — that was the last one. This is the actual roadmap I’m using to turn “I want to build in Java again” into something with a bigger trajectory than before, and I’m publishing it so I can hold myself to it.
Why “Restart,” Not “Return”
The instinct when picking a language back up is to assume it’s mostly the same, just with a few new keywords. Java in 2026 doesn’t reward that assumption — LTS releases, language features, frameworks, and runtime behavior have all moved since I was last deep in the language. Treating this as a light refresh would leave real gaps. That’s the gap this roadmap is built to close, discipline by discipline.
One honest note before the list: I’m working from Fichtner’s session description, not a full transcript, so where I say a topic is “in the talk” I mean it’s named in the official synopsis — build and testing tools, modern frameworks, deployment platforms, performance-tuned runtimes, and cloud-native development are the themes Oracle published going in. Some of what I need is in there. Some of it isn’t, and that’s fine — the talk was the trigger for this roadmap, not the ceiling on it.
The Roadmap: Nine Disciplines, Three Delivery Phases
| # | Discipline | Target | Where it comes from |
|---|---|---|---|
| 1 | Refresh syntax & core APIs | Collections, streams, generics, exception handling | Not in the talk’s synopsis — mine to own |
| 2 | Design patterns: structural & behavioural | GoF patterns, read through a modern Java lens | Not in the talk’s synopsis — mine to own |
| 3 | Spring Boot & microservices | Idiomatic Spring Boot, service boundaries, observability | Matches “modern frameworks” in the synopsis |
| 4 | JVM internals & performance tuning | Generational ZGC, JFR profiling, heap/startup tuning | Matches “performance-tuned runtimes” in the synopsis |
| 5 | Concurrency & parallelism | Virtual threads, structured concurrency, scoped values | Runtime-adjacent, but not named directly — mine to own |
| 6 | Modern Java features | Records, sealed classes, pattern matching for switch | Not in the talk’s synopsis — mine to own |
| 7 | Cloud-native development & architecture | GraalVM native image, containerization, deployment platforms | Named directly in the synopsis |
| 8 | AI-native Java | Spring AI / LangChain4j on top of my existing RAG experience | Named directly in the synopsis |
| 9 | Capstone project | A payments-domain project proving disciplines 1–8 together | Beyond the talk — mine to own |
1 — Refresh syntax & core APIs. Before anything else, the unglamorous work: collections, streams, generics, exception handling, var, text blocks, current Maven/Gradle conventions. The fastest way to slow down every phase after this one is to still be guessing at API names while trying to learn a framework on top of them. Fichtner’s talk doesn’t dwell here — it’s aimed at people navigating the ecosystem, not relearning the language — which is exactly why I’m not skipping it.
2 — Design patterns: structural & behavioural. Revisiting the GoF structural patterns (Adapter, Decorator, Facade, Composite, Proxy) and behavioural patterns (Strategy, Observer, Command, Template Method, Visitor) — not as museum pieces, but through what modern Java now does natively. Sealed classes plus exhaustive pattern matching largely replace the classic Visitor pattern. Lambdas collapse most single-method Strategy implementations down to a one-liner. Records simplify a lot of what Builder and Value Object existed to solve. I want both forms cold: the classic shape, because legacy codebases and interview panels still expect it, and the modern equivalent, because that’s what I’ll actually be writing.
3 — Spring Boot & microservices. Current idiomatic Spring Boot — configuration, dependency injection conventions, service boundaries, observability via Actuator, structured logging, and distributed tracing — plus Testcontainers-based integration testing so services get tested against real dependencies instead of mocks. This is the closest match to what Fichtner’s synopsis calls “modern frameworks,” even though Spring Boot isn’t named directly.
4 — JVM internals & performance tuning. Generational ZGC behaviour, JFR (Java Flight Recorder) profiling, heap and startup tuning, and reading a thread dump or flame graph without guessing. “Performance-tuned runtimes” is called out explicitly in the talk’s synopsis — this is where I expect the talk to actually pay off.
5 — Concurrency & parallelism. This is the phase I’m most confident is overdue. Virtual threads, introduced in JDK 21, had a well-known pinning limitation around synchronized blocks that was substantially fixed in JDK 24. Structured Concurrency and Scoped Values — long-running previews since JDK 21 — are now finalized in JDK 25, the current LTS release since September 2025. That means JDK 25 is the first LTS where virtual threads behave the way the original pitch promised, and where I have a real answer to ThreadLocal instead of reaching for it out of habit.
6 — Modern Java features. Records, sealed classes, and pattern matching for switch — how they combine to make illegal states genuinely unrepresentable and cut boilerplate that used to need a pattern (see discipline 2) to work around. Not named in the talk’s synopsis, but non-negotiable for writing Java that looks like it was written in 2026 rather than 2016.
7 — Cloud-native development & architecture. GraalVM native image compilation, containerization, and deployment platforms — fast startup, low memory footprint, the economics that actually matter for cloud-native Java. This one’s named directly in the talk’s synopsis alongside AI integration and sustainable computing.
8 — AI-native Java. Not on the list I was asked to prioritise, but too relevant to drop: bringing my existing RAG and agentic-workflow experience from other stacks into the JVM ecosystem via Spring AI or LangChain4j, rather than learning AI integration and Java at the same time.
9 — Capstone project. Theory doesn’t survive contact with a real system. My capstone is a payments-domain simulation — leaning into the same problem space as my earlier production work — built using disciplines 1 through 8 together: virtual threads under load, structured concurrency for orchestrating downstream calls, and an AI-assisted layer for anomaly triage.
Do’s and Don’ts for a Deliberate Restart
Do:
- Sequence deliberately — syntax and patterns before frameworks, runtime model before architecture. Each discipline assumes the one before it.
- Build something with real constraints — a toy CRUD app won’t surface the problems a capstone project will.
- Timebox each discipline — an open-ended “get back into Java” goal never finishes.
Don’t:
- Don’t assume your old Java is current Java — patterns and habits that were best practice five years ago (heavy
ThreadLocaluse, manual thread-pool tuning, GoF patterns applied where a record now does the job) have modern replacements. - Don’t let the talk’s agenda define your whole plan — mine covers three disciplines a conference session was never going to include.
- Don’t treat AI integration as a bolt-on — if it’s part of your target architecture, design for it from discipline 3 onward, not as an afterthought at the capstone.
Conclusion
Watching one conference talk isn’t what’s driving this — it’s the prompt that made me turn “I should get back into Java” into an actual plan with phases and a capstone at the end of it. Java in 2026 is a genuinely different platform from the one I left several years ago, and treating this as a real restart rather than a refresh is the only way the trajectory ends up bigger than before.
Next steps for me:
- Work through disciplines 1 and 2 — syntax/core APIs and design patterns — and ship a short code sample from each to my pet project Java repo hosted on GitHub
- Get a Spring Boot service running against Testcontainers, then a GraalVM native image build on top of it
- Post a follow-up once I can turn my pet project into the capstone project and have a working first slice
If you’re a senior engineer sitting on your own “I should get back into X” list, I’d genuinely like to hear how you’re structuring it — drop a comment or reach out.
Till next time, Happy Coding!
PS: This post is also applicable for junior developers who are looking in to starting their career or interested in Java, but don’t know where to start. So please feel free to encourage yourself to start your Java journey by following this roadmap, if you’re reading this!