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.

  1. Why Scala Changed Programming Languages Forever - Martin Odersky | The Marco Show

    3 giu

    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

    55 min
  2. Java at Spotify: Microservices, MCP & AI Overload – Mohamed Aboullaite | The Marco Show

    20 mag

    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

    42 min
  3. The Future of Java in the Age of AI Agents - James Ward | The Marco Show

    22 apr

    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

    1h 11m
  4. The Ugly Truth About Open Source - Andres Almiray | The Marco Show

    8 apr

    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

    1h 9m
  5. How Spring Boot Really Works (From a Core Engineer) - Moritz Halbritter | The Marco Show

    11 mar

    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 performanceObservability in Spring Boot (logs, metrics, tracing)Developer experience improvements: Testcontainers, Docker Compose, SSL hot reloadAI 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

    1h 12m
  6. JobRunr: Java Job Scheduling, OSS Monetization, $17K Deals – Ronald Dehuysser

    25 feb

    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

    1h 10m
  7. Java Performance Myths: JIT vs AOT, GraalVM, Performance Engineering – Thomas Wuerthinger

    11 feb

    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

    1h 31m
  8. From Google to Indie Dev: Mac Apps, Subscriptions, AI Coding – Daniel Gräfe

    28 gen

    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

    1h 12m
Elenco completo (18)

Descrizione

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.

Informazioni

  • Creatore
    IntelliJ IDEA
  • Anni di attività
    2025 - 2026
  • Puntate
    18
  • Classificazione
    Contenuti adatti a tutti
  • Copyright
    © IntelliJ IDEA
  • Sito web del podcast
    The Marco Show

Potrebbero piacerti anche…