Opening session with morning announcements
In the era of agentic AI, our role as developers is no longer just about code creation but it’s about code curation. The blank page is dead, but AI-slop is rising. Discover how to use architectural guardrails to force AI to code with your taste, not its training data.
In 2025, PyLadiesCon team said no to spreadsheets and instead started building our conference infrastructure: an open source web app for managing various aspects of our conference. Learn more our challenges in managing the online PyLadiesCon conference, and how we're solving our problems with Python and Django.
Come and hear about some of the exciting things now available in Python 3.14, and also the new stuff coming in Python 3.15 later this year.
In Python, objects live as long as something is holding on to them—and sometimes that’s way longer than you expect. This talk explores how references, the garbage collector, and weak references interact to determine object lifetimes, with real-world examples like lru_cache quietly keeping objects alive.
A couple of slow imports made our Django development miserable. Inlining imports fixed the speed but hurt the codebase. Explicit lazy imports in Python 3.15 will finally give us the speed without the mess!
Have you ever looked at a PySpark pipeline and assumed it would run top-to-bottom? You’d be surprised…it doesn’t. In reality, Spark builds and optimizes execution plans, and this mismatch can lead to subtle, production-grade bugs.
In this talk, I’ll walk through a real-world example where reading and updating the same tables produced inconsistent results in production. We’ll see why this happens, what Spark actually executes under the hood, and why code that looks correct can behave unexpectedly.
Join this session and you’ll learn practical design principles to make pipelines predictable: introducing explicit materializations, using declarative patterns, or imposing physical separation between sources and targets.
We like to treat software architecture as a technical discipline, so when an architecture rots we go looking for technical causes. But every decayed system I've ever seen had a perfectly good plan behind it. The mess didn't come from the code. It came from how the people building it talked to each other, or stopped talking to each other. That's Conway's Law, and it just got a plot twist: a growing share of those conversations now happen with AI assistants instead of with teammates.
This talk follows one fictional organization across three eras of its life, on a single network graph of people, teams, services, and code that evolves on screen, to find out what all those private conversations are doing to your software.
Python is running companies worldwide — through Odoo, an open-source ERP where business logic is just Python code. Come see how Python's expressiveness and modularity power the decisions that keep businesses moving.
A generator, duck typing, and branchless conditionals walk into a bar…
Sounds like the start of a bad Python joke, but it’s actually a list of three features used in my favourite line of Python code.
You have a favourite line of code as well, right?
In this talk we’ll go over two quintessential features of Python programming (generators and duck typing) and you’ll learn how to use them effectively.
We’ll also look at branchless conditionals and understand how this unusual idea can shape the way you think about coding.
In the end, we’ll put the three together to write a powerful Python idiom and conclude I have terrible taste!
Enjoy Thursday's lightning talks! Short talks about everything by everyone.
Morning announcements
Most of us now talk to our computers like we did in the 60s, through a terminal. The difference is what is on the other side. Along the way, we stopped writing code by hand.
This talk is about what that costs and what it buys. Treating AI systems with awe hides what they can't do and hands us back plausible slop. Named precisely, as a tool that drafts, reviews, searches, or automates a specific chore, it becomes something that can be tested, questioned, measured, and optimised.
This talk tackles the common, yet ultimately limiting, practice of using print statements for debugging in Python. We will explore why relying on print statements often becomes inefficient and cumbersome as applications grow in complexity.
There are various websites and services that lets you generate QR codes. However, these services sometimes aren't free, or they might serve ads on the website. What's even worse, sometimes these services would mask your url with a their own url shortener or domain.
Do we really need to use these services in order to accomplish simple thing like generating an image?
Let's reverse engineer these services and see how we can build our own using Python and Django.
Python developers are building APIs that expose industrial control systems (PLCs and sensor networks via Modbus or OPC-UA) to the internet, often with basic authentication and outdated dependencies. When code controls power grids, water systems, or manufacturing processes, a compromised API or a typosquatted package is not just a data leak, it can disrupt operations.
Because of this, the way these APIs are built introduces security concerns that are not always visible during development. Many of these applications depend on third-party packages, which creates exposure to supply chain risks.
Attackers use techniques such as typosquatting, publishing malicious packages with names similar to widely used libraries (such as reqeusts instead of requests). Once installed, these packages can access environment variables, API keys, or system interfaces. Outdated dependencies introduce additional risk, as libraries such as requests or urllib3 may contain known weaknesses, including credential leakage during redirects or improper SSL validation.
These patterns come from web development, where their impact is often limited to data exposure. When the same code is used in systems connected to infrastructure that controls physical processes, the consequences change. Weak API design or a compromised dependency can affect system behavior, not just stored data.
This difference creates a gap between how Python applications are commonly built and what is expected in these environments. Small decisions in Python API design can reduce risk in systems where software directly affects physical processes.
This talk shows Python developers how to secure these integrations through safer API design, careful handling of dependencies, and decisions that improve system resilience without requiring deep security expertise.
Forecasting is one of the most important and frequent problems in machine learning.
- How many customers will visit a store next Friday?
- How many products will a factory sell three months from now?
- How many tourists will visit a city next summer?
In this talk, you will learn how to solve these types of problems with machine learning in Python.
The talk will start with a brief introduction to the necessary machine learning concepts, then explain how to transform a time series problem into a machine learning problem. It will focus on concepts that are not only essential for this approach, but for time series modelling in general.
Are you curious how linters and code formatters work? Would you like to build your own code analyzer? In this talk, I will walk you through the process of doing so using a data structure called an abstract syntax tree, which represents your code's structure and allows you to access its components.
Why keep managing your cloud with rigid HCL when you can use Python?
Python + Pulumi bridges the gap between dev and devOps with the same language.
In this talk about Data Quality, I will explore its main concepts, technologies, and strategies, besides presenting a benchmark of Python solutions and a use case applying Airflow to execute Data Quality validations
Conventions are one of Django’s greatest strengths.
They simplify our day-to-day work, reduce cognitive load, and let teams move fast with confidence. By following well-established defaults, we spend less time debating structure and more time solving real problems.
But every convention is also a decision - and every decision has trade-offs.
Who decided these conventions? Why were they chosen? And what happens when your problem doesn’t quite fit the “Django way”?
In this talk, we’ll explore Django’s conventions as both a feature and a constraint. We’ll look at where they shine, where they leak, and how experienced developers can respectfully bend (or break) them without fighting the framework. This is a talk for anyone who loves Django — especially when they disagree with it.
Enjoy Friday's lightning talks! Short talks about everything by everyone.
Closing session
AI doesn’t just reflect society—it amplifies its contradictions. From viral “bikini” image manipulation trends(!) in generative tools to hiring systems that systematically disadvantage women* in tech, we see the same pattern: erasure in one place, hypervisibility in another. In this hands-on workshop, we build AI agents with LangChain and LangGraph to detect and surface gender bias in real text systems—turning critique into code, and visibility into a technical feature.
Come 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 code analysis checks from scratch, giving you the skills and confidence to use ASTs in your own projects.
These may be the most important skills to keep your job or to find a new one in the future!
AI-generated code is a powerful tool, but it should never be blindly trusted. This intensive workshop, "Audit and evaluate AI generated Python code," teaches you the critical skills you need to stay relevant in the future.
What if we approached Python problems differently? This hands-on workshop introduces Functional Programming as a problem-solving mindset: break complexity into small functions, control side effects, compose reusable pieces, and build predictable systems. Learn practical Functional Programming techniques in Python.
Streamline your Python processes and worfklows by using uv to install tools, run scripts, manage and deploy projects, and more!
This workshop will be a hands-on intro to RSA, X.509, PKI, TLS, and MITM (man-in-the-middle) attacks with Python.
