The Marco Show

Java Performance Myths: JIT vs AOT, GraalVM, Performance Engineering – Thomas Wuerthinger

The Marco Show

Show Notes

Episode description:Thomas Wuerthinger, Founder and Project Lead of GraalVM and Vice President at Oracle, joins Marco to unpack how modern Java runtimes actually work. They explore why duplicating compilers and garbage collectors across languages is a waste of engineering effort, how GraalVM grew from a research project into production technology, and why Native Image unexpectedly became its most impactful feature. 💡 In this episode: GraalVM, Native Image, and Java performance

JIT vs AOT and predictable runtime behavior

Polyglot runtimes and shared memory models

Cloud-native Java, startup time, and memory footprint

Performance lessons from the One Billion Row Challenge

Branch misprediction and hardware-level bottlenecks

Research vs product engineering

AI in compilers and testing

🕐 Timestamps (00:00) Intro (01:09) Meet Thomas Wuerthinger & what GraalVM really is (03:31) Why duplicating language runtimes is a waste (06:08) How GraalVM started at Sun Microsystems Labs (10:26) Writing an interpreter and getting a JIT “for free” (14:26) Going open source and finding real users (16:48) Why Native Image took off (23:02) From research project to real product (26:56) Native Image, Spring, Quarkus, and Java in the cloud (35:38) Why JIT performance can be unpredictable (39:31) When JIT still makes sense (43:02) Python, JavaScript, and polyglot runtimes (46:16) Using AI in compilers and testing (01:04:06) The One Billion Row Challenge (01:09:50) Branch misprediction and performance surprises (01:13:26) How to think about performance optimization (01:25:33) Giveaway question (01:27:11) Rapid fire and wrap-up

New episodes every other Wednesday. Subscribe for in-depth conversations on software engineering, performance, and developer tools. 🎥 Watch the full episode on YouTube: https://youtu.be/naO1Up63I7Q

More from The Marco Show

Sep 2, 2026

Michael Simons, a longtime Java developer and Neo4j engineer, joins Marco to talk about the engineering principles that have stayed relevant across decades of changing technologies. The conversation covers database-first thinking, Spring and the Java ecosystem, graph databases, developer tooling, and why pragmatic decisions often matter more than chasing the “best” framework. They also discuss how AI is changing software development, where AI tools genuinely help, and why human judgment and responsibility still matter. 💡 In this episode: Why Michael still starts with the data model when building applications

Aug 19, 2026

Venkat Subramaniam joins Marco to talk about what AI is really changing for developers. They discuss why AI often impresses novices more than experts, why “AI first” is the wrong mindset, and why critical thinking, fundamentals, and judgment matter more than ever. 💡 In this episode: Why AI is better at finding problems than writing code

Aug 5, 2026

Sébastien Deleuze, a longtime Spring Framework committer and member of the Spring AI team, joins Marco to talk about how 13 years on the Spring team shaped his pragmatic approach to software development. The conversation covers how Spring AI fits into the Spring ecosystem, why enterprise AI still needs deterministic workflows and human accountability, and why long-term software quality matters even as GenAI changes how code gets written. 💡 In this episode: How Sébastien joined the Spring team through open source contributions

Jul 22, 2026

Josh Long, Spring Developer Advocate at Broadcom, joins Marco to cover 25 years of Spring history and what the JVM's real shot at the AI era actually looks like. Josh has published a weekly blog since 2011 and a weekly podcast since 2018 without missing an episode. This conversation gets into why vibe coding concerns him as an engineer, what accountability for AI-generated code actually means, and why Python's dominance in AI is more a marketing gap than a technical one. 💡 In this episode: Spring's origin story: why the documentation came before the code

Jul 8, 2026

Martin Lippert, longtime maintainer of Spring Tools and one of the people who has witnessed developer tooling evolve from Eclipse to VS Code, joins Marco to discuss how AI is transforming Java development, and what that means for the future of software engineering. ⏱️ Timestamps: (00:00) Teaser(00:38) Meet Martin Lippert, Spring Tools & the evolution of Java IDEs(03:28) What happened to Eclipse? Lessons from the rise and fall of a Java giant(12:20) Why Spring Tools moved to VS Code and embraced the Language Server Protocol(20:03) How AI is changing Java development and everyday coding workflows(21:59) Martin's AI workflow: Cursor, IDEs, code review & testing(26:16) Building developer tools for AI agents instead of humans(31:10) Why AI is changing release cycles and developer tooling(36:03) AI review fatigue, cognitive depth & trusting generated code(39:06) Will AI replace senior developers? What happens to junior engineers?(42:16) The future of Java, Spring & software architecture in an AI-first world(48:42) AI's hidden energy problem and the sustainability challenge(54:39) Practical tips for greener software engineering and AI usage(1:00:06) Giveaway & rapid-fire questions

See all episodes →