Talks

Dimensional Shifting

July 7, 2023
TNG Big Tech Day, Munich, Germany.
screencast

An post-pandemic intersectional exploration of Raft, lambda calculus, and category theory. Do formal systems inform actual systems? I don't know, but this talk suggests that they might.

Keynote: The Problem with the Problem

February 22, 2022
PyCon Sri Lanka
screencast

What happens when you give a problem for beginners to professionals? You might uncover a lot of problems.

Keynote: Begin... end?

October 28, 2021
PyData Global
video | screencast

It is an undisputed fact that Python’s success in the world of data owes much to the development of foundational tools such as NumPy, SciPy, and Notebooks. However, what actually happened before all of that? What were scientists even thinking? Or smoking? Why Python in the first place? How did we end up here? In this talk, I recount some of that history.

Keynote: No, not typing. Types.

July 30, 2021
EuroPython 2021
video | screencast

An impressionistic dive into the world of category theory and algebraic type systems--featuring deer, ducks, and space aliens.

Closing Keynote: A Talk Near the Future of Python

October 13, 2019
PyCon India, Chennai
video | screencast

A live-coded implementation of simple stack machine that's later turned into a WebAssembly interpreter capable of running a game written in Rust.

Keynote: Die Threads

July 25, 2018
EuroPython, Edinburgh
video | screencast

An exploration of what Python thread programming could be like if if you gave it advanced features such as thread groups, cancellation, and more. An experimental library "thredo" is described and later revealed to be implemented on top of async (Curio).

Reinventing the Parser Generator

May 12, 2018
PyCon, Cleveland
video

A talk about bringing the PLY parser generator into the modern age through the use of advanced metaprogramming magic. This work can be found in the SLY project.

Keynote: Iterations of Evolution

December 16, 2017
Pycon Pakistan (Remote Presentation)
screencast

An excursion through the early history of Python's most useful practical feature--the for-loop. The discussion describes how iteration evolved from simple beginnings into generator functions and later coroutines. Includes some live demos involving ancient Python versions. Plus, a rare trombone solo.

Keynote: The Other Async (Threads + Asyncio = Love)

October 7, 2017
PyGotham, New York City
video

In the world of concurrency, thread programming and asyncio are often considered separate lands--you either program with one or the other, but not both. In this live-coded talk, I show how to construct a queue object that works with any combination of threads or asyncio tasks using a common simple interface. This allows for a variety of interesting programming techniques that bridge both worlds. This is a somewhat experimental talk, but the underlying foundation can be found in the Curio project.

Keynote: The Fun of Reinvention

June 12, 2017
PyCon Israel, Tel Aviv
video • screencast

A diabolically irresponsible talk in which I celebrate modern Python coding by abandoning all backwards compatibility and look at a variety of new Python 3.6 features. In the talk, I utilize an assortment of advanced language features including decorators, descriptors, class decorators, and metaclasses to build an interesting data-validation system from type-annotations.

Keynote: Builtin Superheroes

August 28, 2016
PyData, Chicago
video • screencast

A celebration of Python's most powerful feature--its builtin types. In this talk, I discuss the builtin types, the collections module, and their use in solving a variety of common data manipulation problems such as cleaning up datafiles, tabulation, and more. For fun, I look at Chicago's health-inspection database with a bit of live-coding. Spoiler: You'll probably want to avoid the airport.

Keynote: Fear and Awaiting in Async: A Savage Journey to the Heart of the Coroutine Dream

July 30, 2016
PyOhio, Columbus, Ohio
video • screencast

A no-holds barred exploration of the new async/await features added to Python 3.5 and their use in writing coroutine-based libraries for asynchronous I/O. A major theme of this talk is that low-level details such as the asyncio standard library event loop are just that--low level details much like assembly code. This talk explores the idea that asynchronous libraries might be better served by focusing on much higher level abstractions and APIs.

Keynote: Topics of Interest (Asyncio)

November 10, 2015
PyCon Brasil 11, São José dos Campos
video • screencast

This talk explores some thinking about the asyncio module and the new async/await features added to Python 3.5. Mainly, I fret about the complexity of asyncio and show that async/await can be used in a completely different manner to achieve the same goals in a simpler way. This talk was given in the early stages of the Curio project. The ideas are explored further in the PyOhio 2016 talk about 9 months later.

Python Concurrency From the Ground Up: LIVE!

April 10, 2015
PyCon 2015, Montreal
video

This is the live-coding talk you were warned about. Starting from scratch I discuss different concurrency models for Python with various coding examples. Topics include programming with threads, the infamous Global Interpreter Lock (GIL), event loops, and coroutine-based concurrency. This talk sets the stage for some of my later talks about asyncio, async/await, and asynchronous APIs.

Discovering Python

April 12, 2014
PyCon 2014, Montreal
video • slides

I talk about my experience serving as an expert-witness in a patent infringement lawsuit. In this work I was locked away in a hidden vault with 1.5 TB of C++ source code and a Python interpreter. Great fun ensued.

Python: A Toy Language

March 15, 2013
PyCon 2013, Santa Clara
video • slides

I talk about writing Python scripts to control a DIY CNC milling machine for the purpose of making toys and doing silly things with the kids. This was an unplanned talk at PyCon 2013 that got created and scheduled at the last minute to fill a time slot left by the unexpected absence of Audrey Roy Greenfeld--who undoubtedly would have talked about something substantially more important than this.

Keynote: Let's Talk About PyPy

March 10, 2012
PyCon 2012, Santa Clara
video • slides

PyPy is an amazing project that makes Python run substantially faster through just-in-time compilation techniques. In this talk, I tackle the general question of whether or not outsiders can actually understand the project enough to tinker with it. To tinker with the CPython interpreter, you need to know C programming. For PyPy, you need to understand RPython. Thus, this talk is mostly focused on that.

Understanding RPython

January 13, 2012 and February 9, 2012
Chipy, Chicago
Part 1: video • slides
Part 2: video • slides

A two-part talk series I presented at the Chicago Python Users Group meeting about understanding the low-level mechanics of RPython--the implementation language for the PyPy project.

In Search of the Perfect Global Interpreter Lock

October 15, 2011
RuPy 2011, Poznan, Poland
video • slides

What's better than blowing up the Python GIL you ask? It's blowing up both the Python GIL and the Ruby GIL in the same talk. In this presentation I take a deep dive into the implementation of global interpreter locks more generally and discuss their pathological performance properties on multicore CPUs.

Embracing the Global Interpreter Lock (GIL)

October 6, 2011
PyCodeConf, Miami
video • slides

When people talk about the Python GIL, much of the conversation centers around its removal. In this talk, I explore the idea of simply making it better--especially with regard to thread scheduling and priorities. To this end, I spend some time blowing up the "new GIL" that was added in Python 3.2. None of the issues in this talk have been fixed as of Python 3.6.

Using Python 3 to Build a Cloud Computing Service for my Superboard II

March 11, 2011
PyCon, Atlanta
video

My first computer was an Ohio Scientific Superboard II. I used it for several years as a kid, but it has since sat in the back of a garage for nearly 30 years. So what happens when my brother takes a summer road-trip to Chicago with the Superboard in tow? Naturally, you plug it in and see if it still works. This talk is about the mayhem that followed. Includes Python 3, ZeroMQ, Redis, and all sorts of other fun.

Understanding the Python GIL

February 20, 2010
PyCon, Atlanta
video • slides • visualization

The Python Global Interpreter Lock (GIL) prevents multiple threads from achieving parallelism on multicore CPUs. In this talk, I deconstruct the internals of the Python GIL in a journey to try and understand some mysterious performance properties. In doing so, I find out that the GIL not only prevents parallelism, it causes threads to fight with each other in a massive multicore battle. There were two related talks presented at ChiPy prior to this talk.

Inside the Python GIL. June 11, 2009. video • slides
Inside the New Python GIL. January 14, 2010. slides

Writing Parsers and Compilers with PLY

February 23, 2007
PyCon, Dallas
slides

A talk about the PLY project and using it to write lexers and parsers. Also presented as a last-minute talk substitution at PyCON UK 2008 in Birmingham, UK. A more detailed deep-dive into PLY was previously given at the ChiPy meeting in Chicago. You might also be interested in those slides

Why Extension Programmers Should Stop Worrying About Parsing and Start Thinking About Type Systems

November 9, 2002
LL2 Conference, MIT, Boston
slides

To extend scripting languages with C/C++, programmers have created a wide-variety of wrapper generation tools such a Swig. Most of these tools are focused on problems related to parsing. For example, parsing C header files. However, in this talk, I claim that this is actually the wrong problem to be solving. Instead, extension building is part of a greater problem in type-systems and that many tricky corner cases can only really be understood in this context.

An Extensible Compiler for Creating Scriptable Scientific Software

April 22, 2002
ICCS 2002 Conference, Amsterdam
slides • paper

A more academically minded talk about the Swig project, given 6 years after Swig's creation. One notable aspect of this talk is a greater emphasis on type-system issues and advanced C++ idioms.

Reintroducing Swig

February 5, 2002
10th International Python Conference, Alexandria
slides

The first presentation on Swig was given at the Python conference in 1996. This talk reintroduces the project after it had undergone 6 years of fairly active development, much of which was focused on supporting advanced C++ features.

An Embedded Error Recovery and Debugging Mechanism for Scripting Language Extensions

June 29, 2001
USENIX Technical Conference, Boston
slides • paper

Scripting languages such as Python and Tcl are often used to build software consisting of a mix of C/C++ and high-level scripts. However, errors in the C/C++ layer often result in a hard-crash that is very difficult to debug. In this talk I describe a mechanism for catching errors such as segmentation faults and transforming them into useful exceptions that can greatly simplify debugging.

WAD: A Module for Converting Fatal Extension Errors into Python Exceptions

March 6, 2001
9th International Python Conference, Long Beach, California
slides • paper

One problem with C/C++ extensions to Python is that fatal errors typically result in a hard-crash of the interpreter with a Segmentation Fault or similar error. This makes debugging extremely difficult. However, what if instead of crashing, a fatal extension error could be transformed into a useful Python exception instead? In this talk, I present a tool and technique for doing just that.

Keynote: Commodity Supercomputing with Python

November 12, 1998
7th International Python Conference, Houston
slides

I describe the use of Python in building massively parallel scientific computing applications on supercomputers at Los Alamos National Laboratory. Much of this talk covers the motivation for using Python in the first place. Also describes work in using Python on early Linux clusters.

Extensible Message Passing Application Development and Debugging with Python

April 3, 1997
IPPS'97 Conference, Geneva
slides • paper

This talk describes how Python was ported to operate on massively parallel supercomputers running MPI.

Lightweight Computation Steering of Very Large Scale Molecular Dynamics Simulations

November 21, 1996
IEEE Supercomputing Conference, Pittsburgh
4th International Python Conference, Livermore, California
slides • paper

I describe the problem of handling large datasets in simulations and how integrating scientific software with a scripting language is a good solution. This is the first talk featuring Python to ever appear at the Supercomputing conference series.

Using SWIG to Control, Prototype, and Debug C Programs with Python

June 5, 1996
4th International Python Conference, Livermore, California
slides • paper

The SWIG project is introduced as a tool for interfacing C/C++ code with Python.