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 Orchid East Sat July 27, 9p


PyOhio
=========================
When: 9 AM Saturday July 27, 2024
Where: Orchid East
The 17th annual PyOhio held July 27-28 in Cleveland, OH.
https://www.pyohio.org/

Topics
------
1. Saturday Welcome


Opening Remarks Saturday
 recording release: yes license: CC BY-NC-SA  

2. Keynote
Steph Hippo

Steph Hippo presents our Saturday morning keynote.
 recording release: yes license: CC BY-NC-SA  

3. Serverless AI Inferencing Using Python and WebAssembly
Shivay Lamba

Unleashing the power of serverless AI has never been more accessible, and Python enthusiasts are in for a treat! Dive into this talk to discover how WebAssembly based Open Source project Spin seamlessly bridges the gap between Python and Serverless AI. There are no models to download. Just create, build and deploy! This talk will guide you on building your own serverless AI inferencing using Python and promises to elevate your game instantly.
 recording release: yes license: CC BY-NC-SA  

4. Snakes & Ladders: A Gentle Introduction to Generators and Iterators
JR Rickerson

Generators and Iterators are two core features of Python that are often misunderstood and overlooked. And yet they are extremely powerful and expressive parts of the language. They can be especially useful in data processing, systems integration, or in projects with limited resources. In this talk, we'll get into the fundamentals of what iterators and generators actually are, how they're different from one another, and how they work under the hood. We will explore how to create your own custom iterators and generators for use in your own projects. Throughout the discussion, we'll make comparisons to the simple children's game "Snakes \& Ladders," and by the end of the talk we should have a simple working example of the game built with iterators and generators.
 recording release: yes license: CC BY-NC-SA  

5. So, I Got Some Code Working… Now How Do I Share It?!
Elaine Wong

You have some code running locally, but you want to be able to share it with your team members and you run into the biggest snag of all, none of them are technical. 

So how do you share code when the idea of asking someone to run git or docker stops them from every trying to automate the boring work that they have to do? 

Let's dive into the fun of trying to go from trying to share code and have others run it. From sharing a Juypter notebook/Google Collab, to new places like py.space, or even trying to host a web app on PythonAnywhere, what are the easiest solutions to get code snippets up and running for non\-technical people?
 recording release: yes license: CC BY-NC-SA  

6. Enhancing the JupyterLab Notebook to Overcome Bioinformatics Analysis Challenges with GiN
Jayadev Joshi

My talk is focused on GiN, (Galaxy in Notebooks) is an open\-source JupyterLab extension powered by the Galaxy API and JupyterLab’s graphical widget interface. GiN provides a simple, GUI\-based, user\-friendly interface to interact with both local and public Galaxy servers from within JupyterLab. Galaxy (https://usegalaxy.org/) is a widely used open\-source web\-based platform for accessible, reproducible, and transparent big data analysis in biomedical research. JupyterLab is a powerful tool for data scientists, researchers, and developers who want to work with data and code in an interactive and collaborative environment. GiN enables researchers to execute all available Galaxy tools graphically, submit jobs, access history datasets, upload large data files with resumable uploads, and explore job details and output. GiN can be used with a Docker image, making it easy to keep GiN up and running on a local machine. The GiN recipe includes Python, JavaScript, and Node.js modules, and can be downloaded from GitHub and installed with the pip package manager.
 recording release: yes license: CC BY-NC-SA  

7. Quantum Computing with Qiskit in Galaxy
Bryan Raubenolt

The era of quantum computing is here. As it continues to evolve from being a technology in its infancy, to something that could revolutionize many aspects of daily life, it is capturing the interest of academia, government, and industry alike. It is thus of great importance for members of the scientific community to familiarize themselves with the theory and applications of this new computing method \-\- and especially how to program and develop algorithms on these devices.

In this talk, we'll take a look at the incorporation of Qiskit, IBM's Python\-based software stack for quantum computing, into the Galaxy ecosystem. We'll revisit the basic theory of quantum computing along with the many important components of the coding framework and syntaxes, and we'll explore a series of previously developed Qiskit tutorials and Jupyter notebooks, presenting new ways of solving some of the most relevant problems in contemporary science and engineering.
 recording release: yes license: CC BY-NC-SA  

8. Canceled: Building Resilient Applications with Circuit Breakers and Retries Using FastAPI
Sameer Shukla

**We regret to announce that Sameer was unable to attend PyOhio and that this session has been canceled.** Sorry, folks!



---

In this session, we will explore techniques for building resilient applications that can gracefully handle failures and ensure high availability. Specifically, we will focus on implementing circuit breakers and retry mechanisms using FastAPI. By the end of this talk, attendees will understand the principles behind these patterns and see a live demonstration of how to implement them in a FastAPI application.
 recording release: yes license: CC BY-NC-SA  

9. A Python Sequence (Un)Packing Primer
Brian Costlow

*What happens in Python when you type things like?*


```
def spam():
    return 1,2,3

a, b, c = spam()

```

```
def foo(*args, **kwargs):
   ...

```

```
for name, value in some_dict.items():

```

```
my_dict = some_func_that_returns_a_dict()

some_other_func(**my_dict)

```

In this talk, we'll examine Python's ability to unpack values from (or sometimes pack them into) sequences. We'll see how that capability powers a host of powerful Python idioms. We'll also look at some less commonly used syntax to unpack sequences into complex data structures. Used judiciously, these techniques can simplify your code. Last, we'll talk about mental models, and why it's important to develop good mental models for what's happening "under\-the\-hood" when we write Python. Well show what can (and did) happen when having the wrong mental model of unpacking syntax lead to a bug. We'll look at code that shows the problem, discuss what's really happening, then use the Python bytecode disassembler to confirm our intuition.

Although this talk briefly uses the Python bytecode disassembler, it's aimed at beginners (though not complete novices) who want to write more idiomatic Python, and develop a better intuition for what's really happening in the interpreter when their code runs.
 recording release: yes license: CC BY-NC-SA  

10. What Django Deployment is Really About
James Walters

People often spend so much time learning how to build apps in Django that when it comes time for deployment, it feels like a whole new world that they don’t understand. Deployment recipes might help them get their app online–but then again they might not, if the steps that worked yesterday don’t work today. Even if they do get online, they might not understand that deployment process anymore than they did before.

Instead of offering another set of steps, I think we can help beginners to make sense of deployment by reducing the entire process to four major areas of concern and equipping them to think through each of these on its own terms:

* Static Files \- why do I have to worry about these now? I thought {% static %} was handling it?
* Database \- does my sqlite3 file not work in deployment? How do I use my cloud provider’s remote DB?
* WSGI Server \- how do I run my app in production? Doesn’t manage.py runserver work? I’ve never heard of WSGI, what is it and why does it matter to my Django project?
* Web Server (Apache/nginx/PaaS) \- What do I need to understand about web servers like Apache or nginx to get my project online? Do I even need to configure a web server if I go with PaaS?

We’ll also consider:

* Django’s deployment checklist
* django\-simple\-deploy
 recording release: yes license: CC BY-NC-SA  

11. Data Science & Agile: Strategies for Working Together
Alyssa Batula

Data science and Agile aren't famous for getting along. Data scientists complain that Agile frameworks are too restrictive and deadline\-focused to accommodate the type of work they do. Scrum masters and product owners have a hard timing planning around unclear timelines and uncertain outcomes, and wish the data scientists would just tell them how much effort a task will take.

But it doesn't have to be this way! Data science and Agile can work together to create a better system for everyone. In this talk I'll highlight tips and pitfalls from my own experience, as well as stories I've heard from my colleagues.
 recording release: yes license: CC BY-NC-SA  

12. Efficient Path Planning for Search and Rescue Missions Using Neural Networks
Keith Martin Machina

Utilizing the Python programming language and the Tkinter library, I propose to develop a simulated robotic application tailored for search and rescue missions. Central to this endeavor is the integration of a neural network, trained on pertinent search and rescue data, to effectively guide the robotic agent towards areas with a high probability of locating survivors. The neural network's computations yield a dynamic cost map, which takes into account both traversal costs and the priority of various regions within the search area. This cost map serves as a comprehensive tool, continuously furnishing the robotic agent with insights into the search region and optimizing its search strategy. Importantly, this approach is conceived to address challenges inherent in reinforcement learning, such as the lack of a global view and the need to balance multiple objectives in search and rescue mission.
 recording release: yes license: CC BY-NC-SA  

13. How to Use Static Typing in Python with Type Hints, MyPy and Pydantic
Jack Bennett

Python's dynamic typing system famously offers flexibility, but this can sometimes lead to runtime errors that are hard to detect or predict. In many cases, the programmer knows what type a variable "should" be, but in earlier language versions the only option to enforce this was by writing custom, run\-time type checks. Since Python 3\.5, the language has offered type hints, which are optional annotations that suggest (but do not require) that a variable has a particular type. Combined with static type checkers like MyPy and run\-time data validation frameworks like Pydantic, type hints offer Python programmers a powerful system to implement static types in a highly standardized way.

This presentation explores these new standards for static typing in Python through the lens of two powerful and versatile libraries: MyPy and Pydantic. These tools build upon Python’s type hints to help you improve your code reliability and effectiveness with minimal extra effort.

At the end of this presentation you will be able to:

* Use type hints, MyPy, and Pydantic to define and enforce static data types in Python.
* Identify important use cases where static types provide greater code reliability and quality.
* Leverage these tools to increase the resilience of your code against bad data, and deliver more useful and actionable error messages sooner.

MyPy is a type checker that leverages built\-in type hints to identify possible type errors during a separate static analysis stage. By integrating a MyPy step into your development, testing, and deployment processes, you can catch type\-related errors at the start of the development cycle. This reduces debugging time, improves code quality, and often heads off potential production failures long before they occur. We will discuss MyPy's key features, how to integrate it into existing projects, and how it works together with Python's built\-in dynamic typing.

Pydantic is a data validation library that leverages Python's type hints to check incoming data at run time. Pydantic's data models ensure that incoming data conforms to defined schemas. This feature is especially useful in data\-intensive applications for guaranteeing data integrity and standardizing error reporting. Key application areas include ETL, streaming data, and RESTful APIs (in fact, the popular FastAPI framework leans heavily on Pydantic for data validation). We will learn about Pydantic's applications in data parsing, and in building data models that enhance code resilience and simplify error\-checking and logging.

Through reference to practical examples and best practices, this talk will demonstrate how you can use MyPy and Pydantic to leverage the static typing capabilities in the core Python language to create more correct, maintainable, and resilient Python applications.
 recording release: yes license: CC BY-NC-SA  

14. Simplifying Python Web App Operations: Automating K8s Ops with Open Source
David Andersson

After creating a great web app using Python such as with flask, the next hurdle to production is how to make it available to users and operate it. And not just your app, but also ingress, the database, observability and the list goes on. We will go through your options for simplifying the operations of your web app using open source tooling. This will include using k8s directly, helm charts, IaaC using pulumi and new tooling developed by Canonical using juju. By the end of the talk you will have seen the benefits and drawbacks of each which will help you make an informed decision on which tool best suits your needs!
 recording release: yes license: CC BY-NC-SA  

15. Python <3 Rust
Moshe Zadka

Python code can be sometimes slow, but is easy to iterate on and prototype in. Rust can be slower for iteration, but results in code that is both fast and safe. The two languages complement each other perfectly. The PyO3 framework bridges the gap in a way that avoids boilerplate. Learn how to use it to add a powerful tool for your toolbox!
 recording release: yes license: CC BY-NC-SA  

16. Validating Complex Types Using Pydantic
Daniel Schelkoph

For some Python Objects it is difficult to understand its contents, even if type annotations are used. For example, PyTorch's `Tensor` or Pandas's `DataFrame` have many different "shapes" to their data structures, but their type annotations are always the same. This can make it very difficult to understand functions that utilize these objects as parameters or return these objects. When reviewing code, it is very common to ask these sorts of questions: 

* What is the shape of the `Tensor` I need to pass in?
* What columns does this `DataFrame` need to have?

In this talk, we will describe how to utilize typing metadata and Pydantic to not only provide additional context for these data structures, but to validate the input/output of functions as well.
 recording release: yes license: CC BY-NC-SA  

17. Boosting Neuroimaging Analysis and Results Digestibility 🧠
Carlos A Aranibar

Electroencephalogram (EEG) measures brain activity, and despite advancements in sensors since its 1924 invention, its result presentation has changed very little. We're addressing this using MNE, an open\-source Python library.

Join us to simplify neuroimaging results for patients and enhance visualization tools for technicians. Affordable biotracking devices now capture brain wave data, and MNE enables innovative data export and manipulation. This opens new possibilities for advanced statistics, improved visualizations, and enhanced analysis capabilities.

No medical background is required – join us in revolutionizing brain activity interpretation, making it more accessible and meaningful for everyone.
 recording release: yes license: CC BY-NC-SA  

18. How to Do the Same Thing Over and Over Again and Yield Different Results
Jessica Garson

When I started working with Elasticsearch, the data in my index quickly needed to be updated. I built a solution using Cloud Functions and Cloud Scheduler in GCP to update my data automatically, a paradigm I've used for creative projects. This talk will outline strategies for automating routine processes while ensuring that the outcomes adapt to changing requirements, enhancing project innovation and data accuracy.
 recording release: yes license: CC BY-NC-SA  

19. 20 GOTO 10: How to Make Scrolling ASCII Art
Al Sweigart

Danger Zone by  Danny Elfman removed to avoid restricted content strikes.
It is not removed in the Internet Archive version: 
https://archive.org/details/pyohio_2024-20_GOTO_10_How_to_Make_Scrolling_ASCII_Art

Scroll art is a form of animated ASCII art that beginners can make. Using loops, print(), and random numbers, you'll learn how to make a surprisingly wide variety of digital art within the constraints of text strings. You'll also learn about the history of ASCII art, computer education, and where to find inspiration for your own digital art.
 recording release: yes license: CC BY-NC-SA  

20. Boosting Python Numeric Computations with Dynamic C++ Integration
Mandar Deshpande

Uncover the secrets to turbocharging your Python numeric computations by harnessing the dynamic performance of `C++`. This talk is aimed at the beginner\-intermediate Python developer working in the ML/AI infra or performance optimization space.

Have you ever wondered how the growing usage of the numeric computation stack, including libraries like numpy, scipy, and scikit\-learn, along with deep learning libraries such as pytorch and tensorflow, are shaping the future of AI and Machine Learning? And what about the intriguing fact that these libraries are built on wrappers for the underlying C\+\+ code? Have you considered the benefits this brings, or how the optimization of these libraries as per the host device \- be it CPU, GPU, or Apple Silicon \- enhances performance and efficiency?

And finally, let's consider the practical applications and real\-world examples of this integration between Python and C\+\+. What are the challenges and solutions in bridging the gap between Python and C\+\+ in the context of AI and Machine Learning.

Observing the growing trends at my workplace over the past few years, I am sure this process is going to be standardised soon with more developers being involved in such integrations/optimizations.

This talk aims to get the Python community excited for this growing trend by sharing:  

1\. reasoning  

2\. Integration framework/paths specifically for pybind
 recording release: yes license: CC BY-NC-SA  

21. Data Engineering: The World Between Worlds
Rainu Ittycheriah

Data engineering is an often misunderstood, conflated range of skills from database administration, analytics, ETL, cloud infrastructure, big data and back. As someone who worked as a data engineer for just over 5 years, I’d love to share my stories about my time as a data engineer to pull back the curtain on what kind of value you might be able to get from data engineering as the heat of ML Ops and AI takes flight, both as organization and individual. Notably, many data engineering teams heavily leverage Python due to the depth and breadth of the data libraries, and the ease by which folks can learn Python to start creating value within the space. We'll also talk about a few of the key libraries that you can learn to set yourself apart if you decide data engineering is for you!
 recording release: yes license: CC BY-NC-SA  

22. Keynote
Mariatta

Mariatta presents our Saturday afternoon keynote.
 recording release: yes license: CC BY-NC-SA  

23. Lightning Talks


Lightning Talks
 recording release: yes license: CC BY-NC-SA  

24. Sunday Welcome


Re\-Opening Remarks
 recording release: yes license: CC BY-NC-SA  

25. Stress Less: Easy Database Load Testing Using Python and Locust
Miguel Johnson

Overview
--------

Many people have probably used Locust or a tool built on top of it (like Load Forge) in the past. These tools are primarily used for web application load testing by hitting public endpoints and monitoring how they respond. In this talk we review how to use Locust to load test a PostgreSQL database.

Additional Info
---------------

This is a link to an article I wrote about this topic: [https://miguel\-codes.medium.com/unconventional\-load\-testing\-leveraging\-python\-locust\-for\-postgresql\-stress\-testing\-d6e07d63714b](https://miguel-codes.medium.com/unconventional-load-testing-leveraging-python-locust-for-postgresql-stress-testing-d6e07d63714b)
 recording release: yes license: CC BY-NC-SA  

26. Signal Processing in Electrochemistry with Python: Applications to the US Opioids Crisis
Rodrigo Silva Ferreira

With an average of 195 daily deaths due to synthetic opioids overdose in 2021, the US have been facing an unprecedented opioids crisis. Fentanyl and its analogues have been a major source of concern, due to their high levels of addiction, fast\-acting mechanisms, and detection challenges. Fast, effective, and accurate identification and quantification of fentanyl, its analogues, and metabolites are essential to help prevent overdose\-related incidents and to enable agile medical response. Although electrochemical sensors represent a promising technology for selectively detecting opioids at low concentrations, analyzing and processing the data remains one of the major challenges. To tackle this challenge, certain Python libraries, such as *scipy.signal*, could be useful in processing signals with high levels of noise and interference from other substances. 

This talk will focus on specific examples of how such libraries could help enable filtering, Fourier transformation, and wavelet analysis of electrochemical data. As examples, code snippets and outputs will be shown to demonstrate how Python can help improve the quality and usability of electrochemical data. Additionally, this talk will show how data processing can further benefit from hyper parameter optimization techniques, enabled by libraries like *hyperopt* and *ray\-tune*. By doing so, my hope is to demonstrate how Python could be extremely useful in helping address problems at the intersection of statistics, public health, and public policy.
 recording release: yes license: CC BY-NC-SA  

27. A Confession of My Python Sins
Jamie Bliss

I've been writing Python code for twenty years now, and in that time I've done some bad things to it.

Let's discuss them and why you would want to also do black magic, atrocities, abominations, and other sins.
 recording release: yes license: CC BY-NC-SA  

28. Hot: Pathlib, Not: String Paths
Josh Schneider

Have you seen `pathlib`? If not, once I show you, you will never go back to string paths and `os.path` ever again! `pathlib` turns paths into path objects, which have attributes and methods that cover a number of operations. In this talk, we will:

* Talk about how to create `Path` objects, and how this differs on Windows vs Mac/Linux
* Talk about the many properties of pure paths
* Talk about folder operations from `Path` objects, such as creating directory structures and recursive globbing.
* Talk about file operations, made simpler with `Path` objects, such as reading contents, getting properties like file size, and deleting.

Stop messing with string paths and get with `pathlib`!
 recording release: yes license: CC BY-NC-SA  

29. Device Authorization Flow 101: Logging in From Input Constrained Devices
Jessica Temporal

Have you ever heard of device authorization flow? You may have not heard it but good chances are you already used it.

Device flow allows you to login to your applications on input constrained devices, think of IoT devices or smart TVs for example.

Great applications allow the user to continue the login process on a more comfortable device instead of using, for example, the virtual keyboard on a SmartTV.

If you are developing applications that need this type of connectivity come to this talk to learn what device flow actually is, how it works, and better yet, see it working in an application that integrates Python (using FastAPI) and Micropython.
 recording release: yes license: CC BY-NC-SA  

30. Mastering the Zen of Dev Experience: Kubernetes and the Art of Simplicity
Calvin Hendryx-Parker

Happy developers do not have to fight their tools and environment to be productive. They get set up in minutes, deploy without hesitation, and use the same tools to debug in any environment. In this talk and live demo, we'll explore how a Kubernetes\-based development workflow can help you and your team hit the ground running.

We will delve into establishing a powerful Django backend for server\-side functionality and a dynamic React frontend for an engaging user experience. For databases, the setup will include a local Postgres database for development and CloudNativePG for production\-level deployments. Additionally, the integration of Redis for enhanced application performance and email testing will be covered. 

This comprehensive approach ensures that onboarding a new developer on a project is streamlined, overcoming the typical pain points such as:

* manual installation steps
* the inconsistency of tools across development environments

Kubernetes will empower your development and DevOps teams to speak a common language and collaborate effectively, standardizing deployments and debugging processes in local, preview, staging, and production environments.
 recording release: yes license: CC BY-NC-SA  

31. Introducing Immortal Objects: Building Block Towards a Multi-core Python Runtime
Aditya Mehra

In this presentation, I'll cover memory management in Python starting from the fundamentals. I'll explain the rationale behind the need for PEP 683: "Immortal Objects, Using a Fixed Refcount", discussing about this change may be unlocking exciting avenues for true parallelism in Python.

The takeaway of this presentation would be :  

a) Refresher on object(mutable vs immutable and their significance)  

b) Refresher on Life cycle of a Python object.  

c) Refresher on Python memory management with garbage collection  

d) How overcoming with pseudo immutable object will be unlocking exciting avenues for true parallelism in Python.

The target audience would be intermediate and advanced pythonistas. However I will present the information in simple and subtle manner for better understanding of Python newbies.
 recording release: yes license: CC BY-NC-SA  

32. Asyncio by Example
Andrew Kubera

Async functions in Python are a great way to simplify otherwise complex code involving network calls, database queries, or in general waiting and responding to "events". But before you can asycio.run you must learn how to walk\-through some examples. 

This talk will start with the async/await basics, then show common patterns encountered when solving problems with Python's asyncio module, and introduce some of its newer features, such as Barriers, TaskGroups, and ExceptionGroups.

This is a code\-heavy, zero\-to\-hero talk where all the examples are run, and we can experiment and change the code if the audience has questions.
 recording release: yes license: CC BY-NC-SA  

33. Canceled: Gotta Go Fast! Using Asyncio for More Efficient Web Scraping
Samuel Agnew

**We regret to announce that Samuel was unable to attend PyOhio and that this session has been canceled.** Sorry, folks!



---

The internet has a wide variety of information available for human consumption. But this data is often difficult to access programmatically if it doesn't come in the form of a dedicated API. With tools like Beautiful Soup, Python developers can parse data directly from web pages.

There's just one problem: looping through HTTP requests for a bunch of URLs one by one can take forever! Luckily, we can speed things up dramatically by making these requests asynchronous. In this live\-coding adventure we will explore how to use asyncio to improve the performance of your web scraping endeavors.
 recording release: yes license: CC BY-NC-SA  

34. Building Vector-Symbolic Architectures with Python
Fabio Cumbo

Vector\-Symbolic Architectures (a.k.a. Hyperdimensional Computing) is a relatively new computational paradigm that involves the use of random vectors in a high\-dimensional space to represent and process information. As a computational paradigm, it finds applications in a wide range of fields, including artificial intelligence, natural language processing, internet\-of\-things, robotics, bioinformatics, and other scientific domains.

Here we are going to introduce some fundamental concepts at the base of Hyperdimensional Computing, following a presentation of *hdlib*, a library for building Vector\-Symbolic Architectures with Python. Finally, we are going to see how to easily build a machine learning model based on the Hyperdimensional Computing paradigm as a practical use case.

As a reference, *hdlib* is open\-source, it is available on GitHub at [https://github.com/cumbof/hdlib](https://github.com/cumbof/hdlib), and it is published on the Journal of Open Source Software at [[https://doi.org/10\.21105/joss.05704](https://doi.org/10.21105/joss.05704)](https://doi.org/10.21105/joss.05704).
 recording release: yes license: CC BY-NC-SA  

35. Zen Commandments
Paul Hutchings

With the 20th anniversary of the Zen of Python coming up in August, now is the perfect time to reflect on how it has influenced the evolution of the Python language and how we write software in Python over the last 2 decades. Has Python moved closer to the ideals expounded in the Zen, or has it drifted further away? Like many great software engineering principles, different portions of the PEP are in contention with each other at times, which can be revealed in the features and patterns of the language. What does the current relationship between the language and the PEP say about the Python community and ecosystem as a whole, as well as perhaps the most important question: is the Zen of Python still relevant today?
 recording release: yes license: CC BY-NC-SA  

36. Evolve or Die: How I Stopped Avoiding and Starting Loving Python Upgrades
Ruby Henry, Ph.d.

Imagine you’re all set to board a flight. You've got your book and snack, and you're nestled into your seat. The pilot assures you of a smooth journey ahead. Comforting, right? But for hundreds of thousands of airline passengers last holiday season, the reality was far from comforting. Remember the chaos? A major airline canceled around 17,000 flights due to outdated software in their crew scheduling system, leaving pilots clueless about their assignments.

The fallout was severe: a 15% plummet in share price, a $400 million hit to revenue, and about $300 million in compensation costs—not to mention the lasting stain on their reputation.

Now, let’s turn to you. What upgrades are you putting off? What will it cost you to delay?

Fear of the unknown is a major driver of delaying upgrades and inadvertently risking security. Which deprecations in the standard library actually affect me? Do my packages support the next version of Python? If I upgrade one package, which other packages are affected?

In my talk, I will demo how new tools—data that can be leveraged directly through Snowflake or through an app that also parses `requirements.txt` to do even more of the heavy lifting—can help the audience navigate minefields of Python upgrades and get to the latest Python version. The audience will also leave with practical, required actions for Python deprecations on popular platforms: AWS, Heroku, and AZURE.
 recording release: yes license: CC BY-NC-SA  

37. Technical Empathy
Leon Adato

From software to sneakers to sofas, the best designs are executed from the point of view of the user, maintainer, or owner – NOT from the point of view of the designers themselves. The terms "usuability", "intuitive", and even "innovation" are (or should be) inextricably linked with the perspective of the recipient, not the creator.

As IT practitioners, we solve for this by taking time up\-front to nail down the desired feature; by creating small incremental changes rather than sweeping monolithic updates; by collecting metrics on usage and flow; and by maintaining a "fail fast" mentality where we can pivot quickly. But all that might miss a key point: do we understand how the intended beneficiary of brilliance thinks? Do we know not only what they want, but why they want it? Or how they want it?

The ability to see things from this perspective is called "technical empathy". In this talk, I'll define what technical empathy is; describe how having technical empathy enhances our design choices, smooths the road to execution, and leads to better outcomes; and provide ideas on how developers and engineers can build technical empathy in themselves and foster it within teams.
 recording release: yes license: CC BY-NC-SA  

38. Wagtail: The Python CMS Taking the World by Storm
Vince Salvino

What do NASA, Google Blogs, The Motley Fool, CFPB.gov, and the British National Health Service all have in common? Their websites are powered by Wagtail, the fastest\-growing Python CMS that you've probably never heard of. Because it is 100% free and open\-source, you can build your own website with Wagtail too!

We'll discuss:

* What is Wagtail and what does it do?
* How does it compare to other systems such as WordPress?
* Overview of the Wagtail open\-source project; how a team of volunteers makes this all possible.
* Demo and brief getting started tutorial
 recording release: yes license: CC BY-NC-SA  

39. Python + Discord = Great Bots!
Alex Oladele

Okay you already enjoy using python, and you already enjoy using Discord, but what if you combined both! 

In this talk we will explore how to build a discord bot using the Pycord library. We’ll build a dice rolling bot that utilizes Discord’s native slash commands. At the end of this talk you’ll have learned the different ways to invoke discord bot actions, the different lifecycle events each bot goes through, structuring the code for maintainability, and how to build for widespread adoption.
 recording release: yes license: CC BY-NC-SA  

40. 23, Python and Me: Using Machine Learning in Python to Analyze Consumer Genomics Data
Nathan Brouwer

We are over 20 years into the genomics era, with new insights into human health and our recent evolutionary history emerging almost daily. Genomics may seem like the province of PhDs and R\&D departments, but anyone with basic Python skills can navigate a genomics data pipeline and explore human genetic diversity, including their own! In this presentation, I will introduce the fields of population and health genomics, and the types of domain\-specific data used for genomics study. I will then demonstrate how you can use Python to visualize and analyze public data sources like the 1000 Genomes Project using unsupervised machine learning methods, and how to investigate your own genomics data from sources like *23andMe*. Since many people are not comfortable giving for\-profit companies access to their genomic data, I'll also show how you can simulate realistic personal genomic data via a supervised ML model.
 recording release: yes license: CC BY-NC-SA  

41. Keynote: Brains Are Beautiful Liars
Trey Hunner

Trey Hunner presents our Sunday afternoon keynote.
 recording release: yes license: CC BY-NC-SA  

42. Closing Remarks


Closing Remarks
 recording release: yes license: CC BY-NC-SA  



Location
--------
Orchid East


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.