PyCon US 2013 is over! It was a lot of fun — and super informative.
(Want to follow them all? I made a Twitter list.)
I also met a whole lot of other Python developers from across the US and even the world, and the entire conference had a great energy. The discussions over beers ranged from how to use Tornado effectively to how to hack a Python shell into your vim editor to how to scale a Python-based software team to how to grow the community around an open source project.
In stark contrast to the events I’ve been typically going to in the last year (namely: ‘trade conferences’ and ‘startup events’), PyCon is unbelievably pure in its purpose and feel. This is where a community of bright, talented developers who share a common framework and language can push their collective skills to new heights.
And push them, we did.
IPython in Depth
My first tutorial was IPython In-Depth. From this, I was sent down the path of really digging into three areas of IPython I had not paid much attention to before: its 0MQ based architecture, its display framework, and its new support for “cell magics”.
The 0MQ architecture means that IPython has essentially created a “Python server” which can efficiently receive commands for evaluation from other IPython “clients”. What does this mean? You can run IPython in “kernel” mode (simply run: “ipython kernel”) and a headless service will run in the background. You can then connect to that service from any number of clients — for example, IPython’s web-based HTML notebook, an IPython command-line client, or an IPython client embedded inside a vim (via vim-ipython) or emacs editor.
From there, code can be sent to the kernel for evaluation, and results returned. This kernel can even live on a remote server (for example, to pull data from production) and be secured with an SSH tunnel. Really cool stuff — and I think people have only scratched the surface for how this opens up tool development options for Python. For example, imagine two engineers collaboratively working on Python code and testing their interaction in a shared IPython session running on a server.
The IPython display framework is what makes it possible for the IPython Notebook to display rich content as the evaluation of expressions. For example, images, plots, graphics, tables, Markdown-formatted text, and more. The point of understanding this framework is that it actually enabled a much more prototyping-friendly coding style, when you imbue your Python objects with the display protocol to allow them to “repr” themselves in rich and visual ways.
Finally, cell magics. These make it possible to apply some special IPython logic to an entire cell of code. Some of these are already quite powerful, e.g. %px (for parallel execution on an IPython cluster) and %%timeit (for performance measurements). But what’s even cooler is that by using a small Python library and a decorator syntax, you can easily write your own cell magics, offering another higher level abstraction for interactive prototyping.
Rapid Web Prototyping (my tutorial)
Overall, the tutorial went really well. I managed to cover a lot of material in a compressed time period, gave people a chance to play with a lot of small tools from their machines, and even had some great design and architecture discussions during the Q&A session.
One of the tutorial attendees described it as a course that “unified” her web knowledge. And another called it a “smörgåsbord of powerful, but comprehensible, technologies that I’ll be exploring for weeks.”
For me personally, it was a personal goal of mine to teach some material at PyCon that I felt would especially benefit those who were novices in either web development or rapid prototyping. For many attendees, this was the first time they were experimenting with static HTML clickable prototypes and alternative lightweight frameworks / DBs like Flask / MongoDB.
In short: a great experience, lots of fun, and an exhausting first day!
My next day of tutorials were a bit more academic. I spent the first half of the day in Brandon Rhodes’ tutorial on Sphinx and code documentation. Most of this was material I already knew; I attended this tutorial only because my Data Analysis tutorial was over-subscribed and I couldn’t find a seat.
But, I was actually glad about this: Brandon has a great tutorial presentation style (very different from mine) and I treated it more as a way to learn about different teaching approaches. Also, though I’ve been a heavy user of Sphinx for awhile, I learned some new things about using the autodoc module for code documentation and how to customize look-and-feel more directly.
Advanced Machine Learning
In the afternoon, I shifted over to an advanced machine learning tutorial with scikit-learn. This tutorial was loaded with interesting code examples and concepts, many of which were beyond my current level of academic background. But I thoroughly enjoyed getting exposed to a lot of these and learning a bit more about the scikit-learn API. It also meant I had a lot of interesting ideas for how to capitalize on the knowledge for Parse.ly.
Done with Tutorials
The tutorials were over, and I felt like I had truly expanded some of my skills, as well as exercising some of my own teaching / public speaking muscles.
(By the way, you should exercise those, too, periodically — they do atrophy.)
Highlights of the Conference
The rest of the “official conference” was itself, truly a smörgåsbord of powerful Python technologies being explained by top-notch practitioners. Among these, I’ll highlight a few of the most interesting talks I attended, with the respective theme:
On the Parse.ly team, we already had a few watercooler discussions around the Raspberry Pi. My colleague Didier has actually “de-tethered” from cable and now uses a Raspberry Pi as a $35 media center computer.
But it wasn’t until I attended PyCon that I realized just how important — and transformative — this technology really is.
Eben’s keynote address does a great job about getting you excited about the Pi, and is also just a great story of startup scaling. As a present to every PyCon attendee, everyone received a free Raspberry Pi Model B, along with a 4GB SD card pre-loaded with Debian. A very wise marketing move: I’m certainly playing with it when I get home!
The Raspberry Pi was not only featured in several lightning talks, but also in many barside conversations. People were eager to get home and figure out how to use Python to truly embrace the hacker spirit: building useful tools that you can actually deploy in the real world. I heard about ideas for music players, alternative gaming consoles, security systems, art installations, and educational tools. One project even discussed its goal to bring Raspberry Pi devices pre-loaded with thousands of Khan Academy videos to remote regions beyond the Internet’s digital divide.
Parsing and Compilers
As someone who took David Beazley’s amazing compilers course in Chicago last year, I was pleased to see the amount of activity at PyCon around language parsing.
Alex Gaynor, one of PyPy’s core contributors, gave an excellent talk that implemented a basic language interpreter in less than an hour, using a library he wrote called “rply” — a PLY port to RPython with a better API. A related talk was an introduction to Allen Short’s Parser Expression Grammar-based library, parsley.
(Funny side note: Allen mentioned that the reason he spelled ‘parsley’ correctly was to disambiguate it from Parse.ly!)
I also acted as a fly on the wall at the PyPy open space, where some of Python’s most important compiler and language hackers discussed some of the issues they are running into for getting PyPy fully working with Python 3.x and making headway on PyPy’s stackless / GIL-less operation.
These talks are definitely worth a watch:
- So, you want to write an interpreter?, by Alex Gaynor
- Worry-free Parsers with Parsley, by Allen Short
Pandas was declared at one of the keynotes as being a “new killer app” of the Python language. These two talks showed some of the power of Python as a data analysis and algorithm prototyping environment.
Pythonic Approaches to Problems
These two talks focused on some corners of the language that tend not to be discussed in much detail, but open up many interesting Pythonic approaches to problems like encapsulation and datetime handling.
Yes, he deserves his own category. Raymond Hettinger gave three talks that I attended, and each was superb. His keynote discussed the important “winning features” of the Python language that have caused it to not only be a vibrant community in its own right, but a trend-setting language across the entire software landscape. His two other talks focused on Python style, specifically around things like iteration and class design. For those in the startup community, his “Python Class Toolkit” talk is particularly awesome — and hilarious.
Overcoming the Gender Gap
I tweeted that one of the biggest differences between my last PyCon (2009, Chicago) and this one was the much larger startup presence, especially in the exhibit hall. I met the folks from top-notch startups like Optimizely, Bitdeli, Datadog, Disqus, Quantcast, Continuum, and many more.
But the bigger surprise was the difference in terms of gender distribution. Apparently, 20% of PyCon attendees were women. The excellent PyLadies organization managed to help spread awareness for PyCon and the Python Software Foundation made a concerted effort to diversify what was typically a male-dominated conference. These efforts paid off in a big way. I was really glad to see this improvement, and it got me thinking about how the same techniques spearheaded in the Python community can be used to improve the gender diversity of other areas of entrepreneurship, technology, and education.
In short, I couldn’t be prouder to be a Pythonista, and there’s no better time than now to be a Pythonista. It was a great experience — a warm congratulations and thank you to the organizers for putting together an amazing event.
See you next year in Montreal!