The first season of The Marco Show has officially come to an end! In this Christmas special episode, we’re announcing all of our giveaway winners and wrapping up the season with a fun Q&A with Marco.

🎁 Giveaway winners:

If you’re one of the winners featured in this episode, please reach out to us at [email protected] and let us know what you’d prefer: a 1-year license to one of our JetBrains products, or a coupon for the JetBrains merch store.

Timestamps:

(00:00) Season Finale Intro & What to Expect

(00:34) LLMs with Jodie Burchell: giveaway winner

(01:08) Software performance with Casey: giveaway winner

(01:39) Hibernate with Gavin King: giveaway winner

(02:15) Flyway with Axel Fontaine: giveaway winner

(02:45) SQL with Torben: giveaway winner

(03:16) Quarkus with Kevin Dubois: giveaway winner

(03:46) Jetty with Ludovic: giveaway winner

(04:18) ByteBuddy with Rafael: giveaway winner

(04:52) How to claim your prize

(05:08) Q&A with Marco

(09:35) Outro and meet the team

Thank you to everyone who watched, listened, and supported the show this season. We truly appreciate it. See you next year!

New episodes every other Wednesday. Subscribe for more developer-focused conversations. 🎥 Watch the full episode on YouTube: https://youtu.be/hZemYWNKa6I

Rafael Winterhalter, creator of ByteBuddy and long-time Java consultant, joins Marco to break down the hidden world of JVM bytecode instrumentation. They discuss how ByteBuddy powers tools like Mockito and Hibernate, why legacy Java still dominates enterprise systems, and what it’s really like maintaining a massive open-source project as a single developer.

💡 Topics in this episode:

• How ByteBuddy works and why frameworks rely on it

• JVM bugs, JIT issues, and surprises from instrumentation

• Supporting legacy Java (5, 6, 8…) in modern environments

• Open-source sustainability and avoiding burnout

• Java modules, unsafe, and evolving with new JDK releases

• Rethinking Java build tools and software engineering complexity

🕑 Timestamps:

(00:00) Intro

(01:10) Rafael’s background & the origin of ByteBuddy

(03:00) What ByteBuddy does and why it matters

(04:32) Replacing CGLIB and early challenges

(07:05) ByteBuddy’s design philosophy

(09:15) Mockito, Hibernate and real-world adoption

(13:14) Open source reality

(15:48) Performance myths and JVM behavior

(18:47) JVM bugs, JIT issues and instrumentation pitfalls

(21:11) Supporting legacy Java in enterprise

(23:56) Testing ByteBuddy across many JDKs

(25:53) Why companies still run Java 5/6

(28:25) Engineering vs economics

(30:39) Modules, unsafe and evolving with Java

(36:12) Maintaining a one-person project

(39:31) Conferences and developer evangelism

(42:02) Consulting vs product engineering

(49:51) Burnout and sustainability

(52:02) Thoughts on AI in software development

(57:13) Rethinking Java build tools

(01:05:07) Build security and dependency risks

(01:10:16) Giveaway

(01:10:48) Rapid fire and outro

New episodes every other Wednesday. Subscribe for more developer-focused conversations.

🎥 Watch the full episode on YouTube: https://youtu.be/AzfhxgkBL9s

Episode description:

Ludovic Orban (Jetty Maintainer and Performance Engineer at WebTide) joins Marco to break down what “web scale” really means, why most systems don’t need Google-level architecture, and how modern Java servers achieve massive throughput. From Jetty’s design philosophy to multi-core CPU realities, distributed transactions, Terracotta’s wild JVM clustering experiments, and the limits of AI-generated code, this episode dives deep into how high-performance Java is built today.

💡 In this episode:

• What “web scale” actually means for real-world systems

• Jetty vs Tomcat and how Jetty became a fast, modern web server

• CPU evolution, memory bottlenecks, and multi-core performance

• Distributed transactions, XA pitfalls, and compensating patterns

• Terracotta’s clustered JVM: engineering lessons and war stories

• Why developers struggle with performance (and how to learn it)

• AI, coding assistance, and why Ludovic doesn’t trust generated code

⏱️ Timestamps:

(00:00) Teaser

(01:10) Who is Ludovic Orban?

(02:04) What “web scale” really means, and who actually needs it

(03:54) How hardware changes reshaped software performance

(06:28) Cloud, containers, and why performance still matters

(07:28) Jetty vs Tomcat: history, adoption & performance

(10:47) What makes Jetty “fast” in practice

(13:21) How the Jetty team prioritizes performance

(15:10) Recent work: fixing complex HTTP/2 bugs

(16:38) How WebTide supports customers beyond Jetty issues

(17:52) Bitronix: Why Ludovic built his own transaction manager

(20:45) Open-source challenges. The rise and fall of Bitronix

(24:19) Distributed transactions vs compensating transactions

(27:07) Where to learn more: Atomikos and modern approaches

(28:25) Terracotta: clustering JVMs and wild engineering stories

(31:20) What Terracotta taught him about the JVM

(33:48) Real-world Java performance mistakes developers make

(40:22) Why learning performance is so hard

(45:40) Kubernetes, abstraction, and performance visibility

(48:50) Hardware that excites Ludovic: Oxide Computer

(50:42) His take on AI and why he doesn’t trust generated code

(53:30) Lessons from Jetty, Terracotta, Bitronix, and Quartz

(56:10) Rapid-fire questions

(01:01:15) Giveaway and outro

New episodes every other Wednesday. Subscribe for more deep, developer-focused conversations.

🎥 Watch the full episode on YouTube: https://youtu.be/fJvg5zTKHeE

Kevin Dubois (IBM Developer Advocate, Quarkus Team) joins Marco to explore how Quarkus is reinventing Java for the modern cloud era, and why it’s not about killing Spring Boot. From startup times to developer experience, microservices, AI, and GraalVM, this episode dives into where Java is heading in 2025 and beyond.

💡 Topics in this episode:

• The origins of Quarkus and why it exists

• Spring Boot dominance and migration trends

• Hot reload, Dev UI, and developer experience

• Cloud-native Java, containers, and serverless

• GraalVM and the future of native Java

• Java’s role in the age of AI

New episodes every other Wednesday. Subscribe for more deep, developer-focused conversations.

🎥 Watch the full episode on YouTube: https://youtu.be/IRqTbgC2JLU

⏱️ Timestamps:

(00:00) Intro

(01:12) Why Quarkus was created (it’s not about killing Spring)

(04:45) How Quarkus compares to Spring Boot today

(08:30) Developer experience: hot reloads, Dev UI, and that “aha” moment

(13:05) Quarkus in the cloud: Kubernetes, containers, and serverless

(18:20) Native compilation vs JVM: when (and when not) to use it

(24:00) MicroProfile, Jakarta EE, and open specs

(28:35) The future of Java: monoliths, microservices, and AI

(33:10) How IBM is investing in Quarkus and the Java ecosystem

(37:25) Agentic AI, LangChain4J, and practical use cases

(42:10) Rapid-fire questions

(46:15) Giveaway question + closing thoughts

Thorben Janssen joins Marco to talk about the hidden power (and pain) of Java persistence frameworks. Hibernate, JPA, Spring Data, jOOQ: which one should you really use in 2025? From learning SQL the right way to surviving microservices madness, this episode is packed with hard-won lessons from decades of real-world Java work.

💡 Topics in this episode:

• Hibernate vs JPA vs Jakarta Data
• When to use jOOQ or Exposed
• The biggest persistence misconceptions
• Common performance traps (and how to avoid them)
• Monoliths, microservices, and “real” architecture decisions
• How AI might change the way we write queries

⏱️ Timestamps:

(00:00) Introduction: From painful early learning to AI-generated annotations
(01:02) Meet Thorben Janssen – consultant and trainer for Java persistence
(02:11) Early days of Hibernate and the horror of EJB2
(04:33) Main challenges in database access today
(06:18) Too many tools: Hibernate, JPA, Spring Data, jOOQ – how to choose
(08:15) Why understanding ORM internals really matters
(09:20) How juniors should start learning persistence
(10:59) SQL skills – why you still need them even with Hibernate or Spring Data
(13:48) SQL essentials for beginners: what to learn first
(16:01) Why Hibernate became the dominant persistence tool
(18:57) Hibernate vs JPA – is there really a difference?
(20:35) Hibernate API vs Jakarta Persistence API – which to use
(22:10) Criteria API and DSLs for queries
(23:43) Strengths and weaknesses of Spring Data JPA
(27:26) Jakarta Data vs Spring Data JPA
(30:53) Stateful vs stateless data models
(33:21) jOOQ, Exposed, and the SQL-centric approach
(37:41) Mixing Hibernate and Exposed in one project
(39:33) Where Spring Data JDBC fits in
(43:24) Starting a new project in 2025 – what stack to choose
(45:24) The role of experience and not chasing every new trend
(48:50) Monoliths, microservices, and common pitfalls
(52:14) Database design vs service design – where to start
(59:02) Common database performance issues
(01:03:10) Why developers should collaborate with DBAs
(01:06:20) Caching problems: when caches make things worse
(01:09:29) Reactive database access – what happened to the hype
(01:12:33) The "perfect" persistence framework – does it exist?
(01:14:40) AI-assisted development and query generation
(01:19:43) The AI hype cycle and developer reality
(01:20:17) Other persistence models worth learning (graph, full-text search)
(01:21:43) Full-text search and graph databases in practice
(01:23:25) Integrating AI into applications
(01:24:38) Thorben's unpopular opinions
(01:26:04) Giveaway announcement
(01:27:06) Rapid-fire round: Paderborn, joins, and lazy loading
(01:30:00) Closing remarks

🎁 Giveaway: What’s the highest number of SQL queries you’ve ever seen one workflow generate? Best answers win JetBrains merch or IDE licenses.

New episodes every other Wednesday. Subscribe for deep, developer-focused conversations.📺 Watch on YouTube: https://youtu.be/t4h6l-HlMJ8

Axel Fontaine, creator of Flyway, one of the most popular database migration tools, joins Marco to share how he built a global open source project, turned it into a profitable business, and sold it to Redgate. From bootstrapping alone to making millions without investors, Axel’s story is a deep dive into the business side of coding.

💡 Topics in this episode:

• How Flyway grew from a side project to an acquisition

• The power of simplicity and zero dependencies

• Turning open source into a sustainable business

• Bootstrapping vs venture capital

• Life after selling your company

⏱️ Timestamps:

(00:00) Intro

(00:54) Guest introduction

(01:18) What is Flyway?

(02:16) Evolution of databases and CI/CD

(07:37) The idea and first version of Flyway

(10:41) Competitors and why Axel built his own tool

(13:27) Building Flyway’s simplicity and focus

(17:30) Design principles: zero dependencies and reliability

(20:18) Learning user focus through onboarding docs

(23:31) How Flyway’s roadmap evolved

(27:00) Handling bugs, testing challenges, and quality

(31:27) Marketing and early promotion

(33:49) The Maven Release Plugin blog post

(36:07) Technical mistakes and lessons learned

(38:28) Managing contributors and open-source community

(44:44) Burnout and balancing workload

(50:43) Turning Flyway into a business

(52:20) Failed monetization attempts

(01:09:11) Licensing, IP cleanup, and CLA process

(01:30:02) First commercial release and first sale

(01:31:56) Rapid revenue growth

(01:39:07) Leaving consulting and going full-time on Flyway

(01:44:30) Negotiating with enterprise customers

(01:46:55) Acquisition interest and decision process

(01:52:46) Decision to sell

(02:04:57) Life after the sale and reflection

(02:07:38) Key lessons for founders

(02:09:50) Giveaway

(02:10:47) Rapid-fire questions

(02:13:18) Outro

New episodes every other Wednesday. Subscribe for more deep, developer-focused conversations.

📺 Watch the episodes on YouTube: https://youtu.be/lwF2fg1fOHk 

📺 Note: This episode contains screensharing and live coding examples that work best visually. If you’d like to follow along, check out the full video version on YouTube: https://youtu.be/Qvh3VFlvJnE.

Gavin King (creator of Hibernate) joins Marco to cut through the myths of Java persistence. When should you skip layers of repositories and just write SQL, or even model database views? What actually causes lazy-loading pain, and how do stateless sessions help? We cover Hibernate, JPA, and where Jakarta Data is headed, plus pragmatic advice for legacy schemas, performance, and keeping your code DRY.

💡 Topics in this episode:

• SQL vs repositories (and why views can be your adapter layer)

• The three inheritance strategies, and the trap of table-per-class

• Stateless sessions vs stateful persistence contexts

• LazyInitializationException explained (and avoided)

• DRY first: let architecture emerge via refactoring

• Jakarta Data 1.0/1.1: annotation processing, stateful repos, dynamic queries

• Performance rule-of-thumb: minimize round-trips

⏱️ Timestamps

(00:00) Teaser

(01:00) Gavin King intro and early Hibernate motivation

(03:59) Old-school open-source culture and discovery

(08:39) SQL isn’t hard: minimize DB round-trips

(10:03) “Leaky abstractions are good” (and why)

(12:04) Architecture should emerge from code

(15:44) DRY as commandment #1

(22:05) Reviewing a typical Spring Data setup (and pitfalls)

(25:39) Inheritance strategies: joined vs single table vs table-per-class

(30:06) One screen? Just write a SQL query (pragmatism)

(33:08) When ORM shines: operations over graphs

(35:22) Use views to adapt messy legacy schemas

(43:18) Jakarta Data repos: annotation-driven, step-into-able

(44:59) Stateless Session: less magic, explicit updates

(48:51) Jakarta Data 1.1: stateful repos, dynamic queries, reactive

(01:24:22) Rapid fire questions

(01:33:15) Features Gavin would delete and lessons learned

(01:42:30) Giveaway

New episodes every other Wednesday. Subscribe for deep, developer-focused conversations.

Casey Muratori (programmer, educator, performance advocate) joins Marco to explore why modern software feels so slow, even with today’s powerful hardware. From the infamous Windows Terminal controversy to game server limits, billion-row challenges in Java, and his unfiltered take on AI. This episode dives deep into performance, programming culture, and what developers should really care about.

💡 Topics in this episode:

• Why software performance matters (and how to avoid “ridiculously slow” code)
• The “excuse parade” developers use when things lag
• Expectations for game server concurrency
• Parsing a billion rows in Java: lessons in performance
• Containers, cloud, and performance myths
• AI: helpful tool or unethical theft?
• Why Casey would get rid of Python

New episodes every other Wednesday. Subscribe for more deep, developer-focused conversations.

Watch the episodes on YouTube: https://youtu.be/apREl0KmTdQ

Jodie Burchell (Data Scientist) joins Marco to cut through the hype around large language models. From GPT and Gemini to Claude and beyond — how do you really choose the right one? Benchmarks, context length, hallucinations, ethics, and AGI predictions — all on the table.

If you’ve ever asked yourself, “Which LLM should I use for my work?” — this conversation will help you see past the hype.

💡 Topics in this episode:

• How to compare LLMs for different developer tasks
• Enhanced vs adaptive thinking (is it just branding?)
• Corporate considerations: cost, privacy, and hosting
• The ethics and lawsuits shaping AI’s future
• Predictions for AGI

⏱️Timestamps:

(00:00:00) Teaser

(00:00:37) Intro

(00:01:08) From PhD and academia to data science at JetBrains

(00:02:31) Early NLP versus modern LLMs

(00:04:46) From LSTMs to Transformers (BERT and GPT)

(00:08:49) The DeepSeek surprise and model scaling limits

(00:12:25) Benchmarks, assessments, and confusion for end users

(00:17:18) Choosing models in practice

(00:21:10) “Thinking” models and reasoning limits

(00:23:48) Do you really need the newest model?

(00:25:58) Hallucinations and how to handle them

(00:28:30) Agents and RAG: real-world applications

(00:32:55) Vibe coding: hype versus reality

(00:37:46) What are AI agents? Tools, MCP, and multi-agent apps

(00:43:01) Self-hosting versus proprietary models

(00:45:20) Fine-tuning explained and Hugging Face

(00:50:17) Building reliable AI apps (tests, A/B, traces)

(00:55:33) Privacy, company data, and self-hosting concerns

(00:58:37) Ethical issues: data sourcing and labor

(01:04:23) Environmental costs and the push for smaller models

(01:06:26) Juniors, skills, and the future of coding with AI

(01:09:15) Learning fundamentals in the age of LLMs

(01:13:24) AGI: definitions, timelines, and Jodie’s twenty euro bet

(01:20:03) Rapid-fire questions: slang, food, and culture

(01:25:47) Giveaway

(01:26:26) Outro

New episodes every other Wednesday. Subscribe for more deep, developer-focused conversations.

Watch the episodes on YouTube: https://jb.gg/themarco.show-youtube

Follow Jodie Burchell:

LinkedIn: jodieburchell

Bluesky: @t-redactyl.bsky.social

Mastodon: @[email protected]

Follow The Marco Show:

Instagram: @themarco.show

TikTok: @themarco.show