There's a few popular ways in which we can "see" sound. But what do you actually see on those visualizations?
\nIn this talk\, we'll be building short PyScript programs utilizing WebGL for attractive visualization display. We'll cover two fundamental methods (amplitude measurement and frequency spectrum display) and the many fun ways in which those two can be used. We'll start by looking at simple sounds with offline batch processing to represent the audio graphically. We'll finish with realtime audio visualization.
\nSpeakers:\nŁukasz Langa\nFailed comedian. CPython Developer in Residence. Wannabe musician. Python 3.8 &\; 3.9 release manager. Co-host of the core.py podcast. Original creator of Black. Dad.
DTEND:20250517T181500Z LOCATION:Ballroom A DTSTART:20250517T173000Z STATUS:CONFIRMED SUMMARY:[talk] Looking At Audio TRANSP:OPAQUE UID:bffa3522-4629-5e7c-ac08-0433874a4508 URL:https://us.pycon.org/2025/schedule/presentation/103/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Unlocking Python's Power: A Practical Guide to Metaprogramming with Decorators\, Metaclasses\, and Dynamic Code Generation\nhttps://us.pycon.org/2025/schedule/presentation/102/\nThis presentation delves into advanced Python programming techniques related to metaprogramming\, which allow developers to write code that can evaluate\, modify\, or build upon other code.
\nWe will explore key metaprogramming constructs—decorators\, metaclasses\, and dynamic code generation—through practical examples and real-world applications. \nThis session will provide the audience with the tools and insights to take advantage of the most advanced Python programming techniques to help them plan\, optimize workflows\, or write dynamic applications\nPerfect for intermediate to advanced developers who are ready to take their coding skills to the next level!
\nSpeakers:\nAditya Mehra\nAditya Mehra is a Senior Software Architect with over 17 years of extensive experience in the IT industry. A Computer Science Engineering graduate\, he has delivered numerous talks at Python conferences across the globe.
\nAn active member of the Python Software Foundation\, Aditya is deeply committed to the Python community. He is passionate about mentorship and teaching\, conducting free\, weekly online Python classes for people across the globe. \nHe has also volunteered at multiple Python events across the globe\, consistently contributing to the growth and success of the community.
\nAditya has written several journals on cutting-edge technologies and holds three registered patents and publishes a weekly newsletter on Python and technology and contributes articles to Medium and other public platforms \, showcasing his dedication to innovation and advancing the field of technology.
DTEND:20250516T210000Z LOCATION:Room 301-305 DTSTART:20250516T203000Z STATUS:CONFIRMED SUMMARY:[talk] Unlocking Python's Power: A Practical Guide to Metaprogramming with Decorators\, Metaclasses\, and Dynamic Code Generation TRANSP:OPAQUE UID:b420fd97-db8e-5fe3-a020-238c8e5ba39c URL:https://us.pycon.org/2025/schedule/presentation/102/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Painting with Python\nhttps://us.pycon.org/2025/schedule/presentation/156/\nIn this talk\, we'll cover the basics of making visual algorithmic art with Python using only basic dependencies (like Python Image Library / Pillow). No GPU acceleration. No AI. Just simple vanilla Python code. Come learn the basics from a hacker-turned-artist who repurposed math he learned doing IoT radio hacking to do visual art.
\nSpeakers:\nCaleb Madrigal\nCaleb is a hacker-turned artist who now does mathy lenticular holograms with Python (https://gods.art). He also does AI/ML consulting by day (https://madconsulting.ai). He used to build cyber weapon at Mandiant. Caleb is really into waves and fractals.
DTEND:20250517T213000Z LOCATION:Room 301-305 DTSTART:20250517T210000Z STATUS:CONFIRMED SUMMARY:[talk] Painting with Python TRANSP:OPAQUE UID:2646a198-b51a-5f11-8dff-19bef528655d URL:https://us.pycon.org/2025/schedule/presentation/156/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: You can and Should Build XKCD's "Sky Alarm" for Cool Space Things\nhttps://us.pycon.org/2025/schedule/presentation/16/\nXKCD is a webcomic by Randall Munroe\, and in one of his comics there is a "Sky Alarm". It features a small box with a light on top of it\, and it goes "weeee ooooo" when a "Cool Space Thing [is] Happening!".
\nIf you want one\, I've got great news: you can build one and it can run on Python!
\nCircuit Python let's us extend the Python we know and love into the world around us\, and we can use that extension to build alarms when "Cool Space Things" happen. Or by adding a sensor or two\, we can have it respond to things in our environment.
\nThis talk walks through a basic build of a "Sky Alarm" using Circuit Python. We'll highlight fetching data\, selecting a micro controller\, making it respond to data on a local server\, and adding sensors\, and logging data from those sensors for plotting\, displays\, or more complex functions and analysis. Focusing on a solder free build\, this will give you the tools you need to bring Python into the physical spaces around you without needing to be an expert when it comes to electronics and electrical engineering.
\nSpeakers:\nKeith Murray\nI've been using Python since 2012 and focus on bioinformatics. With Circuit Python I have enjoyed bring Python into my home\, creating a 'somewhat smart' home\, and more than that\, I've enjoyed recording and analyzing data that I can actively change and impact so I can more rapidly understand a complex algorithm as it impacts values I have an intuitive sensor for.
\nBeing active in online communities\, and PyOhio\, I enjoy seeing others build amazing things with Python\, and as Python become more browser based\, mobile deployed\, and embedded\, I'm really excited to see what people build.
DTEND:20250517T190000Z LOCATION:Ballroom A DTSTART:20250517T183000Z STATUS:CONFIRMED SUMMARY:[talk] You can and Should Build XKCD's "Sky Alarm" for Cool Space Things TRANSP:OPAQUE UID:8b2678de-cdc9-523f-9b74-5362b4ce6c92 URL:https://us.pycon.org/2025/schedule/presentation/16/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Reduce the environmental footprint of your Python programs\nhttps://us.pycon.org/2025/schedule/presentation/80/\nAs we witness the cutting-edge developments in Artificial Intelligence\, the carbon footprint of our code base can no longer be brushed off as insignificant. In every respect\, as developers\, we have a responsibility to take the lead in implementing sustainable coding practices. This presentation explores Python techniques that can be embedded in one’s code that will help reduce cycles\, lower resource dependencies\, and decrease energy usage without degrading performance.
\nMore than just tech tips\, this talk is going to focus on the why—looking into the expanding CO2 of the AI and tech space\, what it means for our planet\, and how it points to the importance of responsible development. The audience will discover that simple but conscious changes in one’s handy work\, such writing better algorithms\, datamodelling\, and using greener tools can somehow make a positive impact to the environment.
\nThis talk is not only about utilizing new technologies correctly\, it is also about changing the perception of our field. Let’s be responsible — let’s develop projects that will not harm the environment. Together\, we can progress and adapt our development processes to the current climate change crisis – the one in which development and innovative efforts go hand in hand with taking care of the environment. So let’s code with purpose.
\nSpeakers:\nApoorv Garg\nSoftware Developer at Wells Fargo with a passion for open-source and impactful projects. A Google Summer of Code (GSoC '22\, '23\, '24) participant and Mentor\, I’ve contributed to organizations like Hugging Face\, JdeRobot\, and C4GT. Previously\, I worked with Resilient AI Solution\, Talkdoc\, and interned as an SDE at Deloitte. I’m an alumnus of Amazon ML Summer School 2022 and a 2023 graduate of NSUT\, with a strong focus on building scalable\, efficient\, and maintainable software solutions.
DTEND:20250517T163000Z LOCATION:Room 301-305 DTSTART:20250517T160000Z STATUS:CONFIRMED SUMMARY:[talk] Reduce the environmental footprint of your Python programs TRANSP:OPAQUE UID:9daf72ab-21fd-5c8c-82be-82aa3e2ee9a9 URL:https://us.pycon.org/2025/schedule/presentation/80/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Inclusive Data for 1.3 Billion: Designing Accessible Visualizations\nhttps://us.pycon.org/2025/schedule/presentation/43/\nAccording to the World Health Organization (WHO)\, an estimated 1.3 billion people (1 in 6 individuals) experience a disability\, and nearly 2.2 billion people (1 in 5 individuals) have vision impairment. Improving the accessibility of visualizations will enable more people to participate in and engage with our data analyses.
\nIn this talk\, we’ll discuss some principles and best practices for creating more accessible data visualizations. It will include tips for individuals who create visualizations\, as well as guidelines for the developers of visualization software to help ensure your tools can help downstream designers and developers create more accessible visualizations.
\nSpecifically\, we will cover:
\nThis talk will use examples from our ongoing work to improve the accessibility of Bokeh\, a Python library for creating interactive data visualizations for web browsers. We hope this talk enables you to take the first few steps in making your next data visualization and your visualization tools\, more accessible.
\nSpeakers:\nPavithra Eswaramoorthy\nPavithra Eswaramoorthy is a Developer Advocate at Quansight\, where she works to improve the developer experience and community engagement for several open source projects in the PyData community. Currently\, she maintains the Bokeh visualization library\, and contributes to the Nebari (adjacent to the Jupyter community)\, and conda-store (part of the conda ecosystem).
\nPavithra has been involved in the open source community for over 5 years\, notable as an emeritus contributor to the Dask library and Wikimedia Foundation projects. In her spare time\, she enjoys a good book and hot coffee. :)
\nFrank Elavsky\nFrank is a PhD student and researcher at the Human-Computer Interaction Institute at Carnegie Mellon University and a consultant whose past collaborations include Apple's Human-Centered Machine Learning research group\, Adobe\, Microsoft\, Visa\, Highcharts\, and others. Frank's work lies at the intersection of interactive data visualization and accessibility\, making analytical work more accessible for and alongside people with disabilities. His projects include Chartability\, a framework for helping practitioners evaluate inaccessible visualizations and Data Navigator\, a tool that helps creators make interactive visualizations more accessible for users of assistive technologies. He also advises the Accessible\, Rich\, Internet Applications (ARIA) standards working group as an invited expert in data visualization.
DTEND:20250516T191500Z LOCATION:Ballroom BC DTSTART:20250516T184500Z STATUS:CONFIRMED SUMMARY:[talk] Inclusive Data for 1.3 Billion: Designing Accessible Visualizations TRANSP:OPAQUE UID:dbca4363-10c1-527d-a9ee-818c1f682b7c URL:https://us.pycon.org/2025/schedule/presentation/43/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Type Hints in Real-World Projects: Practical Steps for Continuous Maintenance and Improvement\nhttps://us.pycon.org/2025/schedule/presentation/13/\nMany Python developers have added type hints and run mypy checks\, but still rely on typing.Any too often\, keep old typing.List/typing.Dict hints\, or use # type: ignore comments everywhere. In that case\, typing may feel like just another task\, not a tool that truly improves quality.
But like unittest\, typing can reduce hidden issues and make you confident about changes\, even though it does not add new features directly. If we maintain and improve our type hints over time\, typing can become a reliable foundation for your project\, making refactoring safer and Python upgrades smoother.
\nThis talk is not just another basic intro. We’ll show practical steps with before-and-after code examples:\n- Use ideas from newer features (like typing.TypeIs in Python 3.13) and typing_extensions to apply similar concepts on older versions.
\n- Run pyupgrade (via ruff) to automatically update old hints\, reducing manual edits and creating a consistent style.
\n- Apply partial ignores instead of full # type: ignore\, and integrate pre-commit and CI checks to catch issues early\, making typing checks feel natural.
\n- Add types to example code to detect subtle incompatibilities\, similar to how tests find hidden bugs.
We’ll also propose a gradual approach so your team won’t be overwhelmed. After this talk\, you should see typing as a stable base that reduces bugs\, helps with refactoring\, and supports long-term growth.
\nWho should attend this talk?
\nThis talk is for intermediate Python developers who already use basic type hints but feel they are not getting enough value out of them yet. If you want to go beyond minimal checks and keep your typing strong as your project grows\, this session will show you practical steps you can take.
I am a software developer based in Tokyo\, with a strong focus on Python. I enjoy contributing to Open Source Software (OSS) with a goal to make the development environment friendlier.
DTEND:20250517T181500Z LOCATION:Hall C DTSTART:20250517T174500Z STATUS:CONFIRMED SUMMARY:[talk] Type Hints in Real-World Projects: Practical Steps for Continuous Maintenance and Improvement TRANSP:OPAQUE UID:b9b6607d-6974-594f-8e99-ac3de71c4d89 URL:https://us.pycon.org/2025/schedule/presentation/13/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Marimo: A Notebook that "Compiles" Python for Reproducibility and Reusability\nhttps://us.pycon.org/2025/schedule/presentation/18/\nThis talk explores the following question: What would it take to create a new kind of Python notebook that\, unlike a REPL\, knew the order in which to run cells? What if the notebook could also update automatically or lazily when a variable was updated? And what if we could add UI elements\, like sliders and dropdowns\, to all this? Would this change how you worked with notebooks?
\nBut most of all: how would you build such a thing? In this talk\, we propose that you would need a kind of "compiler" on top of Python.
\nThis talk focuses on how to create such a notebook by using marimo — an open-source reactive notebook for Python that's executable as scripts and shareable as apps — as a case study. Marimo's key technology is static analysis: marimo "compiles" blocks of Python code\, or "cells"\, to a directed acyclic graph. This graph models how data flows across cells\, and is used as an intermediate representation consumed by a runtime that eliminates hidden state while also powering interactive computing\, scripts\, and web apps.
\nBy using notebooks and marimo's internals as a case study\, we'll examine a question that is broadly applicable to developer tools in many domains: What does it take to compile Python code to a flexible intermediate representation that preserves the original program's semantics? We'll discuss design decisions and tradeoffs along the way\, such as the pros and cons of static analysis versus runtime tracing.
\nSpeakers:\nAkshay Agrawal\nAkshay builds open source software designed to make machine learning and data science actionable and accessible. He works full-time on the open-source marimo notebook.
\nHe is both a researcher\, focusing on machine learning and optimization\, and an engineer\, having contributed to several open source projects (including TensorFlow and CVXPY). He has a PhD from Stanford University\, and BS/MS in computer science from Stanford.
DTEND:20250516T171500Z LOCATION:Ballroom BC DTSTART:20250516T163000Z STATUS:CONFIRMED SUMMARY:[talk] Marimo: A Notebook that "Compiles" Python for Reproducibility and Reusability TRANSP:OPAQUE UID:f6d5d99e-cfd8-5ce2-825d-900ed8d255b6 URL:https://us.pycon.org/2025/schedule/presentation/18/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Python: The Architect's Secret Weapon\nhttps://us.pycon.org/2025/schedule/presentation/87/\nThe built environment is undergoing a digital revolution\, and Python is at the forefront. This talk will explore how Python\, combined with open-source tools like Blender\, OpenUSD\, and Dynamo\, is transforming the way we design\, analyze\, and construct buildings.
\nWe'll delve into practical applications\, from generating 3D models to performing energy simulations and creating stunning visualizations. You'll learn how to harness the power of Python to address pressing challenges in the construction industry\, such as climate change\, resource scarcity\, and urban development.
\nSo if you're interested in how Python can shape the built environment then come and see for yourself!
\nKey Takeaways:
\nWith a background in Architecture and Development Tadeh has supported building large scale projects with diverse teams for over 10 years. By promoting open dialogue\, systems thinking\, and long term planning he has improved operational efficiencies in all his endeavors. He is a course author\, trainer\, and open source contributor as well as a speaker at national conferences in technology\, architecture\, design. He loves to talk about the new possibilities with technology and innovation at everyone’s disposal while building communities along the way.
DTEND:20250516T200000Z LOCATION:Ballroom A DTSTART:20250516T193000Z STATUS:CONFIRMED SUMMARY:[talk] Python: The Architect's Secret Weapon TRANSP:OPAQUE UID:6186515d-3998-59f2-b07a-4efc424ed936 URL:https://us.pycon.org/2025/schedule/presentation/87/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: How to build a cross-platform graphical user interface with Python\nhttps://us.pycon.org/2025/schedule/presentation/78/\nIf you need to build a user interface for your Python code\, many guides will tell you that your only options are to use the command line\, or wrap your code in a web interface. However\, there is another option - building a native GUI interface. In fact for some use cases\, a GUI app may be your only option.
\nIn this talk\, you'll learn how to build and run a graphical user interface (GUI) that can run on your desktop\, on your phone\, or in a browser. You'll learn how you can use the BeeWare suite of tools to bootstrap a new GUI project\, develop a GUI interface\, and deploy that app to multiple desktop and mobile platforms\, without making any code changes. You'll learn how to access device hardware like GPS and cameras\; and you'll learn how to distribute your application - including all runtimes and third-party libraries - to others. Lastly\, you'll get a brief introduction to how you can access native platform APIs that don't have a Python API.
\nSpeakers:\nRussell Keith-Magee\nDr Russell Keith-Magee is the founder of the BeeWare project\, a project developing GUI tools and libraries to support the development of Python software on desktop and mobile platforms. He joined the Django core team in 2006\, and was the President of the Django Software Foundation for 5 years. He joined the CPython core team in 2024. He is a frequent speaker at Python and Django conferences around the globe\, sharing his experience as a FLOSS developer\, community maintainer\, and (unsuccessful) startup founder. In his day job\, he is a Principal Engineer at Anaconda\, working on BeeWare in the OSS team.
DTEND:20250517T163000Z LOCATION:Ballroom A DTSTART:20250517T160000Z STATUS:CONFIRMED SUMMARY:[talk] How to build a cross-platform graphical user interface with Python TRANSP:OPAQUE UID:76803812-39d4-52d9-a62b-acb5ea25d73d URL:https://us.pycon.org/2025/schedule/presentation/78/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: A new safe external debugger interface for CPython\nhttps://us.pycon.org/2025/schedule/presentation/134/\nHave you ever needed to debug a Python application in production without stopping it? While tools like GDB make this straightforward for C/C++\, Python developers face unique challenges when attaching debuggers to live processes. This talk introduces PEP 768\, a new proposal for Python 3.14 that adds a safe\, zero-overhead debugging interface to CPython.
\nWe'll explore how the current landscape forces debugging tools to use unsafe methods that can crash interpreters and corrupt memory. Then\, we'll detail how PEP 768 solves these problems by introducing a cooperative debugging protocol that works with the interpreter rather than against it.
\nYou'll learn why attaching debuggers to Python processes is uniquely challenging\, how PEP 768 enables safe debugging through interpreter cooperation\, the technical details of the zero-overhead implementation\, real-world applications\, including live process attachment for pdb and all about the security considerations and safeguards.
\nThis talk will be particularly valuable for tool developers\, system administrators\, and anyone interested in Python internals or debugging techniques. You'll walk away understanding the challenges of live process debugging and how PEP 768 elegantly solves them.
\nSpeakers:\nPablo Galindo Salgado\n-
\nIvona Stojanovic\nIvona Stojanovic is a Software Engineer at Bloomberg. She holds a master's degree from the University of Belgrade\, School of Electrical Engineering. As part of the Python Infrastructure team\, she develops tools that streamline development and enhance efficiency for engineers across the company. Beyond programming\, Ivona is deeply passionate about volunteering and art.
DTEND:20250517T194500Z LOCATION:Hall C DTSTART:20250517T191500Z STATUS:CONFIRMED SUMMARY:[talk] A new safe external debugger interface for CPython TRANSP:OPAQUE UID:84713bd0-d2f4-50f6-a878-cf62266c8079 URL:https://us.pycon.org/2025/schedule/presentation/134/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Cheese Must Stand: Defending the Python Library Ecosystem in 2025\nhttps://us.pycon.org/2025/schedule/presentation/98/\nSupply chain attacks on Python package infrastructure increased in frequency and sophistication in2024. As PyPI comes under threat\, how can we continue to secure our beloved cheese shop through 2025?
\nThe 600k packages in PyPI power sensitive infrastructure in almost every critical industry\, and it's no surprise that the Python library ecosystem is a target. In 2024 alone\, the Ultralytics token compromise and the NP6 combined typosquatting and DLL sideloading attack show the sophistication of these supply chain attacks.
\nIn the first part of this talk (12 minutes)\, we'll look back at these 2024 attacks and also consider examples such as the "revival hijack" attack vector and the 2022 dependency confusion attack on PyTorch. In the second portion (12 minutes)\, we'll dig into some critical developments in this area that have helped to mitigate recent attacks\, such as:
\nWe will also briefly discuss specific insights from developing Chainguard’s Guarded Ecosystems for Python\, an ambitious alternative package index that rebuilds included packages from scratch. The final takeaway: while mitigations exist for these threats\, they're not equally distributed\, and we'll point out low hanging fruit for securing projects and infrastructure (3 minutes).
\nThis talk will be an accessible introduction to an intermediate topic (software supply chain security). Expect some cheesy puns and memes as we deal with this muenster problem—all in excellent taste\, of course.
\nPatrick recently received best speaker at SwampUP 2024. Srishti and Patrick recently teamed up for PyTorch 2024.
\nSpeakers:\nPatrick Smyth\n-
\nSrishti Hegde\nSrishti is a software engineer at Chainguard with expertise in distributed systems and machine learning libraries. She has extensive experience in building minimal\, secure containers for Python projects. As an open-source enthusiast\, she is passionate about the deployment and optimization of AI/ML workloads.
DTEND:20250518T181500Z LOCATION:Room 301-305 DTSTART:20250518T174500Z STATUS:CONFIRMED SUMMARY:[talk] Cheese Must Stand: Defending the Python Library Ecosystem in 2025 TRANSP:OPAQUE UID:17594aa6-64d5-5b6e-b6b3-ff4e1e3e71bf URL:https://us.pycon.org/2025/schedule/presentation/98/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: This Talk Has Been Disabled\nhttps://us.pycon.org/2025/schedule/presentation/130/\nDepending on who you ask\, 15-20% of the world's population has some form of disability. Despite this\, the vast majority of software isn't fully accessible. Building truly accessible systems starts with asking questions. What does it mean to be disabled? How do we know whether people can use our website? And what if our users have access issues that we don't know about?
\nMany of these core concepts are covered by the Web Content Accessibility Guidelines\, which are the governing standard for web accessibility. However\, some scenarios require us to dig a little deeper. We'll look at situations where you might need to think beyond the guidelines\, and some of the resources and tools that you can use to help you do so.
\nFinally\, we'll learn how to meet a variety of different accessibility requirements by breaking down a series of real-world case studies. We'll take a magnifying glass to a household name's user interfaces\, travel back in time to the GeoCities era\, apply some concepts from government press conferences to online content delivery\, hack a life-saving medical device\, and attempt to navigate technical events (and stairs). By the end of the talk\, you should understand why it's important to evaluate the accessibility of your software\, what goes wrong when assessments don't happen\, and how to apply these lessons to design systems that work for everyone.
\nSpeakers:\nDawn Cooper\nDawn likes to tinker with cloud infrastructure and security\, and regularly goes down rabbit holes in a futile search for ways to develop systems that are both reliable and impenetrable. As well as accidental accessibility advocacy\, Dawn can regularly be found sharing knowledge within various tech communities.
\nOutside work\, Dawn is an occasional author\, kitchen alchemist\, and raging sportsball fan.
DTEND:20250516T183000Z LOCATION:Room 301-305 DTSTART:20250516T174500Z STATUS:CONFIRMED SUMMARY:[talk] This Talk Has Been Disabled TRANSP:OPAQUE UID:cca0cc0a-8d45-5ac9-b775-52b84a45cd1d URL:https://us.pycon.org/2025/schedule/presentation/130/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: AI with a Conscience: Building Fair and Transparent Systems in Python\nhttps://us.pycon.org/2025/schedule/presentation/74/\nWith the rise of GPUs and Large Language Models (LLMs)\, Machine Learning (ML) and Artificial Intelligence (AI) have become household names. Python\, known for its simplicity and powerful libraries\, has been at the forefront of this AI revolution\, offering robust tools for model building\, training\, and fine-tuning.
\nHowever\, as AI systems become more embedded in society\, one challenge that has gained increasing attention is "Fairness in AI". Fairness is a complex and widely discussed topic with no one-size-fits-all definition. For example\, imagine a baker dividing a pie: should the larger slice go to the person who worked harder or the one who is hungrier? Similarly\, in AI\, fairness is defined by context\, but it aims to ensure equitable treatment of all individuals or groups impacted by a model’s predictions.
\nML models learn through data. Unfortunately\, more often than not\, data is full of historical inequities\, imbalanced labels\, or skewed representations—that can lead to unfair outcomes. Addressing these biases requires tools that go beyond precision\, accuracy and optimization.
\nIn this talk\, we’ll explore these challenges and go over a demonstration of how Python can help address them using the fairlearn library. Through real-world examples\, we will learn methods to measure fairness using metrics like demographic parity\, equalized odds\, equal opportunity etc. We will also learn to mitigate these biases using GridSearch and ThresholdOptimizer.
\nPrerequisites: Whether you are a Python newbie or a seasoned Pythoniast\, with any level of experience in Machine Learning\, you are welcome to join and explore a piece of the pie!
\nSpeakers:\nSanjana Kandi\nSanjana Kandi is a Senior System Software Engineer at NVIDIA\, specializing in developing tools for data center compliance. With a background in machine learning from her master’s studies at Carnegie Mellon\, Sanjana spends much of her leisure time delving into the fast-evolving world of ML and going hands-on on problem solving. She is a dedicated advocate for women in tech and is deeply committed to advancing diversity and inclusion in the technology sector. Outside her professional life\, she enjoys badminton\, hiking\, and cooking—activities that combine adventure\, fitness\, and creativity.
DTEND:20250517T213000Z LOCATION:Ballroom BC DTSTART:20250517T210000Z STATUS:CONFIRMED SUMMARY:[talk] AI with a Conscience: Building Fair and Transparent Systems in Python TRANSP:OPAQUE UID:4a0c945a-afa8-5189-89c6-2deccebd8adb URL:https://us.pycon.org/2025/schedule/presentation/74/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Make Python Talk\, Make Python Listen\nhttps://us.pycon.org/2025/schedule/presentation/114/\nThird-party packages for Python allow your programs to perform text-to-speech and speech recognition with only a few lines of code. You don't need to understand advanced machine learning algorithms to take advantage of these sophisticated features: even beginners can use these packages. In this talk\, you'll learn the PyTTSx3 and gTTS packages to make your programs talk using your operating system's speech engine. You'll also learn how to use the free\, offline Whisper package to convert audio files into text strings. The straightforward configuration for these packages mean you can start making immediate use of them in your Python applications. Finally\, we cover the yt-dlp package for downloading video and audio files from the web for transcription purposes\, and how all of this is being used by the PyVideo.org website.
\nSpeakers:\nAl Sweigart\nAl Sweigart is a software developer\, author\, artist\, and Fellow of the Python Software Foundation. He has written several programming books for beginners\, including Automate the Boring Stuff with Python\, The Big Book of Small Python Projects\, and The Recursive Book of Recursion. He is the creator of PyAutoGUI\, pyperclip\, and several other open source projects. He lives in Brooklyn\, New York.
DTEND:20250516T170000Z LOCATION:Room 301-305 DTSTART:20250516T163000Z STATUS:CONFIRMED SUMMARY:[talk] Make Python Talk\, Make Python Listen TRANSP:OPAQUE UID:c9e8e711-4c57-57f0-9376-095d44e81a07 URL:https://us.pycon.org/2025/schedule/presentation/114/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Program Your Own Computer in Python\nhttps://us.pycon.org/2025/schedule/presentation/136/\nUsing Python to write code for web applications\, scientific applications\, and data analysis is extremely popular. Those of us who write that sort of code are typically sitting in front of desktop or laptop computers for 6-10 hours a day. And yet\, while we may want those machines to do certain tasks for us\, for some reason it rarely occurs to many of us to use Python to solve problems on those computers rather than the ones in the cloud.
\nPerhaps it's just because the APIs for controlling them are so different\, and it seems difficult to get started.
\nIn this talk I will explain how to use Python to integrate with your desktop environment\; how to schedule tasks\, schedule notifications\, and script the applications you already use. We'll have a focus on macOS for demonstration purposes\, but will also including pointers to similar tools for desktop Linux and Windows.
\nSpeakers:\nGlyph\nAlthough most well-known for being the founder of the Twisted project\, Glyph has also worked on massively multiplayer online games\, dynamic web applications\, enterprise information management software\, and created or contributed to dozens of open source projects\, mostly related to infrastructure. He is currently an independent open source maintainer\, doing weird and fun stuff with Python.
DTEND:20250517T164500Z LOCATION:Hall C DTSTART:20250517T160000Z STATUS:CONFIRMED SUMMARY:[talk] Program Your Own Computer in Python TRANSP:OPAQUE UID:bfdfa523-8a62-56a2-8a6a-a0afdd7f04f6 URL:https://us.pycon.org/2025/schedule/presentation/136/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Intuition vs. Reality: Surprising Truths in Python Performance\nhttps://us.pycon.org/2025/schedule/presentation/55/\nHow often do we trust our instincts when optimizing code? In Python\, performance frequently defies intuition\, leading us to make changes that might slow things down instead of speeding them up. This talk explores surprising truths about Python performance and showcases why measurement tools are essential for finding the real bottlenecks in our code.
\nConsider this: is it faster to count even numbers in a list using len([x for x in arr if x % 2 == 0]) or sum(1 for x in arr if x % 2 == 0)? While one might seem more Pythonic or efficient at first glance\, the performance results might surprise you.
Through an interactive format\, we’ll quiz you on performance scenarios using real-world examples. From counting even numbers to rewriting Python code in Rust\, each case study will challenge assumptions about what makes code faster.
\nPlan:
\nBy the end\, you’ll understand why performance measurements matter and leave with practical insights and tools to improve Python performance systematically.
\nSpeakers:\nArthur Pastel\nHi\, I'm Arthur\, a software engineer based in Paris 🇫🇷🥖
\nI worked as an engineer in a few tech companies over the past years\, mostly building software with Python\, but I'm also passionate about (too ??) many other software fields.
\nI'm an open-source enthusiast and love to contribute when possible. Three years ago\, I built ODMantic\, an ODM for MongoDB and Python. It's a kind of ORM built on top of Pydantic to provide a seamless model definition and integration with FastAPI.
\n2 years ago\, I founded CodSpeed\, a Continuous Performance Analysis solution helping tech companies and Open-Source projects prevent performance issues directly in their CI pipelines.
\nAdrien Cacciaguerra\nHey\, I am Adrien\, a French Software Enfineer for 7 years.
\nI am a co-creator CodSpeed\, a Continuous Performance Analysis solution that helps tech companies and Open-Source projects prevent performance issues directly in their CI pipelines.
\nI am passionate about Developer Experience\, Performance\, Open-Source\, Python\, TypeScript\, and Rust. These passions led me to co-author Swarmion\, an open-source set of tools to develop Serverless micro-services.
DTEND:20250516T183000Z LOCATION:Ballroom A DTSTART:20250516T174500Z STATUS:CONFIRMED SUMMARY:[talk] Intuition vs. Reality: Surprising Truths in Python Performance TRANSP:OPAQUE UID:1604bfeb-dd14-52d5-87d5-922dea42209d URL:https://us.pycon.org/2025/schedule/presentation/55/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: The Zen of Polymorphism: Choosing between isinstance()\, methods\, and @singledispatch\nhttps://us.pycon.org/2025/schedule/presentation/99/\nPython is a multi-paradigm language that embraces both functional programming and object-oriented programming (OOP) approaches to writing code. OOP is especially popular\, in large part due to how it enables polymorphism (for example\, calling speak() on a Dog object returns "woof"\, while a Cat object's method returns "meow".) However\, OOP has many downsides that are often not understood until it's too late in the lifecycle of building a program. Fortunately\, Python also enables developers to achieve similar behavior to polymorphism while using simple functions and plain data objects instead of classes.
This talk will detail three different approaches provided by Python to achieve polymorphism behavior in a realistic program. It will compare and contrast their relative strengths and weaknesses. It will show how the most naive approach\, which relies on isinstance() checks\, leads to severe code duplication. It will show how OOP method polymorphism leads to code being organized along the wrong axis\, which hurts understandability\, debugging\, and maintainability in practice. It will also demonstrate a less commonly known part of the built-in functools library called @singledispatch that strikes a perfect balance between functional and OOP programming styles.
Finally\, you'll learn how @singledispatch works under the covers\, and how to build or integrate similar functionality into your own programs so you can realize the benefits of polymorphism while avoiding the pitfalls.
Brett Slatkin is the author of the book Effective Python and has been writing Python code professionally for the past 19 years. He works as a principal software engineer in the Office of the CTO at Google developing technology strategies and rapid prototypes. His experience includes: founding Google Surveys\, a platform for collecting machine learning and market research datasets\; launching Google App Engine\, the company's first cloud computing product\; scaling Google's A/B experimentation products to billions of users\; and co-creating PubSubHubbub\, the W3C standard for real-time RSS feeds. He earned his B.S. in Computer Engineering from Columbia University in the City of New York.
DTEND:20250517T181500Z LOCATION:Room 301-305 DTSTART:20250517T173000Z STATUS:CONFIRMED SUMMARY:[talk] The Zen of Polymorphism: Choosing between isinstance()\, methods\, and @singledispatch TRANSP:OPAQUE UID:e09259f4-442b-58f2-a040-459ee1fd7b2b URL:https://us.pycon.org/2025/schedule/presentation/99/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Design Pressure: The Invisible Hand That Shapes Your Code\nhttps://us.pycon.org/2025/schedule/presentation/81/\nEver had this weird gut feeling that something is off in your code\, but couldn't put the finger on why? Are you starting your projects with the best intentions\, following all best practices\, and still feel like your architecture turns weird eventually?
\nMaybe\, it's not your fault! Maybe\, the tools or methodology you're using are applying design pressure that you're not cognizant of\, but that influences the shape of your code.
\nThe best way to prevent that is becoming aware of the forces at play. So\, let's look at what design pressure is\, look at the most prominent examples of good and bad\, and explore how to leverage the former and quell the latter. Because you can only deal with something you know exists.
\nSpeakers:\nHynek Schlawack\nHynek Schlawack is a lead infrastructure and software engineer from Berlin/Germany\, PSF fellow\, blogger\, YouTuber\, and maintainer of way too many open source projects.
\nHis main areas of interest are networks\, security\, and robust software.
DTEND:20250516T191500Z LOCATION:Ballroom A DTSTART:20250516T184500Z STATUS:CONFIRMED SUMMARY:[talk] Design Pressure: The Invisible Hand That Shapes Your Code TRANSP:OPAQUE UID:3a242dce-7e7f-5644-bcf4-1c0c7baf3033 URL:https://us.pycon.org/2025/schedule/presentation/81/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: GPU Programming in Pure Python\nhttps://us.pycon.org/2025/schedule/presentation/111/\nGPU programming can be scary but doesn’t need to be. With the CUDA Core Libraries and CUDA Python object model\, you have a friendly interface to get you started with GPU acceleration.
\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 launch work and manage memory. Then\, you'll learn how to use parallel algorithms with cuda.parallel\, write your own kernels that leverage cooperative algorithms with cuda.cooperative\, and integrate seamlessly with accelerated libraries such as cuDNN and cuBLAS.
\nWe'll look at a variety of parallel examples\, from counting words\, to implementing softmax\, to a full blown machine learning demo.
\nBy the time the talk is over\, you'll be ready to start accelerating your Python code with GPUs!
\nSpeakers:\nBryce Adelstein Lelbach\nBryce Adelstein Lelbach has spent over a decade developing programming languages\, compilers\, and software libraries. He is a Principal Architect at NVIDIA\, where he leads programming language efforts and drives the technical roadmap for NVIDIA's compute compilers and libraries. Bryce is passionate about C++ and is one of the leaders of the C++ community. He has served as chair of INCITS/PL22\, the US standards committee for programming languages and the Standard C++ Library Evolution group. Bryce served as the program chair for the C++Now and CppCon conferences for many years. On the C++ Committee\, he has personally worked on concurrency primitives\, parallel algorithms\, executors\, and multidimensional arrays. He is one of the founding developers of the HPX parallel runtime system. Outside of work\, Bryce is passionate about airplanes and watches.
DTEND:20250517T164500Z LOCATION:Ballroom BC DTSTART:20250517T160000Z STATUS:CONFIRMED SUMMARY:[talk] GPU Programming in Pure Python TRANSP:OPAQUE UID:4d6c4945-5016-503c-99df-afcc4b2ef455 URL:https://us.pycon.org/2025/schedule/presentation/111/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Schemas: The Key To Data Happiness\nhttps://us.pycon.org/2025/schedule/presentation/45/\nShape shifting data got you down? If you’re a Pythonista who works with data you’ve probably had at least one headache due to unexpected changes in data. In this talk you’ll see how to create\, maintain\, and leverage schemas to generate test and training data\, improve data pipeline reliability\, generate code\, and some other neat tricks.
\nSpeakers:\nSev Leonard\nA long time snake person\, Sev has been working with data and Python for a bit over a decade. His work spans the data stack from infrastructure to analysis and machine learning\, which he's used to improve healthcare and protect small businesses from cyber threats. Sev enjoys teaching and has presented on data pipelines and micropython at PyCon\, PyDX\, and PyCascades. He is an O'Reilly contributor\, including the author of Cost-Effective Data Pipelines and an invited speaker on data &\; AI. He loves cats\, the forest\, and baked goods.
DTEND:20250516T214500Z LOCATION:Hall C DTSTART:20250516T211500Z STATUS:CONFIRMED SUMMARY:[talk] Schemas: The Key To Data Happiness TRANSP:OPAQUE UID:fb8962fa-ab9d-582a-9c85-fa761496670d URL:https://us.pycon.org/2025/schedule/presentation/45/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Taming file zoos: Data science with DuckDB database files\nhttps://us.pycon.org/2025/schedule/presentation/112/\nData scientists working in Python often spend the majority of their time cleaning input data\, frequently from files. These files have many formats\, can be located anywhere\, and sometimes have names like ‘data_final_final_v3.csv’. Data scientists often produce similar files! We call these “file zoos”.
\nThe MIT-licensed DuckDB database management system was designed to fit perfectly into data scientists’ workflows. Install DuckDB’s pre-compiled\, dependency-free binary from pip. It can read and write dataframes (Pandas\, Polars\, and Apache Arrow) for interoperability. It also has an advanced persistent file format.
\nDuckDB can read and write to and from csv\, parquet\, json - even xlsx and Google Sheets. The csv reader in DuckDB is world-class\, quickly querying even messy csvs. DuckDB interoperates with object stores across clouds and reads lakehouse formats like Delta and Iceberg.
\nUse DuckDB’s highly compressed columnar file format to persist many large tables all in the same file. Store processing logic in views and functions and even update just portions of the file. DuckDB serves as a catalog when files should remain in place.
\nBeyond the format itself\, DuckDB provides ACID transactional safety and parallel processing\, it can be read in 15+ languages\, and is guaranteed to be readable for years to come. It unlocks larger-than-memory analyses to solve 2TB problems\, not 16GB ones!
\nCommunity extensions enable DuckDB to read additional formats and are provided through a pip-like package repository.
\nAttendees will learn how to install and use DuckDB locally\, how to integrate it seamlessly in their existing Python scripts or Jupyter Notebooks\, and how to smoothly manage the deluge of files in their workflow.
\nSpeakers:\nAlex Monahan\nAlex Monahan is a forward deployed software engineer at MotherDuck and writes blogs part time for DuckDB Labs.
\nAlex joined MotherDuck 1 1/2 years ago after 9 years at Intel. After starting at Intel as an industrial engineer\, Alex later became a technical analyst\, and then moved into a data scientist role.
\nBack in 2020 Alex discovered DuckDB while building an internal self-service analytics platform. Alex then became one of DuckDB's biggest Twitter fans! He has been diving deeper into duck-themed databases ever since.
DTEND:20250518T181500Z LOCATION:Ballroom A DTSTART:20250518T174500Z STATUS:CONFIRMED SUMMARY:[talk] Taming file zoos: Data science with DuckDB database files TRANSP:OPAQUE UID:39d93a08-3c7f-5cfe-9b66-5a60832da226 URL:https://us.pycon.org/2025/schedule/presentation/112/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Why `len('😶🌫️') == 4` and other weird things you should know about strings in Python\nhttps://us.pycon.org/2025/schedule/presentation/27/\nStrings in Python behave in all sorts of unexpected ways: len('😶🌫️') == 4\, 'ñ' != 'ñ'\, 'dlrow olleh'.split()[1] == 'olleh'! How is this possible? And importantly\, why should you care?
In this presentation\, we’ll give a brief introduction to text encoding\, the different Unicode standards and how Python encodes strings before we dive deep into Unicode oddities. We’ll cover how one code point can represent multiple characters\, why converting between upper-case and lower-case characters should be locale-dependent and how emoji’s work. Finally\, we will discuss some best practices for handling unicode input in Python.
\nAfter this talk\, you'll have a better understanding of strings in Python\, the Unicode character encoding and you’ll be aware of some common pitfalls and how to avoid them.
\nSpeakers:\nMarie Roald\nMarie Roald is a researcher\, data scientist and educator. For the past years\, she has developed and taught programming courses with the goal of empowering teachers to apply programming in their classrooms and has taught courses both digitally and physically at major cities all across Norway. Marie also has experience with academic conferences and science communication.
\nYngve Mardal Moe\nYngve is an experienced Python educator\, Python developer open source enthusiast. He is a co-creator of TurtleThread and has taught Python to professionals\, university students and academics. He is currently tech lead working on safely automating the Norwegian power grid. While working at the Norwegian University of Life Sciences\, Yngve headed a project transforming introduction to Python into a tutorial-based course focusing on active learning.
DTEND:20250517T194500Z LOCATION:Ballroom BC DTSTART:20250517T191500Z STATUS:CONFIRMED SUMMARY:[talk] Why `len('😶🌫️') == 4` and other weird things you should know about strings in Python TRANSP:OPAQUE UID:69ec8f53-44e5-56b2-b9c2-d5ecbe41e8ae URL:https://us.pycon.org/2025/schedule/presentation/27/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: When GPUs Make Python Slower: Patterns and Pitfalls\nhttps://us.pycon.org/2025/schedule/presentation/138/\nWhen does GPU acceleration slow down your Python code? More often than you might think! Join me to explore the world of GPU acceleration\, in which I will walk through some use cases where it makes your code faster and slower\, and sometimes much slower. I’ll explain what GPU accelerated libraries like Numba\, CuPy\, cuDF and cuGraph really do\, and we’ll dive into string processing\, memory transfer overhead\, and real-world case studies in processing time-series data. Whether you’re new to GPU acceleration or already using it in production\, you’ll better understand when using GPUs help\, when it doesn’t\, and when you should reach for other ways to make your Python code faster.
\nSpeakers:\nKaashif Hymabaccus\nKaashif Hymabaccus is a senior software engineer at Bloomberg. His team\, which builds distributed systems to compute and store portfolio analytics\, are heavy users of Python\, Pandas\, and PySpark.
DTEND:20250517T154500Z LOCATION:Ballroom BC DTSTART:20250517T151500Z STATUS:CONFIRMED SUMMARY:[talk] When GPUs Make Python Slower: Patterns and Pitfalls TRANSP:OPAQUE UID:942569ed-ba8e-5454-a680-0c89983a22ea URL:https://us.pycon.org/2025/schedule/presentation/138/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Dependency Injection in Python with Pydantic and Hydra\nhttps://us.pycon.org/2025/schedule/presentation/128/\nDependency Injection (DI) is a technique that allows for the flexible construction of nested object hierarchies through configuration\, with the goal of reducing coupling between objects and enabling more run-time flexibility in applications.
\nThis talk aims to illustrate how the popular open source packages Pydantic and Hydra can be combined (with a little extra work) to provide a powerful dependency injection framework for python. This session will provide an introduction to these tools\, illustrate their integration\, and highlight their benefits in managing configurations and dependencies. Attendees will gain insights into building flexible and extensible Python applications by leveraging the ability to register and reuse Pydantic models from Hydra based configurations.
\nThis talk is designed for Python developers\, software engineers\, and architects interested in improving their application architecture through dependency injection. Attendees should have a basic understanding of Python and software design principles.
\nNo prior experience with Pydantic or Hydra is required.
\nSpeakers:\nPascal Tomecek\nHead of Research Technology for Cubist Systematic Strategies
DTEND:20250518T181500Z LOCATION:Hall C DTSTART:20250518T174500Z STATUS:CONFIRMED SUMMARY:[talk] Dependency Injection in Python with Pydantic and Hydra TRANSP:OPAQUE UID:3d0de613-1eaa-57ad-80a8-1d6ea30e9da0 URL:https://us.pycon.org/2025/schedule/presentation/128/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Keeping up with Python: what makes upgrades hard\, and what can we do about it\nhttps://us.pycon.org/2025/schedule/presentation/31/\ncPython upgrades can be very challenging. Changes in python version usually mean changes all over the place and managing that can be taxing. Like first party code using deprecated api or Third-party code changing API required to change python versions. Lets go over some bad code examples and ways to improve the experience for everyone. So that maybe in the future upgrades are not so hard.
\nSpeakers:\nJason Fried\nJason has been writing Python for over 13 years\, with most of that time spent at Meta working on cPython version upgrades. He has given talks at PyConUS\, PyConAU\, and PyOhio\, and contributes to various Python open source projects and cPython itself. Recently\, he became a cPython triager. In addition to his work in tech\, Jason is also an avid goat farmer on his ranch in California.
DTEND:20250518T190000Z LOCATION:Hall C DTSTART:20250518T183000Z STATUS:CONFIRMED SUMMARY:[talk] Keeping up with Python: what makes upgrades hard\, and what can we do about it TRANSP:OPAQUE UID:aca52640-2607-5fad-a9ff-fb5312de53af URL:https://us.pycon.org/2025/schedule/presentation/31/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Processing Large Geospatial Datasets with Dask & Xarray\nhttps://us.pycon.org/2025/schedule/presentation/86/\nGeospatial datasets are growing in size\, often exceeding 100TB and reaching into Petabyte scale. Many of these datasets are publicly available\, providing a great resource for analysis\, but working with them requires increasingly large computational resources and a diverse set of tools.
\nWe will start by briefly introducing Dask and Xarray\, which form the backbone of the geospatial stack in Python. Using the ERA5 dataset as a case study\, we will demonstrate how Xarray can be used to explore large-scale climate data effectively from your local laptop.
\nBuilding on this foundation\, we will delve into recent advancements in Dask Array. Originally designed as a parallel NumPy API\, Dask Array was used to handle much larger datasets over the last few years. We’ll explore the latest developments in Dask and Xarray that continue to expand the scalability and capabilities of these tools to catch up with the scale requirements of modern datasets.
\nThis discussion will highlight improvements in ease of use\, scalability\, and performance. Additionally\, we’ll present the first-ever set of geospatial benchmarks\, collected earlier in 2024 from the community. These benchmarks provide a clear illustration of the scale at which Xarray and Dask are required to operate.
\nFinally\, we’ll offer a peak behind the scenes of an ongoing project aimed at building the first ever query optimizer for large scale array computations.
\nSpeakers:\nPatrick Hoefler\nPatrick Hoefler is a member of the pandas core team and a Dask maintainer. He is currently working at Citadel as a Software Engineer. He holds a Msc degree in Mathematics and works towards a Msc in Software engineering at the University of Oxford.
DTEND:20250516T170000Z LOCATION:Ballroom A DTSTART:20250516T163000Z STATUS:CONFIRMED SUMMARY:[talk] Processing Large Geospatial Datasets with Dask & Xarray TRANSP:OPAQUE UID:76ec6198-b83d-5cd6-9da7-61096298b7b7 URL:https://us.pycon.org/2025/schedule/presentation/86/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Going From Notebooks to Scalable Systems\nhttps://us.pycon.org/2025/schedule/presentation/51/\nJupyter Notebooks are a fantastic tool that make it very easy to get started on a project. But often\, you’ll reach a point where you want to make your code part of a larger system\, and you’ll need to change your way of working. You’ll need to go from code that gives you some insights or results to robust\, reproducible code that runs automatically. In this talk\, I’ll explain strategies that will help you smoothly refactor your code. I’ll introduce tools that will help you\, and discuss the skills that you’ll need. Whether you're a data scientist looking to productionize your models or a developer working with data-heavy applications\, you'll gain practical knowledge to help you move from exploratory notebooks to robust\, scalable systems.
\nSpeakers:\nCatherine Nelson\nCatherine Nelson is a freelance data scientist and the author of two O'Reilly books\, this year’s Software Engineering for Data Scientists\, and her 2020 book Building Machine Learning Pipelines. Previously\, she was a Principal Data Scientist at SAP Concur where she worked on production NLP systems. Catherine has a PhD in geophysics from Durham University and a Masters of Earth Sciences from Oxford University. She is currently consulting for startups in the Generative AI space.
DTEND:20250516T161500Z LOCATION:Ballroom BC DTSTART:20250516T154500Z STATUS:CONFIRMED SUMMARY:[talk] Going From Notebooks to Scalable Systems TRANSP:OPAQUE UID:5bccf91e-aec8-5b2d-b5e9-376e477ba198 URL:https://us.pycon.org/2025/schedule/presentation/51/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: The chaotic locals() and how we fixed it\nhttps://us.pycon.org/2025/schedule/presentation/57/\nHistorically\, Python stored local variables in a dict\, which was convenient and consistent. Users can use locals() to get the same dict Python is using for the local variables. As Python evolves\, local variables were moved to the frame stack to improve performance\, which made it invisible from Python code. However\, locals() was kept because we still need a way to access some or all of the local variables in a frame.
\nThis became chaotic when we try to change the local variables through the dict - which is a common requirement for something like a debugger. What could possibly go wrong? Is the update remembered? Could it work with exec()? Will a random read in your code bites you? How can we reliably update the value of a local variable in a debugger?
Well the short answer is - we can't\, not until PEP 667.
\nThis talk will be about how we fixed the chaos in PEP 667 and what's the modern way to deal with local variables in a debugger.
\nSpeakers:\nTian Gao\nSenior Software Engineer at Microsoft AI Frameworks. Python Core Dev\, maintainer of pdb. Author of a few open source projects\, including VizTracer\, coredumpy and objprint. Also a Youtuber.
\nMaking life easier for developers.
DTEND:20250517T204500Z LOCATION:Hall C DTSTART:20250517T201500Z STATUS:CONFIRMED SUMMARY:[talk] The chaotic locals() and how we fixed it TRANSP:OPAQUE UID:975b095c-19f8-505f-8f36-9774c099e719 URL:https://us.pycon.org/2025/schedule/presentation/57/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Missing the Apex: Predicting F1 Races with Python\nhttps://us.pycon.org/2025/schedule/presentation/119/\nInspired by\, and iterates upon\, a paper published in an academic journal\, this talk walks throughs through how I used Python to predict Fomula 1 (F1) races. Specifically we talk about the specific challenges related to web scraper\, data wrangling\, and statistical analysis to try and predict the outcome of F1 races by the evolution of track data over the weekend. Whether beginner or intermediate\, or have no familiarity with F1 there's something in here for everyone to learn how to apply Python to their projects.
\nSpeakers:\nJosh Weissbock\n-
DTEND:20250517T154500Z LOCATION:Ballroom A DTSTART:20250517T151500Z STATUS:CONFIRMED SUMMARY:[talk] Missing the Apex: Predicting F1 Races with Python TRANSP:OPAQUE UID:c765fb02-1ee1-5ffe-8576-759aba4607d1 URL:https://us.pycon.org/2025/schedule/presentation/119/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Scaling the Mountain: A Framework for Tackling Large-Scale Tech Debt\nhttps://us.pycon.org/2025/schedule/presentation/2/\nManaging tech debt in large legacy codebases isn’t just a challenge—it’s an ongoing battle that can drain developer productivity and morale. In this talk\, I’ll introduce a Python-powered Tech Debt Framework bar-raiser designed to help teams tackle even the most daunting tech debt problems with 100\,000+ violations.\nThis open-source framework empowers developers and engineering leaders by:\n - Tracking Progress: Measure and visualize the state of tech debt and trends over time.\n - Recognizing Contributions: Celebrate developer efforts and foster accountability with contribution leaderboards and automated shoutouts.\n - Automating Fixes: Save countless hours with codemods that address repetitive debt patterns\, allowing developers to focus on higher-priority work.
\nThrough real-world case studies\, I’ll showcase how we:\n - Reduced 70\,000+ pyright-ignore annotations to boost type-checking coverage from 60% to 99.5%.\n - Converted a monolithic sync codebase to async\, addressing blocking IO issues and adopting asyncio effectively.
\nAttendees will gain actionable strategies for scaling Python automation\, fostering team buy-in\, and systematically reducing tech debt across massive codebases. Whether you’re dealing with type errors\, legacy dependencies\, or async transitions\, this talk provides a roadmap for creating cleaner\, more maintainable code at scale.
\nSpeakers:\nJimmy Lai\nJimmy Lai is a Software Engineer on the Infrastructure team at ZipHQ\, with a passion for Python and sharing knowledge through engaging tech talks. His recent appearances at PyCon US\, EuroPython\, and PyCon JP covered topics such as linting\, profiling and optimization\, asyncio\, type annotations\, automated refactoring\, and practical testing.
\nJimmy is also an active open-source contributor\, having worked on tools like LibCST\, Fixit\, and bar-raiser\, empowering developers to write cleaner\, more maintainable code. When he’s not coding or presenting\, he’s exploring ways to make large-scale systems more efficient and developer-friendly.
DTEND:20250517T154500Z LOCATION:Room 301-305 DTSTART:20250517T151500Z STATUS:CONFIRMED SUMMARY:[talk] Scaling the Mountain: A Framework for Tackling Large-Scale Tech Debt TRANSP:OPAQUE UID:65aff90a-a220-5483-bc6f-5f2698d1ce13 URL:https://us.pycon.org/2025/schedule/presentation/2/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: The PyArrow revolution in Pandas\nhttps://us.pycon.org/2025/schedule/presentation/69/\nPandas has long used NumPy for its back-end storage. But things are changing\, and the future of Pandas will likely be tied closely with PyArrow. What are Arrow and PyArrow? How do they affect Pandas users today\, and how will they affect us in the future? Is PyArrow always faster than the current Pandas backend? In this talk\, I introduce PyArrow\, tell you what it does\, how we can already use it in our Pandas work\, and when it's appropriate for you to use it.
\nSpeakers:\nReuven M. Lerner\nReuven is a full-time instructor in Python and Pandas\, in business since 1995. He teaches at companies around the world\, offers video courses\, and writes books — most recently\, Python Workout and Pandas Workout\, both published by Manning. He writes about Python for his "Better Developers" newsletter\, and poses Pandas puzzles based on current events in "Bamboo Weekly." Reuven lives with his wife and three children in Modi'in\, Israel.
DTEND:20250516T161500Z LOCATION:Ballroom A DTSTART:20250516T154500Z STATUS:CONFIRMED SUMMARY:[talk] The PyArrow revolution in Pandas TRANSP:OPAQUE UID:6aa2703b-d2f7-5206-be18-ccdb8c7553a9 URL:https://us.pycon.org/2025/schedule/presentation/69/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: World's First Undoable Notebook\nhttps://us.pycon.org/2025/schedule/presentation/92/\nInteractive Notebooks (e.g.\, Jupyter\, Colab) are widely used for data science tasks such as data analysis\, data visualization\, and model training. A fundamental limitation of vanilla notebook frameworks is the inability to undo the effect of cell executions on the session state\, e.g.\, users cannot ‘un-drop’ dataframe columns. In this talk\, I will describe our ongoing work on adding automated\, lightweight checkpointing in notebook sessions to address this issue.
\nThis talk should be interesting for an intermediate-level audience who have some experience with using Python-based notebooks and common data science libraries (e.g.\, Pandas\, Matplotlib) and have experienced first-hand the various issues of existing notebook frameworks (e.g.\, no undos\, non-persistent state). This talk will assume prior knowledge of notebook basics and terminology (e.g.\, cell executions\, session state).
\nAttendees will learn about how incremental checkpointing and versioning techniques commonly utilized in databases can be adapted to work well with interactive notebooks. At a more detailed level\, they will learn about the characteristics of typical notebook workloads and how information (e.g.\, dependencies between variables) required for incremental checkpointing can be profiled from cell executions.
\nSpeakers:\nZhaoheng Li\nI am a fourth-year CS PhD student at the University of Illinois at Urbana-Champaign. I am a member of CreateLab advised by Prof. Yongjoo Park. My research interests lie within Database Systems on the topics of Data management and Support for ML/AI.
DTEND:20250516T153000Z LOCATION:Ballroom BC DTSTART:20250516T150000Z STATUS:CONFIRMED SUMMARY:[talk] World's First Undoable Notebook TRANSP:OPAQUE UID:eba453ca-db1c-51d8-b9d4-0c09adf52b9c URL:https://us.pycon.org/2025/schedule/presentation/92/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Writing Extension Modules To Be Interruptible\nhttps://us.pycon.org/2025/schedule/presentation/39/\nHave you ever told Python to crunch some numbers\, realized right after\npressing RETURN that you made a mistake setting up the problem\, hit\ncontrol-C to stop it again...and then sat there twiddling your thumbs\nfor a surprisingly long time as nothing seemed to happen?
\nThe short version of what's going on when this happens is\, the\nPython interpreter is notified of your having hit control-C almost\nimmediately\, but it has to wait to throw KeyboardInterrupt until\nthe extension module that's doing the number crunching finishes\nits calculation and returns control to the interpreter.
In this talk we will discuss why the interpreter works that way (and\nwhy it has to work that way)\, what extension module authors can do\ntoday to make their extensions notice control-C promptly\, and how we\ncan all work toward a future where it's easy and natural for extension\nmodule authors to write extensions that don't make you wait for them\nto stop.
\nSpeakers:\nZack Weinberg\nZack is a Research Software Engineer at Million Concepts LLC (https://millionconcepts.com/) where he works on tools for analyzing and cataloguing data collected from probes and telescopes over the past half-century and more of space exploration. These projects sometimes require him to delve deeper into the innards of the Python interpreter than one might expect.
\nHe holds a Ph.D. in Electrical and Computer Engineering from Carnegie Mellon University\, where his academic research focused on machine learning and statistical approaches to investigating internet censorship at global scale. He co-taught CMU's "Introduction to Computer Systems" course from 2020 through 2023. Zack's other interests include cognitive science\, systems theory\, candlemaking\, pottery\, and game design. He is re-learning to play the piano.
DTEND:20250517T150000Z LOCATION:Room 301-305 DTSTART:20250517T143000Z STATUS:CONFIRMED SUMMARY:[talk] Writing Extension Modules To Be Interruptible TRANSP:OPAQUE UID:965e199e-beaa-5493-ae10-2223b3dc1e2e URL:https://us.pycon.org/2025/schedule/presentation/39/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: PyXL: A Chip That Runs Python at Turbo Speeds\nhttps://us.pycon.org/2025/schedule/presentation/40/\nPython is powerful but slow - held back by interpreter overhead and dynamic typing. What if it ran natively on hardware?
\nI built PyXL\, a custom processor designed to accelerate Python execution in silicon\, eliminating its biggest performance bottlenecks.\nPyXL achieves massive efficiency gains per cycle\, even significantly surpassing high-end CPUs like the M1 Pro!
\nCome see how Python can break free from its speed limits without rewriting a single line of code.
\nSpeakers:\nRon Livne\nRon Livne is a software engineer with 17 years of experience in performance-critical systems. His work spans high-frequency trading\, high-performance computing\, networking stacks\, and machine learning infrastructure. Ron has a background in low-level software and custom tooling\, with a track record of building lean\, high-efficiency solutions.
DTEND:20250517T150000Z LOCATION:Hall C DTSTART:20250517T143000Z STATUS:CONFIRMED SUMMARY:[talk] PyXL: A Chip That Runs Python at Turbo Speeds TRANSP:OPAQUE UID:f4dee25d-c6a0-58d4-8e66-b58431dfceef URL:https://us.pycon.org/2025/schedule/presentation/40/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Detecting Honeybee Swarms Using the Integration of OpenCV\, Pandas\, AI\, and PyTorch\nhttps://us.pycon.org/2025/schedule/presentation/20/\nHoneybees will swarm during times of increased pollen and nectar flow\, effectively dividing the hive in half. This can result in the complete loss of both halves of the hive for the beekeeper. In this talk\, I will show how I used a Raspberry Pi\, mounted on a hive and powered by solar panels\, to take a still image of a hive entrance every 30 seconds and filtered using OpenCV. Each image was sent off in real-time to Marvin.AI for analysis to obtain a count of the number of bees at the hive entrance. A subsequent refinement has removed the need for AI analysis using an object detection model implemented in PyTorch using large scale datasets from iNaturalist to create a deep learning model which I plan to implement this Spring. The counts were stored in an offsite database and then aggregated into a Pandas dataset and subjected to a rolling window analysis. It was postulated that such an analysis would prove necessary to distinguish between swarming and “bearding” which is when many bees exit the hive and congregate at the entrance during very warm periods to ventilate it. While the bees were “uncooperative” this season and did not swarm\, test data show that a beekeeper could be notified of a swarm event within 10 minutes of its occurrence\, thus saving both hives.\nAttendees will learn : \n(1) The use of “maker” techniques in setting up and integrating solar power\, Raspberry Pi systems and cameras as well as effectively running python on the systems and setting up remote access.\n(2) How to implement the setup and use of PyTorch data object models and how they relate to AI analysis\n(3) How to use NumPy and Pandas for biological system analysis\n(4) And maybe a little apiculture!
\nSpeakers:\nMichael Dahlberg\nMike has been a Linux Systems Administrator for the past 25 years and has written code in some form for that same length of time\, however\, he has only worked with Python for the past 2-3 years. He currently works at the Pennsylvania State University. He has been an avid beekeeper for the past 11 years. While his work with bees out in the apiary and his projects in Python keep him sane\, for some reason\, he keeps making the same mistakes year after year!
DTEND:20250516T210000Z LOCATION:Ballroom A DTSTART:20250516T203000Z STATUS:CONFIRMED SUMMARY:[talk] Detecting Honeybee Swarms Using the Integration of OpenCV\, Pandas\, AI\, and PyTorch TRANSP:OPAQUE UID:064d2598-0b74-552f-8777-1270881d55c6 URL:https://us.pycon.org/2025/schedule/presentation/20/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Safeguard your precious API endpoints built on FastAPI using OAuth 2.0\nhttps://us.pycon.org/2025/schedule/presentation/88/\nAudience Level: Beginners\, Pythonistas who build on FastAPI who are not security experts but still need to deploy secure APIs.
\nIs implementing authorization to your API endpoints an afterthought? Who should have access to your API endpoints? This talk covers using OAuth 2.0 to secure API endpoints (including ML endpoints) built on FastAPI following industry-recognized best practices. Come on a journey with me from taking your API endpoints to being not just functional but also secure. When you follow secure identity standards\, you’ll be equipped with a deeper understanding of the critical need for authorization.
\nSpeakers:\nSemona Igama\nSemona is a Developer Advocate at Okta. She enjoys chatting about OpenID Connect\, OAuth 2.0\, and web security\, but most of all\, learning how developers learn best. Outside work\, Semona is a Pythonista\, loves kombucha\, and plays board/role-playing games and Ultimate!
DTEND:20250516T183000Z LOCATION:Hall C DTSTART:20250516T180000Z STATUS:CONFIRMED SUMMARY:[talk] Safeguard your precious API endpoints built on FastAPI using OAuth 2.0 TRANSP:OPAQUE UID:3c7ea849-af4c-57de-993f-6062c2e37152 URL:https://us.pycon.org/2025/schedule/presentation/88/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Zoom\, Enhance: Asyncio's New Introspection Powers\nhttps://us.pycon.org/2025/schedule/presentation/116/\nasyncio in Python 3.14 introduces a new powerful feature: introspecting a running asyncio program from another OS process. This changes everything—now you can debug and profile your asyncio code in production with no performance penalty. Join us for a fun ride as we show how this magic works under the hood and how you can use it. Learn about technical design decisions\, performance considerations\, security implications\, and trade-offs made. Along the way\, you’ll gain both beautiful and horrible insights into how asyncio and operating systems interact\, and we’ll wrap up with a flawless live demo!
\nSpeakers:\nPablo Galindo Salgado\n-
\nYury Selivanov\nPython core developer since 2013.
\nAuthor of a numerous PEPs\, such as: adding async/await syntax\, asynchronous generators\, exception groups\, context variables\, etc. Contributed to many other areas of CPython.
\nCreator of uvloop -- the de-facto library of running asyncio applications in production.
\nCo-founder and CEO of Gel Data Inc.\, with the mission of advancing SQL and PostgreSQL to the new heights\, enabling high-performance\, and enhancing developer experience.
\nReflecting on a year at the Python Software Foundation (PSF)\, I’ll share insights into how the CPython project and its surrounding efforts\, as well as the PSF\, operate. Learn how anyone can get involved in areas like code\, documentation\, or PSF projects\, and uncover some lesser-known aspects of the PSF’s inner workings. Discover how you can contribute to—from code to documentation—and help shape Python’s future.
\nSpeakers:\nJacob Coffee\nJacob Coffee is an Infrastructure Engineer at the Python Software Foundation and a newly invited CPython triager. He supports key Python services such as PyPI.org and Python.org while also contributing to the maintenance of the Litestar ecosystem which boasts libraries such as Litestar\, Advanced Alchemy\, Polyfactory\, and more. He is passionate about open source development\, funding\, the mission of the PSF\, and enhancing the tools that empower developers worldwide.
DTEND:20250518T190000Z LOCATION:Room 301-305 DTSTART:20250518T183000Z STATUS:CONFIRMED SUMMARY:[talk] One Year In: Insights and Inspiration from my PSF Journey TRANSP:OPAQUE UID:d821db2b-ad1a-5483-a9f5-3b0b6009f299 URL:https://us.pycon.org/2025/schedule/presentation/126/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Cython in Practice: A Deep Dive into Legacy C Integration and Debugging\nhttps://us.pycon.org/2025/schedule/presentation/56/\nIn Cython in Practice\, we'll go over the benefits and challenges of utilizing Cython as a way to utilize legacy C/C++ programs and libraries within Python applications. Cython's capabilities permit users to use Python-like syntax to integrate with existing C code and build their own library and program interfaces accessible from both C and Python. This talk will cover essential tools and workflows for building with Cython and what the interface looks like for integrating with legacy C code\, and how to build and package a Cython extension with Poetry and uv.
\nHowever\, utilizing the full powers of Cython is not without its own set of challenges. The presentation will also provide practical insights into common errors encountered during build and runtime phases while developing in Cython. Attendees will learn how to navigate these issues\, using a detailed account of the specific obstacles faced when wrapping a legacy C library for Python via Cython. We will discuss different memory management and debugging tools\, with a focus on Valgrind\, and how to utilize these tools during development in Cython.
\nSpeakers:\nMaryanne Wachter\nMaryanne Wachter is a versatile software developer and design technologist whose career bridges structural engineering and software development. With deep expertise in Python\, she's developed everything from Blender plugins optimized with Cython to full-stack applications. As a structural engineer\, she worked on landmark transportation and cultural projects across three continents\, specializing in unique structural forms like shells\, membranes\, and bending-active structures. Her current work focuses on developing open-source tools for the built environment\, creating sustainable technology solutions\, and building the software she wished existed during her years as a design professional.
DTEND:20250517T181500Z LOCATION:Ballroom BC DTSTART:20250517T174500Z STATUS:CONFIRMED SUMMARY:[talk] Cython in Practice: A Deep Dive into Legacy C Integration and Debugging TRANSP:OPAQUE UID:41bb8d7a-e096-590e-a0e0-18272be62d34 URL:https://us.pycon.org/2025/schedule/presentation/56/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: How to learn Japanese with Python\nhttps://us.pycon.org/2025/schedule/presentation/122/\nJapanese is reportedly one of the most difficult languages for English speakers to learn.\n(FSI language difficulty: https://www.fsi-language-courses.org/blog/fsi-language-difficulty/)\nThere are many reasons for this\, including the fact that there are three types of characters: hiragana\, katakana\, and kanji\, and that words are not separated by spaces.\nIn this talk\, I will first introduce what makes Japanese different from many European languages.\nThen I will show how Python and natural language processing libraries can be used to support Japanese language learning.
\nSpeakers:\nTakanori Suzuki\nTakanori is a Chairperson of PyCon JP Association.\nWorked as a PyCon JP organizer since PyCon mini JP in January 2011 and has been the Co-Chair of PyCon JP 2024.\nHe is also a director of BeProud Inc.\, and his title is "Python Climber".\nCurrently he teaches Python to beginners as a lecturer at Python Boot Camp all over Japan.\nIn addition\, he published several Python books.
\nHe plays trumpet\, climbs boulder\, loves Lego\, ferrets and craft beer.
DTEND:20250516T161500Z LOCATION:Room 301-305 DTSTART:20250516T154500Z STATUS:CONFIRMED SUMMARY:[talk] How to learn Japanese with Python TRANSP:OPAQUE UID:88d39dc9-3c4b-5bb4-afef-b92b34a5f62d URL:https://us.pycon.org/2025/schedule/presentation/122/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Selenium with Python using Robot Framework\nhttps://us.pycon.org/2025/schedule/presentation/157/\nEnsuring software quality is more important than ever. In this talk\, we'll explore how to harness the power of Selenium with Python alongside the Robot Framework to create robust and efficient automated tests. As QA engineers\, we face numerous challenges in delivering quality software under tight deadlines\, and integrating these tools can streamline our testing processes. I'll start by understanding the fundamentals of Selenium and Robot Framework\, then walk through setting up our environment and writing our first test suite together. We'll share best practices for maintaining our test scripts and discuss real-world applications demonstrating how these tools can enhance collaboration and improve software quality. By the end of the session\, we’ll be equipped with the knowledge and resources to elevate our automation strategies and foster a quality culture in our development teams.
\nSpeakers:\nMonica Oyugi\nMonica Oyugi is a Quality Assurance Engineer\, speaker\, and active participant in the software industry. With a deep passion for coding\, she finds great satisfaction in solving practical problems through software development. Monica specializes in Quality Assurance and Developer Relations\, constantly seeking dynamic opportunities to contribute to business success and foster a positive work environment. In addition to her professional endeavors\, she holds leadership positions in various tech communities\, including organizing API Festival Nairobi\, Organizing Pycon Kenya\, serving as a marketing associate for Droidcon Kenya\, and X lead She Codes Nairobi. Through these roles\, Monica drives collaboration\, innovation\, and community growth while networking with fellow professionals. Her ultimate goal is to leverage her skills and experiences to make a meaningful impact in the tech industry. She actively participates in initiatives promoting diversity\, inclusion\, and knowledge sharing within the tech community\, aiming to drive success and create positive change.
DTEND:20250517T204500Z LOCATION:Ballroom BC DTSTART:20250517T201500Z STATUS:CONFIRMED SUMMARY:[talk] Selenium with Python using Robot Framework TRANSP:OPAQUE UID:c26dd0f0-5088-5a0c-8d7c-2cd7b0aba927 URL:https://us.pycon.org/2025/schedule/presentation/157/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: From Desktop to Browser: Crafting Browser-Native Game Engine with Webassembly\nhttps://us.pycon.org/2025/schedule/presentation/29/\nHave you ever wondered how to turn your Python games into lightning-fast web experiences without compromising speed? In this session\, overcome the browser barrier and learn how to create powerful game engines that smoothly connect desktop and web platforms using Pygame\, pygbag\, and WebAssembly.
\nStarting with familiar Pygame foundations\, discover how pygbag transforms Python games into browser-ready experiences. Learn techniques for managing state\, particle effects\, and physics computations with near-native performance. Through live demonstrations\, explore practical strategies for optimizing rendering and maintaining smooth gameplay across different environments.
\nBy the end of the talk\, learn how to create WebAssembly-powered games that function flawlessly on any platform without sacrificing user experience\, and understand the architectural patterns that enable high-performance browser-based game engines.
\nSpeakers:\nNeeraj Pandey\nNeeraj is a polyglot developer passionate about bridging different technologies. Over the years\, he has worked on a variety of full-stack software and data-science applications\, computational arts\, and quantitative finance projects\, embracing the challenge of creating innovative tools and applications. As an active Python community member\, he has shared his expertise through talks and workshops at numerous conferences and meet-ups.
DTEND:20250516T200000Z LOCATION:Hall C DTSTART:20250516T193000Z STATUS:CONFIRMED SUMMARY:[talk] From Desktop to Browser: Crafting Browser-Native Game Engine with Webassembly TRANSP:OPAQUE UID:77a518ae-f6ee-5192-bb05-665bdbfb4a28 URL:https://us.pycon.org/2025/schedule/presentation/29/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Beautiful and Balanced: Using Color Theory in Data Visualization\nhttps://us.pycon.org/2025/schedule/presentation/71/\nYou have just made the most aesthetically pleasing pie chart in the history of data viz - but has your color palette inadvertently introduced a bias to the data you're presenting?
\nOur brains interpret color contextually: proximity to other colors changes the way we perceive a particular color\, making it appear darker or lighter\, more prominent or more demure. When presenting data visually\, it's important to choose color palettes which do not skew the viewer's perception of the data relationships you're illustrating.
\nIn this talk\, we'll take a peek at some basic color theory based on the work of Josef Albers\, look at what color weight is\, and how you can use it to evaluate your palette choices. We'll learn why those gorgeous palettes created by graphic designers may not be the best choices for your data visualizations\, and present some strategies for choosing color palettes that keep your data presentation both unbiased and visually pleasing.
\nThis is a tool-agnostic talk: you can apply these techniques with any data visualization package or tool which allows you to specify a color palette.
\nSpeakers:\nLaura Fisher\nI'm an artist and designer\, living and working in downtown Los Angeles. I create work in traditional media like oil paint\, and in modern media like code. I am learning data visualization as a fun way to use both these skill sets simultaneously.
\nWebsite: https://mitten.lol
\nFediverse: @mitten@social.lol
DTEND:20250516T200000Z LOCATION:Ballroom BC DTSTART:20250516T193000Z STATUS:CONFIRMED SUMMARY:[talk] Beautiful and Balanced: Using Color Theory in Data Visualization TRANSP:OPAQUE UID:407ed4d0-c606-5251-b0e3-2354489a3ef3 URL:https://us.pycon.org/2025/schedule/presentation/71/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Notes\, Groups and Stars: exceptional new features of Python 3.11!\nhttps://us.pycon.org/2025/schedule/presentation/96/\nNotes\, Groups\, and Stars aren't just for concerts - they're also exception-ally useful features for error handling\, new in Python 3.11!
\nIn this talk\, we'll explore a neglected corner of Python: exceptions and error handling! What would we like Python to do for us\, when our programs do something we didn't expect? How can we help other programmers understand failures in our code?
\nWe'll take a broad view\, starting from fundamentals like exceptions vs return values\, before zooming through a history of tracebacks and chaining\, and arriving at the glorious present with .add_note()\, ExceptionGroup\, and except*. You'll leave not just educated but enthused and excited - but perhaps even a ten-ex except-star developer!
I'm a member of technical staff at Anthropic\; and in my spare time I maintain OSS libraries\, read books\, hike\, and enjoy dark chocolate! You can read more about me at https://zhd.dev/.
DTEND:20250517T194500Z LOCATION:Room 301-305 DTSTART:20250517T191500Z STATUS:CONFIRMED SUMMARY:[talk] Notes\, Groups and Stars: exceptional new features of Python 3.11! TRANSP:OPAQUE UID:8817ace8-2144-5954-a8d2-79beb84985e2 URL:https://us.pycon.org/2025/schedule/presentation/96/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Reinventing the Wheel: A Community-Driven Roadmap for Python Packaging\nhttps://us.pycon.org/2025/schedule/presentation/100/\nThe Python ecosystem thrives on innovation\, adaptability\, versatility and a thriving open-source community. Python’s reach continues to evolve\, fueled today by custom silicon\, variations within CPU architecture families\, AI accelerators\, and diverse use cases. The Wheel format and packaging tools should adapt and evolve to better support the Python community.
\nWe’ll review the most potent challenges in the Python packaging ecosystem\, and present our roadmap for adapting the Wheel format to enable native support for specialized hardware\, the use of non-default Python package indexes\, and managing diverse compute backends\, all while maintaining the accessibility and simplicity Python is known for. We'll issue a call to action from the open source community\, supported by important libraries such as PyTorch\, JAX\, Scikit-learn\, etc. This is a unified roadmap for the future of Python packaging\, and present published and draft PEPs.
\nManaging software stacks in complex compute environments is difficult. Often the standard wheel tags aren’t sufficient to describe your exact compute environment. These are common problems for many users\, are often difficult to remedy\, and even more difficult to make reproducible\, easy to use\, and composable.
\nWe propose to “Re-Invent the Wheel” and have founded the “Wheel Next” interest group as an open source collaboration among different users\, companies\, packages\, and maintainers that are working together on solutions to these difficult problems. We are actively publishing PEPs that extend the Wheel format\, metadata\, packaging tooling\, and PyPI standards\, and contribute to projects that help with various aspects of the problem space\, including installers and indexes.
\nIn addition\, we’ll give a call to action for everyone interested in joining the initiative and helping us evolve and build the packaging ecosystem the Python world needs today and in the future.
\nSpeakers:\nJonathan Dekhtiar\nJonathan Dekhtiar has been contributing to many Deep Learning libraries\, compilers and frameworks since 2019. At NVIDIA\, he played a key role in designing Python software and libraries release mechanisms and solving packaging challenges for GPU-accelerated Python code. As a driving and founding force behind the Wheel-Next initiative\, Jonathan has dedicated significant energy to advance this open-source effort with the community and is actively working on proof of concepts\, demos and on the writing of PEPs.
\nPrevious Talk and Conferences:\n- CVPR 2020 - Workshop Chair - https://workshop-edlcv.github.io/\n- ICML 2019 - Workshop Chair - https://icml.cc/virtual/2019/workshop/3520\n- ICML 2019 - Automatic Mixed Precision Training &\; Inference: https://slideslive.com/38917378/mixed-precision-training-inference
\nBarry Warsaw\nBarry Warsaw has been a core Python developer since 1994\, and is currently employed as a Principle System Software Engineer at NVIDIA where he works on Wheel-Next and other Python-focused initiatives\, both inside the company and in the Open Source community. He has served as Release Manager and Python Steering Council member in 2019\, 2020\, 2021\, 2024\, and 2025. He’s both organized and participated in the annual Python Language Summit at PyCon US. He was the GNU Mailman and Jython/JPython project leader at various times\, and in the early days of Python served as postmaster\, webmaster\, and more.
\nBarry has spoken at Pycon many times in the past:
\nPython 3.13's new free-threaded build brings the possibility of true parallel execution into Python code for the first time.
\nThis brings promise of significant performance opportunity\, but not without cost. Parallel execution is notorious for being challenging due to the additional complexity. This implies bugs\, and the risk is particularly high for the compiled code powering Python - including the CPython interpreter itself (it's written in C). The main risk comes from data races\, which can cause unpredictable and potentially dangerous crashes.
\nThe Rust programming language is designed to prevent data races by construction\; if your code runs\, it should be data race free (unless you misuse unsafe Rust).
We'll explore the way that Rust does this\, both from the rules of the language\, and by the data structures it offers to complement those rules. We'll showcase this with examples of Rust (PyO3) code designed for "regular" Python 3.13 and how it changes to become compatible with the free-threaded build.
\nThis will lead onto ideas which we can carry across languages to influence how we write Python (and maybe C/C++) to be correct in a free-threaded world\, before closing with some tantalizing examples of software architectures made possible by free-threaded Python.
\nNo prior Rust knowledge necessary.
\nWhat you should hope to take away from this talk:\n- a basic understanding of how the free-threaded build of Python is different to the regular one\,\n- an appreciation for the complexity of free-threading for compiled code\,\n- how Rust helps you reason about this complexity\, and\n- excitement for the future of free-threaded Python!
\nSpeakers:\nDavid Hewitt\n-
DTEND:20250516T161500Z LOCATION:Hall C DTSTART:20250516T154500Z STATUS:CONFIRMED SUMMARY:[talk] Using Rust in Free-Threaded vs Regular Python 3.13 TRANSP:OPAQUE UID:6c2adc87-91d0-56a3-809e-dab65d517dbd URL:https://us.pycon.org/2025/schedule/presentation/110/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Supercharge your Python library using AST parsing\nhttps://us.pycon.org/2025/schedule/presentation/129/\nThe primary goal of developers using the Python/C API is to increase the performance of their Python code. Often\, this is done by executing a C function which has been compiled into machine code to bypass the Python interpreter. However\, between a user’s Python code and the invocation of the C function\, we can squeeze out even more performance. How\, you ask?
\nWe can leverage AST parsing with Python’s standard library “ast” module to modify the syntax of the code. In this talk\, we show some tricks to transform the Python AST for optimized runtime performance using the C API. These aren’t just theoretical\, either! Each example is taken from CSP\, an open-source computation graph library which heavily uses the Python/C API.
\nThis talk is meant for an advanced audience which has familiarity with the Python “ast” module as well as the Python/C API.
\nSpeakers:\nAdam Glustein\nAdam Glustein is a Quantitative Developer at Point72 Asset Management in New York\, USA. He is a contributor to CSP\, a reactive stream processing library for both realtime and historical data.
DTEND:20250517T190000Z LOCATION:Hall C DTSTART:20250517T183000Z STATUS:CONFIRMED SUMMARY:[talk] Supercharge your Python library using AST parsing TRANSP:OPAQUE UID:348ce11b-f9ba-5931-a93b-cd5546c2ba63 URL:https://us.pycon.org/2025/schedule/presentation/129/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: 503 days working full-time on FOSS: lessons learned\nhttps://us.pycon.org/2025/schedule/presentation/164/\nI worked full-time on a Python FOSS project (Textual) for 503 days\, so what did I learn?
\nAm I a better (Python) programmer?\nAm I a better teammate?\nAm I a better person?
\nIn this talk\, I will share some lessons I learned over the course of these 503 days:
\nAs for the first 3 questions... Ask my colleagues!
\nSpeakers:\nRodrigo Girão Serrão\nRodrigo Girão Serrão is the author of multiple independently published books on Python\, programming\, and mathematics\, and frequently blogs about those same topics.\nRodrigo has also presented talks and tutorials at some of the largest Python conferences in the world\, including PyCon US\, EuroPython\, and multiple European PyCons.
\nAs a fun fact\, Rodrigo also taught “the largest programming lesson in the world”\, a Guinness World Record established in late 2024.
\nWhen he is not working or writing\, Rodrigo can be found playing board games\, walking his dog\, or exercising at the gym.
DTEND:20250516T200000Z LOCATION:Room 301-305 DTSTART:20250516T193000Z STATUS:CONFIRMED SUMMARY:[talk] 503 days working full-time on FOSS: lessons learned TRANSP:OPAQUE UID:49c1477c-efb6-5a29-a062-fe2c918a4ffa URL:https://us.pycon.org/2025/schedule/presentation/164/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Unraveling Community Support For Free-Threaded Python\nhttps://us.pycon.org/2025/schedule/presentation/42/\nShipping the free-threaded build of Python 3.13 was just the first step towards unlocking scalable multithreaded parallelism in Python. To unlock improved performance for real-world compute tasks\, the universe of community-maintained open source packages also needed to be updated. This is the story of the first year of that effort.
\nWe will share tools\, techniques\, and guidance gained from porting Cython\, NumPy\, SciPy\, PyO3\, and many other packages with C\, Cython\, C++\, Fortran\, and Rust native extensions to support free-threaded Python\, illustrated by anecdotes from our experiences.
\nAttendees will learn about tools and techniques to discover and fix thread safety issues and multithreaded scaling bottlenecks in packages with native extensions or dependencies. If you are unsure about how to support free-threaded Python in a package you maintain\, we hope that this talk will give you a plan and the toolbox necessary to accomplish the task.
\nThis talk is targeted at developers and maintainers of Python packages that include native dependencies as well as people who are interested in contributing to community packages that include native code. We assume some prior knowledge with native Python extensions written in C\, C++\, Rust\, or Cython.
\nSpeakers:\nLysandros Nikolaou\nLysandros works as a Senior Software Engineer at Quansight Labs\, where he spends most of his time on CPython and the PyData ecosystem. He is a CPython core developer\, specializing in the parser\, the tokenizer and the REPL. He recently worked on supercharging f-strings in Python 3.12\, the new REPL for Python 3.13 and introducing fast string ufuncs in NumPy 2.0. Currently\, he's mostly dealing with improving support for free-threaded Python in the PyData ecosystem.
\nNathan Goldbaum\n-
DTEND:20250516T171500Z LOCATION:Hall C DTSTART:20250516T163000Z STATUS:CONFIRMED SUMMARY:[talk] Unraveling Community Support For Free-Threaded Python TRANSP:OPAQUE UID:4905e95e-da65-51e6-97af-5003dcf070c1 URL:https://us.pycon.org/2025/schedule/presentation/42/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Processing large JSON files without running out of memory\nhttps://us.pycon.org/2025/schedule/presentation/125/\nIf you need to process a large JSON file in Python\, it’s very easy to run out of memory while loading the data\, leading to a super-slow run time or out-of-memory crashes. If you're running in the cloud\, you can get a machine with more memory\, but that means higher costs. How can you process these large files without running out of memory?
\nIn this talk you'll learn:
\nThen\, you'll learn some of the solutions to this problem:
\n-
DTEND:20250518T173000Z LOCATION:Ballroom A DTSTART:20250518T170000Z STATUS:CONFIRMED SUMMARY:[talk] Processing large JSON files without running out of memory TRANSP:OPAQUE UID:b30256b4-082a-5d1a-9cef-8e13e9b9c050 URL:https://us.pycon.org/2025/schedule/presentation/125/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Programming for Yourself\nhttps://us.pycon.org/2025/schedule/presentation/79/\nThe career benefits of learning programming have become increasingly obvious over time\, but few people talk about another great super-power you get from learning to program: the ability to make things that solve your own problems.
\nIn this talk\, I'll go through a few case studies from my own life wherein knowing how to program not only allowed me to solve problems for myself\, but also allowed me to recognize that the problem I was having had a solution at all.
\nAdditionally\, I'll talk about ways the approach to engineering changes (and doesn't change!) when programming bespoke applications for a small audience.
\nSpeakers:\nPaul Ganssle\nPaul Ganssle is a software developer at Google and contributor to various open source projects. Among other projects\, he is a core developer of the Python language and created the zoneinfo module.
\nHe lives in Somerville\, MA with his wife and two children\, where he spends most of his time training for a spot on a potential future Catfish Noodling Olympic team.
DTEND:20250516T191500Z LOCATION:Room 301-305 DTSTART:20250516T184500Z STATUS:CONFIRMED SUMMARY:[talk] Programming for Yourself TRANSP:OPAQUE UID:22a299e0-1845-536f-8d8a-59034e52e600 URL:https://us.pycon.org/2025/schedule/presentation/79/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Tips and Tricks for JSON Web Tokens (JWTs)\nhttps://us.pycon.org/2025/schedule/presentation/91/\nJSON Web Tokens (JWTs) are a neat tool useful in many contexts from simple demos to complicated multi-server architectures. The goal of the talk is to give developers a basic understanding of what JWTs are\, why they are useful\, and how to get started using them in python. JWTs can be as lightweight as a JWT library and a few decorators or as thorough as a full-fledged authentication architecture.
\nWhen using public key encryption/signatures\, validating the JWT does not need require maintaining state\, secrets\, passwords\, or user databases. This makes JWTs a robust\, efficient\, and flexible tool for serverless applications\, horizontal scaling (e.g.\, load balancing)\, microservices\, and APIs.
\nIn this talk\, I will provide an introduction to JWTs and provide a simple example of how they can be combined with decorators for easy and flexible authentication. The goal is to give developers unfamiliar with JWTs ideas on how and when to include them in their own applications.
\nSpeakers:\nEmin Martinian\nEmin Martinian has over 25 years of experience in technical research and development. He enjoys finding creative solutions to complex problems in software engineering\, machine learning\, data compression\, prediction\, optimization\, health\, and finance.
\nHe has over 10 patents granted and 30 peer reviewed publications based on research with Mitsubishi Electric Research Labs and MIT (where he earned a PhD in EE/CS). On the development side\, Emin has built software and led teams at small start-ups such as OPC Technologies (acquired by MentorGraphics)\, ViveBenefits and others as well as larger companies such as Bain Capital and DCG.
\nHe is available for consulting through his company AOCKS LLC.
DTEND:20250516T191500Z LOCATION:Hall C DTSTART:20250516T184500Z STATUS:CONFIRMED SUMMARY:[talk] Tips and Tricks for JSON Web Tokens (JWTs) TRANSP:OPAQUE UID:a545a5ac-9ea0-5b65-adb0-04afa85f25e0 URL:https://us.pycon.org/2025/schedule/presentation/91/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: What's New in the Linux Kernel... from Python\nhttps://us.pycon.org/2025/schedule/presentation/12/\nEvery new version of the Linux kernel comes with new features\, many of which can be easily used in Python. In this introduction to the world of systems programming in Python\, we'll use our favorite language to try out a couple of new features added to the Linux kernel over the past year. Along the way\, we'll learn about tools in the Python standard library for interfacing with the operating system and working with C-style data structures.
\nSpeakers:\nGeoffrey Thomas\nGeoffrey Thomas is a software engineer with interests in operating systems infrastructure\, security\, and packaging. In his day job he has built countless Python packages from source in the course of importing them into internal build systems. He may be best known to the Python community indirectly as one of the authors of PEP 668\, which broke sudo pip install (for good reasons\, he promises). Geoffrey was also the co-creator of the initial support for writing Linux kernel modules in Rust and worked to get Rust support accepted in the mainline Linux kernel. Outside of software\, he is active in his church choir and in local activism for streets and housing.
End-to-end signing and verification is one of the hardest technical and social challenges in open source packaging: it rests at the fault lines of error- and misuse-prone cryptography\, long-term secret management\, and identity/trust bootstrapping. These challenges have stymied past attempts to do large-scale end-user signing in the Python ecosystem\, including PyPI's former (now disabled) support for PGP signature uploads.
\nOver the past year\, PyPI has designed\, developed\, and deployed a new approach to package signing\, one that aims to break the iron triangle of end-user signing: digital attestations\, as standardized in PEP 740.
\nThis talk will cover the architectural details of attestations\, how attestations were implemented on PyPI and on the client (uploading side)\, their security properties (including transparency) and advantages\, as well as how PyPI was able to enable signing by default for a large swath of the ecosystem without requiring maintainers to change anything about their packaging processes. The talk will also cover the future of attestations\, including pieces of the puzzle that are currently missing (like large-scale verification of attestations by parties other than PyPI itself).
\nThe audience is expected to have an intermediate familiarity with Python packaging\, including PyPI. No specific familiarity with cryptography is required. Audience members will leave the talk with an improved understanding of the challenges latent in end-user signing\, how PEP 740's design and PyPI's implementation overcome those challenges\, and how they can both produce and consume attestations today.
\nSpeakers:\nWilliam Woodruff\nWilliam Woodruff is an Engineering Director at Trail of Bits\, a NYC-based consultancy. He splits his time between OSS engineering and running the Ecosystem Security group\, which is responsible for contributing security and usability improvements to a wide range of OSS tools and services (PyPI\, Homebrew\, pip-audit\, Sigstore\, LLVM\, PyCA Cryptography\, etc.). Outside of work\, William is a member of Homebrew and contributes to a variety of OSS projects. He blogs at https://blog.yossarian.net.
DTEND:20250517T194500Z LOCATION:Ballroom A DTSTART:20250517T191500Z STATUS:CONFIRMED SUMMARY:[talk] Attestations: a new generation of signatures on PyPI TRANSP:OPAQUE UID:9d660b4d-1c7b-5223-8f2f-240444e0bd45 URL:https://us.pycon.org/2025/schedule/presentation/76/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Finding 2.0\nhttps://us.pycon.org/2025/schedule/presentation/158/\nIn the world of library development\, achieving version 2.0 often takes years\, if it's achieved at all. Surprisingly\, nearly 90% of packages published to PyPI using semantic versioning have a major release number of less than two. What makes reaching this milestone so elusive?
\nIf we applied software versioning to our lives\, what version would we give ourselves? Perhaps in our formative years as students\, we'd be a part of a 0.x series\, and as we establish careers and become self-sufficient\, we might progress to a 1.x scheme. But do we settle there?
\nJust like software libraries\, our lives require maintenance\, and despite our best intentions\, hacks and workarounds inevitably infiltrate our routines. As these multiply and compound\, our health can suffer. Do we wait for disaster to strike? Or\, can we take a proactive approach in not only addressing problem areas but also striving for more?
\nTogether\, we'll explore certain risks to our wellbeing inherent to our profession as software developers: sedentary lifestyles\, long work hours\, and social isolation\, and how we can plan and design our next major release for success.
\n"Finding 2.0" is an invitation to reimagine what's possible across life areas. Whether facing health struggles\, burnout\, or feeling stuck in a rut\, this talk provides practical insights and actionable steps for rewriting the code of your life and embracing a future of health and fulfillment.
\nSpeakers:\nMarc Gibbons\nMarc caught the programming bug as a child when the internet was still text-based and accessed by a 9600 baud modem.
\nHis career path is unique\; he initially studied music and played the oboe professionally with Canadian symphony orchestras before returning to his coding roots as a full-stack engineer.
\nPassionate about enhancing the developer’s quality of life\, Marc excels in testing\, tooling\, and automation. Beyond the technical realm\, he explores ways to promote happiness\, health\, and connection in a remote work setting.
\nAs a two-time cancer survivor\, Marc is on a mission to help and inspire others facing adversity. He founded Port Perry Pedals\, a cycling fundraiser in the Greater Toronto Area which raised over $120\,000 for healthcare in his community.
DTEND:20250517T150000Z LOCATION:Ballroom A DTSTART:20250517T143000Z STATUS:CONFIRMED SUMMARY:[talk] Finding 2.0 TRANSP:OPAQUE UID:2afb56dc-31ce-5c09-9cde-6b07ac2bebaf URL:https://us.pycon.org/2025/schedule/presentation/158/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Building a NoGIL Load Balancer in 30 minutes\nhttps://us.pycon.org/2025/schedule/presentation/113/\nLoad balancers are widespread nowadays because most software systems are web-centric and service oriented. However\, they’re extremely complex to build\, because they must be very performant and use sophisticated algorithms to route traffic. Until recently\, you couldn’t use Python to build one\, because even though it would make the code simpler\, the GIL prevented multiple threads from executing Python at the same time.\nNow that you can\, what are the practical implications in your day to day work?\nIn this talk\, we’re going to live code a load balancer in Python. This will help us understand the pros and cons of using modules such as asyncio\, threading and concurrent.futures\, and what changes when we remove the GIL from the way.\nWhether you’re building systems that demand concurrency (such as AI models or DevOps pipelines)\, or you’re just curious about how tools like gUnicorn or Starlette work under the hood\, you’ll come away with practical insights on how to start off the NoGIL era on the right foot.
\nSpeakers:\nAlvaro Duran\nI write software that moves money around—in Python. It’s software that must be highly available\, performant and correct every single time. Building this kind of system has made me deeply familiar with the design patterns\, libraries and frameworks needed for reliability at scale. I am obsessed with high quality testing and fast product validation cycles.\nI also author The Payments Engineer Playbook\, a newsletter read by over 1\,500 fintech engineers\, where I explore the technical challenges of building money software.\nI use Vim\, I like pineapple in my pizza—and I won't apologize for either.
DTEND:20250516T153000Z LOCATION:Hall C DTSTART:20250516T150000Z STATUS:CONFIRMED SUMMARY:[talk] Building a NoGIL Load Balancer in 30 minutes TRANSP:OPAQUE UID:0216aff8-5cd5-58b0-861f-3d66c1248d03 URL:https://us.pycon.org/2025/schedule/presentation/113/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Scale Smarter\, Not Harder\, with cuPyNumeric.\nhttps://us.pycon.org/2025/schedule/presentation/63/\nMany data and simulation scientists use NumPy for its ease of use and good performance on CPU. This approach works well for single-node tasks\, but scaling to handle larger datasets or more resource-intensive computations introduces significant challenges. Not to mention\, using GPUs requires another level of complexity. We present the cuPyNumeric library. cuPyNumeric gives developers the same familiar NumPy interface\, but seamlessly distributes work across CPUs and GPUs.
\nA compelling example when scaling is necessary is when scientists at the SLAC National Accelerator Laboratory need to process a large amount of data within a fixed time window\, called beam time. The full dataset generated during experiments is too large to be processed on a single CPU. Additionally\, the code often must be modified during the beam time to adapt to changing experimental needs. Being able to use NumPy syntax rather than lower level distributed computing libraries makes these changes quick and easy\, allowing researchers to focus on conducting more experiments rather than debugging or optimizing code.
\ncuPyNumeric is designed to be a drop-in replacement to NumPy. Built on top of task-based distributed runtime from Stanford University\, it automatically parallelizes NumPy APIs across all available resources\, taking care of data distribution\, communication\, asynchronous and accelerated execution of compute kernels on both GPUs or multi-core CPUs. In addition\, cuPyNumeric can be integrated with other popular Python libraries like SciPy\, matplotlib\, Jax. With cuPyNumeric\, SLAC scientists successfully ran their data processing code distributed across multiple nodes and GPUs\, processing the full dataset with a 6x speed-up compared to the original single-node implementation.
\nIn this talk we showcase the productivity and performance of cuPyNumeric library covering some detail on its implementation.
\nSpeakers:\nIrina Demeshko\nIrina Demeshko is a senior software engineer at NVIDIA working on cuNumeric and Legate projects. Before NVIDIA\, Irina was a research scientist and team leader of the Co-Design team at the Los Alamos National Laboratory. Her work and research interests are in the area of new HPC technologies and programming models. Irina received her Ph.D. in mathematical and computer science from the Tokyo Institute of Technology in 2013.
\nQuynh L. Nguyen\nQuynh L. Nguyen is an Associate Scientist at SLAC National Accelerator Laboratory. She completed her PhD in Physics at JILA-University of Colorado Boulder (2020) and postdoctoral work at SLAC National Accelerator Laboratory and Stanford University as a Q-FARM Bloch Fellow. Her research interests include nonequilibrium dynamics of materials and high performance computing with applications towards quantum information science.
DTEND:20250517T150000Z LOCATION:Ballroom BC DTSTART:20250517T143000Z STATUS:CONFIRMED SUMMARY:[talk] Scale Smarter\, Not Harder\, with cuPyNumeric. TRANSP:OPAQUE UID:709d58ce-53b1-592d-8432-89e7f93c97e5 URL:https://us.pycon.org/2025/schedule/presentation/63/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: The Most Bizarre Software Bugs in History\nhttps://us.pycon.org/2025/schedule/presentation/17/\nWe've all heard that we should test our software\, but what happens when we don't? Sometimes\, it leads to strange and unexplainable events.
\nIs 'testing more' always the right solution? What do these bugs reveal about software and its failures? And how can we use these lessons to build more resilient systems?
\nLet's take a look at the most bizarre software bugs in history.
\nSpeakers:\nMia Bajić\nAs a software engineer\, I design and build backend systems that power data products.
\nBeyond my daily work\, I serve as Vice Chair of the EuroPython Society\, where I help shape one of Europe’s largest Python events. I also co-organize local events in Prague. I believe strongly in the power of education\, and through organizing these events\, I contribute to building a more open and connected community.
\nI write a TIL blog\, where I share what I've recently learned: https://clytaemnestra.github.io/tech-blog/
DTEND:20250516T214500Z LOCATION:Ballroom BC DTSTART:20250516T211500Z STATUS:CONFIRMED SUMMARY:[talk] The Most Bizarre Software Bugs in History TRANSP:OPAQUE UID:f9d78e51-cc61-58cc-910f-5aac419f1d70 URL:https://us.pycon.org/2025/schedule/presentation/17/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: A PEP Talk: Adventures in Account Recovery\, PEP 541\, And More As the Inaugural PyPI Support Specialist\nhttps://us.pycon.org/2025/schedule/presentation/165/\nPyPI (Python Packaging Index) is used by over 800\,000 users. With its ever growing user base and popularity\, comes the need for making sure the PyPI ecosystem is secure for all users all without constraining ease of use. Part pep talk (pun intended!)\, part presentation\, this talk plans to discuss some of the challenges that were tackled in terms of bringing the various PyPI support backlogs current in both account recovery and PEP 541 as well as other support requests. This talk will also discuss process improvements made\, lessons learned\, and what’s in store in the future for PyPI support.
\nSpeakers:\nMaria Ashna\nMaria is the inaugural PyPI Support Specialist at the PSF. Prior to PSF\, she has worked at the Brain and Creativity Institute at USC working on the neuroscience of creativity. Maria is also the founder of The Magic Light Bulb\, Inc.\, a tech and product consulting firm and has worked in various roles in tech starting from technical project specialists to technical product management. Maria is also a classically trained performer who has trained in theatre and performing arts with the faculty of the Moscow Art Theatre School and American Rep Theatre at Harvard University and has performed in numerous theater and film productions around the world. She received her first Master's degree in Information Systems and Technology from Claremont Graduate University\, and her second Master's in Neuroimaging and Informatics from USC. Maria has also studied neuroscience and theatre as an undergraduate at University of New Mexico. A Pythonista (and fashionista!)\, she is excited to be a part of PSF.
DTEND:20250517T204500Z LOCATION:Ballroom A DTSTART:20250517T201500Z STATUS:CONFIRMED SUMMARY:[talk] A PEP Talk: Adventures in Account Recovery\, PEP 541\, And More As the Inaugural PyPI Support Specialist TRANSP:OPAQUE UID:2715a353-51a5-5673-8b1d-5a3780d5bfa0 URL:https://us.pycon.org/2025/schedule/presentation/165/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Diving into the Deep End: A Python Journey in Water Management\nhttps://us.pycon.org/2025/schedule/presentation/104/\nSix years ago\, I was asked to create a better Excel spreadsheet to track water requests for a small irrigation district. That request sparked an unexpected journey: from knowing only basic Python syntax to building a SaaS platform that models physical water delivery systems. This platform now handles water accounting\, delivery tracking\, scheduling\, reporting\, and even simulation for real-world use.
\nIn this talk\, I’ll share how I tackled challenges like:\n- Transitioning from spreadsheets to a Python-powered solution.\n- Modeling physical systems without a background in discrete mathematics\, graph theory\, or simulation.\n- Scaling a personal learning project into a production-ready SaaS application.
\nI’ll also explore the tools and techniques that made it possible\, the lessons I learned along the way\, and the moments of failure and success that shaped my journey. Whether new to Python\, considering tackling a big project\, or just curious about real-world applications of Python\, this talk will inspire attendees to dive in and solve problems beyond their comfort zone.
\nSpeakers:\nJack Linke\nJack Linke tends to learn the hard way - and shares the lessons from those experiences with others through blogging\, tweets\, and speaking engagements. He has been developing software and hardware projects off-and-on for most of his life\, but much of his relevant Python development experience has been hard-earned over the past five years during development of Watervize - a B2B2B SaaS web application (written in Django) to help irrigation water utility companies improve efficiency\, analysis\, and communication with staff and agriculture customers.
\nJack’s technology interests include Python\, the Django project\, simulation\, GIS\, graph theory\, data storytelling\, and visualization. He is a frequent contributor to the open source community\, an Individual Member of the Django Software Foundation\, and a contributing member of the Python Software Foundation.
\nHis speaking experience includes briefing Generals on topics ranging from budgets to technical concepts\, instructing at formal training centers\, providing software demonstrations and feature walk-throughs\, and he was certified as a Weapons and Tactics Instructor (WTI) while serving as a Marine Corps Officer.
\nOutside of coding\, Jack takes his Husky (Lady Duchess) on adventures\, solves unusual math and logic problems\, and makes a mess in the kitchen (and life).
DTEND:20250516T153000Z LOCATION:Room 301-305 DTSTART:20250516T150000Z STATUS:CONFIRMED SUMMARY:[talk] Diving into the Deep End: A Python Journey in Water Management TRANSP:OPAQUE UID:a6845065-8407-57da-9cf5-e5cd1b0e69c4 URL:https://us.pycon.org/2025/schedule/presentation/104/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: The past\, present\, and future of virtual environments\nhttps://us.pycon.org/2025/schedule/presentation/32/\nVirtual environments have become an essential part of the Python developer experience\, but recent tools provide workflows where virtual environments are no longer the center of user interactions.
\nThis talk explores the evolution of virtual environments\, from their originating motivations and the role they serve today to a vision for the future\, with a particular focus on how virtual environments are becoming automated\, hidden\, and disposable.
\nVirtual environments were introduced in 2004. We’ll briefly discuss the history of the tools built to manage virtual environments. We’ll talk about the differences between imperative and declarative environment management. Then\, we’ll dive into the user experiences powered by automating management of environments\, using uv as a primary example.
\nFinally\, we’ll discuss limitations of the existing tooling and how they may be overcome in the future\, such as\, improving the IDE experience for scripts with inline metadata\, locking build requirements\, and using declarative interfaces for global environments.
\nSome prior knowledge of virtual environments and Python packaging will be necessary to reason about the broader questions posed\, but the talk will attempt to give the necessary background — deep Python knowledge will not be needed. The talk will be focused on user experience and abstractions rather than implementation details.
\nSpeakers:\nZanie Blue\nZanie is passionate about empowering developers and scientists through powerful\, friendly tooling. They have a background in computational neuroscience and bioinformatics\, but now they build open source tools for Python in Rust at Astral. They have too many hobbies and a very cute dog named Basho.
DTEND:20250518T190000Z LOCATION:Ballroom A DTSTART:20250518T183000Z STATUS:CONFIRMED SUMMARY:[talk] The past\, present\, and future of virtual environments TRANSP:OPAQUE UID:1bd8e5e6-f37a-5444-a5b7-80353595f082 URL:https://us.pycon.org/2025/schedule/presentation/32/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Phantom Dependencies: is your requirements.txt haunted?\nhttps://us.pycon.org/2025/schedule/presentation/14/\nDid you know there’s more than Python code included in Python packages? This might be a surprise\, especially if you’ve inspected your list of dependencies and only found exactly what you've pip-installed. There's something else lurking in the dark corners of your virtual environments.
\nModern software systems are complex\, graph-like\, and difficult to measure by both humans and our tools. Luckily there’s an answer: Software Bill-of-Materials (SBOMs). SBOMs can describe any amalgamation of Python\, C\, C++\, Rust\, and JavaScript in your Python application which enables static code analysis\, license compliance\, vulnerability management\, and complying with new security regulations.
\nBy the end of this talk you'll know what Software Bill-of-Materials documents are\, why they are useful\, and what you need to do when someone asks for one!
\nSpeakers:\nSeth Michael Larson\nSecurity Developer-in-Residence and Fellow of the Python Software Foundation\, Minnesoootan
DTEND:20250518T181500Z LOCATION:Ballroom BC DTSTART:20250518T174500Z STATUS:CONFIRMED SUMMARY:[talk] Phantom Dependencies: is your requirements.txt haunted? TRANSP:OPAQUE UID:4805bf62-8ba1-51dd-bcac-8d03077bfac5 URL:https://us.pycon.org/2025/schedule/presentation/14/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: What they don't tell you about building a JIT compiler for CPython\nhttps://us.pycon.org/2025/schedule/presentation/5/\nDespite their reputation\, just-in-time compilers are not magic “go faster” machines. Developing and maintaining any sort of optimizing compiler for even a single platform\, let alone all of Python’s most popular supported platforms\, is an incredibly complicated\, expensive task.
\nHowever\, figuring out how to compile Python code down to machine code is just the beginning. Most talks and other resources about JITs offer an interesting introduction to the general approaches used\, but gloss over the most interesting technical issues that need to be solved in order to actually "ship" these performance gains in practice.
\nAs one of the engineers working on Microsoft's ambitious "Faster CPython" project\, I'll introduce some of the challenges that we've encountered over the past year in our quest to make your code faster. Along the way\, we'll learn how JITs decide what code to compile\, how they compile this code in-process in a safe and secure way\, and the debugging and profiling requirements that users have come to expect from native code.
\nSpeakers:\nBrandt Bucher\nBrandt is a Python core developer working at Microsoft on a team tasked with improving the speed of the CPython interpreter.
\nHe has officially been involved in CPython development for over five years now\, and has improved its performance\, stability\, and expressiveness in a variety of ways. In addition to his ongoing contributions as part of the "Faster CPython" project in the 3.11-3.14 release cycles\, he also helped design and lead the implementation of structural pattern matching\, a major new feature of Python 3.10.
\nWhen he’s not pushing new commits on GitHub as @brandtbucher\, he spends most of his free time at coffee shops\, sipping espresso and reading nonfiction.
DTEND:20250517T204500Z LOCATION:Room 301-305 DTSTART:20250517T201500Z STATUS:CONFIRMED SUMMARY:[talk] What they don't tell you about building a JIT compiler for CPython TRANSP:OPAQUE UID:00924338-d1f8-5b7c-95af-2faea3728e0d URL:https://us.pycon.org/2025/schedule/presentation/5/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Or Else! An Exploration of Obscure Control Flow\nhttps://us.pycon.org/2025/schedule/presentation/85/\nEveryone knows how an if-else block works\, but what about a for-else block? Or try-except-else? What do those do\, and how can they help us write cleaner code? What other hidden gems await us in the halls of Python grammar? Come join us for an adventure into depths of the Python world less traveled.
\nWe'll start with a brief look at the fundamentals of program control flow\, and how our choices as developers influence the readability and maintainability of our code. We'll look at some easy ways to use lesser-known syntax elements to make common code patterns more obvious\, and compare and contrast them with equivalent alternatives.
\nNext\, we'll start to pull back the curtains a bit on how Python handles more complex control flow mechanisms\, like generators and decorators\, and look at ways to leverage those features to build higher order functionality. Lastly\, we'll get a bit reckless and look at how Python makes it possible to create our own systems for control flow\, and consider committing some light crimes in the name of code readability.
\nWe might even implement the highly desired "do-while" loop while we're at it.
\nSpeakers:\nAmethyst Reese 🌸\nAmethyst is a senior engineer at Meta\, working on foundational Python infrastructure and tooling to support thousands of engineers\, data scientists\, and ML researchers. She is also the maintainer of numerous open source libraries on PyPI\, and an experienced speaker from Python conferences and meetups around the world.
DTEND:20250516T214500Z LOCATION:Room 301-305 DTSTART:20250516T211500Z STATUS:CONFIRMED SUMMARY:[talk] Or Else! An Exploration of Obscure Control Flow TRANSP:OPAQUE UID:271e98a9-3b7a-5bd5-bfa9-c0047b5f235f URL:https://us.pycon.org/2025/schedule/presentation/85/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Metaclasses Demystified\nhttps://us.pycon.org/2025/schedule/presentation/137/\nMetaclasses are among the deep magic of Python\, which most developers will ever need. As Python pushes into more and more spaces\, and becomes responsible for increasingly complex software\, there's a need for elegant solutions to some specific architectural problems\; metaclasses are a part of some of those solutions.
\nIn this talk\, you'll learn all about the enigmatic metaclass\, and where this often esoteric part of Python actually can come in handy. Then\, we'll wrap up by ensuring you're attacking the right problems before reaching for this oft-alluring piece of arcana.
\nSpeakers:\nJason C. McDonald\nJason C. McDonald is a principal software engineer and author with a passion for communication and education. He mentors young developers\, especially through his open source organization's internship program\, and has written many articles on a variety of computer science topics ranging from the technical to the interpersonal. He's the author of "Dead Simple Python" (No Starch Press)\, based on his popular article series of the same name.
\nJason draws from his journey recovering from a traumatic brain injury to help people achieve their full potential. In addition to his programming career\, Jason is a fiction author and an independent songwriter with a love of absurdist humor and wordplay.
DTEND:20250517T213000Z LOCATION:Hall C DTSTART:20250517T210000Z STATUS:CONFIRMED SUMMARY:[talk] Metaclasses Demystified TRANSP:OPAQUE UID:a7d7e5e1-98c8-502d-bbfd-4c7ab64e1bc4 URL:https://us.pycon.org/2025/schedule/presentation/137/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Building Resilient Data Pipelines: The Power of Idempotency\nhttps://us.pycon.org/2025/schedule/presentation/68/\nData pipelines are vital for moving data from source to destination. They help with use cases like integrating multimodal data\, building a data warehouse\, improving data quality\, and more.
\nOver many years\, developers have put forth many design patterns or best practices for building data pipelines in Python using Pandas\, Numpy\, and more. However\, one crucial criterion for creating a data pipeline is idempotency.
\nThis talk will open with a brief overview of data pipelines and the importance of idempotency in distributed systems. We’ll look to answer the question: What does it take to build an idempotent data pipeline in Python with an example?
\nOur exploration will begin with the pitfalls of non-idempotent pipelines\, then proceed to a methodology for building idempotent data pipelines and the design decisions that accompany them. Along the way\, we’ll explore testing strategies using pytest.
\nThis talk is aimed at those interested in building idempotent data pipelines.
\nSpeakers:\nMihir Kavatkar\nHi! My name is Mihir Kavatkar and I love architecting distributed systems\, building data pipelines and web applications. I am a Lead Software Engineer at Memorial Sloan Kettering Cancer Center. My team and I build software systems for molecular tests conducted at MSK in the Department of Pathology and Lab Medicine.
DTEND:20250516T210000Z LOCATION:Hall C DTSTART:20250516T203000Z STATUS:CONFIRMED SUMMARY:[talk] Building Resilient Data Pipelines: The Power of Idempotency TRANSP:OPAQUE UID:d86f9a2b-a2bc-5f35-b882-e612474e6e5f URL:https://us.pycon.org/2025/schedule/presentation/68/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Bridging IoT and Machine Learning with Python for Sustainable Agriculture\nhttps://us.pycon.org/2025/schedule/presentation/47/\nFood Insecurity is a major challenge that is ravaging the entire world especially Africa where Agriculture faces critical challenges in productivity\, sustainability\, and environmental deprivation. This is due to so many factors ranging from climate change to socio-economic factors. To combat this menace\, there is need for a robust and scalable system like IoT for weather monitoring and informed decision making for both the policy makers and the farmers to be able to mitigate these challenges. Python\, with its rich ecosystem\, serves as a bridge between the IoT devices and machine learning\, assisting in resolving these challenges and improving decision making in agriculture.\nThis talk explores the use of Python in delivering sustainable agriculture practices. We will look at how data is collected using Python from such IoT devices as soil\, weather\, and crop sensors. With the help of the Pandas and NumPy and SciPy libraries\, we will also show how the collected information is cleaned up and analyzed for further decision making.\nThe session also emphasizes connecting machine learning solutions via TensorFlow\, PyTorch\, and scikit-learn toward enhancing agriculture. Such examples include estimating when and how much irrigation to apply\, potential pest control measures needed\, and when and how much pest control measures will be accomplished.\nAttendees will learn the mechanics of building complete pipelines beginning from IoT data collection to final deployment of machine learning models in cloud or edge devices. Other concerns which we will tackle include the quality of data\, compatibility of devices\, policies on expansion\, and the solutions to these problems.\nThis talk is ideal for researchers\, developers\, and practitioners interested in leveraging Python to transform agriculture. By the end\, attendees will understand how Python can drive innovation\, sustainability\, and resilience in this critical sector.
\nSpeakers:\nIyinoluwa Moyosola Oyelade\nIyinoluwa Oyelade is an academic and researcher specializing in Machine Learning\, Data Science\, and IoT applications\, with a strong focus on sustainable solutions and innovative technologies. With extensive experience in developing AI-driven systems\, Iyinoluwa leverages expertise in Python programming to create scalable\, impactful solutions that address real-world challenges.\nA passionate advocate for technology-driven transformation\, Iyinoluwa has worked on IoT-based farmland security and AI-powered animal intrusion detection systems\, showcasing proficiency in integrating Python with cutting-edge tools such as TensorFlow\, PyTorch\, and scikit-learn. As a lecturer\, she mentors the next generation of data scientists\, emphasizing hands-on learning and fostering open collaboration.\nHaving participated in pivotal discussions like the AfricaConnect Meeting on IoT-Based Acquisition of Research Data for Scientific Computing and the workshop on "Investing in Africa’s Climate Future\," Iyinoluwa is committed to bridging data accessibility and sustainable development\, particularly in underserved regions.\nAdept at deploying Python for data analysis\, visualization\, and machine learning\, Iyinoluwa blends technical expertise with a deep understanding of global challenges. Enthusiastic about using Python as a tool for innovation\, she continually seeks to empower communities and inspire collaborative solutions to pressing issues
\nAlowolodu Olufunso Dayo\nAlowolodu Olufunso Dayo\, PhD\; is an Associate Professor of Information and Cyber Security in the Department of Cyber Security\, The Federal University of Technology\, Akure\, Nigeria. She holds PhD degree in Computer Science with specialization in Cloud Security and Cryptography from The Federal University of Technology\, Akure\, in 2016. She joined the services of the Federal University of Technology\, Akure in 2010 as an Assistant Lecturer and rose to the position of an Associate Professor in 2022. Currently\, she is researching into IoT Security using AI approaches. She is a registered Information Technology practitioner\, member\, Institute of Electrical and Electronic Engineering (IEEE)\, Computer Society\, Association for Computing Machinery (ACM)\, Cyber Security Experts Association of Nigeria (CSEAN)\, PyLadies Africa and Nigeria Chapter\,WACREN\, AnitaB.Org Systers among others. She is widely travelled with over 15 years of experience in teaching\, research\, training and development. She was the Acting Dean\, College of Computing\, McPherson University\, Nigeria\, The Current Head of Department of Cybersecurity\, Federal University of Technology\, Akure\, Nigeria. She has successfully supervised many postgraduate students and has series of publications in reputable conferences and journals to her credit.
DTEND:20250518T173000Z LOCATION:Hall C DTSTART:20250518T170000Z STATUS:CONFIRMED SUMMARY:[talk] Bridging IoT and Machine Learning with Python for Sustainable Agriculture TRANSP:OPAQUE UID:b217f755-d796-5a4c-878b-a0d48df7a8ba URL:https://us.pycon.org/2025/schedule/presentation/47/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: A11y Need Is Love (But Accessible Docs Help Too)\nhttps://us.pycon.org/2025/schedule/presentation/135/\nThe Beatles told us that ‘all you need is love’ and while that is a lovely sentiment\, love alone won’t fix low contrast colours\, missing focus states or inaccessible navigation. These barriers impact countless users with disabilities\, reducing the usefulness and reach of valuable documentation. So\, while love is great\, accessible docs are essential.
\nIn this talk\, we will use the PyData Sphinx Theme as a case study to explore common accessibility problems in documentation websites and how to tackle them. We will discuss the accessibility changes we made to the theme\, how those changes affected users\, and what we learnt along the way. Additionally\, we will also conduct a short accessibility audit on a website suggested by the audience. This demo will provide a practical understanding of how to improve accessibility.
\nWhether you’re a documentation maintainer\, a curious developer or simply someone who cares about accessibility\, this beginner-friendly talk will help you learn more about accessibility in documentation and how to get started. Love might be a universal language\, but your code appreciates accessible documentation.
\nSpeakers:\nSmera Goel\nBy day (and sometimes by night)\, Smera Goel is a UX/UI designer at Quansight Labs\, where she focuses on making open-source projects more accessible and user-friendly.
\nBeyond design\, Smera also contributes to community-driven projects like the Fedora Project and mentors aspiring designers through Outreachy. Talk to her about design\, accessibility\, mentorship or her ever-growing collection of instant noodles (she's always looking for recommendations).
DTEND:20250516T183000Z LOCATION:Ballroom BC DTSTART:20250516T180000Z STATUS:CONFIRMED SUMMARY:[talk] A11y Need Is Love (But Accessible Docs Help Too) TRANSP:OPAQUE UID:898b1280-9e95-5140-acb8-345b37d4af86 URL:https://us.pycon.org/2025/schedule/presentation/135/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Elastic Generics: Flexible Static Typing with TypeVarTuple and Unpack\nhttps://us.pycon.org/2025/schedule/presentation/83/\nSince Python 3.5\, generic tuples can be parameterized as either orderings of component types (e.g. tuple[int\, str]) or unbound sequences of a single type (e.g. tuple[float\, ...]). Yet sometimes we need both: for example\, a tuple that starts with an int and a str and follows with zero or more floats might describe a row in a dataset that starts with identifiers and follows with a variable number of observations. While we might want to define a generic Record class that can be elastically parameterized in this manner\, doing so was not practical until the introduction of TypeVarTuple and Unpack in Python 3.11.
With TypeVarTuple\, a generic Record class can be made concrete as Record[int\, str]\, Record[int\, str\, float]\, or even Record[int\, str\, *tuple[float\, ...]]: the same class can be parameterized as requiring two types\, three types\, or required int and str types followed by zero or more float types (as given with the Unpack notation *tuple[float\, ...]).
This presentation will introduce TypeVarTuple and Unpack. Starting with annotated tuple types\, the flexible\, expressive range of mixture between fixed and unbound types will be demonstrated with mypy validation. Next\, a variadic generic class\, Record\, will demonstrate the benefits of such elastic typing.
Finally\, a compelling application of TypeVarTuple will be demonstrated. While DataFrames are widely used\, only the StaticFrame library\, leveraging TypeVarTuple\, offers a comprehensively generic DataFrame. DataFrames have variable numbers of columns\, each sometimes a different type\; further\, while DataFrames might have tens or hundreds of columns\, it is common for such datasets to have a fixed number of heterogeneously typed columns followed by a variable number of uniformly typed columns. With TypeVarTuple\, this type of flexible DataFrame typing is now possible.
Christopher Ariza (www.flexatone.net) is Partner and Chief Technology Officer at Research Affiliates\, a global leader in investment strategies and research. He is the creator and lead developer of StaticFrame\, an alternative DataFrame library that offers immutable and statically-typeable DataFrames with runtime type and data validation.
\nHaving worked in Python for over 20 years\, he has developed tools in a variety of domains\, including algorithmic music composition and computer-aided musicology\, and has spoken at numerous conferences\, including PyCon USA\, SciPy\, PyData Global\, PyData Los Angeles\, and numerous other venues.
\nPrior to joining Research Affiliates\, he was Visiting Assistant Professor of Music at MIT\, Assistant Editor at the Computer Music Journal\, and Assistant Professor of Recording Arts and Music Technology at Towson University. He has a PhD and MA in music theory and composition from New York University\, and a BA in music from Harvard University.
DTEND:20250517T190000Z LOCATION:Room 301-305 DTSTART:20250517T183000Z STATUS:CONFIRMED SUMMARY:[talk] Elastic Generics: Flexible Static Typing with TypeVarTuple and Unpack TRANSP:OPAQUE UID:89f80e02-1c58-5567-b4f6-42edbe185319 URL:https://us.pycon.org/2025/schedule/presentation/83/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Who Tests the Testers? Making and Testing Pipelines\nhttps://us.pycon.org/2025/schedule/presentation/28/\nYou likely have a good pipeline that either runs tests\, lints\, or deployments for your project.
\nBut when it comes to changing that pipeline\, how sure are you that it works before taking those changes live?
\nIn this talk\, we'll explore why it doesn't have to be the case that "there's no devops for devops".
\nWe'll give a quick run down of what pipelines are\, and why they should be used\, before we give an example where it can be hard to know whether making changes to a pipeline will fail\, and why that can be the case.
\nThen\, we'll showcase tools and methodologies that can be used for testing\, creating\, and simulating pipelines\, so you too can setup a system to always be sure that your pipeline changes won't cause any water damage.
\nSpeakers:\nEvan Kohilas\nEvan is a serial international speaker and engineering productivity advocate who values frictionless simplicity\, taming tech debt\, thinking in systems\, and tightening feedback loops – all to improve the developer experience and achieve nohumanerrors.com
\nWhen he's not working on his next talk or project idea\, you may catch him as the Assistant Director for PyCon Australia\, dodging magpies while bike riding\, chasing frisbees\, or defending subway cookies.
DTEND:20250516T210000Z LOCATION:Ballroom BC DTSTART:20250516T203000Z STATUS:CONFIRMED SUMMARY:[talk] Who Tests the Testers? Making and Testing Pipelines TRANSP:OPAQUE UID:2bfc074e-a3aa-5852-935d-77aafcaaa814 URL:https://us.pycon.org/2025/schedule/presentation/28/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Working with Audio in Python (feat. Pedalboard)\nhttps://us.pycon.org/2025/schedule/presentation/115/\nDigital audio has been around for as long as computers\, but working with audio data can still be complicated\, especially in Python. In this talk\, we'll talk about how digital audio works from the ground up (from sounds\, to bytes\, to files)\, how you can use Python to do a bunch of really neat things with audio\, and how a Python library - Pedalboard - helps make working with audio much easier.
\nEver used a digital audio workstation (DAW) like GarageBand\, Ableton Live\, Logic\, or Pro Tools? Today's musicians use DAWs as instruments in themselves. But what if you want to combine the power of a DAW with the flexibility of writing your own code?
\nPedalboard was built to fill this niche: to pull the power of a DAW into your Python code. Pedalboard makes it easy to build and apply audio effects\, read and write audio files\, and load audio plug-ins ("VSTs") without any complicated dependencies or frameworks. Just import pedalboard and go!
Peter is a Staff Machine Learning Engineer at Spotify in New York\, where he helps lead their Audio Intelligence Lab - a machine learning research lab dedicated to pushing the state of the art in audio-based machine learning. He also maintains Pedalboard\, a popular package used for working with audio data in Python. He's secretly Canadian (howdy neighbour!) and when not hacking on audio software\, he plays drums and bass in four bands all around New York City.
DTEND:20250516T214500Z LOCATION:Ballroom A DTSTART:20250516T211500Z STATUS:CONFIRMED SUMMARY:[talk] Working with Audio in Python (feat. Pedalboard) TRANSP:OPAQUE UID:30f2511f-e7f2-59e5-b55a-e1687813f809 URL:https://us.pycon.org/2025/schedule/presentation/115/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Going faster in all directions at once: How two teams are working together to make Python better for all\nhttps://us.pycon.org/2025/schedule/presentation/75/\nTwo separate\, but related\, projects to make CPython faster are currently happening at the same time. The first\, funded by Microsoft\, aims to improve the single-threaded performance of CPython (PEP 659\, PEP 744). The second\, funded by Meta\, aims to remove the global interpreter lock so multiple threads can make better use of all processor cores (PEP 703). There are technical challenges to achieving both of these goals simultaneously. We will describe how we collaborate to nonetheless make both projects a success. This includes (a) regular and open lines of communication\, (b) sharing the same code for benchmarking\, (c) leaving space for each of these projects to develop on their own\, and (d) allocating time to directly tackle the intersection of the two problems.
\nThis talk is intended for a general audience. It will cover technical topics related to language runtimes at a high level\, and also include people-management topics related to open source communities.
\nSpeakers:\nMichael Droettboom\nMichael Droettboom is a Principal Software Engineering Manager at Microsoft\, leading the CPython Performance Engineering team. He is also a former lead maintainer of matplotlib\, and creator of airspeed velocity (asv) and Pyodide (CPython on WebAssembly).
\nDino Viehland\nI'm a software engineer at Meta working on Cinder\, our performance focused fork of CPython that runs Instagram and AI workloads. Previously I've worked on Python Tools for Visual Studio and IronPython and have been a core CPython developer since 2010.
DTEND:20250518T173000Z LOCATION:Room 301-305 DTSTART:20250518T170000Z STATUS:CONFIRMED SUMMARY:[talk] Going faster in all directions at once: How two teams are working together to make Python better for all TRANSP:OPAQUE UID:1ddb8ad9-67a1-5fdf-a5c4-bf5937d983a1 URL:https://us.pycon.org/2025/schedule/presentation/75/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Bridging Python and Apache Iceberg™: The Power of PyIceberg\nhttps://us.pycon.org/2025/schedule/presentation/124/\nUsing tools like PyArrow\, Pandas\, or Polars makes it easy to work with dataframes. However\, as datasets scale to terabytes\, managing tables\, evolving schemas\, and ensuring consistency across tools becomes increasingly complex. Apache Iceberg™\, an open table format\, addresses these challenges\, and\, with PyIceberg\, seamlessly integrates with your favorite Python-based tools.
\nWe will start with an introduction to Iceberg and PyIceberg\, focusing on the features PyIceberg brings to the Python ecosystem such as schema evolution and transactional guarantees. We will demonstrate how PyIceberg supports interoperability between Iceberg tables and Python-native dataframes like PyArrow and Pandas\, using practical examples of creating\, querying\, and writing to Iceberg tables.
\nFrom these practical examples\, we will dive deeper to explore how Iceberg tables evolve during these operations. This includes an in-depth look at Iceberg's file structure—metadata files\, manifest lists\, and manifests—and how PyIceberg leverages this structure to perform transactional table updates and optimize query planning\, ensuring reliable performance at scale.
\nFinally\, we will discuss PyIceberg’s advanced features\, including schema evolution\, hidden partitioning\, and time travel\, which make table management efficient and flexible.
\nSpeakers:\nRushan Jiang\nI am also known as Jonas and Honah. I am a software engineer at Snowflake and a committer and PMC member of Apache Iceberg.
DTEND:20250516T153000Z LOCATION:Ballroom A DTSTART:20250516T150000Z STATUS:CONFIRMED SUMMARY:[talk] Bridging Python and Apache Iceberg™: The Power of PyIceberg TRANSP:OPAQUE UID:fc13841d-8ea7-5f38-a819-5ae8e6605a41 URL:https://us.pycon.org/2025/schedule/presentation/124/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: talks\nKind: talk\nName: Unlearning SQL\nhttps://us.pycon.org/2025/schedule/presentation/167/\nSome people find SQL to be a helpful model for data analysis. They can also find themselves frustrated because some things that seem clear in SQL can seem difficult to restate in Python.
\nWe'll look at some of the SQL query design patterns in detail. With this\, we can formulate Python functions that have the same behavior without the overheads of using an actual database. Even something like SQLite3 involves overheads that can be avoided.
\nTo keep the talk short\, we'll avoid a number of more nuanced SQL features. We'll cover the principle elements of a Select statement including the Group by and Having clauses. This isn't a tutorial\, and the audience needs to be comfortable with generator expressions and list comprehensions.
The concept is to use SQL concepts for initial design\, but pivot to Python for a robust implementation.
\nSpeakers:\nSteven Lott\nSteven F. Lott has been turning coffee into software since the days when computers were large\, expensive\, and rare. Working for decades in high tech has given him exposure to a lot of ideas and techniques\, some bad\, but most are useful and helpful to others.
\nSteven has been working with Python since the late ‘90s\, building a variety of tools and applications. He’s written a number of books\, and sometimes manages to attend conferences.
\nSteven is currently a technomad who lives in various places on the east coast of the US. He tries to live by the words “Don’t come home until you have a story.” You can find him online at @slott56@fosstodon.org.
DTEND:20250518T190000Z LOCATION:Ballroom BC DTSTART:20250518T183000Z STATUS:CONFIRMED SUMMARY:[talk] Unlearning SQL TRANSP:OPAQUE UID:2eda13b2-8ccd-5ab7-a305-3813c83432e2 URL:https://us.pycon.org/2025/schedule/presentation/167/ END:VEVENT END:VCALENDAR