Behind the Commit

In this episode, I'm chatting with Larry Hastings — CPython core developer, release manager for Python 3.4 and 3.5, creator of the Gilectomy (an attempt to remove the GIL years before free-threaded Python), and the person who added = inside f-strings and Argument Clinic to CPython. Free-threaded Python is arriving, and threaded code is hard to test: if four threads grab a lock, you don't know which one gets it first, so a race condition that shows up once in a thousand runs almost never shows up in your test suite. We talk about why the Gilectomy got slower with every core he added, Guido's bar for removing the GIL, and Blanket, Larry's library that makes threading tests deterministic. He also explains how he built it with AI doing most of the typing, and why he still reviews every line.

Outline

0:00 Meet Larry Hastings: from the Gilectomy to free-threaded Python

0:57 Brett Cannon: 'Larry, do you want to be a core developer?'

2:14 Free-threaded Python ships: what's different from 10 years ago?

2:54 Why the Gilectomy failed: reference counting across threads

3:54 More cores, slower Python

4:49 Guido's bar for removing the GIL (and does free threading clear it?)

5:43 How do you test free-threaded code?

7:05 Four threads, one lock: which one gets it first?

8:53 100% coverage vs a race condition that happens 1 in 1,000 runs

9:26 How Blanket lets your test decide which thread wins

10:08 The hardest part wasn't technical: designing the API

12:41 'The GIL is a pair of crutches we need to throw away'

14:25 Advice for code meeting free-threaded Python for the first time

15:26 Pass your locks in as parameters (nobody likes monkey patching)

16:14 Human-guided AI development: how Blanket was built

17:06 AI's bad habits: 'I'm going to write a while loop and poll'

17:38 Not vibe coding: pair programming with AI

18:27 One session writes the proposal, two more review it

19:47 Vibe-documented: 'make it sound like I wrote it'

Episode links

– Blanket on GitHub: https://github.com/larryhastings/blanket

– Blanket on PyPI: https://pypi.org/project/blanket/

– Larry Hastings on GitHub: https://github.com/larryhastings

– Guido's Artima blog post on removing the GIL: https://www.artima.com/weblogs/viewpost.jsp?thread=214235

How do you maintain a Python package downloaded more than 40 million times every month, while working on it in your free time?

In this episode of Behind the Commit, Mia talks with Daniel Moran, the solo maintainer of FakeRedis, a pure-Python Redis-compatible implementation used for testing, compatibility checks, and server-agnostic development.

Daniel shares how FakeRedis grew from a personal solution into a widely used open-source project supporting Redis, Valkey, and Dragonfly. They also discuss maintaining a 73-variation CI matrix, AI-generated pull requests, avoiding burnout, monetizing a JetBrains GitHub Actions plugin, Django Commons, and his vision for FakeRedis becoming a standard in the ecosystem.

Outline

00:00 FakeRedis in numbers

00:24 What is FakeRedis?

02:32 Redis license changes

04:48 New use cases

06:21 Supporting Redis, Valkey, and Dragonfly

07:50 The 73-variation test matrix

10:45 Maintaining open source in your free time

16:10 AI and open-source maintenance

20:45 Building a JetBrains plugin

24:42 Django Commons

27:10 The future of FakeRedis

29:19 Connect with Daniel

Episode links

– https://plugins.jetbrains.com/plugin/19347-github-actions-manager – GitHub Actions Manager Plugin

– https://django-commons.org/ – Django Commons

– https://www.linkedin.com/in/daniel-moran-8a096a15/ – Daniel's LinkedIn profile

From 1–2 million to over 40 million downloads per month. Explore 73 variations and discover the DragonFly flavor, its commands, and supported arguments.

In this episode, I'm chatting with Emily Morehouse — CPython core developer, former Python Steering Council member, PSF Fellow, and co-founder and director of engineering at Cuttlesoft. She holds three degrees in theater, computer science, and criminology, and picked up Python in college simply because it was more fun than C++.

After Guido van Rossum announced at a Python conference that he wanted more women in CPython core development, she emailed Guido. He said yes and personally mentored her. She went on to implement the walrus operator (:=), one of the most controversial features in Python's history and one of the things that ultimately led Guido to step down as BDFL. She also chaired PyCon US for three years, two of which went fully online during the pandemic.

Outline

0:00 Episode highlights

0:26 Introduction

1:02 "If someone told you 10 years ago you'd be a core developer…"

1:47 Three degrees: theater, CS, and criminology

1:54 Journey into core development

2:43 Guido's call for female core developers

3:08 "My husband was elbowing me in the side"

3:20 What were you afraid of?

3:57 She emailed Guido — and he said yes

4:34 First language summit: realizing experts are human

5:08 What it's actually like to be mentored by Guido

5:43 The async Friday ritual with Guido and Eric Snow

6:22 Why there's no low-hanging fruit in CPython

7:10 Implementing the Walrus operator (:=)

8:27 Support from the core developer community

8:32 How to inspire more people into core development

9:38 People still reach out years later

10:04 Chairing PyCon US through a pandemic

11:05 What community work teaches you about leadership

12:54 How parenthood changed her relationship with open source

13:59 Practical first steps to contribute to CPython

14:56 Outro

Episode links

– CPython dev guide: https://devguide.python.org

– Cuttlesoft: https://cuttlesoft.com

– Emily on GitHub: https://github.com/emilyemorehouse

In this episode, I'm chatting with Emily Morehouse — CPython core developer, former Python Steering Council member, PSF Fellow, and co-founder and director of engineering at Cuttlesoft. She holds three degrees in theater, computer science, and criminology, and picked up Python in college simply because it was more fun than C++.

After Guido van Rossum announced at a Python conference that he wanted more women in CPython core development, she emailed Guido. He said yes and personally mentored her. She went on to implement the walrus operator (:=), one of the most controversial features in Python's history and one of the things that ultimately led Guido to step down as BDFL. She also chaired PyCon US for three years, two of which went fully online during the pandemic.

Full episode coming soon!

In this episode, I'm chatting with Kushal Das — public interest technologist, core team member at the Tor Project, core developer of CPython, and director at the Python Software Foundation. He is also the founder of dgplug and a maintainer of SecureDrop — the platform journalists use to communicate securely with whistleblowers. We talk about why privacy is increasingly hard to protect, the hidden cameras in your robot vacuum cleaner, what happens to data once it leaves your hands, and what any developer can do right now to build more privacy-respecting software.

Outline

0:00 Episode highlights

0:17 Introduction

0:38 "Privacy is a human right" — is it?

1:22 What turned Kushal from technologist to privacy advocate

2:57 SecureDrop: what it is and who it protects

3:33 How SecureDrop works in practice

5:36 Biggest technical challenges building SecureDrop

6:35 Helping people living under authoritarian regimes

10:38 Vacuum cleaner cameras and the toilet photo incident

11:44 The year hackers took over vacuum cleaners and shouted at owners

13:44 Why Kushal removed Alexa from his home

16:08 Social media as a surveillance tool

18:24 Stalkerware: when someone close to you is tracking your every move

19:31 Cambridge Analytica, the Great Hack, and election manipulation

21:43 Are governments fast enough to regulate technology?

22:55 Once you upload something to the internet, it never comes back

25:20 AI tools and what happens to the data you share with them

35:15 "If you break encryption, it will be broken for everyone"

37:36 How to fight for privacy

40:04 EFF, Tor Project, and where to get involved

Episode links

– Tor Project: https://www.torproject.org

– SecureDrop: https://securedrop.org

– EFF: https://www.eff.org

– Stop Stalkerware: https://stopstalkerware.org

– dgplug: https://dgplug.org

– Kushal's blog: https://kushaldas.in

In this upcoming episode, I chat with Kushal Das — core team member at the Tor Project, core developer of CPython, and director at the Python Software Foundation. We talk about the hidden cameras inside your robot vacuum cleaner, why encryption is non-negotiable, and what it actually takes to protect people's privacy online.

Have you ever wondered what astrophysics has in common with the software running in your car, your coffee machine, and NASA's internal tools?

In this episode, I sit down with Cristian Maureira-Fredes, a PhD in Astrophysics who decided to leave academia to join the software industry. Today, he is a Research and Development Principal Manager at The Qt Company, where he leads the team behind Qt for Python (PySide6) and the Qt Core team.

Outline:

00:00 The persistence of C++ in industry

00:14 Introducing Kristian: From Astrophysics to Qt

01:13 The history and Open Source roots of Qt

02:58 Why we can’t just "rewrite" C++ in Rust

03:52 How PySide (Qt for Python) bindings work

05:07 The challenge of finding new C++ contributors

06:17 Impact of LLMs on understanding complex code

07:34 Qt in the real world: NASA, cars, and coffee machines

08:50 Why Qt uses Gerrit instead of GitHub

10:36 Where does the name "Qt" come from?

11:15 Conclusion

What does a PhD in Astrophysics have in common with the software running in your car, your coffee machine, and NASA’s internal tools? In this episode I sit down with Cristian Maureira-Fredes, a Research and Development Principal Manager at The Qt Company. Cristian leads the team behind Qt for Python (PySide6) and the Qt Core team.

In this episode, I'm chatting with Maria Ashna — PyPI support specialist at the Python Software Foundation and founder of Magic Lightbulb, a tech and product consulting firm. PyPI serves nearly a million developers and is the backbone of Python's entire package ecosystem — maintained by a team of just four people. Maria shares what her role actually looks like day to day, how she cleared a backlog that was delayed by over a year, what happens when a package maintainer passes away, and what's coming next for PyPI organizations.

Outline

0:00 Episode highlights

0:45 Introduction to Maria Ashna

1:11 What does a PyPI support specialist actually do?

2:07 The history of PyPI — born in 2003, formerly "the cheese shop"

2:47 How many people work on PyPI?

3:27 Most common support issues: account recovery and 2FA

3:48 2FA is now 100% mandatory on PyPI

4:10 Clearing a 500+ ticket backlog delayed by over a year

6:14 What is PEP 541?

7:01 What happens when users don't respond?

8:07 The edge case nobody thinks about: users who have passed away

8:30 How to open a ticket with the PyPI team

10:43 PyPI Organizations: what are they and who are they for?

13:17 Is PyPI going commercial? (No)

15:01 Nearly 1 million users, team of 4

15:38 How do you actually pronounce PyPI?

16:13 Where to find Maria online

Episode links

– PyPI: https://pypi.org

– PEP 541: https://peps.python.org/pep-0541/

– Maria on GitHub: https://github.com/despy-brain

– Contact Maria: [email protected]