The Marco Show

IntelliJ IDEA

The Marco Show is a bi-weekly podcast about AI, coding, and developer tools — hosted by Marco Behler, Developer Advocate for Java at JetBrains.
Before JetBrains, Marco ran a consultancy in Munich, working with clients like BMW, Wirecard, and KVB, and built software at BWSO (now tresmo). He’s also a Java and Spring trainer, conference speaker, and writer of guides, courses, and videos.
Each episode brings real conversations with tech people who actually build things: opposing opinions, hot takes, and useful insights for developers who want to go deeper.
New episodes every other Wednesday.

Play

Open in

22 episodes
fortnightly
Avg 1 hr 11 min
English

Episodes 22

Newest Oldest Longest

All20 Unplayed20 In progress0 Played0

Counted on this page — what you have heard stays on this device, so it is not something the list can be paged by.

S3 · E5
September 2 · 1 hr 9 min
Databases, AI Agents and Death by Tooling - Michael Simons | The Marco Show
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 Why too many tooling choices can lead to “death by tooling” How Spring Boot changed the Java ecosystem How Neo4j and graph databases help solve highly connected data problems Where AI tools help developers and where traditional approaches still work better Timestamps: (00:00) Teaser (00:31) Introduction (02:42) Michael’s database-first background (04:18) Why data outlives applications (07:38) Are developers underusing their databases? (09:53) Vendor lock-in: Is it really such a bad thing? (10:57) JPA, jOOQ, Spring Data, and choosing database tools (15:02) From Oracle to Java and Spring (18:21) How Spring Boot changed the industry (20:00) Tool wars and “death by tooling” (23:20) Blogging, community building, and public speaking (29:58) From blog posts to international conferences (32:14) Writing technical books (38:09) Can LLMs replace human editors? (40:26) “I’m a product person, not a project person” (41:28) How Michael joined Neo4j (47:45) Graph databases, fraud detection, and LLMs (48:55) What Michael is building at Neo4j (57:43) The future of Java and AI-generated contributions (59:19) AI-generated pull requests and maintainers (01:01:34) How Michael actually uses AI tools (01:03:46) Static code analysis vs. LLMs (01:05:22) Why Michael doesn’t want AI doing the planning (01:06:27) Giveaway (01:07:34) Rapid-fire questions (01:09:42) Outro New episodes every other Wednesday. Subscribe for more developer-focused conversations. 🎥 Watch the full episode on YouTube: https://youtu.be/Leo8A1FjY1o
S3 · E4
August 19 · 1 hr 24 min
40 Years of Programming: What AI Changes and What It Never Will - Venkat Subramaniam | The Marco Show
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 Why AI needs more skilled developers, not fewer Why “AI is second” The danger of bad AI metrics and token maxing Why critical thinking still matters What excites Venkat about the future of Java and virtual threads Timestamps: (00:00) Teaser (00:40) Introduction (01:12) What is different about AI? (03:26) Why AI is better at finding problems than writing code (04:50) Should AI implement an entire feature? (09:15) How junior developers can become experts in the AI era (12:46) Speed vs. sustainable software development (14:11) Timeboxing and learning to verify solutions (18:18) Why AI should come second (21:19) Why developers and AI are better together (24:22) Token maxing and failed AI adoption strategies (26:43) Why powerful tools require more skill (29:28) Programmer productivity vs. business agility (31:03) What CTOs should do about AI (33:35) Threat-driven development and forced AI adoption (36:06) How Venkat learns new technologies (41:44) How Venkat prepares talks and keynotes (44:50) Why Venkat does not rehearse his talks (47:00) Stage fright after thousands of presentations (49:16) When Venkat’s laptop died before a live coding keynote (53:53) What keeps Venkat learning and creating? (54:21) From a failing student to earning a PhD (56:00) “I hate studying, but I love learning” (01:00:19) Why grades can destroy the joy of learning (01:04:54) How Java has changed over the last decade (01:05:29) Why Java 8 was the game changer (01:09:13) Java’s release cycle and true agility (01:11:29) Virtual threads and asynchronous programming (01:15:47) What makes Java’s innovation different (01:16:56) What is next for Java? (01:19:25) Generics with value types (01:20:30) Giveaway question (01:21:53) Rapid-fire questions (01:23:33) Outro New episodes every other Wednesday. Subscribe for more developer-focused conversations. 🎥 Watch the full episode on YouTube: https://youtu.be/_590TxMwvWM
S3 · E3
August 5 · 40 min
From Spring Framework to Spring AI: 13 Years of Building What Developers Need - Sébastien Deleuze | The Marco Show
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 Why he only introduces features he once wished Spring had as a developer How Spring AI brings AI services into the familiar Spring programming model Why AI helps with speed, but not with the most important decisions Why accountability and sustainable engineering still matter in the age of GenAI Timestamps: (00:00) Teaser (00:32) Introduction (00:54) Sébastien Deleuze’s 13 years on the Spring team (01:22) How an open-source contribution led to joining Spring (03:08) Working on a fully remote team (03:54) Building the Spring features he wished he had as a developer (05:22) Why Kotlin was the right fit for Spring (06:35) How the Spring team discovers what developers need (08:23) Learning from competing frameworks without copying them (11:06) What is Spring AI? (13:27) Bringing AI into enterprise applications (14:53) AI-generated pull requests and the accountability problem (16:36) How open-source maintainers deal with low-quality AI contributions (18:27) Keeping up with the speed of change in AI (20:43) Using AI tools for most coding tasks (21:21) Writing better prompts by providing the right context (24:05) Running multiple AI agents and managing context switching (24:53) Can an AI agent fix a complex Spring issue? (25:38) Why detailed issues and commit messages matter more in the AI era (27:22) What’s next for Spring AI 2.0 and 2.1 (29:44) Spring AI’s relationship with Embabel and the wider ecosystem (30:56) Why Spring AI is reducing its scope (32:05) The most important engineering skill AI cannot replace (33:29) Using AI outside of work (38:10) Giveaway (39:04) Rapid-fire questions (40:13) Outro New episodes every other Wednesday. Subscribe for more developer-focused conversations. 🎥 Watch the full episode on YouTube: https://www.youtube.com/watch?v=mCOGZGV48hU
S3 · E2
July 22 · 49 min
Why AI Won't Replace Great Java Developers - Josh Long | The Marco Show
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 How Spring Boot changed what a developer talk could look like The hidden cost of vibe coding: context, accountability, and integration Why 95% of generative AI projects fail — and what the 5% have in common Project Valhalla, Project Panama, and the Vector API Why Java could have built Kubernetes, and what that means for AI Timestamps: (00:00) Teaser (00:37) Introduction (01:02) Josh's journey before joining the Spring team (03:06) Becoming Spring's first Developer Advocate (05:47) What a Spring Developer Advocate actually did (08:41) How Spring Boot changed Java forever (12:32) Building a career around talks, blogs, and community (15:32) Writing a weekly blog for 15+ years without missing one (19:14) Stage fright and speaking at hundreds of conferences (20:07) Live coding, talk preparation, and presentation failures (26:33) How DevRel changed after COVID (29:08) Why live coding beats slides (31:46) Advice for aspiring Developer Advocates (33:12) AI coding agents, vibe coding, and why more code isn't better (39:27) How AI changed search and everyday work (40:17) The future of Java, Spring, and AI (46:48) Giveaway (47:32) Rapid-fire questions (49:36) Outro New episodes every other Wednesday. Subscribe for more developer-focused conversations. 🎥 Watch the full episode on YouTube: https://youtu.be/_ftzJ33mCTI
S3 · E1
July 8 · 1 hr 5 min
The End of Traditional IDEs?: AI Workflows, Cursor, IntelliJ - Martin Lippert | The Marco Show
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 💡 In this episode: How AI is changing Java development and developer workflows Why IDEs still matter alongside coding agents like Cursor Building developer tools for AI instead of humans AI review fatigue and the importance of writing code yourself Will AI replace senior developers? Why software architecture still matters in an AI-first world The evolution of Java tooling: Eclipse, VS Code, Language Server Protocol, and beyond The future of Java and Spring in the age of AI AI's hidden environmental cost and the rise of Green Software Engineering New episodes every other Wednesday. Subscribe for more conversations with the people shaping the future of software development. 🎥 Watch the full episode on YouTube: https://youtu.be/gUm6DOf1NHI
S2 · E9
June 3 · 54 min
Why Scala Changed Programming Languages Forever - Martin Odersky | The Marco Show
Martin Odersky, creator of Scala and co-designer of Java generics, joins Marco to trace the full arc from Pizza (the 1996 functional Java experiment) to Scala 3, and on to his vision for capabilities as a safety mechanism for AI-generated code. They discuss how Scala unified object-oriented and functional programming, the Scala 2 to 3 evolution (implicits, Tasty, the new compiler), higher-kinded types, and why Martin believes programming languages need to grow up fast to keep AI agents from doing catastrophic things in production. Topics in this episode: The origins of Scala and the Pizza language Java generics: design, type erasure, and the 20-year wait for pattern matching Scala 2 vs Scala 3: what changed and why Higher-kinded types explained accessibly Capabilities and effect polymorphism How capabilities can sandbox untrusted AI agents Scala in the real world: finance, Spark, media, education The future of programming languages in an AI-first world Timestamps: (00:00) Intro (00:31) Meet Martin Odersky, creator of Scala (03:11) Why Scala was created (04:49) How Scala took off (07:01) The story behind Scala’s name and logo (08:03) Java generics and Scala’s design principles (10:41) Haskell, functional programming, and Scala’s identity (12:18) Pizza, Java, and features that came later (14:28) Type erasure and higher-kinded types (16:05) Scala 2 vs Scala 3 (18:49) TASTy and Scala 3 compiler changes (19:21) What Martin would change about Scala (20:25) Kotlin, Java, and JVM languages (23:09) Capabilities, concurrency, and function coloring (29:28) Where Scala is used today (32:07) Scala’s ecosystem and community (36:50) Scala, AI agents, and the future of programming (43:17) Using AI and teaching programming in the AI era (45:56) Scala’s future (49:18) Why code review may be doomed (50:24) Giveaway question (51:26) Rapid fire questions (54:41) Outro New episodes every other Wednesday. Subscribe for more developer-focused conversations. 🎥 Watch the full episode on YouTube: https://youtu.be/Xn_YpUtXWT4
S2 · E8
May 20 · 42 min
Java at Spotify: Microservices, MCP & AI Overload – Mohamed Aboullaite | The Marco Show
Mohamed Aboullaite, backend engineer at Spotify, Java Champion, Google Cloud Developer Expert, and Docker Captain, joins Marco to talk about building AI-powered integrations at scale, what software engineering looks like when you're running five AI agents in parallel, and why the foundations still matter in an AI-first world. They discuss the engineering behind Spotify's ChatGPT integration (built on MCP), the non-determinism challenges of tool-calling, agentic coding workflows, review fatigue, and a frank conversation about the junior developer pipeline and what it takes to become senior today. 💡 In this episode: How Spotify's ChatGPT integration works (MCP apps, the Spotify widget inside ChatGPT) Siri/Alexa/Google Home backends and Spotify's ubiquity strategy Non-determinism in MCP tool-calling and how Spotify works around it Running 5 AI agents in parallel: the plan mode, review loops, cognitive fatigue Java at Spotify: monorepo, microservices, Backstage AI's impact on junior hiring and how to become senior anyway Finding mentors and the power of the Java community The token economy: measuring productivity by tokens burned ⏱️Timestamps: (00:00) Teaser (00:50) Meet Mohamed: Spotify backend engineer and Java Champion (01:53) What Mohamed works on at Spotify (03:12) Spotify inside ChatGPT and MCP apps (06:23) Building for new AI platforms (08:53) Spotify tools, playback, and device switching (09:48) Tool calling challenges with AI models (11:24) Using AI in day-to-day development (13:29) Running multiple coding agents in parallel (14:39) Why planning matters more than prompting (16:56) Review fatigue and cognitive load (19:43) Spotify’s backend, microservices, and Backstage (21:34) Java’s evolution and the AI era (24:14) Scala, Kotlin, Haskell, and JVM languages (25:46) Advice for junior developers in the AI age (29:27) How to become senior when AI solves everything (34:09) Finding mentors and growing through community (37:41) Giveaway question (39:28) Rapid-fire questions: Morocco, Sweden, Spotify, AI New episodes every other Wednesday. Subscribe for more developer-focused conversations. 🎥 Watch the full episode on YouTube: https://youtu.be/6WvoouJ9Mrk
S2 · E7
April 22 · 1 hr 11 min
The Future of Java in the Age of AI Agents - James Ward | The Marco Show
James Ward (Developer Advocate at AWS, Agentic AI Foundation Technical Committee Member) joins Marco to map out the fast-moving landscape of AI agents on the JVM. From MCP and ACP to Spring AI, Embabel, and Ktor — James explains how the JVM ecosystem has not only caught up with Python for building agents, but may have surpassed it. He also introduces SkillsJars (putting agent skills on Maven Central), explains effect-oriented programming and why it supercharges AI coding, and shares how he's been shipping five projects in two months entirely from his phone. 💡 In This Episode • Why the JVM is no longer second-class for AI agents • MCP vs ACP vs A2A — when to use which • Spring AI, Embabel (Rod Johnson), Ktor, LangChain4J compared • GOAP planning and domain-integrated context engineering • Agent skills vs MCP servers — and why skills are winning • SkillsJars: versioned, composable skills on Maven Central • Testing non-deterministic agents with evals • Effect-oriented programming and why types matter more than ever Timestamps: (00:00:00) Intro (00:00:49) Guest intro: James Ward, AWS, and the Agentic AI Foundation (00:01:37) Are developers now orchestrating AI agents? (00:02:51) Agent setup, context switching, and review fatigue (00:05:58) Why typed languages matter more in the AI era (00:07:14) Scala vs Kotlin vs Java (00:10:02) What agentic frameworks are and why they matter (00:14:08) MCP explained (00:19:42) ACP explained (00:21:56) How to get started with agent protocols and frameworks (00:23:43) JVM agent frameworks: Spring AI, Embabel, Koog, and LangChain4j (00:27:50) AIforJVM.com and building projects with AI (00:29:55) AI from your phone, dopamine, and productivity (00:33:14) Testing, evals, orchestration, and reliability in agent systems (00:41:03) What skills are and where they fit (00:43:46) SkillsJars and packaging skills for the JVM (00:49:34) Which AI standards will actually last? (00:55:35) Effect-oriented programming explained (01:06:37) Giveaway question (01:08:24) Rapid-fire round (01:10:58) Outro New episodes every other Wednesday. Subscribe for more developer-focused conversations. 🎥 Watch the full episode on YouTube: https://youtu.be/ACP0Nx-sW10
S2 · E6
April 8 · 1 hr 8 min
The Ugly Truth About Open Source - Andres Almiray | The Marco Show
Andres Almiray, Java Champion and creator of JReleaser, joins Marco to talk about the realities of open source, release automation, and the evolving Java ecosystem. They dive into what it really takes to maintain and grow open source projects, why code isn’t the most important part, and how communication, community, and sustainability determine whether projects thrive or die. The conversation also explores release engineering challenges, why most automation setups fail, and how tools like JReleaser simplify software delivery. 💡In this episode: Open source realities: burnout, maintenance, and sustainability Why code is NOT the most important part of OSS JReleaser and release automation in modern workflows Common CI/CD and release mistakes developers make Maven vs Gradle: trade-offs and real-world experience The future of the Java ecosystem and tooling AI in open source: PR spam, licensing, and quality concerns Advice for newcomers contributing to open source Timestamps: (00:00:00) Intro (00:00:41) Guest intro + Java journey (00:01:45) JReleaser: origin, use cases, and adoption (00:07:49) Software releases and automation best practices (00:11:31) JReleaser roadmap and release cadence (00:14:39) Commonhaus, open source sustainability, and succession (00:20:22) What makes open source projects successful (00:25:17) Burnout, community management, and prioritization (00:31:24) Hackergarten and open source collaboration (00:34:40) Motivation, Java’s evolution, and favorite features (00:40:44) Maven vs Gradle (00:44:29) CI/CD, supply chain security, and the future of Java tooling (00:53:16) AI, licensing, and open source contributions (01:01:39) Giveaway question (01:03:25) Rapid-fire round (01:06:04) Advice for getting started in open source (01:08:34) Outro New episodes every other Wednesday. Subscribe for more developer-focused conversations. 🎥 Watch the full episode on YouTube: https://www.youtube.com/watch?v=Jts62hWkRO8
S2 · E5
March 11 · 1 hr 12 min
How Spring Boot Really Works (From a Core Engineer) - Moritz Halbritter | The Marco Show
Moritz Halbritter, Spring Boot engineer at Broadcom and team lead for start.spring.io (Spring Initializr), joins Marco to talk about the inner workings of the Spring ecosystem and the future of Java performance. 💡 In this episode: GraalVM Native Image vs Project Leyden and Java startup performance Observability in Spring Boot (logs, metrics, tracing) Developer experience improvements: Testcontainers, Docker Compose, SSL hot reload AI coding tools, JSpecify nullability, and the future of Spring ⏱️Timecodes: (00:00) Teaser (00:53) Meet Moritz Halbretter from the Spring Boot team (02:23) From school programming to consulting to Spring (08:14) How Moritz joined the Spring team (14:20) Spring Native, GraalVM, and Project Leyden (25:35) Observability, Micrometer, and customer-driven features (32:08) Developer experience: Docker Compose, Testcontainers, SSL hot reload (40:35) JSpecify and annotating Spring Boot for nullability (45:12) start.spring.io and generating Spring projects (50:45) Using AI in coding, reviews, and open source PRs (57:30) Where Spring is headed in the next few years (1:00:08) Favorite languages, Kotlin, and Linux (1:01:13) Personal projects: solar monitoring, Modbus, and heat pump predictions (1:08:46) Giveaway and rapid-fire questions (1:11:32) Outro New episodes every other Wednesday. Subscribe for more developer-focused conversations. 🎥 Watch the full episode on YouTube: https://youtu.be/FUFsul26rgA
S2 · E4
February 25 · 1 hr 9 min
JobRunr: Java Job Scheduling, OSS Monetization, $17K Deals – Ronald Dehuysser
Ronald Dehuysser, creator of JobRunr, joins Marco to talk about distributed job scheduling in Java, building a high-throughput background processing framework, and turning an open-source side project into a profitable business. They dive into what really happens when microservices lack distributed tracing, why dead letter queues can silently lose invoices, how JobRunr scales to thousands of jobs per second, and what it takes to monetize open source in the Java ecosystem. 💡In this episode: Distributed job scheduling and background processing in Java JobRunr architecture and high-throughput performance Quartz vs modern scheduling approaches Retries, exponential backoff, and reliability patterns Dead letter queues and observability challenges Microservices vs monoliths in enterprise systems Monetizing open source and pro licensing models Enterprise sales and scaling a developer product Burnout, sustainability, and building a team AI, LLMs, and the future of junior developers ⏱️Timestamps (00:00) Teaser(00:48) Who's Ronald Dehuysser and what's JobRunr(01:37) From enterprise dev to freelancing (and switching to .NET)(11:19) Job scheduling pain and birth of JobRunr(16:21) Quitting, COVID, and building the first version(28:48) First customers and monetizing open source(40:13) Big enterprise deal and going full-time(47:16) Burnout, Vipassana, hiring, and building a team(53:20) Sustainability features and the future of JobRunr(56:08) AI, junior developers, the future of coding(01:07:28) Giveaway and Rapid-fire questions New episodes every other Wednesday. Subscribe for more developer-focused conversations. 🎥 Watch the full episode on YouTube: https://youtu.be/9Zgw_0kVFk8
S2 · E3
February 11 · 1 hr 30 min
Java Performance Myths: JIT vs AOT, GraalVM, Performance Engineering – Thomas Wuerthinger
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
S2 · E2
January 28 · 1 hr 11 min
From Google to Indie Dev: Mac Apps, Subscriptions, AI Coding – Daniel Gräfe
Daniel Gräfe, founder of Timing and Cotypist, joins Marco to talk about the realities of indie software development after leaving Big Tech. They discuss turning side projects into a real business, risky rewrites, subscription pricing, and how AI fits into day-to-day coding and support. Daniel shares lessons from more than a decade of building and maintaining Mac apps, including what worked, what didn’t, and why sustainability matters more than quick wins. A grounded conversation for developers thinking about indie SaaS, side projects, or life beyond a full-time engineering role. 💡 Topics in this episode: Leaving Google to go indie Side projects vs running a business Rewriting a product from scratch Subscription pricing decisions B2B vs B2C tradeoffs Using AI in everyday development Long-term maintenance and sustainability 🕑 Timestamps: (00:00) Intro (04:08) Timing, CoTypist, and Daniel’s background (05:30) Early side projects and first Mac apps (13:16) Getting into Google (20:02) Promotion, performance, Big Tech reality (27:33) Quitting Google and going indie (28:27) Rewriting Timing from scratch (37:52) Launch day, sales, and burnout (46:37) Subscriptions and pricing decisions (54:13) Using AI for coding and support (01:03:34) Advice for aspiring indie developers (01:12:10) Agency vs intelligence (01:13:22) Giveaway + outro New episodes every other Wednesday. Subscribe for more developer-focused conversations. 🎥 Watch the full episode on YouTube: https://youtu.be/t4DkaadHLnI
S2 · E1
January 14 · 1 hr 33 min
Are Integrated Tests a Scam? TDD, Architecture, Fast Feedback – J. B. Rainsberger
J. B. Rainsberger, TDD coach and software consultant, joins Marco to challenge common assumptions about software testing. They discuss why JB argues that “integrated tests are a scam,” how testing choices affect design and refactoring, and what teams get wrong when they rely too heavily on end-to-end tests. The conversation draws on decades of real-world experience working with development teams of all sizes. 💡 Topics in this episode: What “integrated tests” really are and why they cause problems Micro tests, fast feedback, and confidence-driven testing When deleting tests is the right decision How tests create pressure on system design Collaboration and contract tests explained Why there is no single testing best practice Practical advice for junior and senior developers New episodes every other Wednesday. Subscribe for more developer-focused conversations. ⏰ Timestamps: (00:00) Teaser (01:24) Intro (02:44) How J. B. got into testing (06:12) What “integrated tests” actually mean (10:42) Stop asking “what’s the right test size?” (13:22) Removing irrelevant details from tests (15:30) Refactoring, coupling, and deleting tests (18:08) “There’s no best practice.” (23:52) Old TDD books and timeless ideas (26:01) Collaboration and contract tests explained (33:53) “99.5% of your tests can be micro tests” (46:21) Do you want to be right or solve the problem? (01:00:48) Advice for junior developers (01:19:32) Testing strategy distilled (01:23:58) Manual QA testing (01:29:44) Giveaway (01:33:15) Rapid fire and outro 🎥 Watch the full episode on YouTube: https://youtu.be/j0NjFsb-at8
S1 · E9
Dec 22, 2025 · 10 min
Season Finale: Giveaway Winners & Q&A with Marco
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 themarcoshow@jetbrains.com 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
S1 · E8
Dec 10, 2025 · 1 hr 12 min
Modern Bytecode Instrumentation with ByteBuddy – Rafael Winterhalter
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
S1 · E7
Nov 26, 2025 · 1 hr 1 min
Scaling the Web: Lessons from Jetty, Bitronix, Terracotta, Quartz – Ludovic Orban
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
S1 · E6
Nov 12, 2025 · 47 min
Growing Quarkus in a Spring Boot World – Kevin Dubois (IBM)
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
S1 · E5
Oct 29, 2025 · 1 hr 30 min
Hibernate vs Spring Data vs jOOQ: Understanding Java Persistence | Thorben Janssen
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
S1 · E4
Oct 15, 2025 · 2 hr 13 min
Flyway: From Open Source Side Project to Multimillion Exit – Axel Fontaine
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

Showing 1–20 of 22 episodes