diff --git a/pyohio-2025/category.json b/pyohio-2025/category.json new file mode 100644 index 000000000..04b24e737 --- /dev/null +++ b/pyohio-2025/category.json @@ -0,0 +1,3 @@ +{ + "title": "PyOhio 2025" +} \ No newline at end of file diff --git a/pyohio-2025/videos/a-bug-s-life.json b/pyohio-2025/videos/a-bug-s-life.json new file mode 100644 index 000000000..cf3a24f88 --- /dev/null +++ b/pyohio-2025/videos/a-bug-s-life.json @@ -0,0 +1,26 @@ +{ + "description": "A beginner friendly talk that goes from the manifestation of a bug in\nproduction, traces it all the way to its inception, and asks what other\nthan code needs to change to ship faster and NOT break things.\n\nWe open with the support rotation pager going off as customers of a low\nlatency realtime system report an outage. With every second of downtime\nresulting in revenue loss, it is all hands on deck for the site\nreliability team, Dev team, data team, product owners are peeling down\nthe stack. We will see the to the commit messages in polyglot systems\nthat caused the failure, the bug getting squashed, hotfix getting\nshipped and crisis is averted.\n\nCut to the blameless postmortem - the real life challenges of issue\nresolution that is more than changing lines in code, debugging\nworkflows, monitoring gaps, testing limitations, navigating change\nmanagement processes, team dynamics. for each of these pillars we will\nsee what allowed the teams to shift left, and shorten a bug's lifecycle.\n\n| What does the audience get out of it:\n| Modern software deployments are complex and dynamic ecosystems, an\n ideal breeding ground for bugs. In a way, the lifecycle of a bug,\n reveals the truth about the software development lifecycle of a\n product.\n| This talk takes learnings from multiple real life outages and tries to\n condense it as a shift-left journey by Continuous Questioning how can\n we catch bugs in lower environments.\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/a-bug-s-life" + } + ], + "speakers": [ + "Tathagata Dasgupta" + ], + "thumbnail_url": "https://i.ytimg.com/vi/D7FM7Js0GHg/maxresdefault.jpg", + "title": "A Bug's Life", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=D7FM7Js0GHg" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/a-very-brief-overview-of-pythons-lang-ai-tools-and-two-low-code-gui-ai-tools-flowise-and-n8n.json b/pyohio-2025/videos/a-very-brief-overview-of-pythons-lang-ai-tools-and-two-low-code-gui-ai-tools-flowise-and-n8n.json new file mode 100644 index 000000000..d5cae99be --- /dev/null +++ b/pyohio-2025/videos/a-very-brief-overview-of-pythons-lang-ai-tools-and-two-low-code-gui-ai-tools-flowise-and-n8n.json @@ -0,0 +1,26 @@ +{ + "description": "AI is the theme of the moment - and even as a pythonista you might not\nknow where to begin, or you may have started as you had time - and\nwished to go further. This talk is a guide about where some have gone,\nand where you might want to go with AI in python. But it is not the last\nstop. This talk is designed to be a stating guide to move from hobbyist\nlevel AI learning to more production-ready coding.\n\nOften where you begin is with some of the low-code GUI tools - for\ninstance Flowise [ flowiseai.com] - where with a api key and some clicks\nyou can quickly build a chatbot - and then you leant to add complexity -\nmaybe you pull out some embeddable code -or start to have more than one\nagent talk to each other, or with some walk-throughs you build a\nknowledge-base of documents for your bot ( a RAG - Retrieval Augmented\nGeneration ) and now it knows - all your recipes.\n\nLater you want to give your bot some \"hands\" or rather tools and later\nyou connect to N8N [n8n.io] - which is a flexible workflow automation.\nYou've made your bot reach out into the world to do something (aka made\nit \"Agentic\").\n\nBut then you want more control - and stability - so you look to do what\nyou previously did in low-code- directly in python, with a view to\nproduction.\n\nThis is when you look to the \"Lang\" flavor tools: Langchain, Langflow,\nLangraph, and Langsmith.\n\nGiven the time, this will be a very quick tour of these concepts with\nboth images and code shown - so it won't be a line-by line build along.\nA repo and suggested resources will be provided at the end.\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/a-very-brief-overview-of-pythons-lang-ai-tools-and-two-low-code" + } + ], + "speakers": [ + "Curtis Oneal" + ], + "thumbnail_url": "https://i.ytimg.com/vi/B700zoxyVHY/maxresdefault.jpg", + "title": "A Very Brief Overview of Python\u2019s \u201cLang\u201d AI Tools and Two Low-Code GUI AI Tools: Flowise and n8n", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=B700zoxyVHY" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/beyond-the-benchmark-why-the-best-python-dependency-manager-might-not-be-best-for-you.json b/pyohio-2025/videos/beyond-the-benchmark-why-the-best-python-dependency-manager-might-not-be-best-for-you.json new file mode 100644 index 000000000..a2b0377f6 --- /dev/null +++ b/pyohio-2025/videos/beyond-the-benchmark-why-the-best-python-dependency-manager-might-not-be-best-for-you.json @@ -0,0 +1,26 @@ +{ + "description": "**Ever wondered why your team still uses pip when benchmarks show\nalternatives are 10x faster?** The answer lies beyond raw performance\nmetrics.\n\nIn this myth-busting session, I'll reveal surprising insights from\nanalyzing thousands of GitHub repositories and real-world implementation\ncase studies. You'll discover why technical superiority doesn't always\ntranslate to organizational success, and how to navigate the complex\ndecision landscape of Python dependency management.\n\n| I'll share:\n| - \u26a1 Eye-opening performance comparisons between UV, Poetry, Conda,\n and pip+pyenv\n| - \ud83d\udcca Actual adoption statistics that challenge conventional wisdom\n| - \ud83d\udcbc ROI calculations that factor in both technical AND human costs\n| - \ud83d\udee3\ufe0f A decision framework for selecting the right tool for YOUR\n specific context\n\nWhether you're contemplating a migration, advocating for better tooling,\nor simply curious about the evolving Python ecosystem, you'll leave with\nactionable insights that balance technical excellence with\norganizational reality.\n\nDon't miss this data-driven exploration of Python's most\nunderappreciated infrastructure challenge!\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/beyond-the-benchmark" + } + ], + "speakers": [ + "Keming He" + ], + "thumbnail_url": "https://i.ytimg.com/vi/ncKno_9NgZs/maxresdefault.jpg", + "title": "Beyond the Benchmark: Why the \u201cBest\u201d Python Dependency Manager Might Not Be Best for You", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=ncKno_9NgZs" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/beyond-the-black-box-interpreting-ml-models-with-shap.json b/pyohio-2025/videos/beyond-the-black-box-interpreting-ml-models-with-shap.json new file mode 100644 index 000000000..899f31fba --- /dev/null +++ b/pyohio-2025/videos/beyond-the-black-box-interpreting-ml-models-with-shap.json @@ -0,0 +1,26 @@ +{ + "description": "ML models behave as a black box in most scenarios. Model predicts or\nprovides a certain output but it is very difficult to generate any\nactionable insights directly. This is mostly because we generally have\nno idea which features are contributing the most to the model behavior\ninternally. SHAP provides a certain way to explain model predictions,\nand can act as an important tool in a data scientist\u2019s toolbox.\n\nIn this talk, we will begin by explaining to the audience the need for\nexplainable ML models and why it is important to understand beyond what\nthe model outputs. We will then briefly go over the mathematical\nintuition behind Shapley values and its origins from game theory. After\nthat we will walk through a couple of case studies of tree based and\nneural network based models. We will be focusing on interpretation of\nSHAP through various plots using the shap library in Python. Finally, we\nwill discuss the best practices for interpreting SHAP visualizations,\nhandling large datasets, and common pitfalls to avoid.\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/beyond-the-black-box" + } + ], + "speakers": [ + "Avik Basu" + ], + "thumbnail_url": "https://i.ytimg.com/vi/8wZ81oyWtxc/maxresdefault.jpg", + "title": "Beyond the Black Box: Interpreting ML Models with SHAP", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=8wZ81oyWtxc" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/bringing-ideas-to-life-with-diy-iot-visualizing-noise-pollution-with-a-raspberry-pi-and-python.json b/pyohio-2025/videos/bringing-ideas-to-life-with-diy-iot-visualizing-noise-pollution-with-a-raspberry-pi-and-python.json new file mode 100644 index 000000000..57f6175cb --- /dev/null +++ b/pyohio-2025/videos/bringing-ideas-to-life-with-diy-iot-visualizing-noise-pollution-with-a-raspberry-pi-and-python.json @@ -0,0 +1,26 @@ +{ + "description": "Discover how to harness the power of IoT to tackle real-world problems\nusing affordable and accessible technology. In this talk, you'll learn\nhow to build an IoT system from off-the-shelf components, collect data\nfrom sensors, and visualize the data to tell compelling stories.\n\n| In this talk I'll showcase a project where I used a Raspberry Pi,\n environmental sensor, and Python to measure and monitor noise levels.\n This project demonstrates how to design and implement an IoT solution\n from concept to deployment, including using InfluxDB and Grafana for\n real-time data visualization, all running in Docker.\n| By the end of this talk, you'll have the skills to bring various\n pieces of technology together to solve real-world problems. Whether\n you're an enthusiast, developer, or researcher, this session will\n inspire you to apply open-source tools and inexpensive hardware in\n innovative ways to address the challenges in your every day life.\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/bringing-ideas-to-life-with-diy-iot" + } + ], + "speakers": [ + "Ryan Carroll" + ], + "thumbnail_url": "https://i.ytimg.com/vi/RtvgQLkzj1s/maxresdefault.jpg", + "title": "Bringing Ideas to Life with DIY IoT: Visualizing Noise Pollution with a Raspberry Pi and Python", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=RtvgQLkzj1s" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/chasten-your-python-program-configurable-program-analysis-and-linting-with-xpath.json b/pyohio-2025/videos/chasten-your-python-program-configurable-program-analysis-and-linting-with-xpath.json new file mode 100644 index 000000000..838fd9a3c --- /dev/null +++ b/pyohio-2025/videos/chasten-your-python-program-configurable-program-analysis-and-linting-with-xpath.json @@ -0,0 +1,26 @@ +{ + "description": "Abstract\n--------\n\n| Stop wrestling with regular expressions (regex) and complex abstract\n syntax tree\n| (AST)-based frameworks to analyze and lint your Python code! Chasten\n offers an\n| elegant solution by leveraging XPath expressions to search Python's\n abstract\n| syntax tree, making static code analysis both powerful and accessible.\n In this\n| talk, you'll discover how to implement custom linting rules, enforce\n coding\n| standards, and perform sophisticated pattern matching in your Python\n projects\n| using a tool designed for both simplicity and flexibility. Whether\n you're a\n| developer tired of writing fragile regex patterns, an instructor\n validating\n| student code, or a project maintainer who wants to ensure code\n quality, Chasten\n| provides the perfect balance of power and usability for your static\n analysis\n| needs. More details about chasten are available at:\n| https://github.com/AstuteSource/chasten.\n\nKey Takeaways\n-------------\n\n- Create custom linting rules through simple YAML configuration\n- Practical examples of enforcing code standards on documentation and\n code\n- Ways to analyze results through interactive dashboards with Datasette\n- How to integrate Chasten into development workflow and CI/CD\n pipelines\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/chasten-your-python-program" + } + ], + "speakers": [ + "Gregory M. Kapfhammer" + ], + "thumbnail_url": "https://i.ytimg.com/vi/DkbYq-N8AIA/maxresdefault.jpg", + "title": "Chasten Your Python Program: Configurable Program Analysis and Linting with XPath", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=DkbYq-N8AIA" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/demystifying-ai-agents-with-python-code.json b/pyohio-2025/videos/demystifying-ai-agents-with-python-code.json new file mode 100644 index 000000000..8d18b02db --- /dev/null +++ b/pyohio-2025/videos/demystifying-ai-agents-with-python-code.json @@ -0,0 +1,26 @@ +{ + "description": "Everyone\u2019s talking about AI Agents! But what are they, and how can you\nbuild them? This talk cuts through the hype. Drawing on a year spent\ndeveloping a GenAI platform, I'll show you that creating powerful AI\nAgents is within your reach, no advanced degree required.\n\nWe\u2019ll define agents practically: Large Language Models combined with\ntools and memory. Moving beyond the abstract definition, I\u2019ll show you\nhow to build your first agent using the OpenAI Python SDK and\nfundamental Python concepts you\u2019re already familiar with: functions,\nloops, and conditions. From there, I will demonstrate how you can use\nthe CrewAI framework to abstract away the boilerplate code, allowing for\nsimpler setup of multi-agent systems.\n\nBy the end, you won't just understand agents; you'll be equipped and\ninspired to build your own, ready to tackle custom tasks by integrating\nthe APIs that matter to you.\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/demystifying-ai-agents-with-python-code" + } + ], + "speakers": [ + "William Horton" + ], + "thumbnail_url": "https://i.ytimg.com/vi/jOEdb9HnwsQ/maxresdefault.jpg", + "title": "Demystifying AI Agents with Python Code", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=jOEdb9HnwsQ" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/deploy-django-gitops-kubernetes-made-easy.json b/pyohio-2025/videos/deploy-django-gitops-kubernetes-made-easy.json new file mode 100644 index 000000000..ed427bada --- /dev/null +++ b/pyohio-2025/videos/deploy-django-gitops-kubernetes-made-easy.json @@ -0,0 +1,26 @@ +{ + "description": "Deploying code shouldn\u2019t be stressful. But too often, the journey from\nlocal dev to production is fragile, manual, and hard to debug. This talk\nis about building peace of mind into your pipeline \u2014 with GitOps,\nKubernetes, and open source tools like Argo CD that make continuous\ndelivery predictable, repeatable, and scalable from the very first\nrelease to the 50th.\n\nWe\u2019ll tackle the realities of \u201cday two\u201d DevOps \u2014 what happens after the\nfirst deploy. From managing rollbacks and coordinating releases to\nenforcing consistency across dev, staging, and production, you\u2019ll learn\nhow to bring stability and scalability to your delivery pipeline.\n\nIn a live demo, we\u2019ll deploy a full stack Django app from GitHub to\nproduction using Argo CD and GitHub Actions \u2014 with observability,\nrollback strategies, and environment parity built in from the start.\n\n| **You\u2019ll learn how to:**\n| - Set up a GitOps-based CI/CD pipeline that works across all\n environments\n| - Automate rollouts, rollbacks, and version control of infrastructure\n| - Understand why Kubernetes is a future-proof platform for Django\n teams\n| - Gain confidence in releasing updates safely, consistently, and at\n scale\n| - Leverage open source tools to eliminate manual deployment headaches\n\nWhether you're writing the code or leading the team, you'll leave with a\nclear, practical blueprint for shipping faster \u2014 and with fewer\nsurprises.\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/deploy-django" + } + ], + "speakers": [ + "Calvin Hendryx-Parker" + ], + "thumbnail_url": "https://i.ytimg.com/vi/H7GMjMgue14/maxresdefault.jpg", + "title": "Deploy Django: GitOps & Kubernetes Made Easy", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=H7GMjMgue14" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/detecting-road-conditions-from-space-using-pytorch-public-data-and-free-satellite-imagery.json b/pyohio-2025/videos/detecting-road-conditions-from-space-using-pytorch-public-data-and-free-satellite-imagery.json new file mode 100644 index 000000000..7bb91a503 --- /dev/null +++ b/pyohio-2025/videos/detecting-road-conditions-from-space-using-pytorch-public-data-and-free-satellite-imagery.json @@ -0,0 +1,26 @@ +{ + "description": "Monitoring the health of city streets and roadways is expensive,\ntime-consuming, and often reactive. But what if we could automate part\nof that process using satellite imagery and Python?\n\nIn this talk, we\u2019ll walk through a real-world project that combines\ntransfer learning, PyTorch, and publicly available datasets to classify\nroad segment conditions (good, fair, poor) from aerial imagery. You'll\nlearn how to work with messy real-world geospatial data, fine-tune a\ndeep learning model using only a small training set (~2,000 examples),\nand overcome common challenges like blurry imagery, inconsistent labels,\nand overfitting.\n\nThis session is practical and code-driven, aimed at data scientists and\nanalysts working in mobility analytics, urban development, or\ninfrastructure who want to apply machine perception techniques in their\nwork. By the end, you\u2019ll walk away with a reusable workflow for\nanalyzing and predicting urban infrastructure quality \u2014 all using free\ntools and open data.\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/detecting-road-conditions-from-space-using-pytorch-public-data" + } + ], + "speakers": [ + "Cynthia Ukawu" + ], + "thumbnail_url": "https://i.ytimg.com/vi/-V3-8Ocq2rQ/maxresdefault.jpg", + "title": "Detecting Road Conditions from Space Using PyTorch, Public Data, and Free Satellite Imagery", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=-V3-8Ocq2rQ" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/developing-a-system-maintenance-plan-and-utilizing-python-to-aid-in-system-maintenance.json b/pyohio-2025/videos/developing-a-system-maintenance-plan-and-utilizing-python-to-aid-in-system-maintenance.json new file mode 100644 index 000000000..6e2c86f03 --- /dev/null +++ b/pyohio-2025/videos/developing-a-system-maintenance-plan-and-utilizing-python-to-aid-in-system-maintenance.json @@ -0,0 +1,26 @@ +{ + "description": "Overtime, systems can experience rapid growth and become unstable\nwithout proper management. Managing that growth while maintaining the\nsystem can become a challenge. We will explore system maintenance in the\ncontext of a Geographic Information Systems (GIS) Team\u2019s plan for GIS\nsystem maintenance. We will go over the reasons for having a system\nmaintenance plan, the components of our plan, and things to consider\nwhen making your own maintenance plan.\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/developing-a-system-maintenance-plan-and-utilizing-python-to-aid" + } + ], + "speakers": [ + "Joseph Guzi" + ], + "thumbnail_url": "https://i.ytimg.com/vi/6LRP-Yjf694/maxresdefault.jpg", + "title": "Developing a System Maintenance Plan and Utilizing Python to Aid in System Maintenance", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=6LRP-Yjf694" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/finding-practical-applications-for-your-passion-projects.json b/pyohio-2025/videos/finding-practical-applications-for-your-passion-projects.json new file mode 100644 index 000000000..2f2f936e2 --- /dev/null +++ b/pyohio-2025/videos/finding-practical-applications-for-your-passion-projects.json @@ -0,0 +1,26 @@ +{ + "description": "Getting from \"I'm passionate about this topic\" to actually working in\n(or on) your dream is a wild leap. Lessons learned from traveling this\npath the hard way, from finding the right niche for your passion project\nto getting the right collaborators on board, can't be taught in a\nclassroom.\n\nThese are some of the lessons formed over six years of growing an\ninternational charity from two through to 6000 volunteers across the\nglobe. You'll learn tips on applying Python's ecosystem of third-party\ntools to your project's aim, assembling a diverse team that can assess\nthe needs of a diverse world, and using Python-based tools to build your\ndream project.\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/finding-practical-applications-for-your-passion-projects" + } + ], + "speakers": [ + "Joe Kaufeld" + ], + "thumbnail_url": "https://i.ytimg.com/vi/hM84dVEr2ZY/maxresdefault.jpg", + "title": "Finding Practical Applications for Your Passion Projects", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=hM84dVEr2ZY" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/from-data-to-insights-in-minutes-accelerating-predictive-modelling-in-python-with-automl.json b/pyohio-2025/videos/from-data-to-insights-in-minutes-accelerating-predictive-modelling-in-python-with-automl.json new file mode 100644 index 000000000..2ea01a384 --- /dev/null +++ b/pyohio-2025/videos/from-data-to-insights-in-minutes-accelerating-predictive-modelling-in-python-with-automl.json @@ -0,0 +1,26 @@ +{ + "description": "Have you ever wondered how Machine Learning could automate your tasks\nbut hesitated due to time constraints or a lack of specialized coding\nskills? If so, this session is for you!\n\nTraditionally, building predictive models required specialized coding\nabilities and a deep understanding of statistical concepts. However,\nAutoML simplifies this process and can automatically create machine\nlearning models from your data. This session will empower you to use a\nsimple, open-source AutoML tool to quickly create Python-based machine\nlearning prototypes (using the pandas, NumPy, and scikit-learn\nframeworks) without writing any code. A live demonstration will show how\nAutoML seamlessly (i) processes input data, (ii) selects and trains the\nbest algorithms for your specific use case, (iii) generates reproducible\nPython code for easy integration, and most importantly, (iv) how to\ninterpret the results.\n\nDiscover how AutoML can turn your transform your data into actionable\ninsights!\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/from-data-to-insights-in-minutes" + } + ], + "speakers": [ + "Shailaja Sampat" + ], + "thumbnail_url": "https://i.ytimg.com/vi/wXrkahS1KUo/maxresdefault.jpg", + "title": "From Data to Insights in Minutes: Accelerating Predictive Modelling (in Python) with AutoML", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=wXrkahS1KUo" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/from-forge-to-keyboard-crafting-a-developers-journey.json b/pyohio-2025/videos/from-forge-to-keyboard-crafting-a-developers-journey.json new file mode 100644 index 000000000..65edd9220 --- /dev/null +++ b/pyohio-2025/videos/from-forge-to-keyboard-crafting-a-developers-journey.json @@ -0,0 +1,26 @@ +{ + "description": "What do metalsmithing, managing a manufacturing floor, and raising\nchildren have to do with writing code? More than you might think.\n\nThrough stories of precision, adaptability, and resilience, I'll show\nhow non-technical experiences have helped me to thrive in tech. From\niteration at my forge, troubleshooting on the manufacturing floor, and\nto building empathy as a parent I'll share how life's lessons have built\ntransferable skills.\n\nWhether you're a seasoned professional or a new developer, this session\nwill inspire you to embrace your own journey and discover the hidden\nstrengths you can bring to the table.\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/from-forge-to-keyboard" + } + ], + "speakers": [ + "Bianca Ploss" + ], + "thumbnail_url": "https://i.ytimg.com/vi/dUI1Yf9IoNs/maxresdefault.jpg", + "title": "From Forge to Keyboard: Crafting a Developer\u2019s Journey", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=dUI1Yf9IoNs" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/from-fortran-to-python-a-conversation-across-generations-of-scientific-computing.json b/pyohio-2025/videos/from-fortran-to-python-a-conversation-across-generations-of-scientific-computing.json new file mode 100644 index 000000000..327f2ef97 --- /dev/null +++ b/pyohio-2025/videos/from-fortran-to-python-a-conversation-across-generations-of-scientific-computing.json @@ -0,0 +1,27 @@ +{ + "description": "What was it like to write scientific code before personal computers,\nIDEs, or instant feedback loops? In this talk, a mother and son \u2014 one\nwho programmed in *Fortran* using punch cards and one who writes\n*Python* today in modern IDEs \u2014 reflect on how programming practices,\ntools, and mindsets have evolved across generations.\n\nThrough personal stories and a short demo of a scientific simulation, we\ncompare the experience of coding the same computational model decades\napart. This talk is less about syntax and more about what has changed\n(and what hasn\u2019t) in how we approach problem-solving, debugging, and\nscientific thinking in code.\n\nWhether you're a veteran programmer or just getting started, join us for\na thoughtful, engaging, and intergenerational exploration of scientific\ncomputing \u2014 from punch cards to *Python* notebooks and modern IDEs.\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/from-fortran-to-python" + } + ], + "speakers": [ + "Rodrigo Silva Ferreira", + "Helianildes Silva Ferreira" + ], + "thumbnail_url": "https://i.ytimg.com/vi/qvLZpdb_XqA/maxresdefault.jpg", + "title": "From Fortran to Python: A Conversation Across Generations of Scientific Computing", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=qvLZpdb_XqA" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/gdiocspider-extracting-and-identifying-iocs-from-the-gdriveverse.json b/pyohio-2025/videos/gdiocspider-extracting-and-identifying-iocs-from-the-gdriveverse.json new file mode 100644 index 000000000..8e35e8119 --- /dev/null +++ b/pyohio-2025/videos/gdiocspider-extracting-and-identifying-iocs-from-the-gdriveverse.json @@ -0,0 +1,26 @@ +{ + "description": "| Google Drive in recent years has become one of the most abused\n platforms for threat actors to conduct illegal and malicious activity.\n Threat actors use Google accounts to launch, store, and log malware,\n effectively turning Drive into a command and control center. On the\n side of legal and ethical activity, Google Drive remains a popular\n platform for security researchers to store these artifacts in\n summarized write-ups and spreadsheets of malicious and illegal\n activity observed. Much like an archaeologist looks for artifacts\n providing clues of the history of civilization, security researchers\n look for Indicators of Compromise (IOCs), which are clues to what a\n threat actor has done. Security engineers have worked across decades\n to build out tooling to analyze hard drives and network resources;\n however, similar advances to analyze Google Drive resources have\n remained underdeveloped. Along the same line, tools that aggregate and\n summarize collections of records on IOCs stored in Google Drive by\n researchers are also lacking.\n| The GDIOCSpider (Google Drive IOC Spider) provides a tool for both of\n these use cases. This open-source, configurable, Python tool is\n capable of crawling through an entire Google Drive, analyzing its file\n contents, and searching for various defined IOC (Indicators of\n Compromise) types to extract. This tool outputs a summary of all\n discovered artifacts across all files, erasing the need for security\n researchers to manually sift through cloud stores. Supplementing the\n compromised account use case, the same tool can be used to aggregate\n IOCs collected in personal or corporate Google Drive accounts in the\n form of case records gathered by security researchers. This\n \u2018environment agnostic\u2019 approach is how GDIOCSpider enables security\n researchers to perform efficient IOC research in Google Drive.\n| GDIOCSpider supports capabilities for both user accounts and service\n accounts through the Google Drive API. It has allowlist and denylist\n capabilities for both folders and files to prevent access of files\n with compliance and security restrictions. For those that are very\n interested in performing local IOC analysis and extraction,\n GDIOCSpider contains a build abstract tool \u2018IOCFlagger\u2019 within the\n context of the source code. IOCFlagger offers a rich IOC parser that\n is capable of both loose and strict matching for use cases where it is\n necessary to search within a string, or simply match a string to an\n IOC type exactly. The full suite of tools under the GDIOCSpider\u2019s\n umbrella enables the user or team operating it to enter the\n \u201cGDriveverse\u201d of Google account incident response, and provide\n meaningful data for case work and research.\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/gdiocspider" + } + ], + "speakers": [ + "Noah Dunn" + ], + "thumbnail_url": "https://i.ytimg.com/vi/uiL5fcXXPVQ/maxresdefault.jpg", + "title": "GDIOCSpider: Extracting and Identifying IOCs from the GDriveverse", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=uiL5fcXXPVQ" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/graph-machine-learning-in-all-its-glory.json b/pyohio-2025/videos/graph-machine-learning-in-all-its-glory.json new file mode 100644 index 000000000..60ac419d8 --- /dev/null +++ b/pyohio-2025/videos/graph-machine-learning-in-all-its-glory.json @@ -0,0 +1,26 @@ +{ + "description": "Our world is complex: one approach to understanding and learning more\nabout relationships within the data is to represent it as a network or a\ngraph - with entities as nodes and relations between them as edges.\nNetwork applications are abundant - Facebook, knowledge databases like\nWikipedia, traffic routes, molecular pathways, and the fun starts when\nwe start thinking of the physical world as graphs. Where there\u2019s data,\nthere\u2019s uncertainty and the need to predict the future to make it a\nlittle less uncertain, which is why we need machine learning.\n\n**This talk will be about modeling one such network using a Graph Neural\nNetwork (GNN) and making some predictions on it using Deep Graph\nLibrary, an efficient and scalable open source framework to train and\nserve GNNs. While GNNs can be used for any ML task, we\u2019ll focus on\nbuilding a recommendation model.**\n\n**But the transition from traditional data structures to graph-based\nmodels is not straightforward. Unlike tabular data, graphs require\nadapting ML principles to accommodate their topological and relational\ncomplexities.**\n\n| This talk will help participants gain practical insights into modeling\n their data as graphs and leveraging GNNs to build a recommendation\n system. After the talk, the audience should have a good understanding\n about:\n| - How to structure their data as graph components and prepare it for\n modeling\n| - What a GNN is and how do we train, evaluate and serve models in DGL\n| - End-to-end ML tasks on graph data: best practices to avoid pitfalls\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/graph-machine-learning-in-all-its-glory" + } + ], + "speakers": [ + "Shreya Khurana" + ], + "thumbnail_url": "https://i.ytimg.com/vi/RLB83WFCAmg/maxresdefault.jpg", + "title": "Graph Machine Learning in All Its Glory!", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=RLB83WFCAmg" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/guardrails-an-alternative-view-of-safely-working-in-python.json b/pyohio-2025/videos/guardrails-an-alternative-view-of-safely-working-in-python.json new file mode 100644 index 000000000..407c63fdd --- /dev/null +++ b/pyohio-2025/videos/guardrails-an-alternative-view-of-safely-working-in-python.json @@ -0,0 +1,26 @@ +{ + "description": "Python \u2013 like many languages \u2013 lets you do things that are completely\ninadvisable. Many of the features that (left unchecked) allow you to do\ninadvisable things were used to achieve things that have since become\nnecessary and defining features of Python.\n\nPython \u2013 unlike many languages \u2013 discovered that leaving these obvious\nand necessary features lying around next to inadvisable things was a bad\nidea, and built guardrails around them.\n\nIn real life, guardrails are structures that make it easier to\nunderstand how to be safe in an area where there is otherwise danger. If\nrespected, guardrails make you safer, but unlike walls or fences,\nguardrails do not block you from danger.\n\nIn Python, features like decorators, context managers, async functions,\nimportlib, and more are all guardrails that let you work with less-safe\nPython machinery from a much safer distance.\n\nIn this talk, we\u2019re going to explore the idea of guardrails as a design\nphilosophy, and use that to explain Python\u2019s attitude to safely working\nwith the language and its internals.\n\nWe\u2019ll explore features of Python that are guardrails around less-safe\nfeatures \u2013 what features they replaced, how those features could be used\nincorrectly, and how the newer features allow you to use Python more\nsafely. As a special treat, you may also get to see how Python lets you\nabuse these features\\*.\n\nWe\u2019ll conclude with a discussion of how you can use Python\u2019s guardrail\nphilosophy in your own code.\n\n--------------\n\n(\\* SKILLED OPERATOR ON CLOSED CIRCUIT; DO NOT ATTEMPT)\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/guardrails" + } + ], + "speakers": [ + "Christopher Neugebauer" + ], + "thumbnail_url": "https://i.ytimg.com/vi/ITrSTncNgL8/maxresdefault.jpg", + "title": "Guardrails: An Alternative View of Safely Working in Python", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=ITrSTncNgL8" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/how-a-solo-hobbyist-learned-to-love-testing.json b/pyohio-2025/videos/how-a-solo-hobbyist-learned-to-love-testing.json new file mode 100644 index 000000000..d264d288f --- /dev/null +++ b/pyohio-2025/videos/how-a-solo-hobbyist-learned-to-love-testing.json @@ -0,0 +1,26 @@ +{ + "description": "I don\u2019t get paid to write code. I have no boss to answer to. I have no\npartner to work with. Most of the apps I produce are for me to use. When\nI was learning Python with online videos, I was introduced to testing. I\nfound it interesting, but it felt time consuming.\n\nThen I went back to an old app I had written and wanted to re-work. I\nwas lost. I couldn\u2019t even figure out where to begin to make it work\nagain. I slowly decided to integrate testing into my personal workflow\non projects. Then I came upon an unexpected benefit: by testing my code\nin a Django app, I was able to better learn what the library was doing\nto convert a request into a response. I knew the steps, but through\nwriting a test with an expected output and seeing the error messages on\nfailures, I now intuitively understand how this process works. This talk\nwill demonstrate that.\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/how-a-solo-hobbyist-learned-to-love-testing" + } + ], + "speakers": [ + "Carl James" + ], + "thumbnail_url": "https://i.ytimg.com/vi/pFOY3uHYTEI/maxresdefault.jpg", + "title": "How a Solo Hobbyist Learned to Love Testing", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=pFOY3uHYTEI" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/introducing-labrea-how-embracing-declarative-functional-programming-can-lead-you-out-of-the-tar-pit.json b/pyohio-2025/videos/introducing-labrea-how-embracing-declarative-functional-programming-can-lead-you-out-of-the-tar-pit.json new file mode 100644 index 000000000..cbabab58f --- /dev/null +++ b/pyohio-2025/videos/introducing-labrea-how-embracing-declarative-functional-programming-can-lead-you-out-of-the-tar-pit.json @@ -0,0 +1,26 @@ +{ + "description": "As a multi-paradigm language, Python gives its users the freedom to\nsolve problems in a vast number of ways. However, this freedom comes\nwith a cost: we must resist the urge to use quick, unsustainable\napproaches in order to avoid the plague that is software complexity. For\nmany real world problems, using familiar techniques like mutable state\nand imperative programming make it easier to complete the task while\nyielding a more complex codebase. In many cases, functional programming\noffers a way to write simpler code, but the difficulty of committing to\nit makes it impractical or unappealing to developers.\n\nInspired by the 2006 paper `Out of the Tar\nPit `__, and the\n2011 talk `Simple Made\nEasy `__ by Rich Hickey,\n`Labrea `__ is a Python framework that\nseeks to make the happy path one that results in a simpler codebase that\nis functional, declarative, and composable. Learn about how Labrea\nallowed developers at 84.51\u00ba (Kroger) to pull the company's most\ncomplicated coupon recommender system out of the slow death march of\nsoftware complexity, and how it might help you.\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/introducing-labrea" + } + ], + "speakers": [ + "Austin Warner" + ], + "thumbnail_url": "https://i.ytimg.com/vi/R4zZVjQwxUQ/maxresdefault.jpg", + "title": "Introducing Labrea: How Embracing Declarative, Functional Programming Can Lead You Out of the Tar Pit", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=R4zZVjQwxUQ" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/keynote-begin-with-the-end-in-mind-why-your-community-work-matters.json b/pyohio-2025/videos/keynote-begin-with-the-end-in-mind-why-your-community-work-matters.json new file mode 100644 index 000000000..028369d93 --- /dev/null +++ b/pyohio-2025/videos/keynote-begin-with-the-end-in-mind-why-your-community-work-matters.json @@ -0,0 +1,26 @@ +{ + "description": "In the world of open source, community work often begins with passion,\nbut to make it sustainable and impactful, we must begin with the end in\nmind. In this keynote, I will reflect on my journey from contributing to\nDjango Girls to leading PyLadies Ghana and building inclusive tech\ncommunities across Africa. Drawing lessons from open source leadership,\ncultural identity, and personal growth, we will explore what it truly\nmeans to build communities that outlast us. This talk challenges\nattendees to rethink community involvement not just as volunteering, but\nas systems-building, infused with purpose, clarity, and intention.\nThrough storytelling, reflection, and real-world examples, we will\nexperience how every contribution can create ripple effects of\nconfidence, leadership, and global impact.\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/abigail-mesrenyame-dogbe-keynote" + } + ], + "speakers": [ + "Abigail Mesrenyame Dogbe" + ], + "thumbnail_url": "https://i.ytimg.com/vi/kMxJI2Ik9cc/maxresdefault.jpg", + "title": "Keynote: Begin with the End in Mind: Why Your Community Work Matters", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=kMxJI2Ik9cc" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/keynote-looking-back-at-a-lifetime-of-poor-tech-choices.json b/pyohio-2025/videos/keynote-looking-back-at-a-lifetime-of-poor-tech-choices.json new file mode 100644 index 000000000..c27279b59 --- /dev/null +++ b/pyohio-2025/videos/keynote-looking-back-at-a-lifetime-of-poor-tech-choices.json @@ -0,0 +1,26 @@ +{ + "description": "Working in tech is a never-ending stream of choices: from the language,\nplatform, and framework we use to the vendors we put our trust (and\nmoney) in. Many of us live in fear that our next choice will turn sour,\nand will end up being a resume-generating event for us.\n\nIn reality, there is often a lot more good than you'd expect from those\nseemingly bad tech choices. In this session, I'll look back on several\nfailed implementations, poor calls, and wasted weekends to see, with the\nbenefit of hindsight, how they turned out to be decent decisions after\nall.\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/leon-adato-keynote" + } + ], + "speakers": [ + "Leon Adato" + ], + "thumbnail_url": "https://i.ytimg.com/vi/wB5JIT7rF0g/maxresdefault.jpg", + "title": "Keynote: Looking Back at a Lifetime of Poor Tech Choices", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=wB5JIT7rF0g" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/keynote-the-right-vibe-the-role-of-community-in-the-age-of-ai.json b/pyohio-2025/videos/keynote-the-right-vibe-the-role-of-community-in-the-age-of-ai.json new file mode 100644 index 000000000..cfc3cfa16 --- /dev/null +++ b/pyohio-2025/videos/keynote-the-right-vibe-the-role-of-community-in-the-age-of-ai.json @@ -0,0 +1,26 @@ +{ + "description": "This talk explores the evolution of coding to the current trend of vibe\ncoding, where one allows AI to take the wheel of programmatic decisions.\nUsing an AI assistant, Windsurf, the audience will experience vibe\ncoding in action and learn about the opportunities and challenges that\nexist in this new paradigm, as well as how they might impact programming\ncommunities such as PyOhio,\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/jessica-garson-keynote" + } + ], + "speakers": [ + "Jessica Garson" + ], + "thumbnail_url": "https://i.ytimg.com/vi/Zf1L7jqWnnI/maxresdefault.jpg", + "title": "Keynote: The Right Vibe: The Role of Community in the Age of AI", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=Zf1L7jqWnnI" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/lights-python-action.json b/pyohio-2025/videos/lights-python-action.json new file mode 100644 index 000000000..9b999d5d7 --- /dev/null +++ b/pyohio-2025/videos/lights-python-action.json @@ -0,0 +1,26 @@ +{ + "description": "Intended to be an entertaining overview of challenges faced and lessons\nlearned working on my first big maker project. Using code snippets,\npictures and short demos, I will discuss problems overcome while\ndeveloping new features and integrating new devices into my humble\nanimated sign, which includes lights along with rhythmic and melodic\ncomponents. I promise not to dance; no one wants to see that.\n\nThe intended audience is anyone interested in maker projects. I will\nalso be touching on introductory-level topics in type hinting; the\nstandard library modules abc, dataclasses, signal, and threading; and\nthe 3rd-party modules aiohttp, gpiozero, and requests.\n\n| ``Note on Photosensitivity:``\n| Based on `this epilepsy.com\n article `__,\n this presentation should be safe for any photosensitive audience\n member. I will include this information in a slide at the beginning of\n the presentation, and give anyone in the audience the chance to leave\n or ask questions before proceeding.\n\n- The sign project uses standard 60 watt incandescent bulbs, which are\n not capable of producing a strobe effect.\n- For further safety, during the presentation, bulbs will not cycle on\n and off more than 3 times per second.\n- Additionally, the room\u2019s lighting will not be darkened more than\n usual for a standard presentation.\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/lights-python-action" + } + ], + "speakers": [ + "Mike McCaffrey" + ], + "thumbnail_url": "https://i.ytimg.com/vi/-3euk5EPddU/maxresdefault.jpg", + "title": "Lights! Python! Action!", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=-3euk5EPddU" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/organizing-and-maintaining-your-code-scape-with-python.json b/pyohio-2025/videos/organizing-and-maintaining-your-code-scape-with-python.json new file mode 100644 index 000000000..541a5a912 --- /dev/null +++ b/pyohio-2025/videos/organizing-and-maintaining-your-code-scape-with-python.json @@ -0,0 +1,26 @@ +{ + "description": "If you're a software engineer, a data scientist, or almost any other\ntype of developer, you're probably familiar with the idea of writing\nwell-organized, reusable code. Principles like DRY (\"Don't Repeat\nYourself\") and ETC (\"Easy to Change\") are powerful heuristics at the\nline-by-line level of code. Design concepts like modularity, decoupling,\nMVC (\"Model-View-Controller\") and \"Fat Model, Skinny Controller\" can\nhelp you make software-level organizing decisions. Resources for\nproject-level organization (code, data, documentation, etc.) are\nabundant and growing fast. Putting all this together in a useful way can\nbe challenging, but there's no shortage of advice, resources, or\ntemplates in any of these areas. By comparison, material related to\neffective organization at the level of the coder's file system or source\ntree is sparse, harder to find, or designed for a more general audience.\nThis talk uses \"code-scape\" as an umbrella term to consolidate ideas\nabout organizing files and folders, maintaining your codebase, building\na second brain, digital filing systems, etc. and shares examples of how\nyou can use lightweight Python scripts to help keep your code-scape\norganized, searchable, and safeguarded.\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/organizing-and-maintaining-your-code-scape-with-python" + } + ], + "speakers": [ + "Matt Lavin" + ], + "thumbnail_url": "https://i.ytimg.com/vi/pD3SwklUD-s/maxresdefault.jpg", + "title": "Organizing and Maintaining Your Code-Scape with Python", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=pD3SwklUD-s" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/python-for-hardware-folks.json b/pyohio-2025/videos/python-for-hardware-folks.json new file mode 100644 index 000000000..95364313f --- /dev/null +++ b/pyohio-2025/videos/python-for-hardware-folks.json @@ -0,0 +1,26 @@ +{ + "description": "Python is a versatile language, and it\u2019s often the go-to language for\ndata scientists, machine learning engineers, and web developers, among\nothers. However, often notably absent from this list are those working\non and developing things in the physical world. Too often is the humble\nhardware engineer forgotten, doomed to a fate of spreadsheets. But what\nif I told you there was a whole world of hardware-focused Python? This\ntalk will explore various examples of Python in the world of hardware\nfolks, including building test fixtures, data acquisition, and\nindustrial automation. We\u2019ll also look at other issues, including what\nare the alternatives and why adoption of Python can be challenging. This\ntalk is meant for everyone, but especially those who love or want to\ntinker with hardware.\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/python-for-hardware-folks" + } + ], + "speakers": [ + "Alec Delaney" + ], + "thumbnail_url": "https://i.ytimg.com/vi/UDO_w55Xtcw/maxresdefault.jpg", + "title": "Python for Hardware Folks", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=UDO_w55Xtcw" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/quantum-computing-with-python-from-qubits-to-circuits.json b/pyohio-2025/videos/quantum-computing-with-python-from-qubits-to-circuits.json new file mode 100644 index 000000000..aba0f5268 --- /dev/null +++ b/pyohio-2025/videos/quantum-computing-with-python-from-qubits-to-circuits.json @@ -0,0 +1,26 @@ +{ + "description": "Quantum Computing with Python: From Qubits to Circuits\n------------------------------------------------------\n\nHave you heard the buzz about quantum computing and wondered what it\n*actually* means? This beginner-friendly talk introduces the\nfundamentals of quantum computing using the language we all love;\nPython.\n\nWe\u2019ll start by breaking down core quantum concepts like **qubits**,\n**superposition**, **entanglement**, and **quantum gates** in simple\nterms. Then, we\u2019ll bring those ideas to life with real code using\n`Qiskit `__, a powerful open-source quantum\ncomputing framework built in Python.\n\nYou'll learn how to:\n\n- Simulate qubits and quantum circuits\n- Visualize quantum states and interference\n- Run your own quantum circuits on a real IBM quantum computer (yes,\n free and live!)\n\nAlong the way, we\u2019ll highlight where quantum computing stands today,\nwhere Python fits in the ecosystem, and how you can get involved;\nwhether you're a hobbyist, educator, or software developer.\n\nNo prior knowledge of quantum mechanics is needed. If you can write a\n'for' loop, you can build your first quantum circuit.\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/quantum-computing-with-python" + } + ], + "speakers": [ + "Temitope Adeniyi" + ], + "thumbnail_url": "https://i.ytimg.com/vi/V3dc5UkoO5I/maxresdefault.jpg", + "title": "Quantum Computing with Python: From Qubits to Circuits", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=V3dc5UkoO5I" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/the-core-values-of-a-successful-startup.json b/pyohio-2025/videos/the-core-values-of-a-successful-startup.json new file mode 100644 index 000000000..ebd6b5e7e --- /dev/null +++ b/pyohio-2025/videos/the-core-values-of-a-successful-startup.json @@ -0,0 +1,26 @@ +{ + "description": "What really makes a startup succeed? It\u2019s not just product-market fit or\nclever tech\u2014it\u2019s the people and the culture they create together. In\nthis talk, I\u2019ll share lessons from my journey across three startups at\ndifferent stages, through acquisitions, pivots, and cultural\ntransformations.\n\n| I\u2019ll explore the core values that I\u2019ve seen make the biggest\n difference\u2014not the ones painted on walls, but the ones that show up in\n code reviews, standups, hard conversations, and late-night problem\n solving. We\u2019ll talk about:\n| \u2022 Authenticity over performance\n| \u2022 Love and empathy as engineering virtues\n| \u2022 Presence and trust in high-stakes uncertainty\n| \u2022 Balance, sustainability, and knowing when to push or pause\n| \u2022 Grit, growth, and intentionality\u2014what it really takes to build\n something that lasts\n\nThis talk is for anyone who wants to build or be part of a values-driven\nteam: engineers, tech leads, future founders, or just curious humans\ntrying to build things that matter.\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/the-core-values-of-a-successful-startup" + } + ], + "speakers": [ + "Daniel Kim" + ], + "thumbnail_url": "https://i.ytimg.com/vi/Y8dUZW_Nal4/maxresdefault.jpg", + "title": "The Core Values of a Successful Startup", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=Y8dUZW_Nal4" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/tune-up-your-knowledge-a-beginner-s-journey-under-the-hood-of-search-engines.json b/pyohio-2025/videos/tune-up-your-knowledge-a-beginner-s-journey-under-the-hood-of-search-engines.json new file mode 100644 index 000000000..1c7178da7 --- /dev/null +++ b/pyohio-2025/videos/tune-up-your-knowledge-a-beginner-s-journey-under-the-hood-of-search-engines.json @@ -0,0 +1,26 @@ +{ + "description": "| Many people drive their cars around all day and never look under the\n hood. Likewise, search is used every day, millions of times, with very\n little thought for how those results appear on your device. While I\n can't build a car engine from scratch (yet), I can build a search\n engine! (mostly).\n| In this talk, we'll take a beginner-friendly approach to discussing\n how search engines work under the hood while building one from scratch\n in Python along the way. We'll discuss some history of search,\n demonstrate common data structures that make search engines fast and\n effective, and review how we can get results in a meaningful order.\n| We'll also take a high-level look at machine learning models and how\n vector embeddings can easily understand similarity and influence\n search results.\n| This talk is for those interested in taking a beginner's peek under\n the hood to understand some of the techniques used. No prior\n experience with information retrieval required\u2014just bring your\n curiosity about what really happens when you type a query into that\n search bar.\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/tune-up-your-knowledge" + } + ], + "speakers": [ + "Eddie Mitchell" + ], + "thumbnail_url": "https://i.ytimg.com/vi/0i_K1awHYHk/maxresdefault.jpg", + "title": "Tune-Up Your Knowledge: A Beginner's Journey Under the Hood of Search Engines", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=0i_K1awHYHk" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/using-python-in-the-concrete-industry.json b/pyohio-2025/videos/using-python-in-the-concrete-industry.json new file mode 100644 index 000000000..4003eaa35 --- /dev/null +++ b/pyohio-2025/videos/using-python-in-the-concrete-industry.json @@ -0,0 +1,26 @@ +{ + "description": "Working in the concrete industry, I often found myself doing tasks that\nfelt repetitive. Python has been great for automating these tasks, with\nthe goal being to both increase efficiency and remove opportunities for\nhuman error, which can be costly in this business. Automating things has\nalso taught me that seemingly simple tasks can be more complicated than\nthey seem.\n\nAs part of this I will discuss libraries that I have found useful,\nincluding ezdxf, which can be used for drafting and creating files that\ncan be read by CAD software.\n\nPython really is a programming language for everyone, and can have a use\ncase in places you might not expect.\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/using-python-in-the-concrete-industry" + } + ], + "speakers": [ + "Scott Windsor" + ], + "thumbnail_url": "https://i.ytimg.com/vi/eUeeKwJwzxI/maxresdefault.jpg", + "title": "Using Python in the Concrete Industry", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=eUeeKwJwzxI" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/uv-ultimate-victory-over-installation-and-dependency-chaos.json b/pyohio-2025/videos/uv-ultimate-victory-over-installation-and-dependency-chaos.json new file mode 100644 index 000000000..08c27a003 --- /dev/null +++ b/pyohio-2025/videos/uv-ultimate-victory-over-installation-and-dependency-chaos.json @@ -0,0 +1,26 @@ +{ + "description": "Did you recoil at the news that there's *yet another* hot new packaging\ntool to cram into your poor crowded brain?\n\nTake heart, brain! It will be all right! uv is splendidly complete and\ngloriously simple to use. It's the single tool that can elegantly and\neasily replace the whole jumbled toolbox you've been using until now.\nSee the essential simple usages of uv, and you'll be a believer.\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/uv" + } + ], + "speakers": [ + "Catherine Devlin" + ], + "thumbnail_url": "https://i.ytimg.com/vi/QtuyzS6cHq0/maxresdefault.jpg", + "title": "uv: Ultimate Victory over Installation and Dependency Chaos", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=QtuyzS6cHq0" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/when-your-sme-ghosts-you-using-genai-to-build-a-database-documentation-agent.json b/pyohio-2025/videos/when-your-sme-ghosts-you-using-genai-to-build-a-database-documentation-agent.json new file mode 100644 index 000000000..4ea0693dd --- /dev/null +++ b/pyohio-2025/videos/when-your-sme-ghosts-you-using-genai-to-build-a-database-documentation-agent.json @@ -0,0 +1,26 @@ +{ + "description": "Have you ever been handed a mystery database and told, \u201cYou\u2019ll figure it\nout\u201d... with no documentation, no SME, and no time?\n\nIn this session, I\u2019ll share how I turned a frustrating (and very\nrelatable) real-world problem into a capstone project for Kaggle's Gen\nAI 5 Day Intensive Course with Google: building a GenAI-powered Database\nDocumentation Agent using Python, SQLite, and the Gemini API \u2014 aka what\nI like to call my SME Ghost Protocol.\n\nI\u2019ll walk through how I used GenAI to automatically generate natural\nlanguage summaries, answer ad-hoc schema questions, and create entity\nrelationship diagrams \u2014 even when human help wasn't available.\n\nWe'll dive into the challenges of working with GenAI as a \"coding\npartner,\" designing prompts like communication plans, and lessons\nlearned the hard way about iteration, hallucination, and debugging when\nyou're flying solo.\n\nExpect live demos, practical takeaways, a little workplace sarcasm, and\nideas for how you can launch your own SME Ghost Protocol \u2014 because\nsometimes, GenAI is the only teammate who shows up.\ud83d\udc7b\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/when-your-sme-ghosts-you" + } + ], + "speakers": [ + "Denise Williams" + ], + "thumbnail_url": "https://i.ytimg.com/vi/_qpuALSX9lc/maxresdefault.jpg", + "title": "When Your SME Ghosts You: Using GenAI to Build a Database Documentation Agent", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=_qpuALSX9lc" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/why-python-loops-are-slow-a-gentle-introduction-to-interpretation-bytecode-and-fast-code.json b/pyohio-2025/videos/why-python-loops-are-slow-a-gentle-introduction-to-interpretation-bytecode-and-fast-code.json new file mode 100644 index 000000000..52c43a936 --- /dev/null +++ b/pyohio-2025/videos/why-python-loops-are-slow-a-gentle-introduction-to-interpretation-bytecode-and-fast-code.json @@ -0,0 +1,26 @@ +{ + "description": "Python loops are \"slow\", is a phrase every python programmer has heard.\nFor better or worse, it is partially true. This talk breaks down how\nPython executes code and why that creates overhead, especially in tight\nloops. I'll also explore how tools like NumPy, SIMD, and JIT compilation\nachieve massive speedups by working with the CPU instead of against it.\n\nYou should walk away from this talk with more insight into why loops are\nslow, how python code is executed at a high level, and what you should\ndo about it if anything.\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/why-python-loops-are-slow" + } + ], + "speakers": [ + "Tyler Riccio" + ], + "thumbnail_url": "https://i.ytimg.com/vi/r129pNEBtYg/maxresdefault.jpg", + "title": "Why Python Loops Are \"Slow\": A Gentle Introduction to Interpretation, Bytecode, and Fast Code", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=r129pNEBtYg" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/wildfires.json b/pyohio-2025/videos/wildfires.json new file mode 100644 index 000000000..31bfe1420 --- /dev/null +++ b/pyohio-2025/videos/wildfires.json @@ -0,0 +1,26 @@ +{ + "description": "Wildfires have become more frequent nationwide, causing chaos not only\nwithin fire zones but also affecting communities far away through smoke\nand poor air quality. In this talk, we'll explore the world of\nwildfires, understanding common terminology and clearing up\nmisconceptions. We will explore data sources, potential file formats,\nand essential data fields using fire perimeter data. By leveraging\nPython and Geopandas we will clean a dataset, analyze the cleaned\ndataset, and finally create compelling visualizations of our wildfire\ndata.\n", + "language": "eng", + "recorded": "2025-07-26", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/wildfires" + } + ], + "speakers": [ + "Lazouich Ford" + ], + "thumbnail_url": "https://i.ytimg.com/vi/LXkxjbUY0rU/maxresdefault.jpg", + "title": "Wildfires!", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=LXkxjbUY0rU" + } + ] +} \ No newline at end of file diff --git a/pyohio-2025/videos/write-apps-for-your-tv-with-kodi-and-python.json b/pyohio-2025/videos/write-apps-for-your-tv-with-kodi-and-python.json new file mode 100644 index 000000000..c9bbc0bec --- /dev/null +++ b/pyohio-2025/videos/write-apps-for-your-tv-with-kodi-and-python.json @@ -0,0 +1,26 @@ +{ + "description": "The open-source media player Kodi is designed to play videos and music\non your TV, but it also comes with a plugin system that is programmable\nwith Python. This talk will walk through writing a plugin for your\nset-top-box running Kodi, including packaging, debugging, and dealing\nwith dependencies (there's no pip here).\n", + "language": "eng", + "recorded": "2025-07-27", + "related_urls": [ + { + "label": "Conference Website", + "url": "https://www.pyohio.org/2025/" + }, + { + "label": "Presentation Webpage", + "url": "https://www.pyohio.org/2025/program/talks/write-apps-for-your-tv-with-kodi-and-python" + } + ], + "speakers": [ + "Andrew Kubera" + ], + "thumbnail_url": "https://i.ytimg.com/vi/LB0Pj41nMwI/maxresdefault.jpg", + "title": "Write Apps for Your TV with Kodi and Python", + "videos": [ + { + "type": "youtube", + "url": "https://www.youtube.com/watch?v=LB0Pj41nMwI" + } + ] +} \ No newline at end of file