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.

Afleveringen

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

    2 DGN GELEDEN

    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

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

    28 JAN

    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

    1u 12m
  3. Are Integrated Tests a Scam? TDD, Architecture, Fast Feedback – J. B. Rainsberger

    14 JAN

    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

    1u 34m
  4. Season Finale: Giveaway Winners & Q&A with Marco

    22-12-2025

    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

    10 min
  5. Modern Bytecode Instrumentation with ByteBuddy – Rafael Winterhalter

    10-12-2025

    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

    1u 13m
  6. Scaling the Web: Lessons from Jetty, Bitronix, Terracotta, Quartz – Ludovic Orban

    26-11-2025

    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

    1u 2m
  7. Growing Quarkus in a Spring Boot World – Kevin Dubois (IBM)

    12-11-2025

    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

    48 min
  8. Hibernate vs Spring Data vs jOOQ: Understanding Java Persistence | Thorben Janssen

    29-10-2025

    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

    1u 30m
  9. Flyway: From Open Source Side Project to Multimillion Exit – Axel Fontaine

    15-10-2025

    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

    2u 14m
  10. Hibernate: Myths & Over-Engineering. ORMs vs SQL vs Hexagonal — Gavin King

    01-10-2025

    Hibernate: Myths & Over-Engineering. ORMs vs SQL vs Hexagonal — Gavin King

    📺 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.

    1u 43m
  11. Software Performance: Avoiding Slow Code, Myths & Sane Approaches – Casey Muratori | The Marco Show

    17-09-2025

    Software Performance: Avoiding Slow Code, Myths & Sane Approaches – Casey Muratori | The Marco Show

    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 lagExpectations for game server concurrencyParsing a billion rows in Java: lessons in performanceContainers, cloud, and performance mythsAI: helpful tool or unethical theft?Why Casey would get rid of Python ⏱️ Timestamps: (00:00) Teaser (01:00) Meet Casey Muratori (04:00) The Windows Terminal story (15:00) The “excuse parade” of slow software (18:30) Game servers and performance expectations (24:00) The billion-row Java challenge (46:00) Getting 30x performance gains (52:00) Modern CPUs and performance myths (01:09:00) Should companies rewrite bloated software? (01:18:00) Casey’s take on AI (01:33:00) AI and ethics: who owns the data? (01:40:00) Rapid-fire questions: OS, IDEs, languages (01:50:00) Giveaway and Outro New episodes every other Wednesday. Subscribe for more deep, developer-focused conversations. Watch the episodes on YouTube: https://youtu.be/apREl0KmTdQ

    1u 52m
  12. LLMs for Devs: Model Selection, Hallucinations, Agents, AGI – Jodie Burchell | The Marco Show

    02-09-2025

    LLMs for Devs: Model Selection, Hallucinations, Agents, AGI – Jodie Burchell | The Marco Show

    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 tasksEnhanced vs adaptive thinking (is it just branding?)Corporate considerations: cost, privacy, and hostingThe ethics and lawsuits shaping AI’s futurePredictions 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: @t_redactyl@fosstodon.org Follow The Marco Show: Instagram: @themarco.show TikTok: @themarco.show

    1u 27m
  • 12 afleveringen

Info

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.

Informatie

  • Maker
    IntelliJ IDEA
  • Jaren actief
    2025 - 2026
  • Afleveringen
    12
  • Beoordeling
    Veilig
  • Copyright
    © IntelliJ IDEA
  • Website van aflevering
    The Marco Show

Suggesties voor jou