Uploaded August 2026 | Updated November 2026, 4 days ago
[EuroPython 2026 - S2 on 2026-07-15]
π€ *How CPython errors keep getting better by Florian Freitag*
π https://ep2026.europython.eu/session/how-cpython-errors-keep-getting-better
π Abstract:
The upcoming Python 3.15 keeps improving error messages, which will be the fourth out of the last five releases to establish this most recent tradition. Good errors help developers debug faster and keep beginners from giving up in frustration
In this talk we go all the way back to 2008 and explore how error messages evolved from Python 3.0 to today. Along the way we will also go into what makes up a good error message and why they are often so hard to get right. We'll also touch on how academia and research let us down and why good errors remain an art more than an exact science. I will also talk about my personal experience and the ~~bad~~ _unfortunate_ error message I encountered during my first teaching job that fueled my passion for compiler and language development.
Finally, I will also argue why you not only don't have to be a compiler engineer to contribute to python errors but why not being one might be an actual advantage.
By the end, you will have learned what makes a good error message, how to spot a bad one and how to fix them.
---
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: creativecommons.org/licenses/by-nc-sa/4.0
[EuroPython 2026 - S2 on 2026-07-15]
π€ *How CPython errors keep getting better by Florian Freitag*
π https://ep2026.europython.eu/session/how-cpython-errors-keep-getting-better
π Abstract:
The upcoming Python 3.15 keeps improving error messages, which will be the fourth out of the last five releases to establish this most recent tradition. Good errors help developers debug faster and keep beginners from giving up in frustration
In this talk we go all the way back to 2008 and explore how error messages evolved from Python 3.0 to today. Along the way we will also go into what makes up a good error message and why they are often so hard to get right. We'll also touch on how academia and research let us down and why good errors remain an art more than an exact science. I will also talk about my personal experience and the ~~bad~~ _unfortunate_ error message I encountered during my first teaching job that fueled my passion for compiler and language development.
Finally, I will also argue why you not only don't have to be a compiler engineer to contribute to python errors but why not being one might be an actual advantage.
By the end, you will have learned what makes a good error message, how to spot a bad one and how to fix them.
---
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: creativecommons.org/licenses/by-nc-sa/4.0
![Beyond `Optional` in Real-World Projects: Missing, `None`, and Unset - Koudai Aono
[EuroPython 2026 - S4 on 2026-07-15]
π€ *Beyond `Optional` in Real-World Projects: Missing, `None`, and Unset by Koudai Aono*
π https://ep2026.europython.eu/session/beyond-optional-in-real-world-projects-missing-none-and-unset
π Abstract:
Have you ever merged a config file, applied an input that says update only these fields, or handled an API payload, only to overwrite data because missing, `None`, and unset were treated as the same thing?
In real-world projects, no value has at least three meanings:
- a missing key (the field is absent),
- an explicit `None` (the value is present and intentionally null),
- an unset input (the caller didnt specify the field, so you must not touch it).
When we collapse these into `T | None` (a nullable type) or fall back to `dict[str, Any]`, type checking becomes noisy, branching becomes fragile, and refactors get risky. Every field nullable, every check defensive, every change scary.
This is a practical talk about using typing to model and safely consume real-world data with `TypedDict` and `dataclasses`, not a typing tutorial or a framework pitch. Well walk through one end-to-end example (payload - normalization - domain model - safe updates) with before/after code and focus on patterns you can apply immediately:
- Use `Required` / `NotRequired` to model missing keys instead of abusing `T | None`.
- Use `T | None` only when `None` is a meaningful value.
- Represent unset inputs with a sentinel pattern (starting from `UNSET = object()` and optionally evolving to `typing_extensions.Sentinel`) so partial updates dont silently overwrite data and the type checker can distinguish unset from `None`.
- Keep extraction code honest with type aliases, `TypeIs`, and (optionally) small `match` cases for readability.
After this session, youll be able to define stricter data models, write safer extraction code, and make schema changes less painful, because your types will reflect what your data actually means. This talk is for intermediate Python developers who already use type hints in production.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ Beyond `Optional` in Real-World Projects: Missing, `None`, and Unset - Koudai Aono](https://i.ytimg.com/vi/JuLEUIsdTjo/mqdefault.jpg)
![From Ticket Taker to Problem Solver: Discovery for Senior Thinking - Damian Wysocki
[EuroPython 2026 - S4 on 2026-07-17]
π€ *From Ticket Taker to Problem Solver: Discovery for Senior Thinking by Damian Wysocki*
π https://ep2026.europython.eu/session/from-ticket-taker-to-problem-solver-discovery-for-senior-thinking
π Abstract:
Have you ever built a feature perfectly, only to discover it solved the wrong problem? Or made architectural decisions that seemed right in isolation but fell apart when business needs changed? You were missing context.
Discovery workshops give developers what tickets cant: the full picture. This talk explores how proper discovery phase work transforms developers from ticket executors into empowered problem solvers who make better decisions and have more fun doing it.
Developers with discovery artifacts like Business Model Canvas summaries, entity relation diagrams, and mapped user segments write better code. They understand why revenue streams demand certain performance characteristics, how customer segments shape feature priorities, and how key partnerships affect API design.
This talk walks through the discovery process from a developer perspective. Youll see what artifacts actually help us code, how business requirements map to technical architecture, and why understanding the problem space before touching code prevents costly rework. Well cover epics, user stories, service architecture, and wireframes, but more importantly, how they connect to real business value.
Discovery workshops reduce surprises, empower confident decisions, and accelerate your growth from developer to senior engineer by teaching you to think beyond tickets. Learn how to work smarter by knowing the WHY, not just the WHAT.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ From Ticket Taker to Problem Solver: Discovery for Senior Thinking - Damian Wysocki](https://i.ytimg.com/vi/KMvFT4mL5M4/mqdefault.jpg)



![Write async. Get sync for free - Thom Lane
[EuroPython 2026 - S4 on 2026-07-15]
π€ *Write async. Get sync for free by Thom Lane*
π https://ep2026.europython.eu/session/write-async-get-sync-for-free
π Abstract:
When you write a Python library, you have a dilemma. Ship async-only? Ship blocking-only? Or write everything twice and watch both copies drift?
Synchronicity (https://github.com/modal-labs/synchronicity) removes this dilemma. Write your library once (in async) and get a blocking interface for free, while avoiding the boilerplate and limitations of `asyncio.run()` wrappers. Weβll talk through how to handle persistent connections, async generators, clean tracebacks, type hints and more.
Weve used it in production at Modal for years, and its fully open source. We hope it can save you from writing your own library twice!
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ Write async. Get sync for free - Thom Lane](https://i.ytimg.com/vi/MOZL9XgepxM/mqdefault.jpg)



![Inside Python 3.15s JIT Optimizer - Ken Jin
[EuroPython 2026 - S1 on 2026-07-15]
π€ *Inside Python 3.15s JIT Optimizer by Ken Jin*
π https://ep2026.europython.eu/session/inside-python-3-15-s-jit-optimizer
π Abstract:
Python 3.15s JIT is finally starting to see real speedups on benchmarks. Core to that is a revamped JIT optimizer. *What* the JIT selects to compile and *how* it optimizes code has seen significant improvements thanks to the work of many contributors. In this talk, I will cover in-depth how the Python JIT optimizes your Python code, and how this was an amazing community team effort spanning multiple continents.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ Inside Python 3.15s JIT Optimizer - Ken Jin](https://i.ytimg.com/vi/NN_kHSIw0SY/mqdefault.jpg)
![Args: Amazing or Approaching? - Evan Kohilas
[EuroPython 2026 - S1 on 2026-07-16]
π€ *Args: Amazing or Approaching? by Evan Kohilas*
π https://ep2026.europython.eu/session/args-amazing-or-approaching
00:00 - Intro
01:21 - Arguments vs Parameters
01:55 - Example intro
02:21 - Problems of adding optional parameters
03:20 - Solution via wrapper functions
03:59 - Solution via function overloading
04:29 - Pythons lack of function overloading
05:10 - Solution via Pythons default arguments
05:52 - Problems of Pythons default arguments
07:16 - How other languages use the builder pattern to solve optional arguments without function overloading
07:56 - Problems of the builder pattern
08:33 - Problems of function overloading
09:07 - Benefits of Pythons keyword arguments
11:30 - re.sub example problem
13:30 - re.sub example solution using the `*` parameter
13:37 - How to enforcing keyword arguments using the `*` parameter
14:25 - Problems when using the `*` parameter
15:14 - Solution via PEP736
15:31 - Solution via linters
16:34 - The `/` parameter, and problems of Pythons keyword arguments
18:06 - How the `/` parameter helps with parameter renaming
18:32 - Benefits of Swifts handling of external and internal parameter names
19:36 - How Javascript similarly handles external and internal parameter names
20:24 - How the `**` operator in Python allows for unpack arguments from dictionaries
21:08 - How the `...rest` property allows Javascript to handle unexpected arguments
21:21 - How the `**kwargs` parameter allows Python to handle unexpected arguments
22:19 - How Python 2 used to handle parameter unpacking
22:53 - Problems of `**kwargs` and solution using the `/` parameter
23:40 - How the `*args` parameter allows an arbitrary number of arguments
25:15 - Are arbitrary arguments a good idea? Why doesnt Rust support them?
25:38 - How arbitrary arguments make it difficult to understand function definitions
26:01 - Typing arbitrary arguments
26:36 - Recap of Pythons function parameter and argument system
27:37 - Outro
π Abstract:
From default args, to `**kwargs`, and everything in-between, Pythons comprehensive argument system lends itself to some of the most effective code, through encouraging readability, reuse, and easy refactoring.
But is that really true? Why, and why not?
What could we learn from other languages?
And what else could lie in their future?
In this session, well give a rundown of Pythons comprehensive function argument system and how its features allow for safety, conciseness, and expressiveness (whether youre calling or writing functions).
Well then give examples for where that system lacks, where it could bite you, and give suggestions for what more could be done on Python code to fix those limitations.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ Args: Amazing or Approaching? - Evan Kohilas](https://i.ytimg.com/vi/NQRU9bmVkyw/mqdefault.jpg)