diff --git a/pycon-us-2026/category.json b/pycon-us-2026/category.json new file mode 100644 index 000000000..2a4d98ec8 --- /dev/null +++ b/pycon-us-2026/category.json @@ -0,0 +1,3 @@ +{ + "title": "PyCon US 2026" +} diff --git a/pycon-us-2026/videos/2026-python-steering-council-panel.json b/pycon-us-2026/videos/2026-python-steering-council-panel.json new file mode 100644 index 000000000..c49612cf6 --- /dev/null +++ b/pycon-us-2026/videos/2026-python-steering-council-panel.json @@ -0,0 +1,27 @@ +{ + "description": "The Python Steering Council is a 5-person elected committee that assumes a mandate to maintain the quality and stability of the Python language and CPython interpreter, improve the contributor experience, formalize and maintain a relationship between the Python core team and the PSF, establish decision making processes for Python Enhancement Proposals, seek consensus among contributors and the Python core team, and resolve decisions and disputes in decision making among the language.\n\nPresented by: Barry Warsaw, Donghee Na, Pablo Galindo Salgado, Savannah Ostrowski, Thomas Wouters", + "duration": 1882, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + } + ], + "speakers": [ + "Barry Warsaw", + "Donghee Na", + "Pablo Galindo Salgado", + "Savannah Ostrowski", + "Thomas Wouters" + ], + "thumbnail_url": "https://i.ytimg.com/vi/arE9g0uMDq4/hqdefault.jpg", + "title": "2026 Python Steering Council Panel", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=arE9g0uMDq4" + } + ] +} diff --git a/pycon-us-2026/videos/a-bridge-over-not-troubled-waters-collecting-marine-data-from-your-couch.json b/pycon-us-2026/videos/a-bridge-over-not-troubled-waters-collecting-marine-data-from-your-couch.json new file mode 100644 index 000000000..78311265f --- /dev/null +++ b/pycon-us-2026/videos/a-bridge-over-not-troubled-waters-collecting-marine-data-from-your-couch.json @@ -0,0 +1,27 @@ +{ + "description": "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.", + "duration": 1830, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/125/" + } + ], + "speakers": [ + "Sarah Kaiser" + ], + "thumbnail_url": "https://i.ytimg.com/vi/5QQKRTlau4Y/hqdefault.jpg", + "title": "A bridge over (not) troubled waters: Collecting marine data from your couch", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=5QQKRTlau4Y" + } + ] +} diff --git a/pycon-us-2026/videos/ai-assisted-contributions-and-maintainer-load.json b/pycon-us-2026/videos/ai-assisted-contributions-and-maintainer-load.json new file mode 100644 index 000000000..3fb53c1b9 --- /dev/null +++ b/pycon-us-2026/videos/ai-assisted-contributions-and-maintainer-load.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nThis 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.\n\nThe 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.\n\nThe 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.\n\nRather 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.", + "duration": 1864, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/105/" + } + ], + "speakers": [ + "Paolo Melchiorre" + ], + "thumbnail_url": "https://i.ytimg.com/vi/EKayPgbD6J0/hqdefault.jpg", + "title": "AI-Assisted Contributions and Maintainer Load", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=EKayPgbD6J0" + } + ] +} diff --git a/pycon-us-2026/videos/anatomy-of-a-phishing-campaign.json b/pycon-us-2026/videos/anatomy-of-a-phishing-campaign.json new file mode 100644 index 000000000..3ac5de433 --- /dev/null +++ b/pycon-us-2026/videos/anatomy-of-a-phishing-campaign.json @@ -0,0 +1,27 @@ +{ + "description": "In July 2025, PyPI users received emails directing them to pypj.org\u2014a near-perfect clone transparently proxying requests to pypi.org. Within hours, attackers compromised four accounts and uploaded malicious releases of the popular num2words package.\n\nThis talk dissects the complete attack chain: how attackers harvested email addresses from public package metadata, built a transparent proxy that relayed TOTP codes in real-time, and why traditional 2FA failed while WebAuthn-based authentication stopped the attack cold.\n\nThe session covers the incident response timeline, challenges getting malicious infrastructure taken down (including initial rejection of abuse reports), and defensive measures deployed afterward\u2014including new email verification for TOTP logins from unrecognized devices.\n\nAttendees will learn exactly how modern phishing attacks work against package repositories, the critical difference between \"phishable\" and \"phishing-resistant\" 2FA, and practical steps to protect accounts and packages from the next campaign. The talk also examines the September 2025 follow-up campaign targeting pypi-mirror.org and patterns across these ongoing attacks.", + "duration": 1845, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/74/" + } + ], + "speakers": [ + "Mike Fiedler" + ], + "thumbnail_url": "https://i.ytimg.com/vi/uXW1qeUS6Yw/hqdefault.jpg", + "title": "Anatomy of a Phishing Campaign", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=uXW1qeUS6Yw" + } + ] +} diff --git a/pycon-us-2026/videos/asegurando-y-protegiendo-aplicaciones-python-con-open-keycloak.json b/pycon-us-2026/videos/asegurando-y-protegiendo-aplicaciones-python-con-open-keycloak.json new file mode 100644 index 000000000..eecd664d9 --- /dev/null +++ b/pycon-us-2026/videos/asegurando-y-protegiendo-aplicaciones-python-con-open-keycloak.json @@ -0,0 +1,26 @@ +{ + "description": "#### Contexto\nActualmente se est\u00e1n desarrollando un sin fin de aplicaciones web basadas en Python con frameworks y librer\u00edas como Django y Flask, o gestores de contenido y herramientas para aplicaciones interactivas como Wagtail y Streamlit, incluso backends con FastAPI. \u00bfPero c\u00f3mo podemos proteger, con mecanismos de autorizaci\u00f3n y autenticaci\u00f3n (hasta MFA), estas aplicaciones y sistemas desarrollados con Python?\n\n#### Propuesta\nLa popularidad del gestor de accesos e identidades Open Keycloak aumenta m\u00e1s y m\u00e1s en la comunidad, incluso Red Hat lo adopt\u00f3 para la plataforma de infraestructura que ofrece comercialmente. Se trata de una soluci\u00f3n muy potente que permite asegurar cualquier tipo de aplicaci\u00f3n, incluso aplicaciones Python. \u00bfPor qu\u00e9 no blindar y robustecer nuestras aplicaciones desarrolladas en Python con un Single Sign-On como Open Keycloak? Conozcamos c\u00f3mo asegurar de mejor forma nuestras aplicaciones Python con esta gran herramienta, un proyecto soportado y mantenido por la CNCF.\n\n#### \u00bfQu\u00e9 aprender\u00e1s?\nEn esta charla abordaremos qu\u00e9 es Open Keycloak, c\u00f3mo funciona, y algunos de los enfoques m\u00e1s pr\u00e1cticos para integrarlo con aplicaciones desarrolladas en nuestro lenguaje favorito: Python. Incluye demo en AWS.\n\n#### \u00bfPara qui\u00e9n es?\nCualquier persona que est\u00e9 desarrollando e implementado aplicaciones Python y tenga inter\u00e9s en entender c\u00f3mo funcionan las soluciones de Single Sign-On que proveen autenticaci\u00f3n y autorizaci\u00f3n a aplicaciones que utilizan protocolos como OpenID Connect, OAuth 2.0, y SAML.", + "duration": 989, + "language": "spa", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + } + ], + "speakers": [ + "Samuel Palacios" + ], + "tags": [ + "charla" + ], + "thumbnail_url": "https://i.ytimg.com/vi/BYzqLBkqDaw/hqdefault.jpg", + "title": "Asegurando y Protegiendo Aplicaciones Python con Open Keycloak", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=BYzqLBkqDaw" + } + ] +} diff --git a/pycon-us-2026/videos/asleep-at-the-wheel-getting-your-sboms-to-pay-attention-to-python-builds.json b/pycon-us-2026/videos/asleep-at-the-wheel-getting-your-sboms-to-pay-attention-to-python-builds.json new file mode 100644 index 000000000..4758567c7 --- /dev/null +++ b/pycon-us-2026/videos/asleep-at-the-wheel-getting-your-sboms-to-pay-attention-to-python-builds.json @@ -0,0 +1,28 @@ +{ + "description": "Full talk title: \"Asleep at the Wheel: Getting your SBOMs to pay attention to Python Builds\"\n\nBetween competing standards, tools, and compliance-checkboxes, developers are effectively told to \u201cgenerate an SBOM\u201d 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.\n\nIn 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.\n\nThis 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: \u201cWhat did the build actually do?\u201d. 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.\n\nIn this talk, we examine the gaps in today\u2019s SBOM generation approaches and how they affect Python ecosystem. We walk through SBOMit\u2019s architecture and how it provides a workflow to plug into your SBOM generation process. Finally, we\u2019ll 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.", + "duration": 1932, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/116/" + } + ], + "speakers": [ + "Sanchit Sahay", + "Abhishek Reddypalle" + ], + "thumbnail_url": "https://i.ytimg.com/vi/VYY3HnRtV6U/hqdefault.jpg", + "title": "Asleep at the Wheel: Getting your SBOMs to pay attention to Python Builds", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=VYY3HnRtV6U" + } + ] +} diff --git a/pycon-us-2026/videos/beyond-rate-limiting-adaptive-security-for-python-web-applications.json b/pycon-us-2026/videos/beyond-rate-limiting-adaptive-security-for-python-web-applications.json new file mode 100644 index 000000000..b735c765d --- /dev/null +++ b/pycon-us-2026/videos/beyond-rate-limiting-adaptive-security-for-python-web-applications.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nThis 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.\n\nThe 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\u2019t, and how to design security systems that fail safely and respect user privacy.", + "duration": 1036, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/61/" + } + ], + "speakers": [ + "Aayush Gauba" + ], + "thumbnail_url": "https://i.ytimg.com/vi/J3A-LReijws/hqdefault.jpg", + "title": "Beyond Rate Limiting Adaptive Security for Python Web Applications", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=J3A-LReijws" + } + ] +} diff --git a/pycon-us-2026/videos/beyond-the-hype-a-pragmatic-look-at-how-developers-actually-use-ai-tools.json b/pycon-us-2026/videos/beyond-the-hype-a-pragmatic-look-at-how-developers-actually-use-ai-tools.json new file mode 100644 index 000000000..de2933235 --- /dev/null +++ b/pycon-us-2026/videos/beyond-the-hype-a-pragmatic-look-at-how-developers-actually-use-ai-tools.json @@ -0,0 +1,32 @@ +{ + "description": "Panel Members: Carol Willing, Catherine Nelson, Jelle Zijlstra, Jodie Burchell, La\u00eds Carvalho, Maike Scherer\n\nAI tooling is evolving faster than most teams can evaluate it, leaving developers caught between real productivity gains, constant change, and growing fatigue. Five practitioners \u2014 spanning open-source, data science, developer relations, and production engineering \u2014 share what actually works, what they've abandoned, and how they decide what's worth learning next. Attendees will leave with workflow patterns worth stealing, a sharper sense of which tools deserve their attention, and honest advice for developers at any career stage.", + "duration": 1924, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/172/" + } + ], + "speakers": [ + "Carol Willing", + "Catherine Nelson", + "Jelle Zijlstra", + "Jodie Burchell", + "La\u00eds Carvalho", + "Maike Scherer" + ], + "thumbnail_url": "https://i.ytimg.com/vi/9VW_5SaeILs/hqdefault.jpg", + "title": "Beyond the Hype: A Pragmatic Look at How Developers Actually Use AI Tools", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=9VW_5SaeILs" + } + ] +} diff --git a/pycon-us-2026/videos/beyond-the-p-value-a-data-scientists-guide-to-tier-1-feature-launches.json b/pycon-us-2026/videos/beyond-the-p-value-a-data-scientists-guide-to-tier-1-feature-launches.json new file mode 100644 index 000000000..d8fcc655e --- /dev/null +++ b/pycon-us-2026/videos/beyond-the-p-value-a-data-scientists-guide-to-tier-1-feature-launches.json @@ -0,0 +1,27 @@ +{ + "description": "In a perfect world, every feature launch is a clean A/B test with a clear winner. In the world of high-growth platforms like Meta, Coinbase, and Loom, launches are messy. Users influence one another through network effects, selection bias skews your metrics, and a simple t-test often hides more than it reveals.\n\nThis talk walks through the anatomy of a \"Launch Post-Mortem\" using a Jupyter Notebook. We will move beyond basic statistical significance to explore how to handle the complexities of real-world growth data.\n\nAttendees will learn how to use Python libraries like CausalML and PyMatch to account for user behavior bias and network interference, ensuring that \"winning\" features actually drive long-term value.", + "duration": 1440, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/69/" + } + ], + "speakers": [ + "Jyoti Yadav" + ], + "thumbnail_url": "https://i.ytimg.com/vi/bZNX6Cuj-1A/hqdefault.jpg", + "title": "Beyond the P-Value: A Data Scientist\u2019s Guide to Tier-1 Feature Launches", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=bZNX6Cuj-1A" + } + ] +} diff --git a/pycon-us-2026/videos/brains-and-explosions-a-simple-vdb-writer-for-python.json b/pycon-us-2026/videos/brains-and-explosions-a-simple-vdb-writer-for-python.json new file mode 100644 index 000000000..aa467658a --- /dev/null +++ b/pycon-us-2026/videos/brains-and-explosions-a-simple-vdb-writer-for-python.json @@ -0,0 +1,27 @@ +{ + "description": "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.", + "duration": 1710, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/55/" + } + ], + "speakers": [ + "Joachim Pfefferkorn" + ], + "thumbnail_url": "https://i.ytimg.com/vi/a8Fy4kk2xFY/hqdefault.jpg", + "title": "Brains and Explosions: A Simple VDB Writer for Python", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=a8Fy4kk2xFY" + } + ] +} diff --git a/pycon-us-2026/videos/breaking-the-speed-limit-fast-statistical-models-with-python-3-14-numba-and-jax.json b/pycon-us-2026/videos/breaking-the-speed-limit-fast-statistical-models-with-python-3-14-numba-and-jax.json new file mode 100644 index 000000000..4bc77bfdf --- /dev/null +++ b/pycon-us-2026/videos/breaking-the-speed-limit-fast-statistical-models-with-python-3-14-numba-and-jax.json @@ -0,0 +1,28 @@ +{ + "description": "Full talk title: \"Breaking the Speed Limit: Fast Statistical Models with Python 3.14, Numba, and JAX\"\n\nData 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\u2011world datasets. How do we choose the right tool without getting lost in low\u2011level details?\n\nWith the new free\u2011threaded 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\u2011means) and massive data parallelism (permutation test). The focus is on computational patterns rather than statistical theory.\n\nWe'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.", + "duration": 1787, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/128/" + } + ], + "speakers": [ + "Wenxin Jiang", + "Jian Yin" + ], + "thumbnail_url": "https://i.ytimg.com/vi/ZywVdsNkMwc/hqdefault.jpg", + "title": "Breaking the Speed Limit: Fast Statistical Models with Python 3.14, Numba, and JAX", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=ZywVdsNkMwc" + } + ] +} diff --git a/pycon-us-2026/videos/como-pase-de-perdida-a-ensenar-python-ia-a-miles-en-un-ano-gwyneth-pena.json b/pycon-us-2026/videos/como-pase-de-perdida-a-ensenar-python-ia-a-miles-en-un-ano-gwyneth-pena.json new file mode 100644 index 000000000..7ddde48fc --- /dev/null +++ b/pycon-us-2026/videos/como-pase-de-perdida-a-ensenar-python-ia-a-miles-en-un-ano-gwyneth-pena.json @@ -0,0 +1,30 @@ +{ + "description": "En enero me cambi\u00e9 a un equipo de Python con una barra t\u00e9cnica muy alta y de inmediato me sent\u00ed frustrada y perdida. No les miento, hubo momentos en los que dud\u00e9 si iba a poder. En un a\u00f1o pas\u00e9 de eso a ense\u00f1ar Python m\u00e1s IA a miles de personas, crear demos para conferencias de alto impacto, entrevistar a figuras clave de la comunidad, contribuir a librer\u00edas open source y recuperar confianza t\u00e9cnica y en m\u00ed misma.\n\nEsta no es la historia de una estrategia perfecta. Es una charla de reflexi\u00f3n sobre lo que s\u00ed me funcion\u00f3 en la pr\u00e1ctica. Compartir\u00e9 ejemplos concretos de c\u00f3mo crec\u00ed en Python en la era de la IA, cuando el c\u00f3digo aparece en minutos pero el criterio y el rigor siguen siendo tu responsabilidad. Hablaremos de c\u00f3mo aprender desde trabajo real, c\u00f3mo colaborar con gente m\u00e1s experta sin volverte dependiente y c\u00f3mo pasar de ejecutar demos a construirlos y mejorarlos con calidad.\n\nSi est\u00e1s entrando a un equipo nuevo o subiendo de nivel en Python, saldr\u00e1s con pr\u00e1cticas concretas y un checklist para aprender m\u00e1s r\u00e1pido sin perder rigor t\u00e9cnico.\n\nThe PyCon US 2026 conference in Lon", + "duration": 1886, + "language": "spa", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/159/" + } + ], + "speakers": [ + "Gwyneth Pe\u00f1a-Siguenza" + ], + "tags": [ + "charla" + ], + "thumbnail_url": "https://i.ytimg.com/vi/1rAyJzbLOBk/hqdefault.jpg", + "title": "C\u00f3mo pas\u00e9 de perdida a ense\u00f1ar Python + IA a miles, en un a\u00f1o - Gwyneth Pe\u00f1a", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=1rAyJzbLOBk" + } + ] +} diff --git a/pycon-us-2026/videos/como-python-puede-ayudar-a-detectar-senales-tempranas-en-la-salud-mental-universitaria.json b/pycon-us-2026/videos/como-python-puede-ayudar-a-detectar-senales-tempranas-en-la-salud-mental-universitaria.json new file mode 100644 index 000000000..8fb614524 --- /dev/null +++ b/pycon-us-2026/videos/como-python-puede-ayudar-a-detectar-senales-tempranas-en-la-salud-mental-universitaria.json @@ -0,0 +1,30 @@ +{ + "description": "Full Charlas Title:\u00bfC\u00f3mo Python puede ayudar a detectar se\u00f1ales tempranas en la salud mental universitaria?\n\nBolivia como muchos otros pa\u00edses de Am\u00e9rica Latina a diario se enfrenta con un tema poco visibilizado, que es la salud mental, especialmente en j\u00f3venes universitarios, a pesar de su impacto directo en el bienestar, el rendimiento acad\u00e9mico y la vida de miles de j\u00f3venes. Factores emocionales, socioecon\u00f3micos, entre otros suelen acumularse sin ser detectados a tiempo lo que dificulta una intervenci\u00f3n oportuna y el posible desarrollo de un trastorno mental, como la depresi\u00f3n. En esta charla se comparte c\u00f3mo Python fue usado como una herramienta clave para apoyar la detecci\u00f3n temprana de riesgo de depresi\u00f3n en una poblaci\u00f3n universitaria, combinando an\u00e1lisis de datos e inteligencia artificial de forma responsable y \u00e9tica. Python permiti\u00f3 explorar y analizar datos con caracter\u00edsticas sociodemogr\u00e1ficas y emocionales logrando identificar factores de riesgo de depresi\u00f3n y patrones relevantes. Adem\u00e1s se us\u00f3 Python para adaptar un modelo de PLN mediante fine-tuning para analizar respuestas a preguntas abiertas escritas por estudiantes, lo que ayud\u00f3 a identificar emociones presentes en el lenguaje, y as\u00ed ampliar la visi\u00f3n para detectar un posible nivel de riesgo de depresi\u00f3n. M\u00e1s all\u00e1 de la tecnolog\u00eda, 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\u00f3n temprana de riesgo de depresi\u00f3n manteniendo siempre a las personas en el centro del proyecto.", + "duration": 2209, + "language": "spa", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/18/" + } + ], + "speakers": [ + "Valentina Lazaro" + ], + "tags": [ + "charla" + ], + "thumbnail_url": "https://i.ytimg.com/vi/s-m9DZ-AWuw/hqdefault.jpg", + "title": "\u00bfC\u00f3mo Python puede ayudar a detectar se\u00f1ales tempranas en la salud mental universitaria?", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=s-m9DZ-AWuw" + } + ] +} diff --git a/pycon-us-2026/videos/conquer-multithreaded-python-with-blanket.json b/pycon-us-2026/videos/conquer-multithreaded-python-with-blanket.json new file mode 100644 index 000000000..6391bb48c --- /dev/null +++ b/pycon-us-2026/videos/conquer-multithreaded-python-with-blanket.json @@ -0,0 +1,27 @@ +{ + "description": "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!\n\nBlanket is here to help. Come learn how Blanket gives you back control over the order of execution in multithreaded code, enabling you to write deterministic multithreaded tests. Restore blessed order and determinism to your unit test suite--use Blanket!", + "duration": 2451, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/51/" + } + ], + "speakers": [ + "Larry Hastings" + ], + "thumbnail_url": "https://i.ytimg.com/vi/S3LUpx0hzkw/hqdefault.jpg", + "title": "Conquer multithreaded Python with Blanket", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=S3LUpx0hzkw" + } + ] +} diff --git a/pycon-us-2026/videos/construye-aplicaciones-web-interactivas-con-python-streamlit-y-supabase-en-accion.json b/pycon-us-2026/videos/construye-aplicaciones-web-interactivas-con-python-streamlit-y-supabase-en-accion.json new file mode 100644 index 000000000..30a971900 --- /dev/null +++ b/pycon-us-2026/videos/construye-aplicaciones-web-interactivas-con-python-streamlit-y-supabase-en-accion.json @@ -0,0 +1,30 @@ +{ + "description": "Full Charlas Title: Construye aplicaciones web interactivas con Python: Streamlit y Supabase en acci\u00f3n\n\nEsta charla demuestra c\u00f3mo desarrollar aplicaciones web interactivas completas usando Python, Streamlit y Supabase, sin necesidad de conocimientos avanzados de frontend o infraestructura.\n\n\u00bfQu\u00e9 aprender\u00e1s?\nLos asistentes descubrir\u00e1n c\u00f3mo: - Crear interfaces de usuario interactivas en minutos con Streamlit - Conectar aplicaciones Python a Supabase para gesti\u00f3n de datos en tiempo real - Implementar autenticaci\u00f3n de usuarios y manejo de sesiones - Desplegar aplicaciones completas de forma gratuita o con bajo costo\n\nContenido de la charla\nIntroducci\u00f3n (5 min): Por qu\u00e9 Streamlit y Supabase son ideales para MVPs y prototipos r\u00e1pidos con Python.\n\nIntegraci\u00f3n pr\u00e1ctica (15 min): Demostraci\u00f3n paso a paso de una aplicaci\u00f3n funcional que incluye: - Conexi\u00f3n a base de datos PostgreSQL v\u00eda Supabase - Operaciones CRUD en tiempo real - Visualizaci\u00f3n de datos con componentes interactivos - Manejo de estado y cach\u00e9 en Streamlit\n\nBuenas pr\u00e1cticas (7 min): Gesti\u00f3n de secrets, optimizaci\u00f3n de queries, estructura de proyecto recomendada y consideraciones de seguridad.\n\nCierre y Q&A (3 min): Recursos adicionales y cu\u00e1ndo elegir esta stack sobre alternativas.\n\n\u00bfPara qui\u00e9n es esta charla?\nDesarrolladores Python que buscan crear aplicaciones web r\u00e1pidamente, equipos que necesitan prototipar ideas sin configurar servidores complejos, y cualquier persona interesada en desarrollo full-stack moderno con Python.\n\nAl finalizar, los asistentes tendr\u00e1n el conocimiento para construir y desplegar sus propias aplicaciones web interactivas usando estas herramientas modernas del ecosistema Python.", + "duration": 535, + "language": "spa", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/17/" + } + ], + "speakers": [ + "Nicolas Emir Mejia Agreda" + ], + "tags": [ + "charla" + ], + "thumbnail_url": "https://i.ytimg.com/vi/9NICc1uuveA/hqdefault.jpg", + "title": "Construye aplicaciones web interactivas con Python: Streamlit y Supabase en acci\u00f3n", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=9NICc1uuveA" + } + ] +} diff --git a/pycon-us-2026/videos/construyendo-computadoras-cuanticas-con-python-aprendizajes-al-crear-un-ecosistema-de-diseno-de-hardware.json b/pycon-us-2026/videos/construyendo-computadoras-cuanticas-con-python-aprendizajes-al-crear-un-ecosistema-de-diseno-de-hardware.json new file mode 100644 index 000000000..611c227e4 --- /dev/null +++ b/pycon-us-2026/videos/construyendo-computadoras-cuanticas-con-python-aprendizajes-al-crear-un-ecosistema-de-diseno-de-hardware.json @@ -0,0 +1,30 @@ +{ + "description": "Full Charlas Title: Construyendo computadoras cu\u00e1nticas con Python: aprendizajes al crear un ecosistema de dise\u00f1o de hardware\n\nEl dise\u00f1o de hardware \u2014ya sea para computaci\u00f3n cu\u00e1ntica, fot\u00f3nica o sistemas mixtos\u2014 ha estado tradicionalmente limitado por herramientas cerradas, complejas y costosas. Durante los \u00faltimos a\u00f1os he estado trabajando en un enfoque distinto: usar Python para dise\u00f1ar chips reales que terminan fabric\u00e1ndose en foundries industriales. Lo que comenz\u00f3 como unos cuantos scripts se transform\u00f3 en GDSFactory, una biblioteca abierta que hoy utilizan universidades, startups y grandes empresas para dise\u00f1ar dispositivos fot\u00f3nicos y cu\u00e1nticos.\n\nEsta charla no es una demostraci\u00f3n de un producto, sino la historia de c\u00f3mo Python abri\u00f3 un dominio entero y lo que me habr\u00eda gustado saber antes de construir un stack EDA en Python. Compartir\u00e9 patrones arquitect\u00f3nicos, lecciones aprendidas, errores, sorpresas y t\u00e9cnicas para integrar simulaci\u00f3n, verificaci\u00f3n y exploraci\u00f3n de dise\u00f1o dentro de flujos cient\u00edficos.\n\nLos asistentes saldr\u00e1n con ideas concretas sobre c\u00f3mo usar Python para modelar sistemas f\u00edsicos, crear herramientas especializadas y ampliar los l\u00edmites de lo que podemos dise\u00f1ar desde software.", + "duration": 1537, + "language": "spa", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/169/" + } + ], + "speakers": [ + "Joaquin Matres" + ], + "tags": [ + "charla" + ], + "thumbnail_url": "https://i.ytimg.com/vi/L1iTkK5m9_g/hqdefault.jpg", + "title": "Construyendo computadoras cu\u00e1nticas con Python: aprendizajes al crear un ecosistema de dise\u00f1o de hardware", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=L1iTkK5m9_g" + } + ] +} diff --git a/pycon-us-2026/videos/container-enabled-asyncio-is-all-you-need-to-build-pythonic-ai-workflows-at-scale.json b/pycon-us-2026/videos/container-enabled-asyncio-is-all-you-need-to-build-pythonic-ai-workflows-at-scale.json new file mode 100644 index 000000000..3fab06b85 --- /dev/null +++ b/pycon-us-2026/videos/container-enabled-asyncio-is-all-you-need-to-build-pythonic-ai-workflows-at-scale.json @@ -0,0 +1,27 @@ +{ + "description": "As AI applications and agents move from prototypes to production, Python developers are increasingly tasked with orchestrating large numbers of models, tools and external services. These requirements often push teams toward specialized frameworks or domain-specific languages to manage concurrency and workflows, even though Python\u2019s standard library already provides the core building blocks to solve these problems.\n\nThis talk demonstrates how engineers can leverage Python\u2019s native asyncio library together with container orchestration platforms like Kubernetes to build scalable, production-ready AI workflows. It presents a practical explainer of asyncio, emphasizing the aspects most relevant to today\u2019s AI systems, such as structured concurrency, task coordination, backpressure, timeouts and failure isolation. It demonstrates how asyncio can be a highly effective programming paradigm to coordinate compute and data flow on a Kubernetes backend, giving Python developers the scale they need to build production-grade AI applications and agents.\n\nThrough concrete examples, the session shows how common workflow patterns, including coordinating LLM calls, executing tools in parallel, streaming responses and interacting with rate-limited APIs, can be implemented directly with asyncio and other Python primitives. Rather than relying on declarative pipelines or custom Domain-Specific Language (DSLs), these patterns remain explicit, debuggable and easy to reason about using plain Python.\n\nThe talk also explores how async Python can serve as a client to a scalable container orchestration backend, enabling AI services and agents to scale predictably while preserving readability and operational control. Topics include handling partial failures, retries, and high-throughput workloads without blocking or over-abstracting the developer\u2019s programming paradigm.\n\nBy the end of the session, attendees will understand why asyncio coupled with container orchestrators like Kubernetes are sufficient to build scalable, Pythonic AI workflows and how using the standard library can reduce complexity and improve long-term maintainability.", + "duration": 1819, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/167/" + } + ], + "speakers": [ + "Niels Bantilan" + ], + "thumbnail_url": "https://i.ytimg.com/vi/YF1Dgp0jZrM/hqdefault.jpg", + "title": "Container-enabled Asyncio is All You Need (to Build Pythonic AI Workflows at Scale)", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=YF1Dgp0jZrM" + } + ] +} diff --git a/pycon-us-2026/videos/create-a-python-package-from-zero-to-hero.json b/pycon-us-2026/videos/create-a-python-package-from-zero-to-hero.json new file mode 100644 index 000000000..4bbb4dcf8 --- /dev/null +++ b/pycon-us-2026/videos/create-a-python-package-from-zero-to-hero.json @@ -0,0 +1,27 @@ +{ + "description": "Ever wondered where those cool things that you pip install come from? Have you thought about what it might take for you\u2014yes, you\u2014to create your very own package that others can install and enjoy?\n\nThis talk will talk about specific ways in which you can move from problem, to idea, to implementation, and lastly, packaging.\n\nIt 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!", + "duration": 1792, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/99/" + } + ], + "speakers": [ + "Mario Munoz" + ], + "thumbnail_url": "https://i.ytimg.com/vi/oM_3N2ocExc/hqdefault.jpg", + "title": "Create a Python Package From Zero to Hero", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=oM_3N2ocExc" + } + ] +} diff --git a/pycon-us-2026/videos/cuando-pip-install-no-es-suficiente-amenazas-reales-y-defensas-practicas-en-python-y-pypi.json b/pycon-us-2026/videos/cuando-pip-install-no-es-suficiente-amenazas-reales-y-defensas-practicas-en-python-y-pypi.json new file mode 100644 index 000000000..1e58b51f0 --- /dev/null +++ b/pycon-us-2026/videos/cuando-pip-install-no-es-suficiente-amenazas-reales-y-defensas-practicas-en-python-y-pypi.json @@ -0,0 +1,30 @@ +{ + "description": "Full Charlas Title: \u201cCuando pip install no es suficiente: amenazas reales y defensas pr\u00e1cticas en Python y PyPI\u201d\n\nEl ecosistema Python se ha convertido en uno de los pilares del desarrollo moderno, pero su apertura y velocidad tambi\u00e9n 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\u00f3n inocente.\n\nEn esta charla, basada en experiencia real en ciberseguridad y operaci\u00f3n de entornos productivos, se analizar\u00e1n las principales amenazas que afectan a Python y PyPI, mostrando c\u00f3mo actores maliciosos explotan la confianza del ecosistema open source. A trav\u00e9s de ejemplos concretos y casos reales, se evidenciar\u00e1n riesgos que impactan tanto a desarrolladores individuales como a organizaciones empresariales.\n\nFinalmente, se presentar\u00e1n defensas pr\u00e1cticas y aplicables para fortalecer aplicaciones Python en distintos entornos: buenas pr\u00e1cticas de gesti\u00f3n de dependencias, controles de seguridad en pipelines CI/CD, herramientas de an\u00e1lisis de paquetes, principios DevSecOps y estrategias para reducir el riesgo sin frenar la innovaci\u00f3n. El objetivo es entregar a la audiencia criterio, conciencia y acciones concretas para pasar de consumidores pasivos a defensores activos del ecosistema Python.", + "duration": 1687, + "language": "spa", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/43/" + } + ], + "speakers": [ + "Diego Caceres Solis" + ], + "tags": [ + "charla" + ], + "thumbnail_url": "https://i.ytimg.com/vi/IyLccXQ8xBk/hqdefault.jpg", + "title": "\u201cCuando pip install no es suficiente: amenazas reales y defensas pr\u00e1cticas en Python y PyPI\u201d", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=IyLccXQ8xBk" + } + ] +} diff --git a/pycon-us-2026/videos/d-i-panel-python-is-for-everyone-growing-the-community-without-limits.json b/pycon-us-2026/videos/d-i-panel-python-is-for-everyone-growing-the-community-without-limits.json new file mode 100644 index 000000000..238333fb0 --- /dev/null +++ b/pycon-us-2026/videos/d-i-panel-python-is-for-everyone-growing-the-community-without-limits.json @@ -0,0 +1,27 @@ +{ + "description": "D\u00e9bora Azevedo\nD\u00e9bora is a public school teacher in Brazil, and one of the cofounders of PyLadies Brazil, the largest PyLadies chapter in the world. She's a PhD student and she researches educational software development. She's currently one of the organizers of Python Nordeste, a regional Python conference in Brazil, and a former PSF board member (2021\u20132024).\n\nAlla Barbalat\nAlla Barbalat began her career as a lawyer before transitioning into tech. She is the lead organizer of PyLadies San Francisco, an avid Python user, and a speaker on topics at the intersection of Python, AI, and law.\n\nGeorgi Ker\nGeorgi Ker is the Director and a Fellow of the Python Software Foundation. She co-organizes PyLadiesCon and chairs the D&I Workgroup within the PSF. She is also one of the co-hosts of the podcast series \u201cThe Hidden Figures of Python\u201d alongside Mariatta Wijaya, Cheuk Ting Ho, and Tereza Iofciu.\n\nTheresa Seyram Agbenyegah (Stancy)\nTheresa Seyram Agbenyegah (mostly referred to in the Tech community as Stancy) is a Software Engineer, Open-Source advocate, and Social Entrepreneur. She currently serves as the Programmes and Events Lead for PyLadies Ghana and is a member of Python Ghana. She is a DSF member and a member of the DSF event support working group, a PSF Diversity and Inclusion workgroup member, an Outreach ambassador for the CHAOSS DEI workgroup, and a Django Girls organizer.\n\nAbhijeet Mote\nAbhijeet is a Lead Python AI Engineer and Fellow of the Python Software Foundation. He founded Python Penang, Malaysia, where he has helped grow the local developer community. He has spoken at international conferences including PyCon Italy, runs workshops, and mentors students and underrepresented groups in technology. His work focuses on scalable Python AI systems, distributed systems, data pipelines, and LLM-based applications across adtech, semiconductor, and healthcare.", + "duration": 1370, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + } + ], + "speakers": [ + "D\u00e9bora Azevedo", + "Alla Barbalat", + "Georgi Ker", + "Theresa Seyram Agbenyegah (Stancy)", + "Abhijeet Mote" + ], + "thumbnail_url": "https://i.ytimg.com/vi/Rjy5Xc4SGbY/hqdefault.jpg", + "title": "D&I Panel: Python is for Everyone: Growing the Community Without Limits", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=Rjy5Xc4SGbY" + } + ] +} diff --git a/pycon-us-2026/videos/debugging-python-in-production-practical-techniques-beyond-print-statements.json b/pycon-us-2026/videos/debugging-python-in-production-practical-techniques-beyond-print-statements.json new file mode 100644 index 000000000..73a012771 --- /dev/null +++ b/pycon-us-2026/videos/debugging-python-in-production-practical-techniques-beyond-print-statements.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nThis 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\u2019s built-in and ecosystem tooling.\n\nTopics 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.\n\nAll 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.\n\nBy 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.", + "duration": 690, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/93/" + } + ], + "speakers": [ + "Anshul Jannumahanti" + ], + "thumbnail_url": "https://i.ytimg.com/vi/vXCQvD04gTE/hqdefault.jpg", + "title": "Debugging Python in Production: Practical Techniques Beyond Print Statements", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=vXCQvD04gTE" + } + ] +} diff --git a/pycon-us-2026/videos/demystifying-pythons-generational-garbage-collector.json b/pycon-us-2026/videos/demystifying-pythons-generational-garbage-collector.json new file mode 100644 index 000000000..7da9e323b --- /dev/null +++ b/pycon-us-2026/videos/demystifying-pythons-generational-garbage-collector.json @@ -0,0 +1,27 @@ +{ + "description": "Automatic memory management is one of Python\u2019s key features, yet for many developers it stays opaque: objects appear when you create them and vanish when you stop using them, with little visibility into what happens in between.\n\nThis talk pulls back that curtain and explains how CPython actually manages memory\u2014from how objects are allocated and laid out in memory, to how unused objects are reclaimed through reference counting, to why reference counting alone is not enough when objects reference each other in cycles.\n\nWe will cover the cyclic garbage collector: how it discovers unreachable reference cycles, and why it is split across generations to amortize cost. Along the way, we will touch on practical debugging and tuning: interpreting GC behavior and spotting retention and leaks.", + "duration": 1593, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/21/" + } + ], + "speakers": [ + "Puneet Khushwani" + ], + "thumbnail_url": "https://i.ytimg.com/vi/w9RNuPb0DBQ/hqdefault.jpg", + "title": "Demystifying Python\u2019s Generational Garbage Collector", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=w9RNuPb0DBQ" + } + ] +} diff --git a/pycon-us-2026/videos/demystifying-the-gil.json b/pycon-us-2026/videos/demystifying-the-gil.json new file mode 100644 index 000000000..762548e98 --- /dev/null +++ b/pycon-us-2026/videos/demystifying-the-gil.json @@ -0,0 +1,27 @@ +{ + "description": "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\u2019ll 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\u2019ll explore how the GIL maintains reference-counted garbage collection, then look at how Python\u2019s 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\u2019t expect them.", + "duration": 2278, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/45/" + } + ], + "speakers": [ + "Bruce Eckel" + ], + "thumbnail_url": "https://i.ytimg.com/vi/MC1PQ7ZgUeU/hqdefault.jpg", + "title": "Demystifying the GIL", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=MC1PQ7ZgUeU" + } + ] +} diff --git a/pycon-us-2026/videos/distributing-ai-with-python-in-the-browser-edge-inference-and-flexibility-without-infrastructure.json b/pycon-us-2026/videos/distributing-ai-with-python-in-the-browser-edge-inference-and-flexibility-without-infrastructure.json new file mode 100644 index 000000000..601f750da --- /dev/null +++ b/pycon-us-2026/videos/distributing-ai-with-python-in-the-browser-edge-inference-and-flexibility-without-infrastructure.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nThis 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\u2019s browser. Along the way, we will look at how this fits into the broader AI\u2011in\u2011browser ecosystem: interoperating with existing JavaScript model runners, leveraging WebGPU/WebNN for acceleration, mixing Python\u2011based preprocessing with client\u2011side inference engines or simply a gateway to AI services like OpenAI or Anthropic.\n\nSecurity and privacy are first\u2011class 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\u2011offs: bundle sizes, model constraints, performance, and when a hybrid edge/cloud approach makes more sense than going fully client\u2011side. Attendees will leave with concrete patterns, example architectures, and a clear path to experimet with Python\u2011powered AI at the edge, no special infrastructure required.", + "duration": 1813, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/126/" + } + ], + "speakers": [ + "Fabio Pliger" + ], + "thumbnail_url": "https://i.ytimg.com/vi/xncJoSGWZpg/hqdefault.jpg", + "title": "Distributing AI with Python in the Browser: Edge Inference and Flexibility Without Infrastructure", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=xncJoSGWZpg" + } + ] +} diff --git a/pycon-us-2026/videos/dont-write-polars-code-with-a-pandas-accent.json b/pycon-us-2026/videos/dont-write-polars-code-with-a-pandas-accent.json new file mode 100644 index 000000000..1ac6cc59c --- /dev/null +++ b/pycon-us-2026/videos/dont-write-polars-code-with-a-pandas-accent.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nWe 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.\n\nAttendees 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.\n\nAudience\n\nThis 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.\n\nTakeaways\n\nHow Polars\u2019 execution model differs from pandas.\nSpot pandas habits that lead to poor Polars code.\nAdopt idiomatic Polars patterns for data transformation and analysis.\nEmbrace chained operations to leverage the query optimizer.", + "duration": 1335, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/10/" + } + ], + "speakers": [ + "Joram Mutenge" + ], + "thumbnail_url": "https://i.ytimg.com/vi/5-4xTrN-M98/hqdefault.jpg", + "title": "Don\u2019t Write Polars Code with a Pandas Accent", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=5-4xTrN-M98" + } + ] +} diff --git a/pycon-us-2026/videos/el-agent-que-convirtio-el-caos-de-on-call-en-un-solo-slack-thread.json b/pycon-us-2026/videos/el-agent-que-convirtio-el-caos-de-on-call-en-un-solo-slack-thread.json new file mode 100644 index 000000000..7a50ee8a4 --- /dev/null +++ b/pycon-us-2026/videos/el-agent-que-convirtio-el-caos-de-on-call-en-un-solo-slack-thread.json @@ -0,0 +1,30 @@ +{ + "description": "\u00bfY si lo pr\u00f3ximo que automatizas no fuera tu infraestructura, sino el caos de estar on-call?\n\nMientras Datadog constantemente est\u00e1 estimando m\u00e9tricas 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\u00e9 se rompi\u00f3 y por qu\u00e9!\n\nEn esta secci\u00f3n vamos a ense\u00f1arles c\u00f3mo 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.\n\nVan a ver un Agente que: - Relaciona alertas, m\u00e9tricas y eventos de AWS en un solo timeline de incidentes - Sugiere probables causas utilizando an\u00e1lisis 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\n\nEn general, vamos a disectar c\u00f3mo funciona y trabaja este Agente explorando m\u00faltiples escenarios con incidentes en vivo durante la secci\u00f3n. Todo con la finalidad de aprender c\u00f3mo convertir este proceso disperso en uno organizado y colaborativo.", + "duration": 1663, + "language": "spa", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/50/" + } + ], + "speakers": [ + "Angelik Laboy Torres" + ], + "tags": [ + "charla" + ], + "thumbnail_url": "https://i.ytimg.com/vi/WQJ2d5KXpGM/hqdefault.jpg", + "title": "El Agent que Convirti\u00f3 el Caos de On-Call en un Solo Slack Thread", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=WQJ2d5KXpGM" + } + ] +} diff --git a/pycon-us-2026/videos/el-texto-no-es-texto-historia-de-las-strings-en-python.json b/pycon-us-2026/videos/el-texto-no-es-texto-historia-de-las-strings-en-python.json new file mode 100644 index 000000000..a692a29b9 --- /dev/null +++ b/pycon-us-2026/videos/el-texto-no-es-texto-historia-de-las-strings-en-python.json @@ -0,0 +1,30 @@ +{ + "description": "Usamos strings todo el tiempo, pero casi nadie sabe c\u00f3mo funcionan realmente.\n\nEn esta charla desmontaremos la abstracci\u00f3n del texto en Python desde sus or\u00edgenes m\u00e1s peligrosos en C (char \\*) hasta las innovaciones de Python 3.14. Exploraremos c\u00f3mo errores hist\u00f3ricos de memoria, encodings incompatibles y el caos de Unicode forzaron algunas de las decisiones de dise\u00f1o m\u00e1s elegantes del lenguaje.\n\nNos adentraremos en el int\u00e9rprete para entender el PEP 393 y c\u00f3mo Python logra representar texto Unicode de forma eficiente y din\u00e1mica. Recorreremos la evoluci\u00f3n del formateo de strings, desde % hasta f-strings, para entender qu\u00e9 problemas resolvi\u00f3 cada paso.\n\nCerraremos con el PEP 750 y las Template Strings: una nueva forma de tratar el texto como estructura, no como concatenaci\u00f3n, habilitando procesamiento diferido, metaprogramaci\u00f3n y una defensa mucho m\u00e1s s\u00f3lida contra inyecciones de c\u00f3digo.\n\nAl terminar, no solo entender\u00e1s mejor c\u00f3mo funcionan las strings en Python: entender\u00e1s por qu\u00e9 est\u00e1n dise\u00f1adas as\u00ed, y c\u00f3mo usar ese conocimiento para escribir c\u00f3digo m\u00e1s eficiente, m\u00e1s seguro y m\u00e1s expresivo.", + "duration": 2118, + "language": "spa", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/139/" + } + ], + "speakers": [ + "Daniel Herv\u00e1s" + ], + "tags": [ + "charla" + ], + "thumbnail_url": "https://i.ytimg.com/vi/m5ZboJD84CY/hqdefault.jpg", + "title": "El texto no es texto: historia de las strings en Python", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=m5ZboJD84CY" + } + ] +} diff --git a/pycon-us-2026/videos/fall-in-love-with-css.json b/pycon-us-2026/videos/fall-in-love-with-css.json new file mode 100644 index 000000000..e05618e00 --- /dev/null +++ b/pycon-us-2026/videos/fall-in-love-with-css.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nLet 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.\n\nSpoilers:\n\nVariables (custom properties)\nnested styles (CSS nesting)\nTwo! Great layout tools (CSS grid and flexbox)", + "duration": 1931, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/82/" + } + ], + "speakers": [ + "Piper Thunstrom" + ], + "thumbnail_url": "https://i.ytimg.com/vi/LIEsWtEUxrQ/hqdefault.jpg", + "title": "Fall In Love With CSS", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=LIEsWtEUxrQ" + } + ] +} diff --git a/pycon-us-2026/videos/free-threaded-python-past-present-and-future.json b/pycon-us-2026/videos/free-threaded-python-past-present-and-future.json new file mode 100644 index 000000000..9f49c0b8e --- /dev/null +++ b/pycon-us-2026/videos/free-threaded-python-past-present-and-future.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nThis overview will explain what free-threading is, why it's a big deal, how it differs from other ways to deal with the GIL, and what the plan is for ensuring a smooth migration. We'll explain the basics of thread safety, data races, and concurrent designs, how those apply to Python code, and how this will and won't change when the GIL is disabled. And yes, we'll show some threads go brrr.\n\nAlthough we'll mention some complex, deeply technical problems, this is not a technical deep dive and any experience level is welcome.", + "duration": 1825, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/63/" + } + ], + "speakers": [ + "Thomas Wouters" + ], + "thumbnail_url": "https://i.ytimg.com/vi/PZu6LyiZVbM/hqdefault.jpg", + "title": "Free threaded Python past, present and future", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=PZu6LyiZVbM" + } + ] +} diff --git a/pycon-us-2026/videos/from-graveyard-to-glory-production-python-in-the-browser.json b/pycon-us-2026/videos/from-graveyard-to-glory-production-python-in-the-browser.json new file mode 100644 index 000000000..723748aa9 --- /dev/null +++ b/pycon-us-2026/videos/from-graveyard-to-glory-production-python-in-the-browser.json @@ -0,0 +1,27 @@ +{ + "description": "For a decade, \"Python in the browser\" was a graveyard of transpilers (PyJS), dead plugins (Silverlight), and academic experiments.\n\nBut 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.\n\nThis 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.\n\nWe 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.\n\nThen, we open the hood on a production-grade case study:\n\n- 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.\n- 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.\n- 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.\n\nAttendees will leave with a proven blueprint for bridging backend power with frontend interactivity, sharing code and bridging Python to new frontiers.", + "duration": 1726, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/121/" + } + ], + "speakers": [ + "Mahmoud Hashemi" + ], + "thumbnail_url": "https://i.ytimg.com/vi/YLZ6HrZSBrQ/hqdefault.jpg", + "title": "From Graveyard to Glory: Production Python in the Browser", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=YLZ6HrZSBrQ" + } + ] +} diff --git a/pycon-us-2026/videos/from-messy-clinical-data-to-interoperable-fhir-a-python-first-mapping-and-validation-pipeline.json b/pycon-us-2026/videos/from-messy-clinical-data-to-interoperable-fhir-a-python-first-mapping-and-validation-pipeline.json new file mode 100644 index 000000000..3448f39cd --- /dev/null +++ b/pycon-us-2026/videos/from-messy-clinical-data-to-interoperable-fhir-a-python-first-mapping-and-validation-pipeline.json @@ -0,0 +1,27 @@ +{ + "description": "Full talk title: \"From Messy Clinical Data to Interoperable FHIR: A Python-First Mapping and Validation Pipeline\"\n\nHealthcare 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.\n\nThis talk presents a Python-first approach to bridging that gap. I\u2019ll 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\u2019ll 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.\n\nThe 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.\n\nNo prior FHIR knowledge is required.", + "duration": 2014, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/58/" + } + ], + "speakers": [ + "Lisa Smith" + ], + "thumbnail_url": "https://i.ytimg.com/vi/AJkdevs4zOY/hqdefault.jpg", + "title": "From Messy Clinical Data to Interoperable FHIR: A Python-First Mapping and Validation Pipeline", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=AJkdevs4zOY" + } + ] +} diff --git a/pycon-us-2026/videos/github-actions-security-in-python-packages.json b/pycon-us-2026/videos/github-actions-security-in-python-packages.json new file mode 100644 index 000000000..f3687c283 --- /dev/null +++ b/pycon-us-2026/videos/github-actions-security-in-python-packages.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nBut 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.\n\nI 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.\n\nThis talk presents findings at ecosystem scale and explores what the Python community can learn from how we've solved similar problems in pip.\n\nWhat we'll cover:\n\nWhy GitHub Actions is a supply chain risk\nWhat's missing compared to pip, npm, and other package managers\nFindings from scanning Python package workflows at scale\nWhat we can learn from pip's security model\nA checklist for hardening Python package release workflows\nHow to integrate zizmor into CI pipelines", + "duration": 1820, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/117/" + } + ], + "speakers": [ + "Andrew Nesbitt" + ], + "thumbnail_url": "https://i.ytimg.com/vi/vn3YIqdseWI/hqdefault.jpg", + "title": "GitHub Actions Security in Python Packages", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=vn3YIqdseWI" + } + ] +} diff --git a/pycon-us-2026/videos/high-performance-llm-inference-in-pure-python-with-pytorch-custom-ops.json b/pycon-us-2026/videos/high-performance-llm-inference-in-pure-python-with-pytorch-custom-ops.json new file mode 100644 index 000000000..7dd0c2dea --- /dev/null +++ b/pycon-us-2026/videos/high-performance-llm-inference-in-pure-python-with-pytorch-custom-ops.json @@ -0,0 +1,27 @@ +{ + "description": "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\u2014an 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.\n\nThe 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.\n\nThis talk will cover:\n\nWhy a pure-Python architecture can match C++ inference engines\n\nThe key design principles behind multi-process runtime scheduling\n\nHow zero-overhead batch scheduling improves utilization and reduces latency\n\nThe role of PyTorch custom ops in high-performance serving\n\nInsights and practical lessons learned from scaling a Python LLM engine\n\nAttendees 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\u2014without requiring C++ or CUDA expertise.", + "duration": 1106, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/120/" + } + ], + "speakers": [ + "Yineng Zhang" + ], + "thumbnail_url": "https://i.ytimg.com/vi/XdDiixKHk38/hqdefault.jpg", + "title": "High Performance LLM Inference in Pure Python with PyTorch Custom Ops", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=XdDiixKHk38" + } + ] +} diff --git a/pycon-us-2026/videos/how-many-spoons-does-your-environment-cost.json b/pycon-us-2026/videos/how-many-spoons-does-your-environment-cost.json new file mode 100644 index 000000000..91500c69e --- /dev/null +++ b/pycon-us-2026/videos/how-many-spoons-does-your-environment-cost.json @@ -0,0 +1,27 @@ +{ + "description": "Full talk title: \"How many spoons does your environment cost: Feat. demos breaking and the human element of your broken env\"\n\nThis talk is one part technology dance and one part walk through of Python environment best practices. In under 30 minutes, you'll see me load up some of the most gnarly environments and watch them fail. This isn't just another talk about dependency management. It's about the hidden cost of environment friction: the cognitive load, the lost spoons, the brilliant developers who almost quit tech because they felt \"too stupid\" to make pip work. It's about recognizing that setup barriers aren't just inconvenient\u2014they're accessibility barriers that determine who gets to write Python.\n\nIn 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.\n\nContent note: This talk discusses mental health, burnout, and the emotional impact of technical barriers with care and intention.", + "duration": 1452, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/119/" + } + ], + "speakers": [ + "Dawn Wages" + ], + "thumbnail_url": "https://i.ytimg.com/vi/IenJs6ZO1hA/hqdefault.jpg", + "title": "How many spoons does your environment cost", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=IenJs6ZO1hA" + } + ] +} diff --git a/pycon-us-2026/videos/how-to-build-your-first-real-time-voice-agent-in-python-without-losing-your-mind.json b/pycon-us-2026/videos/how-to-build-your-first-real-time-voice-agent-in-python-without-losing-your-mind.json new file mode 100644 index 000000000..3493bfd98 --- /dev/null +++ b/pycon-us-2026/videos/how-to-build-your-first-real-time-voice-agent-in-python-without-losing-your-mind.json @@ -0,0 +1,28 @@ +{ + "description": "Full talk title: \"How to Build Your First Real-Time Voice Agent in Python (Without Losing Your Mind)\"\n\nVoice agents powered by LLMs look amazing in demos\u2026 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\u2019ll share how I built an \u201cEnglish Speaking Buddy\u201d voice agent: an English tutor you can talk to, that adapts to your level and helps you lose the fear of speaking. It\u2019s built with Python, AWS services (for speech and LLM), and Pipecat, an open source Python framework for creating real-time conversational voice agents. We\u2019ll walk through the core pipeline audio \u2192 text \u2192 LLM \u2192 audio, and how to build a clear, maintainable architecture for real-time voice agents. We\u2019ll also look at the less glamorous but critical parts that make this actually work: handling errors, configuring and protecting API keys, logging what\u2019s 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\u2019ll discuss can be applied with other providers and libraries. You\u2019ll 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.", + "duration": 1614, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/101/" + } + ], + "speakers": [ + "Camila Hinojosa A\u00f1ez", + "Elizabeth Fuentes" + ], + "thumbnail_url": "https://i.ytimg.com/vi/6NY44ciOjRQ/hqdefault.jpg", + "title": "How to Build Your First Real-Time Voice Agent in Python (Without Losing Your Mind)", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=6NY44ciOjRQ" + } + ] +} diff --git a/pycon-us-2026/videos/how-to-give-your-python-code-to-someone-else-russell-keith.json b/pycon-us-2026/videos/how-to-give-your-python-code-to-someone-else-russell-keith.json new file mode 100644 index 000000000..dfbdffb12 --- /dev/null +++ b/pycon-us-2026/videos/how-to-give-your-python-code-to-someone-else-russell-keith.json @@ -0,0 +1,27 @@ +{ + "description": "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?\n\nIn 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.", + "duration": 1870, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/36/" + } + ], + "speakers": [ + "Russell Keith-Magee" + ], + "thumbnail_url": "https://i.ytimg.com/vi/A2-pcMOVu0c/hqdefault.jpg", + "title": "How to give your Python code to someone else - Russell Keith", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=A2-pcMOVu0c" + } + ] +} diff --git a/pycon-us-2026/videos/how-to-port-a-python-kernel-to-pyodide-for-a-blazingly-fast-in-browser-coding-experience.json b/pycon-us-2026/videos/how-to-port-a-python-kernel-to-pyodide-for-a-blazingly-fast-in-browser-coding-experience.json new file mode 100644 index 000000000..9e1623807 --- /dev/null +++ b/pycon-us-2026/videos/how-to-port-a-python-kernel-to-pyodide-for-a-blazingly-fast-in-browser-coding-experience.json @@ -0,0 +1,27 @@ +{ + "description": "Full talk title: \"How to port a Python kernel to Pyodide for a blazingly fast in-browser coding experience\"\n\nPyodide 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.\n\nThis 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.\n\nThrough 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.\n\nNo 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.", + "duration": 1732, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/78/" + } + ], + "speakers": [ + "Myles Scolnick" + ], + "thumbnail_url": "https://i.ytimg.com/vi/Yt-DhlY7dFM/hqdefault.jpg", + "title": "How to port a Python kernel to Pyodide for a blazingly fast in-browser coding experience", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=Yt-DhlY7dFM" + } + ] +} diff --git a/pycon-us-2026/videos/how-to-write-a-great-command-line-application.json b/pycon-us-2026/videos/how-to-write-a-great-command-line-application.json new file mode 100644 index 000000000..f65d4053b --- /dev/null +++ b/pycon-us-2026/videos/how-to-write-a-great-command-line-application.json @@ -0,0 +1,27 @@ +{ + "description": "Command line applications are incredibly useful, and a well written one can be a joy to use. Fortunately, Python provides some powerful tools in the standard library, as well as the wider package ecosystem, that makes it easy to write great CLI tools that are a breeze to use as well as to test. In this talk, we will build up from sys.argv, cover the basics of how programs run on the terminal, and learn how to use the standard library's argparse with some some useful patterns to build a beautiful and useful command line application. We will then look at some of the third-party packages for building command line applications, and finally how to distribute your tool as a single file, even if it has external dependencies.", + "duration": 1638, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/165/" + } + ], + "speakers": [ + "Dan Craig" + ], + "thumbnail_url": "https://i.ytimg.com/vi/sflWQAxZV0U/hqdefault.jpg", + "title": "How to Write a Great Command Line Application", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=sflWQAxZV0U" + } + ] +} diff --git a/pycon-us-2026/videos/interoperabilidad-de-hardware-con-python-para-sistemas-conectados.json b/pycon-us-2026/videos/interoperabilidad-de-hardware-con-python-para-sistemas-conectados.json new file mode 100644 index 000000000..e350584be --- /dev/null +++ b/pycon-us-2026/videos/interoperabilidad-de-hardware-con-python-para-sistemas-conectados.json @@ -0,0 +1,30 @@ +{ + "description": "En un mundo lleno de dispositivos conectados, lograr que el hardware \"hable\" con los sistemas modernos sigue siendo sorprendentemente dif\u00edcil. 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\u00eda, sino de c\u00f3mo dise\u00f1amos la integraci\u00f3n.\n\nEsta charla muestra c\u00f3mo usar Python como capa unificadora entre hardware y sistemas conectados, mediante patrones concretos de interoperabilidad. Veremos c\u00f3mo pasar de se\u00f1ales f\u00edsicas desordenadas a un modelo de datos can\u00f3nico, validado y listo para ser consumido por servicios, dashboards o pipelines de datos.\n\nExploraremos tres ideas clave: - C\u00f3mo dise\u00f1ar un modelo can\u00f3nico en Python que represente lecturas de hardware de forma consistente. - C\u00f3mo construir \"protocol bridges\" que traduzcan entre UART/serial, MQTT o HTTP sin duplicar l\u00f3gica. - C\u00f3mo aplicar validaci\u00f3n y normalizaci\u00f3n cerca del dispositivo (validation at the edge) para detectar datos corruptos, incoherentes o peligrosos antes de que lleguen al sistema central.\n\nAcompa\u00f1aremos estos conceptos con una demo donde Python act\u00faa como intermediario entre un dispositivo f\u00edsico (o simulado) y un servicio conectado, mostrando logs, datos transformados y puntos de extensi\u00f3n.\n\nQuienes asistan saldr\u00e1n con patrones reutilizables, ejemplos claros y criterios para decidir cu\u00e1ndo usar cada enfoque, de modo que puedan integrar hardware en entornos modernos sin caer en soluciones fr\u00e1giles o dif\u00edciles de mantener.", + "duration": 1345, + "language": "spa", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/137/" + } + ], + "speakers": [ + "Hugo Leyton" + ], + "tags": [ + "charla" + ], + "thumbnail_url": "https://i.ytimg.com/vi/3ZUxodF3XUM/hqdefault.jpg", + "title": "Interoperabilidad de hardware con Python para sistemas conectados", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=3ZUxodF3XUM" + } + ] +} diff --git a/pycon-us-2026/videos/keynote-amanda-casari.json b/pycon-us-2026/videos/keynote-amanda-casari.json new file mode 100644 index 000000000..98450e265 --- /dev/null +++ b/pycon-us-2026/videos/keynote-amanda-casari.json @@ -0,0 +1,27 @@ +{ + "description": "In 2026, it can be harder than ever for someone in open source to leave their work at work at the end of the day. The future of open source, and technology as a whole, regularly makes news headlines \u2014 touching tough and potentially personal subjects such as technical ethics, intellectual property, and the value of volunteer labor.\n\nWhether you're a new contributor looking for a project to grow with, or a salty maintainer who still remembers shipping into production Python 2.anything, you might have asked: \"What am I actually building for anymore?\"\n\nAs part of a global Python community, how do we stay optimistic in times like these? How do we make space for hope for ourselves and with each other? In this talk, we'll examine how we can foster building for a collective future we may never see, but can still believe in.", + "duration": 1853, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/about/keynote-speakers/" + } + ], + "speakers": [ + "amanda casari" + ], + "thumbnail_url": "https://i.ytimg.com/vi/Z90Ax4SrhDQ/hqdefault.jpg", + "title": "Keynote - amanda casari", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=Z90Ax4SrhDQ" + } + ] +} diff --git a/pycon-us-2026/videos/keynote-pablo-galindo-salgado.json b/pycon-us-2026/videos/keynote-pablo-galindo-salgado.json new file mode 100644 index 000000000..31e1da6bb --- /dev/null +++ b/pycon-us-2026/videos/keynote-pablo-galindo-salgado.json @@ -0,0 +1,27 @@ +{ + "description": "PyCon US's first-ever Spanish keynote: Pablo Galindo Salgado!\n\nPablo Galindo Salgado works in the Python team of Hudson River Trading. He is a CPython core developer and a Theoretical Physicist specializing in general relativity and black hole physics. He is currently serving on the Python Steering Council in his 6th term and he is the release manager for Python 3.10 and 3.11. He has also a cat, but he does not code.\n\nPablo Galindo Salgado trabaja en el equipo de Python de Hudson River Trading. Es un core developer de CPython y f\u00edsico te\u00f3rico especializado en relatividad general y f\u00edsica de agujeros negros. Actualmente forma parte del Steering Council de Python en su sexto mandato y es release manager de Python 3.10 y 3.11. Tambi\u00e9n tiene un gato llamado BMO pero no programa.", + "duration": 2021, + "language": "spa", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/about/keynote-speakers/" + } + ], + "speakers": [ + "Pablo Galindo Salgado" + ], + "thumbnail_url": "https://i.ytimg.com/vi/e8uozuvRf7g/hqdefault.jpg", + "title": "Keynote - Pablo Galindo Salgado", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=e8uozuvRf7g" + } + ] +} diff --git a/pycon-us-2026/videos/lazy-imports-and-the-art-of-interpreter-procrastination.json b/pycon-us-2026/videos/lazy-imports-and-the-art-of-interpreter-procrastination.json new file mode 100644 index 000000000..ba2c31cc8 --- /dev/null +++ b/pycon-us-2026/videos/lazy-imports-and-the-art-of-interpreter-procrastination.json @@ -0,0 +1,27 @@ +{ + "description": "From CLI developers to maintainers of large applications, many Python developers have been bitten by the high overhead of eagerly loading imports. Long start-up times can make it prohibitively costly to run simple commands like --help, and the memory overhead from loading every imported module eagerly can trigger Out-Of-Memory errors in production.\n\nAfter the most discussed PEP thread in the history of discuss.python.org, with hundreds of messages and fierce debate, Python 3.15 finally brings Explicit Lazy Imports to the language. With a simple new keyword, you can now defer module loading until the moment you actually need it. This is one of the most requested performance features in Python's history, and finally it's here.\n\nThis presentation will take you through how we got here and where we're going. We'll look at why existing workarounds never quite worked, and how an earlier proposal (PEP 690) tried to make all imports lazy by default but was rejected. Then PEP 810 emerged with a different approach: explicit, opt-in syntax that the community accepted. You'll also learn about the future tooling that we are baking that will help you adopt this safely in your own projects.\n\nWhether you're a beginner curious about Python's future, someone looking to speed up your CLI tools, or you just want to understand what's happening under the hood, this talk will give you everything you need to start using lazy imports with confidence.", + "duration": 1821, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/176/" + } + ], + "speakers": [ + "Brittany Reynoso" + ], + "thumbnail_url": "https://i.ytimg.com/vi/6C1dPOeXOfU/hqdefault.jpg", + "title": "Lazy imports and the art of interpreter procrastination", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=6C1dPOeXOfU" + } + ] +} diff --git a/pycon-us-2026/videos/leading-without-permission-building-digital-diaspora-as-an-afro-latina-woman-in-tech.json b/pycon-us-2026/videos/leading-without-permission-building-digital-diaspora-as-an-afro-latina-woman-in-tech.json new file mode 100644 index 000000000..94d1068d5 --- /dev/null +++ b/pycon-us-2026/videos/leading-without-permission-building-digital-diaspora-as-an-afro-latina-woman-in-tech.json @@ -0,0 +1,27 @@ +{ + "description": "Full talk title: \"Leading Without Permission: Building Digital Diaspora as an Afro-Latina Woman in Tech\"\n\nDigital 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?\n\nIn 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.\n\nThe 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.\n\nThis talk is for anyone interested in community building, inclusive leadership, and how meaningful tech ecosystems can emerge from the Global South.", + "duration": 1514, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/132/" + } + ], + "speakers": [ + "Veronica Rodriguez Viveros" + ], + "thumbnail_url": "https://i.ytimg.com/vi/FMMdX9fpDkQ/hqdefault.jpg", + "title": "Leading Without Permission: Building Digital Diaspora as an Afro-Latina Woman in Tech", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=FMMdX9fpDkQ" + } + ] +} diff --git a/pycon-us-2026/videos/learning-computer-science-with-python-and-music-21.json b/pycon-us-2026/videos/learning-computer-science-with-python-and-music-21.json new file mode 100644 index 000000000..fd42c4b5b --- /dev/null +++ b/pycon-us-2026/videos/learning-computer-science-with-python-and-music-21.json @@ -0,0 +1,27 @@ +{ + "description": "Courses mixing computation and the arts or humanities are usually marketed as \u201capplied.\u201d 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?\n\nFor 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\u2019s pop. (And, of course, part of this talk will show how you can too!)\n\nPython\u2019s 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.\n\nBy 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.", + "duration": 1813, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/127/" + } + ], + "speakers": [ + "Michael Scott Asato Cuthbert" + ], + "thumbnail_url": "https://i.ytimg.com/vi/PhkGSj-KKD4/hqdefault.jpg", + "title": "Learning Computer Science with Python and Music(21)", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=PhkGSj-KKD4" + } + ] +} diff --git a/pycon-us-2026/videos/lightning-talks-friday-may-15-2026-pm.json b/pycon-us-2026/videos/lightning-talks-friday-may-15-2026-pm.json new file mode 100644 index 000000000..8b8173b98 --- /dev/null +++ b/pycon-us-2026/videos/lightning-talks-friday-may-15-2026-pm.json @@ -0,0 +1,35 @@ +{ + "description": "1:20: Evan Kohilas - How I Learned to Stop Worrying and Love Connecting\n5:15: Jon Gould - Tech Hiring has a Fraud Problem\n10:29: Amanda Lundberg - Captioning PyCon\n15:38: Aayush Gauba - Python and the future of quantum computing\n19:24: Camila Maia, Maria Antonia Maia - Cumbuca Dev\n25:01: Larry Gray - Giving AI Agents a Shared Place to Think\n34:01: Mike McGurrin - Hauntomation: Automating Halloween with Python\n38:47: Jack - Baby Boom: Using Python to Forecast Hospital Births\n43:27: Paul McGuire - re.sub simplified through decoratorification\n48:48: Seongsoo Cho - Growing Open Source Mentors\n54:09: Lex Scarisbrick - Testing + Spoof\n59:35: Leo Postovoit - If Physical Objects Had Python Tracebacks", + "duration": 4133, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + } + ], + "speakers": [ + "Evan Kohilas", + "Jon Gould", + "Amanda Lundberg", + "Aayush Gauba", + "Camila Maia", + "Maria Antonia Maia", + "Larry Gray", + "Mike McGurrin", + "Jack", + "Paul McGuire", + "Seongsoo Cho", + "Lex Scarisbrick", + "Leo Postovoit" + ], + "thumbnail_url": "https://i.ytimg.com/vi/m11iOY82-eo/hqdefault.jpg", + "title": "Lightning Talks - Friday May 15, 2026 PM", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=m11iOY82-eo" + } + ] +} diff --git a/pycon-us-2026/videos/lightning-talks-saturday-may-16-2026-pm.json b/pycon-us-2026/videos/lightning-talks-saturday-may-16-2026-pm.json new file mode 100644 index 000000000..e0f9ef739 --- /dev/null +++ b/pycon-us-2026/videos/lightning-talks-saturday-may-16-2026-pm.json @@ -0,0 +1,34 @@ +{ + "description": "09:00: Keith Murray - How to find Python near you\n04:17: Christopher Ariza - One Command to Find the Most Vulnerable Python Package on Your System\n09:19: Simon Willison - The last six months in LLMs in five minutes\n14:31: Ned Batchelder - Silence is Golden\n18:19: Eric Matthes - gh-profiler\n23:07: KwonHan Bae - Money, Money, Money: Running Python isn't Free\n27:50: Sophia - The Daisy Operator\n33:00: Jason McPheron - I Made a Gearbox Business Card, Then Made Python Explain It\n38:45: Jared Moreno - We All Live in a Python Submarine\n42:39: Gabriel dos Reis - The opossum-bility to win a bet\n48:16: S. Lott - DSL for Table-Top Role-Playing Games\n52:31: Ariel Ortiz - Less Code, More Fun: Building the Simplest Esoteric Language", + "duration": 3533, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + } + ], + "speakers": [ + "Keith Murray", + "Christopher Ariza", + "Simon Willison", + "Ned Batchelder", + "Eric Matthes", + "KwonHan Bae", + "Sophia", + "Jason McPheron", + "Jared Moreno", + "Gabriel dos Reis", + "S. Lott", + "Ariel Ortiz" + ], + "thumbnail_url": "https://i.ytimg.com/vi/VA3O7UxuZO4/hqdefault.jpg", + "title": "Lightning Talks - Saturday May 16, 2026 PM", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=VA3O7UxuZO4" + } + ] +} diff --git a/pycon-us-2026/videos/lock-free-multi-core-performance-with-behavior-oriented-concurrency.json b/pycon-us-2026/videos/lock-free-multi-core-performance-with-behavior-oriented-concurrency.json new file mode 100644 index 000000000..b30e3294a --- /dev/null +++ b/pycon-us-2026/videos/lock-free-multi-core-performance-with-behavior-oriented-concurrency.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nBOC 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.", + "duration": 1795, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/54/" + } + ], + "speakers": [ + "Matthew Johnson" + ], + "thumbnail_url": "https://i.ytimg.com/vi/LytoGIXLYkY/hqdefault.jpg", + "title": "Lock Free Multi Core Performance with Behavior Oriented Concurrency", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=LytoGIXLYkY" + } + ] +} diff --git a/pycon-us-2026/videos/logs-llanto-y-feature-flags-historias-de-codigo-en-modo-supervivencia.json b/pycon-us-2026/videos/logs-llanto-y-feature-flags-historias-de-codigo-en-modo-supervivencia.json new file mode 100644 index 000000000..d9c33821a --- /dev/null +++ b/pycon-us-2026/videos/logs-llanto-y-feature-flags-historias-de-codigo-en-modo-supervivencia.json @@ -0,0 +1,30 @@ +{ + "description": "Ser padre primerizo ya es un caos. Serlo mientras intentas mantener tu c\u00f3digo en pie\u2026 es otro tipo de runtime error. Como buen desarrollador, intent\u00e9 sobrevivir con datos: usaba una app para registrar el sue\u00f1o y las tomas del beb\u00e9. Pero una noche, justo cuando m\u00e1s la necesitaba, la app se colg\u00f3. Medio dormida y totalmente frustrada, decid\u00ed reescribirla en Python. Quer\u00eda algo que funcionara sin conexi\u00f3n, que no perdiera datos y que \u2014idealmente\u2014 fuera m\u00e1s estable que yo.\n\nEn esta charla exploraremos c\u00f3mo el caos cotidiano puede ense\u00f1arnos a construir software m\u00e1s resiliente. A partir de una mini app casera, veremos c\u00f3mo conceptos como caching, feature flags y recuperaci\u00f3n local pueden mantener con vida una app (y a su programador) en condiciones extremas.\n\nNo hace falta ser madre ni experta en sistemas distribuidos: alcanza con tener curiosidad y ganas de re\u00edrse un poco del desborde. Spoiler: al final, todo se trata de dise\u00f1ar para recuperarse, no de que nada falle", + "duration": 891, + "language": "spa", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/41/" + } + ], + "speakers": [ + "Laura Meng" + ], + "tags": [ + "charla" + ], + "thumbnail_url": "https://i.ytimg.com/vi/oYflWdKpXUE/hqdefault.jpg", + "title": "Logs, llanto y feature flags: historias de c\u00f3digo en modo supervivencia", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=oYflWdKpXUE" + } + ] +} diff --git a/pycon-us-2026/videos/making-python-faster-with-free-threading-and-mypyc.json b/pycon-us-2026/videos/making-python-faster-with-free-threading-and-mypyc.json new file mode 100644 index 000000000..5f6483190 --- /dev/null +++ b/pycon-us-2026/videos/making-python-faster-with-free-threading-and-mypyc.json @@ -0,0 +1,27 @@ +{ + "description": "It\u2019s common to hear complaints about Python being slow. In this talk, I will show how to make some Python programs dramatically faster by using Python 3.14\u2019s free threading and ahead-of-time compilation to C extensions using mypyc.\n\nFree threading can deliver large speedups for CPU-bound code that can be adapted for parallel execution, while mypyc speeds up workloads that benefit from reduced interpreter overhead and that use strict static typing. If each can give a 10\u00d7 speedup in an ideal use case, do we get a \u201choly grail\u201d 100\u00d7 improvement by combining them?\n\nI\u2019ll 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).\n\nAlong the way, I\u2019ll cover common bottlenecks that limit performance scaling and how to diagnose them, including allocation-heavy code and thread contention driven by reference counting.", + "duration": 2030, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/72/" + } + ], + "speakers": [ + "Jukka Lehtosalo" + ], + "thumbnail_url": "https://i.ytimg.com/vi/Y-ri74ZfGdo/hqdefault.jpg", + "title": "Making Python Faster with Free Threading and Mypyc", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=Y-ri74ZfGdo" + } + ] +} diff --git a/pycon-us-2026/videos/memory-management-in-cpython-fast-or-slow.json b/pycon-us-2026/videos/memory-management-in-cpython-fast-or-slow.json new file mode 100644 index 000000000..7cc3c5485 --- /dev/null +++ b/pycon-us-2026/videos/memory-management-in-cpython-fast-or-slow.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nMost Python developers know that CPython uses reference counting to determine when objects can be freed. But that\u2019s only one part of a much more intricate system. Behind the scenes, CPython must also:\n\n- Allocate memory for new objects quickly and efficiently\n- Return freed memory back to the system or to internal allocators for reuse\n- Detect and collect cyclic references, which reference counting alone cannot handle; CPython includes a dedicated cycle detector to ensure these objects are eventually freed\n\nIn this talk, I will:\n\n- Trace the lifetime of a Python object through the lens of memory management\n- Examine the time and space costs associated with each component of memory management\n- Highlight improvements made in recent CPython releases, and discuss future opportunities to further reduce these costs", + "duration": 1671, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/42/" + } + ], + "speakers": [ + "Mark Shannon" + ], + "thumbnail_url": "https://i.ytimg.com/vi/Cxv1ujO3izo/hqdefault.jpg", + "title": "Memory management in CPython, fast or slow?", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=Cxv1ujO3izo" + } + ] +} diff --git a/pycon-us-2026/videos/mind-the-gap-why-static-typing-requires-more-than-just-adding-annotations.json b/pycon-us-2026/videos/mind-the-gap-why-static-typing-requires-more-than-just-adding-annotations.json new file mode 100644 index 000000000..7a4015ba6 --- /dev/null +++ b/pycon-us-2026/videos/mind-the-gap-why-static-typing-requires-more-than-just-adding-annotations.json @@ -0,0 +1,28 @@ +{ + "description": "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!\n\nStatic 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.\n\nBut often we approach turning untyped code into statically typed code as if it\u2019s just a matter of adding annotations. This is rarely the case, and understanding why can help.\n\nPython 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:\n\nPervasive duck typing\nMetaprogramming and classes with dynamic behavior\nReliance on flow-sensitive type information that type checkers can\u2019t track\nUsing heterogeneous containers in ways the type system can\u2019t model\nWe\u2019ll explore these patterns, why they\u2019re 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.\n\nWe\u2019ll also look at how Python\u2019s type system has evolved to support more dynamic use cases, and possible future directions.\n\nWhat attendees will learn :\n- Historical context on Python before static types\n- Common challenges adding types to code whose semantics don\u2019t fit\n- Approaches for dealing with code that\u2019s difficult to statically type\n- Perspective on how the Python type system evolves to handle a wider range of patterns", + "duration": 1703, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/15/" + } + ], + "speakers": [ + "Jia Chen", + "Steven Troxler" + ], + "thumbnail_url": "https://i.ytimg.com/vi/zIUGND4Ubmo/hqdefault.jpg", + "title": "Mind the gap! Why static typing requires more than just adding annotations", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=zIUGND4Ubmo" + } + ] +} diff --git a/pycon-us-2026/videos/no-more-spreadsheets-building-pyladiescon-infrastructure-with-python-and-django.json b/pycon-us-2026/videos/no-more-spreadsheets-building-pyladiescon-infrastructure-with-python-and-django.json new file mode 100644 index 000000000..0706e1865 --- /dev/null +++ b/pycon-us-2026/videos/no-more-spreadsheets-building-pyladiescon-infrastructure-with-python-and-django.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nOne 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.\n\nWhile 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.\n\nIn 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.", + "duration": 2400, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/80/" + } + ], + "speakers": [ + "Mariatta" + ], + "thumbnail_url": "https://i.ytimg.com/vi/bU_6lovnre0/hqdefault.jpg", + "title": "No More Spreadsheets! Building PyLadiesCon Infrastructure with Python and Django", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=bU_6lovnre0" + } + ] +} diff --git a/pycon-us-2026/videos/panel-fostering-better-collaboration-between-the-scientific-python-community-and-core-python-development.json b/pycon-us-2026/videos/panel-fostering-better-collaboration-between-the-scientific-python-community-and-core-python-development.json new file mode 100644 index 000000000..d74fcfe49 --- /dev/null +++ b/pycon-us-2026/videos/panel-fostering-better-collaboration-between-the-scientific-python-community-and-core-python-development.json @@ -0,0 +1,29 @@ +{ + "description": "Full title: \"Panel: Fostering better collaboration between the scientific Python community and core Python development\"\n\nPresented by: Jonathan Dekhtiar, Dawn Wages, Michael Droettboom\n\nWe often think about \u201cthe Python Community\u201d 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.\n\nIn 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.\n\nSome of the topics we hope to cover are:\n\nHow can we create better communication structures so that the needs of the scientific Python ecosystem bubble up into core development decisions?\nHow 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?\nHow can the core team better signal long-term direction to downstream maintainers of major scientific Python libraries?\nHow can we make the community more welcoming to new members?\nWhat are the most effective ways to onboard and mentor new contributors to core and critical ecosystem projects?", + "duration": 2848, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/123/" + } + ], + "speakers": [ + "Jonathan Dekhtiar", + "Dawn Wages", + "Michael Droettboom" + ], + "thumbnail_url": "https://i.ytimg.com/vi/uitUsCAK9dY/hqdefault.jpg", + "title": "Panel: Fostering better collaboration between the scientific Python community and core Python development", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=uitUsCAK9dY" + } + ] +} diff --git a/pycon-us-2026/videos/pathlib-why-and-how-to-use-it.json b/pycon-us-2026/videos/pathlib-why-and-how-to-use-it.json new file mode 100644 index 000000000..eb6c0a660 --- /dev/null +++ b/pycon-us-2026/videos/pathlib-why-and-how-to-use-it.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nPython'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.\n\nDuring 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.\n\nBy the end of this talk, you'll be tempted to convert all your path-handling code to use pathlib.", + "duration": 1595, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/25/" + } + ], + "speakers": [ + "Trey Hunner" + ], + "thumbnail_url": "https://i.ytimg.com/vi/qU6mN3XENEY/hqdefault.jpg", + "title": "pathlib: why and how to use it", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=qU6mN3XENEY" + } + ] +} diff --git a/pycon-us-2026/videos/peeking-under-the-hood-of-uv-run.json b/pycon-us-2026/videos/peeking-under-the-hood-of-uv-run.json new file mode 100644 index 000000000..175121a17 --- /dev/null +++ b/pycon-us-2026/videos/peeking-under-the-hood-of-uv-run.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nIn 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\u2019ll also discuss how modern standards made uv possible, the practical challenges that remain, and new standards that would unlock further improvements.\n\nSome 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.", + "duration": 2338, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/77/" + } + ], + "speakers": [ + "Zanie Blue" + ], + "thumbnail_url": "https://i.ytimg.com/vi/gZiqURP5tbk/hqdefault.jpg", + "title": "Peeking under the hood of uv run", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=gZiqURP5tbk" + } + ] +} diff --git a/pycon-us-2026/videos/pep-750-t-strings-safer-and-smarter-string-processing.json b/pycon-us-2026/videos/pep-750-t-strings-safer-and-smarter-string-processing.json new file mode 100644 index 000000000..25b56f45a --- /dev/null +++ b/pycon-us-2026/videos/pep-750-t-strings-safer-and-smarter-string-processing.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nIn this presentation we\u2019ll 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\u2019ll also discuss some potential drawbacks and things to keep in mind about t-strings.\n\nThe 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.", + "duration": 1832, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/70/" + } + ], + "speakers": [ + "Vin\u00edcius Gubiani Ferreira" + ], + "thumbnail_url": "https://i.ytimg.com/vi/3OvmsETa7f8/hqdefault.jpg", + "title": "PEP 750 - T-strings: safer and smarter string processing", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=3OvmsETa7f8" + } + ] +} diff --git a/pycon-us-2026/videos/post-incident-runtime-sbom-generation-from-python-memory.json b/pycon-us-2026/videos/post-incident-runtime-sbom-generation-from-python-memory.json new file mode 100644 index 000000000..b5029e457 --- /dev/null +++ b/pycon-us-2026/videos/post-incident-runtime-sbom-generation-from-python-memory.json @@ -0,0 +1,28 @@ +{ + "description": "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\u2019s 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.", + "duration": 1932, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/104/" + } + ], + "speakers": [ + "Hala Ali", + "Andrew Case" + ], + "thumbnail_url": "https://i.ytimg.com/vi/mgY7zuDYrag/hqdefault.jpg", + "title": "Post Incident Runtime SBOM Generation from Python Memory", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=mgY7zuDYrag" + } + ] +} diff --git a/pycon-us-2026/videos/preflight-your-data-catch-hidden-issues-before-handoff.json b/pycon-us-2026/videos/preflight-your-data-catch-hidden-issues-before-handoff.json new file mode 100644 index 000000000..52a977aae --- /dev/null +++ b/pycon-us-2026/videos/preflight-your-data-catch-hidden-issues-before-handoff.json @@ -0,0 +1,27 @@ +{ + "description": "Handing over your dataset to another person is a key step in sharing your results. Often data looks fine but falls apart due to common issues like missing IDs, random date formats, broken links, and mixed vocabulary. Consistency and human review still matter and especially for foundational metadata. In this talk, I\u2019ll show a practical preflight built in Python: define a small set of rules, run them locally, and generate a report that real people can use to fix metadata quickly. We\u2019ll build a Markdown report with a summary table and failing-row examples. You\u2019ll see how to structure findings and produce an attachable preflight report you can use for data handoffs, pipeline outputs, or repository submissions.", + "duration": 1024, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/170/" + } + ], + "speakers": [ + "Jennifer Slotnick" + ], + "thumbnail_url": "https://i.ytimg.com/vi/3aavEybRzM0/hqdefault.jpg", + "title": "Preflight Your Data: Catch Hidden Issues Before Handoff", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=3aavEybRzM0" + } + ] +} diff --git a/pycon-us-2026/videos/psf-update-and-awards.json b/pycon-us-2026/videos/psf-update-and-awards.json new file mode 100644 index 000000000..f0e933ecd --- /dev/null +++ b/pycon-us-2026/videos/psf-update-and-awards.json @@ -0,0 +1,24 @@ +{ + "description": "Update on the work of the Python Software Foundation by PSF Executive Director, Deb Nicholson, followed by Community Service Awards. Lynn Root presents the PyLadies Awards ceremony.", + "duration": 1541, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + } + ], + "speakers": [ + "Deb Nicholson", + "Lynn Root" + ], + "thumbnail_url": "https://i.ytimg.com/vi/g8Q47_gXmoM/hqdefault.jpg", + "title": "PSF Update and Awards", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=g8Q47_gXmoM" + } + ] +} diff --git a/pycon-us-2026/videos/psf-update-from-our-security-engineers.json b/pycon-us-2026/videos/psf-update-from-our-security-engineers.json new file mode 100644 index 000000000..a81416242 --- /dev/null +++ b/pycon-us-2026/videos/psf-update-from-our-security-engineers.json @@ -0,0 +1,24 @@ +{ + "description": "Update from Python Software Foundation Security Engineers, Seth Michael Larson and Mike Fiedler", + "duration": 980, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + } + ], + "speakers": [ + "Seth Michael Larson", + "Mike Fiedler" + ], + "thumbnail_url": "https://i.ytimg.com/vi/PtMysG7aAO0/hqdefault.jpg", + "title": "PSF - Update from our Security Engineers", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=PtMysG7aAO0" + } + ] +} diff --git a/pycon-us-2026/videos/pycon-2026-closing-remarks.json b/pycon-us-2026/videos/pycon-2026-closing-remarks.json new file mode 100644 index 000000000..ca05e87c8 --- /dev/null +++ b/pycon-us-2026/videos/pycon-2026-closing-remarks.json @@ -0,0 +1,24 @@ +{ + "description": "The closing session of PyCon US 2026 by Conference Chair Elaine Wong and Co-Chair Jon Banafato. Followed by regional conference announcements and sprint introductions.", + "duration": 1796, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + } + ], + "speakers": [ + "Elaine Wong", + "Jon Banafato" + ], + "thumbnail_url": "https://i.ytimg.com/vi/4IxNnzHn_1o/hqdefault.jpg", + "title": "PyCon 2026 Closing Remarks", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=4IxNnzHn_1o" + } + ] +} diff --git a/pycon-us-2026/videos/python-a-la-velocidad-de-la-luz-un-recorrido-completo-por-el-ecosistema-de-cuda.json b/pycon-us-2026/videos/python-a-la-velocidad-de-la-luz-un-recorrido-completo-por-el-ecosistema-de-cuda.json new file mode 100644 index 000000000..92788e29b --- /dev/null +++ b/pycon-us-2026/videos/python-a-la-velocidad-de-la-luz-un-recorrido-completo-por-el-ecosistema-de-cuda.json @@ -0,0 +1,30 @@ +{ + "description": "Esta charla presentar\u00e1 una visi\u00f3n completa del ecosistema CUDA Python, mostrando c\u00f3mo Python tiene soporte de primera clase para programar GPUs de NVIDIA desde el runtime de bajo nivel hasta DSLs de alto nivel. Iremos m\u00e1s all\u00e1 de simplemente usar PyTorch para entrenar modelos de machine learning y exploraremos las diferentes capas del stack de CUDA entendiendo cu\u00e1ndo usar cada una para sacar el m\u00e1ximo provecho a una GPUs. Ideal para cient\u00edficos, ingenieros de datos, desarrolladores de ML, y cualquier pythonista que quiera aprovechar GPUs sin necesidad de aprender C++.\n\nExploraremos c\u00f3mo migrar c\u00f3digo NumPy a CuPy y c\u00f3mo acelerar bibliotecas de ciencias de datos como Pandas y Polars con RAPIDS para mover cargas de trabajo de CPU a la GPU. Tambi\u00e9n veremos c\u00f3mo escalar c\u00f3digo 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\u00f3n m\u00e1s accesible. Conocer\u00e1s nvmath-python, que te da acceso muchas bibliotecas optimizadas de CUDA-X con compilaci\u00f3n just-in-time y fusi\u00f3n de kernels autom\u00e1tica.\n\nTambi\u00e9n presentaremos un nuevo modelo de programaci\u00f3n: cuTile. Este te permite escribir c\u00f3digo 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\u00f3n de tensor cores sea tan natural como usar NumPy.\n\nVer\u00e1s casos de uso reales y saldr\u00e1s con recursos pr\u00e1cticos para empezar a acelerar tu c\u00f3digo hoy mismo.", + "duration": 2119, + "language": "spa", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/29/" + } + ], + "speakers": [ + "Daniel Rodriguez" + ], + "tags": [ + "charla" + ], + "thumbnail_url": "https://i.ytimg.com/vi/NxTzS3uQBO0/hqdefault.jpg", + "title": "Python a la velocidad de la luz: Un recorrido completo por el ecosistema de CUDA", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=NxTzS3uQBO0" + } + ] +} diff --git a/pycon-us-2026/videos/python-and-the-jvm-a-love-story.json b/pycon-us-2026/videos/python-and-the-jvm-a-love-story.json new file mode 100644 index 000000000..2a149a6a5 --- /dev/null +++ b/pycon-us-2026/videos/python-and-the-jvm-a-love-story.json @@ -0,0 +1,27 @@ +{ + "description": "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.", + "duration": 1636, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/38/" + } + ], + "speakers": [ + "Shir Havron" + ], + "thumbnail_url": "https://i.ytimg.com/vi/mtRjYEAuGZA/hqdefault.jpg", + "title": "Python and the JVM - A Love Story", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=mtRjYEAuGZA" + } + ] +} diff --git a/pycon-us-2026/videos/python-como-herramienta-de-movilidad-social-en-comunidades-afro-y-subrepresentadas.json b/pycon-us-2026/videos/python-como-herramienta-de-movilidad-social-en-comunidades-afro-y-subrepresentadas.json new file mode 100644 index 000000000..0ab356a08 --- /dev/null +++ b/pycon-us-2026/videos/python-como-herramienta-de-movilidad-social-en-comunidades-afro-y-subrepresentadas.json @@ -0,0 +1,30 @@ +{ + "description": "Full Charlas Title: Python como herramienta de movilidad social en comunidades afro y subrepresentadas\n\nPython es uno de los lenguajes de programaci\u00f3n m\u00e1s accesibles del mundo, pero su verdadero poder no est\u00e1 solo en su sintaxis sencilla o su ecosistema robusto, sino en su capacidad de abrir puertas donde hist\u00f3ricamente han existido barreras.\n\nEn esta charla comparto c\u00f3mo Python se ha convertido en una herramienta real de movilidad social para personas afrodescendientes y comunidades subrepresentadas en Colombia y Am\u00e9rica Latina, permitiendo el acceso a educaci\u00f3n tecnol\u00f3gica, empleos de calidad y liderazgo en la industria tech. A partir de experiencias concretas en programas comunitarios, talleres, mentor\u00edas y proyectos de formaci\u00f3n, explorar\u00e9 c\u00f3mo el aprendizaje de Python ha facilitado transiciones profesionales, creaci\u00f3n de oportunidades econ\u00f3micas y construcci\u00f3n de comunidades t\u00e9cnicas sostenibles.\n\nLa charla aborda los desaf\u00edos estructurales que enfrentan estas comunidades, desde la falta de acceso a educaci\u00f3n formal hasta la exclusi\u00f3n de redes profesionales globales, y c\u00f3mo el software libre y las comunidades Python pueden actuar como catalizadores de cambio cuando se dise\u00f1an con intenci\u00f3n y enfoque humano.", + "duration": 1519, + "language": "spa", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/76/" + } + ], + "speakers": [ + "Veronica Rodriguez Viveros" + ], + "tags": [ + "charla" + ], + "thumbnail_url": "https://i.ytimg.com/vi/R1oMrueI28U/hqdefault.jpg", + "title": "Python como herramienta de movilidad social en comunidades afro y subrepresentadas", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=R1oMrueI28U" + } + ] +} diff --git a/pycon-us-2026/videos/python-en-la-nube-introduccion-a-aws-con-boto3-alison-orellana.json b/pycon-us-2026/videos/python-en-la-nube-introduccion-a-aws-con-boto3-alison-orellana.json new file mode 100644 index 000000000..69eb0fa75 --- /dev/null +++ b/pycon-us-2026/videos/python-en-la-nube-introduccion-a-aws-con-boto3-alison-orellana.json @@ -0,0 +1,30 @@ +{ + "description": "\u00bfTe gustar\u00eda administrar tus recursos de AWS desde Python sin depender de la consola web?\n\nEn esta charla descubrir\u00e1s c\u00f3mo 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\u00f3mo se crean y administran instancias EC2, el trabajar con almacenamiento S3 e invocaci\u00f3n de funciones Lambda directamente desde c\u00f3digo. Conocer\u00e1s los pasos que se requieren para integrar Python en los flujos de DevOps y administraci\u00f3n en la nube, logrando procesos m\u00e1s eficientes, repetibles y escalables. La sesi\u00f3n est\u00e1 pensada para desarrolladores, DevOps, data engineers y entusiastas que quieran iniciar o fortalecer su camino en la nube utilizando Python.\n\nA lo largo de la presentaci\u00f3n, se cubrir\u00e1n conceptos clave como la creaci\u00f3n y gesti\u00f3n de instancias, almacenamiento, la automatizaci\u00f3n de funciones y la integraci\u00f3n de Python en procesos de DevOps.", + "duration": 1383, + "language": "spa", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/9/" + } + ], + "speakers": [ + "Alison Orellana-Rios" + ], + "tags": [ + "charla" + ], + "thumbnail_url": "https://i.ytimg.com/vi/lBw1ABtOqbw/hqdefault.jpg", + "title": "Python en la nube: Introducci\u00f3n a AWS con Boto3 - Alison Orellana", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=lBw1ABtOqbw" + } + ] +} diff --git a/pycon-us-2026/videos/python-for-humans-designing-python-code-like-a-user-interface.json b/pycon-us-2026/videos/python-for-humans-designing-python-code-like-a-user-interface.json new file mode 100644 index 000000000..cde0ce38d --- /dev/null +++ b/pycon-us-2026/videos/python-for-humans-designing-python-code-like-a-user-interface.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nMany 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.\n\nWe 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.\n\nTopics include: \u2022 Using top-level structure as layout to improve scannability \u2022 Treating naming like labeling to aid navigation and tool-assisted discovery \u2022 Using spacing and indentation to signal intent and grouping \u2022 Applying decorators and type hints to clarify usage without adding noise \u2022 Using tools like black, ruff, and Pylance as consistency and clarity enforcers \u2022 Knowing when to avoid cleverness in favor of long-term readability\n\nThis talk is about adopting a mindset. Treat your codebase like a user experience, and write Python you will not dread revisiting.", + "duration": 1781, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/142/" + } + ], + "speakers": [ + "Justin Lee" + ], + "thumbnail_url": "https://i.ytimg.com/vi/gDFlW_dMwZ4/hqdefault.jpg", + "title": "Python for Humans - Designing Python Code Like a User Interface", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=gDFlW_dMwZ4" + } + ] +} diff --git a/pycon-us-2026/videos/running-every-street-in-paris-with-python-and-postgis.json b/pycon-us-2026/videos/running-every-street-in-paris-with-python-and-postgis.json new file mode 100644 index 000000000..197f07c57 --- /dev/null +++ b/pycon-us-2026/videos/running-every-street-in-paris-with-python-and-postgis.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nWe'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.\n\nThis 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.", + "duration": 1941, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/108/" + } + ], + "speakers": [ + "Vinayak Mehta" + ], + "thumbnail_url": "https://i.ytimg.com/vi/wPSLip5CsRE/hqdefault.jpg", + "title": "Running Every Street in Paris with Python and PostGIS", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=wPSLip5CsRE" + } + ] +} diff --git a/pycon-us-2026/videos/running-large-language-models-on-laptops-practical-quantization-techniques-in-python.json b/pycon-us-2026/videos/running-large-language-models-on-laptops-practical-quantization-techniques-in-python.json new file mode 100644 index 000000000..3e98f9ead --- /dev/null +++ b/pycon-us-2026/videos/running-large-language-models-on-laptops-practical-quantization-techniques-in-python.json @@ -0,0 +1,27 @@ +{ + "description": "Full talk title: \"Running Large Language Models on Laptops: Practical Quantization Techniques in Python\"\n\nNote: \n00:00 - 03:20: A greeting from our AI Track Sponsors, NVIDIA and Anaconda\n03:24: Talk begins\n\nLarge 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.\n\nThis 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.\n\nThe 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.\n\nBy the end of the session, attendees will be able to:\n\nUnderstand when LLM quantization is appropriate\n\nChoose between common quantization formats and libraries\n\nRun LLMs locally on limited hardware using Python\n\nAvoid common pitfalls when moving from experimentation to deployment\n\nThis talk is aimed at Python developers who want to work with modern LLMs without relying exclusively on high-end infrastructure.", + "duration": 1743, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/138/" + } + ], + "speakers": [ + "Aayush Kumar JVS" + ], + "thumbnail_url": "https://i.ytimg.com/vi/CynFICT4BXk/hqdefault.jpg", + "title": "Running Large Language Models on Laptops: Practical Quantization Techniques in Python", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=CynFICT4BXk" + } + ] +} diff --git a/pycon-us-2026/videos/rust-for-cpython-making-python-safer-and-more-robust-for-everyone.json b/pycon-us-2026/videos/rust-for-cpython-making-python-safer-and-more-robust-for-everyone.json new file mode 100644 index 000000000..9c9943e3c --- /dev/null +++ b/pycon-us-2026/videos/rust-for-cpython-making-python-safer-and-more-robust-for-everyone.json @@ -0,0 +1,27 @@ +{ + "description": "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?\n\nThe 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.", + "duration": 1889, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/1/" + } + ], + "speakers": [ + "Emma Smith" + ], + "thumbnail_url": "https://i.ytimg.com/vi/42kibVnUHYE/hqdefault.jpg", + "title": "Rust for CPython: Making Python Safer and More Robust for Everyone", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=42kibVnUHYE" + } + ] +} diff --git a/pycon-us-2026/videos/switching-from-sphinx-to-markdown.json b/pycon-us-2026/videos/switching-from-sphinx-to-markdown.json new file mode 100644 index 000000000..010378d50 --- /dev/null +++ b/pycon-us-2026/videos/switching-from-sphinx-to-markdown.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nIn 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.", + "duration": 1925, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/6/" + } + ], + "speakers": [ + "Kattni" + ], + "thumbnail_url": "https://i.ytimg.com/vi/W8jmuJ1Ttmw/hqdefault.jpg", + "title": "Switching from Sphinx to Markdown", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=W8jmuJ1Ttmw" + } + ] +} diff --git a/pycon-us-2026/videos/tachyon-python-3-15-s-sampling-profiler-is-faster-than-your-code.json b/pycon-us-2026/videos/tachyon-python-3-15-s-sampling-profiler-is-faster-than-your-code.json new file mode 100644 index 000000000..74622e61c --- /dev/null +++ b/pycon-us-2026/videos/tachyon-python-3-15-s-sampling-profiler-is-faster-than-your-code.json @@ -0,0 +1,28 @@ +{ + "description": "Full talk title: \"Tachyon: Python 3.15's sampling profiler is faster than your code\"\n\nIn 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.\n\nThis 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.\n\nBut 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.\"\n\nWhether 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.", + "duration": 2055, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/31/" + } + ], + "speakers": [ + "Pablo Galindo Salgado", + "Laszlo Kiss Kollar" + ], + "thumbnail_url": "https://i.ytimg.com/vi/f1x4X83CDSA/hqdefault.jpg", + "title": "Tachyon: Python 3.15's sampling profiler is faster than your code", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=f1x4X83CDSA" + } + ] +} diff --git a/pycon-us-2026/videos/taking-generators-too-far-writing-a-pdf-from-scratch-in-python.json b/pycon-us-2026/videos/taking-generators-too-far-writing-a-pdf-from-scratch-in-python.json new file mode 100644 index 000000000..ae4c64706 --- /dev/null +++ b/pycon-us-2026/videos/taking-generators-too-far-writing-a-pdf-from-scratch-in-python.json @@ -0,0 +1,27 @@ +{ + "description": "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?\n\nHere's the twist: we'll use generators all the way down\u2014streaming 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 streaming.\n\nThis talk walks through the problem-solving journey step by step. You'll pick up practical techniques\u2014composing generators, managing dependencies in streaming pipelines, and knowing when \"too far\" is actually just far enough\u2014all while building something real. You'll also walk away with a surprising appreciation for what's inside every PDF you've ever opened.", + "duration": 1568, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/98/" + } + ], + "speakers": [ + "Arie Bovenberg" + ], + "thumbnail_url": "https://i.ytimg.com/vi/WqdUOt0TRP0/hqdefault.jpg", + "title": "Taking Generators Too Far: Writing a PDF from Scratch in Python", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=WqdUOt0TRP0" + } + ] +} diff --git a/pycon-us-2026/videos/the-art-of-extending-python-with-other-languages-cristian-maureira.json b/pycon-us-2026/videos/the-art-of-extending-python-with-other-languages-cristian-maureira.json new file mode 100644 index 000000000..8b37e2853 --- /dev/null +++ b/pycon-us-2026/videos/the-art-of-extending-python-with-other-languages-cristian-maureira.json @@ -0,0 +1,27 @@ +{ + "description": "The potential that Python has had since its origins, with its standard implementation written in C, has been demonstrated by the language's evolution, focused on calculations with the performance and precision necessary to be part of scientific projects that are revolutionizing different fields.\n\nBut how do extensions work? In this talk, we will look at how different programming languages offer the possibility of extending Python, and current cases to which its popularity can be attributed.\n\nPractical examples of extensions in C++ and Rust will be presented, mentioning other examples such as Zig. Additionally, the tools (\"binding generators\") that are currently available and are responsible for the development of many projects that you are probably using, perhaps without realizing it, will be presented.\n\nAfter this talk you will learn how to create Python extensions in a few languages.", + "duration": 1741, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/171/" + } + ], + "speakers": [ + "Cristi\u00e1n Maureira-Fredes" + ], + "thumbnail_url": "https://i.ytimg.com/vi/OIWzMcDNUh0/hqdefault.jpg", + "title": "The Art of Extending Python with other languages - Cristi\u00e1n Maureira", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=OIWzMcDNUh0" + } + ] +} diff --git a/pycon-us-2026/videos/the-art-of-live-process-manipulation-with-python-3-14-s-zero-overhead-debugging-interface.json b/pycon-us-2026/videos/the-art-of-live-process-manipulation-with-python-3-14-s-zero-overhead-debugging-interface.json new file mode 100644 index 000000000..d27e815ae --- /dev/null +++ b/pycon-us-2026/videos/the-art-of-live-process-manipulation-with-python-3-14-s-zero-overhead-debugging-interface.json @@ -0,0 +1,27 @@ +{ + "description": "Full title: \"The art of live process manipulation with Python 3.14's zero overhead debugging interface\"\n\nHave 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?\n\nIn this talk, I'll show you why sys.remote_exec() is one of the coolest features of Python 3.14! I'll cover the basics of Python's new remote debugging capabilities and demonstrate how sys.remote_exec() can be combined with debugpy (an implementation of the Debug Adapter Protocol) to provide full IDE debugging experiences for live processes. I'll share what I learned building a tool that uses these primitives to attach debuggers to FastAPI applications running in local Kubernetes clusters.\n\nBeyond debugging, we'll explore other use cases for sys.remote_exec() and how you can apply the feature to solve problems in your own work!", + "duration": 1480, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/67/" + } + ], + "speakers": [ + "Savannah Ostrowski" + ], + "thumbnail_url": "https://i.ytimg.com/vi/CnDFc4azdbU/hqdefault.jpg", + "title": "The art of live process manipulation with Python 3.14's zero-overhead debugging interface", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=CnDFc4azdbU" + } + ] +} diff --git a/pycon-us-2026/videos/the-bakery-how-pep810-sped-up-my-bread-operations-business.json b/pycon-us-2026/videos/the-bakery-how-pep810-sped-up-my-bread-operations-business.json new file mode 100644 index 000000000..1823dee4a --- /dev/null +++ b/pycon-us-2026/videos/the-bakery-how-pep810-sped-up-my-bread-operations-business.json @@ -0,0 +1,27 @@ +{ + "description": "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:\n\n- ?\u00d7 faster --help command execution\n- ?% reduction in baseline memory usage\n- Clear before/after comparisons using industry-standard benchmarking tools\n\nIdeal 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.", + "duration": 1501, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/30/" + } + ], + "speakers": [ + "Jacob Coffee" + ], + "thumbnail_url": "https://i.ytimg.com/vi/BdSne37enK4/hqdefault.jpg", + "title": "The Bakery: How PEP810 sped up my bread operations business", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=BdSne37enK4" + } + ] +} diff --git a/pycon-us-2026/videos/the-exceptions-we-don-t-catch-in-technical-conversations.json b/pycon-us-2026/videos/the-exceptions-we-don-t-catch-in-technical-conversations.json new file mode 100644 index 000000000..1148aa9eb --- /dev/null +++ b/pycon-us-2026/videos/the-exceptions-we-don-t-catch-in-technical-conversations.json @@ -0,0 +1,27 @@ +{ + "description": "\"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.\n\nDo 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.\n\nIf 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.\n\nI 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.", + "duration": 2146, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/40/" + } + ], + "speakers": [ + "Emin Martinian" + ], + "thumbnail_url": "https://i.ytimg.com/vi/595G7p1JjCE/hqdefault.jpg", + "title": "The Exceptions We Don't Catch in Technical Conversations", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=595G7p1JjCE" + } + ] +} diff --git a/pycon-us-2026/videos/the-surprising-effectiveness-of-immutable-data-structures.json b/pycon-us-2026/videos/the-surprising-effectiveness-of-immutable-data-structures.json new file mode 100644 index 000000000..f75676a4c --- /dev/null +++ b/pycon-us-2026/videos/the-surprising-effectiveness-of-immutable-data-structures.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nThis 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.", + "duration": 2449, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/115/" + } + ], + "speakers": [ + "Brett Slatkin" + ], + "thumbnail_url": "https://i.ytimg.com/vi/5OElk7Oend0/hqdefault.jpg", + "title": "The Surprising Effectiveness of Immutable Data Structures", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=5OElk7Oend0" + } + ] +} diff --git a/pycon-us-2026/videos/the-terminal-is-the-new-browser-building-rich-tuis-with-textual.json b/pycon-us-2026/videos/the-terminal-is-the-new-browser-building-rich-tuis-with-textual.json new file mode 100644 index 000000000..f32195383 --- /dev/null +++ b/pycon-us-2026/videos/the-terminal-is-the-new-browser-building-rich-tuis-with-textual.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nIn 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.", + "duration": 1509, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/103/" + } + ], + "speakers": [ + "Andres Pineda" + ], + "thumbnail_url": "https://i.ytimg.com/vi/xYRDhr8zv4I/hqdefault.jpg", + "title": "The Terminal is the New Browser: Building Rich TUIs with Textual", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=xYRDhr8zv4I" + } + ] +} diff --git a/pycon-us-2026/videos/thinking-of-topic-modeling-as-search.json b/pycon-us-2026/videos/thinking-of-topic-modeling-as-search.json new file mode 100644 index 000000000..a5d4af919 --- /dev/null +++ b/pycon-us-2026/videos/thinking-of-topic-modeling-as-search.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nPython packages and extensions to commonly used databases that now support dense vectors, have made this approach viable \u2014and relatively easy to implement\u2014 in most production environments.\n\nIn 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.\n\nKey concepts\n- Embeddings - quick introduction (or refresher, for those familiar)\n- How to convert sentence embeddings into document embeddings and ultimately topic embeddings.\n- How to generate topic embeddings (using LLMs, supervised models or unsupervised models)\n- How to store topic embeddings on popular databases to enable search\n- How to retrieve current documents related to a topic using search queries and cosine similarity \u2014 without tagging documents.\n\nBenefits of this approach\n- Simplify and improve performance for storing and retrieving documents related to a topic\n- Capture fast-moving, evolving conversations\n- Allow user-generated topics (personalization)\n- Anticipate topics that don\u2019t yet exist\n- No need to maintain document \"tags\"\n\nAudience\n- Intermediate Python developers interested in NLP and search technologies\n- Practitioners building search, recommendation, or semantic discovery systems\n- Anyone curious about combining classic topic modeling with modern vector search architectures\n\nNo prior experience with vector search is required. Familiarity with Python and basic NLP concepts is helpful.", + "duration": 1721, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/5/" + } + ], + "speakers": [ + "Kas Stohr" + ], + "thumbnail_url": "https://i.ytimg.com/vi/jtva4oiJ-lk/hqdefault.jpg", + "title": "Thinking of Topic Modeling as Search", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=jtva4oiJ-lk" + } + ] +} diff --git a/pycon-us-2026/videos/upgrading-python-clis-from-scripts-to-interactive-tools.json b/pycon-us-2026/videos/upgrading-python-clis-from-scripts-to-interactive-tools.json new file mode 100644 index 000000000..f9a4341de --- /dev/null +++ b/pycon-us-2026/videos/upgrading-python-clis-from-scripts-to-interactive-tools.json @@ -0,0 +1,27 @@ +{ + "description": "Audience\nThis 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.\n\nObjective\nAttendees 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.\n\nDetails\nWell 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.\n\nWe 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.", + "duration": 1994, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/141/" + } + ], + "speakers": [ + "Avik Basu" + ], + "thumbnail_url": "https://i.ytimg.com/vi/lVIPEjDVTME/hqdefault.jpg", + "title": "Upgrading Python CLIs From Scripts to Interactive Tools", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=lVIPEjDVTME" + } + ] +} diff --git a/pycon-us-2026/videos/using-python-biopharm-to-help-cure-cancer.json b/pycon-us-2026/videos/using-python-biopharm-to-help-cure-cancer.json new file mode 100644 index 000000000..ed488e655 --- /dev/null +++ b/pycon-us-2026/videos/using-python-biopharm-to-help-cure-cancer.json @@ -0,0 +1,27 @@ +{ + "description": "Cancer research produces enormous volumes of data \u2014 experiments, manufacturing runs, quality investigations, and clinical outcomes. Yet the hardest problems aren\u2019t about scale or storage. They\u2019re about context: understanding how decisions, processes, and data points connect when human lives are on the line.\n\nIn this talk, I\u2019ll share how I used Python to build systems that help scientists and engineers reason about cancer therapies in development \u2014 not through dashboards alone, but through connected data and conversational interfaces that answer meaningful, qualitative questions.\n\nYou\u2019ll see how FastAPI and Pydantic enable strongly typed, auditable APIs suitable for regulated environments, and how knowledge graphs can model biological, manufacturing, and operational relationships as a living graph. On top of this foundation, we built chat-based interfaces that don\u2019t just retrieve documents, but traverse relationships, surface patterns, and explain why something happened \u2014 enabling questions like \u201cWhat changed?\u201d, \u201cWhere have we seen this before?\u201d, and \u201cWhat decisions led us here?\u201d\n\nThis is not a hype-driven AI talk. It\u2019s a practical, production-focused story about Python used where correctness matters, trust must be earned, and failure has real consequences. It\u2019s also a reminder that Python\u2019s greatest strength isn\u2019t just speed of development \u2014 it\u2019s its ability to bring clarity to complex, human problems.\n\nIf you\u2019re interested in Python beyond demos \u2014 in systems that inform decisions and meaningfully impact people\u2019s lives \u2014 this talk is for you.", + "duration": 1520, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/109/" + } + ], + "speakers": [ + "Sushant Singh" + ], + "thumbnail_url": "https://i.ytimg.com/vi/iZUIaGjzFTs/hqdefault.jpg", + "title": "Using Python Biopharm to Help Cure Cancer", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=iZUIaGjzFTs" + } + ] +} diff --git a/pycon-us-2026/videos/welcome-to-pycon-us-2026.json b/pycon-us-2026/videos/welcome-to-pycon-us-2026.json new file mode 100644 index 000000000..16ac877fa --- /dev/null +++ b/pycon-us-2026/videos/welcome-to-pycon-us-2026.json @@ -0,0 +1,24 @@ +{ + "description": "Welcome to PyCon US 2026, from Conference Chair, Elaine Wong and Python Software Foundation Executive Director, Deb Nicholson", + "duration": 2706, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + } + ], + "speakers": [ + "Elaine Wong", + "Deb Nicholson" + ], + "thumbnail_url": "https://i.ytimg.com/vi/44MweJvxJF0/hqdefault.jpg", + "title": "Welcome to PyCon US 2026", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=44MweJvxJF0" + } + ] +} diff --git a/pycon-us-2026/videos/what-python-developers-need-to-know-about-hardware-a-practical-guide-to-gpu-memory-kernel-scheduling-and-execution-models.json b/pycon-us-2026/videos/what-python-developers-need-to-know-about-hardware-a-practical-guide-to-gpu-memory-kernel-scheduling-and-execution-models.json new file mode 100644 index 000000000..595af30b2 --- /dev/null +++ b/pycon-us-2026/videos/what-python-developers-need-to-know-about-hardware-a-practical-guide-to-gpu-memory-kernel-scheduling-and-execution-models.json @@ -0,0 +1,28 @@ +{ + "description": "Full talk title: \"What Python Developers Need to Know About Hardware: A Practical Guide to GPU Memory, Kernel Scheduling, and Execution Models\"\n\nPython developers building machine learning models often interact with GPUs \u201cindirectly\u201d through frameworks like PyTorch, TensorFlow, and JAX. Because these frameworks abstract away low-level behavior, it\u2019s easy to assume that GPU execution works like CPU execution\u2014deterministic, 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.\n\nThis talk offers a practical, developer-friendly introduction to the hardware concepts that directly impact Python-based AI workloads. You don\u2019t 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.\n\nWe 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\u2019ll connect these concepts to real examples in PyTorch and TensorFlow, demonstrating how awareness of hardware behavior can improve performance, stability, and debugging outcomes.\n\nThe 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.", + "duration": 2016, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/81/" + } + ], + "speakers": [ + "Santosh Appachu Devanira Poovaiah", + "Vyas Ramasubramani" + ], + "thumbnail_url": "https://i.ytimg.com/vi/P8P4lHzlUMU/hqdefault.jpg", + "title": "What Python Developers Need to Know About Hardware: A Practical Guide to GPU Memory, Kernel Scheduling, and Execution Models", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=P8P4lHzlUMU" + } + ] +} diff --git a/pycon-us-2026/videos/what-s-so-hard-about-writing-a-type-checker-a-tour-of-ty.json b/pycon-us-2026/videos/what-s-so-hard-about-writing-a-type-checker-a-tour-of-ty.json new file mode 100644 index 000000000..b0acffecd --- /dev/null +++ b/pycon-us-2026/videos/what-s-so-hard-about-writing-a-type-checker-a-tour-of-ty.json @@ -0,0 +1,27 @@ +{ + "description": "You've probably used a Python type checker or language server\u2014but 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) \u2014 and keep it all running snappily.\n\nAn 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.", + "duration": 2793, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/143/" + } + ], + "speakers": [ + "Carl Meyer" + ], + "thumbnail_url": "https://i.ytimg.com/vi/0Wo1eGjfQxw/hqdefault.jpg", + "title": "What's so hard about writing a type checker? A tour of ty", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=0Wo1eGjfQxw" + } + ] +} diff --git a/pycon-us-2026/videos/where-the-sidewalk-ends-data-driven-urban-safety.json b/pycon-us-2026/videos/where-the-sidewalk-ends-data-driven-urban-safety.json new file mode 100644 index 000000000..2ad8598eb --- /dev/null +++ b/pycon-us-2026/videos/where-the-sidewalk-ends-data-driven-urban-safety.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nThe 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\u2019s 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.\n\nUsing 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.\n\nI 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\u2019ll 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.", + "duration": 1076, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/124/" + } + ], + "speakers": [ + "Fay Shaw" + ], + "thumbnail_url": "https://i.ytimg.com/vi/QxK_rRrquBM/hqdefault.jpg", + "title": "Where the Sidewalk Ends Data Driven Urban Safety", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=QxK_rRrquBM" + } + ] +} diff --git a/pycon-us-2026/videos/why-software-engineering-best-practices-fail-in-data-engineering.json b/pycon-us-2026/videos/why-software-engineering-best-practices-fail-in-data-engineering.json new file mode 100644 index 000000000..ff88ef199 --- /dev/null +++ b/pycon-us-2026/videos/why-software-engineering-best-practices-fail-in-data-engineering.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nBut here's the problem: It doesn't work.\n\nWhen 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.\n\nData 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.\n\nSoftware engineering practices fail in data engineering because the causality is reversed, and no amount of \"doing it better\" will change that.\n\nThis 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.\n\nIf you've ever felt like you're \"doing software engineering wrong\" because your data pipelines still break, this talk will reframe everything.", + "duration": 1517, + "language": "eng", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/94/" + } + ], + "speakers": [ + "Constance Martineau" + ], + "thumbnail_url": "https://i.ytimg.com/vi/EFB4fZuWGUc/hqdefault.jpg", + "title": "Why Software Engineering Best Practices Fail in Data Engineering", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=EFB4fZuWGUc" + } + ] +} diff --git a/pycon-us-2026/videos/why-you-as-a-python-developer-should-learn-rust.json b/pycon-us-2026/videos/why-you-as-a-python-developer-should-learn-rust.json new file mode 100644 index 000000000..f211b9e54 --- /dev/null +++ b/pycon-us-2026/videos/why-you-as-a-python-developer-should-learn-rust.json @@ -0,0 +1,27 @@ +{ + "description": "In this talk, I will introduce the Rust programming language from a Python developer\u2019s perspective. We will explore some of Rust\u2019s 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\u2019s 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.", + "duration": 1592, + "language": "eng", + "recorded": "2026-05-17", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/88/" + } + ], + "speakers": [ + "Daniel Szoke" + ], + "thumbnail_url": "https://i.ytimg.com/vi/lkSxUIdP6Ds/hqdefault.jpg", + "title": "Why you, as a Python developer, should learn Rust", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=lkSxUIdP6Ds" + } + ] +} diff --git a/pycon-us-2026/videos/yes-you-can-test-sql.json b/pycon-us-2026/videos/yes-you-can-test-sql.json new file mode 100644 index 000000000..34ed36d26 --- /dev/null +++ b/pycon-us-2026/videos/yes-you-can-test-sql.json @@ -0,0 +1,27 @@ +{ + "description": "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.", + "duration": 2226, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/64/" + } + ], + "speakers": [ + "Paul Zuradzki" + ], + "thumbnail_url": "https://i.ytimg.com/vi/bQLN9PIo_rs/hqdefault.jpg", + "title": "Yes, You Can Test SQL", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=bQLN9PIo_rs" + } + ] +} diff --git a/pycon-us-2026/videos/zero-trust-in-200ms-implementing-identity-per-transaction-with-python-and-serverless.json b/pycon-us-2026/videos/zero-trust-in-200ms-implementing-identity-per-transaction-with-python-and-serverless.json new file mode 100644 index 000000000..936d8c6c0 --- /dev/null +++ b/pycon-us-2026/videos/zero-trust-in-200ms-implementing-identity-per-transaction-with-python-and-serverless.json @@ -0,0 +1,27 @@ +{ + "description": "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.\n\nThis 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.\n\nAttendees will learn: \n- 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\u2014and destroys it milliseconds later.\n- 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. \n- Audit-Ready Logging: Techniques for structuring Python's logging module to produce immutable, auditor-friendly JSON trails that prove compliance without leaking sensitive data. \n\nJoin us to see how we replaced static service accounts with ephemeral Python logic to solve the \"Non-Human Identity\" crisis in high-stakes environments.", + "duration": 1538, + "language": "eng", + "recorded": "2026-05-16", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/140/" + } + ], + "speakers": [ + "Tristan McKinnon" + ], + "thumbnail_url": "https://i.ytimg.com/vi/WOOlzsJx9cg/hqdefault.jpg", + "title": "Zero Trust in 200ms: Implementing Identity-Per-Transaction with Python and Serverless", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=WOOlzsJx9cg" + } + ] +} diff --git a/pycon-us-2026/videos/zonas-horarias-en-python-todo-lo-que-ojala-no-necesitases.json b/pycon-us-2026/videos/zonas-horarias-en-python-todo-lo-que-ojala-no-necesitases.json new file mode 100644 index 000000000..e763322d5 --- /dev/null +++ b/pycon-us-2026/videos/zonas-horarias-en-python-todo-lo-que-ojala-no-necesitases.json @@ -0,0 +1,30 @@ +{ + "description": "Las zonas horarias son muy complejas, pero son una realidad inevitable en ingenier\u00eda. Algunas zonas horarias han llegado a saltarse d\u00edas enteros y repetirse otros. Hay zonas horarias que se cambian a DST dos veces al a\u00f1o. Pero no necesariamente cada a\u00f1o. En Python, es posible hasta crear datetimes con igualdad no transitiva (a == b, b == c, a != c).\n\nEn 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\u00f3dulo zoneinfo introducido en Python 3.9, cubrimos como lidiar con tiempos ambiguos e imaginarios, aritm\u00e9tica de datetimes cerca de una transici\u00f3n de horario de verano, y que significa el atributo fold.", + "duration": 1684, + "language": "spa", + "recorded": "2026-05-15", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://us.pycon.org/2026/" + }, + { + "label": "Presentation Webpage", + "url": "https://us.pycon.org/2026/schedule/presentation/39/" + } + ], + "speakers": [ + "Paul Ganssle" + ], + "tags": [ + "charla" + ], + "thumbnail_url": "https://i.ytimg.com/vi/Evrrzmo_ZMs/hqdefault.jpg", + "title": "Zonas Horarias en Python: Todo lo que ojal\u00e1 no necesitases", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=Evrrzmo_ZMs" + } + ] +}