00 - What "intermediate" means¶
What this session is¶
Ten minutes. The map for this path: what changes between beginner and intermediate, what we'll cover, and how to get the most out of it.
The shift¶
Beginner Java is about syntax and "does it run." You learned what a class is, how a loop works, how to catch an exception. The question was always: how do I make the compiler accept this and produce the right output?
Intermediate Java is about judgment and "is this good." The syntax is settled. Now the questions are different:
- There are five ways to do this. Which is right, and why?
- This works on my machine with one user. Does it still work with a thousand users hitting it at once?
- This is correct. Is it fast enough, and if not, where's the cost?
- This class works. Will the next person who reads it understand it, or curse my name?
Nobody writes good Java by accident. Every senior engineer you admire learned the judgment in this path the hard way - by shipping something, watching it break or slow down or confuse a teammate, and learning the rule behind the mistake. This path gives you the rules without requiring the full set of scars.
The three things that separate intermediate from beginner¶
1. Design judgment¶
A beginner makes a class because they need to group some data. An intermediate engineer asks: should this be a class or a record? Should it use inheritance or composition? Should this method take a concrete type or an interface? These choices compound. Get them right and your code stays flexible for years; get them wrong and every change fights you.
Chapters 01–07 are about design judgment.
2. Concurrency¶
This is the big one, and it's almost entirely absent from beginner Java. The moment your code runs on a server handling many requests at once - which is most real Java - you're writing concurrent code, whether you meant to or not. Concurrency bugs are the worst kind: they appear randomly, vanish when you look closely, and pass every test until production. You can't be a competent Java engineer without understanding threads, shared state, and the tools for managing them.
Chapters 09–11 are about concurrency. They're the heart of this path.
3. Performance awareness¶
Not premature optimization - awareness. Knowing that a String concatenation in a loop allocates a new object every iteration. Knowing that autoboxing an int into an Integer a million times has a cost. Knowing how to find the actual hot spot with a profiler instead of guessing. You won't optimize most code - but you'll recognize the 5% that matters and you'll have the tools to fix it.
Chapters 08, 12, and 13 are about performance awareness.
What this path is not¶
- Not JVM internals. We'll talk about the garbage collector enough to write GC-friendly code, but we won't dissect G1's remembered sets or ZGC's colored pointers. That's Java Mastery.
- Not a framework course. No Spring, no Hibernate as protagonists. We use the standard library so the concepts transfer. Frameworks are easier once the fundamentals are solid.
- Not exhaustive. Java is vast. This path covers the intermediate concepts you'll use weekly, not every corner of the language.
How to use this path¶
- Do the exercises. Even more than in the beginner path. Concurrency especially cannot be learned by reading - you have to run code, see it race, and fix it.
- Use the race detector mindset. From chapter 09 on, get in the habit of asking "what if two threads ran this at the same time?" of every piece of shared state.
- Read real code alongside. Pick a small, well-regarded Java library (we'll suggest some). When a chapter teaches a concept, find it in the wild.
- Don't rush the concurrency chapters. 09–11 are worth a week each. They're the difference between "writes Java" and "writes Java that survives production."
A note on Java versions¶
This path targets Java 21+ (the current LTS as you read this is 21 or 25). Where a feature is newer - virtual threads (21), structured concurrency, scoped values - it's flagged. If you're on an older JDK at work (Java 8 and 11 are still everywhere), the design and concurrency concepts all transfer; only some syntax and a few APIs differ. We note the important gaps.
What you might wonder¶
"I haven't finished From Scratch. Can I start here?" If you can write a class with fields and methods, use a List and a Map, write a try/catch, and define a generic method - yes. If any of those made you pause, do the relevant From Scratch chapters first. This path moves fast through anything From Scratch covered.
"Is concurrency really that important?" Yes. Almost every Java job involves servers handling concurrent requests. The frameworks hide some of it, but the moment you have shared mutable state - a cache, a counter, a connection pool - you're responsible for thread safety. It's the single most common source of "senior" Java interview questions and production incidents.
"Will this make me job-ready?" This plus From Scratch gets you to "competent mid-level Java engineer who can be trusted with real features." Mastery is for the senior/staff tier. Most working Java engineers operate at the level this path teaches.
Done¶
- You know the beginner → intermediate shift: from syntax to judgment.
- You know the three pillars: design, concurrency, performance.
- You know how to use the path: do the exercises, especially the concurrency ones.