Full text search of PyConUS talks, using littletable with CSV

pyconus2026_search.py

import sys
try:
    import littletable as lt
    import rich
except ImportError:
    print("littletable and rich modules required")
    sys.exit(1)

print("PyConUS 2026 Schedule Search - by Paul McGuire (powered by littletable)\nEnter '/quit' to exit\n")

talks_csv = '''\
id,title,url,date,time,room,speaker,description,scheduled_datetime
105,AI-Assisted Contributions and Maintainer Load,/2026/schedule/presentation/105/,"Friday, May 15th, 2026",11a.m.-11:30a.m.,Grand Ballroom A,Paolo Melchiorre,"AI tools are increasingly used by contributors to read code, explore codebases, and generate changes. Across many open source projects, this is already affecting how issues are opened and pull requests are submitted. While AI can help people get started, it also creates new challenges for maintainers. This talk is grounded in real discussions and concrete examples from the open source community. Maintainers in projects such as GNOME, OCaml, Python, and Django have reported similar patterns: large or unnecessary AI-generated changes, missing design discussion, references to non-existent APIs, and contributions that are technically correct but hard to review and maintain. In many cases, the workload shifts from contributors to already time-constrained maintainers. The focus of this talk is not whether AI should be allowed or banned. The shared concern emerging from these communities is about responsibility. Problems arise when AI replaces understanding, testing, and human accountability, breaking the social processes that open source relies on. The talk also looks at how projects are trying to respond. Some are adding documentation, review rules, or disclosure requirements, while others are starting broader discussions around governance, sustainability, and legal risk. These efforts show that the problem goes beyond individual pull requests. Rather than offering simple answers, this talk aims to share the real questions the community is actively asking, and to help contributors and maintainers think more clearly about the future role of AI in Python open source.",2026-05-15 11:00:00
4,I Accidentally Built a Monitoring System While Trying to Debug a Memory Leak,/2026/schedule/presentation/4/,"Friday, May 15th, 2026",11a.m.-11:30a.m.,Grand Ballroom B,Goutam Tiwari,"Three months ago, I was hunting down a memory leak in our Flask API that was driving me absolutely insane. The app would run fine for hours, then suddenly RAM usage would spike and everything would crash. Profilers showed nothing useful. Logs were useless. My manager kept asking ""is it fixed yet?"" In my desperation, I started writing small Python scripts to track every possible metric I could think of - not because I knew what I was doing, but because I was running out of ideas. I tracked function call counts, database connection pools, even how many times certain variables were accessed. Most of it was probably stupid, but I was grasping at straws. The weird thing is, those hacky little monitoring scripts I threw together in frustration actually became the most useful debugging tool our team has ever had. Not because they're sophisticated (they're definitely not), but because they were built by someone who was genuinely confused about what was happening in their own code. This talk is the story of how desperation led to accidentally building something useful, and why sometimes the best tools come from not knowing what you're supposed to be doing. I'll show you the exact scripts I wrote (warts and all), the embarrassing assumptions I made, and how you can steal these ideas to debug your own mysterious problems - even if you have no idea what you're doing either.",2026-05-15 11:00:00
15,Mind the gap! Why static typing requires more than just adding annotations,/2026/schedule/presentation/15/,"Friday, May 15th, 2026",11a.m.-11:30a.m.,Room 103ABC,Jia Chen,"Have you ever tried to add types to an existing Python library or application and hit a wall or wondered why it can be so hard? This talk is for you! Static typing is a powerful lever for working with code. It provides verifiable documentation, finds bugs quickly, enables less scary refactors, and unlocks tools like modern IDEs for understanding and navigating code. But often we approach turning untyped code into statically typed code as if it’s just a matter of adding annotations. This is rarely the case, and understanding why can help. Python was conceived as a dynamically typed language, so much of its rich library ecosystem emerged without types. Many powerful patterns that make Python useful are difficult to express statically, for example: Pervasive duck typing Metaprogramming and classes with dynamic behavior Reliance on flow-sensitive type information that type checkers can’t track Using heterogeneous containers in ways the type system can’t model We’ll explore these patterns, why they’re hard to type and might not be worth typing, and offer advice for getting the most out of the type system in the presence of these patterns. We’ll also look at how Python’s type system has evolved to support more dynamic use cases, and possible future directions. What attendees will learn Historical context on Python before static types Common challenges adding types to code whose semantics don’t fit Approaches for dealing with code that’s difficult to statically type Perspective on how the Python type system evolves to handle a wider range of patterns",2026-05-15 11:00:00
102,GPU Communications for Python,/2026/schedule/presentation/102/,"Friday, May 15th, 2026",11a.m.-11:30a.m.,Room 104AB,Benjamin Glick,"The AI/ML and HPC ecosystems share characteristics that make them difficult to serve: They both require specialized orchestration of many processors across systems, They both make use of hardware acceleration and They both have user communities who overwhelmingly prefer Python to other languages. This session covers NVSHMEM4Py and NCCL4Py, libraries which make GPU-centric communication accessible to Python programmers without compromising performance or usability. NVSHMEM and NCCL are GPU-centric communication libraries primarily exposed through CUDA C++. These libraries address 3 common use cases: Performing collectives from GPU memory, using GPU cores and for mathematical operations, GPU to GPU communication with low-latency and high-bandwidth, and Enabling custom communication patterns and fusing communication with computation NVSHMEM4Py and NCCL4Py offer this in Python, so AI/HPC practitioners can achieve high performance in multi-GPU programs without leaving Python. Our host APIs integrate with the cuda-Python ecosystem with array-oriented memory APIs. Point-to-point operations (put/get) and collectives (reduce) execute on CUDA streams, enabling overlapping communication with computation. Device APIs expose GPU-initiated communication primitives into Python DSLs such as Numba and CuTe. Developers invoke GPU-resident operations (e.g., device_put) in the DSL, enabling custom/fused kernels in Python. For example, a user kernel can perform partial computation and push results to peer GPUs without host intervention. To generate the code and link Python to CUDA C++, we use Numbast to generate 1:1 Python bindings of device functions. We then write DSL code wrapping around those bindings for a Pythonic experience. At runtime, we JIT-compile the Python functions to LTO-IR, and link them against CUDA objects. The presentation covers the details of our host and device APIs, some applications using them, and performance evaluations comparing the NVSHMEM/NCCL APIs across CUDA and Python.",2026-05-15 11:00:00
41,"Logs, llanto y feature flags: historias de código en modo supervivencia",/2026/schedule/presentation/41/,"Friday, May 15th, 2026",11a.m.-11:30a.m.,Room 104C,Laura Meng,"Ser padre primerizo ya es un caos. Serlo mientras intentas mantener tu código en pie… es otro tipo de runtime error. Como buen desarrollador, intenté sobrevivir con datos: usaba una app para registrar el sueño y las tomas del bebé. Pero una noche, justo cuando más la necesitaba, la app se colgó. Medio dormida y totalmente frustrada, decidí reescribirla en Python. Quería algo que funcionara sin conexión, que no perdiera datos y que —idealmente— fuera más estable que yo. En esta charla exploraremos cómo el caos cotidiano puede enseñarnos a construir software más resiliente. A partir de una mini app casera, veremos cómo conceptos como caching, feature flags y recuperación local pueden mantener con vida una app (y a su programador) en condiciones extremas. No hace falta ser madre ni experta en sistemas distribuidos: alcanza con tener curiosidad y ganas de reírse un poco del desborde. Spoiler: al final, todo se trata de diseñar para recuperarse, no de que nada falle",2026-05-15 11:00:00
66,AI-Powered Python Education : Towards Adaptive and Inclusive Learning,/2026/schedule/presentation/66/,"Friday, May 15th, 2026",11:45a.m.-12:15p.m.,Grand Ballroom A,Sonny Mupfuni,"This talk explores how AI can transform Python learning by making it more accessible, personalized, and effective for learners of all backgrounds and skill levels. AI-powered tools offer unprecedented opportunities for personalized learning paths that adapt to each learner's level and style, instant multilingual support that breaks down language barriers, immediate constructive feedback that helps learners understand not just what went wrong but why, and 24/7 access to expert-level explanations that democratize quality education regardless of geography or financial resources. Through concrete demonstrations, I'll show how these tools can provide different explanations of the same concept depending on the learner's background, analyze errors with pedagogical insight rather than just corrections, and generate progressive exercises tailored to individual needs. However, this potential comes with significant responsibilities. Technical limitations like LLM hallucinations risk teaching incorrect code. Pedagogically, we must balance assistance with autonomy to avoid creating dependency rather than independent problem-solvers. This talk presents AI as a complement to human teachers, not a replacement. I'll discuss opportunities for the Python community to build educational tools responsibly and establish best practices for AI-assisted learning. The goal is to inspire thoughtful discussion about how we collectively shape the future of Python education. Target Audience: Python educators, maintainers of educational projects, tool developers, and anyone interested in the intersection of AI and learning.",2026-05-15 11:45:00
36,How to give your Python code to someone else,/2026/schedule/presentation/36/,"Friday, May 15th, 2026",11:45a.m.-12:15p.m.,Grand Ballroom B,Russell Keith-Magee,"You've written some Python code. It works great on your machine. Now you want someone else to use that code. How do you deliver your Python code to someone else so that they can run it? And how do you do that if the person who needs to use your code isn't a Python user themselves? In this talk, you'll learn the options you have for delivering your code to someone else. You'll learn what is involved in configuring a project so that someone else can use it, and when you might want to consider bundling your code as a standalone application. You'll get an overview of some of the tools that can be used to produce a standalone application, and a detailed look at one of those options - Briefcase. Finally, you'll be introduced some of the possibly unexpected benefits of bundling your code as a standalone application.",2026-05-15 11:45:00
70,PEP 750 - T-strings: safer and smarter string processing,/2026/schedule/presentation/70/,"Friday, May 15th, 2026",11:45a.m.-12:15p.m.,Room 103ABC,Vinícius Gubiani Ferreira,"After the introduction of f-strings on PEP-498, using strings and variables in general to produce desired output text became simpler and easier. But f-strings still lack some desired features such as transformation, customization and the most important: security checks (such as SQL injection or XSS). PEP-750 aims to solve those issues with t-strings, by giving flexibility and control to developers, with a familiar and already known syntax. In this presentation we’ll go over how t-strings work, good examples of actually using them, compare it against already existing solutions, and how we intend to change the way we write our DSL (Domain Specific Language) to use t-strings. I’ll also discuss some potential drawbacks and things to keep in mind about t-strings. The talk is targeted for intermediate pythonistas. People who are just starting with Python may feel a bit lost, but I'll try my best to make it easy for all audiences. After this presentation, participants will learn about this new template system, how to use it, and compare it against existing alternatives.",2026-05-15 11:45:00
119,How many spoons does your environment cost: Feat. demos breaking and the human element of your broken env,/2026/schedule/presentation/119/,"Friday, May 15th, 2026",11:45a.m.-12:15p.m.,Room 104AB,Dawn Wages,"This talk is one part technology dance and one part walk through of Python environment best practices. In under 30 minutes, you'll see me load up some of the most gnarly environments and watch them fail. This isn't just another talk about dependency management. It's about the hidden cost of environment friction: the cognitive load, the lost spoons, the brilliant developers who almost quit tech because they felt ""too stupid"" to make pip work. It's about recognizing that setup barriers aren't just inconvenient—they're accessibility barriers that determine who gets to write Python. In this talk we'll cover: - Several environment failures (with dramatic audience participation): GPU-enabled errors, OS errors, mounted systems, CI/CD and virtual environments - The human side of technical frustration: spoon theory, burnout - Patterns about how environments break - What the Python community is doing to lower these barriers. Content note: This talk discusses mental health, burnout, and the emotional impact of technical barriers with care and intention.",2026-05-15 11:45:00
139,El texto no es texto: historia de las strings en Python,/2026/schedule/presentation/139/,"Friday, May 15th, 2026",11:45a.m.-12:15p.m.,Room 104C,Daniel Hervás,"Usamos strings todo el tiempo, pero casi nadie sabe cómo funcionan realmente. En esta charla desmontaremos la abstracción del texto en Python desde sus orígenes más peligrosos en C (char *) hasta las innovaciones de Python 3.14. Exploraremos cómo errores históricos de memoria, encodings incompatibles y el caos de Unicode forzaron algunas de las decisiones de diseño más elegantes del lenguaje. Nos adentraremos en el intérprete para entender el PEP 393 y cómo Python logra representar texto Unicode de forma eficiente y dinámica. Recorreremos la evolución del formateo de strings, desde % hasta f-strings, para entender qué problemas resolvió cada paso. Cerraremos con el PEP 750 y las Template Strings: una nueva forma de tratar el texto como estructura, no como concatenación, habilitando procesamiento diferido, metaprogramación y una defensa mucho más sólida contra inyecciones de código. Al terminar, no solo entenderás mejor cómo funcionan las strings en Python: entenderás por qué están diseñadas así, y cómo usar ese conocimiento para escribir código más eficiente, más seguro y más expresivo.",2026-05-15 11:45:00
23,Making African Languages Visible: A Python-Based Guide to Low-Resource Language ID,/2026/schedule/presentation/23/,"Friday, May 15th, 2026",12:30p.m.-1:15p.m.,Grand Ballroom A,Gift  Ojeabulu,"African languages remain heavily underrepresented in NLP, and building reliable language identification tools for them is still a major challenge. In this session, we explore how Python and FastText can be utilised to develop practical language detection systems for low-resource African languages, drawing insights from the MasakhaNER dataset on Huggingface, one of the most comprehensive open-source African language corpora. The talk begins with an overview of the unique characteristics of African languages that affect NLP performance, including dialect diversity, orthographic variation, code-switching, and limited labelled resources. We then outline a clear workflow for preparing multilingual datasets, selecting features, and evaluating language identification models, with a focus on the realistic constraints faced in low-resource environments. A central part of the talk compares FastText with other African NLP tools such as AfroXLMR, Masakhane Models, and spaCy’s limited-language pipelines. This comparison highlights key differences in language coverage, model size, task flexibility, and production readiness. Attendees will gain practical guidance on when FastText is sufficient, when transformer-based models offer clear advantages, and how to navigate trade-offs around accuracy, speed, and resource usage. This session emphasizes conceptual clarity, reproducible steps, and real-world lessons from applying these tools to African language datasets. The audience will leave with a strong understanding of the challenges and opportunities in low-resource language identification, along with actionable strategies for designing more inclusive NLP systems.",2026-05-15 12:30:00
87,Cron Is Dead: Smarter Task Scheduling for Modern Python Apps,/2026/schedule/presentation/87/,"Friday, May 15th, 2026",12:30p.m.-1p.m.,Grand Ballroom B,Ken Alger,"Whether you’re sending email digests, refreshing data, or syncing APIs, scheduling is a core part of almost every app—but many Python developers still rely on old-school cron jobs. This talk explores how to modernize background job orchestration with APScheduler, Celery, and cloud-native task runners. We’ll look at real-world deployment patterns for Python task scheduling, including health checks, retries, idempotency, and state persistence. You’ll see how to safely coordinate background tasks in stateless environments and detect failures early. The examples use modern cloud-native runners and Redis Queue for clarity, but the ideas translate directly to any Python deployment model—from containers to serverless. You’ll leave with a playbook for building more reliable, self-healing automation in your applications.",2026-05-15 12:30:00
143,What's so hard about writing a type checker? A tour of ty,/2026/schedule/presentation/143/,"Friday, May 15th, 2026",12:30p.m.-1:15p.m.,Room 103ABC,Carl Meyer,"You've probably used a Python type checker or language server—but have you ever looked under the hood to see how they're built? Join a guided tour with one of the authors of ty, a fast Python type checker and language server. We'll explore the challenges of Python type checking: what it takes to provide detailed contextual diagnostics, responsive fine-grained incremental re-checking as you type, control-flow-sensitive type narrowing, gradual typing, and set-theoretic types (unions, intersections, and negations) — and keep it all running snappily. An extensive community of contributors has helped build ty. By the end of this talk, you'll have the foundations to become the next contributor, or a ty user with a better understanding of your tools.",2026-05-15 12:30:00
128,"Breaking the Speed Limit: Fast Statistical Models with Python 3.14, Numba, and JAX",/2026/schedule/presentation/128/,"Friday, May 15th, 2026",12:30p.m.-1p.m.,Room 104AB,Wenxin Jiang,"Data scientists and domain experts often face a dilemma: we understand the models, and we use Python, but we aren't C++ or Rust engineers. We need code that is quick to write, easy to work with, and still fast enough to run on large, real‑world datasets. How do we choose the right tool without getting lost in low‑level details? With the new free‑threaded build and experimental JIT in Python 3.14, combined with tools like Numba and JAX, we finally have a realistic way to push back against the ""Python is slow"" stereotype. In this talk, we'll use two concrete workloads to illustrate this modern stack: complex iterative loops (k‑means) and massive data parallelism (permutation test). The focus is on computational patterns rather than statistical theory. We'll compare plain NumPy, Python 3.14 (with free-threaded or JIT configurations), Numba, and JAX across varying data scales, highlighting the trade-offs in runtime, memory, debuggability, and developer experience. Along the way, we'll also demonstrate how AI coding tools can serve as a copilot, helping to translate clear mathematical code into high-performance kernels without requiring deep compiler expertise.",2026-05-15 12:30:00
59,Cómo Python ayudó a descubrir criminales que se estaban postulando en las elecciones de Brasil,/2026/schedule/presentation/59/,"Friday, May 15th, 2026",12:30p.m.-1p.m.,Room 104C,Judite Cypreste,"En 2024, una sola denuncia llevó a una pregunta poco común: “¿hay personas buscadas por la Justicia que están intentando presentarse en las elecciones municipales de Brasil?”. La respuesta no estaba en un solo lugar. Estaba dispersa en bases de datos públicas del gobierno, desordenadas, con datos ocultos, formatos distintos y campos incompletos. Ahí es donde entró Python. En esta charla voy a mostrar cómo Python fue esencial para hacer posible una investigación que terminó desencadenando una operación policial inédita en mi país, que detuvo a más de 60 personas que estaban, simplemente, postulándose a cargos municipales. Entre ellas había acusados de delitos graves, como homicidio, abuso sexual de menores e incluso personas vinculadas a un intento de golpe de Estado. Estos son los puntos que voy hablar: Recolección de datos y transparencia pública: cómo Python me ayudó a sortear limitaciones creadas por el propio gobierno (descargas por estado, límite de filas, campos faltantes) y a reconstruir una base nacional de órdenes de detención. El gobierno no cruzaba los datos, así que yo los crucé: usando solo datos oficiales, voy a mostrar cómo hice el cruce entre la base de órdenes de detención y el registro de candidaturas — algo que las autoridades públicas no estaban haciendo. Encontrando a las personas buscadas: cómo unifiqué varios archivos, estandaricé la información e identifiqué a los prófugos. Documentación: qué dejé registrado para que otra periodista o desarrollador pueda repetir el proceso en la próxima elección. Bonus: cómo las técnicas de investigación periodística ayudaron a confirmar los cruces finales.",2026-05-15 12:30:00
123,Panel: Fostering better collaboration between the scientific Python community and core Python development,/2026/schedule/presentation/123/,"Friday, May 15th, 2026",1:45p.m.-2:30p.m.,Grand Ballroom B,Jonathan Dekhtiar,"We often think about “the Python Community” as a monolith, but in reality it behaves more like a collection of diverse sub-communities. One could name, as highlighted by the 2024 Jetbrain Python Developer Survey, data analysis, web development, machine learning & artificial intelligence, academic research, DevOps & System Administration, scientific computing, to name only a few. In typical distributed open source fashion, each of these communities has their own set of communication channels, conferences and governance, and this is generally a very good thing, but it does create silos and blindspots. In this panel, we hope to explore some ways that the scientific Python community, specifically, can more closely interact with core Python development and the rest of the Python ecosystem. In this panel, we will invite leaders from the scientific Python ecosystem and the core Python development team to participate in a lively discussion about working better together to create a Python that works for all, how to advocate & steward for a lively open source community and keep the community engaged and working toward a common goal. Some of the topics we hope to cover are: How can we create better communication structures so that the needs of the scientific Python ecosystem bubble up into core development decisions? How can we encourage technical leaders in the scientific Python ecosystem to participate more in core development? What are some of the current barriers to that? How can the core team better signal long-term direction to downstream maintainers of major scientific Python libraries? How can we make the community more welcoming to new members? What are the most effective ways to onboard and mentor new contributors to core and critical ecosystem projects? Panelists: - Dawn Wages (moderator) - Travis Oliphant - Carol Willing - Savannah Ostrowski - Barry Warsaw - Michael Droettboom - Jonathan Dekhtiar",2026-05-15 13:45:00
77,Peeking under the hood of uv run,/2026/schedule/presentation/77/,"Friday, May 15th, 2026",1:45p.m.-2:30p.m.,Room 104AB,Zanie Blue,"uv is a popular new package and project management tool with a focus on speeding up the fundamental operations of packaging. uv's performance improvements are used to power new workflows and user experiences that were previously impossible. A core example of this is uv run, which does a lot of work to ensure your environment is up-to-date before executing your command. In this talk, we'll dive into the details of what uv is doing under the hood during the run command. We'll cover the many steps necessary to go from a pyproject.toml to running Python code, including dependency resolution, package installation, and Python interpreter discovery and installation. We'll walk through the design decisions that make these operations fast. We’ll also discuss how modern standards made uv possible, the practical challenges that remain, and new standards that would unlock further improvements. Some prior knowledge of Python packaging will be helpful, but not necessary. We will focus on implementation details at a high-level, e.g., why the performance of version parsing is important, but we won't be diving into the low-level code, e.g., how uv implements version parsing.",2026-05-15 13:45:00
138,Running Large Language Models on Laptops: Practical Quantization Techniques in Python,/2026/schedule/presentation/138/,"Friday, May 15th, 2026",2p.m.-2:30p.m.,Grand Ballroom A,Aayush Kumar JVS,"Large Language Models are often assumed to require expensive GPUs and large cloud budgets. In practice, recent Python tooling makes it possible to run and experiment with LLMs efficiently on consumer hardware. This talk focuses on practical quantization techniques for LLMs using Python, with an emphasis on real-world tradeoffs rather than theory. We will compare commonly used approaches such as QLoRA, bitsandbytes, GGUF, and GGML, and discuss how each impacts memory usage, latency, and output quality. The examples and benchmarks in this talk are drawn from applied experimentation on real-world text datasets, but the focus remains on generalizable lessons for Python developers, not domain-specific claims. Attendees will see how quantization choices affect model behavior, when aggressive compression helps, and when it introduces unexpected failure modes. By the end of the session, attendees will be able to: Understand when LLM quantization is appropriate Choose between common quantization formats and libraries Run LLMs locally on limited hardware using Python Avoid common pitfalls when moving from experimentation to deployment This talk is aimed at Python developers who want to work with modern LLMs without relying exclusively on high-end infrastructure.",2026-05-15 14:00:00
30,The Bakery: How PEP810 sped up my bread operations business,/2026/schedule/presentation/30/,"Friday, May 15th, 2026",2p.m.-2:30p.m.,Room 103ABC,Jacob Coffee,"This talk demonstrates measurable performance improvements using Python 3.15(?)'s newly accepted PEP 810 lazy imports feature. Through a live-coded (scary!) CLI application (breadctl), everyone will see: ?× faster --help command execution ?% reduction in baseline memory usage Clear before/after comparisons using industry-standard benchmarking tools Ideal for devs seeking wins to optimize CLI tools, test suites, or other applications that may be pluggable (this not needing things loaded EVERY time) while also offering deeper insights into Python's import system for those ready to dive in. Whether you're shipping a framework like Litestar (how could I not plug our framework!) or building internal tooling, learn when and how to apply lazy imports effectively.",2026-05-15 14:00:00
39,Zonas Horarias en Python: Todo lo que ojalá no necesitases,/2026/schedule/presentation/39/,"Friday, May 15th, 2026",2p.m.-2:30p.m.,Room 104C,Paul Ganssle,"Las zonas horarias son muy complejas, pero son una realidad inevitable en ingeniería. Algunas zonas horarias han llegado a saltarse días enteros y repetirse otros. Hay zonas horarias que se cambian a DST dos veces al año. Pero no necesariamente cada año. En Python, es posible hasta crear datetimes con igualdad no transitiva (a == b, b == c, a != c). En esta charla, vas a aprender sobre el modelo de zonas horarias en Python y otros conceptos fundamentales para evitar problemas con datetime. Usando el módulo zoneinfo introducido en Python 3.9, cubrimos como lidiar con tiempos ambiguos e imaginarios, aritmética de datetimes cerca de una transición de horario de verano, y que significa el atributo fold.",2026-05-15 14:00:00
126,Distributing AI with Python in the Browser: Edge Inference and Flexibility Without Infrastructure,/2026/schedule/presentation/126/,"Friday, May 15th, 2026",2:45p.m.-3:15p.m.,Grand Ballroom A,Fabio Pliger,"AI models are often complex, require a lot of resources to run and many considerations in terms of security, privacy, and performance. An emerging ecosystem of tools is making it possible to use the Browser as a great platform to run Python and consume (either by connecting or directly running) AI models. This opens the door to distributing AI to the edge without provisioning servers, managing GPUs, or handling complex infrastructure. This talk shows how to use Python in the browser as a secure, sandboxed runtime for both edge inference or using it in agentic workflows where models are provided via an API. We will walk through an architecture where a Python runtime and models are delivered as assets, with all inference happening in different ways in (or through) the user’s browser. Along the way, we will look at how this fits into the broader AI‑in‑browser ecosystem: interoperating with existing JavaScript model runners, leveraging WebGPU/WebNN for acceleration, mixing Python‑based preprocessing with client‑side inference engines or simply a gateway to AI services like OpenAI or Anthropic. Security and privacy are first‑class concerns: the browser sandbox limits what code can do, and keping inference and related compute on the client means user data does not need to leave the device. We will also be honest about the trade‑offs: bundle sizes, model constraints, performance, and when a hybrid edge/cloud approach makes more sense than going fully client‑side. Attendees will leave with concrete patterns, example architectures, and a clear path to experimet with Python‑powered AI at the edge, no special infrastructure required.",2026-05-15 14:45:00
25,pathlib: why and how to use it,/2026/schedule/presentation/25/,"Friday, May 15th, 2026",2:45p.m.-3:15p.m.,Grand Ballroom B,Trey Hunner,"If your Python code works with file paths, you should be using pathlib. This standard library module may seem a bit cumbersome at first, but pathlib-using code is often more readable than the alternative. Python's many path-oriented utilities used to expect a string representation for all file paths. That's not the case anymore. Now every important path-consuming library will accept pathlib.Path objects. During this talk, we'll see why pathlib.Path objects make for more maintainable code. We'll visit a number of useful pathlib examples and recipes along the way. By the end of this talk, you'll be tempted to convert all your path-handling code to use pathlib.",2026-05-15 14:45:00
58,From Messy Clinical Data to Interoperable FHIR: A Python-First Mapping and Validation Pipeline,/2026/schedule/presentation/58/,"Sunday, May 17th, 2026",2:30p.m.-3p.m.,Grand Ballroom A,Lisa Smith,"Healthcare data is rarely clean. In practice, it arrives as spreadsheets with inconsistent column names, free-text clinical descriptions, partial fields, and little agreement on structure. At the same time, modern analytics and data sharing increasingly require FHIR-compliant resources. This talk presents a Python-first approach to bridging that gap. I’ll describe a production Flask application that allows users to upload CSV or Excel files, map columns to FHIR resources (Patient, Observation, Condition, Procedure, Medication, etc.), resolve terminology using LOINC, SNOMED CT, and RxNorm, and generate valid FHIR bundles without requiring users to understand FHIR itself. The focus is on architecture and design decisions rather than standards theory. We’ll look at how pandas is used for normalization and validation, how fuzzy matching (via RapidFuzz) is applied safely to clinical text, and how FHIR resources are constructed dynamically so that only available data is included. Special attention is paid to handling optional fields, extensions, and partial compliance without corrupting downstream data. The system is intentionally database-agnostic and stateless; uploaded files are validated and processed in memory, with no persistent file storage, providing fast, interactive feedback. This keeps the deployment lightweight while reducing security and compliance risk, constraints that significantly shaped the final design. Although the example domain is healthcare, the techniques discussed: schema mediation, fuzzy matching, user-guided validation, and resilient ingestion pipelines, are broadly applicable to any Python system that needs to turn messy, user-supplied data into structured, standardized output. No prior FHIR knowledge is required.",2026-05-17 14:30:00
78,How to port a Python kernel to Pydodide for a blazingly fast in-browser coding experience,/2026/schedule/presentation/78/,"Friday, May 15th, 2026",2:45p.m.-3:15p.m.,Room 104AB,Myles Scolnick,"Pyodide has proven instrumental in making scientific computing accessible to anyone with an internet connection, by eliminating the need to install and manage Python and making it possible to distribute Python applications on the web, no servers required. Combined with projects such as JupyterLite and marimo, Pyodide makes it easy to share interactive executable notebooks via a url, eliminating the financial and technical burden of deploying backend infrastructure. This talk focuses on how to build a large Python codebase that's compatible with both Pyodide and native Python, with minimal code changes. We will examine the kernel implementation of the marimo notebook, an open-source reactive Python notebook, as a case study. marimo's kernel implementation uses a single codebase, with minimal changes, for both the native Python and Pyodide codepaths, despite significant architectural differences in the two runtimes. Through this case study, we'll examine a question that is broadly applicable to developers seeking to make their tools widely accessible: How do you adapt an existing Python codebase to work in WebAssembly, without sacrificing maintainability or performance of the original implementation? For example, we'll look at examples on how to get around Pyodide's restrictions on threading and multiprocessing, how to implement interrupts, package management, and more. We will also give an overview of techniques on the frontend to ensure a performant in-browser experience, resulting in a coding editor that starts up far faster than hosted alternatives like Google Colab. No prior experience with marimo, Pyodide, or WebAssembly is required. This talk is for anyone interested in making Python tools and applications accessible to anyone with an internet connection, no servers required.",2026-05-15 14:45:00
97,Uso de Python para apoyar la traduccion de una lengua indígena en zonas rurales de Bolivia,/2026/schedule/presentation/97/,"Friday, May 15th, 2026",2:45p.m.-3:15p.m.,Room 104C,Iblin Rocio Mocho,"En muchas zonas rurales de Bolivia, las comunidades indígenas enfrentan barreras lingüísticas que limitan el acceso a la educación, la salud y los servicios públicos. Una de estas comunidades es el pueblo Tsimane, cuya lengua tiene muy poca representación digital y escaso soporte tecnológico. Esta charla presenta un estudio de caso de un proyecto en desarrollo basado en Python, que explora la creación de una aplicación sencilla de traducción del idioma Tsimane al español. Más que mostrar un producto terminado, la charla se enfoca en el contexto real, las motivaciones y los desafíos de construir tecnología en entornos con recursos limitados. Durante la presentación se abordarán: - El contexto social y cultural de trabajar con una lengua indígena en una región rural - Las razones para elegir Python como herramienta principal - Decisiones de diseño tomadas al trabajar con datos lingüísticos limitados - Desafíos técnicos y no técnicos encontrados en las primeras etapas del proyecto - Aprendizajes obtenidos como programadora relativamente nueva en Python La charla no requiere conocimientos previos de procesamiento de lenguaje natural ni de aprendizaje automático. Su objetivo es mostrar cómo Python puede ser una herramienta accesible y práctica para la preservación lingüística, la inclusión y el desarrollo de soluciones centradas en la comunidad. Las personas asistentes obtendrán ideas sobre cómo iniciar proyectos significativos con Python a partir de problemas locales, recursos limitados e ideas en etapa temprana, demostrando que es posible generar impacto social desde cualquier nivel de experiencia.",2026-05-15 14:45:00
110,Don't Block the Loop: Python Async Patterns for AI Agents,/2026/schedule/presentation/110/,"Friday, May 15th, 2026",3:30p.m.-4p.m.,Grand Ballroom A,Aditya Mehra,"Building AI agents that can reason, plan, and execute tasks requires orchestrating dozens of concurrent LLM calls, tool invocations, and external API requests. This talk explores how Python's async ecosystem—asyncio, threading, and multiprocessing—provides the foundation for building responsive, scalable agentic systems. We'll examine real patterns for concurrent agent workflows: managing parallel tool execution, handling streaming responses, implementing graceful timeouts, and coordinating multi-agent collaboration. Through practical code examples, attendees will learn when to use asyncio.gather() versus TaskGroups, how to avoid common pitfalls like blocking the event loop with synchronous LLM clients, and strategies for mixing async and sync code in production systems. The talk also compares how popular Python agent frameworks (LangGraph, CrewAI, AutoGen) leverage async patterns under the hood, helping developers make informed architectural decisions. Attendees will leave with concrete Python patterns they can immediately apply to build faster, more responsive AI applications—whether they're creating simple chatbots or complex autonomous agents.",2026-05-15 15:30:00
63,"Free-threaded Python: past, present and future",/2026/schedule/presentation/63/,"Friday, May 15th, 2026",3:30p.m.-4p.m.,Grand Ballroom B,Thomas Wouters,"Free-threaded Python, the effort to remove the Global Interpreter Lock from CPython, is one of the biggest and most exciting changes to Python in many years. However, It can be hard to follow what that means, what effect it will have on you and your code, and how this isn't yet another Python 2 to 3 migration. This overview will explain what free-threading is, why it's a big deal, how it differs from other ways to deal with the GIL, and what the plan is for ensuring a smooth migration. We'll explain the basics of thread safety, data races, and concurrent designs, how those apply to Python code, and how this will and won't change when the GIL is disabled. And yes, we'll show some threads go brrr. Although we'll mention some complex, deeply technical problems, this is not a technical deep dive and any experience level is welcome.",2026-05-15 15:30:00
69,Building AI That Explains Itself: Why Your Card Got Declined,/2026/schedule/presentation/69/,"Friday, May 15th, 2026",3:30p.m.-4p.m.,Room 103ABC,Jyoti Yadav,"Your customer's trying to buy groceries. Their card gets declined. They call, furious, asking why. Your answer: 'The fraud detection system flagged it.' They want to know why. You... don't know. When AI blocks transactions in real-time - catching fraud, stopping money laundering, protecting accounts - we can't just trust the black box. Customers are standing at checkout, embarrassed. Legitimate transactions get blocked. And you have no idea why your model made that call. This talk is about building AI systems that can explain their decisions. At Rabobank, we built explanation systems for transaction monitoring - models that process millions of transactions daily, flagging suspicious activity in milliseconds.",2026-05-15 15:30:00
121,From Graveyard to Glory: Production Python in the Browser,/2026/schedule/presentation/121/,"Friday, May 15th, 2026",3:30p.m.-4p.m.,Room 104AB,Mahmoud Hashemi,"For a decade, ""Python in the browser"" was a graveyard of transpilers (PyJS), dead plugins (Silverlight), and academic experiments. But with WebAssembly and Pyodide, we have finally arrived at a party that used to be JS-only. We can now ship a full Python runtime AND ecosystem to the client. However, moving from a ""Hello World"" demo to a production application that survives the front page of Hacker News is a minefield. This talk moves beyond demo hype to dissect the architecture of a real-world SPA that runs complex Python logic in the user's browser, with full JS/TS intercompatibility. We start with a brief, honest history of the attempts to bring Python to the web, highlighting why previous attempts failed and why the current approach is working, citing examples from the open-source ecosystem. Then, we open the hood on a production-grade case study: The Build Pipeline: How to correctly leverage CDN and build a robust distribution with wheels from PyPI, package them into versioned, cache-busted bundles, and manage dependencies strictly. The Integration: Keeping the page responsive and SEO optimized with SSR and Web Workers. We show how to orchestrate Svelte and Vite using Comlink for seamless RPC between the JS main thread and the Python worker. Plus, leveraging Pydantic + OpenAPI for TypeScript safety. The ""Real Talk"": The cost of doing business. We discuss the realities of download sizes, memory leaks, and bridging the gap between Python error tracking and browser debugging. Many lessons learned. Attendees will leave with a proven blueprint for bridging backend power with frontend interactivity, sharing code and bridging Python to new frontiers.",2026-05-15 15:30:00
75,Antispoofing en aplicaciones de escritorio: cómo Python resolvió los límites de las tecnologías web,/2026/schedule/presentation/75/,"Friday, May 15th, 2026",3:30p.m.-4p.m.,Room 104C,Carlos Jostin León Galeas,"En esta charla presentaré cómo Python se convirtió en la pieza clave para lograr la implementación de un sistema de reconocimiento facial con antispoofing dentro de una aplicación de escritorio construida con tecnologías web. Aunque el proyecto empezó como una solución basada únicamente en herramientas del ecosistema JavaScript, pronto surgieron límites importantes: las librerías disponibles no ofrecían mecanismos de detección de falsificación confiables y resultaban vulnerables a fotos y videos. La solución llegó gracias a la gran cantidad de librerías y documentación disponible en Python. Al integrar un backend local Python, empaquetado dentro del ejecutable, fue posible utilizar librerías como DeepFace y herramientas clásicas de procesamiento de imágenes para reforzar la detección. Esta combinación permitió implementar validaciones adicionales, incluyendo el cálculo de la similitud estructural (SSIM) entre imágenes capturadas en diferentes momentos, reduciendo drásticamente las falsas aceptaciones en intentos de suplantación. Durante la charla explicaré los principales retos enfrentados, tales como la forma de comunicación entre la aplicación de escritorio y el backend en Python, el empaquetado de ambos componentes, el manejo de imágenes y tiempos de procesamiento, y las pruebas realizadas para identificar intentos de falsificación. También hablaré sobre los aprendizajes extraídos del proceso, incluyendo decisiones de arquitectura, descubrimientos sobre ataques con fotos impresas, errores comunes, y mejoras obtenidas al combinar técnicas de aprendizaje profundo con métodos tradicionales. La charla está orientada a desarrolladores interesados en integrar capacidades avanzadas dentro de aplicaciones locales, especialmente cuando Python es la herramienta adecuada para potenciar proyectos basados en tecnologías web.",2026-05-15 15:30:00
81,"What Python Developers Need to Know About Hardware: A Practical Guide to GPU Memory, Kernel Scheduling, and Execution Models",/2026/schedule/presentation/81/,"Friday, May 15th, 2026",4:30p.m.-5p.m.,Grand Ballroom A,Santosh Appachu Devanira Poovaiah,"Python developers building machine learning models often interact with GPUs “indirectly” through frameworks like PyTorch, TensorFlow, and JAX. Because these frameworks abstract away low-level behavior, it’s easy to assume that GPU execution works like CPU execution—deterministic, sequential, and predictable. In practice, the GPU is running an entirely different execution model, with its own scheduling rules, memory hierarchies, precision trade-offs, and parallelism strategies. These differences can lead to surprising behaviors: sudden slowdowns, unexpected memory spikes, kernel launch bottlenecks, and accuracy drift when switching hardware. This talk offers a practical, developer-friendly introduction to the hardware concepts that directly impact Python-based AI workloads. You don’t need background in computer architecture; instead, the session focuses on the small set of hardware ideas that make the biggest difference when building or deploying machine learning models. We will walk through how GPU memory is structured, why kernel launches behave differently from Python function calls, how floating-point math on GPUs differs from CPUs, and why the same Python code behaves differently across GPU generations or SDK versions. Along the way, we’ll connect these concepts to real examples in PyTorch and TensorFlow, demonstrating how awareness of hardware behavior can improve performance, stability, and debugging outcomes. The aim of this session is not to turn Python developers into hardware experts, but to give them the mental models they need to reason about GPU behavior in a practical, Python-centered way.",2026-05-15 16:30:00
54,Lock-Free Multi-Core Performance with Behavior-Oriented Concurrency,/2026/schedule/presentation/54/,"Friday, May 15th, 2026",4:30p.m.-5p.m.,Grand Ballroom B,Matthew Johnson,"Behavior-Oriented Concurrency (BOC) is a new paradigm for parallel and concurrent programming which is particularly well-suited to Python. In a BOC program, data is shared such that each behavior has unique temporal ownership of the data, removing the need for locks to coordinate access. For Python programmers, this brings a lot of benefits. Behaviors are implemented as decorated functions, and from the programmer's perspective, those functions work like normal. Importantly, the programmer's task shifts from solving concurrent data access problems to organizing data flow through functions. The resulting programs are easier to understand, easier to support, easier to extend, and unlock multi-core performance due to the ability to schedule behaviors to run efficiently across multiple processes. BOC has been implemented in several languages, including as a foundational aspect of the research language Verona, and now has been implemented in Python. In this talk we will provide a tutorial for Python programmers on BOC programming, introduce our new boc library, and discuss the ways in which adoption of BOC as a paradigm could shape Python's development in the future.",2026-05-15 16:30:00
94,Why Software Engineering Best Practices Fail in Data Engineering,/2026/schedule/presentation/94/,"Friday, May 15th, 2026",4:30p.m.-5p.m.,Room 103ABC,Constance Martineau,"We've been told to ""treat data pipelines like software"" for years. Apply CI/CD. Write unit tests. Use version control. Follow software engineering best practices, and our data pipelines will be reliable. But here's the problem: It doesn't work. When I analyzed failure patterns across thousands of production data pipelines, I discovered something surprising: Code changes showed virtually no correlation with pipeline failures. Instead, failures traced to the inputs, like schema drift, late data and upstream systems changing behavior. All the external, unpredictable things data engineers can't control. Data engineers aren't doing software engineering ""wrong"". They're operating under fundamentally different causality: - In application development, code controls input. When something breaks, you trace it to a code change. Testing means predicting outputs for controlled inputs and practices have evolved to manage this reality. - In data engineering, inputs control code. Your code reacts to external systems you don't control. Failures trace to input variance and invalid assumptions, things you can't unit test. Software engineering practices fail in data engineering because the causality is reversed, and no amount of ""doing it better"" will change that. This talk presents empirical evidence for this pattern, explains why the conventional wisdom persists. Then it explores what actually works when inputs control your code: Treating time and data state as first-class concerns and designing for graceful degradation when inputs inevitably surprise you. If you've ever felt like you're ""doing software engineering wrong"" because your data pipelines still break, this talk will reframe everything.",2026-05-15 16:30:00
21,Demystifying Python's Generational Garbage Collector,/2026/schedule/presentation/21/,"Friday, May 15th, 2026",4:30p.m.-5p.m.,Room 104AB,Puneet Khushwani,"Python's automatic memory management is a key feature, but its primary mechanism, the generational garbage collector (GC) in CPython, often remains a black box for many developers. This talk aims to pull back the curtain, providing a clear understanding of how CPython's GC actually works, from reference counting's limitations to the intricacies of cyclic garbage detection across different generations, as well as practical debugging and optimization strategies.",2026-05-15 16:30:00
9,Python en la nube: Introducción a AWS con Boto3,/2026/schedule/presentation/9/,"Friday, May 15th, 2026",4:30p.m.-5p.m.,Room 104C,Alison Orellana-Rios,"¿Te gustaría administrar tus recursos de AWS desde Python sin depender de la consola web? En esta charla descubrirás cómo Python, junto con Boto3 (el SDK oficial de AWS), puede convertirse en tu herramienta principal para gestionar, configurar y automatizar tareas en la nube. Exploraremos cómo se crean y administran instancias EC2, el trabajar con almacenamiento S3 e invocación de funciones Lambda directamente desde código. Conocerás los pasos que se requieren para integrar Python en los flujos de DevOps y administración en la nube, logrando procesos más eficientes, repetibles y escalables. La sesión está pensada para desarrolladores, DevOps, data engineers y entusiastas que quieran iniciar o fortalecer su camino en la nube utilizando Python. A lo largo de la presentación, se cubrirán conceptos clave como la creación y gestión de instancias, almacenamiento, la automatización de funciones y la integración de Python en procesos de DevOps.",2026-05-15 16:30:00
101,How to Build Your First Real-Time Voice Agent in Python (Without Losing Your Mind),/2026/schedule/presentation/101/,"Friday, May 15th, 2026",5:15p.m.-5:45p.m.,Grand Ballroom A,Camila Hinojosa Añez,"Voice agents powered by LLMs look amazing in demos… until you try to build one yourself and the problems start: slow responses, overlapping audio, and a bot that either hallucinates non-stop or falls into eternal silence. In this talk, I’ll share how I built an “English Speaking Buddy” voice agent: an English tutor you can talk to, that adapts to your level and helps you lose the fear of speaking. It’s built with Python, AWS services (for speech and LLM), and Pipecat, an open source Python framework for creating real-time conversational voice agents. We’ll walk through the core pipeline audio → text → LLM → audio, and how to build a clear, maintainable architecture for real-time voice agents. We’ll also look at the less glamorous but critical parts that make this actually work: handling errors, configuring and protecting API keys, logging what’s going on, and making good design decisions so the conversation with the bot feels natural. Even though the examples use AWS and Pipecat, the patterns we’ll discuss can be applied with other providers and libraries. You’ll leave with a clear mental model of how these agents work, concrete Python code examples you can adapt to your own projects, and a small checklist to turn a demo into something people can actually talk to.",2026-05-15 17:15:00
45,Demystifying the GIL,/2026/schedule/presentation/45/,"Friday, May 15th, 2026",5:15p.m.-5:45p.m.,Grand Ballroom B,Bruce Eckel,"Python 3.14 makes it easy to invoke a version of the interpreter without the Global Interpreter Lock (GIL). This makes it especially important to understand the GIL and how it affects your code, otherwise you’ll encounter surprises when attempting to write code without the GIL. This presentation introduces the GIL for Python novices and covers issues you must know to begin understanding the challenges of switching to GIL-free Python. We’ll explore how the GIL maintains reference-counted garbage collection, then look at how Python’s different concurrency strategies solve different kinds of problems. The heart of this talk shows how the GIL incidentally protects you from basic shared-memory concurrency errors, so you understand that removing the GIL will likely reveal those errors when you don’t expect them.",2026-05-15 17:15:00
93,Debugging Python in Production: Practical Techniques Beyond Print Statements,/2026/schedule/presentation/93/,"Friday, May 15th, 2026",5:15p.m.-5:45p.m.,Room 103ABC,Anshul Jannumahanti,"Debugging Python code becomes significantly harder once applications move beyond local scripts and into real environments. Logs are incomplete, errors are intermittent, and reproducing failures is often non-trivial. This talk focuses on practical debugging techniques for Python applications, emphasizing tools and workflows that developers can apply immediately. Rather than relying on theoretical examples, the session walks through realistic failure scenarios and shows how to diagnose them using Python’s built-in and ecosystem tooling. Topics include structured logging, stack trace analysis, runtime inspection, and controlled reproduction of bugs. Attendees will see how to move from vague error reports to actionable fixes, even when issues cannot be reproduced locally on the first attempt. All examples use small, reproducible Python programs that attendees can run on their own machines. The goal is not to introduce new frameworks, but to build confidence and intuition around debugging techniques that work across different kinds of Python applications. By the end of the talk, attendees will be better equipped to debug issues in unfamiliar codebases, reason about failures under incomplete information, and reduce time spent guessing at the root cause of bugs.",2026-05-15 17:15:00
38,Python and the JVM - A Love Story,/2026/schedule/presentation/38/,"Friday, May 15th, 2026",5:15p.m.-5:45p.m.,Room 104AB,Shir Havron,"Baby, just say yes! Teach your Python programs the love language of the JVM with Py4J - a high-performance tool to leverage the power of the JVM from within Python itself for performance, fun and profit. Learn how to use Py4j, the core package behind big data engines like PySpark, to unlock the magic of powerful performance driven applications with clean and easy to use Python APIs.",2026-05-15 17:15:00
43,“Cuando pip install no es suficiente: amenazas reales y defensas prácticas en Python y PyPI”,/2026/schedule/presentation/43/,"Friday, May 15th, 2026",5:15p.m.-5:45p.m.,Room 104C,Diego Caceres Solis,"El ecosistema Python se ha convertido en uno de los pilares del desarrollo moderno, pero su apertura y velocidad también lo han transformado en un objetivo atractivo para ataques de malware, typosquatting, dependencias maliciosas y compromisos de la cadena de suministro. En este contexto, ejecutar un simple pip install ya no es una acción inocente. En esta charla, basada en experiencia real en ciberseguridad y operación de entornos productivos, se analizarán las principales amenazas que afectan a Python y PyPI, mostrando cómo actores maliciosos explotan la confianza del ecosistema open source. A través de ejemplos concretos y casos reales, se evidenciarán riesgos que impactan tanto a desarrolladores individuales como a organizaciones empresariales. Finalmente, se presentarán defensas prácticas y aplicables para fortalecer aplicaciones Python en distintos entornos: buenas prácticas de gestión de dependencias, controles de seguridad en pipelines CI/CD, herramientas de análisis de paquetes, principios DevSecOps y estrategias para reducir el riesgo sin frenar la innovación. El objetivo es entregar a la audiencia criterio, conciencia y acciones concretas para pasar de consumidores pasivos a defensores activos del ecosistema Python.",2026-05-15 17:15:00
142,Python for Humans - Designing Python Code Like a User Interface,/2026/schedule/presentation/142/,"Saturday, May 16th, 2026",10:30a.m.-11a.m.,Grand Ballroom A,Justin Lee,"This talk explores how UI and UX design principles such as layout, labeling, affordances, and hierarchy can help you write Python code that is easier to read, navigate, and maintain. In a team setting, Python code is not just instructions for machines. It is an interface your teammates interact with, extend, and depend on over time. Many of the biggest slowdowns in collaborative development come from code that is hard to revisit. Opening an old file and struggling to remember what it does or why it exists is a familiar and frustrating experience. This talk shares design-inspired practices that help make Python code more discoverable and easier to return to, even months later. We will look at how ideas from interface design translate directly to code structure. Concepts like visual hierarchy, layout, and progressive disclosure can guide how you organize files, name functions, and design function signatures so readers can scan code top-down, just like a well-designed page. Topics include: • Using top-level structure as layout to improve scannability • Treating naming like labeling to aid navigation and tool-assisted discovery • Using spacing and indentation to signal intent and grouping • Applying decorators and type hints to clarify usage without adding noise • Using tools like black, ruff, and Pylance as consistency and clarity enforcers • Knowing when to avoid cleverness in favor of long-term readability This talk is about adopting a mindset. Treat your codebase like a user experience, and write Python you will not dread revisiting.",2026-05-16 10:30:00
51,Conquer multithreaded Python with Blanket,/2026/schedule/presentation/51/,"Saturday, May 16th, 2026",10:30a.m.-11a.m.,Grand Ballroom B,Larry Hastings,"Debugging and testing multithreaded code in Python is so challenging. How do you create reproducible tests of multithreaded code, when the order of execution changes from run to run? How do you achieve 100% coverage, when you ship code only called to handle rare, obscure race conditions? And if you think it's a problem now... just imagine how much worse it's going to become as adoption of ""nogil"" Python grows! Blanket is here to help. Come learn how Blanket gives you back control over the order of execution in multithreaded code, enabling you to write deterministic multithreaded tests. Restore blessed order and determinism to your unit test suite--use Blanket!",2026-05-16 10:30:00
34,"FastAPI Security Patterns: OAuth 2.0, JWTs, and API Keys Done Right",/2026/schedule/presentation/34/,"Saturday, May 16th, 2026",10:30a.m.-11a.m.,Room 103ABC,Ian,"Every FastAPI application needs authentication, but the security landscape is confusing. OAuth 2.0 has multiple grant types. JWTs have access tokens, refresh tokens, and claims. API keys seem simple but hide complexity. When do you use each? How do you implement them without security holes? This talk cuts through the confusion with battle-tested patterns from production systems. We'll implement each authentication method live, discussing not just the ""how"" but the ""why"" and ""when."" JWTs Done Right: Token structure, signing algorithms, refresh token rotation, and the mistakes that get apps hacked. We'll build secure token handling with python-jose and FastAPI's dependency injection. OAuth 2.0 for Real Applications: Authorization Code flow for web apps, PKCE for mobile and SPAs, and when to use Client Credentials for service-to-service auth. Practical integration patterns with real identity providers. API Keys That Scale: Why hashing matters, implementing key rotation without downtime, scoping permissions, and rate limiting per key. Simple doesn't mean insecure. Combining Methods: Many production apps need multiple auth strategies. We'll build middleware that gracefully handles JWT, OAuth, and API key authentication on the same endpoints. You'll leave with a decision framework for choosing authentication methods, production-ready code patterns, and a security checklist to audit your existing FastAPI applications. Whether you're securing a public API, building internal services, or integrating with third-party platforms, these patterns will keep your users safe.",2026-05-16 10:30:00
90,Hash me if you can: let's talk about Python dictionaries!,/2026/schedule/presentation/90/,"Saturday, May 16th, 2026",10:30a.m.-11a.m.,Room 104AB,Mia Bajić,"We all use dictionaries constantly, but most of us treat them as a black box. This talk opens that box. We'll walk through how hash tables actually work and what the 2011 ""hash flooding"" vulnerability taught us about algorithmic complexity attacks. We'll also check some genuinly weird behavior (hash(-1) == hash(-2)), the birthday paradox, and why your hash seeds are randomized. We'll wrap up with a quick tour of other hash-based structures like Bloom filters and consistent hashing.",2026-05-16 10:30:00
76,Python como herramienta de movilidad social en comunidades afro y subrepresentadas,/2026/schedule/presentation/76/,"Saturday, May 16th, 2026",10:30a.m.-11a.m.,Room 104C,Veronica Rodriguez Viveros,"Python es uno de los lenguajes de programación más accesibles del mundo, pero su verdadero poder no está solo en su sintaxis sencilla o su ecosistema robusto, sino en su capacidad de abrir puertas donde históricamente han existido barreras. En esta charla comparto cómo Python se ha convertido en una herramienta real de movilidad social para personas afrodescendientes y comunidades subrepresentadas en Colombia y América Latina, permitiendo el acceso a educación tecnológica, empleos de calidad y liderazgo en la industria tech. A partir de experiencias concretas en programas comunitarios, talleres, mentorías y proyectos de formación, exploraré cómo el aprendizaje de Python ha facilitado transiciones profesionales, creación de oportunidades económicas y construcción de comunidades técnicas sostenibles. La charla aborda los desafíos estructurales que enfrentan estas comunidades, desde la falta de acceso a educación formal hasta la exclusión de redes profesionales globales, y cómo el software libre y las comunidades Python pueden actuar como catalizadores de cambio cuando se diseñan con intención y enfoque humano.",2026-05-16 10:30:00
10,Don’t Write Polars Code with a Pandas Accent,/2026/schedule/presentation/10/,"Saturday, May 16th, 2026",11:15a.m.-11:45a.m.,Grand Ballroom A,Joram Mutenge,"Abstract Many Python developers adopt Polars expecting immediate speedups, only to be disappointed when their code shows little improvement or even runs slower than pandas. The issue is not Polars, but how it is used. Writing Polars code as if it were pandas, that is, with a pandas accent, leads to confusing code and poor performance. This talk focuses on writing idiomatic Polars code instead of translating pandas patterns line by line, empowering Python developers to work efficiently with large datasets without leaving the Python ecosystem. We will show common mistakes made by developers transitioning from pandas to Polars, such as using square bracket notation, overusing eager execution, and relying on intermediate variables. Through code examples, the talk will demonstrate how Polars promotes a different mental model built around expressions, lazy execution, and chained operations. Attendees will learn best practices for structuring Polars pipelines, writing clear and composable expressions, and leveraging the query optimizer through chained operations. By the end of the session, participants will be able to recognize pandas-accented Polars code and confidently rewrite it in a way that is more readable, performant, and idiomatic. More importantly, they will learn to think in Polars first, writing code that is faster and easier to maintain. Audience This talk is for data scientists, analysts, and engineers familiar with pandas who are beginning to explore Polars. Intermediate Polars users will learn best practices to improve code quality and performance, while beginners will gain insight into how Polars differs conceptually from pandas and why it matters. Takeaways How Polars’ execution model differs from pandas. Spot pandas habits that lead to poor Polars code. Adopt idiomatic Polars patterns for data transformation and analysis. Embrace chained operations to leverage the query optimizer.",2026-05-16 11:15:00
6,Switching from Sphinx to Markdown,/2026/schedule/presentation/6/,"Saturday, May 16th, 2026",11:15a.m.-11:45a.m.,Grand Ballroom B,Kattni,"For most of Python's history, the predominant option for documentation has been Sphinx and reStructuredText. However, a majority of other ecosystems have adopted Markdown. There are historical reasons for reStructuredText being a better choice than Markdown, but those reasons no longer exist. In this talk, you'll learn why Markdown is a better option for your project's documentation. You'll be introduced to MkDocs, a static site generator built around Markdown content, and a series of associated plugins and extensions that you need to bring Sphinx-like capabilities to a Markdown site. You'll also hear a case study of migrating multiple large, existing Sphinx-based documentation bases to Markdown, including the tools used for automating the process. You'll learn how you can engage the community to assist with the effort. Finally, you'll learn why it's worth the effort to make a change of this magnitude.",2026-05-16 11:15:00
74,Anatomy of a Phishing Campaign,/2026/schedule/presentation/74/,"Saturday, May 16th, 2026",11:15a.m.-11:45a.m.,Room 103ABC,Mike Fiedler,"In July 2025, PyPI users received emails directing them to pypj.org—a near-perfect clone transparently proxying requests to pypi.org. Within hours, attackers compromised four accounts and uploaded malicious releases of the popular num2words package. This talk dissects the complete attack chain: how attackers harvested email addresses from public package metadata, built a transparent proxy that relayed TOTP codes in real-time, and why traditional 2FA failed while WebAuthn-based authentication stopped the attack cold. The session covers the incident response timeline, challenges getting malicious infrastructure taken down (including initial rejection of abuse reports), and defensive measures deployed afterward—including new email verification for TOTP logins from unrecognized devices. Attendees will learn exactly how modern phishing attacks work against package repositories, the critical difference between ""phishable"" and ""phishing-resistant"" 2FA, and practical steps to protect accounts and packages from the next campaign. The talk also examines the September 2025 follow-up campaign targeting pypi-mirror.org and patterns across these ongoing attacks.",2026-05-16 11:15:00
28,"Beyond Optional in Real-World Projects: Missing, None, and Unset",/2026/schedule/presentation/28/,"Saturday, May 16th, 2026",11:15a.m.-11:45a.m.,Room 104AB,Koudai Aono,"Have you ever merged a config file, applied an input that says ""update only these fields"", or handled an API payload, only to overwrite data because ""missing"", None, and ""unset"" were treated as the same thing? In real-world projects, ""no value"" has at least three meanings: a missing key (the field is absent), an explicit None (the value is present and intentionally null), an unset input (the caller didn't specify the field, so you must not touch it). When we collapse these into T | None (a nullable type) or fall back to dict[str, Any], type checking becomes noisy, branching becomes fragile, and refactors get risky. Every field nullable, every check defensive, every change scary. This is a practical talk about using typing to model and safely consume real-world data with TypedDict and dataclasses, not a typing tutorial or a framework pitch. We'll walk through one end-to-end example (payload -> normalization -> domain model -> safe updates) with before/after code and focus on patterns you can apply immediately: Use Required / NotRequired to model missing keys instead of abusing T | None. Use T | None only when None is a meaningful value. Represent unset inputs with a sentinel pattern (starting from UNSET = object() and optionally evolving to typing_extensions.Sentinel) so partial updates don't silently overwrite data and the type checker can distinguish unset from None. Keep extraction code honest with type aliases, TypeIs, and (optionally) small match cases for readability. After this session, you'll be able to define stricter data models, write safer extraction code, and make schema changes less painful, because your types will reflect what your data actually means. This talk is for intermediate Python developers who already use type hints in production.",2026-05-16 11:15:00
7,Python el puente para la Robótica educativa,/2026/schedule/presentation/7/,"Saturday, May 16th, 2026",11:15a.m.-11:45a.m.,Room 104C,Randy Gutierrez,"En la robótica educativa, Python suele ser el puente entre el mundo físico (sensores, motores y microcontroladores) y experiencias de aprendizaje más potentes como visualización de datos, automatización, interfaces y una puerta hacia visión/IA. En esta charla mostraré cómo introducir Python de forma accesible para docentes y estudiantes que vienen desde Arduino/ESP32/micro:bit, incluso si no tienen un perfil técnico o conocimiento amplio de la tecnología. Veremos un flujo simple: adquirir datos desde un microcontrolador, interpretarlos de forma segura, y convertirlos en retroalimentación útil para el aula (por ejemplo: gráficos en tiempo real, paneles sencillos o una interfaz de control). El enfoque será totalmente práctico: qué enseñar primero, errores típicos al conectar hardware con Python (ruido, latencia, reconexión, formatos de datos), y un “checklist” para que la actividad sea replicable con grupos grandes. La idea es que el público se lleve una ruta clara para integrar Python como parte del futuro de la robótica educativa, empezando con proyectos simples que realmente funcionen en clase.",2026-05-16 11:15:00
80,No More Spreadsheets! Building PyLadiesCon Infrastructure with Python and Django,/2026/schedule/presentation/80/,"Saturday, May 16th, 2026",noon-12:45p.m.,Grand Ballroom A,Mariatta,"PyLadiesCon is an online conference for the Global PyLadies community. It is one of a kind conference with programming spans 24 hours and offering talks and contents in multiple languages. Run entirely by volunteers, we face unique challenges specific to the nature of our conference. One of the ways we have been managing the various aspects of PyLadiesCon is by using spreadsheets. Spreadsheets for volunteer sign ups, spreadsheets for program scheduling, spreadsheets for sponsorship. Any information you want about the conference, we have a spreadsheet for that. While spreadsheets are great for capturing data, they come with drawbacks when it comes to online collaboration with various team members, causing frustrations and confusion among our team of volunteers. In 2025, PyLadiesCon team said no to spreadsheets and instead started building our conference infrastructure: an open source web app for managing various aspects of our conference. Learn more our challenges in managing the online PyLadiesCon conference, and how we're solving our problems with Python and Django. Contribute to the project, and support the PyLadies community.",2026-05-16 12:00:00
40,The Exceptions We Don't Catch in Technical Conversations,/2026/schedule/presentation/40/,"Saturday, May 16th, 2026",noon-12:30p.m.,Grand Ballroom B,Emin Martinian,"""The major problems of our work are not so much technological as sociological"" argues the book Peopleware. Yet we spend most of our time on developing and training technical skills. We are so careful with error handling, testing, exceptions, etc., in our code but remarkably sloppy about catching the errors in how we talk to each other. Do you agree with the above? If so, I hope you will enjoy hearing about examples where supposedly objective feedback carried hidden judgments, where being technically correct didn't change anyone's mind, and where teammates were hired for individual strengths and then blamed for thinking differently. If you did not agree, then maybe you will appreciate that the first paragraph is itself an example of the patterns this talk is about: I smuggle in an evaluation (""we're sloppy""), I state something that may be true but easily triggers defensiveness, and I fail to take ownership of my own contribution to the problem. I share some communication failures and discuss frameworks from various authors that helped me understand what went wrong. If you have tried to give helpful feedback and wondered why you ended up in an argument, won an argument but lost the conversation, or been frustrated when someone makes what seem like obviously poor decisions, some of these patterns might be familiar. I hope you will leave the talk with insights for improving communication and ideas for getting yourself out of the way in technical conversations.",2026-05-16 12:00:00
140,Zero Trust in 200ms: Implementing Identity-Per-Transaction with Python and Serverless,/2026/schedule/presentation/140/,"Saturday, May 16th, 2026",noon-12:30p.m.,Room 103ABC,Tristan McKinnon,"Building a data pipeline is difficult. Building one that satisfies the US Federal Government's strictest security controls (FedRAMP High) while handling Protected Health Information (PHI) is typically a nightmare of encryption management and rigid access controls. This talk dissects the architecture of a production serverless pipeline designed for federal life sciences that flips the traditional security model on its head. We move beyond pip install cryptography to explore how Python acts as the dynamic glue between rigorous compliance verification and massive data throughput. Attendees will learn: The Identity-Per-Transaction Pattern: Why ""rotating keys"" is obsolete. We walk through a Python-based identity broker that instantiates a unique, cryptographically scoped IAM credential for every single file transaction—and destroys it milliseconds later. Streaming De-identification: How to implement a clean room scrubbing layer using Python generators and NLP (Microsoft Presidio) to tokenize PII in-memory before it ever touches your data lake. Audit-Ready Logging: Techniques for structuring Python's logging module to produce immutable, auditor-friendly JSON trails that prove compliance without leaking sensitive data. Join us to see how we replaced static service accounts with ephemeral Python logic to solve the ""Non-Human Identity"" crisis in high-stakes environments.",2026-05-16 12:00:00
26,The Unseen Pull Request: The Crisis We Don’t Measure,/2026/schedule/presentation/26/,"Saturday, May 16th, 2026",noon-12:30p.m.,Room 104AB,Lokko Joyce Dzifa,"What holds open source together when the code is done? Recent research paints a worrying picture: 58% of open source maintainers have considered stepping back, and over two-thirds of OSS work is non-code labor: conflict mediation, mentoring, documentation, governance, and emotional labor.Most of it unpaid, invisible, and unrewarded. These pressures are disproportionately carried by community leads and underrepresented contributors. As open source scales across companies, foundations, and global teams, outdated governance models built to manage code is today being asked to manage humans, and they’re failing or buckling under the weight of human complexity. We continue to optimise for commits while ignoring emotional load, collaboration friction, and psychological safety, the very factors that determine sustainability. I’ve lived this tension as a Service Delivery Manager and community leader. I’ve helped build and sustain communities, but I’ve also reached the point of emotional exhaustion, questioning whether my unseen contributions mattered at all. This talk argues that ignoring emotional labor is no longer neutral , it is actively harmful. We’ll explore how modern governance approaches, supported by AI-driven tooling such as sentiment analysis, workload dashboards, and governance bots, can surface invisible work, distribute responsibility more fairly, and prevent burnout before it becomes exit.If open source is to survive its own success, we must start treating its human systems with the same rigor as its technical ones.",2026-05-16 12:00:00
18,¿Cómo Python puede ayudar a detectar señales tempranas en la salud mental universitaria?,/2026/schedule/presentation/18/,"Saturday, May 16th, 2026",noon-12:30p.m.,Room 104C,Valentina Lazaro,"Bolivia como muchos otros países de América Latina a diario se enfrenta con un tema poco visibilizado, que es la salud mental, especialmente en jóvenes universitarios, a pesar de su impacto directo en el bienestar, el rendimiento académico y la vida de miles de jóvenes. Factores emocionales, socioeconómicos, entre otros suelen acumularse sin ser detectados a tiempo lo que dificulta una intervención oportuna y el posible desarrollo de un trastorno mental, como la depresión. En esta charla se comparte cómo Python fue usado como una herramienta clave para apoyar la detección temprana de riesgo de depresión en una población universitaria, combinando análisis de datos e inteligencia artificial de forma responsable y ética. Python permitió explorar y analizar datos con características sociodemográficas y emocionales logrando identificar factores de riesgo de depresión y patrones relevantes. Además se usó Python para adaptar un modelo de PLN mediante fine-tuning para analizar respuestas a preguntas abiertas escritas por estudiantes, lo que ayudó a identificar emociones presentes en el lenguaje, y así ampliar la visión para detectar un posible nivel de riesgo de depresión. Más allá de la tecnología, la charla se centra en las decisiones tomadas, los aprendizajes obtenidos y los cuidados cuando se trabaja con datos sensibles. El objetivo de este proyecto no fue diagnosticar o reemplazar a los profesionales de la salud sino apoyar la detección temprana de riesgo de depresión manteniendo siempre a las personas en el centro del proyecto.",2026-05-16 12:00:00
64,"[Yes, You Can] Test SQL",/2026/schedule/presentation/64/,"Saturday, May 16th, 2026",1:30p.m.-2:15p.m.,Grand Ballroom B,Paul Zuradzki,"Testing SQL can be awkward. In this talk, we'll cover how to test raw SQL with and without a live database, strategies for managing test environments, testing across SQL dialects, and automating code quality checks locally and in CI (Continuous Integration). You'll leave with concrete patterns and code examples that you can apply to your SQL pipelines. This talk is aimed at (1) Python developers who want to bring software engineering rigor to their SQL workflows and (2) SQL/data engineers looking to level up with Python-based testing tools and automation.",2026-05-16 13:30:00
115,The Surprising Effectiveness of Immutable Data Structures,/2026/schedule/presentation/115/,"Saturday, May 16th, 2026",1:30p.m.-2:15p.m.,Room 104AB,Brett Slatkin,"The functional programming style is often praised as the best way to write maintainable programs, in contrast to the highly-mutable OOP style that is commonly pervasive in Python programs. Although Python is a multi-paradigm language that supports writing functional code, practically speaking there are limitations that prevent Python from fully realizing the benefits. That said, there is still a lot of value that Python programmers can receive by embracing one of the core principles of the functional style: immutability. This talk will present how to incorporate immutability into your programs: how it will help you write better business logic, improve the quality of tests, simplify debugging and reproducing issues, and enable parallelism and speed-ups in a potentially GIL-less future version of Python. It will cover practical examples of where immutability shines and where it falls short. It will discuss the frozen feature of the dataclasses built-in library, and how it compares to and complements other immutable language features and community packages.",2026-05-16 13:30:00
99,Create a Python Package: From Zero to Hero,/2026/schedule/presentation/99/,"Saturday, May 16th, 2026",1:45p.m.-2:15p.m.,Grand Ballroom A,Mario Munoz,"Ever wondered where those cool things that you pip install come from? Have you thought about what it might take for you—yes, you—to create your very own package that others can install and enjoy? This talk will talk about specific ways in which you can move from problem, to idea, to implementation, and lastly, packaging. It might sound intimidating, but by the end of this talk, you will have the know-how to wrap up your own cool ideas and unleash them to the world!",2026-05-16 13:45:00
1,Rust for CPython: Making Python Safer and More Robust for Everyone,/2026/schedule/presentation/1/,"Saturday, May 16th, 2026",1:45p.m.-2:15p.m.,Room 103ABC,Emma Smith,"You're running a program written in Python and suddenly Segmentation fault (Core dumped) - your program crashed. Wait what? Python isn't supposed to segfault! Today, significant parts of CPython are written in C. C code suffers from memory and thread unsafety, leading to crashes and potentially exploitable security bugs. But how can these issues be eliminated? The Rust for CPython project proposes to address these issues by introducing the Rust programming language to CPython and migrating parts of CPython to Rust. We'll discuss how Rust is able to prevent memory and thread unsafety before running any code, and how large projects like Android and Chromium have leveraged Rust to not only reduce unsafety, but also increase developer velocity and confidence in changes. But how do you go from a massive project in C to adding Rust? We'll cover the technical and social aspects of introducing Rust into CPython, such as engaging new contributors and ensuring compatibility with the old code. We'll also discuss future plans for the Rust for CPython project.",2026-05-16 13:45:00
137,Interoperabilidad de hardware con Python para sistemas conectados,/2026/schedule/presentation/137/,"Saturday, May 16th, 2026",1:45p.m.-2:15p.m.,Room 104C,Hugo Leyton,"En un mundo lleno de dispositivos conectados, lograr que el hardware ""hable"" con los sistemas modernos sigue siendo sorprendentemente difícil. Sensores que entregan bytes crudos por UART, equipos industriales que hablan Modbus, servicios cloud que esperan JSON bien formado y APIs que cambian con frecuencia: la interoperabilidad rara vez es un problema de una sola librería, sino de cómo diseñamos la integración. Esta charla muestra cómo usar Python como capa unificadora entre hardware y sistemas conectados, mediante patrones concretos de interoperabilidad. Veremos cómo pasar de señales físicas desordenadas a un modelo de datos canónico, validado y listo para ser consumido por servicios, dashboards o pipelines de datos. Exploraremos tres ideas clave: - Cómo diseñar un modelo canónico en Python que represente lecturas de hardware de forma consistente. - Cómo construir ""protocol bridges"" que traduzcan entre UART/serial, MQTT o HTTP sin duplicar lógica. - Cómo aplicar validación y normalización cerca del dispositivo (validation at the edge) para detectar datos corruptos, incoherentes o peligrosos antes de que lleguen al sistema central. Acompañaremos estos conceptos con una demo donde Python actúa como intermediario entre un dispositivo físico (o simulado) y un servicio conectado, mostrando logs, datos transformados y puntos de extensión. Quienes asistan saldrán con patrones reutilizables, ejemplos claros y criterios para decidir cuándo usar cada enfoque, de modo que puedan integrar hardware en entornos modernos sin caer en soluciones frágiles o difíciles de mantener.",2026-05-16 13:45:00
61,Beyond Rate Limiting: Adaptive Security for Python Web Applications,/2026/schedule/presentation/61/,"Saturday, May 16th, 2026",2:30p.m.-3p.m.,Grand Ballroom A,Aayush Gauba,"Modern web abuse rarely looks like a traditional attack. Bots scrape content slowly, spam blends in with real users, and malicious clients often behave just well enough to avoid static rules. Many Python web applications rely on rate limiting, IP blocking, or simple pattern matching, which can miss these kinds of threats or create unnecessary false positives. This talk explores a behavior-based approach to securing Python web applications using lightweight AI techniques that run directly inside application middleware. Rather than focusing on heavy models or external security services, the session looks at how Python developers can use signals they already have, request timing, headers, paths, and error patterns, to detect abuse more reliably. The ideas in this talk are drawn from building and testing adaptive security middleware across multiple Python web frameworks, including Django, Flask, and FastAPI. Attendees will learn what signals are useful, where AI helps, where it doesn’t, and how to design security systems that fail safely and respect user privacy.",2026-05-16 14:30:00
124,Where the Sidewalk Ends: Data-Driven Urban Safety,/2026/schedule/presentation/124/,"Saturday, May 16th, 2026",2:30p.m.-3p.m.,Grand Ballroom B,Fay Shaw,"Pedestrian fatalities are on the rise across the US, yet available data remains difficult to access and understand. I built MOSEY, a Streamlit app that visualizes car crashes with Walk Score to better understand street safety where I live. This talk shows how Python tools can transform civic engagement -- and what I learned from building a personal project to becoming part of collective action. The motivation of this project came from seeing pedestrian fatalities close to home. As a concerned citizen and as a data scientist, I wanted to better understand pedestrian and cyclist safety in the city north of Boston. The Massachusetts Department of Transportation (MassDOT) Crash Portal provides extensive dashboards and statewide statistics, but it’s not intuitive to use. Concurrently, I thought about how to define walkability. Walk Score is often used, but it is based on if errands can be completed by foot, not safety. I wanted to visualize both together. Using MassDOT data and the Walk Score API, I built MOSEY (Move On Safely EverYone) with Streamlit, geopandas, and folium. Users enter an address to see nearby car crashes from the last 10 years along with the Walk Score, for a fuller picture of walkability. I joined local organizations that advocate for pedestrian and cyclist safety and I used my analysis to push for a proposed bike path. We recently conducted walk audits to understand the condition of sidewalks and streets, and we’ll synthesize this data to advance safer streets legislation. What started as a personal project has led me to engage with my community and I hope it inspires others to do the same.",2026-05-16 14:30:00
116,Asleep at the Wheel: Getting your SBOMs to pay attention to Python Builds,/2026/schedule/presentation/116/,"Saturday, May 16th, 2026",2:30p.m.-3p.m.,Room 103ABC,Sanchit Sahay,"Between competing standards, tools, and compliance-checkboxes, developers are effectively told to “generate an SBOM” and move on. Security teams are told to trust this SBOM implicitly. When that SBOM is incomplete or inaccurate, the result is noise that creates a real security risk. Vulnerabilities can go undetected, where teams cannot confidently determine their exposure, and the compliance reviews/tools have to work with incomplete evidence of what actually happened. In the Python ecosystem, this problem is common. SBOMs rely solely on scanning environments and trusting declared dependencies. This model breaks often and silently, Python wheels for example include more dependencies than the metadata reveals - bundled libraries, vendored code, and build-time artifacts are often undetected. These missing components cause security teams to miss vulnerable components entirely and approve builds that violate organizational policy. This talk introduces SBOMit, an OpenSSF project which closes SBOM blind spots by generating SBOMs from build evidence rather than metadata alone. SBOMit consumes in-toto attestations and breaks the reliance on idealised assumptions and addresses the gaps of traditional SBOM tools. SBOMit asks the important question: “What did the build actually do?”. What commands it ran, files it accessed, and network calls it made. This approach lets us use CI attestations and provenance as a further source of truth. In this talk we examine the gaps in today’s SBOM generation approaches and how they affect Python ecosystem. We walk through SBOMit’s architecture and how it provides a workflow to plug into your SBOM generation process. Finally, we’ll demonstrate how evidence-based SBOMs can be turned into enforceable CI policies for example preventing unexpected network access during builds or detecting unexplained files in final artifacts. SBOMit transforms your SBOM from a background actor to an active member of your supply-chain security toolkit.",2026-05-16 14:30:00
109,Using Python Biopharm to Help Cure Cancer,/2026/schedule/presentation/109/,"Saturday, May 16th, 2026",2:30p.m.-3p.m.,Room 104AB,Sushant Singh,"Cancer research produces enormous volumes of data — experiments, manufacturing runs, quality investigations, and clinical outcomes. Yet the hardest problems aren’t about scale or storage. They’re about context: understanding how decisions, processes, and data points connect when human lives are on the line. In this talk, I’ll share how I used Python to build systems that help scientists and engineers reason about cancer therapies in development — not through dashboards alone, but through connected data and conversational interfaces that answer meaningful, qualitative questions. You’ll see how FastAPI and Pydantic enable strongly typed, auditable APIs suitable for regulated environments, and how Neo4j can model biological, manufacturing, and operational relationships as a living graph. On top of this foundation, we built chat-based interfaces that don’t just retrieve documents, but traverse relationships, surface patterns, and explain why something happened — enabling questions like “What changed?”, “Where have we seen this before?”, and “What decisions led us here?” This is not a hype-driven AI talk. It’s a practical, production-focused story about Python used where correctness matters, trust must be earned, and failure has real consequences. It’s also a reminder that Python’s greatest strength isn’t just speed of development — it’s its ability to bring clarity to complex, human problems. If you’re interested in Python beyond demos — in systems that inform decisions and meaningfully impact people’s lives — this talk is for you.",2026-05-16 14:30:00
46,Cuando los datos no hablan: Python como intérprete de la supervivencia de las especies,/2026/schedule/presentation/46/,"Saturday, May 16th, 2026",2:30p.m.-3p.m.,Room 104C,Joyce Beatriz Ferreira da Costa Silva,"¿Cómo puede Python ayudarnos a entender por qué algunas especies desaparecen y otras sobreviven? Hoy en día tenemos muchos datos sobre especies, poblaciones y ambientes. El problema ya no es la falta de información, sino qué hacer con ella. Muchas veces analizamos estos datos por separado y, en ese proceso, se nos escapan patrones importantes que podrían ayudarnos a explicar por qué algunas especies sobreviven y otras no. En este punto, Python deja de ser solo una herramienta técnica y se convierte en una forma práctica de explorar datos, probar ideas y hacer mejores preguntas. En esta charla se presentará una aplicación práctica de Python para optimizar y aplicar el algoritmo DBSCAN (Density-Based Spatial Clustering of Applications with Noise), un método que permite agrupar datos similares y detectar patrones en conjuntos de datos complejos. El trabajo se desarrolló en colaboración con el Instituto de Ciencias Biológicas de la Universidad Federal de Goiás (ICB-UFG) y utiliza datos biológicos para estudiar patrones de supervivencia, extinción y diversificación genética. Como ejemplo especies sometidas a alta presión ambiental, como el guacamayo azul, una especie nativa de Sudamérica afectada por la pérdida de hábitat y la fragmentación de sus poblaciones. A lo largo de la charla compartiré cómo abordamos este problema con Python: qué decisiones tomamos, qué funcionó, qué no y por qué. Veremos cómo preparar los datos, cómo experimentar con este tipo de clustering en Python y, sobre todo, cómo interpretar los resultados sin sacar conclusiones apresuradas. La idea es que salgas de la charla con más criterio para usar clustering en Python cuando los datos no se comportan como esperas.",2026-05-16 14:30:00
31,Tachyon: Python 3.15's sampling profiler is faster than your code,/2026/schedule/presentation/31/,"Saturday, May 16th, 2026",3:15p.m.-3:45p.m.,Grand Ballroom A,Pablo Galindo Salgado,"In the core dev team we set out to build the best sampling profiler for any interpreted language and place it in the standard library. Python 3.15 ships the result: Tachyon, a sampling profiler that can sample at the microsecond level. At that speed, your profiler might actually be doing more work than the code it's profiling. This talk is the story of how we built it. You'll learn how to read memory from a running process without stopping it, how to make sense of Python's internal structures from the outside, and what tricks are needed to go from ""fast enough"" to ""this speed is almost illegal"". If you've ever wondered what it takes to build a profiler that can attach to a production server, grab data, and leave without the application noticing, this is where you find out. But this isn't just a talk about internals. You'll also learn how to use Tachyon to find the slow parts of your code. Flamegraphs, heatmaps, async-aware profiling, GIL contention analysis, bytecode level profiling... By the end you'll know which output format to pick, which profiling mode fits your problem, and how to go from ""my server is slow"" to ""here's the line that's killing us."" Whether you're interested in the systems programming that makes this work, or you just want a better way to debug performance problems, this talk has something for you.",2026-05-16 15:15:00
67,The art of live process manipulation with Python 3.14's zero-overhead debugging interface,/2026/schedule/presentation/67/,"Saturday, May 16th, 2026",3:15p.m.-3:45p.m.,Grand Ballroom B,Savannah Ostrowski,"Have you ever needed to debug a live Python process but couldn't restart it? Didn't want to redeploy with debug flags or manage sidecar containers just to debug your application? In this talk, I'll show you why sys.remote_exec() is one of the coolest features of Python 3.14! I'll cover the basics of Python's new remote debugging capabilities and demonstrate how sys.remote_exec() can be combined with debugpy (an implementation of the Debug Adapter Protocol) to provide full IDE debugging experiences for live processes. I'll share what I learned building a tool that uses these primitives to attach debuggers to FastAPI applications running in local Kubernetes clusters. Beyond debugging, we'll explore other use cases for sys.remote_exec() and how you can apply the feature to solve problems in your own work!",2026-05-16 15:15:00
104,Post-Incident Runtime SBOM Generation from Python Memory,/2026/schedule/presentation/104/,"Saturday, May 16th, 2026",3:15p.m.-3:45p.m.,Room 103ABC,Hala Ali,"Most SBOM tools report what they find in metadata files or what is installed on the system, not what the Python application actually executes. Python's flexible import mechanism allows modules to load dynamically at runtime, so the dependencies an application uses can differ from what metadata files or package managers tell. Runtime SBOM tools are designed to capture components as they load, but they need the system to stay live and observable. In real incidents, systems may crash, become corrupted, or end up completely inaccessible because of malicious dependencies or destructive actions like ransomware. When this happens, memory becomes the only reliable source of what was actually running. This talk introduces the first approach that generates SBOMs directly from the in-memory runtime state of Python applications. This approach traverses the interpreter’s module registries, garbage-collector lists, memory arenas, and heap objects to recover all loaded modules, including ones attackers try to hide, group them into packages, resolve their versions using in-memory attributes, and output a CycloneDX-compliant SBOM. It also constructs dependency relationships and identifies which code paths were exploitable at runtime. Across 51 real-world Python applications (web frameworks, CLI tools, ML platforms, schedulers, and visualization tools), we found significant mismatches between what SBOM tools report and what the memory reveals. In a case study involving the Tornado package, we found that only Streamlit v1.40.1 out of six dependent applications invokes the vulnerable routines, reducing false-positive CVE noise by 80.3%. Through this talk, attendees will learn why we need SBOMs, why existing tools misreport Python dependencies, how Python internals appear in memory, and why recovering the runtime state of a Python application from memory is critical for supply chain security.",2026-05-16 15:15:00
103,The Terminal is the New Browser: Building Rich TUIs with Textual,/2026/schedule/presentation/103/,"Saturday, May 16th, 2026",3:15p.m.-3:45p.m.,Room 104AB,Andres Pineda,"Do you think the terminal is only for plain white text on a black screen? It's time to reconsider. Thanks to 'Terminal User Interfaces' (TUIs), we can now create apps with CSS-like styles, interactive components, and mouse support, all inside the terminal. In this talk, we'll take a closer look at Textual, a fast development framework for Python. You'll see how its CSS engine helps you design great layouts, how its message-passing system keeps your UI fast, and why a TUI could be a smarter pick for your next DevOps tool or data dashboard than a web app. Join us to see how you can make the command line more appealing than ever.",2026-05-16 15:15:00
17,Construye aplicaciones web interactivas con Python: Streamlit y Supabase en acción,/2026/schedule/presentation/17/,"Saturday, May 16th, 2026",3:15p.m.-3:45p.m.,Room 104C,Nicolas Emir Mejia Agreda,"Esta charla demuestra cómo desarrollar aplicaciones web interactivas completas usando Python, Streamlit y Supabase, sin necesidad de conocimientos avanzados de frontend o infraestructura. ¿Qué aprenderás? Los asistentes descubrirán cómo: - Crear interfaces de usuario interactivas en minutos con Streamlit - Conectar aplicaciones Python a Supabase para gestión de datos en tiempo real - Implementar autenticación de usuarios y manejo de sesiones - Desplegar aplicaciones completas de forma gratuita o con bajo costo Contenido de la charla Introducción (5 min): Por qué Streamlit y Supabase son ideales para MVPs y prototipos rápidos con Python. Integración práctica (15 min): Demostración paso a paso de una aplicación funcional que incluye: - Conexión a base de datos PostgreSQL vía Supabase - Operaciones CRUD en tiempo real - Visualización de datos con componentes interactivos - Manejo de estado y caché en Streamlit Buenas prácticas (7 min): Gestión de secrets, optimización de queries, estructura de proyecto recomendada y consideraciones de seguridad. Cierre y Q&A (3 min): Recursos adicionales y cuándo elegir esta stack sobre alternativas. ¿Para quién es esta charla? Desarrolladores Python que buscan crear aplicaciones web rápidamente, equipos que necesitan prototipar ideas sin configurar servidores complejos, y cualquier persona interesada en desarrollo full-stack moderno con Python. Al finalizar, los asistentes tendrán el conocimiento para construir y desplegar sus propias aplicaciones web interactivas usando estas herramientas modernas del ecosistema Python.",2026-05-16 15:15:00
72,Making Python Faster with Free Threading and Mypyc,/2026/schedule/presentation/72/,"Saturday, May 16th, 2026",4:15p.m.-4:45p.m.,Grand Ballroom A,Jukka Lehtosalo,"It’s common to hear complaints about Python being slow. In this talk, I will show how to make some Python programs dramatically faster by using Python 3.14’s free threading and ahead-of-time compilation to C extensions using mypyc. Free threading can deliver large speedups for CPU-bound code that can be adapted for parallel execution, while mypyc speeds up workloads that benefit from reduced interpreter overhead and that use strict static typing. If each can give a 10× speedup in an ideal use case, do we get a “holy grail” 100× improvement by combining them? I’ll walk through several small, readable examples distilled from real-world workloads, measuring and explaining what changes when you apply free threading, mypyc, or both. In practice, relatively few programs are excellent fits for both techniques at once, but when they are, you can see substantial gains. Having both tools available gives you more options for attacking performance problems, while staying entirely in Python (and CPython). Along the way, I’ll cover common bottlenecks that limit performance scaling and how to diagnose them, including allocation-heavy code and thread contention driven by reference counting.",2026-05-16 16:15:00
73,Getting Started with Celery: Building Your First Background Task System in Python,/2026/schedule/presentation/73/,"Saturday, May 16th, 2026",4:15p.m.-4:45p.m.,Grand Ballroom B,Italo Carvalho Vianelli Ribeiro,"Slow, CPU-intensive work such as image resizing can easily block Python applications when handled synchronously. Background task processing provides a way to offload this kind of work, keeping applications responsive while expensive operations run elsewhere. Celery is a widely used solution in the Python ecosystem for coordinating this work through distributed task queues. Using image processing as a concrete example, we will walk through setting up a minimal Celery application that generates thumbnails and resized images in the background. Along the way, it introduces message brokers in practical terms and shows how tasks flow from the application to worker processes without blocking the main program.",2026-05-16 16:15:00
117,GitHub Actions Security in Python Packages,/2026/schedule/presentation/117/,"Saturday, May 16th, 2026",4:15p.m.-4:45p.m.,Room 103ABC,Andrew Nesbitt,"GitHub Actions is the dominant CI system for Python open source, used for testing and publishing including trusted publishing to PyPI via OIDC. That means the security properties of Actions directly affect the Python supply chain. But Actions is a package manager without the security features we expect from package managers: no lockfiles, mutable version tags, implicit transitive dependencies. Prior research shows 97% of workflows use actions from unverified creators. If a workflow can be compromised before the package is signed, downstream protections don't help. I scanned GitHub Actions workflows across thousands of Python packages on PyPI using zizmor, a static analysis tool for Actions security. I found unpinned third-party actions, overly permissive GITHUB_TOKEN scopes, artifact poisoning risks, and pull request vulnerabilities that could let attackers hijack releases. This talk presents findings at ecosystem scale and explores what the Python community can learn from how we've solved similar problems in pip. What we'll cover: Why GitHub Actions is a supply chain risk What's missing compared to pip, npm, and other package managers Findings from scanning Python package workflows at scale What we can learn from pip's security model A checklist for hardening Python package release workflows How to integrate zizmor into CI pipelines",2026-05-16 16:15:00
5,Thinking of Topic Modeling as Search,/2026/schedule/presentation/5/,"Saturday, May 16th, 2026",4:15p.m.-4:45p.m.,Room 104AB,Kas Stohr,"Typically, when considering using a topic model in production, you encounter two hurdles: First, topics change continually, and document tags become stale as soon as they are created. Second, while unsupervised topic models do a good job of clustering topics, creating robust, human-interpretable labels is challenging. Framing topic modeling as a search problem, helps overcome these challenges and makes it easier to use supervised or unsupervised topic models in real-time applications. Python packages and extensions to commonly used databases that now support dense vectors, have made this approach viable —and relatively easy to implement— in most production environments. In this talk, attendees will learn how to repurpose embeddings generated by a topic model as dense vectors that can be used in search to find current documents similar to the topic. Key concepts Embeddings - quick introduction (or refresher, for those familiar) How to convert sentence embeddings into document embeddings and ultimately topic embeddings. How to generate topic embeddings (using LLMs, supervised models or unsupervised models) How to store topic embeddings on popular databases to enable search How to retrieve current documents related to a topic using search queries and cosine similarity — without tagging documents. Benefits of this approach Simplify and improve performance for storing and retrieving documents related to a topic Capture fast-moving, evolving conversations Allow user-generated topics (personalization) Anticipate topics that don’t yet exist No need to maintain document ""tags"" Audience Intermediate Python developers interested in NLP and search technologies Practitioners building search, recommendation, or semantic discovery systems Anyone curious about combining classic topic modeling with modern vector search architectures No prior experience with vector search is required. Familiarity with Python and basic NLP concepts is helpful.",2026-05-16 16:15:00
50,El Agent que Convirtió el Caos de On-Call en un Solo Slack Thread,/2026/schedule/presentation/50/,"Saturday, May 16th, 2026",4:15p.m.-4:45p.m.,Room 104C,Angelik Laboy Torres,"¿Y si lo próximo que automatizas no fuera tu infraestructura, sino el caos de estar on-call? Mientras Datadog constantemente está estimando métricas en el background y AWS sigue generando servidores como respuesta, el ingeniero tiene que manejar diez tabs - PagerDuty alertando, Slack explotao' y los dashboards subiendo lentamente - solo para tratar de entender qué se rompió y por qué! En esta sección vamos a enseñarles cómo crear un Agent que responde a incidentes para poder calmar la marea. Usando Retool Agents con custom Python tools, el agente unifica a Datadog, PagerDuty, CloudWatch, Slack y Linear en un solo workflow haciendo que las alertas empiecen a tener contexto y el contexto se convierta en acciones, todo dentro de un Slack thread. Van a ver un Agente que: - Relaciona alertas, métricas y eventos de AWS en un solo timeline de incidentes - Sugiere probables causas utilizando análisis lightweight de Python - Manda updates accionables en Slack con botones para resolver con un solo click - Sincroniza los resultados del incidente en Linear para mantener un follow-up limpio y postmortems En general, vamos a disectar cómo funciona y trabaja este Agente explorando múltiples escenarios con incidentes en vivo durante la sección. Todo con la finalidad de aprender cómo convertir este proceso disperso en uno organizado y colaborativo.",2026-05-16 16:15:00
120,High-Performance LLM Inference in Pure Python with PyTorch Custom Ops,/2026/schedule/presentation/120/,"Saturday, May 16th, 2026",5p.m.-5:30p.m.,Grand Ballroom A,Yineng Zhang,"This talk presents how a modern large language model (LLM) inference engine written entirely in Python can reach performance comparable to C++-based systems such as TensorRT-LLM. Based on experience maintaining SGLang—an open-source pure-Python inference engine, this session explains the design principles behind choosing a Python-first architecture and how it achieves high throughput and low latency in real deployments. The core idea is that Python, supported by the evolving PyTorch runtime stack, can serve not only as orchestration code but as the foundation of a performant inference system. Three components make this possible: a multi-process scheduling framework for parallelism, a zero-overhead batch scheduler that hides CPU overhead behind GPU execution, and a set of high-performance PyTorch custom ops implemented directly in Python. Together, they keep GPUs fully utilized while maintaining a clean and flexible Python development experience. This talk will cover: Why a pure-Python architecture can match C++ inference engines The key design principles behind multi-process runtime scheduling How zero-overhead batch scheduling improves utilization and reduces latency The role of PyTorch custom ops in high-performance serving Insights and practical lessons learned from scaling a Python LLM engine Attendees will gain a clear understanding of how Python can power high-performance LLM workloads and how these ideas can be applied to their own systems—without requiring C++ or CUDA expertise.",2026-05-16 17:00:00
141,Upgrading Python CLIs: From Scripts to Interactive Tools,/2026/schedule/presentation/141/,"Saturday, May 16th, 2026",5p.m.-5:30p.m.,Grand Ballroom B,Avik Basu,"Audience This talk is for Python developers at any level. We will use ML workflows as our running example, but the patterns apply to any CLI application. Objective Attendees will learn how to progressively enhance command-line tools. Through a concrete example that evolves throughout the talk, they will see when and how to apply each library to improve usability, interactivity, and maintainability. By building better CLI experiences, attendees will be encouraged to use terminals more in their own workflows. Details Well designed CLI tools are powerful, fast and it makes it very appealing to work with. But more than that, great TUIs can make the command line approachable, and even enjoyable, helping more people embrace terminal-based workflows. We will build a CLI tool from scratch, starting with basic argparse and print statements, then progressively enhance it through three stages. First, we'll use Typer to replace verbose argparse code with clean, type-safe configuration management. Next, we'll add Rich for progress bars, tables, and styled output. Lastly, we will introduce some interactive elements with Textual, e.g. dashboards, filtering, and real-time updates. Finally we will conclude by discussing when each enhancement is worthwhile, different testing strategies, and some production considerations.",2026-05-16 17:00:00
79,Breaking Bad (Packages): Why Traditional Vulnerability Tracking Fails Supply Chain Attacks,/2026/schedule/presentation/79/,"Saturday, May 16th, 2026",5p.m.-5:30p.m.,Room 103ABC,Shelby Cunningham,"2025 was a year of attention-grabbing malware campaigns targeting the open-source supply chain. From a campaign that affected a single package (tj-actions/changed-files) to massive supply chain compromises like the Shai-Hulud attacks against npm, vulnerability management teams need ways to keep track of compromised packages that provides accurate information in a timely fashion. PyPI, as a package manager with hundreds of thousands of legitimate packages, is also a tempting target for those threat actors who seek to invade the machines and organizations of the world’s Python developers. While CVE rules prohibit use for tracking general-purpose malicious code, it does allow assigning a CVE ID to a legitimate package infected with malware. We will explore how modern vulnerability and malware management addresses the unique situations when malicious actors replace or augment legitimate open source software with malware to cause widespread harm. There are existing vulnerability notification pipelines that commonly rely on CVE identifiers, but the CVE Program wasn’t intended to support open source malware tracking. Given the complexities that arise from transitive dependency vulnerabilities when there are malicious takeovers of packages, this raises a question: what is the best way to track malicious supply chain compromises?",2026-05-16 17:00:00
136,When KPIs Go Weird: Anomaly Detection with Python,/2026/schedule/presentation/136/,"Saturday, May 16th, 2026",5p.m.-5:30p.m.,Room 104AB,Juliana Ferreira Alves,"In many teams, KPIs are everywhere, but understanding when something is actually wrong is still a challenge. In People Analytics, for example, a sudden change in turnover, engagement, or role movement may point to a real problem, or it may simply reflect normal variation in noisy, human-centered data. In this talk, I will walk through how to detect anomalies in KPIs using Python, drawing from practical experience working with real organizational metrics. We will start by building a clear intuition around what data anomalies are, and what they are not, and why simple rules or fixed thresholds often fail when metrics exhibit seasonality, trends, and structural changes. From there, we will explore statistical, time-series, and machine learning approaches to anomaly detection, with concrete Python examples using libraries such as pandas, scikit-learn, and PyOD. I will show how these techniques can be applied to People Analytics metrics like employee turnover, engagement trends, and role rotation, and how the same challenges appear across many other business KPIs. In some cases, I will also show how generative models can be used to support anomaly detection workflows, especially for summarizing patterns, providing context, and helping humans interpret unusual behavior in metrics. The focus of this talk, however, remains on practical decision-making. We will discuss how to choose the right method for your data, how to evaluate whether an anomaly is meaningful, and how to design monitoring that supports human interpretation instead of creating alert fatigue. Attendees will leave with a solid mental model for anomaly detection, reusable Python patterns, and a clearer understanding of how to apply these techniques to their own metrics.",2026-05-16 17:00:00
29,Python a la velocidad de la luz: Un recorrido completo por el ecosistema de CUDA,/2026/schedule/presentation/29/,"Saturday, May 16th, 2026",5p.m.-5:30p.m.,Room 104C,Daniel Rodriguez,"Esta charla presentará una visión completa del ecosistema CUDA Python, mostrando cómo Python tiene soporte de primera clase para programar GPUs de NVIDIA desde el runtime de bajo nivel hasta DSLs de alto nivel. Iremos más allá de simplemente usar PyTorch para entrenar modelos de machine learning y exploraremos las diferentes capas del stack de CUDA entendiendo cuándo usar cada una para sacar el máximo provecho a una GPUs. Ideal para científicos, ingenieros de datos, desarrolladores de ML, y cualquier pythonista que quiera aprovechar GPUs sin necesidad de aprender C++. Exploraremos cómo migrar código NumPy a CuPy y cómo acelerar bibliotecas de ciencias de datos como Pandas y Polars con RAPIDS para mover cargas de trabajo de CPU a la GPU. También veremos cómo escalar código en NumPy de tu computador personal a un supercomputador. Para quienes buscan control total, exploraremos CUDA Core para programar kernels de GPU directamente desde Python, y CCCL para hacer esta programación más accesible. Conocerás nvmath-python, que te da acceso muchas bibliotecas optimizadas de CUDA-X con compilación just-in-time y fusión de kernels automática. También presentaremos un nuevo modelo de programación: cuTile. Este te permite escribir código para tensor cores usando sintaxis NumPy familiar, alcanzando rendimiento pico sin complejidad. cuTile abstrae los detalles del hardware especializado (Tensor Cores) y te permite enfocarte en tu algoritmo especificando operaciones sobre bloques de datos (tiles) en lugar de programar elemento por elemento. Es el mayor avance en CUDA desde 2006, haciendo que la programación de tensor cores sea tan natural como usar NumPy. Verás casos de uso reales y saldrás con recursos prácticos para empezar a acelerar tu código hoy mismo.",2026-05-16 17:00:00
125,A bridge over (not) troubled waters: Collecting marine data from your couch,/2026/schedule/presentation/125/,"Sunday, May 17th, 2026",1p.m.-1:30p.m.,Grand Ballroom A,Sarah Kaiser,"Do you ever have a weird feeling that something around you is off? I certainly do, and one recurring thought I have is that the vintage boat I'm helping restore has sunk. I decided to use the tools available to me to put my mind at ease: software, a soldering iron, and stubbornness. My crewmate and I have built a way to get live data from our boat while on the couch at home at 3 am :) Data is a great way to reduce anxiety, and in this case has also generated a rising tide of interest in marine tech infrastructure. In this talk, we will give you a tour the cool Python and OSS tools we have discovered for collecting telemetry on boats, a specialized marine data collection platform (Signal K), and an MQTT bridge to bring it all into our smart home dashboards on Home Assistant.",2026-05-17 13:00:00
55,Brains and Explosions: A Simple VDB Writer for Python,/2026/schedule/presentation/55/,"Sunday, May 17th, 2026",1p.m.-1:30p.m.,Grand Ballroom B,Joachim Pfefferkorn,"VDB is a volumetric data format. Commonly used in films and video-games, it is also great for rendering scientific data. However, the current open source standard is poorly documented, requires a docker container to run, and contains a ton of code that is unneeded outside of niche graphics applications. As a result, many scientific visualization artists must rely on closed-source commercial software: leading to citation and reproducibility issues. To solve these problems, I built Neurovolume: a low-dependency, Python library for writing VDBs. This talk spans Zig/Python interoperability, satellite data, big spinning magnets, dead salmon, and Blender plugins.",2026-05-17 13:00:00
127,Learning Computer Science with Python and Music(21),/2026/schedule/presentation/127/,"Sunday, May 17th, 2026",1p.m.-1:30p.m.,Room 103ABC,Michael Scott Asato Cuthbert,"Courses mixing computation and the arts or humanities are usually marketed as “applied.” Students take what they learn in computer science and use it to discover something new about music, literature, or history. But what if the application actually happens in reverse? What if taking a Python-based music class teaches and reinforces fundamental computation and CS skills? For over a decade, I taught just such a course using the open-source Python toolkit music21. Students wrote Python code to compose their own pieces and to study music ranging from Bach to today’s pop. (And, of course, part of this talk will show how you can too!) Python’s ease of use and its ecosystem of interactive tools, including Jupyter, make it possible to hear music and see musical notes immediately, turning code and choices of algorithms into results students can understand and revise on the spot. Solving musical problems such as building chords or locating key changes gives life and meaning to abstract concepts such as breadth-first search and divide-and-conquer strategies. Composition and coding with recursion become two sides of the same coin. Ideas that once felt abstract or fuzzy become concrete and experienced. By sharing how Python and music, including music21, can create reusable classroom patterns, this talk will give teachers and learners, including self-learners in any area, the confidence and skill to use applied Python projects as paths to a deeper understanding of algorithms and computer science.",2026-05-17 13:00:00
32,From notebooks to scripts: turning one-off analysis into reusable Python code,/2026/schedule/presentation/32/,"Sunday, May 17th, 2026",1p.m.-1:30p.m.,Room 104AB,Rafael Mendes de Jesus,"This talk is about a problem many Python users run into without noticing: analysis that works once, lives in a notebook, and never really becomes reusable. I’ll walk through how a simple exploratory notebook can slowly turn into something fragile, hard to rerun, hard to share, and hard to maintain, and what to do about it without overengineering. The focus is not on “best practices at scale” or complex project structures. It’s about small, practical steps: when a notebook is enough, when it stops being enough, and how to move from cells to scripts in a way that still feels lightweight. Using a real example, I’ll show how to extract logic from a notebook, turn it into simple functions, organize files just enough, and keep the workflow readable and flexible. The goal is to help people make their Python work easier to reuse, rerun, and trust, without turning analysis into a software project.",2026-05-17 13:00:00
108,Running Every Street in Paris with Python and PostGIS,/2026/schedule/presentation/108/,"Sunday, May 17th, 2026",1:45p.m.-2:15p.m.,Grand Ballroom A,Vinayak Mehta,"In 2006, Tom Murphy started a project of running every street in Pittsburgh (over 1,500 miles in total). He finished the project in 2022, covering 3661 miles in 269 runs. In this talk, we'll look at how we can do the same in our cities and track our progress, with Paris as an example. We'll explore how to extract street networks from OpenStreetMap, process GPS tracking data from running activities, and build a system to track progress toward covering every street in a city. We'll dive into challenges like handling GPS inaccuracies, matching runs to streets, and maintaining a database of covered streets. This talk is aimed at Python developers interested in working with geospatial data using Python libraries like osmnx, shapely, geopandas, and storing it for efficient querying in Postgres and PostGIS.",2026-05-17 13:45:00
42,"Memory management in CPython, fast or slow?",/2026/schedule/presentation/42/,"Sunday, May 17th, 2026",1:45p.m.-2:15p.m.,Grand Ballroom B,Mark Shannon,"When considering Python performance, memory management often gets less attention than features like free-threading or the JIT compiler. Yet, roughly a third of the runtime of a typical Python program is spent performing memory management. Understanding how CPython allocates, tracks, and frees memory is important for understanding Python performance. Most Python developers know that CPython uses reference counting to determine when objects can be freed. But that’s only one part of a much more intricate system. Behind the scenes, CPython must also: Allocate memory for new objects quickly and efficiently Return freed memory back to the system or to internal allocators for reuse Detect and collect cyclic references, which reference counting alone cannot handle; CPython includes a dedicated cycle detector to ensure these objects are eventually freed In this talk, I will: Trace the lifetime of a Python object through the lens of memory management Examine the time and space costs associated with each component of memory management Highlight improvements made in recent CPython releases, and discuss future opportunities to further reduce these costs",2026-05-17 13:45:00
132,Leading Without Permission: Building Digital Diaspora as an Afro-Latina Woman in Tech,/2026/schedule/presentation/132/,"Sunday, May 17th, 2026",1:45p.m.-2:15p.m.,Room 103ABC,Veronica Rodriguez Viveros,"Digital Diaspora began as a response to a simple but persistent question: why do so many talented Afro-descendant technologists remain invisible in the global tech ecosystem? In this talk, I share the story of how Digital Diaspora was built from the ground up in Colombia, without institutional backing, funding, or proximity to traditional tech power centers. As an Afro-Latina woman working in global technology, I will explore what it means to lead without permission, build credibility outside dominant narratives, and create community as a form of infrastructure. The session reflects on the challenges of leadership at the intersection of identity, geography, and technology, and how open source values, Python communities, and intentional design helped transform an idea into a sustained and growing network. Rather than focusing on success stories alone, the talk highlights real lessons learned, mistakes made, and the strategies that allowed the community to grow while staying rooted in purpose. This talk is for anyone interested in community building, inclusive leadership, and how meaningful tech ecosystems can emerge from the Global South.",2026-05-17 13:45:00
88,"Why you, as a Python developer, should learn Rust",/2026/schedule/presentation/88/,"Sunday, May 17th, 2026",1:45p.m.-2:15p.m.,Room 104AB,Daniel Szoke,"In this talk, I will introduce the Rust programming language from a Python developer’s perspective. We will explore some of Rust’s main advantages as a language: its safety guarantees and excellent tooling. Some of the safety guarantees we will explore include null safety, explicit mutability, and the ownership and borrowing system. I will also go over how the language’s tooling, including the compiler, linter, and formatter, can help developers learn the language and enforce consistent patterns in their codebases. We will tie all of this information back to the Python language by discussing the main philosophical differences between Rust and Python. I will argue that learning Rust is beneficial to Python developers, even if they never plan to write Rust, as the concepts they learn while learning Rust will also help them write better Python code. Attendees should come away from the talk with motivation to learn Rust, or at least to play around with the language a little bit.",2026-05-17 13:45:00
96,A Shiny for Python Cultural Survival Tool: Training Your Slang Translator,/2026/schedule/presentation/96/,"Friday, May 15th, 2026",2:45p.m.-3:15p.m.,Room 103ABC,Elizabeth Black,"Bà ngoại(grandmother) is a slang translation App that I have built in Shiny for Python and have trained it in Vietnamese. It has a reactive UI that quickly delivers the Vietnamese slang equivalent. Instead of a literal translation, it identifies meaning, tone, and even risk level using TF-IDF and cosine similarity all while blending humor and machine learning to help users understand slang in context. Users who need a quick slang phrase, will type a phrase in the reactive UI and Bà ngoại returns the closest slang match with explanations all through a friendly and reactive Shiny for Python interface. It's fun, educational look at the generational slang language, culture, and computational linguistics, but you can train it to be your abuela, your grand-mère or even your grandma. Your grandma of choice wants you to survive the cultural and generational slang gap unscathed.",2026-05-15 14:45:00
98,Taking Iterators Too Far: Writing a PDF from Scratch in Python,/2026/schedule/presentation/98/,"Sunday, May 17th, 2026",2:30p.m.-3p.m.,Grand Ballroom B,Arie Bovenberg,"PDFs are everywhere, but the file format itself feels like a black box. What better way to demystify it than to write a PDF writer from scratch? Here's the twist: we'll use iterators all the way down—streaming every byte without ever assembling the full document in memory. At first, this seems like a natural fit. But PDFs fight back: forward references, cross-reference tables, and content lengths that need to be known before the content exists. Each of these challenges forces us to discover a new way to keep things lazy. This talk walks through the problem-solving journey step by step. You'll pick up practical iterator techniques—composing generators, managing dependencies in lazy pipelines, and knowing when ""too far"" is actually just far enough—all while building something real. You'll also walk away with a surprising appreciation for what's inside every PDF you've ever opened.",2026-05-17 14:30:00
82,Fall In Love With CSS,/2026/schedule/presentation/82/,"Sunday, May 17th, 2026",2:30p.m.-3p.m.,Room 103ABC,Piper Thunstrom,"CSS is an ancillary technology for many software developers, similar to other declarative languages used for specific tasks. Historically there's been a deep mistrust of the language, embedded in jokes and so many projects that try to remove the need to write any CSS. Let me show you how to think about CSS. We'll cover the concepts, talk about the cascade, and show off some of the best features of modern CSS. Spoilers: Variables (custom properties) nested styles (CSS nesting) Two! Great layout tools (CSS grid and flexbox)",2026-05-17 14:30:00
47,Understanding Python's logging: Combine components like Lego blocks!,/2026/schedule/presentation/47/,"Sunday, May 17th, 2026",2:30p.m.-3p.m.,Room 104AB,nikkie,"Abstract Are you using Python's standard logging module? I am, but I found it challenging to understand. It seems this module is difficult not just for me, but for the entire Python community. After exploring several popular libraries released post-ChatGPT, I noticed they all had room for improvement in their logging implementations. In production, I want to log everything to understand my application's behavior thoroughly, but many libraries have idiosyncratic logging that requires hacks from the library user's side... Real-world logging can be quite frustrating! From these experiences, I've become confident in teaching Python logging essentials. To help others avoid my struggles, I'll share the fundamental pattern of Python logging. Since logging is non-functional, it often gets less attention than feature implementation. I hope this talk and materials can provide one solid pattern for combining logging module components (though you're free to choose not to adopt it after understanding it!). Message The logging module contains various elements: Logger, Handler, Formatter, and Filter. I'll demonstrate one pattern for combining these components: Logging implementation in libraries (imported code): - Use Logger (+ NullHandler) Logging implementation in applications (code that imports libraries): - Attach Handler to the root logger - Attach Formatter to the Handler - Set Filter and log levels on the Handler Target Audience Prerequisite: Experience implementing logging in Python Experience with the logging module is not required Perfect for those thinking ""I don't quite understand the logging module..."" Takeaways Understand components like Logger and Handler Understand how to combine components for logging ""Simple"" doesn't mean easy—it means combining simple things to build complex systems (like Lego blocks)",2026-05-17 14:30:00
'''
talks = lt.csv_import(talks_csv)

talks.create_search_index("tags", using="description title speaker")

def search(search_terms: str) -> None:
    results = talks.search.tags(search_terms)

    if results:
        results.orderby("scheduled_datetime")
        results.select("title speaker date time room").present(caption=f"{len(results)} talk{'s' * (len(results) != 1)} found", caption_justify="left")
    else:
        print(f"no matching talks found for {search_terms!r}")
    print()

# REPL
while True:
    terms = input("Search: ")
    if terms.lower() == "/quit":
        break
    search(terms)

good

good

Added a couple of minor tweaks - results are sorted in scheduled time order. Easier to use to create your own custom track (on "ai" for example). Also, changed the exit command to "/quit", since "quit" should actually be a valid search term (and in fact, matches one of the talks!).