veyepar: Guardrails: An Alternative View of Safely Working in Python

Author(s):	Christopher Neugebauer
Location	Ballroom D
Date	jul Sat 26	Days Raw Files
Start	14:15	First Raw Start	13:53
Duration	00:30:00	Offset	0:21:20
End	14:45	Last Raw End	14:53
Chapters	00:00 0:08:37
Total cuts_time	30 min.

https://www.pyohio.org/2025/program/talks/guardrails
raw-playlist raw-mp4-playlist encoded-files-playlist host mp4 svg png

assets release.pdf Guardrails_An_Alternative_View_of_Safely_Working_in_Python.json
logs
Admin: episode episode list cut list raw files day marks day marks day image_files

State:

Locked:

clear this to unlock

Locked by:

user/process that locked.

Start:

initially scheduled time from master, adjusted to match reality

Duration:

length in hh:mm:ss

Name:

Video Title (shows in video search results)

Emails:

email(s) of the presenter(s)

Released:

has someone authorised pubication

Normalise:

Channelcopy:

m=mono, 01=copy left to right, 10=right to left, 00=ignore.

Thumbnail:

filename.png

Description:

markdown

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

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

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

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

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

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

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

---

(\* SKILLED OPERATOR ON CLOSED CIRCUIT; DO NOT ATTEMPT)

Comment:

production notes