Home > Python > Writing > 

Conference Report: Seventh Python Conference

[Search amk.ca]
This page last modified: 22 Dec 2006

This is a day-by-day account of the Seventh Python Conference, held in San Jose, California in November 1998. Originally this was a set of entries in my diary for November 1998.

Tue Nov 10 1998: In transit to the Python Conference for most of the day. Things started off ominously when the shuttle that was supposed to pick up me broke down, and a replacement shuttle had to be sent. I arrived at the airport an hour and a half later than planned, but thanks to my paranoia about scheduling, that still left me plenty of time to catch my plane. After an uneventful flight to Hobby Airport in Houston, I took a taxi to the conference hotel, checked in around 2PM, and took a much-needed nap. I was afraid the conference hotel would be in the middle of a wasteland, and my fears turned out to be true; it was an asphalt wasteland, of strip malls and fast-food restaurants. Don't have a car? Then forget the idea of going anywhere on foot!

Anyway, after my nap I headed down to the conference area where people were milling about after the afternoon tutorials. Around 6 PM we moved outside for the reception. It wasn't really suitable weather for an outdoor reception, since the Houston area is in the middle of a cold snap, so it was rather chilling, and people kept running back to their rooms for sweaters and jackets. I finally got to meet Sean McGrath and Paul Prescod from the XML SIG, Frank Stajano, and Fredrik Lundh and Håkan Karlsson from Pythonware. I also ran into people whom I'd already met: Andrew Dalke, David Ascher, Jeff Bauer, Paul Everitt, Robin Friedrich, David Beazley, Dave Mitchell from Magnet (3 Daves in a row?), a brief glimpse of Christian Tismer, and doubtless others whom I've forgotten.

For supper 16 of us went out to a sushi restaurant recommended by Robin. Those of us who didn't want sushi ordered on our own; the other 10 people had a massive group sushi order that took about 15 minutes of planning on Barry Warsaw's part, and rang up a final tab roughly equivalent to the US defense budget. Back to the hotel, and that was the end of day 0.

Wed Nov 11 1998: Day 1 of the conference was great fun, one of my best days at any of the Python conferences. Eric S. Raymond started it off with "Homesteading the Noosphere", which I'd already seen at the May Linux Expo. (He'll also be giving a talk in the DC area in early December, at the next NOVALUG meeting.) Programmer types seem to respond really well to the talk, and there were several insightful comments from the audience, particularly from Paul Dubois. Even if you've seen ESR give this talk before, his presentation is varied enough that you definitely won't get bored if you see it again.

The standard of the accepted papers was quite high, and there wasn't a single one that I didn't find interesting (unlike past conferences). Probably this is due to the continuing growth of the Python community, which permitted the program committee to be more selective. The first three papers (Frank Stajano's SMS Server, Ken Manheimer's Mailman talk, and Sean McGrath's XML talk) were all very good. Sean's application, using an XML processing system built in Python to handle all 600 volumes of the Official Record of the Proceedings of the Irish Parliament, was particularly interesting, since it's a critical application built in Python, and demonstrates the language's usefulness for processing over 3 gigabytes worth of data.

After lunch (some only mildly successful fajitas), Jim Hugunin gave his invited talk about JPython. Jim has been experimenting with doing whole program analysis in jpythonc and performing ML-style type inference, in order to generate better Java bytecodes from a Python program. Currently jpythonc turns Python code like i = i + 1 into a method call into the JPython run-time, which handles Python's varied addition semantics; i could be a string, it could be a list, an object with an __add__ method, etc. If it's possible to determine that i will always be an integer, it can be compiled to a few Java VM instructions, without the relatively slow method call. This provides a substantial performance boost. Even without a Just-in-Time compiler, the resulting JPython code is faster than CPython. With a JIT, the bytecodes can get transformed into machine instructions that are essentially the same as would result from corresponding C code; Jim showed some benchmarks where the resulting code was 25 times faster than CPython.

That's good news, because the following session on Optimizing Python, seems to show that there aren't any easy ways to speed up the existing Python interpreter. Skip Montanaro tried running a peephole optimizer over Python bytecodes, and only got about 3-4% speedup. John Aycock converted bytecodes to C, and got 50% to 100% speedups for some cases, but 100% slowdowns for other cases; a fancier conversion process might fix those degenerate bad cases. Martin von Löwis's attempt at adding virtual method tables to Python may be more promising, but the results, while they demonstrated fewer lookups required, are too preliminary to demonstrate that this actually results in much of an improvement in running time.

At the demo/poster session, I presented our Remote Microscope software. Unfortunately, I was busy enough talking about it that I didn't get a chance to walk around the room and look at all the other demos, but I did get some helpful suggesions from some of the people I talked to. Word-of-mouth had it that they were all quite good. I particularly regret not getting around to seeing the Pythonware demo, or the demo of Beyond, a Python-scriptable framework for 3D action games. Overall the demo session was a great success, since a lot of people got to talk to each other, and the applications were all very impressive. There will almost certainly be another demo session at the next conference.

Thu Nov 12 1998: The day started off with David Beazley's supercomputing talk. He reminisced about the trials of programming on a Connection Machine CM-5, and discussed SPaSM, a C/Python application running on Avalon, LLNL's Beowulf system. Beowulf is a Linux-based supercomputer architecture that's been attracting a lot of attention because of its low price/performance ratio, and David's talk let us see what gets executed on a Beowulf machine. SPaSM was nominated for the Gordon Bell Prize for the most innovative supercomputing application; the prize was also being announced today, and SPaSM wound up being the runner-up, after another application that used custom-built hardware instead of off-the-shelf Linux boxes. David's talk was hilarious, but still contained lots of interesting technical details and insights into the supercomputing community. Note to organizers of Linux conferences: try to get David to give this talk at your next conference; it'll be worth it...

The next session was on extending and compiling Python. Paul Dubois discussed CXX, a C++ wrapper for Python's API that made the code for a C extension look much clearer and more like the corresponding Python code. This was impressive enough that Guido referred to it in his keynote speech on Python's future, as a possibility for Python 2.0. John Aycock (again!) gave a great talk on his parsing framework; there seem to be a lot of compiler geeks in the Python community, since there were lots of questions and comments. Jonathan Riehl talked about the PyFront system for converting Python code to the corresponding C code, and Roger Masse discussed the problem of adding optional static typing to Python, so you could specify that a given function parameter would always be a string or an integer or whatever. Optional static typing was definitely a hot topic at this year's conference, since it would let us generate much better C or Java bytecode from Python; witness Jim Hugunin's results.

After lunch, Guido van Rossum gave his talk, variously titled "Python: The Next Seven Years" or "Python 2000" depending on who you asked. Guido didn't try to predict the next 7 years, because it's impossible to predict the course of software and operating environments over that long a time span, so he limited himself to discussing his roadmap for upcoming versions of Python:

The final session was on science and simulation applications. Jason Asbahr talked about Beyond, a 3D gaming system that lets you write all the components in Python, letting you program sophisticated behaviour. You'd write Python classes to implement characters, weapons, and so forth. It's essentially simply SWIG interfaces on top of 3rd-party graphics libraries, tied together with the object control system in Python. The control system is portable; they're using proprietary libraries on Windows, but you could SWIG entirely different libraries on Linux, and games written using this system would see no difference across the two platforms.

Unfortunately I didn't see the demo of Asbahr's system at the demo session, but word-of-mouth said it was really impressive. Performance seems to be quite sufficient; Asbahr claimed that, with a good 3D graphics card, the software only used about 10% of the CPU, so the use of an interpreted language isn't a bottleneck. (Asbahr doesn't seem to be the only person with this idea. Conferences are often used for recruiting employees, and there was a handout from Origin Systems floating around; they're looking for Python programmers to "write the second generation of massively multiplayer online gaming systems". Are they talking about the next version of Ultima Online?)

After his talk, I left the conference room to get a drink, ran into Cameron Laird, and talked to him for a while. This meant I missed F. Oliver Gathmann's talk, but got back into the conference room in time for Ivan Van Laningham's talk on the Mayan calendar. This turned out to be a really good talk, and the following question-and-answer session was the longest and liveliest one of the whole conference.

"The Mayans looked on the integers as gods."

"What did the Mayans think of integer division?"

Ivan Van Laningham and an unknown audience member at IPC7

Y2K problem? The Mayans didn't have a millennium-2K problem!

Eric S. Raymond at IPC7, on learning that the Mayan calendar takes 28 octillion years to wrap around

IPC7 was an excellent conference, and definitely a true hacker's conference. Some applications were practical and some weren't, but there wasn't a single talk that I found boring, and most of them were very (as opposed to just mildly) interesting. Yet again this year, I was astonished by the applications that people are using Python for: games, running systems from supercomputers down to Windows CE devices, prototype software, production software, little useful hacks... I was also reminded of why I like the community that surrounds Python; we're a friendly and clever bunch of people, who are doing all sorts of interesting things with the language. The Python community is definitely an excellent example of a free software community in action: working together, helping each other, and having fun in the process.

Fri Nov 13 1998: I don't think I slept at all during the previous night, though my memories of the time from 1 to 3 AM are a bit fuzzy. The rest of the night was spent staring into the darkness, wishing I could really fall asleep. That left me in great shape for Developer's Day, where we got to argue with each other about the future course of Python development. In the first session, GvR took some polls to learn the distribution of the various platforms (Windows, Mac, Unix, other) and which versions of Python people are using. The moderators of each session then gave little overview talks of their subject, so people could decide which sessions to attend. I was responsible for the XML session, and an advocacy discussion in the final session. The other track of sessions focused on language design questions -- static typing, interfaces and implementations -- and I didn't attend them.

Greg Ward's "Extension Building Considered Painful" session went well, and produced a good list of action items to work on. The XML-SIG session also produced good results, giving me a future direction to move in. The near-term issues are:

I was disappointed by the advocacy session (I probably shouldn't have skipped my slides, since they would have provided more of a grounding for discussion) but jobs were a large issue: companies are looking for Python programmers, but have difficulty finding them; we need to set up some sort of job board. The following free-for-all session didn't produce any remarkable fireworks, so Developer's Day ended quietly.

[Contact me]