Python DevCenter
oreilly.comSafari Books Online.Conferences.


An Interview with Guido van Rossum

by Bruce Stewart

Guido van Rossum created the Python language in the early 1990s at CWI in Amsterdam, responding to an inner desire for a more elegant and powerful scripting language. He now leads the PythonLabs development team at Zope Corporation.

Guido will be presenting a session on the State of the Python Union at O'Reilly's upcoming Open Source Convention. He recently took a few minutes out of his busy schedule to answer some questions about Python and open source development.

Stewart: I know you just released version 2.2.1 of Python. What's new in this version?

van Rossum: That can be interpreted in two ways: what's new in 2.2 (since 2.1), or what's new in 2.2.1 (since 2.2).

Many people are still using some version of 2.1; we even released a bugfix release, 2.1.3, a few days before 2.2.1 was released. Therefore the first question is an important one. For the answer I usually refer to Andrew Kuchling's paper by that title. For me personally, the highlights are (1) iterators and generators, and (2) a new class implementation, which currently lives besides the old one, but will eventually supplant it.

What's new in 2.2.1 isn't particularly interesting, and that's as it should be: it's a maintenance release that adds stability to the new features introduced in 2.2, as well as fixing a number of rare old bugs. Anybody who is using 2.2 should upgrade to 2.2.1.

I did manage to sneak in half a new feature, which is a faint echo of a feature that will be introduced for real in 2.3 -- a new built-in function bool() that takes an arbitrary value as its argument and returns a canonic True or False value; there are also built-in constants True and False. The difference with 2.3 is that in 2.3, bool will be a separate type (a subtype of int); in 2.2, bool() returns a plain int, which is more compatible, though less useful than the 2.3 version.

The goal of adding this to 2.2.1 is not so much that you can start writing code that anticipates the new feature, but that it allows us to more easily backport code written for 2.3 to 2.2.1.

Stewart: What features are you most excited about that are being developed for future versions of Python?

van Rossum: As far as the language is concerned, I'm looking forward to the full integration of the new class implementation. This is quite a ways off, mostly because backwards compatibility is so important in this phase of Python's life.

Another thing, much farther in the future, is compilation to C or machine code. I used to think that this was impossible and (perhaps because of that) uninteresting, but recent experiments (like Armin Rigo's Psyco and Greg Ewing's Pyrex) suggest that this will eventually be possible. It should provide Python with an incredible performance boost and remove many of the reasons why many people are still reluctant to switch to Python.

I'm also excited about a new version of IDLE that is being developed as a separate project. IDLE (a Tkinter-based Python editor and shell) has always been one of my pet projects, but I've had no time to work on it. Fortunately, several others under the leadership of Stephen Gava have picked it up where I dropped it, and are adding many new features.

Perhaps the deepest change to IDLE is separate execution. Currently, when you type a Python command in IDLE's shell environment, it is executed in the same process that is running IDLE. While this is very efficient, and it is normally easy enough to keep IDLE's internal data separate from the user's code, there are certain things that become difficult or impossible, like testing a program that has its own Tkinter main loop (which would interfere with IDLE's main loop), or process management.

It's also hard to interrupt a runaway piece of code in the current version. All of these problems will be fixed. There will also be a proper interactive configuration dialog, and the interface for testing your program will become much more intuitive.

I know that not everybody takes IDLE seriously. But most decent alternatives are commercial products, and you did ask me what excites me.

Stewart: What inspired you to develop Python in the first place? Was there something you needed that wasn't available in other scripting languages?

van Rossum: I needed a decent scripting language. Remember, it was over 12 years ago. Tcl hadn't escaped from the labs in Berkeley yet; an early Perl existed but, besides offending my language design sensibilities, it was strictly limited to Unix.

I needed something that would run first and foremost on Amoeba, a distributed operating system developed by Andrew Tanenbaum's group. The only alternative available on that platform was a port of the Unix V7 shell; but it was hard to teach it about Amoeba's (at the time) exciting new features.

I combined this external need with an internal one: the desire to do a follow-up to the failed ABC language project (still available on the Web).

I had been part of the ABC development team in the early 80s, and in my head I had analyzed some of the reasons it had failed. Failure can be measured in many ways. On the one hand, upper management withdrew all funding from the project; on the other hand, there were few users. I had some understanding for the reasons for the latter, and to some extent Python is a direct response to that.

In part, of course, the reason for ABC's failure was that it was too early for such a high-level language. But I believe that several of its early major design decisions contributed to its demise:

  • Unconventional terminology intended to make beginners more comfortable but instead threw off more experienced users
  • A monolithic implementation that made it hard to add new features
  • Too much emphasis on theoretically optimal performance
  • Not enough flexibility in its interaction with other software running on the same computer (ABC didn't have a way to open a file from within a program)

Python addresses several of these issues by its object-oriented design and by making it really easy to write extension modules.

Stewart: What would you most like to change about the Python development process or community?

van Rossum: I wish I could still interact with the community at large like I used to, but the traffic on comp.lang.python is too overwhelming, so I peek in rarely nowadays (unless there's a specific topic that has my interest).

I don't have a personal desire to change anything about the development process -- it is going as well as it can given the growth of the community. A friend once said, "In a sufficiently large population there are no uncontroversial topics," and my recent forays into comp.lang.python have certainly shown this to be true. But I think the community is doing a good job of developing mechanisms and processes where they are needed.

Pages: 1, 2

Next Pagearrow

Sponsored by: