pre-release: PyOhio meeting announcement

Please take a moment to review your details and reply with OK or edits.
Subject and below is what will go out and also will be used to title the videos.

Subject: 
ANN: PyOhio at Ballroom D Sat July 26, 9p


PyOhio
=========================
When: 9 AM Saturday July 26, 2025
Where: Ballroom D

https://www.pyohio.org/2025/program/talks/

Topics
------
1. Saturday Welcome


(Needs description.) 
 recording release: yes license: CC BY-SA  

2. Keynote
Abigail Mesrenyame Dogbe

Keynote
 recording release: yes license: CC BY-NC-SA  

3. CANCELED: Getting Advice from Myself Using Flatfiles, Postgres, and Frontmatter
Jay Miller

 Unfortunately Jay is unable to attend PyOhio and this session has been canceled

Cicero said - there is no one who can give you wiser advice than you can give yourself. That's why when I started generating transcripts from my productivity podcast, I decided to start using it to give myself productivity advice using ALL of my content.

This talk dives into a journey using PostgreSQL with pgvector for hybrid search as the base for using personal transcriptions, blog posts, and more for RAG and AI Agents.
 recording release: yes license: CC BY-NC-SA  

4. Detecting Road Conditions from Space Using PyTorch, Public Data, and Free Satellite Imagery
Cynthia Ukawu

Monitoring the health of city streets and roadways is expensive, time-consuming, and often reactive. But what if we could automate part of that process using satellite imagery and Python?

In this talk, we’ll walk through a real-world project that combines transfer learning, PyTorch, and publicly available datasets to classify road segment conditions (good, fair, poor) from aerial imagery. You'll learn how to work with messy real-world geospatial data, fine-tune a deep learning model using only a small training set (~2,000 examples), and overcome common challenges like blurry imagery, inconsistent labels, and overfitting.

This session is practical and code-driven, aimed at data scientists and analysts working in mobility analytics, urban development, or infrastructure who want to apply machine perception techniques in their work. By the end, you’ll walk away with a reusable workflow for analyzing and predicting urban infrastructure quality — all using free tools and open data.
 recording release: yes license: CC BY-NC-SA  

5. Demystifying AI Agents with Python Code
William Horton

Everyone’s talking about AI Agents! But what are they, and how can you build them? This talk cuts through the hype. Drawing on a year spent developing a GenAI platform, I'll show you that creating powerful AI Agents is within your reach, no advanced degree required.

We’ll define agents practically: Large Language Models combined with tools and memory. Moving beyond the abstract definition, I’ll show you how to build your first agent using the OpenAI Python SDK and fundamental Python concepts you’re already familiar with: functions, loops, and conditions. From there, I will demonstrate how you can use the CrewAI framework to abstract away the boilerplate code, allowing for simpler setup of multi-agent systems.

By the end, you won't just understand agents; you'll be equipped and inspired to build your own, ready to tackle custom tasks by integrating the APIs that matter to you.
 recording release: yes license: CC BY-NC-SA  

6. Python for Hardware Folks
Alec Delaney

Python is a versatile language, and it’s often the go-to language for data scientists, machine learning engineers, and web developers, among others. However, often notably absent from this list are those working on and developing things in the physical world. Too often is the humble hardware engineer forgotten, doomed to a fate of spreadsheets. But what if I told you there was a whole world of hardware-focused Python? This talk will explore various examples of Python in the world of hardware folks, including building test fixtures, data acquisition, and industrial automation. We’ll also look at other issues, including what are the alternatives and why adoption of Python can be challenging. This talk is meant for everyone, but especially those who love or want to tinker with hardware.
 recording release: yes license: CC BY-NC-SA  

7. VSCode Tooling for Python
Daniel Segan

Visual Studio Code has become a powerhouse for Python development, offering a lightweight yet robust environment packed with tools to streamline coding, debugging, and testing. In this talk, we’ll dive into the essential VS Code tooling that can turbocharge your Python workflow. From setting up the perfect Python environment to leveraging extensions for linting, debugging, and Git integration, you’ll leave with practical tips to boost productivity and code quality. Whether you’re wrangling data pipelines, building web apps, or just tinkering with scripts, this session will show you how to make VS Code your Python best friend.  
Key Points:  
1 Setup Basics: Configuring Python interpreters, virtual environments, and workspace settings in VS Code.  
2 Extensions That Matter: Must-haves like Python (by Microsoft), Pylance, and Flake8 for autocompletion, type checking, and linting.  
3 Debugging Like a Pro: Using breakpoints, variable inspection, and the debug toolbar for painless bug hunting.  
4 Testing Made Easy: Integrating pytest and unittest directly in VS Code with real-time feedback.  
5 Git Integration: Streamlining version control without leaving the editor.  
6 Pro Tips: Custom snippets, Jupyter notebook support, and remote development tricks
 recording release: yes license: CC BY-NC-SA  

8. Lights!  Python!  Action!
Mike McCaffrey

Intended to be an entertaining overview of challenges faced and lessons learned working on my first big maker project. Using code snippets, pictures and short demos, I will discuss problems overcome while developing new features and integrating new devices into my humble animated sign, which includes lights along with rhythmic and melodic components. I promise not to dance; no one wants to see that.

The intended audience is anyone interested in maker projects. I will also be touching on introductory-level topics in type hinting; the standard library modules abc, dataclasses, signal, and threading; and the 3rd-party modules aiohttp, gpiozero, and requests.

`Note on Photosensitivity:`  
Based on [this epilepsy.com article](https://www.epilepsy.com/stories/shedding-light-photosensitivity-one-epilepsys-most-complex-conditions), this presentation should be safe for any photosensitive audience member. I will include this information in a slide at the beginning of the presentation, and give anyone in the audience the chance to leave or ask questions before proceeding.

* The sign project uses standard 60 watt incandescent bulbs, which are not capable of producing a strobe effect.
* For further safety, during the presentation, bulbs will not cycle on and off more than 3 times per second.
* Additionally, the room’s lighting will not be darkened more than usual for a standard presentation.
 recording release: yes license: CC BY-NC-SA  

9. From Forge to Keyboard: Crafting a Developer’s Journey
Bianca Ploss

What do metalsmithing, managing a manufacturing floor, and raising children have to do with writing code? More than you might think.

Through stories of precision, adaptability, and resilience, I'll show how non-technical experiences have helped me to thrive in tech. From iteration at my forge, troubleshooting on the manufacturing floor, and to building empathy as a parent I'll share how life's lessons have built transferable skills.

Whether you're a seasoned professional or a new developer, this session will inspire you to embrace your own journey and discover the hidden strengths you can bring to the table.
 recording release: yes license: CC BY-NC-SA  

10. Chasten Your Python Program: Configurable Program Analysis and Linting with XPath
Gregory M. Kapfhammer

Abstract
--------

Stop wrestling with regular expressions (regex) and complex abstract syntax tree  
(AST)-based frameworks to analyze and lint your Python code! Chasten offers an  
elegant solution by leveraging XPath expressions to search Python's abstract  
syntax tree, making static code analysis both powerful and accessible. In this  
talk, you'll discover how to implement custom linting rules, enforce coding  
standards, and perform sophisticated pattern matching in your Python projects  
using a tool designed for both simplicity and flexibility. Whether you're a  
developer tired of writing fragile regex patterns, an instructor validating  
student code, or a project maintainer who wants to ensure code quality, Chasten  
provides the perfect balance of power and usability for your static analysis  
needs. More details about chasten are available at:  
https://github.com/AstuteSource/chasten.

Key Takeaways
-------------

* Create custom linting rules through simple YAML configuration
* Practical examples of enforcing code standards on documentation and code
* Ways to analyze results through interactive dashboards with Datasette
* How to integrate Chasten into development workflow and CI/CD pipelines
 recording release: yes license: CC BY-NC-SA  

11. How a Solo Hobbyist Learned to Love Testing
Carl James

I don’t get paid to write code. I have no boss to answer to. I have no partner to work with. Most of the apps I produce are for me to use. When I was learning Python with online videos, I was introduced to testing. I found it interesting, but it felt time consuming.

Then I went back to an old app I had written and wanted to re-work. I was lost. I couldn’t even figure out where to begin to make it work again. I slowly decided to integrate testing into my personal workflow on projects. Then I came upon an unexpected benefit: by testing my code in a Django app, I was able to better learn what the library was doing to convert a request into a response. I knew the steps, but through writing a test with an expected output and seeing the error messages on failures, I now intuitively understand how this process works. This talk will demonstrate that.
 recording release: yes license: CC BY-NC-SA  

12. Deploy Django: GitOps & Kubernetes Made Easy
Calvin Hendryx-Parker

Deploying code shouldn’t be stressful. But too often, the journey from local dev to production is fragile, manual, and hard to debug. This talk is about building peace of mind into your pipeline — with GitOps, Kubernetes, and open source tools like Argo CD that make continuous delivery predictable, repeatable, and scalable from the very first release to the 50th.

We’ll tackle the realities of “day two” DevOps — what happens after the first deploy. From managing rollbacks and coordinating releases to enforcing consistency across dev, staging, and production, you’ll learn how to bring stability and scalability to your delivery pipeline.

In a live demo, we’ll deploy a full stack Django app from GitHub to production using Argo CD and GitHub Actions — with observability, rollback strategies, and environment parity built in from the start.

**You’ll learn how to:**   
- Set up a GitOps-based CI/CD pipeline that works across all environments  
- Automate rollouts, rollbacks, and version control of infrastructure  
- Understand why Kubernetes is a future-proof platform for Django teams  
- Gain confidence in releasing updates safely, consistently, and at scale  
- Leverage open source tools to eliminate manual deployment headaches

Whether you're writing the code or leading the team, you'll leave with a clear, practical blueprint for shipping faster — and with fewer surprises.
 recording release: yes license: CC BY-NC-SA  

13. Graph Machine Learning in All Its Glory!
Shreya Khurana

Our world is complex: one approach to understanding and learning more about relationships within the data is to represent it as a network or a graph - with entities as nodes and relations between them as edges. Network applications are abundant - Facebook, knowledge databases like Wikipedia, traffic routes, molecular pathways, and the fun starts when we start thinking of the physical world as graphs. Where there’s data, there’s uncertainty and the need to predict the future to make it a little less uncertain, which is why we need machine learning.

**This talk will be about modeling one such network using a Graph Neural Network (GNN) and making some predictions on it using Deep Graph Library, an efficient and scalable open source framework to train and serve GNNs. While GNNs can be used for any ML task, we’ll focus on building a recommendation model.**

**But the transition from traditional data structures to graph-based models is not straightforward. Unlike tabular data, graphs require adapting ML principles to accommodate their topological and relational complexities.**

This talk will help participants gain practical insights into modeling their data as graphs and leveraging GNNs to build a recommendation system. After the talk, the audience should have a good understanding about:  
- How to structure their data as graph components and prepare it for modeling  
- What a GNN is and how do we train, evaluate and serve models in DGL  
- End-to-end ML tasks on graph data: best practices to avoid pitfalls
 recording release: yes license: CC BY-NC-SA  

14. Beyond the Black Box: Interpreting ML Models with SHAP
Avik Basu

ML models behave as a black box in most scenarios. Model predicts or provides a certain output but it is very difficult to generate any actionable insights directly. This is mostly because we generally have no idea which features are contributing the most to the model behavior internally. SHAP provides a certain way to explain model predictions, and can act as an important tool in a data scientist’s toolbox.

In this talk, we will begin by explaining to the audience the need for explainable ML models and why it is important to understand beyond what the model outputs. We will then briefly go over the mathematical intuition behind Shapley values and its origins from game theory. After that we will walk through a couple of case studies of tree based and neural network based models. We will be focusing on interpretation of SHAP through various plots using the shap library in Python. Finally, we will discuss the best practices for interpreting SHAP visualizations, handling large datasets, and common pitfalls to avoid.
 recording release: yes license: CC BY-NC-SA  

15. Wildfires!
Lazouich Ford

Wildfires have become more frequent nationwide, causing chaos not only within fire zones but also affecting communities far away through smoke and poor air quality. In this talk, we'll explore the world of wildfires, understanding common terminology and clearing up misconceptions. We will explore data sources, potential file formats, and essential data fields using fire perimeter data. By leveraging Python and Geopandas we will clean a dataset, analyze the cleaned dataset, and finally create compelling visualizations of our wildfire data.
 recording release: yes license: CC BY-NC-SA  

16. The Core Values of a Successful Startup
Daniel Kim

What really makes a startup succeed? It’s not just product-market fit or clever tech—it’s the people and the culture they create together. In this talk, I’ll share lessons from my journey across three startups at different stages, through acquisitions, pivots, and cultural transformations.

I’ll explore the core values that I’ve seen make the biggest difference—not the ones painted on walls, but the ones that show up in code reviews, standups, hard conversations, and late-night problem solving. We’ll talk about:  
• Authenticity over performance  
• Love and empathy as engineering virtues  
• Presence and trust in high-stakes uncertainty  
• Balance, sustainability, and knowing when to push or pause  
• Grit, growth, and intentionality—what it really takes to build something that lasts

This talk is for anyone who wants to build or be part of a values-driven team: engineers, tech leads, future founders, or just curious humans trying to build things that matter.
 recording release: yes license: CC BY-NC-SA  

17. Guardrails: An Alternative View of Safely Working in Python
Christopher Neugebauer

Python – like many languages – lets you do things that are completely inadvisable. Many of the features that (left unchecked) allow you to do inadvisable things were used to achieve things that have since become necessary and defining features of Python.

Python – unlike many languages – discovered that leaving these obvious and necessary features lying around next to inadvisable things was a bad idea, and built guardrails around them.

In real life, guardrails are structures that make it easier to understand how to be safe in an area where there is otherwise danger. If respected, guardrails make you safer, but unlike walls or fences, guardrails do not block you from danger.

In Python, features like decorators, context managers, async functions, importlib, and more are all guardrails that let you work with less-safe Python machinery from a much safer distance.

In this talk, we’re going to explore the idea of guardrails as a design philosophy, and use that to explain Python’s attitude to safely working with the language and its internals.

We’ll explore features of Python that are guardrails around less-safe features – what features they replaced, how those features could be used incorrectly, and how the newer features allow you to use Python more safely. As a special treat, you may also get to see how Python lets you abuse these features\*.

We’ll conclude with a discussion of how you can use Python’s guardrail philosophy in your own code.

---

(\* SKILLED OPERATOR ON CLOSED CIRCUIT; DO NOT ATTEMPT)
 recording release: yes license: CC BY-NC-SA  

18. From Data to Insights in Minutes: Accelerating Predictive Modelling (in Python) with AutoML
Shailaja Sampat

Have you ever wondered how Machine Learning could automate your tasks but hesitated due to time constraints or a lack of specialized coding skills? If so, this session is for you!

Traditionally, building predictive models required specialized coding abilities and a deep understanding of statistical concepts. However, AutoML simplifies this process and can automatically create machine learning models from your data. This session will empower you to use a simple, open-source AutoML tool to quickly create Python-based machine learning prototypes (using the pandas, NumPy, and scikit-learn frameworks) without writing any code. A live demonstration will show how AutoML seamlessly (i) processes input data, (ii) selects and trains the best algorithms for your specific use case, (iii) generates reproducible Python code for easy integration, and most importantly, (iv) how to interpret the results.

Discover how AutoML can turn your transform your data into actionable insights!
 recording release: yes license: CC BY-NC-SA  

19. Hyperdimensional Computing for Hackers
Anthony

In this session, we will explore the concept of hyperdimensional computing (HDC), a brain-inspired method of computing. We'll begin by talking about neurons and the brain. Through simple Python examples we’ll dive into HDC and answer: What it is? How does it work? And, how does it learn? We will review how other researchers have applied HDC and demonstrate how it can be used for solving cybersecurity tasks.  
Where deep learning fails, HDC excels. No supercomputer? No problem. HDC offers interpretability, low energy requirements, robustness to errors, online learning, on-device learning, and more. By pushing the difficult calculations into the embedding process, learning becomes a cinch. By the end of this talk, attendees will have everything they need to teach their own hyperdimensional computing models.
 recording release: no  

20. Building Custom Data Structures Using Abstract Collections
Daniel Schelkoph

Python’s abstract base classes (ABCs) in the `collections.abc` module provide a powerful way to create objects that behave like built-in data structures such as dictionaries, lists, and sets. In this talk, we’ll explore how these abstract collections work, why they’re useful, and how they enable seamless integration into Python’s ecosystem. Additionally, we will explain the Mixin design pattern and provide concrete examples of implementing an abstract collection. This session is perfect for attendees looking to learn more about Python's design philosophy and make their code more Pythonic.
 recording release: yes license: CC BY-NC-SA  

21. Tune-Up Your Knowledge: A Beginner's Journey Under the Hood of Search Engines
Eddie Mitchell

Many people drive their cars around all day and never look under the hood. Likewise, search is used every day, millions of times, with very little thought for how those results appear on your device. While I can't build a car engine from scratch (yet), I can build a search engine! (mostly).  
In this talk, we'll take a beginner-friendly approach to discussing how search engines work under the hood while building one from scratch in Python along the way. We'll discuss some history of search, demonstrate common data structures that make search engines fast and effective, and review how we can get results in a meaningful order.  
We'll also take a high-level look at machine learning models and how vector embeddings can easily understand similarity and influence search results.  
This talk is for those interested in taking a beginner's peek under the hood to understand some of the techniques used. No prior experience with information retrieval required—just bring your curiosity about what really happens when you type a query into that search bar.
 recording release: yes license: CC BY-NC-SA  

22. A Bug's Life
Tathagata Dasgupta

A beginner friendly talk that goes from the manifestation of a bug in production, traces it all the way to its inception, and asks what other than code needs to change to ship faster and NOT break things.

We open with the support rotation pager going off as customers of a low latency realtime system report an outage. With every second of downtime resulting in revenue loss, it is all hands on deck for the site reliability team, Dev team, data team, product owners are peeling down the stack. We will see the to the commit messages in polyglot systems that caused the failure, the bug getting squashed, hotfix getting shipped and crisis is averted.

Cut to the blameless postmortem - the real life challenges of issue resolution that is more than changing lines in code, debugging workflows, monitoring gaps, testing limitations, navigating change management processes, team dynamics. for each of these pillars we will see what allowed the teams to shift left, and shorten a bug's lifecycle.

What does the audience get out of it:  
Modern software deployments are complex and dynamic ecosystems, an ideal breeding ground for bugs. In a way, the lifecycle of a bug, reveals the truth about the software development lifecycle of a product.   
This talk takes learnings from multiple real life outages and tries to condense it as a shift-left journey by Continuous Questioning how can we catch bugs in lower environments.
 recording release: yes license: CC BY-NC-SA  

23. Keynote
Jessica Garson

Keynote
 recording release: yes license: CC BY-NC-SA  

24. Lightning Talks


Lightning Talks are quick 5-minute (hard limit!) talks on any topics of interest to the PyOhio community. Anyone can present a Lightning Talk. Yes, even you! Slides are encouraged but not required!

A sign-up sheet will be posted in the lobby near registration. Talks will be selected and the order randomized. The talk list will be posted on this page once they are selected.
 recording release: yes license: CC BY-SA  

25. Sunday Welcome


(Needs description.) 
 recording release: yes license: CC BY-SA  

26. Write Apps for Your TV with Kodi and Python
Andrew Kubera

The open-source media player Kodi is designed to play videos and music on your TV, but it also comes with a plugin system that is programmable with Python. This talk will walk through writing a plugin for your set-top-box running Kodi, including packaging, debugging, and dealing with dependencies (there's no pip here).
 recording release: yes license: CC BY-NC-SA  

27. From Busy Waiting to Async Awaiting: A Journey from Iterators to asyncio
Vignesh Iyer

**Category:**  
Core python / Concurrency

**Description:**  
Ever wonder how Python’s iterator protocol connects all the way up to `asyncio`?

In this talk, we'll start with a gentle dive into the fundamentals of iterators, generators, coroutines and async coroutines, including how they work at a high level. From there, we will follow an exciting journey of a humble customer service line — starting with a single agent helping one customer at a time, gradually leveling it up into an efficient, concurrent system using generators, coroutines and asyncio. Through this journey, we'll explore how each concept builds on top of the previous one, all with clear runnable code.

**Python level:**  
Beginner - Intermediate

**Target audience:**  
If you are a beginner or an intermediate Python developer curios about Python's async capabilities, aiming to write more idiomatic python code (or just looking to flex on your teammates with some cool async python), this talk is for you.
 recording release: yes license: CC BY-NC-SA  

28. From Fortran to Python: A Conversation Across Generations of Scientific Computing
Rodrigo Silva Ferreira, Helianildes Silva Ferreira

What was it like to write scientific code before personal computers, IDEs, or instant feedback loops? In this talk, a mother and son — one who programmed in *Fortran* using punch cards and one who writes *Python* today in modern IDEs — reflect on how programming practices, tools, and mindsets have evolved across generations.

Through personal stories and a short demo of a scientific simulation, we compare the experience of coding the same computational model decades apart. This talk is less about syntax and more about what has changed (and what hasn’t) in how we approach problem-solving, debugging, and scientific thinking in code.

Whether you're a veteran programmer or just getting started, join us for a thoughtful, engaging, and intergenerational exploration of scientific computing — from punch cards to *Python* notebooks and modern IDEs.
 recording release: yes license: CC BY-NC-SA  

29. Finding Practical Applications for Your Passion Projects
Joe Kaufeld

Getting from "I'm passionate about this topic" to actually working in (or on) your dream is a wild leap. Lessons learned from traveling this path the hard way, from finding the right niche for your passion project to getting the right collaborators on board, can't be taught in a classroom.

These are some of the lessons formed over six years of growing an international charity from two through to 6000 volunteers across the globe. You'll learn tips on applying Python's ecosystem of third-party tools to your project's aim, assembling a diverse team that can assess the needs of a diverse world, and using Python-based tools to build your dream project.
 recording release: yes license: CC BY-NC-SA  

30. Bringing Ideas to Life with DIY IoT: Visualizing Noise Pollution with a Raspberry Pi and Python
Ryan Carroll

Discover how to harness the power of IoT to tackle real-world problems using affordable and accessible technology. In this talk, you'll learn how to build an IoT system from off-the-shelf components, collect data from sensors, and visualize the data to tell compelling stories.

In this talk I'll showcase a project where I used a Raspberry Pi, environmental sensor, and Python to measure and monitor noise levels. This project demonstrates how to design and implement an IoT solution from concept to deployment, including using InfluxDB and Grafana for real-time data visualization, all running in Docker.  
By the end of this talk, you'll have the skills to bring various pieces of technology together to solve real-world problems. Whether you're an enthusiast, developer, or researcher, this session will inspire you to apply open-source tools and inexpensive hardware in innovative ways to address the challenges in your every day life.
 recording release: yes license: CC BY-NC-SA  

31. Using Python in the Concrete Industry
Scott Windsor

Working in the concrete industry, I often found myself doing tasks that felt repetitive. Python has been great for automating these tasks, with the goal being to both increase efficiency and remove opportunities for human error, which can be costly in this business. Automating things has also taught me that seemingly simple tasks can be more complicated than they seem.

As part of this I will discuss libraries that I have found useful, including ezdxf, which can be used for drafting and creating files that can be read by CAD software.

Python really is a programming language for everyone, and can have a use case in places you might not expect.
 recording release: yes license: CC BY-NC-SA  

32. uv: Ultimate Victory over Installation and Dependency Chaos
Catherine Devlin

Did you recoil at the news that there's *yet another* hot new packaging tool to cram into your poor crowded brain?

Take heart, brain! It will be all right! uv is splendidly complete and gloriously simple to use. It's the single tool that can elegantly and easily replace the whole jumbled toolbox you've been using until now. See the essential simple usages of uv, and you'll be a believer.
 recording release: yes license: CC BY-NC-SA  

33. When Your SME Ghosts You: Using GenAI to Build a Database Documentation Agent
Denise Williams

Have you ever been handed a mystery database and told, “You’ll figure it out”... with no documentation, no SME, and no time?

In this session, I’ll share how I turned a frustrating (and very relatable) real-world problem into a capstone project for Kaggle's Gen AI 5 Day Intensive Course with Google: building a GenAI-powered Database Documentation Agent using Python, SQLite, and the Gemini API — aka what I like to call my SME Ghost Protocol.

I’ll walk through how I used GenAI to automatically generate natural language summaries, answer ad-hoc schema questions, and create entity relationship diagrams — even when human help wasn't available.

We'll dive into the challenges of working with GenAI as a "coding partner," designing prompts like communication plans, and lessons learned the hard way about iteration, hallucination, and debugging when you're flying solo.

Expect live demos, practical takeaways, a little workplace sarcasm, and ideas for how you can launch your own SME Ghost Protocol — because sometimes, GenAI is the only teammate who shows up.👻
 recording release: yes license: CC BY-NC-SA  

34. Quantum Computing with Python: From Qubits to Circuits
Temitope Adeniyi

Quantum Computing with Python: From Qubits to Circuits
------------------------------------------------------

Have you heard the buzz about quantum computing and wondered what it *actually* means? This beginner-friendly talk introduces the fundamentals of quantum computing using the language we all love; Python.

We’ll start by breaking down core quantum concepts like **qubits**, **superposition**, **entanglement**, and **quantum gates** in simple terms. Then, we’ll bring those ideas to life with real code using [Qiskit](https://qiskit.org/), a powerful open-source quantum computing framework built in Python.

You'll learn how to:

* Simulate qubits and quantum circuits
* Visualize quantum states and interference
* Run your own quantum circuits on a real IBM quantum computer (yes, free and live!)

Along the way, we’ll highlight where quantum computing stands today, where Python fits in the ecosystem, and how you can get involved; whether you're a hobbyist, educator, or software developer.

No prior knowledge of quantum mechanics is needed. If you can write a 'for' loop, you can build your first quantum circuit.
 recording release: yes license: CC BY-NC-SA  

35. Introducing Labrea: How Embracing Declarative, Functional Programming Can Lead You Out of the Tar Pit
Austin Warner

As a multi-paradigm language, Python gives its users the freedom to solve problems in a vast number of ways. However, this freedom comes with a cost: we must resist the urge to use quick, unsustainable approaches in order to avoid the plague that is software complexity. For many real world problems, using familiar techniques like mutable state and imperative programming make it easier to complete the task while yielding a more complex codebase. In many cases, functional programming offers a way to write simpler code, but the difficulty of committing to it makes it impractical or unappealing to developers.

Inspired by the 2006 paper [*Out of the Tar Pit*](https://curtclifton.net/papers/MoseleyMarks06a.pdf), and the 2011 talk [*Simple Made Easy*](https://www.youtube.com/watch?v=SxdOUGdseq4) by Rich Hickey, [Labrea](https://github.com/8451/labrea) is a Python framework that seeks to make the happy path one that results in a simpler codebase that is functional, declarative, and composable. Learn about how Labrea allowed developers at 84.51º (Kroger) to pull the company's most complicated coupon recommender system out of the slow death march of software complexity, and how it might help you.
 recording release: yes license: CC BY-NC-SA  

36. Why Python Loops Are "Slow": A Gentle Introduction to Interpretation, Bytecode, and Fast Code
Tyler Riccio

Python loops are "slow", is a phrase every python programmer has heard. For better or worse, it is partially true. This talk breaks down how Python executes code and why that creates overhead, especially in tight loops. I'll also explore how tools like NumPy, SIMD, and JIT compilation achieve massive speedups by working with the CPU instead of against it.

You should walk away from this talk with more insight into why loops are slow, how python code is executed at a high level, and what you should do about it if anything.
 recording release: yes license: CC BY-NC-SA  

37. GDIOCSpider: Extracting and Identifying IOCs from the GDriveverse
Noah Dunn

Google Drive in recent years has become one of the most abused platforms for threat actors to conduct illegal and malicious activity. Threat actors use Google accounts to launch, store, and log malware, effectively turning Drive into a command and control center. On the side of legal and ethical activity, Google Drive remains a popular platform for security researchers to store these artifacts in summarized write-ups and spreadsheets of malicious and illegal activity observed. Much like an archaeologist looks for artifacts providing clues of the history of civilization, security researchers look for Indicators of Compromise (IOCs), which are clues to what a threat actor has done. Security engineers have worked across decades to build out tooling to analyze hard drives and network resources; however, similar advances to analyze Google Drive resources have remained underdeveloped. Along the same line, tools that aggregate and summarize collections of records on IOCs stored in Google Drive by researchers are also lacking.  
The GDIOCSpider (Google Drive IOC Spider) provides a tool for both of these use cases. This open-source, configurable, Python tool is capable of crawling through an entire Google Drive, analyzing its file contents, and searching for various defined IOC (Indicators of Compromise) types to extract. This tool outputs a summary of all discovered artifacts across all files, erasing the need for security researchers to manually sift through cloud stores. Supplementing the compromised account use case, the same tool can be used to aggregate IOCs collected in personal or corporate Google Drive accounts in the form of case records gathered by security researchers. This ‘environment agnostic’ approach is how GDIOCSpider enables security researchers to perform efficient IOC research in Google Drive.  
GDIOCSpider supports capabilities for both user accounts and service accounts through the Google Drive API. It has allowlist and denylist capabilities for both folders and files to prevent access of files with compliance and security restrictions. For those that are very interested in performing local IOC analysis and extraction, GDIOCSpider contains a build abstract tool ‘IOCFlagger’ within the context of the source code. IOCFlagger offers a rich IOC parser that is capable of both loose and strict matching for use cases where it is necessary to search within a string, or simply match a string to an IOC type exactly. The full suite of tools under the GDIOCSpider’s umbrella enables the user or team operating it to enter the “GDriveverse” of Google account incident response, and provide meaningful data for case work and research.
 recording release: yes license: CC BY-NC-SA  

38. Developing a System Maintenance Plan and Utilizing Python to Aid in System Maintenance
Joseph Guzi

Overtime, systems can experience rapid growth and become unstable without proper management. Managing that growth while maintaining the system can become a challenge. We will explore system maintenance in the context of a Geographic Information Systems (GIS) Team’s plan for GIS system maintenance. We will go over the reasons for having a system maintenance plan, the components of our plan, and things to consider when making your own maintenance plan.
 recording release: yes license: CC BY-NC-SA  

39. Organizing and Maintaining Your Code-Scape with Python
Matt Lavin

If you're a software engineer, a data scientist, or almost any other type of developer, you're probably familiar with the idea of writing well-organized, reusable code. Principles like DRY ("Don't Repeat Yourself") and ETC ("Easy to Change") are powerful heuristics at the line-by-line level of code. Design concepts like modularity, decoupling, MVC ("Model-View-Controller") and "Fat Model, Skinny Controller" can help you make software-level organizing decisions. Resources for project-level organization (code, data, documentation, etc.) are abundant and growing fast. Putting all this together in a useful way can be challenging, but there's no shortage of advice, resources, or templates in any of these areas. By comparison, material related to effective organization at the level of the coder's file system or source tree is sparse, harder to find, or designed for a more general audience. This talk uses "code-scape" as an umbrella term to consolidate ideas about organizing files and folders, maintaining your codebase, building a second brain, digital filing systems, etc. and shares examples of how you can use lightweight Python scripts to help keep your code-scape organized, searchable, and safeguarded.
 recording release: yes license: CC BY-NC-SA  

40. A Very Brief Overview of Python’s “Lang” AI Tools and Two Low-Code GUI AI Tools: Flowise and n8n
Curtis Oneal

AI is the theme of the moment - and even as a pythonista you might not know where to begin, or you may have started as you had time - and wished to go further. This talk is a guide about where some have gone, and where you might want to go with AI in python. But it is not the last stop. This talk is designed to be a stating guide to move from hobbyist level AI learning to more production-ready coding.

Often where you begin is with some of the low-code GUI tools - for instance Flowise [ flowiseai.com] - where with a api key and some clicks you can quickly build a chatbot - and then you leant to add complexity - maybe you pull out some embeddable code -or start to have more than one agent talk to each other, or with some walk-throughs you build a knowledge-base of documents for your bot ( a RAG - Retrieval Augmented Generation ) and now it knows - all your recipes.

Later you want to give your bot some "hands" or rather tools and later you connect to N8N [n8n.io] - which is a flexible workflow automation. You've made your bot reach out into the world to do something (aka made it "Agentic").

But then you want more control - and stability - so you look to do what you previously did in low-code- directly in python, with a view to production.

This is when you look to the "Lang" flavor tools: Langchain, Langflow, Langraph, and Langsmith.

Given the time, this will be a very quick tour of these concepts with both images and code shown - so it won't be a line-by line build along. A repo and suggested resources will be provided at the end.
 recording release: yes license: CC BY-NC-SA  

41. Beyond the Benchmark: Why the “Best” Python Dependency Manager Might Not Be Best for You
Keming He

**Ever wondered why your team still uses pip when benchmarks show alternatives are 10x faster?** The answer lies beyond raw performance metrics.

In this myth-busting session, I'll reveal surprising insights from analyzing thousands of GitHub repositories and real-world implementation case studies. You'll discover why technical superiority doesn't always translate to organizational success, and how to navigate the complex decision landscape of Python dependency management.

I'll share:  
- ⚡ Eye-opening performance comparisons between UV, Poetry, Conda, and pip+pyenv  
- 📊 Actual adoption statistics that challenge conventional wisdom  
- 💼 ROI calculations that factor in both technical AND human costs  
- 🛣️ A decision framework for selecting the right tool for YOUR specific context

Whether you're contemplating a migration, advocating for better tooling, or simply curious about the evolving Python ecosystem, you'll leave with actionable insights that balance technical excellence with organizational reality.

Don't miss this data-driven exploration of Python's most underappreciated infrastructure challenge!
 recording release: yes license: CC BY-NC-SA  

42. Keynote
Leon Adato

Keynote
 recording release: yes license: CC BY-NC-SA  

43. Closing Remarks


(Needs description.) 
 recording release: yes license: CC BY-SA  



Location
--------
Ballroom D


About the group
---------------
===
https://PyOhio.org

Founded in 2008, PyOhio is a free annual Python programming language community conference based in Ohio. Content ranges from beginner to advanced and is intended to be relevant to all types of Python users: students, software professionals, scientists, hobbyists, and anyone looking to learn more.