{
"33RGZA": {
"abstract": "IIoT Networks' performance is significantly impacted by packet losses in the network, which is the failure of data packets in reaching their intended destination within the network. Most of the transmission control protocol versions reduce the rate of transmission during the detection of packet losses, assuming network congestion and interference, thus resulting in operational disruption, reduced efficiency, data integrity failure and economic impact.\r\nHowever, not all packet losses are due to congestions and interference, some happen based on link issues from wireless which are seen as non-congestive packet losses as most transmission control protocol (TCP) modifications reduce the rate of transmission when these losses are detected while assuming network congestion, so TCP could not at present distinguish among these types of packet losses and reduces the rate of transmission irrespective of the types thus resulting in lower throughput for IIoT networks clients. \r\nIn addressing this issue, a heuristic-rule-based machine learning model was used for packet loss identification, classification, and prediction to differentiate between the types of packet losses at the IIoT network hosts\u2019 end. The result shows that Random Forest performs better based on the rule, giving a hopeful resolution to an enhanced IIoT network's performance.",
"code": "33RGZA",
"delivery": "in-person",
"duration": "60",
"end": "2026-07-15T13:50:00+02:00",
"level": "intermediate",
"next_session": null,
"prev_session": null,
"resources": null,
"room": "Exhibit Hall",
"session_type": "Poster",
"sessions_after": [
"3HBWHB",
"DRXC3E",
"NWLBJC",
"US3W8J",
"ZRWENU"
],
"sessions_before": [
"CBA98V",
"HJ8KPY",
"NEH7RE",
"UPELCT",
"W9NLXV"
],
"sessions_in_parallel": [
"LNVDY3",
"PRGGNW"
],
"slug": "heuristic-rule-based-model-for-packet-loss-inference-in-iiot-networks",
"speakers": [
"DGMZXX"
],
"start": "2026-07-15T12:50:00+02:00",
"title": "Heuristic-Rule Based Model for Packet Loss Inference in IIoT Networks",
"track": "Machine Learning: Research & Applications",
"tweet": "A heuristic-rule based machine learning model to distinguish between packet losses is important in IIoT devices.",
"website_url": "https://ep2026.europython.eu/session/heuristic-rule-based-model-for-packet-loss-inference-in-iiot-networks",
"youtube_url": null
},
"3APM9B": {
"abstract": "Are you new to EuroPython? Or perhaps you're feeling overwhelmed by all the activities, sessions, and networking opportunities happening at EuroPython 2026? Whether you're a first-time attendee or a returning participant looking to make the most of your conference experience, this session is designed for you. Join us to discover essential tips and strategies for navigating the conference smoothly and efficiently. We'll cover everything from understanding the schedule and choosing the right sessions to attend, to making meaningful connections with fellow developers and speakers. You'll learn insider tricks for managing your time effectively, finding the best networking opportunities, and ensuring you don't miss out on the most valuable experiences the conference has to offer. By the end of this session, you'll feel confident and prepared to dive into EuroPython 2026 with a clear plan for maximizing your learning and networking potential.",
"code": "3APM9B",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-14T18:00:00+02:00",
"level": "beginner",
"next_session": null,
"prev_session": "3TZHB9",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Announcements",
"sessions_after": [],
"sessions_before": [
"3TZHB9",
"BTTFFJ",
"K7XNTF",
"N39TFS",
"ZSRZPC"
],
"sessions_in_parallel": [],
"slug": "beginner-s-orientation",
"speakers": [],
"start": "2026-07-14T17:00:00+02:00",
"title": "Beginner's Orientation",
"track": null,
"tweet": "Join the Beginner's Orientation to learn how to surf EuroPython 2026!",
"website_url": "https://ep2026.europython.eu/session/beginner-s-orientation",
"youtube_url": null
},
"3FDLUS": {
"abstract": "Quantum computing is often introduced either through high-level circuit abstractions or through heavy theoretical formalism. Developers frequently struggle to bridge the gap between textbook concepts, real algorithms, and hardware-aware execution. This tutorial provides a practical, hands-on introduction to quantum computing using QiliSDK, a Python framework designed to support both digital and analog workflows in a unified and modular way.\r\n\r\nThe session begins with the foundations: qubits, quantum states, gates, and measurement. Participants will implement basic circuits and understand how quantum programs are constructed, simulated, and executed. From there, we move to algorithmic patterns such as variational circuits and Hamiltonian-based workflows, demonstrating how quantum programs can be expressed in a clean and composable API.\r\n\r\nThe core value of the tutorial is depth without unnecessary abstraction. Attendees will not only build and simulate quantum circuits, but also explore time evolution, noise models, and backend selection. We will demonstrate how the same high-level program can target different execution layers, including simulators and hardware-oriented backends. For advanced participants, we will introduce pulse-level programming concepts, showing how quantum operations map to control-level primitives and how pulse-based experiments can be expressed in the SDK.\r\n\r\nBy the end of the tutorial, participants will have:\r\n\r\n- A clear understanding of core quantum computing concepts.\r\n- Hands-on experience building and simulating quantum circuits.\r\n- Exposure to variational and Hamiltonian-based workflows.\r\n- Insight into noise modeling and realistic execution.\r\n- An understanding of how circuit-level abstractions connect to pulse-level control.\r\n\r\nThis tutorial is designed for developers and researchers who want a practical entry point into quantum computing without sacrificing architectural clarity. Prior experience with Python is required. No prior quantum computing knowledge is assumed, though basic linear algebra familiarity is helpful.",
"code": "3FDLUS",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-14T12:45:00+02:00",
"level": "intermediate",
"next_session": "3TZHB9",
"prev_session": null,
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Tutorial",
"sessions_after": [
"3TZHB9",
"K7XNTF",
"N39TFS",
"ZSRZPC"
],
"sessions_before": [],
"sessions_in_parallel": [
"BTTFFJ",
"MENRZG",
"TGGHKC",
"ZPCDKE"
],
"slug": "learn-quantum-computing-with-qilisdk-from-circuits-to-pulse-level-control",
"speakers": [
"HCHWDW"
],
"start": "2026-07-14T09:30:00+02:00",
"title": "Learn Quantum Computing with QiliSDK: From Circuits to Pulse-Level Control",
"track": "Jupyter and Scientific Python",
"tweet": "Hands-on quantum computing with QiliSDK: build circuits, run simulations, explore noise, and connect algorithms to pulse-level control.",
"website_url": "https://ep2026.europython.eu/session/learn-quantum-computing-with-qilisdk-from-circuits-to-pulse-level-control",
"youtube_url": null
},
"3FW7UF": {
"abstract": "Coding often looks boring or challenging at the beginning, but the more we code, the more it becomes interesting, and we hope to be better in it. From my background, schools don\u2019t always teach the exciting ways for us to learn coding, which makes many teenagers of my age not realise how simple Python programming can assist them in real life and day-to-day activities. Also, the adults within the Python community don\u2019t know that the future of Python programming depends on bringing new and young beginners like me into the community at an early stage, so this session discusses how teenagers can use their communication interests in learning Python.\r\n\r\nLearning Python at a young age can expose us to various skills and help us develop our reasoning, as teenagers face a lot of distractions today through social media chats. Showing how Python can be learned through simple chat interactions makes Python programming more accessible and friendly.\r\n\r\nAs a teenager and beginner myself, I have an idea of how teenagers chat regularly on phones and applications, so chatting can also be a way of learning Python, so schools and communities like Python can discover this method to introduce Python to teenagers as a beginner. Python doesn\u2019t need to be scary; it can feel like chatting with a friend who explains things step by step. By combining Python with conversational learning, we can remove fear, build confidence, and make coding a normal part of teenage life.\r\n\r\nThis session will expose how teenagers can use simple conversation in WhatsApp to ask questions and learn Python as a chat. The audience will understand the tools and techniques for introducing Python to young people in a way that fits their communication style and how conversational learning makes Python more fun and less intimidating.",
"code": "3FW7UF",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T16:20:00+02:00",
"level": "beginner",
"next_session": "BDUAKE",
"prev_session": "SASJQU",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Talk",
"sessions_after": [
"BDUAKE"
],
"sessions_before": [
"8HBEYS",
"9URK9U",
"BFK3JK",
"BMQP7J",
"NS8QQA",
"SASJQU",
"TAZHCD"
],
"sessions_in_parallel": [
"9JALSN",
"UY9UAG"
],
"slug": "python-learning-that-fits-teen-life",
"speakers": [
"3LKBHX"
],
"start": "2026-07-16T15:50:00+02:00",
"title": "Python Learning that fits Teen Life",
"track": "Community Building, Education, Outreach",
"tweet": "Coding often looks boring at the beginning, but the more we code, the more interesting & better in it, let us chat our way into Python as a Teenager",
"website_url": "https://ep2026.europython.eu/session/python-learning-that-fits-teen-life",
"youtube_url": null
},
"3HBWHB": {
"abstract": "Sometimes, one writes code to answer an important scientific question. On other occasions, code is developed with some economic interest in mind, legitimate or otherwise. And then there are situations where something else is going on. This work, which I call _June Gloom_, is just that: something else. Specifically, it is about producing pretty pictures, inspired by very real analog art and executed by using a somewhat abstract toy model for magnetism from statistical mechanics. In my presentation, I will show how we can use Monte Carlo techniques to perform physically accurate computer simulations. The results obtained from these simulations are then turned into both static as well as interactive visualizations using Matplotlib.",
"code": "3HBWHB",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T14:20:00+02:00",
"level": "beginner",
"next_session": "7VKQQM",
"prev_session": "UPELCT",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"7VKQQM",
"ENK9EF",
"HVTSPC",
"SWCWKZ",
"ZRWENU"
],
"sessions_before": [
"33RGZA",
"CBA98V",
"HJ8KPY",
"LNVDY3",
"NEH7RE",
"PRGGNW",
"UPELCT",
"W9NLXV"
],
"sessions_in_parallel": [
"DRXC3E",
"NWLBJC",
"US3W8J"
],
"slug": "how-to-blend-python-physics-and-art-to-create-hopefully-pretty-pictures",
"speakers": [
"PPQPPU"
],
"start": "2026-07-15T13:50:00+02:00",
"title": "How to blend Python, physics, and art to create (hopefully) pretty pictures",
"track": "Python for Games, Art, Play and Expression",
"tweet": "How about just producing pretty pictures? Inspired by very real analog art and executed by applying techniques from theoretical physicl physics.",
"website_url": "https://ep2026.europython.eu/session/how-to-blend-python-physics-and-art-to-create-hopefully-pretty-pictures",
"youtube_url": null
},
"3KT3BW": {
"abstract": "\"TBD: Keynote Speaker\"\r\nDetails coming soon. This prime session will feature an inspiring keynote address to set the tone for the entire event. Our team is finalizing an exceptional speaker whose insights and vision will leave a lasting impression. Check back shortly for the full announcement, topic, and speaker biography.",
"code": "3KT3BW",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-16T10:05:00+02:00",
"level": "beginner",
"next_session": "TZHTEE",
"prev_session": null,
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Keynote",
"sessions_after": [
"788XZA",
"8HBEYS",
"9URK9U",
"CWBA3L",
"ETBPVR",
"TZHTEE",
"UGM7F8"
],
"sessions_before": [],
"sessions_in_parallel": [],
"slug": "keynote-3-placeholder",
"speakers": [],
"start": "2026-07-16T09:20:00+02:00",
"title": "Keynote 3 - Placeholder",
"track": null,
"tweet": "\"TBD: Keynote Speaker\" Details coming soon. This prime session will feature an inspiring keynote address to set the tone for the entire event.",
"website_url": "https://ep2026.europython.eu/session/keynote-3-placeholder",
"youtube_url": null
},
"3QHVK3": {
"abstract": "Do you know what is a sprint?\r\n\r\nThe sprints are activities that will happen during the weekend on a different location.\r\nDo you know if you can join? and how can you join?\r\nDo you know all the projects that are participating?\r\n\r\nLet us answer these questions and a few more in the Sprint orientation.",
"code": "3QHVK3",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T18:25:00+02:00",
"level": "beginner",
"next_session": null,
"prev_session": "8XMJGZ",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Announcements",
"sessions_after": [],
"sessions_before": [
"8XMJGZ",
"BPJHWT",
"BX77EE",
"GP39VP",
"LRVCYU",
"MP9ZRM",
"U7AHP3",
"WHHAQK"
],
"sessions_in_parallel": [],
"slug": "sprint-orientation",
"speakers": [],
"start": "2026-07-17T17:55:00+02:00",
"title": "Sprint Orientation \ud83c\udfc3",
"track": null,
"tweet": "Do you know what is a sprint? The sprints are activities that will happen during the weekend on a different location. Do you know if you can join?",
"website_url": "https://ep2026.europython.eu/session/sprint-orientation",
"youtube_url": null
},
"3TZHB9": {
"abstract": "You\u2019ve likely used a tool like black, flake8, or ruff to lint or format your code, or a tool like sphinx to document it, but you probably do not know how they accomplish their tasks. These tools and many more use **Abstract Syntax Trees (ASTs)** to analyze and extract information from Python code. An AST is a representation of your code's structure that enables you to access and manipulate its different components, which is what makes it possible to automate tasks like code migrations, linting, and docstring extraction.\r\n\r\nIn this workshop, you\u2019ll learn how to use the Python standard library\u2019s ast module to parse and analyze code. Using just the standard library, we will implement a couple of common checks from scratch, which will give you an idea of how these tools work and help you build the skills and confidence to use ASTs in your own projects.",
"code": "3TZHB9",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-14T17:00:00+02:00",
"level": "intermediate",
"next_session": "3APM9B",
"prev_session": "3FDLUS",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Tutorial",
"sessions_after": [
"3APM9B"
],
"sessions_before": [
"3FDLUS",
"BTTFFJ",
"MENRZG",
"TGGHKC",
"ZPCDKE"
],
"sessions_in_parallel": [
"K7XNTF",
"N39TFS",
"ZSRZPC"
],
"slug": "process-analyze-and-transform-python-code-with-asts",
"speakers": [
"9WJJPL"
],
"start": "2026-07-14T13:45:00+02:00",
"title": "Process, Analyze, and Transform Python Code with ASTs",
"track": "Python Core, Internals, Extensions",
"tweet": "Come learn how to use the Python standard library\u2019s `ast` module to parse and analyze code.",
"website_url": "https://ep2026.europython.eu/session/process-analyze-and-transform-python-code-with-asts",
"youtube_url": null
},
"788XZA": {
"abstract": "This is the real story about the design, benchmark, tuning and operation of a 24x7 multi-tenant network monitoring platform, that started out at only 1 packet/second, but then with the power of Python it scaled to 1 million packet/second.\r\n\r\nIt is like an high performance version of ICMP ping and mtr/traceroute, supports dualstack IP v4/v6, and runs 24x7 on a set of probing nodes distributed Worldwide.\r\n\r\nEach ICMP packet needs to be scheduled, crafted, sent, analyzed and stored for query in near-time.\r\n\r\nTo make things harder, the probing platform has been designed and tuned to use the least amount of resources as CPU, memory and storage, in order to run on cheap burstable cloud instances.\r\n\r\nPython is used everywhere: packet scheduling, generate randomized ICMP packets, send them via RAW sockets, and match results from probing.\r\n\r\nProbing results are then pushed to ClickHouse in near-time, and visualized via Grafana.\r\n\r\nAnd rest assured that every packet counts.\r\n\r\nSome of the concept explored during the talk:\r\n- ICMP protocol, BGP protocol, routing table\r\n- ping, mtr/traceroute\r\n- RAW socket in Python, crafting ICMP packets\r\n- tcpdump, PCAP dump file\r\n- msgpack, zstd compression\r\n- object storage\r\n- Apache Parquet as optimized data storage format\r\n- near-time batch and streaming data workflow\r\n- performance profiling and tuning\r\n- Python vs PyPy performance comparison\r\n- monitoring of the monitor: probing node performance monitoring",
"code": "788XZA",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-16T11:15:00+02:00",
"level": "intermediate",
"next_session": "BYWVNK",
"prev_session": "3KT3BW",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk (long session)",
"sessions_after": [
"8HBEYS",
"9URK9U",
"AGX8D9",
"BYWVNK",
"DWGSFA",
"G9FDRY",
"JQSQBB"
],
"sessions_before": [
"3KT3BW"
],
"sessions_in_parallel": [
"CWBA3L",
"ETBPVR",
"TZHTEE",
"UGM7F8"
],
"slug": "from-one-to-1-million-packet-second-scaling-global-internet-monitoring",
"speakers": [
"P3TRFT"
],
"start": "2026-07-16T10:30:00+02:00",
"title": "From one to 1 million packet/second: scaling global Internet monitoring",
"track": "DevOps, Cloud, Scalable Infrastructure",
"tweet": "From one to 1 million packet/second: the real story about design, tune and operating a distributed high performance network monitoring platform",
"website_url": "https://ep2026.europython.eu/session/from-one-to-1-million-packet-second-scaling-global-internet-monitoring",
"youtube_url": null
},
"7NWR9R": {
"abstract": "What if AI could help design 3D worlds without taking creative control away from humans?\r\n\r\nIn this talk, I will present a hosted Blender agent that creates and edits 3D scenes from natural language. The agent runs Blender headlessly inside Docker, communicates with it through a TCP socket protocol, and exposes Python-powered tools for scene creation, object manipulation, materials, screenshots, rendering, and asset import. It is built with the Microsoft Agent Framework and Azure AI Foundry, using Python as the bridge between the LLM, Blender\u2019s scripting API, cloud storage, and the hosted runtime.\r\n\r\nMore than a technical demo, this talk explores a potential future pipeline for AI-assisted 3D creation: a workflow where artists, game designers, architects, and developers can iteratively generate, inspect, modify, and refine 3D environments while keeping human control at every stage. Instead of replacing creative tools, the agent becomes a programmable collaborator that can accelerate repetitive work, propose variations, and turn high-level intent into editable Blender scenes.\r\n\r\nThrough live examples, we will discuss what this could mean for the future of video game world-building, virtual production, and 3D architecture: faster prototyping, more accessible scene creation, and new ways to move from idea to interactive environment. Attendees will leave with a practical architecture for building Python agents that operate real creative software, and a grounded view of both the opportunities and current limitations of human-in-the-loop AI for 3D design.",
"code": "7NWR9R",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T14:25:00+02:00",
"level": "intermediate",
"next_session": "WHHAQK",
"prev_session": "SCZ8ZK",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Sponsored",
"sessions_after": [
"NTZ7DG",
"QY7PFR",
"T7ATVM",
"WHHAQK",
"ZFJEUJ"
],
"sessions_before": [
"BJBKRM",
"FBQQXS",
"PWGSJQ",
"SCZ8ZK",
"SQRYJA"
],
"sessions_in_parallel": [
"BX77EE",
"GP39VP",
"PBTPJR",
"RGBSS8",
"U7AHP3",
"UGLF7Q",
"VSZSMW"
],
"slug": "when-python-agents-meet-3d-automating-blender-from-natural-language",
"speakers": [
"GYZDCU"
],
"start": "2026-07-17T13:55:00+02:00",
"title": "When Python Agents Meet 3D: Automating Blender from Natural Language",
"track": "Python for Games, Art, Play and Expression",
"tweet": "Design 3D worlds with Python, Blender, and AI agents\u2014while keeping humans in control from prompt to final render.",
"website_url": "https://ep2026.europython.eu/session/when-python-agents-meet-3d-automating-blender-from-natural-language",
"youtube_url": null
},
"7SSS93": {
"abstract": "Music generation has gone from a research curiosity to something you can try in a browser. Commercial platforms and open source models can produce full songs from a text prompt. Between the hype and the technical papers, it\u2019s hard to get a straight answer about what\u2019s actually going on under the hood. **This talk is a clear, honest walkthrough of how music generation systems work, in simple language**, no deep machine learning knowledge needed.\r\n\r\nWe start with the core challenge: how do you turn a continuous audio signal into something a generative model can work with? Neural audio codecs solve this by compressing waveforms into sequences of discrete tokens, and this idea is the foundation everything else builds on. From there, we look at the two main modeling strategies: token prediction and diffusion. We compare what each does well, where it struggles, and why the choice between them matters.\r\n\r\nOn the practical side, we walk through the open source models and Python tools available today, and what you can build with them. Then we get into evaluation, one of the most important open problems in the field. Current metrics only tell part of the story, and there is no standard benchmark for comparing systems. This has real consequences for how research moves forward and how models get used.\r\n\r\nWe close with a discussion that often gets skipped: how artists and musicians see these tools, what legal questions remain around training data and copyright, and why these conversations matter for the future of the field.\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b",
"code": "7SSS93",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T11:35:00+02:00",
"level": "beginner",
"next_session": "PQCHT3",
"prev_session": "DBBNQD",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk",
"sessions_after": [
"BX77EE",
"GP39VP",
"PQCHT3",
"QXZMP8",
"SCZ8ZK",
"U7AHP3",
"VKURLV",
"VSZSMW"
],
"sessions_before": [
"DBBNQD",
"KFQN3X",
"LFSJYL",
"RB9TKP",
"SGM9SV"
],
"sessions_in_parallel": [
"ARRMQR",
"FBQQXS",
"TG7YMS"
],
"slug": "how-music-generation-actually-works",
"speakers": [
"8HVY9P"
],
"start": "2026-07-17T11:05:00+02:00",
"title": "How Music Generation Actually Works",
"track": "Python for Games, Art, Play and Expression",
"tweet": "A clear view of how AI music generation works: codecs, models, Python tools, evaluation, and why it matters. No ML background needed.\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b",
"website_url": "https://ep2026.europython.eu/session/how-music-generation-actually-works",
"youtube_url": null
},
"7VKQQM": {
"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?\r\n\r\nIn real-world projects, \"no value\" has at least three meanings:\r\n\r\n- a missing key (the field is absent),\r\n- an explicit `None` (the value is present and intentionally null),\r\n- an unset input (the caller didn't specify the field, so you must not touch it).\r\n\r\nWhen 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.\r\n\r\nThis 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. We'll 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:\r\n\r\n- Use `Required` / `NotRequired` to model missing keys instead of abusing `T | None`.\r\n- Use `T | None` only when `None` is a meaningful value.\r\n- Represent unset inputs with a sentinel pattern (starting from `UNSET = object()` and optionally evolving to `typing_extensions.Sentinel`) so partial updates don't silently overwrite data and the type checker can distinguish unset from `None`.\r\n- Keep extraction code honest with type aliases, `TypeIs`, and (optionally) small `match` cases for readability.\r\n\r\nAfter this session, you'll 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.",
"code": "7VKQQM",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T15:00:00+02:00",
"level": "intermediate",
"next_session": "H7KGU3",
"prev_session": "3HBWHB",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"H7KGU3",
"PCMBVT",
"RMY7Y7",
"WKBHZW",
"ZRWENU"
],
"sessions_before": [
"33RGZA",
"3HBWHB",
"DRXC3E",
"HJ8KPY",
"LNVDY3",
"NWLBJC",
"PRGGNW",
"US3W8J"
],
"sessions_in_parallel": [
"ENK9EF",
"HVTSPC",
"SWCWKZ"
],
"slug": "beyond-optional-in-real-world-projects-missing-none-and-unset",
"speakers": [
"BPFJEJ"
],
"start": "2026-07-15T14:30:00+02:00",
"title": "Beyond `Optional` in Real-World Projects: Missing, `None`, and Unset",
"track": "Python Core, Internals, Extensions",
"tweet": "In real-world Python, \"no value\" means three different things. This talk shows how to type them apart with TypedDict, sentinels, and dataclasses.",
"website_url": "https://ep2026.europython.eu/session/beyond-optional-in-real-world-projects-missing-none-and-unset",
"youtube_url": null
},
"8HBEYS": {
"abstract": "The poster shows a [railroad diagram](https://en.wikipedia.org/wiki/Syntax_diagram) of the entire [Python grammar](https://docs.python.org/3/reference/grammar.html).\r\n\r\nIt allows exploring subtle details of the language, like when parentheses are required around generator expressions, tuples or \u201cwalrus\u201d assignment operations; what's the precedence of various operators; or what kinds of arguments are possible in function definitions and calls.",
"code": "8HBEYS",
"delivery": "in-person",
"duration": "60",
"end": "2026-07-16T14:00:00+02:00",
"level": "beginner",
"next_session": null,
"prev_session": null,
"resources": null,
"room": "Exhibit Hall",
"session_type": "Poster",
"sessions_after": [
"93XE3S",
"NXNHSB",
"PPQ3KE",
"UY9UAG",
"VNR377"
],
"sessions_before": [
"9MRVPM",
"GEJAQW",
"JSLSHM",
"LN7EF3",
"YKWMBZ"
],
"sessions_in_parallel": [
"9URK9U",
"B7CMBD",
"BMQP7J",
"E3GVVR",
"FB93DB",
"MJTZ7A"
],
"slug": "python-syntax-diagram",
"speakers": [
"SCAGQW"
],
"start": "2026-07-16T13:00:00+02:00",
"title": "Python Syntax Diagram",
"track": "Python Core, Internals, Extensions",
"tweet": "A railroad diagram showing the grammar of the Python language",
"website_url": "https://ep2026.europython.eu/session/python-syntax-diagram",
"youtube_url": null
},
"8XMJGZ": {
"abstract": "\"TBD: Keynote Speaker\"\r\nDetails coming soon. This prime session will feature an inspiring keynote address to set the tone for the entire event. Our team is finalizing an exceptional speaker whose insights and vision will leave a lasting impression. Check back shortly for the full announcement, topic, and speaker biography.",
"code": "8XMJGZ",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-17T16:55:00+02:00",
"level": "beginner",
"next_session": "YUECR3",
"prev_session": "ZHCNDY",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Keynote",
"sessions_after": [
"YUECR3"
],
"sessions_before": [
"BPJHWT",
"BX77EE",
"GP39VP",
"LRVCYU",
"MP9ZRM",
"U7AHP3",
"WHHAQK",
"ZHCNDY"
],
"sessions_in_parallel": [],
"slug": "keynote-6-placeholder",
"speakers": [],
"start": "2026-07-17T16:10:00+02:00",
"title": "Keynote 6 - Placeholder",
"track": null,
"tweet": "\"TBD: Keynote Speaker\" Details coming soon. This prime session will feature an inspiring keynote address to set the tone for the entire event.",
"website_url": "https://ep2026.europython.eu/session/keynote-6-placeholder",
"youtube_url": null
},
"93XE3S": {
"abstract": "Has this ever happened to you? You're happily coding a new feature in your Python project, and at some point, you make a hasty call:\r\n\r\n```\r\nself._thing.do_someting(rnicro_meters=10)\r\n```\r\n\r\nYou've written unit tests for it, including an assertion line:\r\n\r\n```\r\nmock_do_someting.assret_called_once_with(rnicro_meters=10)`\r\n```\r\n\r\nThe tests pass, the CI is green, the PR is reviewed and merged. But some time later, the service crashes because the real method does not have the `rnicro_meters` keyword argument in the first place. What happened? And more importantly, did you notice any of the mistakes above? This is a problem we've faced more than a few times over the past few years, and that's a few too many.\r\n\r\nUnit tests are crucial in any sort of Python development, from small libraries to large distributed systems. `unittest.mock` is used to isolate dependencies and mock external calls in order to keep the tests simple and focused. But mistakes can slip by (e.g.: attribute typos, wrong keyword arguments, wrong patch locations), just like the three mistakes above, leading to false positive tests and a false sense of confidence in our code quality. This can happen because `Mock` and `MagicMock` silently auto-creates attributes on the fly, even when those attributes do not exist on the real object. These issues become even more pronounced as dependencies change and projects evolve.\r\n\r\nIn this session, we\u2019ll look at why these false positives happen, and how to avoid them. Topics include:\r\n\r\n- Understand how `Mock` and `MagicMock` allow invalid attributes and calls.\r\n- Common pitfalls and anti-patterns with `Mock`, `MagicMock`, and `patch`.\r\n- Using `spec`, `spec_set`, and `autospec` to force mocks to match real objects.\r\n- Ensuring patched functions and methods have their signatures validated.\r\n- How to avoid patching the wrong import path.\r\n- Introducing guardrails in existing projects (e.g. OpenStack\u2019s approach) without rewriting the entire test suite.",
"code": "93XE3S",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T14:45:00+02:00",
"level": "intermediate",
"next_session": "SASJQU",
"prev_session": "E3GVVR",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Talk",
"sessions_after": [
"BFK3JK",
"NS8QQA",
"SASJQU",
"TAZHCD",
"UY9UAG"
],
"sessions_before": [
"8HBEYS",
"9URK9U",
"B7CMBD",
"BMQP7J",
"E3GVVR",
"FB93DB",
"MJTZ7A"
],
"sessions_in_parallel": [
"NXNHSB",
"PPQ3KE",
"VNR377"
],
"slug": "what-is-this-footgun-called-unittest-mock-and-how-to-avoid-misusing-it",
"speakers": [
"LLRS88"
],
"start": "2026-07-16T14:15:00+02:00",
"title": "What is this footgun called unittest.mock, and how to avoid misusing it",
"track": "Testing, Quality Assurance, Security",
"tweet": "Your unittests are green, but are they lying? Avoid false positives with safer mocking patterns, or else you'll be the one getting mocked!",
"website_url": "https://ep2026.europython.eu/session/what-is-this-footgun-called-unittest-mock-and-how-to-avoid-misusing-it",
"youtube_url": null
},
"9EFAJS": {
"abstract": "Open source software (OSS) is today an integral part of software solutions and the software industry as a whole. However, it is often the case that not all parts of an organization are equally familiar with the OSS ecosystem and the specific licenses upon which it relies. Since this ecosystem is built on intellectual property, discussions about using OSS, patching existing OSS projects, or publishing one's own software as an OSS project inevitably involve conversations with the legal department at some point. In this talk, we will discuss some of the fundamentals of intellectual property, OSS licenses, how lawyers tend to think about software in general, and how to convince them that OSS is a good idea.",
"code": "9EFAJS",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-15T11:30:00+02:00",
"level": "beginner",
"next_session": "HJ8KPY",
"prev_session": "BJCYNE",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Talk (long session)",
"sessions_after": [
"33RGZA",
"CBA98V",
"HJ8KPY",
"KRMBWS",
"LNVDY3",
"PRGGNW",
"UPELCT",
"VXDYGX"
],
"sessions_before": [
"BJCYNE"
],
"sessions_in_parallel": [
"DWBGJ9",
"M8Q77Z",
"QT97WA",
"Y8QAUA"
],
"slug": "how-to-talk-with-your-legal-department-about-open-source",
"speakers": [
"AVHBH8"
],
"start": "2026-07-15T10:45:00+02:00",
"title": "How to Talk With Your Legal Department About Open Source",
"track": "Ethics, Social Responsibility, Sustainability, Legal",
"tweet": "Developers and the legal department tend to have different approaches when thinking about open source. In this talk, we will try to bridge that gap.",
"website_url": "https://ep2026.europython.eu/session/how-to-talk-with-your-legal-department-about-open-source",
"youtube_url": null
},
"9JALSN": {
"abstract": "The CPython runtime is some of the most-used software in the world. Part of maintaining a secure software project like CPython is participating in coordinated vulnerability disclosure (CVD). This process allows security researchers and maintainers of projects to work together to fix vulnerabilities and alert the public, keeping all Python programmers and users safe.\r\n\r\nIn this talk attendees will learn about how the Python language organizes its security team, how to balance security and open source contribution in coordinated vulnerability disclosure, and the latest in how open source projects can maintain a sustainable vulnerability disclosure program. Attendees that aren\u2019t currently contributing to open source projects, but have an interest in their dependencies being secure, will learn ways they can contribute meaningfully to the security of open source projects they depend on.",
"code": "9JALSN",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T16:20:00+02:00",
"level": "beginner",
"next_session": "BDUAKE",
"prev_session": "TAZHCD",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"BDUAKE"
],
"sessions_before": [
"8HBEYS",
"9URK9U",
"BFK3JK",
"BMQP7J",
"NS8QQA",
"SASJQU",
"TAZHCD"
],
"sessions_in_parallel": [
"3FW7UF",
"UY9UAG"
],
"slug": "learning-from-the-not-so-secret-python-security-cabal",
"speakers": [
"KKVUH8"
],
"start": "2026-07-16T15:50:00+02:00",
"title": "Learning from the not-so-secret Python security \"cabal\"",
"track": "Testing, Quality Assurance, Security",
"tweet": "It\u2019s dangerous to go alone! \ud83d\udc0d\ud83d\udee1\ufe0f Learn sustainable open source security practices for projects of all sizes from the Python Security Response Team.",
"website_url": "https://ep2026.europython.eu/session/learning-from-the-not-so-secret-python-security-cabal",
"youtube_url": null
},
"9MRVPM": {
"abstract": "Production has a special talent for turning \u201cseems fine\u201d into \u201cwhy is everything on fire?\u201d \u2014 usually because we\u2019re missing signals. A service restarts and never becomes ready, a background worker silently stops consuming tasks, or a database gets overloaded and latency creeps up until downstream services (or customers) notice it first. These situations aren\u2019t unsolvable \u2014 they\u2019re preventable with the right signals in place.\r\n\r\nI\u2019ve seen how stressful this gets when a system is already in production, but there\u2019s no clear guidance or shared \u201cwhere to look first\u201d playbook; so every incident starts with guesswork. Over time, we turned those lessons into a lightweight standard that replaces panic mode with a predictable investigation flow.\r\n\r\nIn this talk, I\u2019ll share a practical, vendor-agnostic observability checklist for a Python setup with three cooperating workloads: an HTTP API, an event-driven worker, and a scheduled daily job. Each workload fails differently, so each requires a different set of signals to stay observable.\r\n\r\nWe\u2019ll cover what \u201cgood enough\u201d looks like for logging, metrics, tracing, and alerting: what to instrument first, what pitfalls to avoid, and how to design alerts that catch problems early without creating noise. You\u2019ll leave with a concrete checklist and a phased rollout order you can apply to your own Python services \u2014 without rewriting your system or committing to a specific monitoring vendor.\r\n\r\n## **Takeaways**\r\n- A baseline observability checklist every service should have: health/readiness, logging with consistent context, core metrics, and alert routing\r\n- Workload-specific signals: what to watch in APIs vs background workers vs scheduled jobs, and why one size doesn\u2019t fit all\r\n- Structured logging that works in production: a minimal event schema + contextual fields that speed up debugging\r\n- Must-have alerts that prevent silent failures: service never becomes ready, worker stalls, scheduled job misses its run, sustained latency increase\r\n- Where tracing adds value: when it\u2019s worth the effort, what \u201cminimal viable tracing\u201d looks like, and what\u2019s optional at the beginning\r\n- A rollout sequence you can apply incrementally: what to do first, what to add later",
"code": "9MRVPM",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T12:35:00+02:00",
"level": "intermediate",
"next_session": "MJTZ7A",
"prev_session": "BYWVNK",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"8HBEYS",
"9URK9U",
"B7CMBD",
"BMQP7J",
"E3GVVR",
"FB93DB",
"MJTZ7A"
],
"sessions_before": [
"AGX8D9",
"BYWVNK",
"DWGSFA",
"G9FDRY",
"JQSQBB"
],
"sessions_in_parallel": [
"GEJAQW",
"JSLSHM",
"LN7EF3",
"YKWMBZ"
],
"slug": "stop-firefighting-practical-observability-for-python-apis-workers-jobs",
"speakers": [
"WTJPR3"
],
"start": "2026-07-16T12:05:00+02:00",
"title": "Stop firefighting: practical observability for Python APIs, workers & jobs",
"track": "DevOps, Cloud, Scalable Infrastructure",
"tweet": "A practical observability checklist for Python APIs, workers and cron jobs: logs, metrics, tracing, alerts.",
"website_url": "https://ep2026.europython.eu/session/stop-firefighting-practical-observability-for-python-apis-workers-jobs",
"youtube_url": null
},
"9URK9U": {
"abstract": "Have you ever wondered how to write good unit tests?\r\nDo you know the best practices for unit testing?\r\nOr maybe you\u2019re already using unit tests in your project and want to see how others approach them?\r\n\r\nIf the answer to any of these questions is yes, this talk is for you. During the session, you\u2019ll learn how to write proper unit tests, discover good testing practices, learn to distinguish mocks from stubs, see examples of using dependency injection to improve testability, and find out what pure functions are and why they\u2019re easier to test.",
"code": "9URK9U",
"delivery": "in-person",
"duration": "60",
"end": "2026-07-16T14:00:00+02:00",
"level": "beginner",
"next_session": null,
"prev_session": null,
"resources": null,
"room": "Exhibit Hall",
"session_type": "Poster",
"sessions_after": [
"93XE3S",
"NXNHSB",
"PPQ3KE",
"UY9UAG",
"VNR377"
],
"sessions_before": [
"9MRVPM",
"GEJAQW",
"JSLSHM",
"LN7EF3",
"YKWMBZ"
],
"sessions_in_parallel": [
"8HBEYS",
"B7CMBD",
"BMQP7J",
"E3GVVR",
"FB93DB",
"MJTZ7A"
],
"slug": "how-we-write-unit-test-in-my-team-in-openchip",
"speakers": [
"PHABML"
],
"start": "2026-07-16T13:00:00+02:00",
"title": "How we write unit test in my team in Openchip",
"track": "Testing, Quality Assurance, Security",
"tweet": "A practical intro to writing effective unit tests: key techniques, best practices, and improved testability.",
"website_url": "https://ep2026.europython.eu/session/how-we-write-unit-test-in-my-team-in-openchip",
"youtube_url": null
},
"9V77RU": {
"abstract": "Welcome to EuroPython 2026! Please notice the registration will happen on the TBD.\r\nYou can pick up your badges at any time during the week as long as we are open!\r\nIf you want to avoid the morning rush on Wednesday, come on Monday and Tuesday!\r\n\r\nWe hope to see you around!",
"code": "9V77RU",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T09:00:00+02:00",
"level": "beginner",
"next_session": "BJCYNE",
"prev_session": null,
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Announcements",
"sessions_after": [
"BJCYNE"
],
"sessions_before": [],
"sessions_in_parallel": [],
"slug": "wednesday-registration-welcome-tbd",
"speakers": [],
"start": "2026-07-15T08:00:00+02:00",
"title": "Wednesday Registration & Welcome @ TBD",
"track": null,
"tweet": "EuroPython 2026 Wednesday Conference Registration & Welcome from the Volunteers",
"website_url": "https://ep2026.europython.eu/session/wednesday-registration-welcome-tbd",
"youtube_url": null
},
"AGX8D9": {
"abstract": "Deploying a Python web app is deeply confusing for newcomers, but it doesn't have to be! In this talk, I'll provide an overview of the entire process, with visuals and code, to demystify it and share hard-won lessons along the way.\r\n\r\nWe will start with a high-level overview of the architecture underpinning deployment: web servers vs. app servers, queues, security considerations, databases, caching, environment variables, and more. Then we will discuss Python-specific aspects, such as how WSGI (PEP 333) standardized the process across all frameworks. Finally, we will review a deployment checklist for Django, Flask, and FastAPI, highlighting where they overlap and where they differ.\r\n\r\nThe goal of this talk is to explain how web deployments work under the hood, highlighting the Python-specific technical underpinnings that enable a knowledgeable developer to quickly deploy any Python web app, whether using FastAPI, Django, or Flask.",
"code": "AGX8D9",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T11:55:00+02:00",
"level": "intermediate",
"next_session": "YKWMBZ",
"prev_session": "CWBA3L",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Talk",
"sessions_after": [
"8HBEYS",
"9MRVPM",
"9URK9U",
"GEJAQW",
"JSLSHM",
"LN7EF3",
"YKWMBZ"
],
"sessions_before": [
"788XZA",
"CWBA3L",
"ETBPVR",
"TZHTEE",
"UGM7F8"
],
"sessions_in_parallel": [
"BYWVNK",
"DWGSFA",
"G9FDRY",
"JQSQBB"
],
"slug": "deploying-python-web-apps-in-2026",
"speakers": [
"Z38FJK"
],
"start": "2026-07-16T11:25:00+02:00",
"title": "Deploying Python Web Apps in 2026",
"track": "Web Development, Web APIs, Front-End Integration",
"tweet": "Every website must be deployed. This talk provides a clear, practical model for deploying Python web apps, across frameworks.",
"website_url": "https://ep2026.europython.eu/session/deploying-python-web-apps-in-2026",
"youtube_url": null
},
"ARRMQR": {
"abstract": "Most Pythonistas handle Python objects every day, but sometimes, the bugs and performance surprises we encounter happen because we misunderstand how Python actually manages memory. \r\nVariables are not just containers(which I previously thought), objects are not copied by default, and references behave differently than what many developers expect \u2014 especially as the codebases we work with grow.\r\nIn this talk, we will build an accurate mental model of how Python handles objects, references, and memory at runtime; we will look at what really happens when objects are created, passed to functions, mutated, and destroyed. \r\nWe will also look at how reference counting works at a high level, why mutability matters, and how these fundamental concepts come up when we examine debugging and performance in our Python code.\r\nAfter this session, developers will be more confident about their understanding of Python behaviour, avoid common pitfalls, and better understand what the profilers and debuggers are really saying.",
"code": "ARRMQR",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T11:35:00+02:00",
"level": "beginner",
"next_session": "VKURLV",
"prev_session": "KFQN3X",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"BX77EE",
"GP39VP",
"PQCHT3",
"QXZMP8",
"SCZ8ZK",
"U7AHP3",
"VKURLV",
"VSZSMW"
],
"sessions_before": [
"DBBNQD",
"KFQN3X",
"LFSJYL",
"RB9TKP",
"SGM9SV"
],
"sessions_in_parallel": [
"7SSS93",
"FBQQXS",
"TG7YMS"
],
"slug": "pointers-objects-and-references-how-python-manages-memory",
"speakers": [
"SKGET8"
],
"start": "2026-07-17T11:05:00+02:00",
"title": "Pointers, Objects, and References - How Python Manages Memory",
"track": "Python Core, Internals, Extensions",
"tweet": "In this session, we will look at how Python manages memory\u2014references, mutability, garbage collection, and performance.",
"website_url": "https://ep2026.europython.eu/session/pointers-objects-and-references-how-python-manages-memory",
"youtube_url": null
},
"B7CMBD": {
"abstract": "Step 1: Fix a bug\r\nStep 2: ???\r\nStep 3: Core developer\r\n\r\nOk, it's not that simple but it's also not as mysterious as it might seem!\r\n\r\nAbout three years ago I fixed an obscure bug in the unittest module. Today, I'm a core developer. This talk is about what happened in between, and how you can start contributing too!\r\n\r\nOver the years, I got to work on many different areas of Python. I've fixed bugs in the parser, added import autocomplete to the REPL, worked on gettext tooling, and eventually found my way to the JIT compiler, all things I knew little about before diving in.\r\n\r\nGetting started contributing to Python can be intimidating, so I'll share some practical things I learned along the way such as:\r\n\r\n- How is the CPython project organized?\r\n- How do you find something to work on? (and why it doesn't have to be code!)\r\n- What happens after you submit a PR?\r\n- How do you navigate a 30 year old codebase without getting lost?\r\n\r\nIf you've ever wanted to contribute to Python but weren't sure where to start, this talk is for you.",
"code": "B7CMBD",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T13:15:00+02:00",
"level": "beginner",
"next_session": "NXNHSB",
"prev_session": "GEJAQW",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"93XE3S",
"NXNHSB",
"PPQ3KE",
"UY9UAG",
"VNR377"
],
"sessions_before": [
"9MRVPM",
"GEJAQW",
"JSLSHM",
"LN7EF3",
"YKWMBZ"
],
"sessions_in_parallel": [
"8HBEYS",
"9URK9U",
"BMQP7J",
"E3GVVR",
"FB93DB",
"MJTZ7A"
],
"slug": "become-a-python-core-developer-in-3-easy-steps",
"speakers": [
"YX7F3Y"
],
"start": "2026-07-16T12:45:00+02:00",
"title": "Become a Python Core Developer in 3 Easy Steps",
"track": "Python Core, Internals, Extensions",
"tweet": "Would you like to contribute to CPython but don't know where to start? This talk is for you!",
"website_url": "https://ep2026.europython.eu/session/become-a-python-core-developer-in-3-easy-steps",
"youtube_url": null
},
"BDUAKE": {
"abstract": "\"TBD: Keynote Speaker\"\r\nDetails coming soon. This prime session will feature an inspiring keynote address to set the tone for the entire event. Our team is finalizing an exceptional speaker whose insights and vision will leave a lasting impression. Check back shortly for the full announcement, topic, and speaker biography.",
"code": "BDUAKE",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-16T17:15:00+02:00",
"level": "beginner",
"next_session": "DJU8GK",
"prev_session": "9JALSN",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Keynote",
"sessions_after": [
"DJU8GK"
],
"sessions_before": [
"3FW7UF",
"8HBEYS",
"9JALSN",
"9URK9U",
"BFK3JK",
"NS8QQA",
"UY9UAG"
],
"sessions_in_parallel": [],
"slug": "keynote-4-placeholder",
"speakers": [],
"start": "2026-07-16T16:30:00+02:00",
"title": "Keynote 4 - Placeholder",
"track": null,
"tweet": "\"TBD: Keynote Speaker\" Details coming soon. This prime session will feature an inspiring keynote address to set the tone for the entire event.",
"website_url": "https://ep2026.europython.eu/session/keynote-4-placeholder",
"youtube_url": null
},
"BFK3JK": {
"abstract": "Nobody likes a slow application or a website. Not only can it frustrate your users, but it can also directly affect your business metrics, such as conversion rates. Without proper care, your application can easily slow down as your project grows.\r\n\r\nOne of the most common sources of slowdowns is your database. Django ORM makes it easy to work with databases, but it also makes it easy to forget how to use it properly.\r\n\r\nIn this talk, you will learn how to measure and diagnose database operations in your Django app, fix common issues, and leverage your database engine's features to unleash its full potential. We will cover topics such as N+1 queries, creating and using database views from Django, database indices and EXPLAINing queries (I\u2019ll keep it easy to understand, I promise!).\r\n\r\nWhile the session focuses on Django apps, most of the topics also apply to SQLAlchemy and other libraries.\r\n\r\nAfter the talk, you will know how to diagnose database query performance and have a good understanding of how to fix common performance bottlenecks.\r\n\r\nYou\u2019ll need basic knowledge of the Django ORM or a similar tool like SQLAlchemy, as well as general database concepts.",
"code": "BFK3JK",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T15:25:00+02:00",
"level": "intermediate",
"next_session": null,
"prev_session": "VNR377",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Talk",
"sessions_after": [
"3FW7UF",
"9JALSN",
"UY9UAG"
],
"sessions_before": [
"8HBEYS",
"93XE3S",
"9URK9U",
"BMQP7J",
"NXNHSB",
"PPQ3KE",
"VNR377"
],
"sessions_in_parallel": [
"NS8QQA",
"SASJQU",
"TAZHCD"
],
"slug": "faster-django-orm-queries-for-everybody",
"speakers": [
"7FCECA"
],
"start": "2026-07-16T14:55:00+02:00",
"title": "Faster Django ORM queries for everybody",
"track": "Web Development, Web APIs, Front-End Integration",
"tweet": "Learn how to speed-up database queries in your Django app. We'll cover N+1 queries, database views, and creating proper indicies.",
"website_url": "https://ep2026.europython.eu/session/faster-django-orm-queries-for-everybody",
"youtube_url": null
},
"BJBKRM": {
"abstract": "After months of maintaining the MCP Python SDK and reviewing many community contributions, I've seen some architectural hiccups in repeat. Developers struggle with questions that seem simple but have nuanced answers: When should one tool become three? When does a server need to split into two? How do you test an MCP server without spinning up a full client? When should you use resources or prompts instead?\r\n\r\nIn this talk, we will explore my learnings and understand how to design tool boundaries that scale with your server's complexity, structure your codebase for long-term maintainability, and build a testing strategy for your MCP server that works. I'll share real examples from the wild, both the antipatterns to run away from and the implementations worth adopting.\r\n\r\nIn 2026, the MCP Python SDK v2 will bring improved typing, a refined API, and better testing primitives. The architectural decisions you make today will determine whether that migration takes a day or a month.\r\n\r\nWhether you're maintaining an internal tool or publishing to the community, you'll leave with a clear framework for evaluating your own server's design and concrete next steps to improve it.",
"code": "BJBKRM",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T12:55:00+02:00",
"level": "intermediate",
"next_session": "UGLF7Q",
"prev_session": "QXZMP8",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"7NWR9R",
"BX77EE",
"GP39VP",
"PBTPJR",
"RGBSS8",
"U7AHP3",
"UGLF7Q",
"VSZSMW"
],
"sessions_before": [
"FBQQXS",
"PQCHT3",
"QXZMP8",
"SCZ8ZK",
"VKURLV"
],
"sessions_in_parallel": [
"PWGSJQ",
"SQRYJA"
],
"slug": "what-i-ve-learned-maintaining-the-mcp-python-sdk",
"speakers": [
"BGPPXA"
],
"start": "2026-07-17T12:25:00+02:00",
"title": "What I've Learned Maintaining the MCP Python SDK",
"track": "Machine Learning, NLP and CV",
"tweet": "Lessons from maintaining the MCP Python SDK: tool boundaries, server architecture, testing strategies, and preparing for SDK v2",
"website_url": "https://ep2026.europython.eu/session/what-i-ve-learned-maintaining-the-mcp-python-sdk",
"youtube_url": null
},
"BJCYNE": {
"abstract": "\"TBD: Keynote Speaker\"\r\nDetails coming soon. This prime session will feature an inspiring keynote address to set the tone for the entire event. Our team is finalizing an exceptional speaker whose insights and vision will leave a lasting impression. Check back shortly for the full announcement, topic, and speaker biography.",
"code": "BJCYNE",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-15T10:15:00+02:00",
"level": "beginner",
"next_session": "Y8QAUA",
"prev_session": null,
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Keynote",
"sessions_after": [
"33RGZA",
"9EFAJS",
"DWBGJ9",
"LNVDY3",
"M8Q77Z",
"PRGGNW",
"QT97WA",
"Y8QAUA"
],
"sessions_before": [],
"sessions_in_parallel": [],
"slug": "keynote-1-placeholder",
"speakers": [],
"start": "2026-07-15T09:30:00+02:00",
"title": "Keynote 1 - Placeholder",
"track": null,
"tweet": "\"TBD: Keynote Speaker\" Details coming soon. This session will feature an inspiring keynote address to open the event",
"website_url": "https://ep2026.europython.eu/session/keynote-1-placeholder",
"youtube_url": null
},
"BMQP7J": {
"abstract": "Your smart home is a wireless network of connected devices which all talk to each other by sending messages into a central hub. If you control the hub's messaging queue, you can control and monitor the network and even create your own custom devices that end up visible in services like Apple or Google Home.\r\n\r\nIn this talk I will show you what it takes to create such a custom device using an affordable ESP32 microcontroller running MicroPython. We'll briefly look at the capabilities of the ESP32 family and why it is a good choice for WiFi-enabled projects. We'll talk about the tooling that makes development a pleasure, from flashing firmware to interacting with the board using WebREPL, installing lightweight dependencies with mip, testing, logging, and more.\r\n\r\nWe will also discuss the MQTT protocol, how our custom devices can send and receive messages, how to integrate third-party Zigbee devices, and how to use Home Assistant as a bridge between our MQTT server and Apple or Google Home. We'll see how to use the Mosquitto broker and client tools such as paho.mqtt and how Zigbee2MQTT allows remote sensors to join the same messaging layer.\r\n\r\nMy goal is to give a practical overview of the hardware and software pieces involved: ESP32, MicroPython tooling, MQTT infrastructure, Zigbee integration, and Home Assistant bridging. If you are comfortable with Python and curious about embedded systems, this talk is for you.",
"code": "BMQP7J",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T13:15:00+02:00",
"level": "intermediate",
"next_session": "UY9UAG",
"prev_session": "LN7EF3",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk",
"sessions_after": [
"93XE3S",
"NXNHSB",
"PPQ3KE",
"UY9UAG",
"VNR377"
],
"sessions_before": [
"9MRVPM",
"GEJAQW",
"JSLSHM",
"LN7EF3",
"YKWMBZ"
],
"sessions_in_parallel": [
"8HBEYS",
"9URK9U",
"B7CMBD",
"E3GVVR",
"FB93DB",
"MJTZ7A"
],
"slug": "building-a-smart-home-device-with-micropython",
"speakers": [
"RMHTBJ"
],
"start": "2026-07-16T12:45:00+02:00",
"title": "Building a Smart Home Device with MicroPython",
"track": "IoT, Embedded Systems, Hardware Integration",
"tweet": "Build smart home devices with ESP32, MicroPython, MQTT, Zigbee, Home Assistant and more.",
"website_url": "https://ep2026.europython.eu/session/building-a-smart-home-device-with-micropython",
"youtube_url": null
},
"BPJHWT": {
"abstract": "Here's a secret from someone who's been on every side of the hiring table \u2014 as a candidate who's passed 80%+ of technical processes (including Google and Meta), as a hiring manager who's interviewed hundreds of engineers, and as the former CTO of Codility, the platform that powers technical assessments at thousands of companies worldwide: the interview is not about solving the problem.\r\nMost candidates walk into coding interviews laser-focused on getting to the correct solution. They grind LeetCode, memorize algorithm patterns, and panic when they hit a wall. But here's what they miss \u2014 interviewers aren't scoring your answer. They're evaluating how you think, how you communicate, and how you handle uncertainty. The candidates who get offers aren't always the ones who solve the problem. They're the ones who make the interviewer want to work with them.\r\nIn this talk, I'll pull back the curtain on what technical interviews \u2014 both coding and system design \u2014 actually measure. You'll learn why talking through a wrong approach can score higher than silently arriving at the right one, why system design interviews aren't looking for the \"correct\" architecture, and why the soft skills you think are secondary are actually the main event.\r\nDrawing from nearly 20 years of real-world experience on both sides of the table, I'll share a practical framework for approaching any technical interview with the right mindset. You'll walk away with concrete strategies you can apply at your next interview \u2014 not more algorithm flashcards, but a fundamentally different understanding of what the process is actually testing.",
"code": "BPJHWT",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T16:00:00+02:00",
"level": "intermediate",
"next_session": "8XMJGZ",
"prev_session": "T7ATVM",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk",
"sessions_after": [
"8XMJGZ"
],
"sessions_before": [
"BX77EE",
"GP39VP",
"NTZ7DG",
"QY7PFR",
"T7ATVM",
"U7AHP3",
"WHHAQK",
"ZFJEUJ"
],
"sessions_in_parallel": [
"LRVCYU",
"MP9ZRM",
"ZHCNDY"
],
"slug": "you-don-t-need-to-solve-it-what-actually-gets-you-hired-in-tech",
"speakers": [
"WH7AWZ"
],
"start": "2026-07-17T15:30:00+02:00",
"title": "You Don't Need to Solve It: What Actually Gets You Hired in Tech",
"track": "Professional Development, Careers, Leadership",
"tweet": "Think solving the problem gets you hired? Think again. Learn what technical interviews actually test.",
"website_url": "https://ep2026.europython.eu/session/you-don-t-need-to-solve-it-what-actually-gets-you-hired-in-tech",
"youtube_url": null
},
"BTTFFJ": {
"abstract": "The WebAssembly Summit aims to bring together maintainers and users of Python with WebAssembly, to discuss the state of this ecosystem, existing challenges, and ongoing work.\r\n\r\n* When: ??? 2026\r\n* Where: ICE Krak\u00f3w Congress Centre, Room ???\r\n* Who can join: Anyone with a valid in-person EuroPython 2026 ticket",
"code": "BTTFFJ",
"delivery": "in-person",
"duration": "360",
"end": "2026-07-14T12:45:00+02:00",
"level": "advanced",
"next_session": null,
"prev_session": null,
"resources": null,
"room": "Reception Room F2 (Fishbowl)",
"session_type": "Summit",
"sessions_after": [
"3TZHB9",
"K7XNTF",
"N39TFS",
"ZSRZPC"
],
"sessions_before": [],
"sessions_in_parallel": [
"3FDLUS",
"MENRZG",
"TGGHKC",
"ZPCDKE"
],
"slug": "web-assembly-summit",
"speakers": [
"WADEN9"
],
"start": "2026-07-14T09:30:00+02:00",
"title": "Web Assembly Summit",
"track": "~ None of these topics",
"tweet": "This Summit brings together maintainers and users of Python with WASM, to discuss the state of this ecosystem, existing challenges, and ongoing work.",
"website_url": "https://ep2026.europython.eu/session/web-assembly-summit",
"youtube_url": null
},
"BX77EE": {
"abstract": "Maintaining CI/CD configurations across dozens of Python projects means copying the same `tox` invocations, Python version matrices, and error-handling logic into every repository. This poster presents five architectural patterns from the `reusable-tox.yml` project that eliminate this duplication by applying familiar software engineering principles to GitHub Actions workflows.\r\n\r\nEach pattern is illustrated with a before/after YAML comparison and a Python code analogy, making the design decisions immediately recognizable to Python developers:\r\n\r\n* *Singular inputs* \u2014 accepting one Python version per workflow call instead of JSON arrays. Like writing `def run(version: str)` instead of `def run(versions: list[str])` \u2014 simpler to reason about, test, and compose via caller-side matrix strategies.\r\n* *Caller-side matrix strategy* \u2014 separating \"what to test\" (the calling workflow's job) from \"how to test\" (the reusable workflow's job). The same Separation of Concerns you'd apply to Python modules.\r\n* *Three-phase execution* \u2014 splitting `tox` runs into environment preparation (`tox --notest`), main execution, and debug rerun on failure. Like Unix pipelines \u2014 each stage transforms data through a single responsibility, improving cacheability and error diagnosis.\r\n* *Composite action hooks* \u2014 providing extension points where projects inject custom setup logic without modifying shared infrastructure, discovered automatically via `hashFiles()`. The Dependency Injection pattern applied to CI/CD.\r\n* *Explicit over implicit* \u2014 refusing to auto-detect `tox` environments or infer configuration. Predictable and debuggable beats magical and surprising.\r\n\r\nThe poster includes a \"Which pattern solves your problem?\" decision flowchart and a QR code linking to the open-source repository with ready-to-fork templates.\r\n\r\nBorn from maintaining dozens of Python projects including aiohttp, CherryPy, and pip-tools, these patterns treat CI/CD with the same architectural rigor as application code.",
"code": "BX77EE",
"delivery": "in-person",
"duration": "60",
"end": "2026-07-17T14:00:00+02:00",
"level": "intermediate",
"next_session": null,
"prev_session": null,
"resources": null,
"room": "Exhibit Hall",
"session_type": "Poster",
"sessions_after": [
"NTZ7DG",
"QY7PFR",
"T7ATVM",
"WHHAQK",
"ZFJEUJ"
],
"sessions_before": [
"BJBKRM",
"FBQQXS",
"PWGSJQ",
"SCZ8ZK",
"SQRYJA"
],
"sessions_in_parallel": [
"7NWR9R",
"GP39VP",
"PBTPJR",
"RGBSS8",
"U7AHP3",
"UGLF7Q",
"VSZSMW"
],
"slug": "reusable-tox-yml-five-patterns-to-eliminate-ci-cd-boilerplate",
"speakers": [
"AWKFRJ"
],
"start": "2026-07-17T13:00:00+02:00",
"title": "reusable-tox.yml: Five Patterns to Eliminate CI/CD Boilerplate",
"track": "Tooling, Packaging, Developer Productivity",
"tweet": "Five patterns from reusable-tox.yml that eliminate CI/CD boilerplate \u2014 with Python analogies, before/after comparisons, and ready-to-fork templates.",
"website_url": "https://ep2026.europython.eu/session/reusable-tox-yml-five-patterns-to-eliminate-ci-cd-boilerplate",
"youtube_url": null
},
"BYWVNK": {
"abstract": "Most LLM tutorials end where production begins. When OpenAI returns a 429, when Claude\u2019s latency spikes 10x, or when your streaming response dies mid-generation\u2014what happens to your users?\r\n\r\nThis talk covers battle-tested architecture patterns for production LLM streaming, moving beyond simple API calls to resilient systems. We will explore multi-provider failover chains (OpenAI \u2192 Anthropic \u2192 local), circuit breakers specifically configured for AI workloads, and token-aware rate limiting that protects both latency and cost.\r\n\r\nYou will learn framework-agnostic Python patterns using asyncio and LiteLLM for provider abstraction. We will examine real incident patterns\u2014including the December 2025 Anthropic outage\u2014and the architectural decisions that separate 99.5% availability from 99.9%.",
"code": "BYWVNK",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T11:55:00+02:00",
"level": "advanced",
"next_session": "9MRVPM",
"prev_session": "788XZA",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"8HBEYS",
"9MRVPM",
"9URK9U",
"GEJAQW",
"JSLSHM",
"LN7EF3",
"YKWMBZ"
],
"sessions_before": [
"788XZA",
"CWBA3L",
"ETBPVR",
"TZHTEE",
"UGM7F8"
],
"sessions_in_parallel": [
"AGX8D9",
"DWGSFA",
"G9FDRY",
"JQSQBB"
],
"slug": "beyond-the-demo-production-patterns-for-streaming-llm-systems",
"speakers": [
"PSCB8W"
],
"start": "2026-07-16T11:25:00+02:00",
"title": "Beyond the Demo: Production Patterns for Streaming LLM Systems",
"track": "Data Engineering and MLOps",
"tweet": "Don't let 429s break your app. Learn battle-tested architecture patterns for resilient, streaming LLM systems at scale.",
"website_url": "https://ep2026.europython.eu/session/beyond-the-demo-production-patterns-for-streaming-llm-systems",
"youtube_url": null
},
"CBA98V": {
"abstract": "Programmers spend countless hours typing, yet we rarely question how keyboard design affects our comfort and productivity. Standard QWERTY layouts and one-size-fits-all hardware often contribute to strain and inefficiency. This talk explores how Python can help you design, build, and optimize your own custom keyboard; from analyzing your typing habits to generating the PCB.\r\n\r\nWe start with a brief history of keyboard design and the limitations of QWERTY, then introduce alternative layouts (ortholinear, split, and more) and explain why they can reduce strain and improve speed. Next, we use Python to make data-driven decisions: we\u2019ll look at scripts that analyze your codebases or IDE usage to find your most-used characters and symbols, so you can place keys where they matter most for your workflow and favorite languages.\r\n\r\nWe then move on to PCB design with KidCad and GDSFactory, a Python-based tool for creating keyboard PCBs and exporting Gerber or GDS files for manufacturing. You\u2019ll see how to arrange keys around your hand shape and generate production-ready files. After that, we cover basic assembly and programming your layout with open-source firmware. Finally, we discuss trade-offs: the benefits of a tailored setup (better posture, less finger travel, DIY satisfaction) it can also be a meaningful accessibility solution for users with special needs, limited mobility, or other conditions where standard keyboards become a uncomfortable or unusable. Some of the barriers (cost, time, learning a new layout), plus strategies for gradual adoption and practice tools.\r\n\r\n**What you will learn:** \r\n- Why keyboard layout and ergonomics matter for long-term comfort and productivity. \r\n- How to use Python to analyze your typing patterns and inform layout choices. \r\n- How to use KidCad or GDSFactory (Python) to design hardware and generate manufacturing files. \r\n- How to go from design to assembly and firmware, and how to ease the transition to a new layout.\r\n\r\nNo prior experience with keyboard building or PCB design is required; just curiosity and a desire to create a custom typing experience. By the end, you\u2019ll know how to question your current keyboard and how to start building your own with Python.",
"code": "CBA98V",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T12:10:00+02:00",
"level": "intermediate",
"next_session": "NWLBJC",
"prev_session": "DWBGJ9",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk",
"sessions_after": [
"33RGZA",
"LNVDY3",
"NEH7RE",
"NWLBJC",
"PRGGNW",
"UPELCT",
"W9NLXV",
"ZRWENU"
],
"sessions_before": [
"9EFAJS",
"DWBGJ9",
"M8Q77Z",
"QT97WA",
"Y8QAUA"
],
"sessions_in_parallel": [
"HJ8KPY",
"KRMBWS",
"VXDYGX"
],
"slug": "designing-and-building-custom-keyboards-with-python",
"speakers": [
"MGPBMB"
],
"start": "2026-07-15T11:40:00+02:00",
"title": "Designing and Building Custom Keyboards \u2328\ufe0f with Python",
"track": "Python for Games, Art, Play and Expression",
"tweet": "Design and build your own keyboard with Python: analyze typing habits, create PCBs and program your layout. No prior hardware experience needed.",
"website_url": "https://ep2026.europython.eu/session/designing-and-building-custom-keyboards-with-python",
"youtube_url": null
},
"CSDM3D": {
"abstract": "Welcome to EuroPython 2026! Please notice the registration will happen on the TBD.\r\nYou can pick up your badges at any time during the week as long as we are open!\r\nIf you want to avoid the morning rush on Wednesday, come on Monday and Tuesday!\r\nEnjoy the conference!",
"code": "CSDM3D",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-13T09:30:00+02:00",
"level": "beginner",
"next_session": "QWEJWT",
"prev_session": null,
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Announcements",
"sessions_after": [
"GCWCEU",
"NQGSY7",
"QWEJWT",
"VYUNHG",
"WYBHCE"
],
"sessions_before": [],
"sessions_in_parallel": [],
"slug": "monday-registration-welcome-tbd-floor",
"speakers": [],
"start": "2026-07-13T08:30:00+02:00",
"title": "Monday Registration & Welcome @ TBD Floor",
"track": null,
"tweet": "Welcome to EuroPython 2026! Please notice the registration will happen on the TBD. You can pick up your badges at any time during the conference days!",
"website_url": "https://ep2026.europython.eu/session/monday-registration-welcome-tbd-floor",
"youtube_url": null
},
"CWBA3L": {
"abstract": "OpenAI's embedding API is the default for most Python RAG applications, but it creates real problems at scale: data privacy (every document leaves your network), cost (per-token pricing compounds fast), no customization (cannot fine-tune or swap models), and no quality validation. Most teams have never measured whether text-embedding-3-large actually works well for their domain.\r\n\r\nOpen embedding models like BGE-M3, GTE-Qwen2, and E5 now match or beat OpenAI on MTEB benchmarks. The problem is not model quality anymore, it is infrastructure: running these models with proper batching, memory management, and quality assurance.\r\n\r\nThis talk walks through a practical migration. We start from a typical LangChain app calling OpenAI, switch to self-hosted open models using SIE (an open-source inference server with an OpenAI-compatible endpoint), validate that retrieval quality is maintained using MTEB, and then go beyond what OpenAI offers by adding sparse embeddings for keyword, recall, and cross-encoder reranking for precision.\r\n\r\nThe talk is aimed at Python developers who currently use OpenAI embeddings and models and want to understand their options. No prior experience with model serving is required.",
"code": "CWBA3L",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-16T11:15:00+02:00",
"level": "intermediate",
"next_session": "AGX8D9",
"prev_session": "3KT3BW",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Talk (long session)",
"sessions_after": [
"8HBEYS",
"9URK9U",
"AGX8D9",
"BYWVNK",
"DWGSFA",
"G9FDRY",
"JQSQBB"
],
"sessions_before": [
"3KT3BW"
],
"sessions_in_parallel": [
"788XZA",
"ETBPVR",
"TZHTEE",
"UGM7F8"
],
"slug": "self-hosted-small-models-from-openai-lock-in-to-open-models",
"speakers": [
"8TWA3E"
],
"start": "2026-07-16T10:30:00+02:00",
"title": "Self-Hosted Small Models: From OpenAI Lock-In to Open Models",
"track": "Machine Learning, NLP and CV",
"tweet": "Most Python RAG apps use OpenAI embeddings. Open models now match the quality. This talk walks through a real migration and what you gain.",
"website_url": "https://ep2026.europython.eu/session/self-hosted-small-models-from-openai-lock-in-to-open-models",
"youtube_url": null
},
"DBBNQD": {
"abstract": "This talk is a practical tour of how CPython really manages memory: from obj = SomeClass() to the moment its bytes are reused or released back to the OS.\r\n\r\nWe\u2019ll start with the basics: object layout, refcounts, and how CPython\u2019s small-object allocator (pymalloc) hands out memory in arenas and pools instead of calling malloc for every tiny object. You\u2019ll see what actually happens when you create lots of ints, tuples, and short-lived objects in hot loops.\r\n\r\nThen we\u2019ll simplify the lifecycle on the way out: what happens when a refcount hits zero, how CPython runs type-specific deallocation code and optional finalizers, and how user __del__ fits into that chain. We\u2019ll look at how memory is either returned to the allocator or kept on freelists to be reused quickly, and why this can look like a \u201cleak\u201d from the outside.\r\n\r\nIn the second half, we\u2019ll focus on optimisations and allocator swaps. We\u2019ll look at freelists for ints, tuples, frames, and other core objects: why they exist, how they speed up hot paths, and when they keep memory around longer than you expect. Then we\u2019ll compare pymalloc with mimalloc: how they differ in fragmentation, multithread behaviour, what actually changes when you run Python with mimalloc, and how to measure the impact with simple benchmarks and tracemalloc-style tooling.\r\n\r\nYou\u2019ll leave with a clear mental model of CPython\u2019s (de)allocation pipeline, an intuition for what freelists and alternative allocators are really doing.",
"code": "DBBNQD",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-17T10:55:00+02:00",
"level": "intermediate",
"next_session": "7SSS93",
"prev_session": "UPKZKC",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk (long session)",
"sessions_after": [
"7SSS93",
"ARRMQR",
"BX77EE",
"FBQQXS",
"GP39VP",
"SCZ8ZK",
"TG7YMS",
"U7AHP3"
],
"sessions_before": [
"UPKZKC"
],
"sessions_in_parallel": [
"KFQN3X",
"LFSJYL",
"RB9TKP",
"SGM9SV"
],
"slug": "cpythons-memory-engine-allocation-deallocation-and-free-list-tricks",
"speakers": [
"CEHB8A"
],
"start": "2026-07-17T10:10:00+02:00",
"title": "CPython\u2019s Memory Engine: Allocation, Deallocation, and Free-List Tricks",
"track": "Python Core, Internals, Extensions",
"tweet": "NoGIL changes memory story. We\u2019ll trace alloc/free path, see what changes under NoGIL (mimalloc) + how to benchmark and profile real memory behavior.",
"website_url": "https://ep2026.europython.eu/session/cpythons-memory-engine-allocation-deallocation-and-free-list-tricks",
"youtube_url": null
},
"DJU8GK": {
"abstract": "Enjoy Thursday's lightning talks!\r\nA series of short community/conference announcements followed by short talks about everything by everyone. \r\n\r\nLightning talks are 5 minute talks that anyone participating at the conference can submit.\r\nIf that talk gets selected, you will have the chance to jump into the main stage and show us your project, your ideas, something you have learned, something you are proud of that's helping and contributing to our conference and community, or something else!\r\n\r\nLightning talks last a maximum of 5 minutes. You can use less time, but not more.\r\nThis time limit is strictly enforced!\r\n\r\nIf you get accepted, you will be notified by email on the day of your talk by 1pm.\r\nReply to the acceptance email by 3pm to confirm your spot.\r\n(If you don't, you lose your spot!)\r\n\r\nYou can submit your lightning talk on this form: TBD\r\nNote that there's a limit of one submission per person.\r\n\r\nCommunity/conference announcement submissions are done through the same form before 1pm Thursday.",
"code": "DJU8GK",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-16T18:00:00+02:00",
"level": "beginner",
"next_session": null,
"prev_session": "BDUAKE",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Announcements",
"sessions_after": [],
"sessions_before": [
"3FW7UF",
"8HBEYS",
"9URK9U",
"BDUAKE",
"BFK3JK",
"NS8QQA",
"UY9UAG"
],
"sessions_in_parallel": [],
"slug": "lightning-talks-thursday",
"speakers": [],
"start": "2026-07-16T17:15:00+02:00",
"title": "Lightning talks \u26a1 Thursday",
"track": null,
"tweet": "Enjoy Thursday's lightning talks! Short talks about everything by everyone. Lightning talks are 5 minute talks that anyone participating at the conf",
"website_url": "https://ep2026.europython.eu/session/lightning-talks-thursday",
"youtube_url": null
},
"DRXC3E": {
"abstract": "# Python and HTTP/3: feel the difference in performance\r\n\r\n## Abstract\r\n\r\nBuilding real-time Python applications, from live dashboards to multiplayer games, often feels like a battle against an invisible lag. While we focus on optimizing our async code, the underlying transport protocol often sabotages us: `TCP` guarantees ordering at the absolute cost of responsiveness.\r\n\r\nIn this session, I will show that the standard choice of using Websocket over `HTTP/1.1` or `HTTP/2` can make the application perform horribly, due to the \"head-of-line blocking\" problem that is visible when the network is unstable.\r\nThen I will present how `HTTP/3` and `WebTransport` eliminate transport-layer bottlenecks and enable seamless connection migration for network switching users.\r\nThe audience will experience the difference between protocols performance firsthand through a live three-round multiplayer snake game demo. \r\n\r\n## Description\r\n\r\n### The Problem\r\n\r\nApplication performance is a complex challenge. Users often complain about lag, and regardless of how well we optimize our business logic, the issue persists. All too often, the blame is shifted to the client for having a \"spotty network.\" However, even under ideal conditions, users experience disruptions simply by being mobile, due to switching between Wi-Fi access points or cellular towers. The core problem is that many developers are unaware of the limitations of `HTTP/1.1` and `HTTP/2`, or that implementing `HTTP/3` might be a solution.\r\n\r\n### Why This is Interesting to the Python Community\r\n\r\nAs Python applications become more real-time and data-intensive, traditional networking stacks are reaching their limits. There are important advances in technology that the audience should get familiar with, like `HTTP/3`, `QUIC`, and `WebTransport`. What is also important, is to be aware of how the Python ecosystem is still fragmented when it comes to supporting `HTTP/3`. \r\nDespite that, a solution is achievable, and by using a combination of `Starlette` and `aioquic` code across three generations of transport protocols, the audience will experience and learn how protocol choice dictates application reliability on imperfect networks.\r\n\r\n### Key takeaways:\r\n- Witness an app suffering from transport-layer head-of-line blocking.\r\n- Understand the Python `HTTP/3` ecosystem, including `aioquic`, `Hypercorn`, and `Starlette`.\r\n- Deploy a `HTTP/3` server handling `WebTransport` datagrams for real-time data.\r\n- Learn how to use Linux traffic control (`tc`) to inject some chaos to the network\r\n- Play multiplayer Snake!",
"code": "DRXC3E",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T14:20:00+02:00",
"level": "intermediate",
"next_session": "HVTSPC",
"prev_session": "NEH7RE",
"resources": [
{
"description": "Game demo screenshot",
"resource": "https://programme.europython.eu/media/europython-2026/submissions/DRXC3E/resources/Screenshot_8RyiRGg.png"
}
],
"room": "Chamber Hall B (S3B)",
"session_type": "Talk",
"sessions_after": [
"7VKQQM",
"ENK9EF",
"HVTSPC",
"SWCWKZ",
"ZRWENU"
],
"sessions_before": [
"33RGZA",
"CBA98V",
"HJ8KPY",
"LNVDY3",
"NEH7RE",
"PRGGNW",
"UPELCT",
"W9NLXV"
],
"sessions_in_parallel": [
"3HBWHB",
"NWLBJC",
"US3W8J"
],
"slug": "python-and-http-3-feel-the-difference-in-performance",
"speakers": [
"RVRZPP"
],
"start": "2026-07-15T13:50:00+02:00",
"title": "Python and HTTP/3: feel the difference in performance",
"track": "Web Development, Web APIs, Front-End Integration",
"tweet": "From TCP to QUIC. Experience the performance gains in a live Snake game thanks to HTTP/3 and WebTransport.",
"website_url": "https://ep2026.europython.eu/session/python-and-http-3-feel-the-difference-in-performance",
"youtube_url": null
},
"DSHNXM": {
"abstract": "Welcome to the second day of conference!\r\nYesterday was an amazing day, but for sure you don't remember all the things that were mentioned during the opening.\r\nJoin us to get an update and few more announcements. Come by and find out what is going to happen today.",
"code": "DSHNXM",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T09:15:00+02:00",
"level": "beginner",
"next_session": "3KT3BW",
"prev_session": null,
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Announcements",
"sessions_after": [
"3KT3BW"
],
"sessions_before": [],
"sessions_in_parallel": [],
"slug": "thursday-s-morning-announcement",
"speakers": [],
"start": "2026-07-16T09:00:00+02:00",
"title": "Thursday's Morning Announcement \u23f0",
"track": null,
"tweet": "Yesterday was an amazing day, but for sure you don't remember all the things that were mentioned during the opening.",
"website_url": "https://ep2026.europython.eu/session/thursday-s-morning-announcement",
"youtube_url": null
},
"DWBGJ9": {
"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\r\n\r\nIn 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.\r\n\r\nFinally, 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.\r\n\r\nBy the end, you will have learned what makes a good error message, how to spot a bad one and how to fix them.",
"code": "DWBGJ9",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-15T11:30:00+02:00",
"level": "intermediate",
"next_session": "CBA98V",
"prev_session": "BJCYNE",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk (long session)",
"sessions_after": [
"33RGZA",
"CBA98V",
"HJ8KPY",
"KRMBWS",
"LNVDY3",
"PRGGNW",
"UPELCT",
"VXDYGX"
],
"sessions_before": [
"BJCYNE"
],
"sessions_in_parallel": [
"9EFAJS",
"M8Q77Z",
"QT97WA",
"Y8QAUA"
],
"slug": "how-cpythons-errors-keep-getting-better",
"speakers": [
"RRDCVX"
],
"start": "2026-07-15T10:45:00+02:00",
"title": "How CPythons Errors keep getting better",
"track": "Python Core, Internals, Extensions",
"tweet": "Ever wondered why some error messages are terrible? We'll how Python improved it's errors over the years and how you can help.",
"website_url": "https://ep2026.europython.eu/session/how-cpythons-errors-keep-getting-better",
"youtube_url": null
},
"DWGSFA": {
"abstract": "Due to climate change, **large wildfires** continue affecting all continents of the Earth, leading to forest loss and exacerbating environmental impacts. Even more, current changing weather conditions associated with global warming will further increase fire danger to a global extent. Investigating these phenomena in a data-driven manner helps in decision making in pre-intervention and post-restoration following wildfire events. **Satellites** orbiting Earth can offer critical insights by capturing detailed images of the planet\u2019s surface. Utilizing this data, environmental scientists perform detailed assessments to monitor an ecosystem\u2019s loss and post-restoration progress. However, data from satellites arrive in the form of millions of raw pixels and turning them into analysis ready products is a **time-consuming** task full of **multi-step** and **error-prone** processes.\r\n\r\nThis talk introduces an end-to-end Python workflow to automate the processing of **Earth Observation (EO) data**. The presentation walks through pixels to insights showcasing a real example and highlighting both the power of automation in the field of remote sensing and the importance of EO data in **climate change monitoring**. After the session, the audience will understand how utilizing open Python packages such as **Rasterio** and **NumPy** with openly distributed data from the [European Space Agency\u2019s Sentinel-2 mission](https://dataspace.copernicus.eu/data-collections/copernicus-sentinel-missions/sentinel-2) can lead us quickly into crucial and spatially meaningful information. Although the demonstration focuses on wildfire events, the automated workflow is broadly applicable to other environmental fields such as land cover change detection, hydrological assessments and coastal studies.\r\n\r\n**No prior knowledge is required**! The **goal** is not to delve into complex mathematical equations, but to showcase the power of automation in remote sensing with Python.",
"code": "DWGSFA",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T11:55:00+02:00",
"level": "beginner",
"next_session": "LN7EF3",
"prev_session": "UGM7F8",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk",
"sessions_after": [
"8HBEYS",
"9MRVPM",
"9URK9U",
"GEJAQW",
"JSLSHM",
"LN7EF3",
"YKWMBZ"
],
"sessions_before": [
"788XZA",
"CWBA3L",
"ETBPVR",
"TZHTEE",
"UGM7F8"
],
"sessions_in_parallel": [
"AGX8D9",
"BYWVNK",
"G9FDRY",
"JQSQBB"
],
"slug": "from-pixels-to-insights-python-for-earth-observation",
"speakers": [
"AEFAYE"
],
"start": "2026-07-16T11:25:00+02:00",
"title": "From Pixels to Insights: Python for Earth Observation",
"track": "Jupyter and Scientific Python",
"tweet": "Satellites watch the Earth from space, capturing invisible signals. Let's see how Python reveals their meaning.",
"website_url": "https://ep2026.europython.eu/session/from-pixels-to-insights-python-for-earth-observation",
"youtube_url": null
},
"E3GVVR": {
"abstract": "Your team ships an AI feature and users love it. Then one viral post turns \"normal load\" into hundreds of LLM requests per second.\r\n\r\nLLM calls don't behave like traditional API requests. They're slow (sometimes seconds), expensive, rate-limited by providers, and a single provider outage can take your entire feature down. You can't just \"add more servers.\" You need a routing layer that knows where to send traffic, when to back off, and how to fail without taking everything with it.\r\n\r\nIn this talk, we'll walk through the LLM traffic routing architecture we built in Python at Manychat, where we serve AI-powered automation to thousands of Instagram and messaging accounts. Everything we'll show is running in production.\r\n\r\nWe'll cover the core gateway patterns for multi-provider LLM traffic, implemented using LiteLLM Router as a reference design.\r\n\r\nBy the end, you'll walk away with:\r\n\r\n- A weighted routing blueprint you can adapt to your own provider mix\r\n- Fallback and cooldown rules designed to survive real outages\r\n- Practical rate limiting (requests and tokens) with retry backoff\r\n- The monitoring baseline (latency, tokens, errors by provider, weight drift) to catch issues before they cascade\r\n- A checklist for rolling this out safely, incrementally",
"code": "E3GVVR",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T13:15:00+02:00",
"level": "intermediate",
"next_session": "93XE3S",
"prev_session": "YKWMBZ",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Sponsored",
"sessions_after": [
"93XE3S",
"NXNHSB",
"PPQ3KE",
"UY9UAG",
"VNR377"
],
"sessions_before": [
"9MRVPM",
"GEJAQW",
"JSLSHM",
"LN7EF3",
"YKWMBZ"
],
"sessions_in_parallel": [
"8HBEYS",
"9URK9U",
"B7CMBD",
"BMQP7J",
"FB93DB",
"MJTZ7A"
],
"slug": "surviving-llm-traffic-spikes-routing-rate-limits-and-failover-in-python",
"speakers": [
"YHZWL7"
],
"start": "2026-07-16T12:45:00+02:00",
"title": "Surviving LLM Traffic Spikes: Routing, Rate Limits, and Failover in Python",
"track": "DevOps, Cloud, Scalable Infrastructure",
"tweet": "Weighted routing, automatic cooldown, fallback chains. How we handle hundreds of LLM calls/s in Python without things falling over.",
"website_url": "https://ep2026.europython.eu/session/surviving-llm-traffic-spikes-routing-rate-limits-and-failover-in-python",
"youtube_url": null
},
"EKE78F": {
"abstract": "Welcome to EuroPython 2026! Please notice the registration will happen on the TBD\r\nYou can pick up your badges at any time during the week as long as we are open!\r\nIf you want to avoid the morning rush on Wednesday, come on Monday and Tuesday!\r\nEnjoy the conference!",
"code": "EKE78F",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-14T09:30:00+02:00",
"level": "beginner",
"next_session": "3FDLUS",
"prev_session": null,
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Announcements",
"sessions_after": [
"3FDLUS",
"BTTFFJ",
"MENRZG",
"TGGHKC",
"ZPCDKE"
],
"sessions_before": [],
"sessions_in_parallel": [],
"slug": "tuesday-registration-welcome-tbd",
"speakers": [],
"start": "2026-07-14T08:30:00+02:00",
"title": "Tuesday Registration & Welcome @ TBD",
"track": null,
"tweet": "Welcome to EuroPython 2026! Please notice the registration will happen on the TBD",
"website_url": "https://ep2026.europython.eu/session/tuesday-registration-welcome-tbd",
"youtube_url": null
},
"ENK9EF": {
"abstract": "Most developers interact with the CPython interpreter by writing code in the Python language and executing it with the bytecode interpreter. However, any native extensions and any code that runs alongside or embeds the interpreter needs to communicate with CPython via the CPython C API. This API corresponds to an application binary interface (ABI) that native code written in C, C++, Rust, Zig, or any other low-level programming language needs to use to directly interact with the CPython interpreter runtime. Understanding the ABI allows Python developers to make informed trade-offs when they distribute or depend on packages that contain native extensions.\r\n\r\nIn this talk, I will explain what the CPython ABI is, how it differs from the CPython C API, and how it determines whether a package from PyPI is installable with a given installation of CPython. I will discuss how CPython's stable ABI and limited C API enable substantially reduced distribution overhead at the cost of some performance overhead. I'll show how maintainers of projects that distribute compiled code in binary wheels can choose to ship wheels using the stable ABI to trade off peak performance with ease of distribution and support for new platforms.\r\n\r\nI'll finish by explaining how the ABI is evolving to enable improvements like the free-threaded interpreter. I will share real-world experience of introducing the new free-threaded ABI to the community with the perspective available to a maintainer of open source projects that are core components of the Python ecosystem.\r\n\r\nPython 3.15 will enable a new stable ABI that allows distributing one extension per platform for any interpreter newer than Python 3.15. I'll describe work done by myself and others in the community to enable end-to-end testing of the next-generation stable ABI.",
"code": "ENK9EF",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T15:00:00+02:00",
"level": "intermediate",
"next_session": "WKBHZW",
"prev_session": "US3W8J",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"H7KGU3",
"PCMBVT",
"RMY7Y7",
"WKBHZW",
"ZRWENU"
],
"sessions_before": [
"33RGZA",
"3HBWHB",
"DRXC3E",
"HJ8KPY",
"LNVDY3",
"NWLBJC",
"PRGGNW",
"US3W8J"
],
"sessions_in_parallel": [
"7VKQQM",
"HVTSPC",
"SWCWKZ"
],
"slug": "what-every-python-developer-should-know-about-the-cpython-abi",
"speakers": [
"XF7NUC"
],
"start": "2026-07-15T14:30:00+02:00",
"title": "What every Python developer should know about the CPython ABI",
"track": "Python Core, Internals, Extensions",
"tweet": "Learn what the Python ABI is, how it influences the distribution of Python packages, and how it's changing in Python 3.15",
"website_url": "https://ep2026.europython.eu/session/what-every-python-developer-should-know-about-the-cpython-abi",
"youtube_url": null
},
"ETBPVR": {
"abstract": "Scaling an application to a global audience often hits a bottleneck: the manual translation of thousands of strings. While machine translation exists, developers need a reliable way to integrate it into their codebases without breaking JSON structures or losing placeholders.\r\n\r\nIn this talk, we will explore a streamlined workflow to optimize the localization (l10n) process using Python and the DeepL API. We will walk through a real-world journey of transforming a single-language platform into a multi-language product, focusing on:\r\n\r\n The Localization Workflow: Designing a pipeline that extracts, translates, and reintegrates content automatically.\r\n\r\n Structure Preservation: Strategies to handle nested JSON files and complex data structures, ensuring that keys and code logic remain untouched while values are translated.\r\n\r\n Variable & Context Integrity: How to protect placeholders and dynamic segments (like {count} or {date}) so they survive the translation process intact.\r\n\r\n Automated Batch Processing: Using Python scripts to iterate through entire project directories, enabling the translation of multiple files in a single execution.\r\n\r\nAttendees will learn how to build a robust localization engine that acts as a \"first draft\" generator, allowing developers to focus on validating quality rather than managing strings.",
"code": "ETBPVR",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-16T11:15:00+02:00",
"level": "intermediate",
"next_session": "JQSQBB",
"prev_session": "3KT3BW",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Talk (long session)",
"sessions_after": [
"8HBEYS",
"9URK9U",
"AGX8D9",
"BYWVNK",
"DWGSFA",
"G9FDRY",
"JQSQBB"
],
"sessions_before": [
"3KT3BW"
],
"sessions_in_parallel": [
"788XZA",
"CWBA3L",
"TZHTEE",
"UGM7F8"
],
"slug": "localization-made-easy-a-pythonic-approach-to-global-applications",
"speakers": [
"YMJGBJ"
],
"start": "2026-07-16T10:30:00+02:00",
"title": "Localization Made Easy: A Pythonic Approach to Global Applications",
"track": "Web Development, Web APIs, Front-End Integration",
"tweet": "Scale your app globally: A guide to automating multi-language support using Python and DeepL without breaking your JSON structures.",
"website_url": "https://ep2026.europython.eu/session/localization-made-easy-a-pythonic-approach-to-global-applications",
"youtube_url": null
},
"FB93DB": {
"abstract": "In tech, it\u2019s easy to get caught up in ego. Chasing the smartest solutions, writing the most complex code, or proving who\u2019s the best in the room. But Python has a funny way of humbling us. Its simplicity reminds us that good code isn\u2019t about showing off; it\u2019s about making things clear, accessible, and collaborative.\r\n\r\nThis talk is about what happens after that sting of humility. Python doesn\u2019t just strip away ego, it builds communities that make you feel proud to belong. I\u2019ll share stories from my journey with Black Python Devs and other Python groups, showing how people from all walks of life come together, support one another, and create space for growth.\r\n\r\nBy the end, you\u2019ll see that the real magic of Python isn\u2019t just the language. It\u2019s the people, the openness, and the sense of pride that comes from being part of something bigger than yourself.",
"code": "FB93DB",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T13:15:00+02:00",
"level": "intermediate",
"next_session": "VNR377",
"prev_session": "JSLSHM",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Talk",
"sessions_after": [
"93XE3S",
"NXNHSB",
"PPQ3KE",
"UY9UAG",
"VNR377"
],
"sessions_before": [
"9MRVPM",
"GEJAQW",
"JSLSHM",
"LN7EF3",
"YKWMBZ"
],
"sessions_in_parallel": [
"8HBEYS",
"9URK9U",
"B7CMBD",
"BMQP7J",
"E3GVVR",
"MJTZ7A"
],
"slug": "python-stings-your-ego-finding-pride-in-community-not-just-code",
"speakers": [
"9DGTAT"
],
"start": "2026-07-16T12:45:00+02:00",
"title": "Python Stings Your Ego: Finding Pride in Community, Not Just Code",
"track": "Community Building, Education, Outreach",
"tweet": "A reflection on ego, imposter syndrome, and how Python communities help developers grow beyond code and competition.",
"website_url": "https://ep2026.europython.eu/session/python-stings-your-ego-finding-pride-in-community-not-just-code",
"youtube_url": null
},
"FBQQXS": {
"abstract": "Do you maintain a Python library, REST API or any other user-facing interface? Breaking changes are frowned upon, but from a a certain project size, they become unavoidable.\r\n\r\nHow do you make the breaking changes manageable? How should you version your package / API? Should you put an upper bound on your dependencies?\r\n\r\nWe'll discuss deprecation, forward and backward compatibility, upgrade strategies and more, illustrated on real-world examples. Our main focus will be on API changes of Python libraries, but the principles are widely applicable.",
"code": "FBQQXS",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T11:35:00+02:00",
"level": "intermediate",
"next_session": "VSZSMW",
"prev_session": "LFSJYL",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Talk",
"sessions_after": [
"BX77EE",
"GP39VP",
"PQCHT3",
"QXZMP8",
"SCZ8ZK",
"U7AHP3",
"VKURLV",
"VSZSMW"
],
"sessions_before": [
"DBBNQD",
"KFQN3X",
"LFSJYL",
"RB9TKP",
"SGM9SV"
],
"sessions_in_parallel": [
"7SSS93",
"ARRMQR",
"TG7YMS"
],
"slug": "breaking-changes-not-great-not-terrible",
"speakers": [
"FWGLE3"
],
"start": "2026-07-17T11:05:00+02:00",
"title": "Breaking changes \u2013 not great, not terrible",
"track": "Tooling, Packaging, Developer Productivity",
"tweet": "Make your user's life easier by keeping the breaking changes managable, even in a large-scale projects.",
"website_url": "https://ep2026.europython.eu/session/breaking-changes-not-great-not-terrible",
"youtube_url": null
},
"FMNUSD": {
"abstract": "Join us for a fast, fun, and brain-twisting quiz all about Python, the tools, and the community.\r\n\r\nTest your knowledge, race against the clock, and compete with fellow EuroPython attendees for a shot at some awesome prizes. \r\n\r\nWhether you\u2019re a seasoned developer or just love a good challenge, this showdown is your time to shine.",
"code": "FMNUSD",
"delivery": "in-person",
"duration": "15",
"end": "2026-07-15T17:45:00+02:00",
"level": "beginner",
"next_session": null,
"prev_session": "PKMSSL",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Announcements",
"sessions_after": [],
"sessions_before": [
"33RGZA",
"H7DVRJ",
"JEN7WA",
"LNVDY3",
"PKMSSL",
"PRGGNW",
"TWBDVZ",
"X3ENDU"
],
"sessions_in_parallel": [],
"slug": "python-quiz",
"speakers": [],
"start": "2026-07-15T17:30:00+02:00",
"title": "Python Quiz \ud83d\udcdd",
"track": null,
"tweet": "Join us for a fast, fun, and brain-twisting quiz all about Python, the tools, and the community.",
"website_url": "https://ep2026.europython.eu/session/python-quiz",
"youtube_url": null
},
"G9FDRY": {
"abstract": "From default args, to `**kwargs`, and everything in-between, Python's comprehensive argument system lends itself to some of the most effective code, through encouraging readability, reuse, and easy refactoring.\r\n\r\nBut is that really true? Why, and why not?\r\nWhat could we learn from other languages?\r\nAnd what else could lie in their future?\r\n\r\n---\r\n\r\nIn this session, we'll give a rundown of Python's comprehensive function argument system and how its features allow for safety, conciseness, and expressiveness (whether you're calling or writing functions).\r\n\r\nWe'll 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.",
"code": "G9FDRY",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T11:55:00+02:00",
"level": "intermediate",
"next_session": "GEJAQW",
"prev_session": "TZHTEE",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"8HBEYS",
"9MRVPM",
"9URK9U",
"GEJAQW",
"JSLSHM",
"LN7EF3",
"YKWMBZ"
],
"sessions_before": [
"788XZA",
"CWBA3L",
"ETBPVR",
"TZHTEE",
"UGM7F8"
],
"sessions_in_parallel": [
"AGX8D9",
"BYWVNK",
"DWGSFA",
"JQSQBB"
],
"slug": "args-amazing-or-approaching",
"speakers": [
"AHET73"
],
"start": "2026-07-16T11:25:00+02:00",
"title": "Args: Amazing or Approaching?",
"track": "Tooling, Packaging, Developer Productivity",
"tweet": "The way that you write code day to day is wrong. Come to Evan's talk \"Args: Amazing or Approaching?\" to find out why!",
"website_url": "https://ep2026.europython.eu/session/args-amazing-or-approaching",
"youtube_url": null
},
"GCWCEU": {
"abstract": "We know we should write automated tests. But too often, it is a real chore: they may be slow, unreliable, difficult to run, to maintain, even to write! Why is it so hard? How to take back control?\r\n\r\nFor that, you will work on a realistic project: a Python app with FastAPI backend, a PostgreSQL database, configuration files, third-party APIs, ... and tests that are awful.\r\n\r\nYou will review:\r\n- the quality culture of the project\r\n- how it is architectured\r\n- the existing tests\r\n- and the code quality\r\n\r\nThen you will prepare the plan:\r\n- your own test pyramid / strategy\r\n- testing tools needed\r\n- essential scenarios\r\n- the CI to have your back\r\n\r\nAnd start coding:\r\n- updating the existing tests\r\n- adding new tests using powerful tooling\r\n- minimal refactoring to enable testing\r\n- creating fakes/mocks/simulators to enable testing\r\n\r\nYou'll leave able to:\r\n* diagnose what makes tests slow or convoluted\r\n* design a pragmatic test strategy for your codebase\r\n* implement reliable tests, with fakes and testcontainers\r\n* refactor just enough to make code testable\r\n\r\nIt will be around 65% hands-on, and 35% guided analysis. The first two parts will take the first half of the session, so that you have plenty of time to actually implement the strategy during the second half.\r\nThe code repository will stay available to you after the workshop, along with an example of the end-result.\r\n\r\nSetup :\r\n* [`uv`](https://docs.astral.sh/uv/)\r\n* (optional) docker or podman, to run TestContainers\r\n* (optional) a GitHub or GitLab account, to run CI",
"code": "GCWCEU",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-13T12:45:00+02:00",
"level": "intermediate",
"next_session": "NELACW",
"prev_session": null,
"resources": null,
"room": "Conference Hall Complex B (S4B)",
"session_type": "Tutorial",
"sessions_after": [
"JRMSZT",
"NELACW",
"RARRL7",
"SNKUW7"
],
"sessions_before": [],
"sessions_in_parallel": [
"NQGSY7",
"QWEJWT",
"VYUNHG",
"WYBHCE"
],
"slug": "getting-out-of-the-testing-hell",
"speakers": [
"FBQ8LL",
"RTRPAJ"
],
"start": "2026-07-13T09:30:00+02:00",
"title": "Getting out of the testing hell",
"track": "Testing, Quality Assurance, Security",
"tweet": "Testing shouldn't hurt. If yours does, come fix it with us, we'll turn a broken test suite into something you can actually trust.",
"website_url": "https://ep2026.europython.eu/session/getting-out-of-the-testing-hell",
"youtube_url": null
},
"GEJAQW": {
"abstract": "Python supports parallelism through multiple sub-interpreters. Parallelism though sub-interpreters avoid the restrictions of a single GIL, and isolating parallel processes from each other is safe from data-races. The downside is that subinterpreter isolation comes with a high cost: sending objects across sub-interpreters typically involves pickling and copying which has negative impact on performance with both CPU and memory overheads. This talk is about [PEP795](https://pep-previews--4468.org.readthedocs.build/pep-0795/) which adds immutability to Python, which permits sub-interpreters to transfer and share immutable objects directly by reference. \r\n\r\nWe will present the design and rationale for immutability in Python, the API for creating and managing immutable state, decorators for communicating immutability in code, as well as opting out of immutability where necessary. We will also discuss our prototype implementation on-top of Python 3.15, and demonstrate how immutable sharing across sub-interpreters improves performance, and compare the speed of freezing (the act of making objects immutable) to pickling and unpickling. \r\n\r\nAttendees will learn:\r\n\r\n* About the semantics of immutability in Python, and what are the challenges of designing immutability to support sharing across sub-interpreters.\r\n* When immutability can improve performance and predictability in concurrent Python.\r\n* How freezing works for built-in types, user\u2011defined types and functions, and how it interacts with sub-interpreters.\r\n* Performance of pickling vs. immutable sharing, with numbers and failure modes.\r\n* Current limitations of immutability, risks, and what would need to land in CPython for this to be widely usable. Target audience: programmers interested in concurrent programming in Python.\r\n \r\n\r\nNote: This PEP is not yet accepted; the talk focuses on design, prototype results, and open questions.",
"code": "GEJAQW",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T12:35:00+02:00",
"level": "intermediate",
"next_session": "B7CMBD",
"prev_session": "G9FDRY",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"8HBEYS",
"9URK9U",
"B7CMBD",
"BMQP7J",
"E3GVVR",
"FB93DB",
"MJTZ7A"
],
"sessions_before": [
"AGX8D9",
"BYWVNK",
"DWGSFA",
"G9FDRY",
"JQSQBB"
],
"sessions_in_parallel": [
"9MRVPM",
"JSLSHM",
"LN7EF3",
"YKWMBZ"
],
"slug": "immutability-fast-and-safe-sharing-of-data-across-subinterpreters",
"speakers": [
"DKRZRV",
"ZAUJUS"
],
"start": "2026-07-16T12:05:00+02:00",
"title": "Immutability: Fast and Safe sharing of Data across Subinterpreters",
"track": "Python Core, Internals, Extensions",
"tweet": "Immutability can enable fast and safe sharing of data across sub-interpreters: Here is how PEP795 works and what we can do with it.",
"website_url": "https://ep2026.europython.eu/session/immutability-fast-and-safe-sharing-of-data-across-subinterpreters",
"youtube_url": null
},
"GP39VP": {
"abstract": "Over the last year, LLM-based coding agents have matured to the point where they can autonomously navigate codebases, edit files, run tests, and iterate on solutions with minimal human input. Many Python teams have started applying these agents to machine learning projects, where the volume of repetitive experimental work makes automation appealing.\r\n\r\nHowever, coding execution and ML optimization are not the same problem. In software engineering, success is often local and binary: a feature works or it does not, a bug is reproduced or fixed. In ML, code correctness is only a prerequisite. Progress is determined by measured model behavior across repeated experiments, and that measurement only happens after training and evaluation are complete. This distinction creates a coordination gap. Coding agents can generate and modify training code, but without external structure they drift over long experiment horizons. Teams encounter recurring failure modes: multiple coupled changes in a single step make results unattributable, LLMs lose context and rediscover already tested hypothesis in slightly different wording, etc.\r\n\r\nThis poster presents an architecture that addresses the gap by pairing coding agents with a deterministic (non-LLM) orchestrator. The orchestrator manages experimentation as a tree search. It starts from a reproducible baseline, samples hypothesis-driven modifications constrained to a single aspect per step, evaluates each modification through a fixed entrypoint that returns multiple metrics, and decides which branches to expand or prune based on statistical evidence. Each experiment runs in an isolated git worktree, so every branch has a clean file state, an independent diff, and a separate log. An anti-repetition memory tracks previously attempted hypotheses across the tree to prevent the agent from regenerating equivalent ideas. When stopping criteria are met, an integration stage combines winning branches and evaluates the result. \r\n\r\nThis presentation is aimed at ML engineers and data scientists who have experimented with (or are considering) coding agents for their workflows. Attendees will learn how to utilize coding agents for ML tasks and structure experiments as an LLM-searchable trajectory with deterministic controls rather than a sequence of ad-hoc edits.",
"code": "GP39VP",
"delivery": "in-person",
"duration": "60",
"end": "2026-07-17T14:00:00+02:00",
"level": "intermediate",
"next_session": null,
"prev_session": null,
"resources": null,
"room": "Exhibit Hall",
"session_type": "Poster",
"sessions_after": [
"NTZ7DG",
"QY7PFR",
"T7ATVM",
"WHHAQK",
"ZFJEUJ"
],
"sessions_before": [
"BJBKRM",
"FBQQXS",
"PWGSJQ",
"SCZ8ZK",
"SQRYJA"
],
"sessions_in_parallel": [
"7NWR9R",
"BX77EE",
"PBTPJR",
"RGBSS8",
"U7AHP3",
"UGLF7Q",
"VSZSMW"
],
"slug": "why-coding-agents-fail-at-ml-and-how-to-fix-it",
"speakers": [
"3QCPHT"
],
"start": "2026-07-17T13:00:00+02:00",
"title": "Why Coding Agents Fail at ML (and How to Fix It)",
"track": "Machine Learning, NLP and CV",
"tweet": "Coding agents can write code fast, but they break down in ML workflows. This poster shows why that happens and how to fix it with better structure.",
"website_url": "https://ep2026.europython.eu/session/why-coding-agents-fail-at-ml-and-how-to-fix-it",
"youtube_url": null
},
"H7DVRJ": {
"abstract": "Say you've built a library whose main value is providing built-in integrations with a considerable number (say 60+) of different Python packages. That's cool, and your users are loving the out-of-the-box experience. (Being blissfully unaware of the lengths you had to go to in the background to make things work \"seamlessly\" helps.) Everything seems to be working fine, you get the odd bug report or feature request, the usual.\r\n\r\nThen one day you wake up and your otherwise fairly chill issue tracker is drowning in folks experiencing an issue with your library that breaks their app. Your first thought is, why is this coming up now, when your last release was two weeks ago? And then you realize: It's not your release that broke the library.\r\n\r\nAll the third party code you're integrating with? It's become *your* code by extension. You need to react if something changes upstream and breaks your integration in unexpected ways. You can write your integrations so defensively that no one will ever want to read them again, but it's not enough: you can't anticipate every single change each of the 60+ packages will ever make.\r\n\r\nLet's assume having your users act as a release monitoring system by notifying you on your issue tracker is not what you want. How do you go about this? You'll want somehow to detect breakage early, so you can go fix things before your users are hit by them. And ideally you'd do it in a way that maintaining it is not a nightmare.\r\n\r\nThis talk will take you through one such journey, from recognizing the problem, to various attempts at making it better, to eventually arriving at a solution that's good enough for now (tm).\r\n\r\nYou might like this talk if you:\r\n- Have to deal with integrations in some shape or form\r\n- Are relying on third-party packages heavily\r\n- Don't like maintaining things by hand\r\n- Like to have that \"this can be automated with a script\" itch scratched\r\n- Are intrigued that there's a talk that has the word \"bananas\" in the title",
"code": "H7DVRJ",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T16:35:00+02:00",
"level": "beginner",
"next_session": "PKMSSL",
"prev_session": "ZRWENU",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Talk",
"sessions_after": [
"PKMSSL"
],
"sessions_before": [
"33RGZA",
"H7KGU3",
"LNVDY3",
"PCMBVT",
"PRGGNW",
"RMY7Y7",
"WKBHZW",
"ZRWENU"
],
"sessions_in_parallel": [
"JEN7WA",
"TWBDVZ",
"X3ENDU",
"Y3DGWB"
],
"slug": "how-to-maintain-60-integrations-and-not-go-bananas",
"speakers": [
"NVGXHG"
],
"start": "2026-07-15T16:05:00+02:00",
"title": "How to Maintain 60 Integrations and Not Go Bananas",
"track": "Testing, Quality Assurance, Security",
"tweet": "Integrating with a third-party package is one thing, but how do you make sure you keep supporting it, regardless of what changes it introduces?",
"website_url": "https://ep2026.europython.eu/session/how-to-maintain-60-integrations-and-not-go-bananas",
"youtube_url": null
},
"H7KGU3": {
"abstract": "*Pitch*\r\n\r\nWith DuckDB and DuckLake, managing and analyzing huge data sets is no longer limited to complex cloud infrastructure setups. You can literally run these tasks on your notebook now and at comparable speeds. This talk will show you how.\r\n\r\n*Description*\r\n\r\n**DuckDB** is an embedded relational analytics database (OLAP) which can be added to a Python project with a simple `uv add duckdb` or `pip install duckdb`. It is both fast and powerful for processing analytical data warehouse workloads, using the well-known PostgreSQL SQL dialect. Data can be stored in memory and persisted on disk. DuckDB is well integrated with Polars via zero copy Apache Arrow data structures, making it a great choice for complex data science and engineering tasks.\r\n\r\n**DuckLake** is a extension which comes with DuckDB to add data lake features, meaning that huge data sets can be managed using Parquet files stored on disk or in an object store such as S3. It uses a novel approach to data lakes in that the management structures are stored in a database (DuckDB), instead of complex file and directory structures, as many other data lake systems do. This provides great advantages for implementing smart features such as snapshots, schema evolution or time travel.\r\n\r\nAgain, installation of the extension is just a simple `INSTALL ducklake` command away, making this a really easy way to configure your own personal \"lake house\" - the ideal combination of a data warehouse with a data lake.\r\n\r\nThe talk will give a short introduction to the database terminology, explain what is novel about the DuckLake approach and then showcase a typical use case for lake houses: storing historical weather data and making this available for analytics to Python applications.\r\n\r\nBoth DuckDB and DuckLake are MIT licensed.\r\n\r\n*Resources:*\r\n- [Python.org](https://www.python.org/)\r\n- [DuckDB \u2013 An in-process SQL OLAP database management system](https://duckdb.org/)\r\n- [DuckLake is an integrated data lake and catalog format \u2013 DuckLake](https://ducklake.select/)",
"code": "H7KGU3",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T15:55:00+02:00",
"level": "intermediate",
"next_session": "JEN7WA",
"prev_session": "7VKQQM",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"H7DVRJ",
"JEN7WA",
"TWBDVZ",
"X3ENDU",
"Y3DGWB"
],
"sessions_before": [
"33RGZA",
"7VKQQM",
"ENK9EF",
"HJ8KPY",
"HVTSPC",
"LNVDY3",
"PRGGNW",
"SWCWKZ"
],
"sessions_in_parallel": [
"PCMBVT",
"RMY7Y7",
"WKBHZW",
"ZRWENU"
],
"slug": "ducklake-take-python-and-duckdb-for-a-swim-in-your-data-lake",
"speakers": [
"QYTJB9"
],
"start": "2026-07-15T15:25:00+02:00",
"title": "DuckLake - Take Python and DuckDB for a swim in your data lake",
"track": "Data Engineering and MLOps",
"tweet": "Using Python with DuckDB and DuckLake, or how to run terabyte scale data analytics on your notebook with ease.",
"website_url": "https://ep2026.europython.eu/session/ducklake-take-python-and-duckdb-for-a-swim-in-your-data-lake",
"youtube_url": null
},
"HJ8KPY": {
"abstract": "A few nights ago I was up to 2am obsessively crafting an LLM plan. (_\"Just one more prompt!\"_ - famous last words). Yet it still did something inexplicably stupid. \ud83e\udee0 So yeah: LLMs are both genuinely useful and genuinely destabilising. Focusing on the first and ignoring the second is how people burn out.\r\n\r\nThis talk is an honest account of what it feels like to be a developer right now, from someone inside it, and some thoughts on what might actually help. My thesis: we've been optimising for _model output_ when we need to be optimising for _human experience_.\r\n\r\nI'll share observations from my work, peers and colleagues. The peculiar fatigue of machine supervision: holding the intent in your head while the machine generates volumes of mostly-correct output that still needs your eyes, your judgment, and your taste. The way the satisfying part of the work shrank while the exhausting part grew. The isolation of pair-programming with a machine, and the loss of real human learning, interconnection and collaboration. And underneath all of it: uncertainty. About market conditions, about employability, about whether the skills we've spent years building will still matter.\r\n\r\nThe second half is about what's been working for me, and what hasn't. On the human side: encouraging pairing and teamwork even when the tools push you toward isolation, sharing the pain openly, naming the uncomfortable thing. On the technical side: structuring your environment to collaborate with LLMs more deliberately \u2014 writing plans, configuring project-specific rules. Learning when to stop prompting and just write code. And critically: rebalancing the push and pull of information so that you're directing your attention, not feeling at the mercy of the model's output. More Star Trek, less Black Mirror.\r\n\r\nLeave with concrete strategies for recalibrating your workflow, challenges to discuss and the reassurance that if you're finding this hard, you're not broken. The feedback loop is. And we can start fixing that.",
"code": "HJ8KPY",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T12:10:00+02:00",
"level": "intermediate",
"next_session": "ZRWENU",
"prev_session": "9EFAJS",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Talk",
"sessions_after": [
"33RGZA",
"LNVDY3",
"NEH7RE",
"NWLBJC",
"PRGGNW",
"UPELCT",
"W9NLXV",
"ZRWENU"
],
"sessions_before": [
"9EFAJS",
"DWBGJ9",
"M8Q77Z",
"QT97WA",
"Y8QAUA"
],
"sessions_in_parallel": [
"CBA98V",
"KRMBWS",
"VXDYGX"
],
"slug": "the-human-in-the-loop-is-tired",
"speakers": [
"QZAEVT"
],
"start": "2026-07-15T11:40:00+02:00",
"title": "The Human-in-the-Loop is Tired",
"track": "Professional Development, Careers, Leadership",
"tweet": "LLMs are useful tools that are also genuinely destabilising. Let's talk about optimising for human experience, not just model outputs.",
"website_url": "https://ep2026.europython.eu/session/the-human-in-the-loop-is-tired",
"youtube_url": null
},
"HVTSPC": {
"abstract": "Conventions are one of Django\u2019s greatest strengths.\r\n\r\nThey simplify our day-to-day work, reduce cognitive load, and let teams move fast with confidence. By following well-established defaults, we spend less time debating structure and more time solving real problems.\r\n\r\nBut every convention is also a decision - and every decision has trade-offs.\r\n\r\nWho decided these conventions? Why were they chosen? And what happens when your problem doesn\u2019t quite fit the \u201cDjango way\u201d?\r\n\r\nIn this talk, we\u2019ll explore Django\u2019s conventions as both a feature and a constraint. We\u2019ll look at where they shine, where they leak, and how experienced developers can respectfully bend (or break) them without fighting the framework. This is a talk for anyone who loves Django \u2014 especially when they disagree with it.",
"code": "HVTSPC",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T15:00:00+02:00",
"level": "beginner",
"next_session": "PCMBVT",
"prev_session": "DRXC3E",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Talk",
"sessions_after": [
"H7KGU3",
"PCMBVT",
"RMY7Y7",
"WKBHZW",
"ZRWENU"
],
"sessions_before": [
"33RGZA",
"3HBWHB",
"DRXC3E",
"HJ8KPY",
"LNVDY3",
"NWLBJC",
"PRGGNW",
"US3W8J"
],
"sessions_in_parallel": [
"7VKQQM",
"ENK9EF",
"SWCWKZ"
],
"slug": "i-am-a-sucker-for-conventions-why-djangos-defaults-work-until-they-dont",
"speakers": [
"3FFT99"
],
"start": "2026-07-15T14:30:00+02:00",
"title": "I Am a Sucker for Conventions. Why Django\u2019s Defaults Work, Until They Don\u2019t",
"track": "Web Development, Web APIs, Front-End Integration",
"tweet": "Conventions are one of Django\u2019s greatest strengths. But every convention is also a decision \u2014 and every decision has trade-offs.",
"website_url": "https://ep2026.europython.eu/session/i-am-a-sucker-for-conventions-why-djangos-defaults-work-until-they-dont",
"youtube_url": null
},
"JEN7WA": {
"abstract": "Modern data systems rarely stay unchanged. Schemas evolve, search indices are rebuilt, and for some period of time, multiple versions of the same dataset need to be kept in sync. A typical example is a zero-downtime migration, where several versions of the same data must be synchronised in parallel while the system remains live. This creates a subtle but important challenge: how to keep each version consistent without duplicating extraction work or increasing database load.\r\n\r\nIn this talk, I\u2019ll describe a production ETL architecture built in Python that processes multiple data versions in parallel using a single streaming pipeline. The system synchronises data from PostgreSQL into OpenSearch, keeps each version independently consistent, and guarantees that no version ever moves backwards \u2014 while querying the database only once per batch. The talk is based on a real production system and explains the design decisions and tradeoffs behind it.\r\n\r\nThe design is based on generator pipelines and functional composition using the functools module. Instead of relying on threads or async frameworks, the ETL flow is expressed as a sequence of small, composable functions: page extraction, DTO normalisation, version-aware filtering, transformation, bulk loading, and dead-letter handling. The reference implementation uses Django as the ORM layer and Celery for orchestration, but the core design is not framework-specific and can be applied equally with SQLAlchemy or raw SQL.\r\n\r\nI\u2019ll show how this design makes it possible to:\r\n1. Synchronise multiple versions efficiently without duplicate database queries\r\n2. Process large datasets in a streaming, memory-efficient way\r\n3. Build extensible pipelines from protocol-defined functional stages\r\n4. Maintain a clear separation of concerns with strong typing and isolated tests\r\n5. handle failures safely using bulk retries and dead-letter queues\r\n\r\nAttendees will leave with concrete patterns for building fast and maintainable ETL pipelines in Python, and with a clearer understanding of how generators and functional composition can be used to model complex data flows \u2014 borrowing ideas from Go-style concurrency while staying entirely within the Python ecosystem. While the examples focus on ETL pipelines, the patterns discussed apply to any Python system that processes large streams of data and needs to balance performance, correctness, and extensibility.\r\n\r\nAudience: Intermediate to advanced Python developers. Familiarity with generators and basic ETL concepts is helpful; interest in functional design patterns and backend data systems will be beneficial.",
"code": "JEN7WA",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T16:35:00+02:00",
"level": "intermediate",
"next_session": "PKMSSL",
"prev_session": "H7KGU3",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"PKMSSL"
],
"sessions_before": [
"33RGZA",
"H7KGU3",
"LNVDY3",
"PCMBVT",
"PRGGNW",
"RMY7Y7",
"WKBHZW",
"ZRWENU"
],
"sessions_in_parallel": [
"H7DVRJ",
"TWBDVZ",
"X3ENDU",
"Y3DGWB"
],
"slug": "fast-multi-version-etl-pipelines-in-python-with-generators-and-functools",
"speakers": [
"XCBLVD"
],
"start": "2026-07-15T16:05:00+02:00",
"title": "Fast Multi-Version ETL Pipelines in Python with Generators and functools",
"track": "Data Engineering and MLOps",
"tweet": "Building multi-version ETL pipelines in Python with generators and functools for memory-efficient, streaming data processing.",
"website_url": "https://ep2026.europython.eu/session/fast-multi-version-etl-pipelines-in-python-with-generators-and-functools",
"youtube_url": null
},
"JGBFDF": {
"abstract": "Welcome to EuroPython 2026! Please notice the registration will happen on the TBD.\r\nYou can pick up your badges at any time during the week as long as we are open!\r\nIf you want to avoid the morning rush on Wednesday, come on Monday and Tuesday!\r\nEnjoy the conference!",
"code": "JGBFDF",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T08:45:00+02:00",
"level": "beginner",
"next_session": "UPKZKC",
"prev_session": null,
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Announcements",
"sessions_after": [
"UPKZKC"
],
"sessions_before": [],
"sessions_in_parallel": [],
"slug": "friday-registration-welcome-tbd",
"speakers": [],
"start": "2026-07-17T08:00:00+02:00",
"title": "Friday Registration & Welcome @ TBD",
"track": null,
"tweet": "Friday Registration & Welcome @ TBD ! Enjoy the conference !",
"website_url": "https://ep2026.europython.eu/session/friday-registration-welcome-tbd",
"youtube_url": null
},
"JQSQBB": {
"abstract": "GPUs power almost every modern Python workload in machine learning, vision, and scientific computing. Yet most Python developers treat GPUs like \u201cfaster CPUs\u201d and hope frameworks will handle performance automatically.\r\nThat mental model is wrong and it is the main reason Python GPU code underperforms by orders of magnitude.\r\n\r\nThis introductory talk builds the correct mental model for writing fast GPU code in Python. We will explore how modern GPUs are structured, why global memory dominates execution time, and how to determine whether a kernel is compute-bound or memory-bound using the roofline model. Through concrete examples, attendees will see why naive parallel kernels fail to scale and which hardware-aware patterns; tiling, data reuse, and kernel fusion actually lead to speedups.\r\n\r\nThe session concludes with a practical look at how Python can express these ideas using Triton, showing how high-level code is compiled into PTX and how Python can approach near-CUDA performance when it respects hardware constraints.",
"code": "JQSQBB",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T11:55:00+02:00",
"level": "intermediate",
"next_session": "JSLSHM",
"prev_session": "ETBPVR",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Talk",
"sessions_after": [
"8HBEYS",
"9MRVPM",
"9URK9U",
"GEJAQW",
"JSLSHM",
"LN7EF3",
"YKWMBZ"
],
"sessions_before": [
"788XZA",
"CWBA3L",
"ETBPVR",
"TZHTEE",
"UGM7F8"
],
"sessions_in_parallel": [
"AGX8D9",
"BYWVNK",
"DWGSFA",
"G9FDRY"
],
"slug": "an-introduction-to-writing-fast-gpu-code-in-python",
"speakers": [
"QAHDBD"
],
"start": "2026-07-16T11:25:00+02:00",
"title": "An Introduction to Writing Fast GPU Code in Python",
"track": "Machine Learning: Research & Applications",
"tweet": "Python is evolving as language for GPU Programming. This talk introduces hardware-aware GPU programming for Python developers.",
"website_url": "https://ep2026.europython.eu/session/an-introduction-to-writing-fast-gpu-code-in-python",
"youtube_url": null
},
"JRMSZT": {
"abstract": "Have you ever opened a piece of code that seems to break just by looking at it\u2014and noticed that your coworker wrote it? You don\u2019t want to be *that* person. While tangled, hard-to-maintain code can emerge for many reasons, it should never be by accident.\r\n\r\nIn this hands-on workshop, you will learn how to make code easier to maintain and to evolve. We will gradually refactor a messy Python web application into a well-organized, testable software. You will develop a mental model for organizing code effectively and understand how its structure impacts code quality. Ultimately, this will inform future decisions on design and code organization.\r\n\r\nThis workshop is specifically designed for people who don't identify as software engineers or don't perform typical software engineering tasks as part of their daily work. Participants should be familiar with basic Python programming and the concept of automated (unit) tests.",
"code": "JRMSZT",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-13T17:00:00+02:00",
"level": "beginner",
"next_session": null,
"prev_session": "WYBHCE",
"resources": [
{
"description": "Preliminary slides (Part 4 of the outline missing)",
"resource": "https://programme.europython.eu/media/europython-2026/submissions/JRMSZT/resources/Code_Organ_ByShOk7.pdf"
}
],
"room": "Chamber Hall B (S3B)",
"session_type": "Tutorial",
"sessions_after": [],
"sessions_before": [
"GCWCEU",
"NQGSY7",
"QWEJWT",
"WYBHCE"
],
"sessions_in_parallel": [
"NELACW",
"RARRL7",
"SNKUW7",
"VYUNHG"
],
"slug": "code-organization-for-non-engineers",
"speakers": [
"A7BNZH"
],
"start": "2026-07-13T13:45:00+02:00",
"title": "Code organization for non-engineers",
"track": "Testing, Quality Assurance, Security",
"tweet": "Turn messy Python into maintainable, testable code\u2014learn to refactor, organize, and level up your skills!",
"website_url": "https://ep2026.europython.eu/session/code-organization-for-non-engineers",
"youtube_url": null
},
"JSLSHM": {
"abstract": "GPU programming can be scary, but doesn't need to be! Did you know you can access the full performance of CUDA purely in Python? With the full CUDA Python stack, you have a friendly interface to get you started with GPU acceleration.\r\n\r\nIn this example-driven talk, we'll begin with a general discussion of the CUDA model and how to manage accelerator devices in Python with cuda.core. Next, we'll teach you how to create arrays and launch work with CuPy. Then, you'll learn how to customize parallel algorithms with cuda.compute and write your own kernels that leverage cooperative algorithms with cuda.coop, and integrate seamlessly with accelerated libraries such as cuBLAS and cuDNN.\r\n\r\nWe'll look at a variety of parallel examples, from counting words, to implementing softmax and row-wise reductions.\r\n\r\nBy the time the talk is over, you'll be ready to start accelerating your Python code with GPUs!",
"code": "JSLSHM",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T12:35:00+02:00",
"level": "intermediate",
"next_session": "FB93DB",
"prev_session": "JQSQBB",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Talk",
"sessions_after": [
"8HBEYS",
"9URK9U",
"B7CMBD",
"BMQP7J",
"E3GVVR",
"FB93DB",
"MJTZ7A"
],
"sessions_before": [
"AGX8D9",
"BYWVNK",
"DWGSFA",
"G9FDRY",
"JQSQBB"
],
"sessions_in_parallel": [
"9MRVPM",
"GEJAQW",
"LN7EF3",
"YKWMBZ"
],
"slug": "gpu-programming-in-pure-python",
"speakers": [
"PJBCE3"
],
"start": "2026-07-16T12:05:00+02:00",
"title": "GPU Programming in Pure Python",
"track": "~ None of these topics",
"tweet": "GPU programming can be scary, but doesn't need to be! Come to this talk to learn how to access the full performance of CUDA purely in Python.",
"website_url": "https://ep2026.europython.eu/session/gpu-programming-in-pure-python",
"youtube_url": null
},
"K7XNTF": {
"abstract": "The majority of the new modules that we see out there including the word \"performance\" in their campaigns are Python modules with extensions in other languages. This has been very clear with languages like Rust, and C++, which has been the core of many popular modules in the recent years.\r\n\r\nBut how difficult is to extend CPython? and more importantly, what are the steps of doing it with other languages?\r\n\r\nThis tutorial aims to be a good starting point for people that wants to familiarize themselves with the CPython internal, and how to do extensions with languages like C, C++, Rust, and Zig, by developing a series of small exercises that will enable you to get more familiar with the processes.\r\n\r\nOn this tutorial you will learn to:\r\n\r\n- Explore the core of the standard Python implementation\r\n- Modify the interpreter by adding new functions\r\n- Extend Python with C, Rust, and Zig.\r\n\r\nThe session will be a combination of a theoretical introduction of the topics, followed by a hand-on experience on each step.\r\n\r\nSome knowledge with C, C++, Rust or Zig is encouraged, but not required.",
"code": "K7XNTF",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-14T17:00:00+02:00",
"level": "intermediate",
"next_session": null,
"prev_session": "MENRZG",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Tutorial",
"sessions_after": [
"3APM9B"
],
"sessions_before": [
"3FDLUS",
"BTTFFJ",
"MENRZG",
"TGGHKC",
"ZPCDKE"
],
"sessions_in_parallel": [
"3TZHB9",
"N39TFS",
"ZSRZPC"
],
"slug": "understand-and-expand-python-a-hands-on-experience-on-python-internals",
"speakers": [
"8VVS8L"
],
"start": "2026-07-14T13:45:00+02:00",
"title": "Understand and expand Python: a hands-on experience on Python internals",
"track": "Python Core, Internals, Extensions",
"tweet": "Jump into Python's internal by undertanding and extending it!",
"website_url": "https://ep2026.europython.eu/session/understand-and-expand-python-a-hands-on-experience-on-python-internals",
"youtube_url": null
},
"KFQN3X": {
"abstract": "Have you ever needed to debug a live Python process but couldn't restart it? Didn't want to redeploy with debug flags or manage sidecar containers just to debug your application?\r\n\r\nIn this talk, I'll show you why `sys.remote_exec()` is one of the coolest features of Python 3.14! I'll cover the basics of Python's new remote debugging capabilities and demonstrate how `sys.remote_exec()` can be combined with debugpy (an implementation of the Debug Adapter Protocol) to provide full IDE debugging experiences for live processes. I'll share what I learned building a tool that uses these primitives to attach debuggers to FastAPI applications running in local Kubernetes clusters.\r\n\r\nBeyond debugging, we'll explore other use cases for `sys.remote_exec()` and how you can apply the feature to solve problems in your own work!",
"code": "KFQN3X",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T10:40:00+02:00",
"level": "intermediate",
"next_session": "ARRMQR",
"prev_session": "UPKZKC",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"7SSS93",
"ARRMQR",
"BX77EE",
"FBQQXS",
"GP39VP",
"SCZ8ZK",
"TG7YMS",
"U7AHP3"
],
"sessions_before": [
"UPKZKC"
],
"sessions_in_parallel": [
"DBBNQD",
"LFSJYL",
"RB9TKP",
"SGM9SV"
],
"slug": "the-coolest-feature-in-python-3-14-sys-remote-exec",
"speakers": [
"HB3VXK"
],
"start": "2026-07-17T10:10:00+02:00",
"title": "The coolest feature in Python 3.14: sys.remote_exec()",
"track": "Python Core, Internals, Extensions",
"tweet": "Debugging live Python in containers is painful. Learn how sys.remote_exec() in 3.14 lets you inject a debugger into running pods - no restart needed.",
"website_url": "https://ep2026.europython.eu/session/the-coolest-feature-in-python-3-14-sys-remote-exec",
"youtube_url": null
},
"KRMBWS": {
"abstract": "Python 3.15's 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.",
"code": "KRMBWS",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T12:10:00+02:00",
"level": "advanced",
"next_session": "W9NLXV",
"prev_session": "Y8QAUA",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"33RGZA",
"LNVDY3",
"NEH7RE",
"NWLBJC",
"PRGGNW",
"UPELCT",
"W9NLXV",
"ZRWENU"
],
"sessions_before": [
"9EFAJS",
"DWBGJ9",
"M8Q77Z",
"QT97WA",
"Y8QAUA"
],
"sessions_in_parallel": [
"CBA98V",
"HJ8KPY",
"VXDYGX"
],
"slug": "inside-python-3-15-s-jit-optimizer",
"speakers": [
"7Y9DS3"
],
"start": "2026-07-15T11:40:00+02:00",
"title": "Inside Python 3.15's JIT Optimizer",
"track": "Python Core, Internals, Extensions",
"tweet": "Python 3.15's JIT is getting faster. Find out the technical details in this talk!",
"website_url": "https://ep2026.europython.eu/session/inside-python-3-15-s-jit-optimizer",
"youtube_url": null
},
"LFSJYL": {
"abstract": "*The hardships of building End-to-End Voice Assistants in the Wild*\r\n\r\nRobot Holmes is back in the mist-choked streets of MLington, but he isn\u2019t working solo.\r\n\r\nMeet Zintia, an intern from the Voice Assistant district. She\u2019s helpful, hyper-efficient, and incredibly annoying, providing Holmes with data before he can lift a finger. But Zintia has a secret. The longer she\u2019s on the case, the more of her \"dark side\" emerges. She\u2019s not just hearing the truth; she\u2019s deciding which parts Holmes is allowed to hear.\r\n\r\nThis is a story-driven, practical session for anyone tired of \"Hello World\" chatbots. We will move past the hype to look at what it actually take to make End-to-End Voice Assistants work in the real world.\r\n\r\nOur Investigation Includes:\r\n\r\n- The Gear: How to use E2E speech models like gpt-realtime and integrate them into a production voice interface using FreeSWITCH and Pipecat.\r\n- The Interrogation: Navigating the hardships of instruction-following, ensuring underlying LLMs stay on path through defined states and agentic flow.\r\n- The Double-Cross: Identifying and mitigating \"hidden agendas\" - the hallucinations and safety guardrails that can make a voice assistant turn on its user.\r\n\r\nExpect live demos, hard-won production lessons, a detective noir story and a blueprint for building voice agents that are fast, fluid, and (mostly) law-abiding.",
"code": "LFSJYL",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-17T10:55:00+02:00",
"level": "intermediate",
"next_session": "FBQQXS",
"prev_session": "UPKZKC",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Talk (long session)",
"sessions_after": [
"7SSS93",
"ARRMQR",
"BX77EE",
"FBQQXS",
"GP39VP",
"SCZ8ZK",
"TG7YMS",
"U7AHP3"
],
"sessions_before": [
"UPKZKC"
],
"sessions_in_parallel": [
"DBBNQD",
"KFQN3X",
"RB9TKP",
"SGM9SV"
],
"slug": "robot-holmes-and-the-silenced-witness-a-noir-guide-to-real-time-voice-ai",
"speakers": [
"QFSMUG"
],
"start": "2026-07-17T10:10:00+02:00",
"title": "Robot Holmes and the Silenced Witness: A Noir Guide to Real-Time Voice AI",
"track": "Machine Learning, NLP and CV",
"tweet": "Robot Holmes vs. Zintia: A detective noir guide to building real-time Voice AI. Fast, fluid, and potentially fatal. \ud83d\udd0d\ud83d\udc0d\u2728",
"website_url": "https://ep2026.europython.eu/session/robot-holmes-and-the-silenced-witness-a-noir-guide-to-real-time-voice-ai",
"youtube_url": null
},
"LN7EF3": {
"abstract": "This talk explores how **Python games can run entirely in the browser using WebAssembly (WASM)** and how they can also be **written and modified directly in the browser using Python itself**.\r\n\r\nRather than treating the browser as a mere deployment target, this talk presents it as the **primary learning environment**. Learners interact with a browser-embedded code editor where they write Python code that directly controls and modifies a game, which is also implemented in Python. This creates a zero-install, highly interactive learning experience where Python concepts are introduced through familiar game mechanics instead of traditional REPLs or slide-based instruction.\r\n\r\nThe focus of this talk is **not on building a game engine**, but on how **educators and instructors** can leverage **WASM to safely run Python in the browser for teaching purposes**. The talk introduces a tool I built that enables instructors to design browser-based Python tutorials using common game concepts such as scenery, sprites, and swatches, making it easier to create engaging, game-driven learning content.\r\n\r\nThe talk covers:\r\n- How Python can be executed in the browser using WebAssembly\r\n- A comparison of **Pyodide vs. pyscript**, highlighting their benefits and limitations in educational contexts\r\n- How browser-based execution changes assumptions around security, isolation, and infrastructure\r\nIn the latter part of the talk, this approach is packaged as an **XBlock**, the modular unit used to build courses in **Open edX**. This demonstrates how WASM-based Python execution can be integrated into large-scale learning platforms and how it compares to traditional server-side execution models such as **CodeJail**, highlighting improvements in safety, reduced infrastructure complexity, and an improved learner experience.\r\n\r\n**WebAssembly enables a new class of interactive, game-based Python learning experiences** that run securely and entirely in the browser, without requiring local setup or server-side code execution.",
"code": "LN7EF3",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T12:35:00+02:00",
"level": "intermediate",
"next_session": "BMQP7J",
"prev_session": "DWGSFA",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk",
"sessions_after": [
"8HBEYS",
"9URK9U",
"B7CMBD",
"BMQP7J",
"E3GVVR",
"FB93DB",
"MJTZ7A"
],
"sessions_before": [
"AGX8D9",
"BYWVNK",
"DWGSFA",
"G9FDRY",
"JQSQBB"
],
"sessions_in_parallel": [
"9MRVPM",
"GEJAQW",
"JSLSHM",
"YKWMBZ"
],
"slug": "python-games-in-the-browser-teaching-with-webassembly",
"speakers": [
"NXPA9Z"
],
"start": "2026-07-16T12:05:00+02:00",
"title": "Python Games in the Browser: Teaching with WebAssembly",
"track": "Community Building, Education, Outreach",
"tweet": "Teach Python through games that run entirely in the browser with WebAssembly \u2014 zero-install, safe, and built for modern learning.",
"website_url": "https://ep2026.europython.eu/session/python-games-in-the-browser-teaching-with-webassembly",
"youtube_url": null
},
"LNVDY3": {
"abstract": "Most Django testing tutorials stop at \"write a test, make it pass, refactor.\" But real-world Django applications have complex model relationships, permission systems, third-party API integrations, and asynchronous task chains that demand more sophisticated testing strategies. After delivering a hands-on TDD workshop at DjangoCon US 2023 and applying these patterns across multiple production Django codebases, I've identified a set of recurring testing patterns and anti-patterns that significantly impact both test reliability and developer productivity.\r\n\r\nThis poster presents a visual field guide to practical TDD patterns in Django, organized as a decision-tree poster that developers can reference when writing tests for their own projects.\r\n\r\n**Section 1 \u2014 The Factory Pattern Taxonomy.** A visual decision tree for choosing the right `factory_boy` strategy based on your model structure. When to use `SubFactory` vs. `RelatedFactory` vs. `LazyAttribute` for foreign keys, how to handle circular relationships without creating test data explosions, and the `create` vs. `build` vs. `build_batch` decision that controls whether you hit the database. Annotated with `faker` provider selection for generating realistic test data that keeps test failure messages readable.\r\n\r\n**Section 2 \u2014 Testing Permission Layers Without Drowning in Fixtures.** Django apps often have three or more permission layers: model-level, view-level, and object-level (via packages like `django-guardian` or row-level security). This section shows a visual matrix for structuring permission tests: one axis for user roles, one for resources, and a clear pattern for generating all combinations using parameterized tests with `pytest.mark.parametrize` and factory traits. Instead of writing 30 separate test functions, you write one parameterized test with a role-resource matrix.\r\n\r\n**Section 3 \u2014 The Mock Boundary Diagram.** A flowchart showing where to place mocking boundaries in a Django request lifecycle. The poster illustrates the difference between mocking at the view level, the service layer, and the adapter/client level \u2014 and why mocking too deep creates brittle tests while mocking too shallow creates slow ones. Includes a decision rule: \"Mock at the boundary where your code meets code you don't own.\"\r\n\r\n**Section 4 \u2014 Common Anti-Patterns and Fixes.** A visual rogues' gallery of the five most common Django testing anti-patterns with before/after code comparisons: test database leaks from missing `TransactionTestCase`, over-mocking that tests implementation instead of behavior, fixture files that nobody can maintain, test ordering dependencies, and the \"God factory\" that creates half the database for every test.\r\n\r\nVisitors will gain a practical decision framework for structuring Django tests, rather than just knowledge of individual testing tools. The patterns are tool-agnostic at their core (though examples use `pytest-django`, `factory_boy`, and `faker`) and apply to any Django project.",
"code": "LNVDY3",
"delivery": "in-person",
"duration": "60",
"end": "2026-07-15T13:50:00+02:00",
"level": "intermediate",
"next_session": null,
"prev_session": null,
"resources": null,
"room": "Exhibit Hall",
"session_type": "Poster",
"sessions_after": [
"3HBWHB",
"DRXC3E",
"NWLBJC",
"US3W8J",
"ZRWENU"
],
"sessions_before": [
"CBA98V",
"HJ8KPY",
"NEH7RE",
"UPELCT",
"W9NLXV"
],
"sessions_in_parallel": [
"33RGZA",
"PRGGNW"
],
"slug": "django-tdd-patterns-a-visual-field-guide",
"speakers": [
"CNF9BG"
],
"start": "2026-07-15T12:50:00+02:00",
"title": "Django TDD Patterns: A Visual Field Guide",
"track": "Testing, Quality Assurance, Security",
"tweet": "A visual decision-tree poster for Django TDD: factory_boy patterns, permission testing matrices, mock boundaries, and anti-pattern fixes.",
"website_url": "https://ep2026.europython.eu/session/django-tdd-patterns-a-visual-field-guide",
"youtube_url": null
},
"LRVCYU": {
"abstract": "As developers, our daily workflow is scattered across dozens of platforms: GitHub for PRs and issues, Jira or Linear for tasks, GitLab for CI/CD, and Todoist for personal focus. Constant \"context switching\" between browser tabs is a productivity killer. To solve this, I built **Monokl** - a unified terminal dashboard that aggregates these services into a single, high-performance interface.\r\n\r\nIn this talk, we explore how to build complex, API-driven applications using **Textual**, the rapid application development framework for Python. We will dive into the real-world challenges of building Monokl, including:\r\n\r\n* **Async integration:** How to fetch data from multiple APIs (GitHub, Atlassian, GitLab, Linear) without freezing the UI.\r\n* **Component architecture:** Designing reusable widgets for task lists, progress bars, and status feeds.\r\n* **Reactive UI:** Using Textual\u2019s reactive traits to ensure your dashboard updates not long after a PR is approved or a task is completed.\r\n* **The TUI advantage:** Why a terminal interface is often faster and more focused than a web-based aggregator.\r\n\r\nAttendees will walk away with a clear blueprint for building their own interactive terminal tools and a deep understanding of the Textual framework.\r\n\r\n## **Learning Outcomes**\r\n\r\n* **Learning Textual:** Understand the core architecture of `App`, `Screen`, and `Widget`.\r\n* **Managing async data:** Learn patterns for integrating multiple external APIs/CLIs into a single event loop.\r\n* **Modern layouts:** How to use **TCSS** (Textual CSS) to create beautiful, responsive terminal layouts.\r\n* **State & reactivity:** How to use `@reactive` attributes to create a UI that stays in sync with background data.",
"code": "LRVCYU",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T16:00:00+02:00",
"level": "beginner",
"next_session": "8XMJGZ",
"prev_session": "NTZ7DG",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"8XMJGZ"
],
"sessions_before": [
"BX77EE",
"GP39VP",
"NTZ7DG",
"QY7PFR",
"T7ATVM",
"U7AHP3",
"WHHAQK",
"ZFJEUJ"
],
"sessions_in_parallel": [
"BPJHWT",
"MP9ZRM",
"ZHCNDY"
],
"slug": "modern-tui-with-textual-in-python-building-monokl",
"speakers": [
"VKW7DJ"
],
"start": "2026-07-17T15:30:00+02:00",
"title": "Modern TUI with Textual in Python: Building Monokl",
"track": "Tooling, Packaging, Developer Productivity",
"tweet": "Learn how to build a modern, high-performance TUI with Textual by following the journey of Monokl, a terminal aggregator for GitHub, Jira, and more.",
"website_url": "https://ep2026.europython.eu/session/modern-tui-with-textual-in-python-building-monokl",
"youtube_url": null
},
"M8Q77Z": {
"abstract": "In 2023, PyPI started supporting Trusted Publishers: A way to publish Python packages to PyPI without relying on insecure password and short-lived tokens. Three years later, this approach has become the default answer to package registries' security, as it found its way into NPM, crates.io, and RubyGems. But does it actually offer the benefits we hoped it would? Can you really trust the green checkmark, and if you can't, what's the point?\r\n\r\nIn this talk, I want to look closely at what Trusted Publishers are, and what we _might_ think they are; who they do and do not protect. We'll explore the potential centralization problem of relying on Big Tech, US-based CI providers, leaving little room for smaller players like Codeberg and Sourcehut, as well as self-hosted Git forges and CI engines.\r\n\r\nBut even when using GitHub, Trusted Publisher may be tricky to get right, exposing different backdoors for the attacker to exploit. I want to discuss the illusion of security Trusted Publishers may give the inexperienced PyPI user; that is, if they actually decide to look at the hidden details of the published artifacts. How can we safeguard our Python projects, and should it be us who safeguards it? I will propose some solutions to this issue, including how the package managers and the PyPI registry itself can help us in this task.\r\n\r\nLastly, we'll reminisce about the past in search of answer. Maybe OpenPGP \u2018Web of Trust\u2019 wasn't such a bad idea after all? Can we regain our independence in deciding who we do and don't trust?",
"code": "M8Q77Z",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-15T11:30:00+02:00",
"level": "intermediate",
"next_session": "VXDYGX",
"prev_session": "BJCYNE",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Talk (long session)",
"sessions_after": [
"33RGZA",
"CBA98V",
"HJ8KPY",
"KRMBWS",
"LNVDY3",
"PRGGNW",
"UPELCT",
"VXDYGX"
],
"sessions_before": [
"BJCYNE"
],
"sessions_in_parallel": [
"9EFAJS",
"DWBGJ9",
"QT97WA",
"Y8QAUA"
],
"slug": "should-you-trust-trusted-publishing",
"speakers": [
"XZGYGJ"
],
"start": "2026-07-15T10:45:00+02:00",
"title": "Should you trust Trusted Publishing?",
"track": "Testing, Quality Assurance, Security",
"tweet": "Everyone says one should use Trusted Publisher, but can you, the maintainer, feel safe, and can you, the consumer, actually trust the green checkmark?",
"website_url": "https://ep2026.europython.eu/session/should-you-trust-trusted-publishing",
"youtube_url": null
},
"MENRZG": {
"abstract": "Decorators are one of Python's most powerful features. But for many developers, they remain somewhat mysterious and intimidating, because they combine a number of complex ideas -- among them, functions as objects, and nested function definitions. In this tutorial, you'll learn what decorators are, how they work, how to write them, and when you should use them. Along the way, you'll write a bunch of decorators that will demonstrate their power and practical use cases.\r\n\r\nThis is a highly interactive, learn-by-doing tutorial in which you'll be actively encouraged to ask questions, challenge the instructor, and share your code (including code that doesn't work), to maximize everyone's learning.",
"code": "MENRZG",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-14T12:45:00+02:00",
"level": "intermediate",
"next_session": "K7XNTF",
"prev_session": null,
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Tutorial",
"sessions_after": [
"3TZHB9",
"K7XNTF",
"N39TFS",
"ZSRZPC"
],
"sessions_before": [],
"sessions_in_parallel": [
"3FDLUS",
"BTTFFJ",
"TGGHKC",
"ZPCDKE"
],
"slug": "let-s-write-some-decorators",
"speakers": [
"VZM8L3"
],
"start": "2026-07-14T09:30:00+02:00",
"title": "Let's write some decorators!",
"track": "Python Core, Internals, Extensions",
"tweet": "Finally understand Python's decorators \u2014 how they work, and how to use them.",
"website_url": "https://ep2026.europython.eu/session/let-s-write-some-decorators",
"youtube_url": null
},
"MJTZ7A": {
"abstract": "Artificial intelligence has become deeply embedded in modern Python development workflows. From generating backend services to refactoring production systems, large language models now influence how software is designed, implemented, and shipped. While these tools offer significant productivity gains, many teams are discovering a less visible cost: code is increasingly produced faster than architectural decisions can be reviewed, validated, and governed.\r\n\r\nIn real production environments, particularly those built on distributed services, data pipelines, and cloud infrastructure, unstructured AI-driven development often leads to predictable outcomes. Teams encounter rising defect rates, fragile integrations, unclear system ownership, security regressions, and access control mistakes introduced by AI-generated code. Over time, these issues surface as service outages, compliance risks, lost clients, and escalating maintenance costs. The problem is not AI itself, but the absence of engineering structure around how it is used.\r\n\r\nThis talk examines why unsupervised \u201cvibe coding\u201d fails at scale and how development teams can adopt a disciplined, AI-assisted development model that improves both velocity and reliability. Drawing from real-world backend systems, I will present practical techniques for embedding AI across the Software Development Life Cycle \u2014 including structured design inputs, architecture validation, automated reviews, testing strategies, and continuous quality controls.\r\n\r\nTo ground the discussion in reality, the session includes a concrete production case study from a rapidly developed, AI-assisted Python system. Starting from access to a single project, I was able to traverse service boundaries and gain visibility into multiple cloud environments and internal repositories across both AWS and GCP. The root cause was not a single vulnerability, but a chain of small, AI-generated decisions: overly broad permissions, copied infrastructure patterns, missing ownership boundaries, and unreviewed assumptions propagated across services. The result was a system that appeared to move quickly, but ultimately required emergency remediation, delayed releases, and loss of trust.\r\n\r\nThe talk concludes by addressing a common misconception: a 50% increase in coding speed does not translate into 50% faster product delivery. Without governance, the opposite is often true.\r\n\r\nThe session is aimed at Python developers, technical leads, and architects responsible for production systems. Familiarity with Python backend development is recommended, but no prior experience with AI tooling is required.",
"code": "MJTZ7A",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T13:15:00+02:00",
"level": "intermediate",
"next_session": "PPQ3KE",
"prev_session": "9MRVPM",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"93XE3S",
"NXNHSB",
"PPQ3KE",
"UY9UAG",
"VNR377"
],
"sessions_before": [
"9MRVPM",
"GEJAQW",
"JSLSHM",
"LN7EF3",
"YKWMBZ"
],
"sessions_in_parallel": [
"8HBEYS",
"9URK9U",
"B7CMBD",
"BMQP7J",
"E3GVVR",
"FB93DB"
],
"slug": "the-hidden-cost-of-vibe-coding",
"speakers": [
"FCQWZC"
],
"start": "2026-07-16T12:45:00+02:00",
"title": "The hidden cost of vibe coding",
"track": "Community Building, Education, Outreach",
"tweet": "AI speeds up coding, but breaks systems without discipline. A real case of vibe coding, security failure, and lessons learned.",
"website_url": "https://ep2026.europython.eu/session/the-hidden-cost-of-vibe-coding",
"youtube_url": null
},
"MP9ZRM": {
"abstract": "One of the most exciting recent developments in Python is the addition of Android and iOS as officially-supported platforms. This allows us to reach far more users on the devices where they spend the most time.\r\n\r\nWhat does this mean for you as a Python package maintainer? If your package is pure-Python, then it'll probably just work. But if it uses C, Cython, Rust, or any other native-compiled language, then you'll have to take some steps to make it available to these new platforms.\r\n\r\nThe mobile support status of the most popular packages on PyPI can be seen at [beeware.org/mobile-wheels](https://beeware.org/mobile-wheels). Let's help push those numbers up! Come to this talk to learn about:\r\n\r\n- Why mobile platforms are important for the future of Python\r\n- How to build your package for Android and iOS using cibuildwheel\r\n- How to test your mobile builds \u2013 even if you don't have Android or iOS hardware\r\n- How to distribute mobile packages to your users\r\n- How to automate all of these things in your CI system\r\n\r\nAt the sprints, there will also be an opportunity to put this into practice, by getting personal assistance from the BeeWare team in building your package for mobile.",
"code": "MP9ZRM",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T16:00:00+02:00",
"level": "intermediate",
"next_session": "8XMJGZ",
"prev_session": "ZFJEUJ",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Talk",
"sessions_after": [
"8XMJGZ"
],
"sessions_before": [
"BX77EE",
"GP39VP",
"NTZ7DG",
"QY7PFR",
"T7ATVM",
"U7AHP3",
"WHHAQK",
"ZFJEUJ"
],
"sessions_in_parallel": [
"BPJHWT",
"LRVCYU",
"ZHCNDY"
],
"slug": "supporting-android-and-ios-in-your-python-package",
"speakers": [
"M9YVF3"
],
"start": "2026-07-17T15:30:00+02:00",
"title": "Supporting Android and iOS in your Python package",
"track": "Tooling, Packaging, Developer Productivity",
"tweet": "Android and iOS are now fully supported by Python. Come to this talk to learn how to build, test and distribute your package for these platforms.",
"website_url": "https://ep2026.europython.eu/session/supporting-android-and-ios-in-your-python-package",
"youtube_url": null
},
"N39TFS": {
"abstract": "Benchmarking is hard. Ever wondered how reliable is your system? How many requests per second can it handle? How about the average response time: what do you do to measure that? How does the system behave during events like black friday, christmas sales, or any other important date that may cause an outage? Have no idea where to start answering these questions? Fear not, because you are in the right place!\r\n\r\nIn this tutorial I will introduce you to locust: probably the most awesome pythonic tool to perform load tests against websites, REST APIs, GQL, and many other ways of contacting and using systems. You'll be able to understand how to structure your stress tests projects, and get your hands dirty in creating tests against a REST API, while visually being able to tell where is the threshold point and what happens after that.\r\n\r\nThis tutorial is targeted for intermediate Pythonistas. Some recommended requirements (or things that will not be covered in a greater level of details) include: basics of git, simple Docker commands (to get a container up and running), classes in Python, some understanding of REST APIs. Will do my best to make it possible so anyone/any level of knowledge can join. After this presentation, participants will be able to create tests that benchmark applications in the most realistic way: exactly how users would use a system - and with that, answer the initial questions proposed, as well as create reports to display anywhere necessary (such as your job).",
"code": "N39TFS",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-14T17:00:00+02:00",
"level": "intermediate",
"next_session": null,
"prev_session": "TGGHKC",
"resources": null,
"room": "Conference Hall Complex A (S4A)",
"session_type": "Tutorial",
"sessions_after": [
"3APM9B"
],
"sessions_before": [
"3FDLUS",
"BTTFFJ",
"MENRZG",
"TGGHKC",
"ZPCDKE"
],
"sessions_in_parallel": [
"3TZHB9",
"K7XNTF",
"ZSRZPC"
],
"slug": "load-testing-1-on-1-discovering-the-limits-of-your-system",
"speakers": [
"PK8LSS"
],
"start": "2026-07-14T13:45:00+02:00",
"title": "Load testing 1-on-1: discovering the limits of your system",
"track": "Testing, Quality Assurance, Security",
"tweet": "How many req/s your system can handle? How about average response time? Need help to answer? Drop by Load testing 1-on-1 tutorial",
"website_url": "https://ep2026.europython.eu/session/load-testing-1-on-1-discovering-the-limits-of-your-system",
"youtube_url": null
},
"NEH7RE": {
"abstract": "The [website](https://hypothesis.works) of the Hypothesis project used to boldly assert: *\"Normal 'automated' software testing is surprisingly manual. Every scenario the computer runs, someone had to write by hand. Hypothesis can fix this.\"*\r\n\r\nWhile it's debatable whether property-based testing should fully replace the manual parametrization of tests with different inputs and outputs, there's no doubt that Hypothesis is a powerful tool for uncovering bugs nobody would even have considered looking for. In fact, during its development, the authors of Hypothesis accidentally discovered countless bugs in CPython and libraries, thus coining the term *\"The Curse of Hypothesis\"*.\r\n\r\nThe framework, although incredibly powerful, might seem overwhelming at first. In this talk, I will demonstrate how even simply throwing random strings at functions can reveal surprising bugs. From there, we'll progress towards generating more complex data, which will be less daunting than it initially appears. You'll also see how Hypothesis seamlessly integrates with various ecosystems and can be a valuable tool in any developer's toolkit.",
"code": "NEH7RE",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T12:50:00+02:00",
"level": "intermediate",
"next_session": "DRXC3E",
"prev_session": "VXDYGX",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Talk",
"sessions_after": [
"33RGZA",
"3HBWHB",
"DRXC3E",
"LNVDY3",
"NWLBJC",
"PRGGNW",
"US3W8J",
"ZRWENU"
],
"sessions_before": [
"CBA98V",
"HJ8KPY",
"KRMBWS",
"QT97WA",
"VXDYGX"
],
"sessions_in_parallel": [
"UPELCT",
"W9NLXV"
],
"slug": "property-based-testing-with-hypothesis",
"speakers": [
"HZMBBH"
],
"start": "2026-07-15T12:20:00+02:00",
"title": "Property based testing with Hypothesis",
"track": "Testing, Quality Assurance, Security",
"tweet": "Hypothesis is a powerful tool for uncovering bugs nobody expected. In this talk, I will show how even simply throwing random strings at code can help.",
"website_url": "https://ep2026.europython.eu/session/property-based-testing-with-hypothesis",
"youtube_url": null
},
"NELACW": {
"abstract": "In this tutorial, we'll discuss how to build the basic components that make up a modern digital synth from scratch using Python. In the process, learn some DSP and audio programming concepts. By the end, you\u2019ll be able to define your own synthesizer make music with code!!\r\n\r\nThis tutorial aims to break down the abstractions that make up a synthesizer by building one using Python, its scientific computing libraries, & Librosa. We will discuss how to build the basic components that make up a modern digital synth from scratch! In the process, learn some DSP and audio programming concepts! By the end, you\u2019ll be able to make your own tunes with Python! We will start with theory, then work through Jupyter notebooks both individually and as a group.",
"code": "NELACW",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-13T17:00:00+02:00",
"level": "intermediate",
"next_session": null,
"prev_session": "GCWCEU",
"resources": null,
"room": "Conference Hall Complex B (S4B)",
"session_type": "Tutorial",
"sessions_after": [],
"sessions_before": [
"GCWCEU",
"NQGSY7",
"QWEJWT",
"WYBHCE"
],
"sessions_in_parallel": [
"JRMSZT",
"RARRL7",
"SNKUW7",
"VYUNHG"
],
"slug": "build-a-synthesizer-with-python",
"speakers": [
"RTG9TS"
],
"start": "2026-07-13T13:45:00+02:00",
"title": "Build a Synthesizer with Python",
"track": "Python for Games, Art, Play and Expression",
"tweet": "Build a Synthesizer with Python! we'll discuss how to build the basic components that make up a modern digital synth from scratch using Python",
"website_url": "https://ep2026.europython.eu/session/build-a-synthesizer-with-python",
"youtube_url": null
},
"NQGSY7": {
"abstract": "In this workshop, you will create practical internet-connected sensors with MicroPython. We will cover the basics of setting up the development environment, both for developing on PC and deploying/developing on a microcontroller device.\r\n\r\nTargeted towards those that are already comfortable programming in Python, but that have little exposure to embedded/hardware/electronics.\r\n\r\nWe will provide some MicroPython-capable hardware to develop against, pre-flashed with MicroPython. You may need to sit together in pairs or small groups for the on-device part.\r\n\r\n#### Prerequisites\r\nParticipants must bring:\r\n\r\n- Laptop with Linux/MacOS/Windows Subsystem for Linux\r\n- Have Python 3.12+ with virtualenv support installed\r\n- USB-C to USB-C cable or USB Type A adapter (our kit only has Type A plug)",
"code": "NQGSY7",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-13T12:45:00+02:00",
"level": "intermediate",
"next_session": "SNKUW7",
"prev_session": null,
"resources": null,
"room": "Conference Hall Complex A (S4A)",
"session_type": "Tutorial",
"sessions_after": [
"JRMSZT",
"NELACW",
"RARRL7",
"SNKUW7"
],
"sessions_before": [],
"sessions_in_parallel": [
"GCWCEU",
"QWEJWT",
"VYUNHG",
"WYBHCE"
],
"slug": "developing-iot-sensors-with-micropython",
"speakers": [
"CVFFNV"
],
"start": "2026-07-13T09:30:00+02:00",
"title": "Developing IoT sensors with MicroPython",
"track": "IoT, Embedded Systems, Hardware Integration",
"tweet": "Use your Python skills to make physical devices and connect them to the Internet",
"website_url": "https://ep2026.europython.eu/session/developing-iot-sensors-with-micropython",
"youtube_url": null
},
"NS8QQA": {
"abstract": "What holds open source together when the code is done? Recent research paints a worrying picture: 58% of open source maintainers have considered stepping back, and over two-thirds of OSS work is non-code labor: conflict mediation, mentoring, documentation, governance, and emotional labor.Most of it unpaid, invisible, and unrewarded. These pressures are disproportionately carried by community leads and underrepresented contributors.\r\nAs open source scales across companies, foundations, and global teams, outdated governance models built to manage code is today being asked to manage humans, and they\u2019re failing or buckling under the weight of human complexity. We continue to optimise for commits while ignoring emotional load, collaboration friction, and psychological safety, the very factors that determine sustainability.\r\n\r\nI\u2019ve lived this tension as a Service Delivery Manager and community leader. I\u2019ve helped build and sustain communities, but I\u2019ve also reached the point of emotional exhaustion, questioning whether my unseen contributions mattered at all.\r\n\r\nThis talk argues that ignoring emotional labor is no longer neutral , it is actively harmful. We\u2019ll explore how modern governance approaches, supported by AI-driven tooling such as sentiment analysis, workload dashboards, and governance bots, can surface invisible work, distribute responsibility more fairly, and prevent burnout before it becomes exit.If open source is to survive its own success, we must start treating its human systems with the same rigor as its technical ones.",
"code": "NS8QQA",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T15:25:00+02:00",
"level": "intermediate",
"next_session": null,
"prev_session": "PPQ3KE",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"3FW7UF",
"9JALSN",
"UY9UAG"
],
"sessions_before": [
"8HBEYS",
"93XE3S",
"9URK9U",
"BMQP7J",
"NXNHSB",
"PPQ3KE",
"VNR377"
],
"sessions_in_parallel": [
"BFK3JK",
"SASJQU",
"TAZHCD"
],
"slug": "the-unseen-pull-request-the-crisis-we-dont-measure",
"speakers": [
"T38F7H"
],
"start": "2026-07-16T14:55:00+02:00",
"title": "The Unseen Pull Request: The Crisis We Don\u2019t Measure",
"track": "Community Building, Education, Outreach",
"tweet": "What if the most important PR never gets merged? The crisis of invisible labor in tech.",
"website_url": "https://ep2026.europython.eu/session/the-unseen-pull-request-the-crisis-we-dont-measure",
"youtube_url": null
},
"NTZ7DG": {
"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.\r\n\r\nDiscovery workshops give developers what tickets can't: 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.\r\nDevelopers 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.\r\n\r\nThis talk walks through the discovery process from a developer perspective. You'll 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. We'll cover epics, user stories, service architecture, and wireframes, but more importantly, how they connect to real business value.\r\nDiscovery 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.",
"code": "NTZ7DG",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T15:05:00+02:00",
"level": "intermediate",
"next_session": "LRVCYU",
"prev_session": "UGLF7Q",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"BPJHWT",
"LRVCYU",
"MP9ZRM",
"ZHCNDY"
],
"sessions_before": [
"7NWR9R",
"BX77EE",
"GP39VP",
"PBTPJR",
"RGBSS8",
"U7AHP3",
"UGLF7Q",
"VSZSMW"
],
"sessions_in_parallel": [
"QY7PFR",
"T7ATVM",
"WHHAQK",
"ZFJEUJ"
],
"slug": "from-ticket-taker-to-problem-solver-discovery-for-senior-thinking",
"speakers": [
"ALN8NK"
],
"start": "2026-07-17T14:35:00+02:00",
"title": "From Ticket Taker to Problem Solver: Discovery for Senior Thinking",
"track": "Professional Development, Careers, Leadership",
"tweet": "Discovery workshops turn developers from ticket takers into problem solvers. Learn why knowing the WHY makes you code smarter and grow faster.",
"website_url": "https://ep2026.europython.eu/session/from-ticket-taker-to-problem-solver-discovery-for-senior-thinking",
"youtube_url": null
},
"NWLBJC": {
"abstract": "This talk shares my experience in my first ever role as a junior engineer after switching careers. I picked up a ticket involving tools and concepts I\u2019d never used before (OpenTelemetry and Honeycomb), hoping to spend a day learning a bit about how we implement observability and monitoring of our Django app. Spoiler alert: it took three weeks of learning, debugging and asking for help to complete this work.\r\n\r\nI learned some valuable lessons along the way, not just technical stuff, but about how to problem-solve, collaborate effectively, and keep going in the face of *seemingly unending* challenges.\r\n\r\nThrough this talk, I want junior engineers in the audience to know:\r\n\r\n- You can do difficult things, even if you think you lack the experience or knowledge required. If you\u2019re willing to learn, and have a supportive team around you, you have everything you need.\r\n- Doing difficult things is daunting, but also incredibly rewarding. You often learn 10x more than you expected, and when you finally merge your work into main, it feels like winning the lottery.\r\n- Taking on hard things benefits the whole team\u2014others might learn something new, or strengthen their own understanding by helping you out.\r\n- There\u2019s a lot you can do to support yourself: reach out early, reach out often, and learn how to communicate problems clearly.\r\n- The value of your work cannot be measured by lines of code, it\u2019s so much greater than that.\r\n\r\nThis talk also offers a reminder to seniors, and leaders or managers, about how tough it can be to be new. Juniors don\u2019t just lack experience, we don't know what we don't know and it's *really* easy (for others and ourselves!) to underestimate this. When things break or go wrong, we might not understand where or why, and even if we find a bug or an error, knowing how to fix it is another challenge altogether. I\u2019ll share how my team\u2019s support made all the difference, and offer some practical ideas for how others can support their junior colleagues, too.\r\n\r\nThis isn\u2019t a super technical talk. It\u2019s more about the human experience of being a beginner, the value of persistence, why asking for help is a great thing to do, and the power of supportive teams; there's hopefully something useful and/or interesting in this for everyone.",
"code": "NWLBJC",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T14:20:00+02:00",
"level": "beginner",
"next_session": "SWCWKZ",
"prev_session": "CBA98V",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk",
"sessions_after": [
"7VKQQM",
"ENK9EF",
"HVTSPC",
"SWCWKZ",
"ZRWENU"
],
"sessions_before": [
"33RGZA",
"CBA98V",
"HJ8KPY",
"LNVDY3",
"NEH7RE",
"PRGGNW",
"UPELCT",
"W9NLXV"
],
"sessions_in_parallel": [
"3HBWHB",
"DRXC3E",
"US3W8J"
],
"slug": "why-doing-difficult-things-is-good-for-you-and-good-for-your-team",
"speakers": [
"ATWUPR"
],
"start": "2026-07-15T13:50:00+02:00",
"title": "Why doing difficult things is good for you and good for your team",
"track": "Community Building, Education, Outreach",
"tweet": "What it\u2019s like to begin again: a junior developer\u2019s perspective on why doing difficult things is good for you and good for your team.",
"website_url": "https://ep2026.europython.eu/session/why-doing-difficult-things-is-good-for-you-and-good-for-your-team",
"youtube_url": null
},
"NXNHSB": {
"abstract": "In July 2025, PyPI users received emails directing them to pypj.org\u2014a near-perfect clone transparently proxying requests to pypi.org. Within hours, attackers compromised four accounts and uploaded malicious releases of the popular num2words package.\r\n\r\nThis talk dissects the complete attack chain: how attackers harvested email addresses from public package metadata, built a transparent proxy that relayed TOTP codes in real-time, and why traditional 2FA failed while WebAuthn-based authentication stopped the attack cold.\r\n\r\nThe session covers the incident response timeline, challenges getting malicious infrastructure taken down (including initial rejection of abuse reports), and defensive measures deployed afterward\u2014including new email verification for TOTP logins from unrecognized devices.\r\n\r\nAttendees will learn exactly how modern phishing attacks work against package repositories, the critical difference between \"phishable\" and \"phishing-resistant\" 2FA, and practical steps to protect accounts and packages from the next campaign. The talk also examines the September 2025 follow-up campaign targeting pypi-mirror.org and patterns across these ongoing attacks.",
"code": "NXNHSB",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T14:45:00+02:00",
"level": "beginner",
"next_session": "TAZHCD",
"prev_session": "B7CMBD",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"BFK3JK",
"NS8QQA",
"SASJQU",
"TAZHCD",
"UY9UAG"
],
"sessions_before": [
"8HBEYS",
"9URK9U",
"B7CMBD",
"BMQP7J",
"E3GVVR",
"FB93DB",
"MJTZ7A"
],
"sessions_in_parallel": [
"93XE3S",
"PPQ3KE",
"VNR377"
],
"slug": "anatomy-of-a-phishing-campaign",
"speakers": [
"TVA3TQ"
],
"start": "2026-07-16T14:15:00+02:00",
"title": "Anatomy of a Phishing Campaign",
"track": "Testing, Quality Assurance, Security",
"tweet": "How real-time phishing bypassed PyPI's 2FA, why WebAuthn stopped it cold, and what defenders learned from a campaign in 2025",
"website_url": "https://ep2026.europython.eu/session/anatomy-of-a-phishing-campaign",
"youtube_url": null
},
"PBTPJR": {
"abstract": "Managing complex authorization logic can be a nightmare. Without a framework to help you,\r\nit can soon end up in a mess of if-else statements and partial solutions that will only\r\ngive you a headache.\r\n\r\nOne day, I found myself in that exact situation. I decided to tackle the problem, and\r\nthat's how I came across the concept of \"policy-based authorization\" or ABAC. While\r\nthere are available libraries for this, I found them of little help for a large, legacy\r\ncodebase that is monolithic at its core.\r\n\r\nIn my talk, I will share my experience in thinking about this problem and how to use\r\nABAC to implement a custom solution that fits your needs. I will outline the main\r\ncomponents of my solution and show how it can be applied to Django views and\r\nFastAPI endpoints.",
"code": "PBTPJR",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T14:25:00+02:00",
"level": "intermediate",
"next_session": "T7ATVM",
"prev_session": "SQRYJA",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk",
"sessions_after": [
"NTZ7DG",
"QY7PFR",
"T7ATVM",
"WHHAQK",
"ZFJEUJ"
],
"sessions_before": [
"BJBKRM",
"FBQQXS",
"PWGSJQ",
"SCZ8ZK",
"SQRYJA"
],
"sessions_in_parallel": [
"7NWR9R",
"BX77EE",
"GP39VP",
"RGBSS8",
"U7AHP3",
"UGLF7Q",
"VSZSMW"
],
"slug": "how-to-tackle-complex-authorization-logic-and-don-t-go-crazy",
"speakers": [
"GYPYPG"
],
"start": "2026-07-17T13:55:00+02:00",
"title": "How to tackle complex authorization logic (and don't go crazy)",
"track": "Web Development, Web APIs, Front-End Integration",
"tweet": "How to handle complex auth logic? How policy-based authorization (ABAC) can help you build a custom solution for Django and FastAPI. #EuroPython2026",
"website_url": "https://ep2026.europython.eu/session/how-to-tackle-complex-authorization-logic-and-don-t-go-crazy",
"youtube_url": null
},
"PCMBVT": {
"abstract": "This talk is one part technology dance and one part walk through of Python environment best practices. In under 30 minutes, you'll see me load up some of the most gnarly environments and watch them fail. This isn't just another talk about dependency management. It's about the hidden cost of environment friction: the cognitive load, the lost spoons, the brilliant developers who almost quit tech because they felt \"too stupid\" to make pip work. It's about recognizing that setup barriers aren't just inconvenient\u2014they're accessibility barriers that determine who gets to write Python.\r\n\r\nIn this talk we'll cover:\r\n- Several environment failures (with dramatic audience participation): GPU-enabled errors, OS errors, mounted systems, CI/CD and virtual environments\r\n- The human side of technical frustration: spoon theory, burnout\r\n- Patterns about how environments break\r\n- What the Python community is doing to lower these barriers.\r\n\r\nContent note: This talk discusses mental health, burnout, and the emotional impact of technical barriers with care and intention.",
"code": "PCMBVT",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T15:55:00+02:00",
"level": "beginner",
"next_session": "X3ENDU",
"prev_session": "HVTSPC",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Talk",
"sessions_after": [
"H7DVRJ",
"JEN7WA",
"TWBDVZ",
"X3ENDU",
"Y3DGWB"
],
"sessions_before": [
"33RGZA",
"7VKQQM",
"ENK9EF",
"HJ8KPY",
"HVTSPC",
"LNVDY3",
"PRGGNW",
"SWCWKZ"
],
"sessions_in_parallel": [
"H7KGU3",
"RMY7Y7",
"WKBHZW",
"ZRWENU"
],
"slug": "how-many-spoons-does-your-environment-cost-broken-demos-human-element",
"speakers": [
"LDQPN9"
],
"start": "2026-07-15T15:25:00+02:00",
"title": "How many spoons does your environment cost: Broken demos & human element",
"track": "Tooling, Packaging, Developer Productivity",
"tweet": "In under 30 minutes, you'll see me load up some of the most gnarly environments and watch them fail, exploring the hidden human cost of env friction.",
"website_url": "https://ep2026.europython.eu/session/how-many-spoons-does-your-environment-cost-broken-demos-human-element",
"youtube_url": null
},
"PKMSSL": {
"abstract": "\"TBD: Keynote Speaker\"\r\nDetails coming soon. This prime session will feature an inspiring keynote address to set the tone for the entire event. Our team is finalizing an exceptional speaker whose insights and vision will leave a lasting impression. Check back shortly for the full announcement, topic, and speaker biography.",
"code": "PKMSSL",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-15T17:30:00+02:00",
"level": "beginner",
"next_session": "FMNUSD",
"prev_session": "Y3DGWB",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Keynote",
"sessions_after": [
"FMNUSD"
],
"sessions_before": [
"33RGZA",
"H7DVRJ",
"JEN7WA",
"LNVDY3",
"PRGGNW",
"TWBDVZ",
"X3ENDU",
"Y3DGWB"
],
"sessions_in_parallel": [],
"slug": "keynote-2-placeholder",
"speakers": [],
"start": "2026-07-15T16:45:00+02:00",
"title": "Keynote 2 - Placeholder",
"track": null,
"tweet": "\"TBD: Keynote Speaker\" Details coming soon. This prime session will feature an inspiring keynote address to set the tone for the entire event.",
"website_url": "https://ep2026.europython.eu/session/keynote-2-placeholder",
"youtube_url": null
},
"PPQ3KE": {
"abstract": "We deployed Python in serverless environments and quickly saw the performance limits. Serverless systems suffer from startup latency, memory overhead, and repeated object creation as their executions start almost from scratch. Those extra seconds made our user experience painfully slow\u2014and we couldn\u2019t afford it.\r\n\r\nWe looked into the performance of our flight search engine, ran profilers, and applied optimizations. We found real gains when **tuning Python\u2019s GC**, reducing **stop-the-world pauses**, and introducing an **asynchronous post-execution process** that runs after the handler returns. We reduced execution time from **1.2 seconds to 300 milliseconds\u2014a 4\u00d7 speedup** with just a few tweaks.\r\n\r\nUnderstanding **Python\u2019s memory model** and its runtime behavior was essential, and it\u2019s something we\u2019ll dive into during the talk. What we share is based on **AWS Lambda**, but it can be applied to any short-lived Python system\u2014whether serverless or containerized.\r\n\r\nAnother big gain came from replacing `Pydantic` with `TypedDict` for faster parsing, using **Redis** strategically to distribute operations, and restructuring code to eliminate duplicated transformations. Our web API processes thousands of flight offers\u2014deserialize, enrich, transform\u2014and every millisecond counts.\r\n\r\nWhile covering optimization techniques, when they matter, and how we measured their impact, the main idea is that you will walk away with tactics that help your system stay fast while it grows.",
"code": "PPQ3KE",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T14:45:00+02:00",
"level": "advanced",
"next_session": "NS8QQA",
"prev_session": "MJTZ7A",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"BFK3JK",
"NS8QQA",
"SASJQU",
"TAZHCD",
"UY9UAG"
],
"sessions_before": [
"8HBEYS",
"9URK9U",
"B7CMBD",
"BMQP7J",
"E3GVVR",
"FB93DB",
"MJTZ7A"
],
"sessions_in_parallel": [
"93XE3S",
"NXNHSB",
"VNR377"
],
"slug": "python-on-serverless-strategies-for-peak-performance",
"speakers": [
"YMJTM9"
],
"start": "2026-07-16T14:15:00+02:00",
"title": "Python on Serverless: Strategies for Peak Performance",
"track": "DevOps, Cloud, Scalable Infrastructure",
"tweet": "From 1.2s to 300ms: Optimizing Python Serverless. A deep dive into GC tuning, async patterns, and TypedDict for a 4x speedup.",
"website_url": "https://ep2026.europython.eu/session/python-on-serverless-strategies-for-peak-performance",
"youtube_url": null
},
"PQCHT3": {
"abstract": "The presentation will discuss practical applications of Python in technologies used in forensic science. In an era of growing cybercrime and digitalization of evidence, Python has become an essential tool for forensics specialists, offering powerful libraries for data analysis, process automation and processing complex information structures. Participants will gain insights into spanning multiple domains of forensic investigation, including:\r\n\r\n- mobile device analysis, \r\n- network traffic examination,\r\n- memory forensics,\r\n- automated report generation.\r\n\r\nWe will analyze how Python libraries parse SQLite databases in messaging applications like WhatsApp and iMessage, also examine tools for analyzing iOS file formats including PLIST and XML structures and techniques for extracting data from disk images using pytsk3 or libewf. Network analysis will showcase Scapy for packet analysis and Dpkt for parsing capture files, demonstrating how Python analyzes Windows Event Logs and Linux syslog to reconstruct activity timelines.\r\n\r\nMemory forensics will be explored through the Volatility Framework for analyzing RAM dumps and recovering volatile data. We will discuss recovering deleted files, extracting metadata, and analyzing browser artifacts. Cryptographic analysis using hashlib will demonstrate integrity verification, encrypted file analysis, and cipher breaking techniques essential for maintaining chain of custody.\r\nData visualization using Matplotlib, Seaborn, and NetworkX will show how to create compelling visual representations of timelines and connection networks. Automated report generation with ReportLab and python-docx streamlines professional expert report creation.\r\n\r\nThe presentation emphasizes real-world applications with dusscussion about Python scripts processing realistic datasets, illustrating how multiple Python tools integrate into comprehensive investigation workflows, demonstrating the synergistic effects of combining different analytical approaches for actionable forensic intelligence.",
"code": "PQCHT3",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T12:15:00+02:00",
"level": "intermediate",
"next_session": "SQRYJA",
"prev_session": "7SSS93",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk",
"sessions_after": [
"7NWR9R",
"BJBKRM",
"BX77EE",
"GP39VP",
"PWGSJQ",
"SQRYJA",
"U7AHP3",
"VSZSMW"
],
"sessions_before": [
"7SSS93",
"ARRMQR",
"FBQQXS",
"RB9TKP",
"TG7YMS"
],
"sessions_in_parallel": [
"QXZMP8",
"SCZ8ZK",
"VKURLV"
],
"slug": "python-in-the-service-of-justice-modern-analysis-tools-in-forensics",
"speakers": [
"SGS9LZ"
],
"start": "2026-07-17T11:45:00+02:00",
"title": "Python in the Service of Justice: Modern Analysis Tools in Forensics",
"track": "Ethics, Social Responsibility, Sustainability, Legal",
"tweet": "Presentation demonstrates Python applications in forensics, covering mobile device analysis, network analysis and cryptographic tools.",
"website_url": "https://ep2026.europython.eu/session/python-in-the-service-of-justice-modern-analysis-tools-in-forensics",
"youtube_url": null
},
"PRFYJA": {
"abstract": "Enjoy Wednesday's lightning talks! Short talks about everything by everyone. \r\n\r\nLightning talks are 5 minute talks that anyone participating at the conference can submit.\r\nIf that talk gets selected, you will have the chance to jump into the main stage and show us your project, your ideas, something you have learned, something you are proud of that's helping and contributing to our conference and community, or something else!\r\n\r\nLightning talks last a maximum of 5 minutes. You can use less time, but not more.\r\nThis time limit is strictly enforced!\r\n\r\nIf you get accepted, you will be notified by email on the day of your talk by 1pm.\r\nReply to the acceptance email by 3pm to confirm your spot.\r\n(If you don't, you lose your spot!)\r\n\r\nYou can submit your lightning talk on this form: TBD\r\nNote that there's a limit of one submission per person.\r\n\r\nCommunity/conference announcement submissions are done through the same form before 1pm Thursday.",
"code": "PRFYJA",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T18:30:00+02:00",
"level": "beginner",
"next_session": null,
"prev_session": "PKMSSL",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Announcements",
"sessions_after": [],
"sessions_before": [
"33RGZA",
"H7DVRJ",
"JEN7WA",
"LNVDY3",
"PKMSSL",
"PRGGNW",
"TWBDVZ",
"X3ENDU"
],
"sessions_in_parallel": [],
"slug": "lightning-talks-wednesday",
"speakers": [],
"start": "2026-07-15T17:45:00+02:00",
"title": "Lightning talks \u26a1 Wednesday",
"track": null,
"tweet": "Enjoy Wednesday's lightning talks! Short talks about everything by everyone. Lightning talks are 5 minute talks that anyone participating at the con",
"website_url": "https://ep2026.europython.eu/session/lightning-talks-wednesday",
"youtube_url": null
},
"PRGGNW": {
"abstract": "This poster will take you on a tour of the 20 functions available in the module `itertools`, showing you how they work, how they interact with each other, and how they relate to each other.\r\n\r\nBy the time you're done reading the poster, you'll have an increased understanding of how to use the module `itertools` efficiently and effectively.",
"code": "PRGGNW",
"delivery": "in-person",
"duration": "60",
"end": "2026-07-15T13:50:00+02:00",
"level": "beginner",
"next_session": null,
"prev_session": null,
"resources": null,
"room": "Exhibit Hall",
"session_type": "Poster",
"sessions_after": [
"3HBWHB",
"DRXC3E",
"NWLBJC",
"US3W8J",
"ZRWENU"
],
"sessions_before": [
"CBA98V",
"HJ8KPY",
"NEH7RE",
"UPELCT",
"W9NLXV"
],
"sessions_in_parallel": [
"33RGZA",
"LNVDY3"
],
"slug": "a-tour-of-the-module-itertools",
"speakers": [
"BLNV7P"
],
"start": "2026-07-15T12:50:00+02:00",
"title": "A tour of the module `itertools`",
"track": "Python Core, Internals, Extensions",
"tweet": "Come learn about the module `itertools`, its 19 iterables and the odd-one-out, `tee`!",
"website_url": "https://ep2026.europython.eu/session/a-tour-of-the-module-itertools",
"youtube_url": null
},
"PWGSJQ": {
"abstract": "It\u2019s common to hear complaints about Python being slow. In this talk, I will show how to make _some_ Python programs dramatically faster by using Python 3.14\u2019s free threading and ahead-of-time compilation to C extensions using the mypyc compiler, while staying entirely in Python (and CPython). \r\n\r\nFree threading can deliver large speedups for CPU-bound code that can be adapted for parallel execution, while mypyc speeds up workloads that benefit from reduced interpreter overhead and that can use static typing. If each can give a 10x speedup in an ideal use case, can we get a \u201choly grail\u201d 100x speedup by using both?\r\n\r\nI\u2019ll introduce several small examples inspired by real-world workloads, measuring and explaining what happens when you apply free threading, mypyc, or both. In practice, relatively few programs are perfect fits for both techniques at once, but when they are, you can get substantial gains. Having both tools available gives you options for attacking a wide range of performance problems.\r\n\r\nAlong the way, I\u2019ll cover various bottlenecks you are likely to encounter while optimizing real-world workloads. These often limit performance scaling. I'll explain how to diagnose and improve allocation-heavy code and thread contention caused by reference counting, in particular.",
"code": "PWGSJQ",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T12:55:00+02:00",
"level": "advanced",
"next_session": "RGBSS8",
"prev_session": "VKURLV",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"7NWR9R",
"BX77EE",
"GP39VP",
"PBTPJR",
"RGBSS8",
"U7AHP3",
"UGLF7Q",
"VSZSMW"
],
"sessions_before": [
"FBQQXS",
"PQCHT3",
"QXZMP8",
"SCZ8ZK",
"VKURLV"
],
"sessions_in_parallel": [
"BJBKRM",
"SQRYJA"
],
"slug": "speeding-up-python-with-free-threading-and-mypyc",
"speakers": [
"K7R9XZ"
],
"start": "2026-07-17T12:25:00+02:00",
"title": "Speeding Up Python with Free Threading and Mypyc",
"track": "Python Core, Internals, Extensions",
"tweet": "Learn how to make Python programs dramatically faster through Python 3.14\u2019s free threading and ahead-of-time compilation to C extensions with mypyc.",
"website_url": "https://ep2026.europython.eu/session/speeding-up-python-with-free-threading-and-mypyc",
"youtube_url": null
},
"QDCP3K": {
"abstract": "Welcome to EuroPython 2026! Please notice the registration will happen on the TBD.\r\nYou can pick up your badges at any time during the week as long as we are open!\r\nIf you want to avoid the morning rush on Wednesday, come on Monday and Tuesday!\r\n\r\nWe hope to see you around!",
"code": "QDCP3K",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T09:00:00+02:00",
"level": "beginner",
"next_session": "3KT3BW",
"prev_session": null,
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Announcements",
"sessions_after": [
"3KT3BW"
],
"sessions_before": [],
"sessions_in_parallel": [],
"slug": "thursday-registration-welcome-tbd",
"speakers": [],
"start": "2026-07-16T08:00:00+02:00",
"title": "Thursday Registration & Welcome @ TBD",
"track": null,
"tweet": "EuroPython 2026 Thursday Conference Registration & Welcome from the Volunteers",
"website_url": "https://ep2026.europython.eu/session/thursday-registration-welcome-tbd",
"youtube_url": null
},
"QT97WA": {
"abstract": "Python systems rarely fail because of raw performance limits.\r\n\r\nThey fail because the architecture does not scale with the team.\r\n\r\nAs services grow, coordination overhead increases. Shared databases create implicit coupling. API contracts become political boundaries. Async workflows leak across domains. Meetings multiply to compensate for structural flaws.\r\n\r\nInstead of adding process, we should redesign architecture.\r\n\r\nThis talk explores how Python system design directly determines team scalability.\r\n\r\nUsing real-world backend systems built with FastAPI, asyncio, gRPC (grpcio), PostgreSQL, Redis, Docker, we will examine how architectural decisions shape organizational complexity.\r\n\r\nTopics include:\r\n\t\u2022\tDomain boundaries in Python services and their impact on ownership\r\n\t\u2022\tDatabase-per-service vs shared schemas\r\n\t\u2022\tREST vs gRPC as team contracts\r\n\t\u2022\tMonorepo vs polyrepo trade-offs in multi-service Python ecosystems\r\n\t\u2022\tContract testing and schema evolution\r\n\t\u2022\tObservability as an interface between teams\r\n\t\u2022\tAsync workloads and cross-service backpressure\r\n\t\u2022\tWhen microservices increase coordination cost instead of reducing it\r\n\r\nRather than promoting a single architecture style, this session introduces a framework for evaluating whether a design reduces or amplifies team cognitive load.\r\n\r\nAttendees will leave with:\r\n\t\u2022\tCriteria for defining service boundaries that align with ownership\r\n\t\u2022\tPatterns for reducing cross-team friction through architectural design\r\n\t\u2022\tWarning signs that architecture is becoming a coordination bottleneck\r\n\t\u2022\tPractical techniques for evolving Python systems without multiplying process\r\n\r\nThis talk is intended for experienced Python engineers, architects, and technical leaders responsible for systems that must scale both technically and organizationally.",
"code": "QT97WA",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-15T11:30:00+02:00",
"level": "intermediate",
"next_session": "UPELCT",
"prev_session": "BJCYNE",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk (long session)",
"sessions_after": [
"33RGZA",
"CBA98V",
"HJ8KPY",
"KRMBWS",
"LNVDY3",
"PRGGNW",
"UPELCT",
"VXDYGX"
],
"sessions_before": [
"BJCYNE"
],
"sessions_in_parallel": [
"9EFAJS",
"DWBGJ9",
"M8Q77Z",
"Y8QAUA"
],
"slug": "scaling-python-systems-by-designing-team-aware-architecture",
"speakers": [
"R8WFXV"
],
"start": "2026-07-15T10:45:00+02:00",
"title": "Scaling Python Systems by Designing Team-Aware Architecture",
"track": "Professional Development, Careers, Leadership",
"tweet": "Learn how Python system architecture shapes team scalability and reduces cross-service friction.",
"website_url": "https://ep2026.europython.eu/session/scaling-python-systems-by-designing-team-aware-architecture",
"youtube_url": null
},
"QWEJWT": {
"abstract": "Ever wondered how a computer actually understands your logic? While Python interprets code line-by-line, WebAssembly allows us to compile high-performance modules that run at near-native speed in the browser. This tutorial breaks open the black box of language design, showing you how to translate human-readable logic into raw, executable power. We will use Python to build a functional compiler from scratch, translating a simple language into **WebAssembly (Wasm)**: the industry standard for high-performance web and cloud computing.\r\n\r\n### Why Build a Compiler? (It\u2019s Not Just for Language Designers)\r\n\r\nLearning compiler logic isn\u2019t just about creating the next C++ or Rust; it\u2019s about mastering **data transformation**. The patterns used in compilers (lexing, parsing, and code generation) are the exact same patterns used in:\r\n\r\n* **Data Engineering:** Writing custom Extract, Transform, and Load (ETL) tools to transform massive datasets.\r\n* **Domain Specific Languages (DSLs):** Creating custom internal tools for finance, science, or game logic.\r\n* **Performance Optimization:** Understanding how code is \u201clowered\u201d into machine instructions to write faster, leaner programs.\r\n* **Security:** Auditing how code is executed to prevent injection attacks and vulnerabilities.\r\n\r\n### The Project: *chiqui_forth* to Wasm\r\n\r\nWe will build a compiler for **chiqui_forth**, a tiny, stack-based language inspired by the legendary Forth (1970). Because both *chiqui_forth* and WebAssembly use **Reverse Polish Notation (RPN)**, they are a perfect match for a first-time compiler project. You\u2019ll see exactly how high-level logic is mapped to the \u201cbare metal\u201d of a virtual machine.\r\n\r\n### Outcomes\r\n\r\nBy the end of this session, you won\u2019t just have a Wasm file; you\u2019ll have a new mental model for software:\r\n\r\n* **The Compiler Pipeline:** Implement the full flow from raw text to executable binary.\r\n* **Wasm Mastery:** Gain a practical understanding of WebAssembly, the technology powering modern browser-based video editors, games, and serverless clouds.\r\n* **Custom Tooling:** Leave with a working Python-based compiler that you can extend to your own custom syntax.\r\n\r\n### Prerequisites\r\n\r\n* **Python Proficiency:** Comfort with variables, loops, lists, dictionaries, and file I/O.\r\n* **Terminal Basics:** Ability to navigate folders and run scripts from a command line.\r\n\r\n*No prior knowledge of compiler design, Wasm, or web development is required.*",
"code": "QWEJWT",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-13T12:45:00+02:00",
"level": "intermediate",
"next_session": "RARRL7",
"prev_session": null,
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Tutorial",
"sessions_after": [
"JRMSZT",
"NELACW",
"RARRL7",
"SNKUW7"
],
"sessions_before": [],
"sessions_in_parallel": [
"GCWCEU",
"NQGSY7",
"VYUNHG",
"WYBHCE"
],
"slug": "crafting-your-own-compiler-from-python-logic-to-high-speed-webassembly",
"speakers": [
"QRQDV3"
],
"start": "2026-07-13T09:30:00+02:00",
"title": "Crafting Your Own Compiler: From Python Logic to High-Speed WebAssembly",
"track": "Python Core, Internals, Extensions",
"tweet": "Stop treating code as a black box! Build a compiler from scratch in Python and master how high-speed WebAssembly actually works.",
"website_url": "https://ep2026.europython.eu/session/crafting-your-own-compiler-from-python-logic-to-high-speed-webassembly",
"youtube_url": null
},
"QXZMP8": {
"abstract": "Running Python natively on Windows on Arm requires more than a working interpreter. To have a nice developer experience, it depends on compilers, packaging, binary wheels, CI infrastructure, and support from the wider library ecosystem.\r\n\r\nThis talk provides a status update of the Python ecosystem on Windows on Arm in 2026, based on ongoing collaboration between Microsoft, Arm, and the open-source community. We will cover CPython support, packaging, wheels, tooling, and CI availability, with a focus on what developers can realistically use today.\r\n\r\nUsing widely adopted libraries such as PyTorch as examples, we will show how native Arm support is being enabled across the ecosystem, what remaining challenges projects face when supporting Windows on Arm.\r\n\r\nThe talk will also cover the developer and CI story enabled by native Arm runners and Windows 11 Arm images on GitHub Actions, and how this infrastructure lowers the barrier for projects to add and maintain Windows on Arm support.\r\n\r\nThe goal is to give a snapshot of the current state, highlight the remaining gaps, and explain how contributors and maintainers can participate to the ongoing effort.",
"code": "QXZMP8",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T12:15:00+02:00",
"level": "beginner",
"next_session": "BJBKRM",
"prev_session": "TG7YMS",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Sponsored",
"sessions_after": [
"7NWR9R",
"BJBKRM",
"BX77EE",
"GP39VP",
"PWGSJQ",
"SQRYJA",
"U7AHP3",
"VSZSMW"
],
"sessions_before": [
"7SSS93",
"ARRMQR",
"FBQQXS",
"RB9TKP",
"TG7YMS"
],
"sessions_in_parallel": [
"PQCHT3",
"SCZ8ZK",
"VKURLV"
],
"slug": "python-on-windows-on-arm-ecosystem-enablement-update",
"speakers": [
"NCU7GS"
],
"start": "2026-07-17T11:45:00+02:00",
"title": "Python on Windows on Arm: Ecosystem Enablement Update",
"track": "Python Core, Internals, Extensions",
"tweet": "Python on Windows on Arm in 2026: ecosystem status, native wheels, CI on Arm runners, and real-world libraries such as PyTorch.",
"website_url": "https://ep2026.europython.eu/session/python-on-windows-on-arm-ecosystem-enablement-update",
"youtube_url": null
},
"QY7PFR": {
"abstract": "Debugging and testing multithreaded code in Python is so challenging. How do you create reproducible tests of multithreaded code, when the order of execution changes from run to run? How do you achieve 100% coverage, when you ship code only called to handle rare, obscure race conditions? And if you think it's a problem now... just imagine how much worse it's going to become as adoption of \"nogil\" Python grows!\r\n\r\nBlanket is here to help. Come learn how Blanket gives you back control over the order of execution in multithreaded code, enabling you to write deterministic multithreaded tests. Restore blessed order and determinism to your unit test suite--use Blanket!",
"code": "QY7PFR",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T15:05:00+02:00",
"level": "intermediate",
"next_session": "ZHCNDY",
"prev_session": "RGBSS8",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"BPJHWT",
"LRVCYU",
"MP9ZRM",
"ZHCNDY"
],
"sessions_before": [
"7NWR9R",
"BX77EE",
"GP39VP",
"PBTPJR",
"RGBSS8",
"U7AHP3",
"UGLF7Q",
"VSZSMW"
],
"sessions_in_parallel": [
"NTZ7DG",
"T7ATVM",
"WHHAQK",
"ZFJEUJ"
],
"slug": "conquer-multithreaded-python-with-blanket",
"speakers": [
"9DMGRT"
],
"start": "2026-07-17T14:35:00+02:00",
"title": "Conquer multithreaded Python with Blanket",
"track": "Python Core, Internals, Extensions",
"tweet": "Debugging and testing multithreaded code in Python is so challenging. Come learn how Blanket can make it deterministic and controllable!",
"website_url": "https://ep2026.europython.eu/session/conquer-multithreaded-python-with-blanket",
"youtube_url": null
},
"R7PTVB": {
"abstract": "Welcome to EuroPython 2026!\r\n\r\nJoin us on the opening session, where we will kick-off the conference days, and tell you what's going to happen in the following days.\r\nYou will have three days filled with Keynotes, talks, panels, and open spaces, lightning talks, and a weekend full of sprints and other events for people attending the conference.",
"code": "R7PTVB",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T09:30:00+02:00",
"level": "beginner",
"next_session": "BJCYNE",
"prev_session": null,
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Announcements",
"sessions_after": [
"BJCYNE"
],
"sessions_before": [],
"sessions_in_parallel": [],
"slug": "conference-opening",
"speakers": [],
"start": "2026-07-15T09:00:00+02:00",
"title": "Conference Opening \ud83c\udf89",
"track": null,
"tweet": "Conference Opening: Welcome to EuroPython 2026, a session that will give you an overview of the following days",
"website_url": "https://ep2026.europython.eu/session/conference-opening",
"youtube_url": null
},
"RARRL7": {
"abstract": "Learn how to use uv for fast, reliable Python development. Created by Astral (the makers of Ruff), uv is a modern Python package and project manager written in Rust that can replace pip, pip-tools, virtualenv, poetry, pyenv, and more\u2014with dramatic speed improvements.\r\n\r\nThis hands-on tutorial teaches you how to use uv for managing Python projects, dependencies, and tools. uv is designed to be a drop-in replacement for pip while offering a complete development workflow: project management, dependency resolution, virtual environments, Python version management, and tool installation.\r\n\r\nKey advantages of uv:\r\n\r\n* **Speed**: 10-100x faster than pip for most operations\r\n* **Compatibility**: Works with existing pip workflows and requirements.txt files\r\n* **Complete workflow**: Replaces multiple tools with a single, unified interface\r\n* **Reliability**: Deterministic dependency resolution with lock files\r\n\r\nYou will learn:\r\n\r\n* How to replace pip with uv for faster package installation\r\n* How to manage Python projects with `pyproject.toml` and `uv.lock`\r\n* How to handle multiple Python versions without external tools\r\n* How to manage workspaces for multi-package projects\r\n* How to use `uvx` for running Python tools without installation\r\n* How to run single-file scripts with inline dependencies\r\n* How to build and publish Python packages\r\n* Best practices for using uv in real-world projects\r\n\r\nA brief comparison with Pixi and other dependency management tools is included.",
"code": "RARRL7",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-13T17:00:00+02:00",
"level": "intermediate",
"next_session": null,
"prev_session": "QWEJWT",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Tutorial",
"sessions_after": [],
"sessions_before": [
"GCWCEU",
"NQGSY7",
"QWEJWT",
"WYBHCE"
],
"sessions_in_parallel": [
"JRMSZT",
"NELACW",
"SNKUW7",
"VYUNHG"
],
"slug": "fast-python-development-with-uv",
"speakers": [
"9KSJ3K"
],
"start": "2026-07-13T13:45:00+02:00",
"title": "Fast Python Development with uv",
"track": "Tooling, Packaging, Developer Productivity",
"tweet": "Learn uv \u2014 the fast, modern Python tool for dependencies, environments, and packaging in one CLI.",
"website_url": "https://ep2026.europython.eu/session/fast-python-development-with-uv",
"youtube_url": null
},
"RB9TKP": {
"abstract": "With the rise of foundation models and zero-shot segmentation, it sometimes feels like fine-tuning classic object detection models is outdated. But is it? There are over 90 000 different LEGO bricks produced in almost 200 colors, and a single photo can easily contain hundreds of bricks. This makes LEGO recognition a perfect stress test for both traditional object detectors and the latest generation of vision models.\r\n\r\nDuring this talk, I will walk you through a practical comparison of approaches to LEGO brick detection. I will start with the classic object detection pipeline: dataset creation, annotation, and training with models like NanoDet and RF-DETR. Then, I will put these detectors up against zero-shot approaches: SAM 3 (Segment Anything Model 3), and vision language models, both closed-source APIs like Gemini and open-source alternatives like Qwen-VL. Along the way, I will share the pitfalls, surprising results, and lessons learned, including cases where a fine-tuned lightweight detector still outperforms models orders of magnitude larger.",
"code": "RB9TKP",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T10:40:00+02:00",
"level": "intermediate",
"next_session": "SCZ8ZK",
"prev_session": "UPKZKC",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Talk",
"sessions_after": [
"7SSS93",
"ARRMQR",
"BX77EE",
"FBQQXS",
"GP39VP",
"SCZ8ZK",
"TG7YMS",
"U7AHP3"
],
"sessions_before": [
"UPKZKC"
],
"sessions_in_parallel": [
"DBBNQD",
"KFQN3X",
"LFSJYL",
"SGM9SV"
],
"slug": "is-object-detection-dead-a-case-for-recognizing-lego-bricks",
"speakers": [
"8DK3QT"
],
"start": "2026-07-17T10:10:00+02:00",
"title": "Is Object Detection Dead? A Case for Recognizing LEGO Bricks",
"track": "Machine Learning, NLP and CV",
"tweet": "Is training your own LEGO brick detector still worth it in the age of foundation models?",
"website_url": "https://ep2026.europython.eu/session/is-object-detection-dead-a-case-for-recognizing-lego-bricks",
"youtube_url": null
},
"RGBSS8": {
"abstract": "From CLI developers to maintainers of large applications, many Python developers have been bitten by the high overhead of eagerly loading imports. Long start-up times can make it prohibitively costly to run simple commands like --help, and the memory overhead from loading every imported module eagerly can trigger Out-Of-Memory errors in production.\r\n\r\nAfter the most discussed PEP thread in the history of discuss.python.org, with hundreds of messages and fierce debate, Python 3.15 finally brings Explicit Lazy Imports to the language. With a simple new keyword, you can now defer module loading until the moment you actually need it. This is one of the most requested performance features in Python's history, and finally it's here.\r\n\r\nThis presentation will take you through how we got here and where we're going. We'll look at why existing workarounds never quite worked, and how an earlier proposal (PEP 690) tried to make all imports lazy by default but was rejected. Then PEP 810 emerged with a different approach: explicit, opt-in syntax that the community accepted.\r\n\r\nThe heart of this talk is discovering how lazy imports actually work inside the interpreter. We'll trace through the bytecode, see how proxy objects stand in for unloaded modules, and watch the moment when your code first touches a lazy import and the real module snaps into place. You'll also learn about the future tooling that we are baking that will help you adopt this safely in your own projects.\r\n\r\nWhether you're a beginner curious about Python's future, someone looking to speed up your CLI tools, or you just want to understand what's happening under the hood, this talk will give you everything you need to start using lazy imports with confidence.",
"code": "RGBSS8",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T14:25:00+02:00",
"level": "intermediate",
"next_session": "QY7PFR",
"prev_session": "PWGSJQ",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"NTZ7DG",
"QY7PFR",
"T7ATVM",
"WHHAQK",
"ZFJEUJ"
],
"sessions_before": [
"BJBKRM",
"FBQQXS",
"PWGSJQ",
"SCZ8ZK",
"SQRYJA"
],
"sessions_in_parallel": [
"7NWR9R",
"BX77EE",
"GP39VP",
"PBTPJR",
"U7AHP3",
"UGLF7Q",
"VSZSMW"
],
"slug": "lazy-imports-and-the-art-of-interpreter-procrastination",
"speakers": [
"VX8MVF"
],
"start": "2026-07-17T13:55:00+02:00",
"title": "Lazy imports and the art of interpreter procrastination",
"track": "Python Core, Internals, Extensions",
"tweet": "Python 3.15 introduces explicit lazy imports via PEP 810. Learn why it matters, how it works under the hood, and how to use it to boost performance.",
"website_url": "https://ep2026.europython.eu/session/lazy-imports-and-the-art-of-interpreter-procrastination",
"youtube_url": null
},
"RMY7Y7": {
"abstract": "Learn how to turn your existing PostgreSQL database into a job queue - no extra infrastructure required. You'll leave this talk with a understanding of the specific pg-SQL patterns that make it work, and practical guidance on whether this approach fits your project.\r\n\r\nI'll walk through the design and internals of PgQueuer, covering:\r\n\r\n- The problem: Why adding a dedicated message broker to your stack introduces operational complexity that many teams don't need - and the hidden costs of running, monitoring, and debugging a separate service.\r\n- The solution: Safe concurrent job claiming across multiple workers without collisions, sub-second job dispatch without constant polling, and all of it backed by your existing database.\r\n- Architecture and API design: How PgQueuer is structured, from the database schema to the decorator-based Python API, and the design decisions behind it.\r\n- Performance: Benchmarks showing 14k+ jobs/second throughput with asyncpg, and how durability policies (volatile, balanced, durable) let you trade safety for speed depending on your workload.\r\n- Tradeoffs and limits: What workloads PostgreSQL handles well as a job queue, what it doesn't, and how to know when your project needs something different.\r\n\r\nAll code shown uses PgQueuer (MIT-licensed, tested across PostgreSQL 13-18 and Python 3.10-3.14).",
"code": "RMY7Y7",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T15:55:00+02:00",
"level": "intermediate",
"next_session": "TWBDVZ",
"prev_session": "SWCWKZ",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk",
"sessions_after": [
"H7DVRJ",
"JEN7WA",
"TWBDVZ",
"X3ENDU",
"Y3DGWB"
],
"sessions_before": [
"33RGZA",
"7VKQQM",
"ENK9EF",
"HJ8KPY",
"HVTSPC",
"LNVDY3",
"PRGGNW",
"SWCWKZ"
],
"sessions_in_parallel": [
"H7KGU3",
"PCMBVT",
"WKBHZW",
"ZRWENU"
],
"slug": "pgqueuer-drop-the-broker-keep-the-queue",
"speakers": [
"GRKGYS"
],
"start": "2026-07-15T15:25:00+02:00",
"title": "PgQueuer: Drop the Broker, Keep the Queue",
"track": "Web Development, Web APIs, Front-End Integration",
"tweet": "Your PostgreSQL database is already a job queue - you just need the right SQL primitives. Let me show you how",
"website_url": "https://ep2026.europython.eu/session/pgqueuer-drop-the-broker-keep-the-queue",
"youtube_url": null
},
"SASJQU": {
"abstract": "Coordinating a swarm of drones to autonomously allocate tasks,\r\nbid on them in real time, and execute multi-robot formations\r\nsounds like science fiction \u2014 but it is entirely possible\r\nwith Python, a handful of threading primitives, and ROS2's\r\nMultiThreadedExecutor.\r\n\r\nThis talk walks through the concrete implementation challenges\r\nof building a decentralised auction-based task allocation\r\nsystem for a swarm of four Crazyflie UAVs. The focus is on\r\na problem that trips up almost every robotics engineer who\r\ngraduates from tutorials to real deployments: what happens\r\nwhen your system has to wait for external, asynchronous\r\nevents \u2014 bids from four robots, assignment confirmations,\r\nformation completion signals \u2014 without blocking the entire\r\nnode and without introducing race conditions or deadlocks?\r\n\r\nWe will explore how Python's threading.Event and Lock\r\nprimitives were used alongside ROS2's MultiThreadedExecutor\r\nand ReentrantCallbackGroup to implement a synchronized\r\nbid-collation protocol, a global assignment barrier, and\r\na concurrent multi-goal formation controller \u2014 all running\r\nin parallel on a single laptop while communicating with\r\nphysical drones over radio.\r\n\r\nYou will leave with a clear, transferable mental model\r\nfor combining Python threading with ROS2 callback groups,\r\npractical patterns for synchronizing distributed asynchronous\r\nevents in real-time systems, and an honest account of what\r\nbreaks in the real world (and why).",
"code": "SASJQU",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T15:25:00+02:00",
"level": "intermediate",
"next_session": "3FW7UF",
"prev_session": "93XE3S",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Talk",
"sessions_after": [
"3FW7UF",
"9JALSN",
"UY9UAG"
],
"sessions_before": [
"8HBEYS",
"93XE3S",
"9URK9U",
"BMQP7J",
"NXNHSB",
"PPQ3KE",
"VNR377"
],
"sessions_in_parallel": [
"BFK3JK",
"NS8QQA",
"TAZHCD"
],
"slug": "flying-in-formation-with-python-threading-and-ros2-parallelism",
"speakers": [
"WWYK7X"
],
"start": "2026-07-16T14:55:00+02:00",
"title": "Flying in Formation - with Python Threading and ROS2 Parallelism",
"track": "~ None of these topics",
"tweet": "Coordinating a drone swarm is a concurrency problem. Here's how threading.Event and ROS2 solved it on real hardware.",
"website_url": "https://ep2026.europython.eu/session/flying-in-formation-with-python-threading-and-ros2-parallelism",
"youtube_url": null
},
"SCZ8ZK": {
"abstract": "A multitude of Python libraries offer Just In Time (JIT) compilation capabilities for general purpose computations, such as JAX or Numba. But in certain cases these solutions might not be enough, thus we seek more specialized solutions that can include domain knowledge as well.\r\n\r\nCompilers for Domain Specific Languages (DSL) allow us to incorporate additional information during compilation, possibly tied to a specific domain, such as sparse arrays computing.\r\n\r\nIn this talk I'm going to introduce [Finch](https://finch-tensor.org/) - language and a compiler for sparse and structured multidimensional arrays, which specializes its kernels for control flow and data structures. It supports common control flow (loops, if conditions, etc.) and a wide variety of data structures - dense, sparse list, triangles, coordinate, or symmetry. \r\n\r\nThe ongoing effort to move Finch from the original Julia implementation to pure Python exposed us to new ways of using Python - as a language for implementing compilers.\r\n\r\nIn this talk I will present some key aspects of Python language and ecosystem which played a central role in making us productive in the last months during this undertaking:\r\n- Defining IRs with dataclasses and utilizing Structural Pattern Matching for term rewriting,\r\n- Using [Lark](https://lark-parser.readthedocs.io/en/stable/) for parsing custom languages into large IR structures,\r\n- Expressing complex rewrite schemes with [rewrite-tools](https://pypi.org/project/rewrite-tools/).\r\n\r\nThe audience will learn our approach to designing the structure of a compiler, together with a few technical decisions made along the way.\r\nI hope these insights will be useful for engineers and scientists coming from closely related fields and projects also involving compiling custom languages, such as probabilistic programming or hardware design.",
"code": "SCZ8ZK",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T12:15:00+02:00",
"level": "advanced",
"next_session": "7NWR9R",
"prev_session": "RB9TKP",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Talk",
"sessions_after": [
"7NWR9R",
"BJBKRM",
"BX77EE",
"GP39VP",
"PWGSJQ",
"SQRYJA",
"U7AHP3",
"VSZSMW"
],
"sessions_before": [
"7SSS93",
"ARRMQR",
"FBQQXS",
"RB9TKP",
"TG7YMS"
],
"sessions_in_parallel": [
"PQCHT3",
"QXZMP8",
"VKURLV"
],
"slug": "building-your-dsl-compiler-in-python",
"speakers": [
"TABXBG"
],
"start": "2026-07-17T11:45:00+02:00",
"title": "Building your DSL compiler in Python",
"track": "Machine Learning: Research & Applications",
"tweet": "Sparse and structured kernels in Finch. Tips and lessons from writing a DSL compiler in Python.",
"website_url": "https://ep2026.europython.eu/session/building-your-dsl-compiler-in-python",
"youtube_url": null
},
"SGM9SV": {
"abstract": "Have you ever wondered how popular tools like pytest or tox are able to discover and use plugins? \r\nIn this talk we will learn about entry-points in Python package metadata and how they enable plugin discovery. \r\nWe will review how some popular projects are using this mechanism to create their plugin systems.\r\nAfter a walkthrough of the basics, we will explore how you can use this to create a plugin mechanism for your own project. \r\nWe will explore possible hook implementations and their advantages and disadvantages. \r\nFinally we will learn how to make plugins discoverable on PyPi.",
"code": "SGM9SV",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T10:40:00+02:00",
"level": "intermediate",
"next_session": "TG7YMS",
"prev_session": "UPKZKC",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"7SSS93",
"ARRMQR",
"BX77EE",
"FBQQXS",
"GP39VP",
"SCZ8ZK",
"TG7YMS",
"U7AHP3"
],
"sessions_before": [
"UPKZKC"
],
"sessions_in_parallel": [
"DBBNQD",
"KFQN3X",
"LFSJYL",
"RB9TKP"
],
"slug": "plugins-in-python-how-it-is-done",
"speakers": [
"LZRGS8"
],
"start": "2026-07-17T10:10:00+02:00",
"title": "Plugins in python - how it is done",
"track": "Tooling, Packaging, Developer Productivity",
"tweet": "Plugins - how it is done in python, a walk through existing solution to understand and use",
"website_url": "https://ep2026.europython.eu/session/plugins-in-python-how-it-is-done",
"youtube_url": null
},
"SNKUW7": {
"abstract": "> *\"There are only two hard problems in distributed systems: 2. Exactly-once delivery 1. Guaranteed order of messages 2. Exactly-once delivery\"*\r\n\r\nIf this made you curious, this tutorial is the right place to dive deeper into the interesting (sometimes weird) world of Distributed Systems. \r\n\r\nWhen you think of constructing systems that can scale to billions of people, you have to think beyond single node programming patterns. This introduces a couple of intriguing challenges like how do you make thousands of nodes agree? Or jargons like *CAP Theorem*. To make matters even more complicated, most of the material on this subject is highly theoretical & geared towards advanced learners. This quickly discourages a lot of programmers who tend to learn better by doing rather than just reading about things.\r\n\r\nPython has always been a great vehicle to learn complex technologies efficiently. It enables a programmer to cut through the weeds to focus on the core concepts. This was recently exemplified when Andrej Karpathy taught a way to train a GPT in pure python with [microgpt.py](https://gist.github.com/karpathy/8627fe009c40f57531cb18360106ce95). \r\nSimilarly, it can be an efficient vehicle to deconstruct the fundamentals of large scale systems, which are essential for a holistic view of modern day applications.\r\n\r\nIn this tutorial, we will have several hands on exercises to dive deeper into the tenets of reliability, availability & scalability. By simulating a Distributed Cluster with pure python code we'll poke the system, make it fail & closely study the perils of planet scale systems & how to overcome them.\r\n\r\nTowards the end of the tutorial, you'll have a clear mental model of some of the most confusing concepts (Consistency, Consensus, Clocks etc) in distributed systems. The ultimate goal is to give you enough knowledge, curiosity & tooling so that you can explore this field on your own & be confident about building the next planet scale system.",
"code": "SNKUW7",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-13T17:00:00+02:00",
"level": "intermediate",
"next_session": null,
"prev_session": "NQGSY7",
"resources": null,
"room": "Conference Hall Complex A (S4A)",
"session_type": "Tutorial",
"sessions_after": [],
"sessions_before": [
"GCWCEU",
"NQGSY7",
"QWEJWT",
"WYBHCE"
],
"sessions_in_parallel": [
"JRMSZT",
"NELACW",
"RARRL7",
"VYUNHG"
],
"slug": "deconstructing-the-tenets-of-planet-scale-systems-with-python",
"speakers": [
"ZWGLVB"
],
"start": "2026-07-13T13:45:00+02:00",
"title": "Deconstructing the tenets of Planet Scale Systems with Python",
"track": "DevOps, Cloud, Scalable Infrastructure",
"tweet": "A hands on tutorial in Python on how to make planet scale, fault tolerant & reliable systems.",
"website_url": "https://ep2026.europython.eu/session/deconstructing-the-tenets-of-planet-scale-systems-with-python",
"youtube_url": null
},
"SQRYJA": {
"abstract": "We\u2019re living in weird times. The lines and connections that hold allies and trusted partners together are changing. New barriers to trade, to travel, to collaboration are affecting everything we do. Python is not immune to these shifts, but internationally stewarded open source is still the best choice if you are looking for software that does what it says it does and doesn\u2019t do a lot of things that you don\u2019t want it to do. \r\n\r\nLarge open source projects are vetted by multiple stakeholders in different counties, using that software for different purposes and running on all different hardware around the world. Increasingly, large projects like Python come with a Software Bill of Materials and massive new patches coming from brand new contributors are looked at with a little more skepticism than they would\u2019ve been a few years ago. This talk will discuss what\u2019s changed about international collaboration and how Python and other community driven projects are looking at security and collaboration these days.",
"code": "SQRYJA",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T12:55:00+02:00",
"level": "beginner",
"next_session": "PBTPJR",
"prev_session": "PQCHT3",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk",
"sessions_after": [
"7NWR9R",
"BX77EE",
"GP39VP",
"PBTPJR",
"RGBSS8",
"U7AHP3",
"UGLF7Q",
"VSZSMW"
],
"sessions_before": [
"FBQQXS",
"PQCHT3",
"QXZMP8",
"SCZ8ZK",
"VKURLV"
],
"sessions_in_parallel": [
"BJBKRM",
"PWGSJQ"
],
"slug": "international-open-source-your-best-choice-in-interesting-times",
"speakers": [
"XCKH3F"
],
"start": "2026-07-17T12:25:00+02:00",
"title": "International Open Source \u2013 Your Best Choice in Interesting Times",
"track": "Ethics, Social Responsibility, Sustainability, Legal",
"tweet": "Learn about how community driven projects are looking at security and collaboration these days.",
"website_url": "https://ep2026.europython.eu/session/international-open-source-your-best-choice-in-interesting-times",
"youtube_url": null
},
"SWCWKZ": {
"abstract": "How do you write and deliver desktop or mobile native apps with Python? Why are there not more native apps built with Python? What choices do Python folk have for creating a native app for desktop or mobile?\r\n\r\n\"It's complicated\", is perhaps the best answer.\r\n\r\nThis talk will give a brief historical survey of previous work in the field, we'll look at the current state of the art and explore future directions and opportunities. Scattered within the talk will be practical examples and perhaps some live-coding! By the end of the talk attendees will have options, ideas and inspiration for creating beautiful native Python apps with contemporary cutting edge cross platform technology.\r\n\r\nWe will encounter:\r\n\r\n* Frameworks like: tkinter, Qt, GTK, wxWidgets and Kivy.\r\n* Cross platform tooling such as that provided by BeeWare.\r\n* Browser based options like PyScript.\r\n* Current trends, new technology and pointers to the future.",
"code": "SWCWKZ",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T15:00:00+02:00",
"level": "intermediate",
"next_session": "RMY7Y7",
"prev_session": "NWLBJC",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk",
"sessions_after": [
"H7KGU3",
"PCMBVT",
"RMY7Y7",
"WKBHZW",
"ZRWENU"
],
"sessions_before": [
"33RGZA",
"3HBWHB",
"DRXC3E",
"HJ8KPY",
"LNVDY3",
"NWLBJC",
"PRGGNW",
"US3W8J"
],
"sessions_in_parallel": [
"7VKQQM",
"ENK9EF",
"HVTSPC"
],
"slug": "the-good-the-bad-and-the-ugly-native-python-app-development-and-delivery",
"speakers": [
"WADEN9"
],
"start": "2026-07-15T14:30:00+02:00",
"title": "The Good, the Bad and the Ugly: native Python app development and delivery.",
"track": "Tooling, Packaging, Developer Productivity",
"tweet": "Learn to write desktop and mobile apps in Python with modern powerful tooling.",
"website_url": "https://ep2026.europython.eu/session/the-good-the-bad-and-the-ugly-native-python-app-development-and-delivery",
"youtube_url": null
},
"SXBNNA": {
"abstract": "Welcome to the third day of conference!\r\nYesterday was an amazing day, but for sure you don't remember all the things that were mentioned during the opening.\r\nJoin us to get an update and few more announcements. Come by and find out what is going to happen today.",
"code": "SXBNNA",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T09:00:00+02:00",
"level": "beginner",
"next_session": "UPKZKC",
"prev_session": null,
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Announcements",
"sessions_after": [
"UPKZKC"
],
"sessions_before": [],
"sessions_in_parallel": [],
"slug": "friday-s-morning-announcement",
"speakers": [],
"start": "2026-07-17T08:45:00+02:00",
"title": "Friday's Morning Announcement \u23f0",
"track": null,
"tweet": "Yesterday was an amazing day, but for sure you don't remember all the things that were mentioned during the opening.",
"website_url": "https://ep2026.europython.eu/session/friday-s-morning-announcement",
"youtube_url": null
},
"T7ATVM": {
"abstract": "How can you create open digital tools that run on both the Cloud and the Edge for small/medium farms across Greek vineyards, French cattle ranches, and Belgian potato fields? The OpenAgri project, funded by the EU Horizon program and now part of the Linux Foundation's AgStack, has developed reusable Python tools for this purpose. These building blocks, using Python Web frameworks such as Django and FastAPI, are already being tested in 14 real-world sustainability pilots across Europe.\r\n\r\nIn this presentation, we will show how Python is helping farmers, from camera-based scouting in vineyards to UHF RFID cattle monitoring, UAV pest detection, IoT smart irrigation, and compost production monitoring. We will talk about what works across different countries, the challenges that arise when your \"data centre is a barn\", and what still needs improvement.\r\n\r\nJoin us to hear farming stories from across Europe and learn practical lessons on deploying Python microservices on Edge devices to build a more democratised agritech landscape in Europe.",
"code": "T7ATVM",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T15:05:00+02:00",
"level": "intermediate",
"next_session": "BPJHWT",
"prev_session": "PBTPJR",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk",
"sessions_after": [
"BPJHWT",
"LRVCYU",
"MP9ZRM",
"ZHCNDY"
],
"sessions_before": [
"7NWR9R",
"BX77EE",
"GP39VP",
"PBTPJR",
"RGBSS8",
"U7AHP3",
"UGLF7Q",
"VSZSMW"
],
"sessions_in_parallel": [
"NTZ7DG",
"QY7PFR",
"WHHAQK",
"ZFJEUJ"
],
"slug": "how-python-is-democratising-agritech-for-farmers-across-europe",
"speakers": [
"JDHQMZ"
],
"start": "2026-07-17T14:35:00+02:00",
"title": "How Python is Democratising Agritech for Farmers Across Europe",
"track": "Ethics, Social Responsibility, Sustainability, Legal",
"tweet": "How Python is democratising agritech across Europe: See how OpenAgri's tools are helping farmers and what breaks when your datacentre is a barn.",
"website_url": "https://ep2026.europython.eu/session/how-python-is-democratising-agritech-for-farmers-across-europe",
"youtube_url": null
},
"TAZHCD": {
"abstract": "The Python Packaging Index or PyPI, is used by over a million users. But what is behind the scenes of PyPI? PyPI is currently powered by Warehouse, a software built using Pyramid, a Python web framework. This talk explores Pyramid through the lens of a beginner\u2019s mindset and will lead the audience through the ins and outs of this Python web framework, its utility, and why it still holds its own and stands strong (like a pyramid!) among other comparable web frameworks.",
"code": "TAZHCD",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T15:25:00+02:00",
"level": "intermediate",
"next_session": "9JALSN",
"prev_session": "NXNHSB",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"3FW7UF",
"9JALSN",
"UY9UAG"
],
"sessions_before": [
"8HBEYS",
"93XE3S",
"9URK9U",
"BMQP7J",
"NXNHSB",
"PPQ3KE",
"VNR377"
],
"sessions_in_parallel": [
"BFK3JK",
"NS8QQA",
"SASJQU"
],
"slug": "climbing-the-pyramid-behind-the-scenes-of-the-python-package-index",
"speakers": [
"LKEVDA"
],
"start": "2026-07-16T14:55:00+02:00",
"title": "Climbing the Pyramid: Behind the Scenes of the Python Package Index",
"track": "Web Development, Web APIs, Front-End Integration",
"tweet": "Come climb the Pyramid, the web framework behind the software that houses the Python Package Index!",
"website_url": "https://ep2026.europython.eu/session/climbing-the-pyramid-behind-the-scenes-of-the-python-package-index",
"youtube_url": null
},
"TG7YMS": {
"abstract": "In software development, messy, outdated, or inefficient code is inevitable. We have to deal daily with old code that has not been touched for years, refactoring allows us to keep the code maintainable and easy to extend without altering its functionality, and it plays a crucial role in enhancing maintainability, readability, and performance.\r\n\r\nThis session explores the how, when, and why of code refactoring with code smell examples, coupled with practical insights on performance profiling techniques, tools and how it affects Refactoring. Also exploring how testing is very crucial when it comes to Refactoring.\r\n\r\nWhether you're dealing with legacy code or looking to enhance your development workflows, this talk equips you with the tools and techniques to write cleaner, more efficient Python code. \r\n\r\nThis session is inspired by Martin Fowler's seminal works on refactoring and Python-specific insights shared at EuroPython 2024.",
"code": "TG7YMS",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T11:35:00+02:00",
"level": "intermediate",
"next_session": "QXZMP8",
"prev_session": "SGM9SV",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"BX77EE",
"GP39VP",
"PQCHT3",
"QXZMP8",
"SCZ8ZK",
"U7AHP3",
"VKURLV",
"VSZSMW"
],
"sessions_before": [
"DBBNQD",
"KFQN3X",
"LFSJYL",
"RB9TKP",
"SGM9SV"
],
"sessions_in_parallel": [
"7SSS93",
"ARRMQR",
"FBQQXS"
],
"slug": "refactor-optimize-and-test-crafting-cleaner-python-code",
"speakers": [
"DGWNHV"
],
"start": "2026-07-17T11:05:00+02:00",
"title": "Refactor, Optimize, and Test: Crafting Cleaner Python Code",
"track": "~ None of these topics",
"tweet": "In software development messy code is inevitable refactoring allows us to keep code maintainable and easy to extend without altering its functionality",
"website_url": "https://ep2026.europython.eu/session/refactor-optimize-and-test-crafting-cleaner-python-code",
"youtube_url": null
},
"TGGHKC": {
"abstract": "This hands-on workshop introduces gRPC, a modern RPC framework for building microservices. Learn Protocol Buffers, implement gRPC services from scratch, and explore communication patterns in Python. Discover how gRPC compares to REST APIs and use pre-configured Docker environments to test, benchmark, and monitor your services. By the end, you'll have practical knowledge to build microservices with gRPC. Basic Python knowledge required. All tools and infrastructure provided\u2014bring a laptop with Docker installed.",
"code": "TGGHKC",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-14T12:45:00+02:00",
"level": "beginner",
"next_session": "N39TFS",
"prev_session": null,
"resources": null,
"room": "Conference Hall Complex A (S4A)",
"session_type": "Tutorial",
"sessions_after": [
"3TZHB9",
"K7XNTF",
"N39TFS",
"ZSRZPC"
],
"sessions_before": [],
"sessions_in_parallel": [
"3FDLUS",
"BTTFFJ",
"MENRZG",
"ZPCDKE"
],
"slug": "grpc-for-beginners",
"speakers": [
"3FUH7N",
"G3TLBD"
],
"start": "2026-07-14T09:30:00+02:00",
"title": "gRPC for Beginners",
"track": "~ None of these topics",
"tweet": "3-hour hands-on gRPC workshop for Python developers. Master Protocol Buffers, build services, implement communication patterns, test and monitor .",
"website_url": "https://ep2026.europython.eu/session/grpc-for-beginners",
"youtube_url": null
},
"TWBDVZ": {
"abstract": "For years, this real-time video system had no tests. Every change produced unpredictable side effects. Accuracy drifted. Production incidents and escalations followed. The only \u201cverification\u201d was manual inspection and hope.\r\n\r\nWhen I joined the project, this was the reality - and building a proper integration test suite became my first priority.\r\n\r\nIn this talk, I\u2019ll share how I designed and evolved the hardest integration test suite of my career using pytest - and kept it readable.\r\n\r\nThe system processed live streams in production. It was non-deterministic. Individual detections were only 80\u201390% accurate. For testing, we replayed recorded scenarios to make system behavior observable and comparable across runs. But binary assertions were not enough. A single failed event did not mean the whole system was broken - but we needed a way to measure when it actually was.\r\n\r\nInstead of writing one massive test, I built a layered architecture:\r\n\r\n- dual parametrization - recording scope and event scope\r\n- orchestration in fixtures - assertions in tiny, single-purpose tests\r\n- statistics collection during execution\r\n- end-of-run aggregation that summarizes system accuracy\r\n\r\nThe result was a suite that could detect regressions in model changes and produce reproducible evidence - HTML reports, structured dumps, and a summary statistics file.\r\n\r\nThis talk explores how far pytest can be stretched beyond unit tests - into a framework for architecting complex integration systems.",
"code": "TWBDVZ",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T16:35:00+02:00",
"level": "advanced",
"next_session": "PKMSSL",
"prev_session": "RMY7Y7",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk",
"sessions_after": [
"PKMSSL"
],
"sessions_before": [
"33RGZA",
"H7KGU3",
"LNVDY3",
"PCMBVT",
"PRGGNW",
"RMY7Y7",
"WKBHZW",
"ZRWENU"
],
"sessions_in_parallel": [
"H7DVRJ",
"JEN7WA",
"X3ENDU",
"Y3DGWB"
],
"slug": "the-hardest-test-suite-i-ever-built-a-pytest-case-study",
"speakers": [
"8ANWRW"
],
"start": "2026-07-15T16:05:00+02:00",
"title": "The hardest test suite I ever built - a pytest case study",
"track": "Testing, Quality Assurance, Security",
"tweet": "No tests. Real-time system. 80% accuracy. Production incidents. How I pushed pytest to its limits to build the hardest test suite of my career.",
"website_url": "https://ep2026.europython.eu/session/the-hardest-test-suite-i-ever-built-a-pytest-case-study",
"youtube_url": null
},
"TZHTEE": {
"abstract": "Should you use Kafka or RabbitMQ? Which Python library is the right fit? Is Celery still alive and kicking in 2026, or has Temporal taken over the world while we weren't watching? Perhaps we should all migrate to FastStream\u2014or are the native background tasks in your web framework all you really need?\r\n\r\nThere have never been so many possibilities when choosing how to queue and distribute work. This talk provides a comprehensive comparison of the modern Python ecosystem. We will explore where each tool shines, how they perform under pressure, and\u2014crucially\u2014when a specific tool is a poor match and should be avoided.\r\n\r\nUsing two real-world case studies, we will showcase the capabilities of each library. You will be able to evaluate the developer experience and how debugging works for each solution. You\u2019ll walk out with an ultimate decision chart, equipped to choose the perfect stack for your next project.",
"code": "TZHTEE",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-16T11:15:00+02:00",
"level": "intermediate",
"next_session": "G9FDRY",
"prev_session": "3KT3BW",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk (long session)",
"sessions_after": [
"8HBEYS",
"9URK9U",
"AGX8D9",
"BYWVNK",
"DWGSFA",
"G9FDRY",
"JQSQBB"
],
"sessions_before": [
"3KT3BW"
],
"sessions_in_parallel": [
"788XZA",
"CWBA3L",
"ETBPVR",
"UGM7F8"
],
"slug": "navigating-waters-of-background-jobs-and-queues-in-python-as-of-2026",
"speakers": [
"Z7MMMN"
],
"start": "2026-07-16T10:30:00+02:00",
"title": "Navigating waters of background jobs and queues in Python as of 2026",
"track": "Web Development, Web APIs, Front-End Integration",
"tweet": "How to run a background job or send something to queue using Python in 2026?",
"website_url": "https://ep2026.europython.eu/session/navigating-waters-of-background-jobs-and-queues-in-python-as-of-2026",
"youtube_url": null
},
"U7AHP3": {
"abstract": "**PyPartMC** is a Pythonic interface to *PartMC*. PartMC (Particle Monte Carlo) is a stochastic, particle-resolved atmospheric aerosol dynamics model, used for solving aerosol processes such as coagulation, nucleation, emission, and deposition. Both projects are free and open-source.\r\n\r\nOne of the main aims of the PyPartMC project is streamlining user experience. To use PartMC, you have to: work with UNIX shell, provide Fortran and C libraries, and perform standard Fortran and C source code configuration, compilation and linking. All of that boils down to a single **pip** package manager call with PyPartMC. Depending on the OS, PyPartMC will install from a binary wheel or compile from a source wheel containing all the dependencies.\r\n\r\nPyPartMC can operate on **Linux**, **Windows** and **MacOS**, and has been tested to install correctly on **Google Colab** Jupyter notebook cloud platform. The API is also callable from C++, Julia, and MATLAB. PyPartMC ships with a collection of introductory notebook examples, that can help with learning the library's API.\r\n\r\nFrom the developers point of view, PyPartMC is an interesting challenge, due to its **multi-language** environment. A C++ API is built on top of the Fortran one, leveraging the C-Fortran API. The Python interface is then constructed with the help of **nanobind** library. \r\n\r\n**PyPartMC** is part of **open-atmos**, which is a multi-institutional community hub for projects in atmospheric sciences (https://github.com/open-atmos). The development of this package is a collaboration between AGH University of Krakow and University of Illinois Urbana-Champaign. \r\n\r\nIn the poster, I will outline the package features and architecture, and also highlight the newly engineered components and CI workflows engineered in our team at AGH.",
"code": "U7AHP3",
"delivery": "in-person",
"duration": "60",
"end": "2026-07-17T14:00:00+02:00",
"level": "beginner",
"next_session": null,
"prev_session": null,
"resources": [
{
"description": "PyPartMC logo",
"resource": "https://programme.europython.eu/media/europython-2026/submissions/U7AHP3/resources/pypartmc_Ilc0zFX.svg"
}
],
"room": "Exhibit Hall",
"session_type": "Poster",
"sessions_after": [
"NTZ7DG",
"QY7PFR",
"T7ATVM",
"WHHAQK",
"ZFJEUJ"
],
"sessions_before": [
"BJBKRM",
"FBQQXS",
"PWGSJQ",
"SCZ8ZK",
"SQRYJA"
],
"sessions_in_parallel": [
"7NWR9R",
"BX77EE",
"GP39VP",
"PBTPJR",
"RGBSS8",
"UGLF7Q",
"VSZSMW"
],
"slug": "pypartmc-a-pythonic-interface-enhancing-fortran-based-simulation-package",
"speakers": [
"ZMNF9N"
],
"start": "2026-07-17T13:00:00+02:00",
"title": "PyPartMC: A Pythonic interface enhancing Fortran-based simulation package",
"track": "Jupyter and Scientific Python",
"tweet": "PyPartMC is a Python interface to Fortran-based PartMC. In this poster, you will see an example of a portable, cross-platform, pip-installable package",
"website_url": "https://ep2026.europython.eu/session/pypartmc-a-pythonic-interface-enhancing-fortran-based-simulation-package",
"youtube_url": null
},
"UALU9S": {
"abstract": "What an amazing week!\r\nWe had two tutorials days and three talks days filled with amazing topics, but more important, amazing people!\r\n\r\nOur community is thankful, and want to close the main conference days.\r\nJoin us to get a nice summary of what was EuroPython 2026.",
"code": "UALU9S",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T17:55:00+02:00",
"level": "beginner",
"next_session": null,
"prev_session": "8XMJGZ",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Announcements",
"sessions_after": [],
"sessions_before": [
"8XMJGZ",
"BPJHWT",
"BX77EE",
"GP39VP",
"LRVCYU",
"MP9ZRM",
"U7AHP3",
"WHHAQK"
],
"sessions_in_parallel": [],
"slug": "conference-closing",
"speakers": [],
"start": "2026-07-17T17:25:00+02:00",
"title": "Conference Closing \ud83d\udc0d",
"track": null,
"tweet": "We had two tutorials days and three talks days filled with amazing topics, but more important, amazing people!",
"website_url": "https://ep2026.europython.eu/session/conference-closing",
"youtube_url": null
},
"UGLF7Q": {
"abstract": "*but were too afraid to ask!\r\n\r\n`pandas`, the data wrangling workhorse, will celebrate its *18th year of existence* in 2026. You rely on it daily, but are you truly confident in your code?\r\n\r\nThis session is dedicated to the unwritten rules and hidden mechanics that separate a confident user from one who constantly battles warnings and unexpected outputs. We will confront the infamous `SettingWithCopyWarning` that haunts chained operations, clarify the critical differences in *deep vs. shallow copies* and the true cost of using `inplace=True`. We\u2019ll also demystify the complex handling of missing data (`NaN`s) and much more!\r\n\r\nCrucially, we will look to the future. `pandas` is engaged in a `DataFrame` library race with newer, high-performance libraries like `polars` and `duckdb`. The latest advancements\u2014`pandas` 2.0 and the new and shiny 3.0, with features like *Copy-on-Write* and *Apache Arrow* integration\u2014are the direct response, promising a future of dramatically improved speed, memory efficiency, and data types.\r\n\r\nJoin me to master the crucial concepts of the past and prepare for the performance gains and new behaviors of the future, ensuring your skills stay ahead of the curve. Stop guessing and start mastering `pandas`!",
"code": "UGLF7Q",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T14:25:00+02:00",
"level": "intermediate",
"next_session": "NTZ7DG",
"prev_session": "BJBKRM",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"NTZ7DG",
"QY7PFR",
"T7ATVM",
"WHHAQK",
"ZFJEUJ"
],
"sessions_before": [
"BJBKRM",
"FBQQXS",
"PWGSJQ",
"SCZ8ZK",
"SQRYJA"
],
"sessions_in_parallel": [
"7NWR9R",
"BX77EE",
"GP39VP",
"PBTPJR",
"RGBSS8",
"U7AHP3",
"VSZSMW"
],
"slug": "everything-you-always-wanted-to-know-about-pandas",
"speakers": [
"3DAXVG"
],
"start": "2026-07-17T13:55:00+02:00",
"title": "Everything you always wanted to know about pandas*",
"track": "Data Engineering and MLOps",
"tweet": "SettingWithCopyWarning, inplace=True, .copy(), .apply(), NaNs.. you use pandas every day, but do you really know how it works? It's time to find out!",
"website_url": "https://ep2026.europython.eu/session/everything-you-always-wanted-to-know-about-pandas",
"youtube_url": null
},
"UGM7F8": {
"abstract": "Some codebases let you ship a change in minutes. Others turn a one-line fix into weeks of investigation.\r\n\r\nThe difference is often not skill, tooling, or even architecture\u2014it\u2019s cognitive load.\r\n\r\nIn this talk, we\u2019ll look at real examples from long-lived Python systems to understand how inheritance, deep nesting, excessive abstraction, microservices, and over-applied DRY silently increase the cost of change.\r\n\r\nYou\u2019ll learn practical heuristics to recognize high cognitive load early and concrete strategies to reduce it\u2014so your team can move faster without rewriting everything.\r\n\r\nThis is a pragmatic engineering talk for developers who work in real production code, not greenfield demos.",
"code": "UGM7F8",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-16T11:15:00+02:00",
"level": "intermediate",
"next_session": "DWGSFA",
"prev_session": "3KT3BW",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk (long session)",
"sessions_after": [
"8HBEYS",
"9URK9U",
"AGX8D9",
"BYWVNK",
"DWGSFA",
"G9FDRY",
"JQSQBB"
],
"sessions_before": [
"3KT3BW"
],
"sessions_in_parallel": [
"788XZA",
"CWBA3L",
"ETBPVR",
"TZHTEE"
],
"slug": "the-hidden-cost-of-complexity-reducing-cognitive-load-in-python",
"speakers": [
"7JPAB8"
],
"start": "2026-07-16T10:30:00+02:00",
"title": "The Hidden Cost of Complexity: Reducing Cognitive Load in Python",
"track": "Tooling, Packaging, Developer Productivity",
"tweet": "Why do simple changes take weeks? Learn how cognitive load in Python codebases slows teams down\u2014and practical ways to reduce it.",
"website_url": "https://ep2026.europython.eu/session/the-hidden-cost-of-complexity-reducing-cognitive-load-in-python",
"youtube_url": null
},
"UPELCT": {
"abstract": "Graphs offer a powerful tool for uncovering relationships and hidden patterns between entities. This presentation provides an introduction to graph theory, and demonstrates how graphs are applied across various business domains - from social network analysis and recommendation systems to fraud detection and supply chain optimization. Through an overview of core concepts and algorithmic approaches, the goal is to show how graphs can reveal underlying structures in complex systems.\r\n\r\nAs a real-world case study, the presentation focuses on Eurovision voting - an area long suspected of regional bias and neighbourly favoritism. Using graph-based analysis and community detection techniques, we explore voting patterns between countries to better understand how geography, history, and politics influence the distribution of points. Through visualizations and data-driven insights, the talk demonstrates how graph theory uncovers hidden alliances and behavioral trends within the seemingly light-hearted spectacle of a music contest.",
"code": "UPELCT",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T12:50:00+02:00",
"level": "intermediate",
"next_session": "3HBWHB",
"prev_session": "QT97WA",
"resources": null,
"room": "Conference Hall Complex (S4)",
"session_type": "Talk",
"sessions_after": [
"33RGZA",
"3HBWHB",
"DRXC3E",
"LNVDY3",
"NWLBJC",
"PRGGNW",
"US3W8J",
"ZRWENU"
],
"sessions_before": [
"CBA98V",
"HJ8KPY",
"KRMBWS",
"QT97WA",
"VXDYGX"
],
"sessions_in_parallel": [
"NEH7RE",
"W9NLXV"
],
"slug": "friendly-borders-graph-algorithms-reveal-eurovision-voting-patterns",
"speakers": [
"XQ8VNG"
],
"start": "2026-07-15T12:20:00+02:00",
"title": "Friendly Borders: Graph algorithms reveal Eurovision voting patterns",
"track": "Data preparation and visualisation",
"tweet": "Discover hidden patterns with(in) graphs - from business networks to Eurovision voting and regional alliances.",
"website_url": "https://ep2026.europython.eu/session/friendly-borders-graph-algorithms-reveal-eurovision-voting-patterns",
"youtube_url": null
},
"UPKZKC": {
"abstract": "\"TBD: Keynote Speaker\"\r\nDetails coming soon. This prime session will feature an inspiring keynote address to set the tone for the entire event. Our team is finalizing an exceptional speaker whose insights and vision will leave a lasting impression. Check back shortly for the full announcement, topic, and speaker biography.",
"code": "UPKZKC",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-17T09:45:00+02:00",
"level": "beginner",
"next_session": "KFQN3X",
"prev_session": null,
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Keynote",
"sessions_after": [
"BX77EE",
"DBBNQD",
"GP39VP",
"KFQN3X",
"LFSJYL",
"RB9TKP",
"SGM9SV",
"U7AHP3"
],
"sessions_before": [],
"sessions_in_parallel": [],
"slug": "keynote-5-placeholder",
"speakers": [],
"start": "2026-07-17T09:00:00+02:00",
"title": "Keynote 5 - Placeholder",
"track": null,
"tweet": "\"TBD: Keynote Speaker\" Details coming soon. This prime session will feature an inspiring keynote address to set the tone for the entire event.",
"website_url": "https://ep2026.europython.eu/session/keynote-5-placeholder",
"youtube_url": null
},
"US3W8J": {
"abstract": "AsyncIO was designed with the Global Interpreter Lock (GIL) in mind: the event loop runs all of your async in a single thread, regardless of the GIL presence. Projects like trio focused on better ergonomics, but with a noticeable disadvantage in performance.\r\nWhat if we can have both?\r\n\r\nIn this talk we\u2019ll explore an alternative approach to async code in Python, redesigning the whole thing from the ground up, looking at what it takes \u2013 spoiler: way less than you think \u2013 to have simpler interfaces and multi-threaded support from day zero in a single package: TonIO.",
"code": "US3W8J",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T14:20:00+02:00",
"level": "intermediate",
"next_session": "ENK9EF",
"prev_session": "W9NLXV",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"7VKQQM",
"ENK9EF",
"HVTSPC",
"SWCWKZ",
"ZRWENU"
],
"sessions_before": [
"33RGZA",
"CBA98V",
"HJ8KPY",
"LNVDY3",
"NEH7RE",
"PRGGNW",
"UPELCT",
"W9NLXV"
],
"sessions_in_parallel": [
"3HBWHB",
"DRXC3E",
"NWLBJC"
],
"slug": "rethinking-asyncio-from-scratch-for-free-threaded-python",
"speakers": [
"TMDTKB"
],
"start": "2026-07-15T13:50:00+02:00",
"title": "Rethinking AsyncIO from scratch for free-threaded Python",
"track": "Python Core, Internals, Extensions",
"tweet": "Python doesn't have the GIL anymore. Can we rewrite AsyncIO to run in a multi-threaded fashion?",
"website_url": "https://ep2026.europython.eu/session/rethinking-asyncio-from-scratch-for-free-threaded-python",
"youtube_url": null
},
"UY9UAG": {
"abstract": "Package manifests like `pyproject.toml` record source-level dependencies: _pandas_ depends on _numpy_'s code. The story is different for binary dependencies, which exist whenever compiled code, like C code, is called from Python. _numpy_ depends on _OpenBLAS_'s binaries, but this dependency relationship is not recorded anywhere. This makes _OpenBLAS_ a _[phantom](https://www.endorlabs.com/learn/dependency-resolution-in-python-beware-the-phantom-dependency) binary dependency_.\r\n\r\nPhantom dependencies are therefore hidden from programmers and researchers, which is bad for at least two reasons.\r\n\r\nFirst, security. If one of your binary dependencies has a vulnerability, this means your project is probably also vulnerable \u2014 but you won't reliably find out about this, since your dependency is invisible.\r\n\r\nSecondly, sustainability. If we can't keep track of our binary dependencies, we can't keep track of their maintainers either, which means we can't credit and [financially support](https://opensourcepledge.com/) them. This can lead to [maintainer burnout](https://opensourcepledge.com/blog/burnout-in-open-source-a-structural-problem-we-can-fix-together/), which has already created serious supply chain issues.\r\n\r\nPython is not only tremendously popular, but also valued for its ability to easily interface with compiled libraries. According to my research, around 20% of Python packages have binary dependencies.\r\n\r\nThis means that the problem of phantom binary dependencies is widespread, and puts the public at risk of harm, eg if critical infrastructure like hospitals or transportation is compromised by exploiting the aforementioned weaknesses.\r\n\r\nI aim to describe how the problem of phantom binary dependencies can be fixed within the Python ecosystem, and demo some of my preliminary work.\r\n\r\nFirst, binary dependencies must be identified. Tools like _[auditwheel](https://github.com/pypa/auditwheel/)_ and _[elfdeps](https://github.com/python-wheel-build/elfdeps/)_ are able to identify a project's [required dynamic libraries](https://vlad.website/how-binary-dependencies-work/). If we create better APIs for these tools, and integrate them with package managers such as _pip_ and _uv_, we can give developers and researchers visibility into binary dependencies, dispelling the phantom.\r\n\r\nBeyond this, standards like [PEP 725](https://peps.python.org/pep-0725/), [PEP 770](https://peps.python.org/pep-0770/) and [PEP 804](https://peps.python.org/pep-0804/) specify how we might record binary dependency relationships in an easily accessible way. I'll explain how we can build on these standards to create tools that will allow users and researchers to explore binary dependencies and identify security issues by default.\r\n\r\nLastly, I want to talk about the road towards the ultimate aim of having binary dependencies be managed not by Python package managers, but by system package managers, as they should be. This will require interoperation between package managers, and I'll explain how this might work.",
"code": "UY9UAG",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T16:20:00+02:00",
"level": "advanced",
"next_session": "BDUAKE",
"prev_session": "BMQP7J",
"resources": null,
"room": "Theatre Hall (S2)",
"session_type": "Talk",
"sessions_after": [
"BDUAKE"
],
"sessions_before": [
"8HBEYS",
"9URK9U",
"BFK3JK",
"BMQP7J",
"NS8QQA",
"SASJQU",
"TAZHCD"
],
"sessions_in_parallel": [
"3FW7UF",
"9JALSN"
],
"slug": "binary-dependencies-identifying-the-hidden-packages-we-all-depend-on",
"speakers": [
"3RGAHL"
],
"start": "2026-07-16T15:50:00+02:00",
"title": "Binary Dependencies: Identifying the Hidden Packages We All Depend On",
"track": "Tooling, Packaging, Developer Productivity",
"tweet": "Hidden binary dependency relationships are putting the security of the Python ecosystem at risk \u2014 but we can fix this.",
"website_url": "https://ep2026.europython.eu/session/binary-dependencies-identifying-the-hidden-packages-we-all-depend-on",
"youtube_url": null
},
"VKURLV": {
"abstract": "Python dicts are everywhere! They back module namespaces, instance attributes, **kwargs, and of course actual dictionaries. But have you ever wondered how they work under the hood? And more importantly, what happens to them now that free-threaded Python is here?\r\n\r\nIn this talk, we'll start by exploring the internals of CPython's dict implementation: how hashing works, the compact table layout that gives you insertion order, and how lookups, insertions, and deletions actually play out in memory. Then we'll see what had to change for free-threading: how reads remain fast without acquiring locks, what the per-object lock is and when it kicks in, and why making a dict thread-safe is harder than it sounds.\r\n\r\nFinally, we'll look at the ongoing effort to document CPython's thread-safety guarantees for built-in types and what the resulting documentation means for a Python developer writing concurrent code.\r\n\r\nThe audience will leave with a deep understanding of how Python's most important data structure works, how it's been adapted for a free-threaded world, and what they can (or can't) safely do with dicts across threads.",
"code": "VKURLV",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T12:15:00+02:00",
"level": "advanced",
"next_session": "PWGSJQ",
"prev_session": "ARRMQR",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"7NWR9R",
"BJBKRM",
"BX77EE",
"GP39VP",
"PWGSJQ",
"SQRYJA",
"U7AHP3",
"VSZSMW"
],
"sessions_before": [
"7SSS93",
"ARRMQR",
"FBQQXS",
"RB9TKP",
"TG7YMS"
],
"sessions_in_parallel": [
"PQCHT3",
"QXZMP8",
"SCZ8ZK"
],
"slug": "python-dicts-past-present-and-free-threaded-future",
"speakers": [
"FRXXAQ"
],
"start": "2026-07-17T11:45:00+02:00",
"title": "Python Dicts: Past, Present, and Free-Threaded Future",
"track": "Python Core, Internals, Extensions",
"tweet": "A deep dive into CPython dict internals, what changed for free-threading, and the thread-safety guarantees you can rely on when the GIL goes away",
"website_url": "https://ep2026.europython.eu/session/python-dicts-past-present-and-free-threaded-future",
"youtube_url": null
},
"VNR377": {
"abstract": "Developing a single drug takes 12 years with only a 12% chance of success. AI is changing this dramatically: the first AI designed drug have reached human trials, Alphafold won a Nobel Prize and pharmaceutical companies have committed billions to AI partnerships. The best part? The Python ecosystem you already know is powering this revolution. This talk introduces AI drug discovery to Python developers with no biology or chemistry background required. We'll start with the key insight that makes this field accessible: molecules are data structures, proteins are strings, and drug target binding is just API matching. Through a demo, attendees will see how to represent and visualize molecules with RDKit, convert chemical structures into ML ready vectors, predict drug properties like toxicity and solubility using graph neural networks with DeepChem and predict 3D protein structures in seconds using the ESMFold API.",
"code": "VNR377",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T14:45:00+02:00",
"level": "intermediate",
"next_session": "BFK3JK",
"prev_session": "FB93DB",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Talk",
"sessions_after": [
"BFK3JK",
"NS8QQA",
"SASJQU",
"TAZHCD",
"UY9UAG"
],
"sessions_before": [
"8HBEYS",
"9URK9U",
"B7CMBD",
"BMQP7J",
"E3GVVR",
"FB93DB",
"MJTZ7A"
],
"sessions_in_parallel": [
"93XE3S",
"NXNHSB",
"PPQ3KE"
],
"slug": "from-molecules-to-models-a-guide-to-ai-drug-discovery-with-python",
"speakers": [
"UMPJBY"
],
"start": "2026-07-16T14:15:00+02:00",
"title": "From Molecules to Models: A Guide to AI Drug Discovery with Python",
"track": "Machine Learning: Research & Applications",
"tweet": "What if your ML skills could help discover new medicines? Join us for an intro to AI drug discovery with Python.",
"website_url": "https://ep2026.europython.eu/session/from-molecules-to-models-a-guide-to-ai-drug-discovery-with-python",
"youtube_url": null
},
"VSZSMW": {
"abstract": "Three months ago, I was hunting down a memory leak in our Flask API that was driving me absolutely insane. The app would run fine for hours, then suddenly RAM usage would spike and everything would crash. Profilers showed nothing useful. Logs were useless. My manager kept asking \"is it fixed yet?\" \r\n \r\n In my desperation, I started writing small Python scripts to track every possible metric I could think of - not because I knew what I was doing, but because I was running out of ideas. I tracked function call counts, database connection pools, even how many times certain variables were accessed. Most of it was probably stupid, but I was grasping at straws.\r\n \r\n The weird thing is, those hacky little monitoring scripts I threw together in frustration actually became the most useful debugging tool our team has ever had. Not because they're sophisticated (they're definitely not), but because they were built by someone who was genuinely confused about what was happening in their own code.\r\n \r\n This talk is the story of how desperation led to accidentally building something useful, and why sometimes the best tools come from not knowing what you're supposed to be doing. I'll show you the exact scripts I wrote (warts and all), the embarrassing assumptions I made, and how you can steal these ideas to debug your own mysterious problems - even if you have no idea what you're doing either.",
"code": "VSZSMW",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T14:25:00+02:00",
"level": "intermediate",
"next_session": "ZFJEUJ",
"prev_session": "FBQQXS",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Talk",
"sessions_after": [
"NTZ7DG",
"QY7PFR",
"T7ATVM",
"WHHAQK",
"ZFJEUJ"
],
"sessions_before": [
"BJBKRM",
"FBQQXS",
"PWGSJQ",
"SCZ8ZK",
"SQRYJA"
],
"sessions_in_parallel": [
"7NWR9R",
"BX77EE",
"GP39VP",
"PBTPJR",
"RGBSS8",
"U7AHP3",
"UGLF7Q"
],
"slug": "i-accidentally-built-a-monitoring-system-while-trying-to-debug-memory-leak",
"speakers": [
"CCE8LJ",
"RKEBRW"
],
"start": "2026-07-17T13:55:00+02:00",
"title": "I Accidentally Built a Monitoring System While Trying to Debug Memory Leak",
"track": "DevOps, Cloud, Scalable Infrastructure",
"tweet": "I\u2019ll share how I chased a stubborn memory leak in our Flask API and built simple Python scripts that turned into our most useful debugging tool.",
"website_url": "https://ep2026.europython.eu/session/i-accidentally-built-a-monitoring-system-while-trying-to-debug-memory-leak",
"youtube_url": null
},
"VXDYGX": {
"abstract": "**Space Weather** doesn\u2019t just produce beautiful auroras: it can silently disrupt navigation systems, radio links, and satellite-based technologies we rely on every day.\r\n\r\nTravelling Ionospheric Disturbances (TIDs) are wave-like structures in the ionosphere that affect GNSS accuracy and HF communications. From an ML perspective, forecasting TIDs is a challenging rare-event prediction problem involving imbalanced data and heterogeneous physical inputs.\r\n\r\nIn this talk, I will present an operational machine learning approach developed within the T-FORS project to forecast TID occurrence over Europe. The model is built using **CatBoost** and integrates data from space- and ground-based observations.\r\n\r\nThe talk focuses on **model design and evaluation choices**. In particular, I will show how **SHAP** can be used to debug model behaviour, validate feature relevance, and build trust in predictions in a high-risk operational context.\r\n\r\nAlong the way, I\u2019ll share practical engineering lessons on:\r\n- handling class imbalance,\r\n- incorporating domain knowledge into ML pipelines,\r\n- producing **uncertainty-aware outputs** via **Conformal Prediction**, and\r\n- running **interpretable models in real-time forecasting systems**.\r\n\r\nThe talk is aimed at data scientists and ML practitioners interested in applied forecasting, interpretable models, uncertainty quantification and ML at the boundary between data and physics.\r\n\r\n---\r\n\r\n**Talk outline**\r\n- 0-4: What is Space Weather and why should we care\r\n- 4-7: Framing TID forecasting as an ML problem\r\n- 7-10: Model design with CatBoost\r\n- 10-13: Explainability with SHAP\r\n- 13-18: Uncertainty quantification with Conformal Prediction\r\n- 18-22: Cost-sensitive learning and real-time operations\r\n- 22-25: Lessons learned\r\n- 25-30: Q&A",
"code": "VXDYGX",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T12:10:00+02:00",
"level": "intermediate",
"next_session": "NEH7RE",
"prev_session": "M8Q77Z",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Talk",
"sessions_after": [
"33RGZA",
"LNVDY3",
"NEH7RE",
"NWLBJC",
"PRGGNW",
"UPELCT",
"W9NLXV",
"ZRWENU"
],
"sessions_before": [
"9EFAJS",
"DWBGJ9",
"M8Q77Z",
"QT97WA",
"Y8QAUA"
],
"sessions_in_parallel": [
"CBA98V",
"HJ8KPY",
"KRMBWS"
],
"slug": "when-the-sun-breaks-your-gps-building-an-explainable-early-warning-system",
"speakers": [
"FRRAE7"
],
"start": "2026-07-15T11:40:00+02:00",
"title": "When the Sun Breaks Your GPS: Building an Explainable Early Warning System",
"track": "Machine Learning: Research & Applications",
"tweet": "Have you ever happened to use GPS and realised that it is not working properly? The Sun could be responsible.",
"website_url": "https://ep2026.europython.eu/session/when-the-sun-breaks-your-gps-building-an-explainable-early-warning-system",
"youtube_url": null
},
"VYUNHG": {
"abstract": "## Rust in Python: Deep Dive and Experience Sharing\r\n\r\nThis full-day summit is dedicated to exploring the intersection of Rust and the Python ecosystem. Attendees can expect an intensive schedule built around in-depth discussions, collaborative problem-solving, and practical experience sharing focused specifically on integrating Rust into Python projects and the development of high-performance Python tools (e.g., using technologies like PyO3, Maturin, or writing performant native extensions). The goal is to move beyond introductory concepts to tackle real-world challenges, performance optimizations, and best practices in production environments. This summit is designed for developers who already possess some practical experience in these topics and are looking to deepen their expertise, share lessons learned, and contribute to the community's collective knowledge.\r\n\r\n# Registration and Participation\r\n\r\nParticipation in the Rust Summit is by invitation only to ensure a focused and high-value experience for all attendees.\r\n\r\n1. **Sign-Up Form:** Individuals interested in attending must first complete the [sign-up form](https://forms.gle/bh2WKoUFYBJ6YzibA). \r\n2. **Topic Submission:** This form also provides the opportunity for prospective attendees to suggest talks and/or discussion topics they would like to contribute or see covered during the summit. \r\n3. **Invitation:** After the sign-up period closes, the organizers will review submissions. Successful applicants will receive an official email invitation confirming their attendance in advance of the event. \r\n4. **EuroPython Ticket Requirement:** Please note that all participants *must* also be registered ticket holders for the main EuroPython conference. Holding a EuroPython ticket is a mandatory prerequisite for attending the Rust Summit.",
"code": "VYUNHG",
"delivery": "in-person",
"duration": "360",
"end": "2026-07-13T17:00:00+02:00",
"level": "advanced",
"next_session": null,
"prev_session": null,
"resources": null,
"room": "Reception Room F2 (Fishbowl)",
"session_type": "Summit",
"sessions_after": [],
"sessions_before": [],
"sessions_in_parallel": [
"GCWCEU",
"JRMSZT",
"NELACW",
"NQGSY7",
"QWEJWT",
"RARRL7",
"SNKUW7",
"WYBHCE"
],
"slug": "rust-summit-at-europython",
"speakers": [
"8EGVC9"
],
"start": "2026-07-13T09:30:00+02:00",
"title": "Rust Summit at EuroPython",
"track": "~ None of these topics",
"tweet": "Rust in Python: Deep Dive and Experience Sharing. This full-day summit is dedicated to exploring the intersection of Rust and the Python ecosystem.",
"website_url": "https://ep2026.europython.eu/session/rust-summit-at-europython",
"youtube_url": null
},
"W9NLXV": {
"abstract": "This talk is a follow-up to my EuroPython 2025 session on the foundations of the CPython JIT compiler. It looks at how the JIT has evolved since Python 3.14 and where it stands as Python 3.15 approaches release. We cover the transition of the JIT from an experimental feature towards a supported part of CPython, how it fits into the runtime today, and what that means in practice for users and distributors. The talk also explores how the JIT interacts with free-threaded builds, the current status of integration with external debuggers, and how these constraints shape real-world usage. Finally, we examine how the JIT performs today, where it already delivers substantial speedups, where it does not, and what realistic performance expectations look like for Python 3.15.",
"code": "W9NLXV",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T12:50:00+02:00",
"level": "advanced",
"next_session": "US3W8J",
"prev_session": "KRMBWS",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"33RGZA",
"3HBWHB",
"DRXC3E",
"LNVDY3",
"NWLBJC",
"PRGGNW",
"US3W8J",
"ZRWENU"
],
"sessions_before": [
"CBA98V",
"HJ8KPY",
"KRMBWS",
"QT97WA",
"VXDYGX"
],
"sessions_in_parallel": [
"NEH7RE",
"UPELCT"
],
"slug": "update-on-the-cpython-jit-what-to-expect-in-3-15",
"speakers": [
"NCU7GS"
],
"start": "2026-07-15T12:20:00+02:00",
"title": "Update on the CPython JIT: What to expect in 3.15",
"track": "Python Core, Internals, Extensions",
"tweet": "Update on the CPython JIT in Python 3.15: evolution since 3.14, interaction with free threading and debuggers, and real performance todaye",
"website_url": "https://ep2026.europython.eu/session/update-on-the-cpython-jit-what-to-expect-in-3-15",
"youtube_url": null
},
"WHHAQK": {
"abstract": "As engineers grow in their careers, many of us try to support our teams by writing more code, reviewing every pull request, and stepping in to fix the hardest problems. It feels helpful and responsible. Over time though, this approach can unintentionally create too much dependency on one person.\r\n\r\nThis talk explores the shift from being the person who solves everything to becoming someone who helps the whole team succeed.\r\n\r\nDrawing from lessons learned through experience(often the hard way :)) and from colleagues and mentors along the way, I will share practical shifts that make a difference: creating clearer technical direction, improving design conversations, sharing context early, mentoring thoughtfully and building systems that reduce reliance on any single \u201chero.\u201d\r\n\r\nIf you are a mid or senior engineer who is always busy but still feels that too much depends on you, this talk aims to offer useful ideas for your own journey.",
"code": "WHHAQK",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T15:05:00+02:00",
"level": "beginner",
"next_session": null,
"prev_session": "7NWR9R",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Talk",
"sessions_after": [
"BPJHWT",
"LRVCYU",
"MP9ZRM",
"ZHCNDY"
],
"sessions_before": [
"7NWR9R",
"BX77EE",
"GP39VP",
"PBTPJR",
"RGBSS8",
"U7AHP3",
"UGLF7Q",
"VSZSMW"
],
"sessions_in_parallel": [
"NTZ7DG",
"QY7PFR",
"T7ATVM",
"ZFJEUJ"
],
"slug": "from-code-hero-to-team-leader-learning-to-let-go",
"speakers": [
"VLWVB9"
],
"start": "2026-07-17T14:35:00+02:00",
"title": "From Code Hero to Team Leader: Learning to Let Go",
"track": "Professional Development, Careers, Leadership",
"tweet": "From Saving the Day to Building the Team. How to move from hero mode to team growth.",
"website_url": "https://ep2026.europython.eu/session/from-code-hero-to-team-leader-learning-to-let-go",
"youtube_url": null
},
"WKBHZW": {
"abstract": "Python has become the most widely used language in scientific computing and data science due to its approachable syntax, vast ecosystem of libraries, and rapid prototyping capabilities. However, its interpreted nature often poses a performance bottleneck for computationally intensive tasks common in High Performance Computing (HPC) used in scientific and data work, such as large-scale simulations, complex data analysis, and machine learning model training. \r\n\r\nEnhancing Python's performance, therefore, is critical for scientific computing: it allows researchers and engineers to maintain the productivity and flexibility of the Python environment while achieving the necessary speed and scalability to tackle demanding, real-world HPC problems without needing to switch to lower-level languages entirely.\r\n\r\nIn this talk, we will review the current state of Python in HPC, examine the role of key libraries like NumPy and Dask, and see how to use PyO3 to create robust Rust bindings for Python in a way that simplifies the process of building and distributing packages. We\u2019ll explore how Rust brings specific advantages to HPC, including guaranteed memory safety without garbage collection, zero-cost abstractions, and true parallelism.\r\n\r\nAttendees will leave with a clear understanding of the 'why' and 'how' of leveraging Rust in their Python-based HPC workflows, positioning them to develop faster, safer, and more scalable computational code.",
"code": "WKBHZW",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T15:55:00+02:00",
"level": "intermediate",
"next_session": "Y3DGWB",
"prev_session": "ENK9EF",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"H7DVRJ",
"JEN7WA",
"TWBDVZ",
"X3ENDU",
"Y3DGWB"
],
"sessions_before": [
"33RGZA",
"7VKQQM",
"ENK9EF",
"HJ8KPY",
"HVTSPC",
"LNVDY3",
"PRGGNW",
"SWCWKZ"
],
"sessions_in_parallel": [
"H7KGU3",
"PCMBVT",
"RMY7Y7",
"ZRWENU"
],
"slug": "rust-for-high-performance-computing-hpc-in-python",
"speakers": [
"8EGVC9"
],
"start": "2026-07-15T15:25:00+02:00",
"title": "Rust for High Performance Computing (HPC) in Python",
"track": "Jupyter and Scientific Python",
"tweet": "In this talk, we will review the state of Python in HPC, examine the role of key libraries, and see using PyO3 to create Rust bindings for Python.",
"website_url": "https://ep2026.europython.eu/session/rust-for-high-performance-computing-hpc-in-python",
"youtube_url": null
},
"WYBHCE": {
"abstract": "Asynchronous programming is infamous for leading to confusing projects with non linear code paths and all sorts of nasty bugs\u2026\r\n\r\nBut with the right mental models and a cooking analogy, you will find yourself writing async code with confidence.\r\n\r\nCome to this tutorial if you\u2019re prepared to challenge your understanding of how programs run, if you want to create a simple Human-to-Human asynchronous chat application, or ir you want to critique my culinary taste.",
"code": "WYBHCE",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-13T12:45:00+02:00",
"level": "intermediate",
"next_session": "JRMSZT",
"prev_session": null,
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Tutorial",
"sessions_after": [
"JRMSZT",
"NELACW",
"RARRL7",
"SNKUW7"
],
"sessions_before": [],
"sessions_in_parallel": [
"GCWCEU",
"NQGSY7",
"QWEJWT",
"VYUNHG"
],
"slug": "cooking-with-asyncio-an-introduction-to-asynchronous-programming",
"speakers": [
"BLNV7P"
],
"start": "2026-07-13T09:30:00+02:00",
"title": "Cooking with asyncio: an introduction to asynchronous programming",
"track": "Python Core, Internals, Extensions",
"tweet": "Come cook with asyncio and write a chat app with asynchronous programming!",
"website_url": "https://ep2026.europython.eu/session/cooking-with-asyncio-an-introduction-to-asynchronous-programming",
"youtube_url": null
},
"X3ENDU": {
"abstract": "Most developers have to interact with databases at some point, and therefore need to know at least a little bit about them, but probably don't have much training or experience in that area. I've worked with databases for over 25 years because I love them so much, but I'm aware that most people don't feel the same way! \r\n\r\nAs a Python developer, you probably just want the database to quietly do its thing in the background so you can concentrate on coding. That seems like a reasonable request. But the world of databases is changing. The traditional DBA role is becoming less common, and developers are increasingly expected to manage their own databases. \r\n\r\nSo let's talk about what you actually need to know about databases. You should come away reassured that, although it helps to have a smattering of database knowledge, you don't need to be a database expert. We'll explore the minimum that you *do* need to know, and look at where you can find more information or help when you need it.\r\n\r\nI don't expect to turn everyone into a database enthusiast, but I hope I can share some of my love of databases with you along the way.",
"code": "X3ENDU",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T16:35:00+02:00",
"level": "beginner",
"next_session": "PKMSSL",
"prev_session": "PCMBVT",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Talk",
"sessions_after": [
"PKMSSL"
],
"sessions_before": [
"33RGZA",
"H7KGU3",
"LNVDY3",
"PCMBVT",
"PRGGNW",
"RMY7Y7",
"WKBHZW",
"ZRWENU"
],
"sessions_in_parallel": [
"H7DVRJ",
"JEN7WA",
"TWBDVZ",
"Y3DGWB"
],
"slug": "how-much-do-you-really-need-to-know-about-databases",
"speakers": [
"NMCVC3"
],
"start": "2026-07-15T16:05:00+02:00",
"title": "How much do you really need to know about Databases?",
"track": "~ None of these topics",
"tweet": "What does a Python developer really need to know about databases?",
"website_url": "https://ep2026.europython.eu/session/how-much-do-you-really-need-to-know-about-databases",
"youtube_url": null
},
"Y3DGWB": {
"abstract": "September 2026, a month after Euro Python, the first wave of legal obligations for the EU Cyber Resilience Act (CRA) will wash over the software world. For us in the open-source community, CRA has been a source of major confusion, dilemma, and anxiety \r\n- 'Will my hobby project make me liable?'\r\n- 'Is my Python package \"commercial activity\"?'\r\n- 'Will PSF be liable for your code?'\r\n- 'Do I really need an SBOM for a Python library?'\r\nIn this talk I, a lawyer, engineer, and FOSS alumni, will cut through the legal jargon to explain what the CRA actually is, why it exists, and how it changes the \"manufacturer\" relationship with open-source code. We will walk through the new legal roles\u2014from Manufacturers to the newly defined \"Stewards\"\u2014and provide a clear \"To-Do and Not-To-Do\" list for community maintainers. Whether you are a solo contributor or part of a major foundation, this session will help you navigate the 2026\u20132027 transition period with confidence.",
"code": "Y3DGWB",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T16:35:00+02:00",
"level": "beginner",
"next_session": "PKMSSL",
"prev_session": "WKBHZW",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"PKMSSL"
],
"sessions_before": [
"33RGZA",
"H7KGU3",
"LNVDY3",
"PCMBVT",
"PRGGNW",
"RMY7Y7",
"WKBHZW",
"ZRWENU"
],
"sessions_in_parallel": [
"H7DVRJ",
"JEN7WA",
"TWBDVZ",
"X3ENDU"
],
"slug": "demystifying-cra-for-the-community",
"speakers": [
"QYF9E3"
],
"start": "2026-07-15T16:05:00+02:00",
"title": "Demystifying CRA for the community",
"track": "Ethics, Social Responsibility, Sustainability, Legal",
"tweet": "Is my Python project commercial activity? Why is everyone talking about SBOMs? What is Stewardship? We talk about CRA, legal roles & ToDos for co.",
"website_url": "https://ep2026.europython.eu/session/demystifying-cra-for-the-community",
"youtube_url": null
},
"Y8QAUA": {
"abstract": "Free-threaded Python, the effort to remove the Global Interpreter Lock from CPython, is one of the biggest and most exciting changes to Python in many years. However, It can be hard to follow what that means, what effect it will have on you and your code, and how this isn't yet another Python 2 to 3 migration.\r\n\r\nThis overview will explain what free-threading is, why it's a big deal, how it differs from other ways to deal with the GIL, and what the plan is for ensuring a smooth migration. We'll explain the basics of thread safety, data races, and concurrent designs, how those apply to Python code, and how this will and won't change when the GIL is disabled. And yes, we'll show some threads go _brrr_.\r\n\r\nAlthough we'll mention some complex, deeply technical problems, this is not a technical deep dive and any experience level is welcome.",
"code": "Y8QAUA",
"delivery": "in-person",
"duration": "45",
"end": "2026-07-15T11:30:00+02:00",
"level": "intermediate",
"next_session": "KRMBWS",
"prev_session": "BJCYNE",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk (long session)",
"sessions_after": [
"33RGZA",
"CBA98V",
"HJ8KPY",
"KRMBWS",
"LNVDY3",
"PRGGNW",
"UPELCT",
"VXDYGX"
],
"sessions_before": [
"BJCYNE"
],
"sessions_in_parallel": [
"9EFAJS",
"DWBGJ9",
"M8Q77Z",
"QT97WA"
],
"slug": "free-threaded-python-past-present-and-future",
"speakers": [
"VGYSEC"
],
"start": "2026-07-15T10:45:00+02:00",
"title": "Free-threaded Python: past, present and future",
"track": "Python Core, Internals, Extensions",
"tweet": "Why removing CPython's Global Interpreter Lock is hard, and how we did it anyway.",
"website_url": "https://ep2026.europython.eu/session/free-threaded-python-past-present-and-future",
"youtube_url": null
},
"YKWMBZ": {
"abstract": "Your FastAPI + SQLAlchemy tests pass alone but fail together. Data leaks between tests, and cleanup becomes slower. Meanwhile, it seems effortless in Django. Why?\r\n\r\nThis isn't a framework war - we'll dig into what Django actually does behind the scenes to keep the database clean between tests and why that approach isn\u2019t straightforward to replicate in a typical SQLAlchemy setup.\r\n\r\nWe'll explore common cleanup strategies like recreating schema, truncating, transaction wrapping or template databases and benchmark how they scale as your test suite grows. \r\n\r\nYou'll leave with a clear understanding of why this problem exists and practical, benchmarked options to keep your test suite fast and data isolated.\r\n\r\nAimed at intermediate Python developers comfortable with writing tests and familiar with basic database concepts like transactions.",
"code": "YKWMBZ",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-16T12:35:00+02:00",
"level": "intermediate",
"next_session": "E3GVVR",
"prev_session": "AGX8D9",
"resources": null,
"room": "Chamber Hall B (S3B)",
"session_type": "Talk",
"sessions_after": [
"8HBEYS",
"9URK9U",
"B7CMBD",
"BMQP7J",
"E3GVVR",
"FB93DB",
"MJTZ7A"
],
"sessions_before": [
"AGX8D9",
"BYWVNK",
"DWGSFA",
"G9FDRY",
"JQSQBB"
],
"sessions_in_parallel": [
"9MRVPM",
"GEJAQW",
"JSLSHM",
"LN7EF3"
],
"slug": "djangos-magic-fastapis-reality-test-isolation-at-scale",
"speakers": [
"9PKN9W"
],
"start": "2026-07-16T12:05:00+02:00",
"title": "Django\u2019s Magic, FastAPI\u2019s Reality: Test Isolation at Scale",
"track": "Web Development, Web APIs, Front-End Integration",
"tweet": "Django cleans up tests automagically. FastAPI doesn't. Let's find out why and fix it.",
"website_url": "https://ep2026.europython.eu/session/djangos-magic-fastapis-reality-test-isolation-at-scale",
"youtube_url": null
},
"YUECR3": {
"abstract": "Enjoy Friday's lightning talks! Short talks about everything by everyone. \r\n\r\nLightning talks are 5 minute talks that anyone participating at the conference can submit.\r\nIf that talk gets selected, you will have the chance to jump into the main stage and show us your project, your ideas, something you have learned, something you are proud of that's helping and contributing to our conference and community, or something else!\r\n\r\nLightning talks last a maximum of 5 minutes. You can use less time, but not more.\r\nThis time limit is strictly enforced!\r\n\r\nIf you get accepted, you will be notified by email on the day of your talk by 1pm.\r\nReply to the acceptance email by 3pm to confirm your spot.\r\n(If you don't, you lose your spot!)\r\n\r\nYou can submit your lightning talk on this form: TBD\r\nNote that there's a limit of one submission per person.",
"code": "YUECR3",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T17:25:00+02:00",
"level": "beginner",
"next_session": null,
"prev_session": "8XMJGZ",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Announcements",
"sessions_after": [],
"sessions_before": [
"8XMJGZ",
"BPJHWT",
"BX77EE",
"GP39VP",
"LRVCYU",
"MP9ZRM",
"U7AHP3",
"WHHAQK"
],
"sessions_in_parallel": [],
"slug": "lightning-talks-friday",
"speakers": [],
"start": "2026-07-17T16:55:00+02:00",
"title": "Lightning talks \u26a1 Friday",
"track": null,
"tweet": "Enjoy Friday's lightning talks! Short talks about everything by everyone. Lightning talks are 5 minute talks that anyone participating at the confer",
"website_url": "https://ep2026.europython.eu/session/lightning-talks-friday",
"youtube_url": null
},
"ZFJEUJ": {
"abstract": "Pandas now natively supports PyArrow-backed data types. But what does that actually mean? If you've ever wondered how these two libraries relate to each other, whether they compete or complement each other, and what happens to your data when it moves between them, this talk is for you.\r\n\r\nAs PyArrow maintainers, we took on the challenge of digging into the conversion code between PyArrow and Pandas, and we're here to share what we've learned. We'll show you what's really going on under the hood: how Arrow's columnar format differs from Pandas' block-based memory layout (including what a BlockManager actually is), when data can be shared without copying, and when a full copy is unavoidable.\r\n\r\nWe'll also clarify what each library is designed for and how they work together rather than against each other. With pandas increasingly adopting PyArrow as a backend, understanding this relationship is becoming essential rather than optional.\r\n\r\nThis talk is aimed at Python developers and data engineers who want to deepen their understanding of what's happening beneath the surface.",
"code": "ZFJEUJ",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T15:05:00+02:00",
"level": "intermediate",
"next_session": "MP9ZRM",
"prev_session": "VSZSMW",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Talk",
"sessions_after": [
"BPJHWT",
"LRVCYU",
"MP9ZRM",
"ZHCNDY"
],
"sessions_before": [
"7NWR9R",
"BX77EE",
"GP39VP",
"PBTPJR",
"RGBSS8",
"U7AHP3",
"UGLF7Q",
"VSZSMW"
],
"sessions_in_parallel": [
"NTZ7DG",
"QY7PFR",
"T7ATVM",
"WHHAQK"
],
"slug": "stop-guessing-start-understanding-how-arrow-and-pandas-exchange-data",
"speakers": [
"EMFTT7",
"ZDP7FM"
],
"start": "2026-07-17T14:35:00+02:00",
"title": "Stop Guessing, Start Understanding: How Arrow and Pandas Exchange Data",
"track": "Data Engineering and MLOps",
"tweet": "Ever wondered what happens when your data moves between Arrow and Pandas? We dug into the code so you don't have to.",
"website_url": "https://ep2026.europython.eu/session/stop-guessing-start-understanding-how-arrow-and-pandas-exchange-data",
"youtube_url": null
},
"ZHCNDY": {
"abstract": "Open source maintainers are drowning in a new kind of noise. \"AI\"-generated pull requests \u2014 superficial, poorly reasoned, and submitted without genuine understanding of the codebase \u2014 are consuming review bandwidth that was already scarce. These contributions range from cosmetic \"improvements\" that introduce subtle bugs to elaborate refactorings that no one asked for, all bearing telltale signs of LLM output: confident tone, plausible-looking code, and zero awareness of project conventions.\r\n\r\nThis talk presents a practical, battle-tested framework for combating \"AI\" slop without discouraging legitimate contributors. Drawing from real experiences maintaining pip-tools, aiohttp, ansible-core, CherryPy, and other Python projects, I'll share concrete strategies that work today.\r\n\r\nFirst, we'll dissect the anatomy of \"AI\" slop PRs \u2014 what they look like, why they pass superficial review, and the hidden costs beyond wasted review time: CI compute waste, security risks from plausible-but-wrong code, and the demoralizing effect on genuine contributors who see low-effort submissions getting attention.\r\n\r\nThen I'll walk through a defense-in-depth approach being developed across my projects: updating `CONTRIBUTING.md` with explicit expectations about understanding the codebase before submitting changes; crafting repository-level LLM instruction files (like `AGENTS.md`/`CLAUDE.md`) that steer \"AI\" tools toward project-specific conventions; configuring PR templates to require evidence of human reasoning; and establishing community norms that set quality expectations without being hostile to newcomers.\r\n\r\nWe'll also tackle the harder questions: Where is the line between \"AI\"-assisted (the human drives and understands the change) and \"AI\"-generated (the human clicks \"submit\" on LLM output)? How do we preserve the welcoming culture that makes open source special while defending against low-effort spam? What should platforms like GitHub improve for maintainers?\r\n\r\nYou'll leave with a ready-to-adapt policy template and configuration files for your own projects.",
"code": "ZHCNDY",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-17T16:00:00+02:00",
"level": "beginner",
"next_session": "8XMJGZ",
"prev_session": "QY7PFR",
"resources": null,
"room": "Auditorium Hall (S1)",
"session_type": "Talk",
"sessions_after": [
"8XMJGZ"
],
"sessions_before": [
"BX77EE",
"GP39VP",
"NTZ7DG",
"QY7PFR",
"T7ATVM",
"U7AHP3",
"WHHAQK",
"ZFJEUJ"
],
"sessions_in_parallel": [
"BPJHWT",
"LRVCYU",
"MP9ZRM"
],
"slug": "defending-open-source-from-ai-slop-a-maintainer-s-practical-guide",
"speakers": [
"AWKFRJ"
],
"start": "2026-07-17T15:30:00+02:00",
"title": "Defending Open Source from \"AI\" Slop: A Maintainer's Practical Guide",
"track": "Ethics, Social Responsibility, Sustainability, Legal",
"tweet": "\"AI\"-generated PRs are flooding open source. A practical framework for defending your projects \u2014 with policy templates you can adopt today.",
"website_url": "https://ep2026.europython.eu/session/defending-open-source-from-ai-slop-a-maintainer-s-practical-guide",
"youtube_url": null
},
"ZPCDKE": {
"abstract": "Implementing high-performance deep learning models often feels like a struggle between readable Python code and the low-level optimizations required for modern GPUs and TPUs. JAX bridges this gap by treating neural networks as pure mathematical transformations. In this session, we will move beyond the abstractions of high-level frameworks to build a Denoising Diffusion Probabilistic Model (DDPM) from the ground up.\r\n\r\nWe will explore how JAX\u2019s functional programming paradigm is uniquely suited for the stochastic nature of diffusion. You will learn how to:\r\n\r\n- Master the JIT (Just-In-Time) compilation: See how @jax.jit transforms Python functions into optimized XLA kernels for massive speedups.\r\n- Leverage Vectorized Mapping: Use @jax.vmap to handle data parallelism across batches without the overhead of manual loops.\r\n- Dissect the Diffusion Pipeline: Step through the forward noise process (SDEs) and the reverse denoising process (Score-matching).\r\n- Manage State and PRNGs: Navigate JAX\u2019s unique, explicit handling of random number generation and stateless transformations.\r\n\r\nThis tutorial is designed for Python developers and ML engineers who want to understand the \"how\" and \"why\" behind state-of-the-art text-to-image models. You will leave with a deep understanding of the diffusion objective and the practical skills to deploy high-performance model architectures using the JAX ecosystem.",
"code": "ZPCDKE",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-14T12:45:00+02:00",
"level": "intermediate",
"next_session": "ZSRZPC",
"prev_session": null,
"resources": null,
"room": "Conference Hall Complex B (S4B)",
"session_type": "Tutorial",
"sessions_after": [
"3TZHB9",
"K7XNTF",
"N39TFS",
"ZSRZPC"
],
"sessions_before": [],
"sessions_in_parallel": [
"3FDLUS",
"BTTFFJ",
"MENRZG",
"TGGHKC"
],
"slug": "let-it-rip-a-diffusion-tutorial",
"speakers": [
"7T3KC8"
],
"start": "2026-07-14T09:30:00+02:00",
"title": "Let it rip a diffusion tutorial",
"track": "Machine Learning, NLP and CV",
"tweet": "Build a DDPM from scratch using JAX. This talk covers JIT compilation, vmap for batching, and bridging the gap between math and GPU/TPU optimization.",
"website_url": "https://ep2026.europython.eu/session/let-it-rip-a-diffusion-tutorial",
"youtube_url": null
},
"ZRWENU": {
"abstract": "APIs development start simple, feel fast, and ship quickly. Then the API grows: more endpoints, more traffic, more data, and suddenly performance becomes unpredictable. Latency creeps in, async code blocks without anyone noticing, and every new feature feels a little riskier to add.\r\n\r\nThis talk is about building Python APIs that stay fast *as they evolve*.\r\n\r\nWe\u2019ll look at where performance issues really come from in real-world APIs: request lifecycle overhead, hidden blocking calls, dependency injection costs, serialization, and poorly scoped middleware. Instead of chasing micro-optimizations or benchmark numbers, we\u2019ll focus on design decisions that make performance predictable.\r\n\r\nUsing Litestar as a concrete example, you\u2019ll see how explicit control over routing, dependencies, and async execution helps avoid common performance traps. We\u2019ll walk through realistic API patterns and show how to structure handlers and dependencies so performance problems don\u2019t slowly accumulate.\r\n\r\nYou\u2019ll leave with practical techniques you can apply immediately, whether you\u2019re building a new API or maintaining one in production. Even if you don\u2019t use Litestar today, the design principles in this talk will help you reason more clearly about performance in any Python API.",
"code": "ZRWENU",
"delivery": "in-person",
"duration": "30",
"end": "2026-07-15T15:55:00+02:00",
"level": "beginner",
"next_session": "H7DVRJ",
"prev_session": "HJ8KPY",
"resources": null,
"room": "Chamber Hall A (S3A)",
"session_type": "Talk",
"sessions_after": [
"H7DVRJ",
"JEN7WA",
"TWBDVZ",
"X3ENDU",
"Y3DGWB"
],
"sessions_before": [
"33RGZA",
"7VKQQM",
"ENK9EF",
"HJ8KPY",
"HVTSPC",
"LNVDY3",
"PRGGNW",
"SWCWKZ"
],
"sessions_in_parallel": [
"H7KGU3",
"PCMBVT",
"RMY7Y7",
"WKBHZW"
],
"slug": "designing-performant-apis-with-litestar",
"speakers": [
"8BQEZZ"
],
"start": "2026-07-15T15:25:00+02:00",
"title": "Designing Performant APIs with Litestar",
"track": "Web Development, Web APIs, Front-End Integration",
"tweet": "Your API started fast, then grew slow. Learn design patterns to keep Python APIs performant at scale, using Litestar to avoid common bottlenecks",
"website_url": "https://ep2026.europython.eu/session/designing-performant-apis-with-litestar",
"youtube_url": null
},
"ZSRZPC": {
"abstract": "This tutorial will introduce fundamentals of security research and CodeQL when looking for security vulnerabilities in software. We'll share how to look for vulnerabilities in code and how to use static analysis to help us find sources, sinks and vulnerabilities.\r\n\r\nUsing an example of a vulnerability in an open source project that the speaker has found, CVE-2024-32022, we will walk through how we could detect it manually by reading code, learn how to write CodeQL, and by the end write a CodeQL query to find this vulnerability and its variants.",
"code": "ZSRZPC",
"delivery": "in-person",
"duration": "180",
"end": "2026-07-14T17:00:00+02:00",
"level": "intermediate",
"next_session": null,
"prev_session": "ZPCDKE",
"resources": null,
"room": "Conference Hall Complex B (S4B)",
"session_type": "Tutorial",
"sessions_after": [
"3APM9B"
],
"sessions_before": [
"3FDLUS",
"BTTFFJ",
"MENRZG",
"TGGHKC",
"ZPCDKE"
],
"sessions_in_parallel": [
"3TZHB9",
"K7XNTF",
"N39TFS"
],
"slug": "introduction-to-security-research-find-a-cve-with-codeql",
"speakers": [
"CDSVUM"
],
"start": "2026-07-14T13:45:00+02:00",
"title": "Introduction to security research. Find a CVE with CodeQL.",
"track": "Testing, Quality Assurance, Security",
"tweet": "Learn how to find security vulnerabilities at Introduction to security research. Find a CVE with CodeQL tutorial",
"website_url": "https://ep2026.europython.eu/session/introduction-to-security-research-find-a-cve-with-codeql",
"youtube_url": null
}
}