Raymond Hettinger
Bio
Raymond has been a prolific contributor to the CPython project for over a decade, having implemented and maintained many of Python's great features. He has been instrumental in modules like bisect, collections, decimal, functools, itertools, math, random, with types like namedtuple, sets, dictionaries, and in many other places around the codebase. He has contributed to the modification of nearly 90,000 lines of code in the CPython repository, and has made over 160 changes in the PEP repository.
Raymond has also served as a director of the Python Software Foundation, and has mentored many people over the years on their contributions to the python-dev community. He's also well known for his contributions to the Python Cookbook, and shares many pieces of Python wisdom on Twitter. He received the Distinguished Service Award at PyCon 2014 for his exceptional contributions to the python community.
​
Keynote
All levels, Python Fundamentals
​
What I've learned from being a maintainer and core developer for the past 15 years. Thoughts on channeling Guido, stability, hyper-generalization, Sturgeon's law and egativity, evaluating submissions, inability to predict the future, user centric design, treating mature code differently, believing in or doubting your predecessors, lever arguments and completers, problems of too many choices, implementation details, how much to document, needs of the standard library versus the needs of users, code that is dead on arrival and how PyPI changed everything, orthogonality, importance of skill and expertise, consistency and foolish consistency, optimization and premature optimization, security tautologies, argument ordering, operator abuse, avoiding race to implementation (we can all write working code), the naming of parts, economy of force and complexity balance, feature creep, developing for others, over reliance on Guido, great minds don't think alike, preference for compactness, and aversion to deprecations. What it means to be completely reliant on long term unpaid
volunteers.
​
​
​
Patterns for Improving Expressiveness and Eliminating Redundancy using Decorators, Descriptors, Context Managers, and Metaclasses
Intermediate level, 4 1/2 hours of material, 12n-5p before conference starts
* The Spiderman Rule and Management of Complexity
* Wrapper functions
* Nested namespaces and how closures work
* Pattern for factoring-out common parts of functions
* Project: add_logging
* Project: unbounded_cache()
* Class decorators
* How total_ordering() works
* Preview: use of property() for computed fields
* Overview: How descriptors work
* Project: Develop descriptor based data validators
* Preview: Output redirection with print()
* Most common context managers: files and locks
* Three paths through a content manager
* Project base case: family() help() dis()
* Redirection the hard way
* Redirection the better way
* The type() meatballs
* Customizing type
* Project: Name fix-up for the data validators
--------------------------------------------------------------
This is a hands-on workshop where you develop small projects in parallel with the instructor. Bring your computer!
The level is intermediate python, meaning that you already know how to develop working Python code and can easily manipulate data with core containers and can readily organize
your code into functions, classes and modules. You should be reasonably proficient with exception handling and control flow.
If you already know how to write decorators, descriptors, context managers, and meta-classes, this tutorial will be too basic for you. But for everyone else, this will be a great
way to open the door to Python's richest tools for writing expressive code and eliminating redundancy.
​
​
​