DEV Community: Anh-Duc Nguyen

Why I'm Learning Java in 2026: The Boring Career Bet

Anh-Duc Nguyen — Wed, 05 Aug 2026 01:08:11 +0000

Java is the best trade-off between runtime performance, developer productivity, and maintainability.

That's Paul Bakker, a Netflix engineer, in a JavaOne 2026 talk called How Netflix Uses Java. Netflix serves hundreds of millions of people, and its backend runs on the JVM. Not because the company is stuck. It chose this, deliberately, year after year.

Meanwhile, every tech forum I open tells me Java is dead. Boring. Legacy. A language for old enterprise apps nobody wants to touch.

I'm a high school student in Vietnam who taught himself to code. I learned JavaScript, built a React Native app in three weeks, then got roasted on React fundamentals by an AI quiz that scored me 3/10. Since then I've been slowing down and learning the fundamentals I skipped.

Everything I've built lives in the "modern" ecosystem: React Native, Supabase, TypeScript. And in 2026, I decided to learn Java and Spring Boot anyway.

I'm not writing this as a Java evangelist. I had to be argued out of "Java is dead." Here's why.

Why I believed Java was dead

Let me steelman the "Java is dead" take, because I genuinely believed most of it:

Cold starts: 3-10 seconds, vs under a second for Node.
Boilerplate: more ceremony per feature than any modern framework.
Two languages: a Java backend means Java and JavaScript, instead of TypeScript everywhere.
"Everyone uses Next.js now."

And there's an honest data point against me: Java isn't even in the top 10 most-requested technologies in the German job listings for 2026. TypeScript is #1. If I picked a stack by raw listing counts, I'd stay in JS land.

I'm not. The Netflix talk is a big part of why.

The Netflix talk

Netflix can afford any stack in the world. And they use the modern stuff where it fits: Go for platform sidecars, JavaScript and Swift for mobile, Python for data science. Java is their backend default because, in their words, it's the best trade-off. Not the fastest at any one thing. The best balance of all three:

Runtime performance: the JVM is a runtime tuned for over 25 years, and Netflix runs it on Java 21 and 25. Performance you can trust is worth more than peak performance you have to babysit.
Developer productivity: the tooling is mature and you rarely rebuild infrastructure from scratch. Modern Java removed most of the old friction: records, sealed classes, pattern matching, virtual threads.
Maintainability: static types, explicit code, and code written a decade ago that still runs in production. This is the pillar that never shows up in "which language is hottest" polls, and the one that matters most over a career.

And here's the detail that sealed it for me: they're fully on Spring Boot 3 and migrating to Spring Boot 4 with Claude Code. The largest streaming service on the planet is doing its framework migration with the same AI-assisted workflow I use every day, on a framework people call legacy.

That flipped "Java is boring" into "Java is stable enough that 25 years of tooling is worth investing in."

What this means for me

Netflix's scale isn't my scale. But the reasoning transfers.

The market I'm actually aiming at

I'm planning to study computer science in Germany, likely in Dortmund, one of the most Java-dense enterprise markets in the country. adesso, one of Germany's largest IT-services companies, and Materna are headquartered there, surrounded by banks, insurers, and public-sector IT. German recruiters describe Java as "constant demand" in enterprise, and Bitkom counts 155,000 unfilled IT positions.

The honest version: Java isn't the most-listed technology. It's the deep, T-shaped skill for the slice of the market I'm targeting: the biggest, most stable employers.

Depth beats breadth, especially with AI

Fast Company: AI is "exceptionally good at replacing shallow knowledge." Moderate competence across several domains now competes against systems that synthesize all of them instantly. Every 2026 market analysis I've read converges on the same model: a broad base plus one deep specialization. Pure generalists are in structural decline.

My broad base is React and TypeScript. My deep skill is becoming Java and Spring Boot.

Java is a good deep bet for the AI era specifically. Its static, deterministic syntax is easier for LLMs to model than dynamic languages, so generated code is more often right on the first pass. And the boilerplate-heavy parts of Spring Boot (controllers, services, repositories) are exactly what AI writes best. The "Java is too verbose for AI-assisted development" argument is from 2019. In 2026, it's backwards.

Startup languages churn. Java doesn't.

A heavily-upvoted r/java comment I found puts it better than I can:

When you consider that a large corporation can employ as many people as 500-10,000 startups and that only 10% of those startups survive and the rest are replaced by companies that eventually pick some other language according to the fashion of the day, you see why what startups do is not necessarily a good indicator of where the industry is going.

Quick applications have chased the language of the moment for decades: PHP, then Ruby, then Python, then Node. Java has been the constant through all of them. The survivors that bet on the fashionable option? Facebook picked PHP and had to invent Hack to scale it. Stripe and Shopify picked Ruby and spent years bolting types onto it. The commenter's punchline: "those who picked Java (and survived) virtually always ended up happy with their choice."

That number reframed everything for me: optimizing your career for the startup language du jour means optimizing for a tiny fraction of the industry. And it's not just theory. Eric Cupsa, a developer I follow, learned Java and Spring Boot at university, landed at Amazon (whose backend is famously ~80% Java), and went on to found startups, including one on a Spring Boot backend. Java got him through the door.

The trade-offs I'm accepting

I'm not claiming Java is better at everything. I'm claiming it's better for the bet I'm making:

Giving up	Why it's OK
One-language full-stack (TypeScript everywhere)	React/TS frontend + Java backend is one of the most employable combinations in the German market. Two languages means more jobs
Faster prototyping (hot reload, no compile step)	My priority right now is stability-first employers, not shipping consumer MVPs in a weekend
NestJS and TypeScript-backend depth	Spring Boot transfers to more of the market I'm targeting, and my university coursework will reinforce Java. It's leverage, not friction

What I'm doing now

The plan, build-first, roughly 7-14 hours a week:

Java fundamentals. Bro Code's full Java course: OOP, collections, on a modern JDK.
Functional Java. Amigos Code's functional programming course, for streams and optionals. It's the one real gap in the basics.
Modern Java. Records, sealed classes, pattern matching, virtual threads.
Spring Boot. The 13-step path: Maven/Gradle → dependency injection → Spring Boot → data access → security → testing → Docker.
A fun layer. Minecraft modding, where @Mod / @SubscribeEvent maps almost 1:1 onto Spring's @Component / @Service / @Autowired. Dependency injection won't feel like magic.
A real project. A CRUD app with PostgreSQL and Docker. Amigos Code's Java roadmap calls Spring Boot "the king" of Java frameworks. Kings need a kingdom.

Every session produces output: code, a diagram, a post like this one. That's the rule I learned the hard way in my first two projects.

The bottom line

In 2026, everyone told me Java was dead. A Netflix engineer told me it's the best trade-off between runtime performance, developer productivity, and maintainability. The German enterprise market calls it constant demand. And the history of startup stacks says the language that's exciting today might not be the one that pays my bills in a decade.

So I'm going deep on the boring one. Boring, it turns out, is a feature.

If you're picking a stack this year, what made you choose it? And what did you give up?

I Built React Native Apps for Months — Then Scored 3/10 on React Fundamentals

Anh-Duc Nguyen — Sun, 26 Jul 2026 01:58:15 +0000

Original post on my website here.

I've been building mobile apps with React Native and Supabase for months. I had a working GTD app, I could scaffold a project, wire up state, fetch data, handle auth. So when I decided it was time to move on to full-stack frameworks like Next.js, I figured I already knew React well enough.

Then I actually thought about it. I work with React Native, not React. A lot of the concepts are similar, but there are real differences — forms, routing, how lists render, even what JSX compiles to under the hood. I wasn't sure how much of my knowledge would transfer directly, and how much I'd need to relearn.

So before jumping into Next.js, I asked an AI to quiz me on React fundamentals. 30 questions across 10 sections, topics from Traversy Media's React course — JSX, props, state, effects, hooks, routing. The basics.

I scored 3 out of 10.

How the roast worked

I gave the AI my topic list and said: go through each section, ask me to explain things in my own words, and score me honestly. No Googling, no assistance. Just what I actually know off the top of my head.

It asked me things like "what is JSX?", "what's the difference between these two state updates?", "what does the cleanup function in useEffect do?" — and gave me a score after each section with a brief explanation of what I got wrong.

Here's the damage:

Section	Score	Verdict
Welcome to React	6/10	Practical intuition, fuzzy mental model
JSX	4/10	Knows patterns, misses mechanics
Props	4/10	`children` prop unknown, immutability weak
State & Events	3/10	Missing functional updates, immutable updates
Forms	0/10	No knowledge (React Native difference)
Effects & Data	3/10	Missing cleanup, dependency array mechanics
Sharing State	3/10	Used context but can't articulate it
More Hooks	1/10	useRef, useReducer unknown
Routing	1/10	Platform difference, skipped

Overall: 3/10.

The rough moments

The JSX question was probably the most embarrassing. It asked me what JSX actually is, and I said something like "it's kind of like special HTML where you can add variables." That's what it looks like, not what it is. JSX is JavaScript syntax that compiles to React.createElement() calls. It's not HTML at all. I'd been writing JSX for months without knowing that.

The functional updates question was frustrating because I actually do know the difference between setCount(count + 1) and setCount(prev => prev + 1). I've Googled it before, I understand the concept, and I've used both. But in the moment, I just froze and said I didn't know. The AI showed me this example afterward:

// count is stale in this closure
setCount(count + 1); // 0 → 1
setCount(count + 1); // 0 → 1 (still sees 0!)
setCount(count + 1); // 0 → 1

// prev is always the latest
setCount((prev) => prev + 1); // 0 → 1
setCount((prev) => prev + 1); // 1 → 2
setCount((prev) => prev + 1); // 2 → 3

I knew this. I just couldn't recall it under pressure. Which honestly might be worse than not knowing — if I can't explain something when asked, do I really understand it?

Cleanup functions, on the other hand, I genuinely didn't know. Or maybe I've used them before without realizing what they were called. The concept of returning a function from useEffect that cleans up timers, event listeners, subscriptions — that was new to me. I even asked "do they even exist in React Native?" They do. I just never needed them badly enough to learn.

What I actually got right

It wasn't all bad. I got conditional rendering right (8/10), which makes sense since I use ternaries in JSX all the time. I understood prop drilling intuitively (6/10) — the chain-breaking risk, the annoyance of passing props through five levels of components. I just couldn't name the formal solutions.

And I actually had used Context for auth and theme in my apps. But during the quiz I panicked and started talking about Zustand and Redux, which I've never used. The AI called it "hallucinating to cover gaps." Fair enough.

What this showed me

The biggest thing this quiz revealed is that there's a real gap between being able to build something and being able to explain how it works. I can write a React Native app that works. But when someone asks me to explain why I'm writing it that way, I often can't.

This is basically the Feynman Technique in action: explain something simply, and wherever you can't, that's the gap. The quiz forced me to explain things in my own words without Googling, and every place I stumbled was a place my understanding was shallow.

And it's not that React Native "made me worse" at React or anything like that. It's more that the knowledge doesn't transfer directly. React Native and React share a lot — components, state, effects, JSX — but there are differences in how things work under the hood. FlatList handles list rendering differently than .map() on the web. React Navigation is a completely different paradigm from React Router. Forms in React Native don't use <form> or controlled inputs the way web React does. So when I was quizzed on React web specifically, there were gaps I didn't expect.

What I'm still confused about

As I'm writing this, there are things I still don't fully understand:

useReducer vs useState: I know useReducer exists. I know it's for "complex state logic." But I can't tell you when I'd actually reach for it over useState. Every explanation I've read feels abstract — I haven't hit a real problem where useState was clearly the wrong tool.
useRef: I've seen it in code examples. I think it's for accessing DOM elements? But I've never used it in React Native, and I'm not sure what problem it solves that state doesn't.
Dependency arrays: The quiz flagged that I don't understand how useEffect dependency arrays actually work. I know the rule — "put everything you use inside the effect into the array" — but I don't have a mental model for what happens when you get it wrong, beyond "infinite loops maybe?"

I'm sharing these not as things I'll fix later, but as things I'm genuinely confused about right now. If you know these well, I'd love to hear how you think about them.

What's next

First thing: I'm working through Traversy Media's React fundamentals course, but with code review exercises instead of just watching videos. The AI gives me a component with some issues — bugs, anti-patterns, things that work but aren't ideal — and I try to find and explain what's wrong. It's faster than writing code from scratch, and it tests whether I actually understand the concepts or just recognize patterns. I'll re-quiz myself after each section to see what actually stuck.

The goal is to actually understand React before moving to Next.js. Not just follow patterns and hope for the best.

If I fill the gaps successfully, I'll turn the notes into a React Native → React transition cheatsheet. The full roast session is also coming to YouTube soon — you can watch me get quizzed in real time and see exactly where I froze up.

If you've been building with React, try the same quiz. Pick any 5 topics from the fundamentals and explain them out loud without Googling. You'll find your gaps in 10 minutes.