Programa

...

Participants will learn how to design and simulate a quantum algorithm directly from their laptops. Quantum algorithms utilize the power of quantum physics to perform certain tasks significantly faster than traditional algorithms. Using QiliSDK, an open-source Python framework developed by Qilimanjaro from Barcelona, we’ll demonstrate how easy it is to start building and experimenting as a quantum developer.

Large Language Models are confidently wrong more often than most users realize. When an LLM says "Napoleon was born in 1765" with the same confidence as "Paris is the capital of France," users have no way to tell the difference. This is called hallucination, and it is one of the most pressing problems in production AI systems. In this workshop, we build a hallucination detection system in Python from scratch. The core idea is simple: ask the LLM the same question multiple times and measure how much the answers disagree. But we go further than existing approaches by combining four different uncertainty signals (self-consistency, semantic entropy, logit calibration, and NLI-based contradiction checking) and introducing "uncertainty fingerprinting" -- a novel method that classifies hallucinations into distinct types based on the pattern across these signals. We demonstrate that not all hallucinations are the same. A "knowledge gap" (the model clearly guessing) is easy to catch. A "confident fabrication" (the model consistently producing the same wrong answer) is dangerous because every standard detector misses it. Different types need different responses: abstaining, flagging for verification, or answering with a warning. Using Mistral-7B, HuggingFace Transformers, DeBERTa-MNLI, and scikit-learn, we walk through the full pipeline -- from sampling multiple LLM responses, to clustering answers by meaning, to building an adaptive response policy that improved accuracy from 76.5% to 93.9% on TriviaQA. Attendees will leave with working Python code and a Gradio demo they can adapt to their own LLM applications. No prior experience with hallucination detection is required. Familiarity with Python and basic ML concepts (what a model is, what inference means) is sufficient.

In this tutorial, we'll discuss how to build the basic components that make up a modern digital synth from scratch using Python. In the process, learn some DSP and audio programming concepts. By the end, you’ll be able to define your own synthesizer make music with code!! This tutorial aims to break down the abstractions that make up a synthesizer by building one using Python, its scientific computing libraries, & Librosa. We will discuss how to build the basic components that make up a modern digital synth from scratch! In the process, learn some DSP and audio programming concepts! By the end, you’ll be able to make your own tunes with Python! We will start with theory, then work through Jupyter notebooks both individually and as a group.

En los últimos años hemos visto un progreso extraordinario en las herramientas para empaquetar código Python reutilizable. Empaquetar aplicaciones requiere más esfuerzo, pero gracias a avances recientes es más fácil que nunca. ¿Será este el año en el que empaquetes tu aplicación Python para el escritorio Linux? En este taller aprenderás cómo usar técnicas y herramientas modernas de paquetería en Python, y aplicarás algunas de ellas a una aplicación sencilla. Gracias a herramientas modernas como uv y maturin podrás crear artefactos Python de manera sencilla, y con Snapcraft y Briefcase podrás empaquetarlos en diferentes formatos como .deb, AppImage, Flatpak, y Snap. Para hacer todo más interesante, incluiremos algo de código Rust también que habrá que compilar.

...

El matemático Grant Sanderson creó la librería Manim para poder crear animaciones para su canal de YouTube 3B1B en el que explica conceptos matemáticos de lo más variados. Con el tiempo, surgió una versión mantenida por la comunidad llamada ManimCE que hoy en día es usada por miles de divulgadores en todo el mundo para crear animaciones sencillas de crear pero muy potentes y vistosas. En este taller aprenderemos lo básico para poder hacer animaciones con ManimCE que cautiven a nuestra audiencia con simple código python.

You’ve likely used a tool like `black`, `flake8`, or `ruff` to lint or format your code, or a tool like `sphinx` to document it, but you probably do not know how they accomplish their tasks. These tools and many more use **Abstract Syntax Trees (ASTs)** to analyze and extract information from Python code. An AST is a representation of your code's structure that enables you to access and manipulate its different components, which is what makes it possible to automate tasks like code migrations, linting, and docstring extraction. In this workshop, you’ll learn how to use the Python standard library’s `ast` module to parse and analyze code. Using just the standard library, we will implement a couple of common checks from scratch, which will give you an idea of how these tools work and help you build the skills and confidence to use ASTs in your own projects.

Calling Rust from Python with PyO3 and Maturin Rust lets us Python developers accelerate performance-critical code without giving up the language we love. This hands-on workshop introduces participants to building native Python extensions in Rust using PyO3 and Maturin. Attendees will learn how to expose Rust functions and data structures directly to Python, package them as installable modules, and integrate them into existing Python projects. The workshop covers: Setting up a Rust-powered Python extension project Writing and exposing Rust functions to Python Handling Python types and memory safely in Rust Building and distributing wheels with Maturin Benchmarking Rust extensions against pure Python implementations Practical patterns for incrementally optimizing Python applications with Rust Integrating all this in your CI pipeline (using Docker). By the end of the session, participants will have built and packaged a working Python extension module in Rust and gained a practical understanding of when and how to use Rust for Python interoperability. Target Audience Intermediate Python developers interested in performance optimization, systems programming, or native extensions. Prior Rust experience is helpful but not required.

LangGraph permite construir agentes controlables y mantenibles, pero su verdadero potencial aparece cuando lo combinamos con sistemas de conocimiento y recuperación de información. En este taller práctico construiremos paso a paso un agente utilizando Python y LangGraph, empezando desde un grafo básico hasta llegar a un sistema capaz de consultar conocimiento externo (RAG) y evolucionar con el uso. A lo largo de la sesión, los asistentes aprenderán a modelar estado, definir nodos y controlar el flujo de ejecución. Sobre esta base, añadiremos un sistema de recuperación híbrido que permitirá al agente acceder a información relevante en tiempo real. Finalmente, exploraremos cómo introducir mecanismos de “aprendizaje” en el agente, permitiéndole almacenar nuevo conocimiento y reutilizarlo en futuras interacciones. Al final del taller, los asistentes: - Entenderán cómo construir agentes con LangGraph desde cero - Sabrán integrar RAG de forma estructurada (más allá de ejemplos simples) - Verán cómo diseñar agentes que evolucionan mediante conocimiento persistente - Tendrán una base sólida para construir sistemas reales en producción Este taller está orientado a desarrolladores con conocimientos básicos de Python interesados en sistemas de IA aplicada.

...

From CLI developers to maintainers of large applications, many Python developers have been bitten by the high overhead of eagerly loading imports. Long start-up times can make it prohibitively costly to run simple commands like --help, and the memory overhead from loading every imported module eagerly can trigger Out-Of-Memory errors in production. After the most discussed PEP thread in the history of discuss.python.org, with hundreds of messages and fierce debate, Python 3.15 finally brings Explicit Lazy Imports to the language. With a simple new keyword, you can now defer module loading until the moment you actually need it. This is one of the most requested performance features in Python's history, and finally it's here. This 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. The heart of this talk is discovering how lazy imports actually work inside the interpreter. We'll trace through the implementation, see how proxy objects stand in for unloaded modules, and watch the moment when your code first touches a lazy import and the real module snaps into place. You'll also learn about the future tooling that we are baking that will help you adopt this safely in your own projects. Whether 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.

¿Sabías que compartes el 99,9% de tu ADN con cualquier persona… y que el 0,1% restante hace que un fármaco te funcione bien y a esa persona no, o que tengas más predisposición a ciertas enfermedades? En esta charla hablaremos de la medicina personalizada, que se centra en ese 0.1% de tu ADN para predecir efectos de tratamientos y anticipar patologías. Además, haremos una demo práctica con Python analizando los datos genéticos de una paciente. Con esto veremos cómo la medicina personalizada puede revolucionar la clínica, previniendo enfermedades antes de que aparezcan y encontrando el tratamiento más apropiado en cada caso.

De Contributor a Maintainer es una charla que recorre el camino que los desarrolladores transitan en el mundo del open source: desde animarse a abrir ese primera pull request con algo de miedo e incertidumbre, hasta convertirse en la persona responsable de mantener un proyecto vivo, tomar decisiones de diseño y gestionar una comunidad. Compartiremos lecciones aprendidas en carne propia sobre cómo comunicarse efectivamente en entornos asincrónicos, cómo crear un code review diferente, y qué cambia fundamentalmente en la mentalidad cuando dejas de ser quien propone cambios y pasas a ser quien decide qué entra y qué no. No es una guía de pasos perfectos, sino una mirada honesta a los patrones, los errores y las preguntas que uno aprende a hacerse cuando el software que mantienes ha de ser usado por otros. Pasaremos por proyectos internacionales de Deepmind o la libreria de Hugginface Transformers hasta paquetes de la comunidad de Python Málaga como pip-rating, llegando a la libreria de entrenamiento de robots Odyssey.

La industria entera escribe sobre cómo escalar a millones de usuarios por segundo. Pero la mayoría de los sistemas que efectivamente corren en producción no son ese sistema. Son aplicaciones chicas, usadas por cientos o miles de personas, que aún así son críticas: porque manejan dinero, salud, decisiones legales, logística, datos sensibles, o porque caerse cinco horas un martes le cuesta a alguien mucho más que el orgullo. Esos sistemas tienen un problema cultural antes que técnico. Sus equipos copian patrones de empresas que resolvieron problemas distintos a los suyos. Microservicios cuando un monolito modular alcanzaba. Kubernetes cuando systemd era suficiente. Event sourcing cuando una transacción ACID resolvía el caso. Eventual consistency cuando el negocio exigía lo contrario. El resultado es over-engineering caro, frágil, y operado por equipos chicos que no pueden mantenerlo. Esta charla propone una distinción que suena obvia pero que en la práctica casi nadie respeta: escala no es lo mismo que criticidad. Hay sistemas que tienen que aguantar mucha carga. Hay sistemas que tienen que ser confiables, recuperables, mantenibles y auditables. A veces coinciden, pero la mayor parte del tiempo no. Y diseñar para el problema equivocado es la fuente más común de complejidad innecesaria que vi en veinte años. Voy a recorrer, con código Python real, los anti-patrones más comunes y los patrones que sí funcionan: cuándo un monolito modular gana, cuándo Postgres alcanza para todo, cuándo arq o dramatiq reemplazan a Kafka, cuándo backups bien hechos importan más que alta disponibilidad sofisticada. Y un framework mental simple para decidir, en cada componente nuevo, si la complejidad se justifica o se asume sin pensar. Pensada para tech leads, arquitectos, senior developers y engineering managers que diseñan sistemas Python reales en equipos chicos.

En muchos proyectos de Machine Learning, el principal obstáculo no es el modelo, sino la ausencia de datos adecuados. ¿Cómo diseñar un sistema cuando los datos son escasos, inconsistentes o difíciles de obtener? En esta charla se presenta el diseño de un pipeline de Machine Learning implementado en Python que aborda este problema combinando generación de datos sintéticos, extracción de features y clasificación jerárquica. A través de un caso de uso en zooarqueología (la identificación de restos óseos a partir de imágenes) se construye un sistema capaz de operar en condiciones de datos limitados combinando visión y datos tabulares. El pipeline integra distintas etapas: preprocesado de imágenes con OpenCV, generación de datos sintéticos a partir de modelos 3D utilizando Blender y su API en Python, extracción de features geométricas, y entrenamiento de modelos de Machine Learning con PyTorch. En lugar de depender de un único modelo, el sistema se estructura en varios niveles de decisión que permiten reducir progresivamente el espacio de búsqueda antes de la clasificación final. Se mostrará cómo Python permite orquestar todo el flujo, desde la generación del dataset hasta el entrenamiento y evaluación, apoyándose en herramientas como DVC y MLflow para la reproducibilidad y seguimiento de experimentos. Además, se discutirán retos habituales en este tipo de sistemas, como la brecha entre datos sintéticos y reales, la estimación de escala a partir de imágenes y la gestión de la incertidumbre en pipelines jerárquicos.

...

La web moderna se ha convertido en algo que sus creadores nunca imaginaron: un enredo de rastreadores, JavaScript y banners de cookies que se interponen entre las personas y el contenido que buscan. Junto a esta web sobrecargada ha crecido un movimiento más tranquilo: el *Small Internet*, *Smolweb*, o **Internetsito**. Desarrolladores, escritores y aficionados construyen espacios que priorizan el contenido sobre la apariencia, usando protocolos como Gemini que resisten deliberadamente la complejidad moderna. El *Geminispace* ha pasado de 200,000 URLs en 750 cápsulas en 2021 a 530,000 URLs en casi 5,000 cápsulas hoy. Esta charla es una invitación a explorar ese mundo. Hablaremos del *"por qué"*: qué impulsa a buscar alternativas y qué ofrece la simplicidad intencional del Internetsito a quienes lidiamos con complejidad creciente. Luego entraremos en lo práctico: el **Protocolo Gemini**, creado en 2019, se ubica entre la austeridad de Gopher y la complejidad de HTTP, con TLS simple y un lenguaje de marcado, **Gemtext**, diseñado para resistir la acumulación de funciones. Conocerás cómo funciona el protocolo, cómo se ve el *Geminispace* desde adentro y cómo comunidades como los servidores **Tilde** mantienen el espíritu colaborativo de los primeros Unix. La segunda mitad es práctica, con dos proyectos Python de código abierto. **Astronomo** es un navegador moderno de Gemini para terminal, construido con Textual, que soporta Gemini, Gopher y Finger; será la lente para explorar el *Geminispace*. Del lado del servidor, **Xitzin** es un framework para aplicaciones Gemini: rutas con decoradores, plantillas Jinja2 y soporte async. Una guía mostrará cómo construir una aplicación de *microblogging* desde cero, en menos de 100 líneas. No necesitas abandonar la web para apreciar el Internetsito: saldrás conociendo un rincón de internet poco explorado y con herramientas en Python para empezar a recorrerlo.

Computational models are increasingly used to inform real-world policy decisions — from public health and climate planning to economics and infrastructure design. In practice, these models are not used as “prediction machines”, but as structured ways of exploring uncertainty, testing assumptions, and comparing scenarios when real-world experimentation is impossible. In this talk, I’ll discuss what it actually means to build and use modelling systems in a policy context, drawing on experience developing epidemiological and other applied simulation models in Python. While epidemiology provides one concrete example, the focus of the talk is broader: how models are constructed, how they are used by decision-makers, and where misunderstandings often arise. I will highlight common failure modes — such as over-interpreting model outputs, hidden assumptions in code, and miscommunication between technical builders and non-technical users — as well as what good practice looks like in terms of transparency, uncertainty handling, and reproducibility. The goal of this talk is to give Python developers a clearer understanding of how modelling systems are used beyond academia, and why careful software design and communication matter when code has real-world consequences.

A medida que los proyectos crecen, también lo hace su suite de tests… y con ella, el tiempo que tarda el CI en darnos feedback. En la mayoría de los casos, seguimos ejecutando todos los tests en cada cambio, aunque solo una pequeña parte del código haya sido modificada. Existen herramientas que intentan romper esta inercia (se llaman herramientas de "Test Impact Analysis") pero lo realmente interesante es cómo lo hacen, las ideas que hay detrás. En esta charla exploraremos cómo es posible reducir drásticamente el tiempo de CI necesario en una suite de tests sin sacrificar confianza. Analizaremos cómo funcionan estas herramientas, cómo decidir qué tests debemos ejecutar para cada cambio en el código. También hablaremos de los límites de este enfoque, de los compromisos que implica y de por qué no es un problema trivial ni una solución perfecta. El objetivo es ofrecer una nueva forma de pensar sobre testing que trata de responder a la pregunta: ¿qué tests son realmente necesarios en cada cambio?

After months of maintaining the MCP Python SDK and reviewing many community contributions, I’ve seen some architectural hiccups in repeat. Developers struggle with questions that seem simple but have nuanced answers: When should one tool become three? When does a server need to split into two? How do you test an MCP server without spinning up a full client? When should you use resources or prompts instead? In this talk, we will explore my learnings and understand how to design tool boundaries that scale with your server’s complexity, structure your codebase for long-term maintainability, and build a testing strategy for your MCP server that works. I’ll share real examples from the wild, both the antipatterns to run away from and the implementations worth adopting. In 2026, the MCP Python SDK v2 will bring improved typing, a refined API, and better testing primitives. The architectural decisions you make today will determine whether that migration takes a day or a month. Whether you’re maintaining an internal tool or publishing to the community, you’ll leave with a clear framework for evaluating your own server’s design and concrete next steps to improve it.

Galaxy clusters are the largest structures in the Universe held together by gravity, containing hundreds or even thousands of galaxies. As galaxies interact, merge, and fall into these massive systems, some of their stars can become detached from their parent galaxies and drift freely within the cluster. These stars are bound not to individual galaxies but to the cluster's overall gravitational potential, which is dominated by dark matter (invisible but dominant matter in the Universe). Over time, they create a very faint and diffuse glow between galaxies known as intra-cluster light (ICL). The talk is about using astronomical images and cosmological simulations to study this elusive component of galaxy clusters. This faint glow is so dim that it is extremely difficult to detect, making it one of the most challenging features to study in astronomical images. Python plays a central role in this work: from image processing and object detection to measuring galaxy properties, mapping the distribution of diffuse light, and investigating the connections between visible matter and dark matter in galaxy clusters. In this talk, I will present how Python-based tools and scientific libraries enable the analysis of some of the faintest structures ever observed in the Universe and help us uncover the history of galaxy clusters.

...

Ya sabes construir un modelo de difusión desde cero y ahora toca tomar el control. Un modelo que genera imágenes aleatorias es impresionante, pero un modelo que puedes dirigir es realmente útil. En esta charla exploraremos cómo guiar el proceso de generación mediante Classifier-Free Guidance (CFG), la técnica que hay detrás de cada prompt del estilo "un gato al estilo de Monet" que hayas escrito. ¿Por qué decirle a un modelo qué generar resulta ser tan difícil? Veremos la evolución desde el classifier guidance clásico hasta el CFG, con un solo modelo, un solo entrenamiento y control infinito, y desmitificaremos el parámetro guidance_scale que todo el mundo toca pero poca gente entiende de verdad. Con código Python veremos el CFG en acción: cómo un único escalar interpola entre el caos y la precisión, por qué subirlo demasiado rompe tus imágenes, y qué significa eso geométricamente. Los asistentes saldrán entendiendo cómo funciona el CFG matemática e intuitivamente, cómo usarlo con confianza en sus proyectos Python, y por qué el guidance scale es uno de los parámetros más interesantes de la IA generativa moderna.

Si alguna vez has abierto un proyecto Python de hace dos años y no has sabido muy bien qué hacía el Makefile, por qué había un requirements.txt y un pyproject.toml a la vez, ni quién puso ese pyenv local 3.9.7 en el directorio raíz... esta charla es para ti. Vamos a ver cómo uv convierte esa arqueología de proyectos en algo que cualquiera del equipo puede entender, reproducir y no maldecir en voz baja. Con demos reales, un setup.py de 2018 que da algo de vergüenza, y un truco con PEP 723 que vas a querer enseñarle a alguien nada más salir. Terminarás con una base para migrar tus proyectos a uv la semana que viene, o por lo menos con ganas de hacerlo.

Apache Arrow and Apache Parquet are the de-facto standards for in-memory and file formats for columnar data. We use them on our data workflows daily, sometimes even without noticing. This talk will demystify these formats by going over the specifications and showing some real world examples of how the data actually looks on our systems. For Arrow, we will briefly mention some of the batteries included for exchanging data like Arrow IPC, Arrow Flight or Arrow ADBC and how they relate to the core In-memory format. The main libraries shown will be PyArrow with its Arrow and Parquet implementation and datanomy a new tool created for visualizing data formats.

...

Los incendios forestales en regiones mediterráneas como España han aumentado en frecuencia e intensidad durante los últimos años, impulsados por factores como el cambio climático, los cambios en el uso del suelo y la acumulación de combustible vegetal. Esta tendencia ha puesto de manifiesto la necesidad de ir más allá de los enfoques centrados únicamente en la extinción, reforzando la prevención y la planificación a escala de paisaje. Una de las estrategias más prometedoras consiste en la identificación de Puntos Estratégicos de Gestión: zonas clave donde la topografía, la vegetación y las condiciones meteorológicas interactúan de forma especialmente relevante en el comportamiento del fuego. Estas áreas pueden convertirse en lugares prioritarios para actuaciones selectivas de gestión del combustible, prevención y defensa del territorio. Cada vez más trabajos en gestión forestal e incendios se centran en anticipar el comportamiento potencial del fuego antes de que se produzca una ignición. Herramientas como FlamMap se utilizan ampliamente para simular y visualizar dinámicas como la velocidad de propagación, la longitud de llama o la actividad de fuego de copa bajo distintos escenarios ambientales. Estas simulaciones son útiles tanto para la toma de decisiones operativas como para la planificación preventiva a largo plazo. En esta charla presentaremos el papel de las estrategias de prevención basadas en Puntos Estratégicos de Gestión dentro de este contexto, revisando enfoques actuales y líneas de trabajo en la gestión de incendios mediterráneos. Además, mostraremos un flujo de trabajo experimental y de código abierto desarrollado en Python, construido sobre bibliotecas científicas y geoespaciales ampliamente utilizadas. El objetivo es explorar cómo Python puede ayudar a crear herramientas más accesibles, flexibles e integrables con procesos de análisis de datos ya existentes, así como facilitar la automatización y la visualización intuitiva de información geoespacial aplicada a la prevención de incendios forestales.

En el análisis forense digital, gran parte de la evidencia se encuentra en conversaciones, principalmente en un dispositivo celular móvil mediante una aplicación de mensajería ya sea formato de texto o audio, gran parte de la información relevante está ahí. Actualmente los modelos de IA permiten detectar amenazas, estafas y otros delitos, pero su uso en contextos legales es limitado si no son explicables, esto es una condición necesaria para que un sistema pueda ser confiable, auditable y admisible. En contextos donde una conclusión puede tener impacto real en una investigación judicial criminal, la explicabilidad deja de ser una mejora deseable y pasa a ser un requisito fundamental. Diseñé un sistema desarrollado en Python que combina arquitectura multi-agente con RAG para trabajar sobre evidencia concreta y modelos de lenguaje ejecutados localmente con Ollama para mantener la confidencialidad. El foco no está solo en detectar, sino en explicar: cada resultado es trazable, auditable y respaldado por evidencia. No alcanza con que el modelo “detecte algo”: es necesario entender por qué lo detecta, en base a qué evidencia y si ese proceso puede ser revisado y defendido. En esta charla mostraré que cada resultado está respaldado por evidencia concreta recuperada, el registro del flujo de decisión de los agentes, la generación de explicaciones en lenguaje natural junto con fragmentos relevantes de las conversaciones y como consecuencia la obtención de un análisis reproducible y auditable.

How can Python systems remain stable when many valid states coexist? Python succeeds because it allows many valid ways to build systems. It fails when those valid states cannot be coordinated, validated, or made to converge. This talk introduces SIGIL4Py, a practical approach to making Python systems more reliable by structuring how different parts interact. Rather than replacing existing tools, SIGIL4Py provides a thin execution layer that coordinates them, ensuring that changes are traceable, admissible, and consistent across environments. We frame this as compositional plural programming: many voices—libraries, workflows, developers, tools, humans, and agents—working together as one system without forcing a single implementation path. The result is harmonic integration at scale: faster development, fewer integration failures, and more trustworthy execution. SIGIL4Py integrates across the Python stack by structuring interaction rather than rewriting components. It enables large-scale coordination of concurrent systems through ordered transformations, explicit validation, and reproducible execution traces. A key contribution is the unified treatment of human and agent actions within the same input/output workflows, allowing systems to incorporate multiple sources of execution while maintaining consistency and control. At the system level, SIGIL4Py is realized through composable components: a minimal runtime layer structures execution flow; a trace subsystem records state transitions for replay and debugging; validation gates enforce admissible transitions; typed schemas preserve data integrity; and a composition layer ensures compatibility between independently developed components. These are extended with modules for CI/CD reproducibility, AI workflow stabilization, deterministic notebook execution, and deployable kernel orchestration, supported by KUIR and KUBE. The goal is not to impose one correct way to build Python systems. The goal is to make plural systems runnable, inspectable, reproducible, and safe to evolve.

...

Reescribir código de un lenguaje interpretado con uno compilado resultará en una mejora de rendimiento increíble, pero ¿es suficiente? Para muchas personas sí, pero para otras, y probablemente para ti, no es una buena razón para cambiar tu conjunto de tecnologías y de paradigma. Con los últimos avances y la adopción de extensiones en Rust en el mundo de Python, quizás te preguntes: ¿es esto todo? La respuesta es: "Ahora sí, pero en el futuro probablemente no". Añadir más lenguajes a nuestro ecosistema es una excelente estrategia para mantener la relevancia de Python, pero al mismo tiempo debemos recordar que participar en este juego nos obligará a evolucionar y adaptarnos. En esta charla, descubrirás algunos de los fundamentos del éxito de Rust en el ecosistema de Python en comparación con C, pero también explorarás otros lenguajes que aportan mejoras diferentes, como Zig, Gleam, C++ moderno y lenguajes experimentales como Circle y Carbon. Mediante la creación de extensiones con diferentes lenguajes, podrás evaluar qué opción se ajusta mejor a tus necesidades y cuál crees que puede desempeñar un papel importante en el futuro del lenguaje. Se requiere un conocimiento básico de las extensiones de Python para comprender completamente el contenido de la charla, pero los principiantes podrán seguir la idea principal de la presentación.

...

...

...

Production has a special talent for turning “seems fine” into “why is everything on fire?” — usually because we’re missing signals. A service restarts and never becomes ready, a background worker silently stops consuming tasks, or a database gets overloaded and latency creeps up until downstream services (or customers) notice it first. These situations aren’t unsolvable — they’re preventable with the right signals in place. I’ve seen how stressful this gets when a system is already in production, but there’s no clear guidance or shared “where to look first” playbook; so every incident starts with guesswork. Over time, we turned those lessons into a lightweight standard that replaces panic mode with a predictable investigation flow. In this talk, I’ll share a practical, vendor-agnostic observability checklist for a Python setup with three cooperating workloads: an HTTP API, an event-driven worker, and a scheduled daily job. Each workload fails differently, so each requires a different set of signals to stay observable. We’ll cover what “good enough” looks like for logging, metrics, tracing, and alerting: what to instrument first, what pitfalls to avoid, and how to design alerts that catch problems early without creating noise. You’ll leave with a concrete checklist and a phased rollout order you can apply to your own Python services — without rewriting your system or committing to a specific monitoring vendor.

Python puede ser de gran ayuda para hacer más accesibles las películas, series y otros contenidos multimedia. Muchas series y películas carecen de pistas de audiodescripción, lo que las hace inaccesibles para personas ciegas o con discapacidad visual; además, muchas veces los subtítulos (o los ejemplos de código en muchos tutoriales en vídeo) están incrustados en los fotogramas del vídeo, lo que los hace invisibles a los lectores de pantalla e impiden su personalización o copia como texto. En esta charla exploraré cómo utilizar bibliotecas de procesamiento de audio e imagen, incluyendo algunas técnicas de IA, para mejorar la accesibilidad en distintos tipos de multimedia: desde traducir o generar audiodescripciones hasta extraer subtítulos incrustados y otra información en pantalla. Te irás con un modelo mental claro para construir pipelines para mejorar la accesibilidad en películas, series y otros materiales multimediamultimedia. La sesión es ante todo de ideas, centrada en el enfoque de diseño y resolución de problemas, las decisiones sobre el flujo de trabajo y el lugar que ocupa cada técnica, sin dejar de mostrar ejemplos concretos y algo de código. También hablaré de los retos del mundo real, como la precisión, la sincronización y algunas consideraciones relacionadas con el idioma. Por último, reflexionaremos sobre las implicaciones éticas más amplias del uso de la IA para automatizar la accesibilidad: desde el impacto en el empleo hasta las preocupaciones sobre la huella ambiental y el uso responsable de la IA.

Cuando integras un LLM en una aplicación, una parte de tu lógica de negocio pasa a ser probabilística. El problema se complica en escenarios de tiempo real: la latencia es estricta y no te puedes permitir una segunda llamada al modelo para corregir la primera. Si el LLM se equivoca, hay que detectarlo y gestionarlo en el mismo turno. En esta charla veremos los tipos de fallo más comunes en un sistema conversacional con LLM: extracción incorrecta, salidas casi válidas, instrucciones ignoradas, fallos en el cliente,... y las estrategias que aplicamos en producción para gestionarlos con restricciones de latencia. Como hilo conductor, un agente conversacional con llamadas reales. Veremos qué patrones funcionan, cuáles parecen buena idea y no lo son, y cuándo lo correcto es devolver el control a un humano. Cerraremos con una demo en vivo de algunas de las soluciones aplicadas.

Usamos strings todo el tiempo, pero casi nadie conoce la historia que llevó a desarrollar estas abstracciones. En esta charla desmontaremos la abstracción del texto en Python desde sus orígenes más peligrosos en C (char *) hasta las innovaciones de Python 3.14. Exploraremos cómo errores históricos de memoria, encodings incompatibles y el caos de Unicode forzaron algunas de las decisiones de diseño más elegantes del lenguaje. Cerraremos con el PEP 750 de Template Strings: una nueva forma de tratar el texto como estructura, no como concatenación, habilitando procesamiento diferido, metaprogramación y una defensa mucho más sólida contra inyecciones de código. Al terminar, no solo entenderás mejor cómo funcionan las strings en Python: entenderás por qué están diseñadas así, y cómo usar ese conocimiento para escribir código más eficiente, más seguro y más expresivo.

Applications that process money operate under numerous security constraints and require particular attention. Even small issues, such as an insecure endpoint or an inconsistent workflow, can lead to fraud or financial loss. Yet many Django applications rely on the default setups that are not always suitable for high-risk domains. In this talk, I will share practical lessons from securing a real-world Django payment system. We will explore how to design reliable transaction flows, enforce data integrity across distributed components, and prevent various attacks. The session covers common blind spots such as race conditions, fraud attacks, unsafe admin usage, as well as the architectural patterns that prevent them. We will also discuss proper error handling, secrets management, monitoring strategies for abusive behaviour, and how to think like an attacker when evaluating your own code. Attendees will learn concrete techniques and pragmatic security recommendations to build modern applications that remain secure under high load.

¿Y tú, formas parte de la guerra? En el contexto de globalización que vivimos, es imposible negar que nuestras acciones afectan más allá de nuestro entorno más cercano. Si bien eligiendo comprar A o B, dando like a C y compartiendo D, nos estamos posicionando ¿qué pasa con nuestro trabajo?¿Llegan nuestras líneas de código a las trincheras? La guerra moderna ya no depende únicamente de tanques, misiles o soldados. La tecnología es una pieza central: el dato es un recurso estratégico, la IA forma parte de las decisiones, los drones se construyen a partir de hardware comercial y el software civil se integra cada vez más en sistemas militares. Cada día escribimos código, corregimos errores, publicamos librerías, entrenamos modelos o contribuimos a proyectos Open Source. Lo hacemos pensando en resolver problemas, pero ¿puede una contribución aparentemente inocente acabar formando parte de un conflicto armado? Esta charla pretende servir de reflexión colectiva. No se trata de señalar culpables ni de proponer respuestas simples. Se trata de comprender una realidad tecnológica cada vez más compleja y preguntarnos qué significa desarrollar software en un mundo donde una misma línea de código puede servir para construir una herramienta educativa, una empresa multimillonaria o un sistema utilizado en una guerra.

La Inteligencia Artificial puede acelerar la producción musical y no, no voy a hablarte de Suno. Existen conectores que permiten consultar manuales o buscar sonidos, pero ya que sabemos de código…¿y si vamos más allá? 👀 Te presento mi flujo de creación musical donde **Ableton** y **Claude Code** ya son inseparables. Veremos cómo acelerar las tareas mecánicas que rompen el flujo creativo (organizar plantillas, crear bases de patrones rítmicos y melódicos, ajustar parámetros) y sobre todo cómo **potenciar nuestra expresividad** con sesiones más dinámicas y creativas. Claude Code será el puente directo hacia el Live Object Model (LOM) de Ableton Live a través del protocolo OSC (Open Sound Control). Y créeme, **saber de python aquí es clave** para evitar errores a tiempo. Al final de la sesión lanzaré una demo de la canción mezclada con voz en directo para que veas el resultado de una de mis sesiones 🎶.

...

You made an LED blink with Python, or a motor move, a real physical thing happening because of code you wrote, and it feels genuinely exciting. Python implementations like MicroPython or CircuitPython, running on embedded devices like Arduinos, Raspberry Pis, micro:bits, or ESP32s, they open the door to controlling hardware with the same language we all know and love. It starts feeling familiar, until it doesn't. No OS or access to the tools we are used to, a sensor that doesn't respond, a system that randomly crashes, so what do we do now? This talk is your guide through that shift. How to think about memory when you only have 128KBs of RAM, how to debug your programme when crashes are silent and the board just resets, what hardware protocols to reach for and why, and recommendations on low cost electronic tools that lets you see what's actually happening on the hardware. You'll learn what comes after the initial blink, how to work with these embedded systems and feel as confident with hardware as you do with Python.

Moving large amounts of data between Python and Rust is often slow and memory intensive because of unnecessary serialization and copying. As data pipelines, AI workloads, and analytics systems continue to grow, these overheads quickly become a bottleneck. In this talk, we will explore how to achieve zero copy data sharing between Python and Rust using PyO3 and Apache Arrow. Starting from a simple Python and Rust integration, we will learn how Arrow’s columnar memory format allows both languages to work on the same data in memory without expensive conversions or duplication. Through practical demos and real world examples, attendees will learn how to build high performance Python extensions in Rust, exchange Arrow arrays and tables efficiently, and significantly reduce memory overhead in data intensive applications. The session will also cover common interoperability pitfalls, debugging techniques, and performance comparisons between traditional serialization approaches and zero copy workflows. By the end of the talk, attendees will understand how modern data systems use Arrow as a shared memory layer and how Python developers can leverage Rust for performance critical workloads without sacrificing developer productivity.

...

Un vuelo comienza mucho antes de subirse al avión: días antes hay que empezar a preparar el plan operativo, que consiste en un itinerario detallado del viaje. Este itinerario incluye la ruta a seguir, rumbos entre puntos, desvíos por viento, cálculo de la ground speed, combustible consumido y mil cosas más. Es algo que consume muchísimo tiempo y que me propuse automatizar con Python. Es el primer pet project que hago en mucho tiempo, que combina mis dos grandes pasiones: aviación y python!

This presentation explores the increasing tendency to anthropomorphize Artificial Intelligence, drawing a parallel to the psychological phenomenon of pareidolia—specifically, seeing familiar patterns in random stimuli, such as Jesus's image on a piece of toast. The core argument is that while AI has become an indispensable and powerful tool, the perception of its sentience is a projection of human cognitive biases: our innate need to find familiarity and project emotion. The discussion moves beyond the technology itself to focus on the socio-ethical challenges arising from its use, including misplaced trust in AI outputs and the creation of systems designed to simply "please" users rather than solve problems ethically. Furthermore, the presentation highlights the critical lag in effective regulation. The people most engaged in AI development are often less focused on governance, leading to enforcement and ethical oversight gaps (exemplified by issues like the 'Matplotlib issue'). Ultimately, the presentation concludes that while the "Jesus on toasts" phenomenon in AI will persist, clear communication is necessary to temper public perceptions, urging both the public and relevant authorities to actively engage in the urgent discussion around AI ethics and regulatory enforcement. The goal of this talk is to help the audience understand the effect of AI from a moral perspective and the danger posed by a lack of regulation. This presentation is intended for everyone who is interested in or currently using AI.

Todos los días escribimos código, abrimos la terminal y ejecutamos `python my_app.py`. El programa hace exactamente lo que le pedimos, pero... **¿qué ocurre en las entrañas de CPython en esos milisegundos que transcurren entre que pulsamos *Enter* y se ejecuta la primera línea de nuestro script?** Esta charla es un viaje a las profundidades de la arquitectura de Python 3.14 para desmitificar la "magia" del intérprete. Exploraremos, paso a paso, el ciclo de vida de la ejecución. Comenzaremos desde el sistema operativo, analizando la API de Inicialización moderna (`PyConfig` y `Py_RunMain`), el estado de los hilos y el impacto del modo *free-threading* ([`PEP 703`](https://peps.python.org/pep-0703/)) en el GIL. A continuación, nos sumergiremos en la traducción de texto a instrucciones: desde la construcción del Árbol Sintáctico Abstracto (AST) usando el analizador PEG, hasta la compilación en *bytecode*. Finalmente, entraremos en el corazón de la máquina virtual (`ceval.c`). Veremos cómo el bucle de evaluación clásico interactúa con el nuevo optimizador de Nivel 2 (Tier 2) y el compilador JIT (*copy-and-patch*) para acelerar tu código. Al salir, tendrás las herramientas conceptuales para entender el rendimiento de Python a bajo nivel. ¡Levantemos el capó!

¿Cuál es el límite de Python cuando nos enfrentamos a problemas de alta intensidad computacional en bioinformática? En esta charla se presenta un análisis comparativo sobre la paralelización y distribución de los algoritmos de Biclustering BiBit y BCCA, esenciales para la búsqueda de patrones en grandes matrices de datos genómicos. Se detallará el proceso de transformación y optimización desde una implementación base en Python secuencial hacia cinco arquitecturas de alto rendimiento (HPC): 1. Numba (CPU & GPU): Implementación de compilación Just-In-Time (JIT) y kernels vectorizados. 2. Cython: Optimización mediante tipado estático y gestión eficiente de memoria a nivel de C. 3. Cython + OpenMP: Estrategias de paralelismo multinúcleo nativo. 4. Cython + CUDA: Desarrollo de kernels de bajo nivel para la ejecución masiva en GPUs NVIDIA. A través de un riguroso benchmark, compararemos métricas de aceleración (speed-up), eficiencia energética y complejidad de implementación. El objetivo es desglosar objetivamente bajo qué condiciones técnicas cada una de estas herramientas es la opción óptima para superar las barreras del rendimiento en el ecosistema Python.

Para la ultima edicion de Python, en el core dev team nos propusimos construir el mejor profiler por muestreo para cualquier lenguaje interpretado y añadirlo en la libreria estándar. Python 3.15 trae el resultado: Tachyon, un nuevo profiler por muestreo capaz de samplear a nivel de microsegundo. A esa velocidad, puede que tu profiler esté haciendo más trabajo que el propio código al que analiza. Esta charla es la historia de cómo lo construimos. En esta charla aprenderás a leer memoria de un proceso en ejecución sin detenerlo, a dar sentido a las estructuras internas de Python desde fuera, y qué trucos hacen falta para pasar de «suficientemente rápido» a «esta velocidad es casi ilegal». Si alguna vez te has preguntado qué hace falta para construir un profiler capaz de conectarse a un servidor en producción, capturar datos y marcharse sin que la aplicación se entere, aquí lo vas a descubrir. Pero esto no es solo una charla sobre aspectos secretos de como Python funciona por dentro. También aprenderás a usar Tachyon para encontrar las partes lentas de tu código. Flamegraphs, mapas de calor, profiling consciente de async, análisis de contención del GIL, profiling a nivel de bytecode... Al final sabrás qué formato de salida elegir, qué modo de profiling encaja con tu problema, y cómo pasar de «mi servidor va lento» a «aquí está la línea que nos está matando».Tanto si te interesa la programación de sistemas que hace que esto funcione, como si solo quieres una forma mejor de depurar problemas de rendimiento, esta charla tiene algo para ti.

Since neural networks, and especially transformers, became dominant, production AI has largely settled on a small set of mathematical assumptions and rarely revisits them. The research literature has questioned these assumptions for years, but the alternatives have not crossed over into the systems most of us actually build, so in practice we keep pushing the same architectures further rather than asking a more fundamental question: are we even using the right mathematical approach in the first place? This talk focuses on one place where that question bites hardest: how we represent meaning and retrieve it. Many modern AI systems built in Python lean heavily on embeddings and similarity metrics such as cosine similarity, particularly in components like hybrid search. The usual setup treats representations as points in a flat, Euclidean space and measures relatedness by angle. That choice is convenient, but it is not neutral, and it quietly limits what these systems can capture. We will look at how embeddings and similarity metrics are used in practice, what inductive biases they introduce, and where they start to break down. From there we will introduce alternative perspectives such as hyperbolic spaces and manifold-based representations that capture hierarchy and structure with far less distortion than flat space. A third lens comes from the theory of moving frames. We will keep all of this intuitive, with a simple illustrative example in Python. Take-home message: the mathematical choices behind AI systems are not neutral. If we question the geometry and structure we assume, we can better understand the limitations of current approaches and open the door to more suitable ways of representing meaning and relationships. Target audience: Python developers, data scientists, and engineers working with machine learning or AI systems who want to understand the foundations behind embeddings, similarity, and retrieval.

10 years, +10K stars, MIT license, thousands of community pull-requests per year, reaching 3 millions downloads per month (once classified as a PyPI critical 1% project). Used in production by thousands of organizations worldwide and more than 15% of Fortune 100/500 companies, supported by a team of 10 full time maintainers, and fully created and developed in Spain. If you haven’t heard of it, it is because it is Conan (https://conan.io), a C/C++ package manager, a tool focused on another programming language and community. This talk will present the lessons learned while creating, developing, maintaining and supporting this Python project, how different challenges have been approached, what worked and what was not so great: - Typing, or better, the lack of it - Testing strategy: unit, integration, e2e, thousands of tests, 98% coverage. Our testing framework and - CI for Windows, Linux, OSX, with multiple compilers and build systems. - The pain of Conan1 to Conan2 migration, repeating Py2-3 history - Hitting Hyrum's law, the pain of public interfaces and APIs. How to evolve without breaking user space. Documentation. - Distributing and installing the tool in different OS. Minimizing dependencies. - The tool configuration system, one tool to rule them all. - Performance and concurrency challenges. - Was Python the best tool for the job? - Abuse of the tool for other programming languages, including Python - Python backend for C/C++ native extensions with dependencies. From developers having to maintain long-lived Python projects with many users, to tool creators and open source maintainers planning their project to become a popular open source one, all will be able to benefit from the many learnings that this project has accumulated in the last decade.

Si tienes un aeropuerto más o menos cerca de casa, estás de suerte: tienes a tu disposición una de las apps del tiempo más precisas que puedes encontrar. Y encima, gratis. Se acabó fiarte del tiempo que dice tu móvil, salir a la calle sin paraguas, y luego volver a casa remando en una góndola como si estuvieras en Venecia. Los aeropuertos son una fuente de información meteorológica súper precisa, pues es la que usan los pilotos y despachadores para planificar los vuelos, decidiendo si es seguro volar, o si por el contrario es mejor quedarse en casa y salvar el pellejo. Dicha información sale de reportes meteorológicos que se publican cada tanto, pero con el pequeño inconveniente de que parecen escritos por la mismísima máquina Enigma. No iba a ser todo tan fácil, por supuesto. Con Python, es posible traducirlos sin ningún esfuerzo, a golpe de clic, ofreciéndote información de fiar. Por fin podrás salir a la calle con la seguridad de que ese paraguas no lo vas a llevar todo el día de adorno. Ya si luego te cae un rayo encima a mitad de camino no nos hacemos responsables de los daños.

Propongo una charla en la que ejecutaré scripts de Python contra dos máquinas virtuales: una vulnerable y otra endurecida. A través de estos escenarios controlados, los asistentes observarán cómo diferentes fases de un ataque —reconocimiento, escaneo, autenticación y explotación— generan eventos que posteriormente serán analizados y correlacionados en un entorno SIEM basado en Elastic Stack. El objetivo principal es despertar el interés por el uso de Python como herramienta tanto en contextos de Red Team como de Blue Team, mostrando cómo un mismo conjunto de acciones ofensivas puede convertirse en una fuente valiosa de detección y análisis defensivo. La charla tiene un enfoque introductorio, aunque se recomienda que los asistentes cuenten con conocimientos básicos de Python, Linux, Terminal y fundamentos de redes para aprovechar mejor la experiencia. Como objetivo final, se busca que los participantes puedan reproducir el laboratorio en su propio entorno. Para ello, será útil tener nociones de virtualización (por ejemplo, con VirtualBox o Docker), uso de la terminal, conceptos de red, gestión básica de logs y fundamentos de certificados TLS/HTTPS. Actualmente, la propuesta está planteada en formato charla. No obstante, existe la posibilidad de evolucionarla a un formato workshop. En este momento prefiero comprometerme con la modalidad de charla, y, si lo consideran adecuado, podría confirmar en un plazo aproximado de un mes la viabilidad de adaptarla a workshop.

...