PyBeach 2025

Doors open, mingle and get settled

Opening Address

This is Carol Willing's Keynote; Details TBD!

Have you used Python's match statement? How do you decide when to use match instead of a typical if/elif/else statement? Although structural pattern matching functionality has been available in Python for years, many Python developers still aren't sure about the best way to employ match in their own programs.

This talk will explore effective patterns that work well with the new match statement, and common pitfalls to avoid. It will highlight when if/elif/else constructs are a better fit, and how to judge when it's time to consider moving from one style to another. The talk will also cover other approaches to matching patterns, including look-up tables for performance and unpacking for sequences.

After attending this talk, you'll be able to confidently use the match statement to enhance your programs and discern when match will harm the readability of your code.

Python's popularity comes from its vast ecosystem of open-source packages, especially for the development for AI modeling and support. However, many Python programmers struggle to share their scripts and packages with others due to a lack of understanding about Python packaging.
Join me on a journey to demystify modern Python packaging and learn the end-to-end mechanism of creating, publishing, and managing Python packages. Whether you are new to Python packaging or want to sharpen your skills around modern Python packaging techniques or are a curious Pythonista, I hope for everyone to learn something new here or just have fun with packaging!

Thanks for attending!

If your Python code works with file paths, you should be using pathlib. This standard library module may seem a bit cumbersome at first, but pathlib-using code is often more readable the alternative.

Python's many path-oriented utilities used to expect a string representation for all file paths. That's not the case anymore. Now, every important path-consuming library will accept pathlib.Path objects.

During this talk, we'll see why pathlib.Path objects make for more maintainable code. We'll visit a number of useful pathlib examples and recipes along the way.

By the end of this talk, you'll be tempted to convert all your path-handling code to use pathlib.

More software is being produced today than ever before. Good software developers want to maintain high standards for quality, but may find it challenging to do so in the face of day-to-day pressures, deadlines, and distractions. Non-developers may feel it's acceptable to stop short of full engineering practice. In this talk we'll explore what engineering rigor looks like and discuss ways to uphold standards, even in the face of resistance. Attendees should come away with an understanding that engineering quality is more than just an ideal worth striving for, but a pragmatic way to keep our users happy, and to stay productive without burning out.

Python implements dynamic type behavior using a statically typed language (C), only to then offer static type annotations on top of a dynamically typed language (Python). This paradox is the focus of this talk. We will look at the basics of type annotations, how polymorphism is implemented in C with PyObject and PyObject_HEAD, and how CPython API functions like PyObject_TypeCheck() work. Despite the chasm between type annotations and runtime reality, their benefits will be demonstrated.

In distributed systems, how we handle failure is often more important than how we handle success. This talk challenges the "never give up" mentality by demonstrating why intelligent retreat strategies consistently outperform blind persistence when systems are under stress.

We'll explore the powerful combination of exponential back-off with jitter for managing retries, and explain why quickly "giving up" through strategic load shedding often leads to better overall system health than dogged persistence. We'll show how these complementary approaches can prevent cascading failures, improve user experience during degraded conditions, and help systems recover faster.

New contributors and maintainers new to accepting contributions face surprisingly similar challenges: anxiety about "getting it right", unclear expectations, and unwritten cultural norms. This talk presents a practical model for real-time collaborative sessions that address both groups' needs simultaneously, creating stronger, more welcoming open source communities from day one.

Announcements for anyone putting on community events in the future

Thanks for attending!