Uploaded August 2026 | Updated September 2026, 2 weeks ago
[EuroPython 2026 - S3B on 2026-07-16]
🎤 *Deploying Python Web Apps in 2026 by Will Vincent*
🔗 https://ep2026.europython.eu/session/deploying-python-web-apps-in-2026
📝 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.
We 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.
The 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.
---
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: creativecommons.org/licenses/by-nc-sa/4.0
[EuroPython 2026 - S3B on 2026-07-16]
🎤 *Deploying Python Web Apps in 2026 by Will Vincent*
🔗 https://ep2026.europython.eu/session/deploying-python-web-apps-in-2026
📝 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.
We 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.
The 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.
---
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: creativecommons.org/licenses/by-nc-sa/4.0
![How to Talk With Your Legal Department About Open Source - Vladimir Slavov
[EuroPython 2026 - S3A on 2026-07-15]
🎤 *How to Talk With Your Legal Department About Open Source by Vladimir Slavov*
🔗 https://ep2026.europython.eu/session/how-to-talk-with-your-legal-department-about-open-source
📝 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 ones 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.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ How to Talk With Your Legal Department About Open Source - Vladimir Slavov](https://i.ytimg.com/vi/R1DpTUzy0_o/mqdefault.jpg)


![Keynote: How to Run 160 KM: Building Resilience When Things Feel Hard - Leah Wasser
[EuroPython 2026 - Keynote - S1 on 2026-07-16]
🎤 *How to Run 160 KM: Building Resilience When Things Feel Hard by Leah Wasser*
🔗 https://ep2026.europython.eu/session/how-to-run-160-km-building-resilience-when-things-feel-hard
📝 Abstract:
What does running 160km (100 miles) have to do with open source? Everything. Both demand that you show up consistently, put in the work, and keep moving forward—even when the path feels uncertain and even when people tell you it cant be done. This talk draws on my journey as an ultrarunner, a data-driven ecologist in a field dominated by traditional fieldwork, and a founder of a nonprofit effort that leverages community as both a support system and a powerful force to tackle hard technical problems. I’ll share my journey and what it really takes to build resilience in the face of uncertainty. Youll leave with a simple framework for moving forward when the path is unclear and the world is rapidly changing. You’ll leave with a better understanding of how to find the signal through the noise and how to build toward something bigger than yourself, one step at a time, and why the people around you are your most powerful resource.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ Keynote: How to Run 160 KM: Building Resilience When Things Feel Hard - Leah Wasser](https://i.ytimg.com/vi/RWUspvMe5DA/mqdefault.jpg)
![Python in the Service of Justice: Modern Analysis Tools in Forensics - Aleksander, Amelia Bartosiak
[EuroPython 2026 - S2 on 2026-07-17]
🎤 *Python in the Service of Justice: Modern Analysis Tools in Forensics by Aleksander, Amelia Bartosiak*
🔗 https://ep2026.europython.eu/session/python-in-the-service-of-justice-modern-analysis-tools-in-forensics
📝 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:
- mobile device analysis,
- network traffic examination,
- memory forensics,
- automated report generation.
We 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.
Memory 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.
Data 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.
The 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.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ Python in the Service of Justice: Modern Analysis Tools in Forensics - Aleksander, Amelia Bartosiak](https://i.ytimg.com/vi/Rh6eodtLGSM/mqdefault.jpg)

![The Self-Healing Web: Designing Resilient, Typo-Proof URLs - Dominic Hollis
[EuroPython 2026 - S3A on 2026-07-16]
🎤 *The Self-Healing Web: Designing Resilient, Typo-Proof URLs by Dominic Hollis*
🔗 https://ep2026.europython.eu/session/the-self-healing-web-designing-resilient-typo-proof-urls
📝 Abstract:
Are you a user of a popular web application who gets frustrated when you encounter a poorly formatted URL resulting in a 404 error? Or are you a developer who just wants a nice way to make your app more user-friendly? Look no further, a self-healing URL _may_ be the solution to your problems.
This talk explores the core principles of self-healing URLs - a URL routing strategy that treat unique identifiers in the URL as the source of truth, while allowing human-readable portions to be flexible or even missing. We will also examine the architectural patterns and logic required to resolve these broken paths, such as partial string (fuzzy) matching.
Using the flask-selfheal package as a practical showcase, Ill show you how these concepts can be implemented in a real-world web application. We’ll also look under the hood at how to teach a routing engine to recognise a users intent and automatically redirect them to the correct URL.
By the end of the talk, you will understand what a self-healing URL is and how it can be implemented in your own web applications, regardless of the language or framework you are using.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ The Self-Healing Web: Designing Resilient, Typo-Proof URLs - Dominic Hollis](https://i.ytimg.com/vi/Rz8XymBnA7U/mqdefault.jpg)
![Rust for High Performance Computing (HPC) in Python - Cheuk Ting Ho
[EuroPython 2026 - S1 on 2026-07-15]
🎤 *Rust for High Performance Computing (HPC) in Python by Cheuk Ting Ho*
🔗 https://ep2026.europython.eu/session/rust-for-high-performance-computing-hpc-in-python
📝 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.
Enhancing Pythons 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.
In 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’ll explore how Rust brings specific advantages to HPC, including guaranteed memory safety without garbage collection, zero-cost abstractions, and true parallelism.
Attendees 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.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ Rust for High Performance Computing (HPC) in Python - Cheuk Ting Ho](https://i.ytimg.com/vi/S-0DF1bi6nI/mqdefault.jpg)
![Refactor, Optimize, and Test: Crafting Cleaner Python Code - Mohamed Elmaghraby
[EuroPython 2026 - S4 on 2026-07-17]
🎤 *Refactor, Optimize, and Test: Crafting Cleaner Python Code by Mohamed Elmaghraby*
🔗 https://ep2026.europython.eu/session/refactor-optimize-and-test-crafting-cleaner-python-code
📝 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.
This 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.
Whether youre 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.
This session is inspired by Martin Fowlers seminal works on refactoring and Python-specific insights shared at EuroPython 2024.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ Refactor, Optimize, and Test: Crafting Cleaner Python Code - Mohamed Elmaghraby](https://i.ytimg.com/vi/SIq-ZnJ9D6k/mqdefault.jpg)
![SPy: high-level Python, low-level performance, no overhead - Antonio Cuni
[EuroPython 2026 - S3B on 2026-07-17]
🎤 *SPy: high-level Python, low-level performance, no overhead by Antonio Cuni*
🔗 https://ep2026.europython.eu/session/spy-high-level-python-low-level-performance-no-overhead
📝 Abstract:
SPy is a Python variant designed for compilation: well-specified, debuggable, and expressive. It consists of a low-level core which gives control and speed comparable to C, Rust and Go, and powerful metaprogramming features which make possible to build high-level zero-cost abstractions. The result is something which is statically typed and as fast as C, but with the feeling and ease of Python.
This talk is a deep dive into the SPy core ideas: in particular, we will explore the internals of the language, show how many builtins are implemented in SPy itself, what zero cost abstraction means in practice and some end-to-end example of how high-level Python code is compiled into a low-level fast executable.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ SPy: high-level Python, low-level performance, no overhead - Antonio Cuni](https://i.ytimg.com/vi/SJ8Ws8Xv9jA/mqdefault.jpg)
![Lazy imports and the art of interpreter procrastination - Pablo Galindo Salgado, Noah Kim
[EuroPython 2026 - S1 on 2026-07-17]
🎤 *Lazy imports and the art of interpreter procrastination by Pablo Galindo Salgado, Noah Kim*
🔗 https://ep2026.europython.eu/session/lazy-imports-and-the-art-of-interpreter-procrastination
📝 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.
After 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 Pythons history, and finally its here.
This presentation will take you through how we got here and where were going. Well 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.
The heart of this talk is discovering how lazy imports actually work inside the interpreter. Well 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. Youll also learn about the future tooling that we are baking that will help you adopt this safely in your own projects.
Whether youre a beginner curious about Pythons future, someone looking to speed up your CLI tools, or you just want to understand whats happening under the hood, this talk will give you everything you need to start using lazy imports with confidence.
This work is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License: https://creativecommons.org/licenses/by-nc-sa/4.0/ Lazy imports and the art of interpreter procrastination - Pablo Galindo Salgado, Noah Kim](https://i.ytimg.com/vi/SavVPtsqUf0/mqdefault.jpg)