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.
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.
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.
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.
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.
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.
April 10, 2015
PyCon 2015, Montreal
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.
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.
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.
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.
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.
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.
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.
March 11, 2011
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.
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.
February 23, 2007
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
November 9, 2002
LL2 Conference, MIT, Boston
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.
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.
February 5, 2002
10th International Python Conference, Alexandria
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.
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.
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.
November 12, 1998
7th International Python Conference, Houston
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.
This talk describes how Python was ported to operate on massively parallel supercomputers running MPI.
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.