Python’s quest for parallelism has plenty of plot twists: threads that don’t really run together, async that isn’t actually parallel, and a masked villain known as the GIL. This talk unpacks the mystery and shows how modern Python is finally changing the ending.

🐍 Python’s Quest for Parallelism

Python has threads. Python has asyncio. Python runs on machines with many CPU cores.

So why does CPU-bound Python code still run… one thing at a time?

This talk dives into one of Python’s most misunderstood topics — parallelism — and unravels the mystery behind why “doing things at the same time” so often isn’t actually happening.

🧩 Act I: Setting the Stage

We begin by building a clear mental model of how Python executes code:

What really separates a program, a process, and a thread
How Python threads map to OS threads — and where they stop helping
Why coroutines and asyncio are powerful… but not parallel

This foundation sets up the twist.

🎭 Act II: Unmasking the Villain

Enter the real antagonist: the Global Interpreter Lock (GIL).

Through visuals and concrete examples, we’ll uncover:

What the GIL actually is (and what it is not)
How it silently serializes CPU-bound execution
Why multiple threads don’t mean multiple cores in CPython

Cue the Scooby-Doo moment.

🛠 Act III: Escaping the GIL

The quest doesn’t end there. We’ll explore the real paths to parallelism in modern Python:

Multiprocessing: true parallelism, real costs
Subinterpreters (PEP 684): shared process, separate interpreters
Free-Threaded Python (PEP 703): a GIL-optional future — with trade-offs

Each option is evaluated honestly: performance, overhead, object sharing, and ecosystem readiness.

🧠 Final Reveal: Choosing the Right Weapon

The talk concludes with a side-by-side comparison of threads, subinterpreters, and processes, giving you a practical decision framework you can apply immediately.

🎯 Who Should Attend

Python developers confused by concurrency vs parallelism
Engineers hitting CPU bottlenecks
Anyone curious about Python’s post-GIL future

🚀 What You’ll Leave With

A clear mental model of Python execution
A deep understanding of the GIL and its impact
Confidence in choosing the right parallelism strategy for your workload

Python is changing the ending. This talk shows you how — and when — to embrace it.

Slide: https://docs.google.com/presentation/d/1TVdfff8znECOf4S6h02oPWumRJrgbVh7eXSWc0_luM8/edit?slide=id.g3ab03e53318_1_0#slide=id.g3ab03e53318_1_0

🎯 Speaker & Relevance

I’m a Software Engineer at Intuit, working on Python-based systems where performance, scalability, and reliability are real constraints. This talk comes from solving—and repeatedly seeing—confusion around “Python concurrency” vs actual parallelism in production contexts.

🧠 Technical Scope

The content is grounded in current CPython behavior and roadmap, including:

Global Interpreter Lock (GIL)
Threads, processes, and coroutines
Subinterpreters (PEP 684)
Free-threaded Python (PEP 703)

Focus: accuracy and practical decision-making, not speculation.

🖥 Technical Requirements

Slides only (no live demos)
Projector/screen for diagrams
No special hardware or network access

👥 Audience Fit

Intermediate Python developers and above
Assumes basic familiarity with threading or async
No interpreter-internals knowledge required

⏱ Why This Matters Now

Python’s execution model is changing fast. This talk helps attendees understand what works today, what’s emerging, and how to choose the right approach for CPU-bound vs I/O-bound workloads.

Python’s Quest for Parallelism

Elevator Pitch

Description