We often think about data in terms of storing the current state of our models. If a chess player moves a piece\, we update the state of the board and persist it. This makes it easy to query the current state of the game\, but also poses some challenges: How do we know which moves led up to the current state? And how do we ensure that the state remains consistent\, even in a distributed system?
\nEvent Sourcing takes a different approach to storing state. Instead of storing the current state as-is\, we store the sequence of events that led to the current state. If we need to know the current state\, we can replay this immutable record of events to reconstruct it. Not only does this give us an immutable audit log\, this also promotes loose coupling and enables optimistic concurrency.
\nIn this tutorial\, we are going to build an “Event Sourcing”-based backend for a game of Connect Four from the ground up. Rather than using a framework that abstracts away some of the core principles\, we are going to implement the mechanisms ourselves to help us understand the core principles.
\nThis tutorial is for you if you’re interested in Event Sourcing but don’t have any real experience with it yet. We do expect you to have at least an intermediate level in Python\, with some experience in writing (simple) classes.
\nDo make sure to bring your laptop\, with the following tools installed:\n- Python 3.12 or 3.13\n- Docker\, podman\, or another container runtime\n- Git\n- Your favorite editor
\nCaution: This tutorial is a well-balanced combination of theory and hands-on exercises. You will have to write some actual code!
\nSpeakers:\nSebastiaan Zeeff\nSebastiaan is a Python enthusiast who likes to think about good software design and engineering. He is a fellow of the EuroPython Society and the Python Software Foundation\, works as a Principal Expert for the Pythoneers at Sopra Steria Netherlands\, and frequently speaks at conferences around the world.
DTEND:20250515T163000Z LOCATION:Room 319 DTSTART:20250515T130000Z STATUS:CONFIRMED SUMMARY:[tutorial] Event Sourcing From The Ground Up TRANSP:OPAQUE UID:071beeb1-b1ed-5e7c-87e3-30a0877942b4 URL:https://us.pycon.org/2025/schedule/presentation/60/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Discover 3D graphics with WebGL and PyScript\nhttps://us.pycon.org/2025/schedule/presentation/24/\nWebGL is a wonderful set of APIs inside every modern Web browser that allow us to generate interactive 3D scenes. Thanks to PyScript\, we can explore WebGL without writing JavaScript. This tutorial will be a deep dive into a single topic: how to use PyScript with WebGL to harness the graphical power of the Web browser. By the end of the tutorial\, I expect you to gain confidence that you can do it\, too\, and be inspired to try!
\nThe tutorial assumes familiarity with Python and high-school math. PyScript experience helpful but not required.
\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:20250515T163000Z LOCATION:Room 320 DTSTART:20250515T130000Z STATUS:CONFIRMED SUMMARY:[tutorial] Discover 3D graphics with WebGL and PyScript TRANSP:OPAQUE UID:70ede393-d226-5e56-9f16-31b79e2b724b URL:https://us.pycon.org/2025/schedule/presentation/24/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: The A-B-Cs of Regressions\nhttps://us.pycon.org/2025/schedule/presentation/95/\nWe all want to do great work with real data\, such as determining causality\, and generating predictions\, but determining the appropriate methods for a situation\, and doing estimation on the relationships between variables is hard. In this tutorial\, we’ll take a deep dive into regression analysis\, which is a set of methods for estimating relationships between dependent (or outcome) variables and independent variables (or covariates or regressors or predictors).
\nWe’ll start with the method of linear regression (finding a best-fit line in a dataset)\, then move to regressions more appropriate for settings where the dependent variable takes a particular given set of values\, such as logistic regressions for binary outcomes. Along the way\, we’ll pay close attention to statistical definitions that teach us what we can and can’t infer from our data regarding real world causality. We’ll also talk about scientific writing\, and how to accurately document and communicate our results. The tutorial will feature a mix of instruction and discussing the mathematical background of each regression model\, and hands-on exploration of real datasets and real world data questions using Jupyter notebooks.
\nSpeakers:\nNeha\nI’m a PhD student at Carnegie Mellon University in Statistics\, Data Science\, and Public Policy. My research interests include machine learning policy and causal inference\, and I’m the primary owner and maintainer of dame-flame\, a Python package for matching in causal inference. In the past\, I’ve worked for the United Nations as an AI and Data Science Research Fellow\, and briefly as a software engineer. My Python teaching experience includes TAing introductory programming classes in Python\, and Girls Who Code clubs for middle school students.
\nI have a large variety of hobbies\, including swimming\, playing music\, and arts.
DTEND:20250515T163000Z LOCATION:Room 321 DTSTART:20250515T130000Z STATUS:CONFIRMED SUMMARY:[tutorial] The A-B-Cs of Regressions TRANSP:OPAQUE UID:38a01d76-c518-5afc-9b94-14cb038b4370 URL:https://us.pycon.org/2025/schedule/presentation/95/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: (Pre-)Commit to Better Code\nhttps://us.pycon.org/2025/schedule/presentation/61/\nMaintaining code quality can be challenging\, no matter the size of your project or number of contributors. Different team members may have different opinions on code styling and preferences for code structure\, while solo contributors might find themselves spending a considerable amount of time making sure the code conforms to accepted conventions. However\, manually inspecting and fixing issues in files is both tedious and error-prone. As such\, computers are much more suited to this task than humans. Pre-commit hooks are a great way to have a computer handle this for you.
\nPre-commit hooks are code checks that run whenever you attempt to commit your changes with Git. They can detect and\, in some cases\, automatically correct code-quality issues before they make it to your codebase. In this tutorial\, you will learn how to install and configure pre-commit hooks for your repository to ensure that only code that passes your checks makes it into your code base. We will also explore how to build custom pre-commit hooks for novel use cases.
\nSpeakers:\nStefanie Molin\nStefanie Molin is a software engineer at Bloomberg in New York City\, where she tackles tough problems in information security\, particularly those revolving around data wrangling/visualization\, building tools for gathering data\, and knowledge sharing. She is also a core developer of numpydoc and the author of “Hands-On Data Analysis with Pandas: A Python data science handbook for data collection\, wrangling\, analysis\, and visualization\,” which is currently in its second edition and has been translated into Korean and Chinese. She holds a bachelor’s of science degree in operations research from Columbia University's Fu Foundation School of Engineering and Applied Science\, as well as a master’s degree in computer science\, with a specialization in machine learning\, from Georgia Tech. In her free time\, she enjoys traveling the world\, inventing new recipes\, and learning new languages spoken among both people and computers.
DTEND:20250515T210000Z LOCATION:Room 317 DTSTART:20250515T173000Z STATUS:CONFIRMED SUMMARY:[tutorial] (Pre-)Commit to Better Code TRANSP:OPAQUE UID:51e4ac9a-92ed-5ca5-95ab-f9260e15f813 URL:https://us.pycon.org/2025/schedule/presentation/61/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Comprehending comprehensions\nhttps://us.pycon.org/2025/schedule/presentation/106/\nComprehensions are one of the most important — and misunderstood — parts of Python. In this tutorial\, I'll walk you through comprehensions\, including how to write them\, and why you would want to do so. By the time you finish this tutorial\, you'll fully understand list\, set and dict comprehensions\, as well as nested comprehensions and generator expressions. You'll understand the differences between regular "for" loops and comprehensions\, and where to use them.
\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:20250514T163000Z LOCATION:Room 320 DTSTART:20250514T130000Z STATUS:CONFIRMED SUMMARY:[tutorial] Comprehending comprehensions TRANSP:OPAQUE UID:afca48e9-59ea-5a28-b8a4-88e0cc6eda1c URL:https://us.pycon.org/2025/schedule/presentation/106/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: NanoDash: Writing an Interactive Web Framework from Scratch\nhttps://us.pycon.org/2025/schedule/presentation/89/\nThis tutorial will demonstrate how interactive web dashboard frameworks like Plotly Dash work\, by building a simplified version of Dash itself from scratch using Python\, the Flask framework\, and just a little bit of vanilla JavaScript. Along the way\, we will introduce some key elements of event-driven programming\, discuss client-server communication\, and demonstrate some ways to make debugging a little less painful.
\nSpeakers:\nMartha Cryan\nMartha Cryan is a software engineer at Plotly\, where she works on open source libraries (including Dash). She is a distinguished contributor to the Jupyter project\, dog-mom to Lou\, and lives in Austin\, TX.
\nEmily Kellison-Linn\nEmily is a software engineer at Plotly\, where she works on open-source data visualization libraries\, including Plotly.js\, Plotly.py\, and Dash. She has been programming in Python for many years\, and her interests include design\, data visualization\, linguistics\, and music. She lives in Montréal\, Québec.
DTEND:20250514T210000Z LOCATION:Room 321 DTSTART:20250514T173000Z STATUS:CONFIRMED SUMMARY:[tutorial] NanoDash: Writing an Interactive Web Framework from Scratch TRANSP:OPAQUE UID:12f18104-36a2-5810-a811-e616e5314449 URL:https://us.pycon.org/2025/schedule/presentation/89/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Codyssey: A playful control system workshop\nhttps://us.pycon.org/2025/schedule/presentation/38/\nControl systems are pervasive in our world and play a crucial role in many aspects of our lives\, from keeping satellites in the right altitude and heading to monitoring patients and making medication adjustments to keep them healthy. Sometimes\, tricky problems can be simplified by applying a control system lens\; but the programming model for a digital control system is not immediately obvious.
\nCodyssey is a 3-hour workshop where you’ll learn about the control system programming model and implement simple systems in Python to autonomously play various games. You’ll observe the behavior of your system in a visual environment\, and compete with other participants to solve as many games as you can. Along the way\, you’ll have to think creatively and practice translating your intuition into code.
\nDuring the workshop I’ll mentor individual participants / pairs\; after the competitive part I’ll live-code solutions for chosen challenges while demonstrating how to apply the control system programming model.
\nTarget audience: only basic Python knowledge is required - variables\, operators\, conditions\, loops\, functions and lists. The workshop can be challenging for experienced programmers as well as fun and instructive for juniors.
\nEach challenge will have you implementing a function that runs dozens of times a second\, deciding which action to take. The challenges you’ll face include:
\nCome hone your Python skills\, adapt to a new way of thinking\, and tackle some epic challenges!
\nSpeakers:\nDaniel Anderson\nHi! I'm Daniel\, a machine learning research engineer from Israel.
\nI started my career as a programmer\, and had the opportunity to take on a range of roles: FS developer\, team lead\, and course instructor.
\nI then got into the world of data science / ML\, in a nutrition startup that was later acquired by Medtronic.
After that I ventured out on my own as a freelance machine learning practitioner\; now I work with several startups on ML / vision problems. I also work with an Israeli non-profit\, helping to create and improve tech-ed programs for youth.
\nBachelor's degree in computer science from the Open University\, Master's degree in machine learning &\; data science from Reichman University.
\nPartial list of things I'm excited about:\n* Algorithms and optimizations\n* Translating experts’ domain knowledge and intuition into concrete methods and metrics\n* Designing ad-hoc models that make the most of little data (mostly because that involves designing custom metrics and coming up with creative ways of optimizing them)\n* Finding patterns in behavior\n* Creating interactive visualizations to explore complex data and interactions
\nAlso\, I have a blog!
DTEND:20250514T210000Z LOCATION:Room 319 DTSTART:20250514T173000Z STATUS:CONFIRMED SUMMARY:[tutorial] Codyssey: A playful control system workshop TRANSP:OPAQUE UID:2342aa20-6cb6-53c8-9764-61bcac17bdcc URL:https://us.pycon.org/2025/schedule/presentation/38/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Building software on top of Large Language Models\nhttps://us.pycon.org/2025/schedule/presentation/25/\nLarge Language Models such as GPT-4o\, Claude and Google Gemini provide APIs that can be used to develop features that were almost impossibly difficult to build in the past\, spanning areas that include human language understanding\, image recognition and structured data extraction.
\nBuilding software that uses these APIs reliably and responsibly is a topic with a great deal of depth and a lot of hidden traps.
\nIn this workshop we'll explore a range of proven techniques for building useful software on top of this wildly powerful but unreliable substrate.
\nTopics we will cover include:
\nParticipants will obtain hands-on experience of building applications on LLMs. Necessary API keys will be provided.
\nSpeakers:\nSimon Willison\nSimon Willison is the creator of Datasette\, an open source tool for exploring and publishing data\, and LLM\, a command-line tool and Python library for interacting with Large Language Models. He currently works full-time developing open source tools for data journalism\, built around Datasette and SQLite.
\nSimon has spent the last three years deeply immersed in the world of Large Language Models\, trying to solve the fascinating problems of how to responsibly use the technology in the two fields he knows best: journalism and software engineering.
\nPrior to becoming an independent open source developer\, Simon was an engineering director at Eventbrite. Simon joined Eventbrite through their acquisition of Lanyrd\, a Y Combinator funded company he co-founded in 2010.
\nHe is a board member of the Python Software Foundation and a co-creator of the Django Web Framework\, and has been blogging about web development and programming since 2002 at https://simonwillison.net/
DTEND:20250514T210000Z LOCATION:Room 310/311 DTSTART:20250514T173000Z STATUS:CONFIRMED SUMMARY:[tutorial] Building software on top of Large Language Models TRANSP:OPAQUE UID:c06243dc-eaed-5ddf-bc34-c28ae6c89ede URL:https://us.pycon.org/2025/schedule/presentation/25/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: plenary\nName: Opening Reception\nOpening Reception
\n DTEND:20250515T230000Z LOCATION:Hall A DTSTART:20250515T210000Z STATUS:CONFIRMED SUMMARY:[plenary] Opening Reception TRANSP:OPAQUE UID:fb5ee05b-8ff0-5a2d-8e7a-a74358a96b3b END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Building machine learning pipelines that scale: a case study using Ibis and IbisML\nhttps://us.pycon.org/2025/schedule/presentation/121/\nTabular data is everywhere. As Python has become the language of choice for data science\, pandas and scikit-learn have become staples in the machine learning (ML) toolkit for processing and modeling this data. However\, when data size scales up\, these tools become unwieldy (slow) or altogether untenable (running out of memory). Ibis provides a unified\, Pythonic\, dataframe interface to 20+ execution backends\, including dataframe libraries\, databases\, and analytics engines. Local backends\, such as Polars\, DuckDB\, and DataFusion\, perform orders of magnitude faster than pandas while using less memory. Ibis further enables users to scale using distributed backends like Spark or cloud data warehouses like Snowflake and BigQuery without changing their code\, giving them the power to choose the right engine for any scale.
\nIbisML extends the intrinsic benefits of using Ibis to the ML workflow. It lets users preprocess their data at scale on any Ibis-supported backend—users create IbisML recipes defining sequences of last-mile preprocessing steps to get their data ready for modeling. A recipe and any scikit-learn estimator can be chained together into a pipeline\, so IbisML seamlessly integrates with scikit-learn\, XGBoost (using the scikit-learn estimator interface)\, and PyTorch (using skorch) models. At inference time\, Ibis/IbisML once again takes the feature preprocessing to the efficient backend\, and user-defined functions (UDFs) enable prediction while minimizing data transfer. This completes an end-to-end ML workflow that scales with data size.
\nIn this tutorial\, you'll build an end-to-end ML project to predict the live win probability at any given move during a chess game. You’ll be using actual\, recent games from the largest free chess server (Lichess). We’ll be using GitHub Codespaces\, so you don’t need to download or configure anything\; however\, please bring a laptop!
\nSpeakers:\nAnjali Datta\nAnjali is a postdoc at Stanford Medicine working on MRI processing to identify neurosurgical targets. She also has a PhD in Electrical Engineering from Stanford\, during which she developed MRI acquisition and reconstruction methods. Medical imaging is of course a field where ML is taking over\, and Anjali is now interested in the applications of deep learning to MRI and other signal processing.
\nDeepyaman Datta\nDeepyaman is a software engineer at Dagster Labs. He joined from Voltron Data\, where he was a Senior Staff Software Engineer on the Ibis team. Before their acquisition by Voltron Data\, he was a Founding Machine Learning Engineer at Claypot AI\, working on their real-time feature engineering platform. Prior to that\, he led data engineering teams and asset development across a range of industries at QuantumBlack\, AI by McKinsey.
\nDeepyaman is passionate about building and contributing to the broader open-source data ecosystem. Outside of his day job\, he helps maintain Kedro\, an open-source Python framework for building production-ready data science pipelines.
DTEND:20250514T163000Z LOCATION:Room 318 DTSTART:20250514T130000Z STATUS:CONFIRMED SUMMARY:[tutorial] Building machine learning pipelines that scale: a case study using Ibis and IbisML TRANSP:OPAQUE UID:c093c7f6-6edf-595e-9539-70de788efbaa URL:https://us.pycon.org/2025/schedule/presentation/121/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Polars: Faster\, Simpler\, Smarter Python Analytics\nhttps://us.pycon.org/2025/schedule/presentation/107/\nDesigned for Python users familiar with pandas\, this session will bridge the gap between what you know and what’s possible with Polars’ power-packed features.
\nWe’ll begin by understanding the fundamentals of Polars: its lazy execution engine\, multi-threading capabilities\, and how it leverages Apache Arrow for performance. You’ll learn how to convert existing pandas workflows to Polars and write concise\, blazing-fast queries that process large datasets effortlessly. From there\, we’ll dive into real-world examples and unlock advanced features\, including expressions\, group-by operations\, and streaming data pipelines.
\nSpeakers:\nMatt Harrison\nMatt Harrison helps the largest companies in the world to leverage Python and apply data science. When he is not providing corporate training\, he can be found writing books or out in the mountains. He is the author of the best-selling books Effective Pandas\, Effective XGBoost\, and more.
DTEND:20250515T163000Z LOCATION:Room 318 DTSTART:20250515T130000Z STATUS:CONFIRMED SUMMARY:[tutorial] Polars: Faster\, Simpler\, Smarter Python Analytics TRANSP:OPAQUE UID:7fb92d73-86ec-5509-ba7b-7be21db93784 URL:https://us.pycon.org/2025/schedule/presentation/107/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: AI crash course for Python developers\nhttps://us.pycon.org/2025/schedule/presentation/77/\nThis crash-course tutorial is for Python developers that want to get up to speed with AI development quickly. \nWe will cover the what and how of language models\, learn about concepts like tokens\, markov chains\, and vector similarity with games and exercises. Each introduction to a concept will be explained by your experienced instructor in terms that don’t assume formal CS education. We’ll build demos\, apps and discuss pitfalls and challenges with AI development in 2025.
\nSpeakers:\nAnthony Shaw\nPython enthusiast
DTEND:20250514T163000Z LOCATION:Room 310/311 DTSTART:20250514T130000Z STATUS:CONFIRMED SUMMARY:[tutorial] AI crash course for Python developers TRANSP:OPAQUE UID:b80c8fef-a677-5340-85fb-2c162d75df03 URL:https://us.pycon.org/2025/schedule/presentation/77/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Snakes in a Grid: Working with spreadsheets in Python + Python in Excel\nhttps://us.pycon.org/2025/schedule/presentation/37/\nSpreadsheets are one of the most common ways to share data\, and thankfully Python has lots of tools to help! In this tutorial\, we will cover some helpful packages like openpyxl and pandas that make working with spreadsheets in Python a breeze. We will also approach the task from the other direction and explore how you can use Python directly in a spreadsheet in Excel to analyze and visualize your data. The session will include practical exercises where attendees will learn how to load\, manipulate\, and export spreadsheet data using Python.
\nBy the end of this tutorial\, participants will be equipped with the skills to efficiently handle spreadsheet tasks in Python as well as leverage Excel to run and share Python code directly in a spreadsheet.
\nSpeakers:\nSarah Kaiser\nSarah has spent most of her career developing technology in the lab\, from virtual reality hardware to satellites. She got her PhD in Physics by starting plasma fires with lasers\, Python\, and Jupyter Notebooks. She has also written tech books for folks of all ages\, including ABCs of Engineering and Learn Quantum Computing with Python and Q#. As a Cloud Developer Advocate for Python at Microsoft and a Python Software Foundation Fellow\, she finds all kinds of new ways to build and break OSS tools for data science and machine learning. When not at her split ergo keyboard\, she loves boating in the Seattle area\, laser cutting everything\, and playing with her German Shepard\, Chewie.
DTEND:20250514T210000Z LOCATION:Room 317 DTSTART:20250514T173000Z STATUS:CONFIRMED SUMMARY:[tutorial] Snakes in a Grid: Working with spreadsheets in Python + Python in Excel TRANSP:OPAQUE UID:b756dcb0-3600-525d-bacb-285c0f1a07e2 URL:https://us.pycon.org/2025/schedule/presentation/37/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: break\nName: Lunch\nLunch
\n DTEND:20250515T173000Z LOCATION:Ballroom A DTSTART:20250515T163000Z STATUS:CONFIRMED SUMMARY:[break] Lunch TRANSP:OPAQUE UID:289dd7fb-89ab-53ff-803d-2fd731906127 END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Handcrafting Your Own Language Processor: The Art of Writing Recursive Descent Parsers\nhttps://us.pycon.org/2025/schedule/presentation/65/\nIn this tutorial\, you will learn the fundamental principles of creating a language processor by hand\, focusing specifically on recursive descent parsers. A recursive descent parser is a program used for analyzing the structure of some input language through a series of functions that represent its grammatical rules.
\nKnowing how to write a parser from scratch is incredibly useful for anyone interested in understanding how programming languages work under the hood. It also provides valuable insights into compiler design\, interpreters\, and any form of automatic text analysis. By mastering this skill\, you can create your own mini-languages\, customize existing ones\, or simply satisfy your curiosity about the inner workings of language processors.
\nThroughout this tutorial\, you will:
\nBy the end of the tutorial\, you will have the knowledge and confidence to craft your own language processor and appreciate the elegance and power of recursive descent parsing.
\nSpeakers:\nAriel Ortiz\nAriel Ortiz is a programming languages enthusiast. Since 1994\, he has been a full-time faculty member at the Tecnológico de Monterrey in Mexico\, where he primarily teaches undergraduate computer science courses. His first encounter with Python was in 2001\, and since then\, he has integrated it into several of his classes\, including Advanced Algorithms and Compiler Design. He is an active member of ACM’s Special Interest Group on Computer Science Education (SIGCSE) and has been a speaker at PyCon US\, PyCon Latam\, Python Brasil\, and EuroPython conferences. Additionally\, he is the main author of the Spanish-language websites EduPython and RIP3.
DTEND:20250515T210000Z LOCATION:Room 319 DTSTART:20250515T173000Z STATUS:CONFIRMED SUMMARY:[tutorial] Handcrafting Your Own Language Processor: The Art of Writing Recursive Descent Parsers TRANSP:OPAQUE UID:1fdaa47a-21ac-5365-934a-42c53f6d327f URL:https://us.pycon.org/2025/schedule/presentation/65/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Building a cross-platform app with BeeWare\nhttps://us.pycon.org/2025/schedule/presentation/147/\nAll code needs a user interface. That might be an API\, or a web page - but these days\, many users will expect an app that they can install on their laptop\, or on their phone. But how do you build a native application in Python? And do you need to build a different version of your app the app for every device and operating system you want to support?
\nIn this hands-on tutorial\, you'll lean how you can use the BeeWare suite of tools to build a graphical user interface for your code\, and deploy that code as a desktop app\, and as a mobile app - all from a single Python codebase. You'll learn how to integrate third-party libraries like NumPy into your app\, and how to customize the appearance of your packaged app. You'll also learn how you can access device hardware (such as cameras and GPS) in your app's code.
\nNo experience with mobile or desktop app development is required\; a basic familiarity with Python is all you need. By the end of the tutorial\, you'll have an app running on your own phone\, written entirely by you\, using nothing but Python.
\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:20250515T210000Z LOCATION:Room 321 DTSTART:20250515T173000Z STATUS:CONFIRMED SUMMARY:[tutorial] Building a cross-platform app with BeeWare TRANSP:OPAQUE UID:0c49e57f-9f0c-56d4-8fdb-7d3ae6246ec9 URL:https://us.pycon.org/2025/schedule/presentation/147/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Build a Synthesizer with Python\nhttps://us.pycon.org/2025/schedule/presentation/19/\nThis tutorial aims to break down the abstractions that make up a synthesizer by building one using Python\, its scientific computing libraries\, &\; Librosa. We will discuss how to build the basic components that make up a modern digital synth from scratch! In the process\, learn some DSP and audio programming concepts! By the end\, you’ll be able to make your own tunes with Python! We will start with theory\, then work through Jupyter notebooks both individually and as a group.
\nThis tutorial will be a lot of fun if you’re a musically inclined Python programmer. As someone interested in music\, you will discover the components that make up a synthesizer by literally building &\; making music with it and as someone interested in Python\, you’ll learn a lot about audio programming and signal processing techniques.
\nSpeakers:\nSangarshanan\nMy name is Sangarshanan and I am a Software Engineer from planet Earth. I love making stuff that helps and amuses me in equal measure and standing upside down while holding a banana. When I'm bored you can find me making absurdist memes\, yet another spotify playlist or staring straight into the void
DTEND:20250515T210000Z LOCATION:Room 320 DTSTART:20250515T173000Z STATUS:CONFIRMED SUMMARY:[tutorial] Build a Synthesizer with Python TRANSP:OPAQUE UID:163990cd-9f59-57e1-acf2-23648195c146 URL:https://us.pycon.org/2025/schedule/presentation/19/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Practical PyScript\nhttps://us.pycon.org/2025/schedule/presentation/8/\nPyScript is a fast growing and vibrant open source platform for Python in the browser. Thanks to PyScript\, CPython and MicroPython run anywhere a browser runs\, which is everywhere!
\nThis tutorial\, aimed at all levels of experience and delivered by PyScript core developers\, will take you through initial steps needed to get PyScript working (hint: it's a single line added to an HTML <\;head>\; element). Afterwards we'll explore the many APIs\, modules\, libraries\, frameworks and tooling that have coalesced around PyScript since its announcement at PyCon three years ago. This will involve a guided tour of the potpourri of PyScript: tooling\, idiomatic PyScript\, core browser capabilities\, writing games with PyGame\, data science\, artificial intelligence\, application frameworks and UI toolkits\, and Internet of Things / robotics. We'll finish with an extended opportunity for folks to get their hands dirty with PyScript based explorations and conclude with a friendly and supportive "show and tell" session where folks can demo their work and share their experiences.
By the end of the tutorial you'll be a confident user of PyScript\, understand its expanding ecosystem and know where the community signposts and gatherings can be found. But most of all\, it's going to be a lot of stimulating supportive fun.
\nThis tutorial complements and would be excellent prep for Łukasz Langa's advanced\, and frankly mind-blowing\, PyScript / WebGL tutorial later in the conference.
\nSpeakers:\nNicholas H.Tollervey\nMusic\, philosophy\, teaching\, writing &\; computing. Just like this bio: concise\, honest and full of useful information. Home is: ntoll.org
DTEND:20250514T210000Z LOCATION:Room 320 DTSTART:20250514T173000Z STATUS:CONFIRMED SUMMARY:[tutorial] Practical PyScript TRANSP:OPAQUE UID:3a8b9d4c-b292-5153-b160-70f43a18999e URL:https://us.pycon.org/2025/schedule/presentation/8/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Decorators Demystified\nhttps://us.pycon.org/2025/schedule/presentation/123/\nYou know that the @ symbol applies a decorator to a function\, but what does that really mean?
Let's learn about decorators by writing our own.
\nDuring this tutorial we'll learn:
\nTrey Hunner helps individuals and teams level-up their Python skills through Python Morsels courses/exercises and his weekly Python tips newsletter.
DTEND:20250514T210000Z LOCATION:Room 318 DTSTART:20250514T173000Z STATUS:CONFIRMED SUMMARY:[tutorial] Decorators Demystified TRANSP:OPAQUE UID:e1e5b788-f429-5a32-9f7e-63865921a5e5 URL:https://us.pycon.org/2025/schedule/presentation/123/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Back to foundations: Automated testing with Python\nhttps://us.pycon.org/2025/schedule/presentation/132/\nIn the era of A.I.\, automatic testing is often tedious\, time-consuming\, and rarely given the attention it deserves. But is there a more engaging way to prove that your code works as expected?
\nThis tutorial will showcase how to harness Python tools to write automated tests\, ranging from fundamental techniques to advanced approaches that make testing truly effective.\nThrough a hands-on live-coding session\, we will follow a top-down approach: starting with principles\, we will begin by testing simple functions. From there\, we will move on to mocking external dependencies we can control and measuring the effectiveness of those tests. Finally\, we will integrate everything tested so far\, unveiling a complete testing strategy. The workshop will conclude with a recap and a brief handbook full of tips and more topics to explore.
\nThroughout the session\, we will embrace the entire philosophy of testing: beyond merely spotting bugs\, we will see how testing is a powerful tool for designing\, understanding\, and uncovering hidden issues in our implementation. We will introduce and practice test-driven development (TDD) while also exploring alternative approaches.
\nNeither extensive knowledge of Python (just some familiarity with classes and basic functions and ability to run Python scripts) nor special tools are required to attend the workshop: a little confidence with the basics is enough to participate\, and a working Python environment is all we will need. Instructions will be provided throughout the workshop.
\nLet's make testing engaging and impactful together. Long live testing!
\nSpeakers:\nFrancesco Bruni\nSoftware engineers for a few years\, working with geospatial data now.\nIn love with Python\, even if I feel comfortable with other languages as well. \nI strongly believe that the approach to the problem is much more relevant than being very tool-oriented.
DTEND:20250514T163000Z LOCATION:Room 317 DTSTART:20250514T130000Z STATUS:CONFIRMED SUMMARY:[tutorial] Back to foundations: Automated testing with Python TRANSP:OPAQUE UID:334b6b31-12a2-5bfc-bf4f-870c0954b343 URL:https://us.pycon.org/2025/schedule/presentation/132/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Reimplementing the module `itertools` for fun and profit\nhttps://us.pycon.org/2025/schedule/presentation/93/\nIn this hands-on tutorial we will reinvent the wheel and implement the module itertools in plain Python.
We'll do that because that will teach us a lot about Python:
\niter and next do\;for loops under the hood\;__iter__ and __next__ play a part in all this\; anditertools\, a module with plenty of useful tools for your day-to-day iterations.And most importantly\, we'll do it because it's genuinely fun!
\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:20250515T210000Z LOCATION:Room 310/311 DTSTART:20250515T173000Z STATUS:CONFIRMED SUMMARY:[tutorial] Reimplementing the module `itertools` for fun and profit TRANSP:OPAQUE UID:2c6e5af1-5b9d-5891-90d2-786607a2882e URL:https://us.pycon.org/2025/schedule/presentation/93/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Python project packaging: from zero to hero\nhttps://us.pycon.org/2025/schedule/presentation/72/\nPackaging your code is an essential skill that empowers you to share your Python projects with the world. However\, the packaging process can appear complex and overwhelming\, and it can be difficult to know where to begin.
\nThis hands-on tutorial will demystify packaging and get you started with the fundamentals of Python packaging. We’ll cover how to structure projects and follow best practices for project layouts\, specify project metadata\, make your package installable\, and publish it to PyPI. We’ll use the modern and easy-to-use packaging tool uv\, but most of the topics covered will also apply to any modern packaging tool (like PDM\, Hatch or Poetry).
\nEvery new concept will be introduced as a group\, practised individually through practical exercises and then reflected on together as a group. The materials will be available on GitHub\, and a compressed packaging cheat sheet will be provided as assistance for the exercises and future reference.
\nBy the end of this tutorial\, participants will have created a properly structured Python package\, and learned how to manage dependencies effectively with packaging tools such as uv\, publish a package to PyPI\, and set up basic CI/CD for the project on GitHub.
\nAudience:
\nThis tutorial assumes you are familiar with basic Python syntax\, have some experience creating (smaller or larger) Python programs\, and want to learn how to package and share your code. Whether you’re a beginner Pythonista eager to start sharing your code or an experienced developer who wants to be brought up to speed with the current state of packaging\, this is the tutorial for you.
Prerequisites:
\nFor this tutorial\, you will need a laptop with Python installed.
Marie 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:20250514T163000Z LOCATION:Room 319 DTSTART:20250514T130000Z STATUS:CONFIRMED SUMMARY:[tutorial] Python project packaging: from zero to hero TRANSP:OPAQUE UID:ff6c5a08-b2fa-56b6-ac00-6830f4074b6a URL:https://us.pycon.org/2025/schedule/presentation/72/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: break\nName: Lunch\nLunch
\n DTEND:20250514T173000Z LOCATION:Ballroom A DTSTART:20250514T163000Z STATUS:CONFIRMED SUMMARY:[break] Lunch TRANSP:OPAQUE UID:5bd20866-3478-53f7-bc79-d2aae304b443 END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: What is the magic of magic methods in the Python language?\nhttps://us.pycon.org/2025/schedule/presentation/6/\nWelcome to this tutorial on Python's magic methods\, often underestimated or overlooked in programming practice. And yet\, magic methods make it easy to write code that implements often very complex algorithms in a readable way.
\nPython allows you to equip created classes with special methods\, also known as magic methods or dunder methods. To recognize a special method\, you should know that it is a method whose name begins and ends with a double underscore. But it's not the name that their magic lies in\, because these methods have a special meaning for Python.
\nPython calls magic methods in response to fundamental operations\, such as creating class instances\, indexing sequences\, comparing objects\, managing attribute access\, and more\, so knowing how to create them is fundamental for any Pythonista.
\nDuring this tutorial\, you’ll:\n* Find out what Python magic methods are\,\n* Understand the magic behind Python magic methods\,\n* Learn how to create and use magic methods\,\n* Customize various behaviors of classes using magic method.\n* Talk about some interesting non-trivial magic methods.
\nTo fully benefit from this tutorial\, you should be familiar with object-oriented programming in Python.
\nThis tutorial will have classroom exercises\, post class homeworks as well as complimentary readings. All the presentation\, code\, exercises will be shared in advance and the solutions of the exercise will be shared after the tutorial is completed.
\nSpeakers:\nPaweł Żal\nPaweł Żal - software developer\, system architect with 20 years of experience in IT. A proponent of distributed solutions\, recently fascinated by time series databases. An avid kayaker and tinkerer.
DTEND:20250515T163000Z LOCATION:Room 310/311 DTSTART:20250515T130000Z STATUS:CONFIRMED SUMMARY:[tutorial] What is the magic of magic methods in the Python language? TRANSP:OPAQUE UID:fc340cae-d629-53ca-bfc2-f46c1a22d325 URL:https://us.pycon.org/2025/schedule/presentation/6/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Speed Up Your Code by 50x: A Guide to Moving from NumPy to JAX\nhttps://us.pycon.org/2025/schedule/presentation/54/\nJAX is more than just "NumPy for the GPU"—it offers advanced features but also presents unique challenges. This hands-on tutorial provides a practical introduction to JAX through interactive exercises covering key concepts such as:
\njit compilation for performance optimizationjax random number generation design and usageParticipants will then deepen their understanding by iteratively migrating a Gaussian Mixture Model from a pure numpy implementation to an optimized jax version\, highlighting a real-world use-case.
This tutorial distills lessons the authors found invaluable during their own migration from numpy to jax\, achieving over an order-of-magnitude speedup in real-world applications. Designed to provide attendees with a jumpstart on adopting jax\, this session—along with its comprehensive set of notebooks—aims to be a one-stop resource for anyone looking to leverage jax for numerical computing and machine learning.
I am a second-year Ph.D. student in the Neural Systems and Behavior program at the University of Washington. My research integrates Neuroscience\, Psychology\, and Machine Learning\, aiming to use machine learning techniques to gain insights into biological processes and leverage those insights to refine and enhance model performance.
\nIn addition\, I work on privacy-preserving machine learning\, specializing in homomorphic encryption for secure computations. I contribute to the OpenFHE lattice-cryptography library\, where I serve as the Head of Technical Outreach.
\nBryan Quah\nBryan works as researcher at Cedars Sinai Medical Center in Los Angeles where he develops machine learning methods for neuroimaging.
DTEND:20250514T163000Z LOCATION:Room 321 DTSTART:20250514T130000Z STATUS:CONFIRMED SUMMARY:[tutorial] Speed Up Your Code by 50x: A Guide to Moving from NumPy to JAX TRANSP:OPAQUE UID:c6577abe-8c0f-5a02-ac84-aa94c2247b1e URL:https://us.pycon.org/2025/schedule/presentation/54/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Reproducible Dependency Management with Pixi\nhttps://us.pycon.org/2025/schedule/presentation/131/\nLearn how to manage your conda- and pip-based Python dependencies with Pixi. With its declarative approach\, Pixi provides a reliable way for reproducible Python environments. Its design is based on experiences drawn from tools such as pip\, conda and mamba as well as Rust's cargo.
Managing dependencies can be a complex task\, especially when it comes to multi-platform support and extensions written in compiled languages\, such as C/C++ or Rust\, are involved. There are many tools for Python that can help to take care of different aspects of this problem. These tools are external Python packages that are not distributed with Python itself. Only pip is installed by default. Other\, more recent languages such as Rust\, include the tooling for dependency management as part of the core language. On the other hand\, the Python ecosystem for dependency management is very fragmented.
In general\, there are two main approaches:\n(a) based on pip packages and\n(b) based on conda packages.
\nPixi offers an approach that can work with both package types. Its design is inspired by Rust's cargo. In addition to Python packages\, Pixi can also manage software written in other languages. For example\, using conda-forge as the default conda repository\, Pixi can install tools such as gcc\, pandoc\, or git. Pixi can work together with existing tools such as setuptools or poetry. In fact\, it uses uv internally to install pip packages.
Please install pixi before the tutorial.
I've been a Python user since 1999\, teaching Python professionally since 2004.\nI am also active in the community\, organizing Python conferences such as\nPyCon DE\, EuroSciPy\, and BarCamps.\nI am a PSF Fellow\, PSF Community Service Award winner\,\nand chair of the German Python Software Verband.
DTEND:20250515T163000Z LOCATION:Room 317 DTSTART:20250515T130000Z STATUS:CONFIRMED SUMMARY:[tutorial] Reproducible Dependency Management with Pixi TRANSP:OPAQUE UID:6d5f64e6-d53b-5df6-8005-7d9a26547399 URL:https://us.pycon.org/2025/schedule/presentation/131/ END:VEVENT BEGIN:VEVENT DESCRIPTION:Section: tutorials\nKind: tutorial\nName: Analyzing Survey Data with Pandas and StatsModels\nhttps://us.pycon.org/2025/schedule/presentation/53/\nWhether you are working with customer data or tracking election polls\, Pandas and StatsModels provide powerful tools for getting insights from survey data. In this tutorial\, we'll start with the basics and work up to age-period-cohort analysis and logistic regression. As examples\, we'll use data from the General Social Survey to see how political beliefs have changed over the last 50 years in the United States. We'll follow the essential steps of a data science project\, from loading and validating data\, exploring and visualizing\, modeling and predicting\, and communicating results.
\nSpeakers:\nAllen Downey\nAllen Downey is a professor emeritus at Olin College and Principal Data Scientist at PyMC Labs. He is the author of several books -- including Think Python\, Think Stats\, and Probably Overthinking It -- and a blog about programming and data science. He is a consultant and instructor specializing in Bayesian statistics. He received a Ph.D. in computer science from the University of California\, Berkeley\, and Bachelor's and Masters degrees from MIT.
DTEND:20250515T210000Z LOCATION:Room 318 DTSTART:20250515T173000Z STATUS:CONFIRMED SUMMARY:[tutorial] Analyzing Survey Data with Pandas and StatsModels TRANSP:OPAQUE UID:b515d77a-1629-5856-9697-c82f3c839a7d URL:https://us.pycon.org/2025/schedule/presentation/53/ END:VEVENT END:VCALENDAR