The Marco Show

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

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

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

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

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