Attachment 'pycon-python-ide-review.html'


Tuesday, February 28, 2006
PyCon Python IDE review

I presented an IDE review at PyCon last Friday. It was basically a re-review of what I thought were the 3 most promising IDEs from the Utah Python User Group IDE review, to which I added SPE, which was by far the most popular of the ones we left out that time. The versions reviewed are:

I'd intended to base my presentation around a comparison of writing a smallish program in each of the IDEs, but the more I tried to make this not suck, the more I realized it was a losing proposition. Instead, I decided to try to focus on the features in each that most set them apart from the others (both positive and negative); this seemed more likely be useful.

(I did a new feature matrix for this review, which is included after my comments. The slides I used are also up, at, but aren't very useful absent video of the presentation itself. Hence this post.)


PyDev has grown up a lot since last September. One rather surprising change, to me, is the splitting of the project into the "base" PyDev, still under the EPL (Eclipse Public License), and the separate, commercial PyDev Extensions. The Extensions may be reviewed for one month for free, but come with a highly annoying nagware dialog every half hour(!).

PyDev Extensions does some stuff that even the much pricier Komodo and Wing professional versions do not. In particular, PyDev provides in-editor warning and error markers for more than the by-now standard syntax errors. For instance, PyDev warns for unused imports, unused variables, and so forth, and will put up an error marker if you try to reference a variable that doesn't exist. As I said in my presentation, "it's like a PyChecker that doesn't suck."

This is still pretty new code, though, and there were some rough edges. In one file, I had an unused "from cStringIO import StringIO" import that PyDev didn't catch for some reason. The import checker also seemed to have issues with nested packages, and the "quick fix" feature doesn't work like you'd expect with previous Eclipse experience--clicking on the error marker in the margin does nothing. (If you remember the keyboard shortcut, though, that works fine.)

This seems symptomatic of PyDev in general -- flashes of brilliance, but sometimes problematic. As another example of this, sometimes code completion didn't work at all. PyDev consistently failed to complete WxPython code, for instance, perhaps because I installed the wx library after PyDev did its initial scan of site-packages.) But other times PyDev completed better than Komodo (and as well as Wing), e.g., PyDev could figure out the attributes of the object returned by file(), where Komodo could not.

It's also worth noting that PyDev's "go to definition" feature was unquestionably the best: if it can't figure out where your symbol comes from, it falls back to a textual analysis, which is better than nothing.


With PyDev switching to a commercial license for, apparently, the bulk of new development, SPE is probably the best remaining choice for a free IDE. (SPE is licensed under the GPL; the author, Stani, does appreciate donations if you find it useful.)

At this point, SPE is rather less mature than the other IDEs I reviewed. SPE ships with the Kiki regexp builder, the wxGlade gui builder, PyChecker, and the winpdb debugger, but of these only PyChecker is really "integrated" with the main SPE editor. Which is a good start, but I found PyChecker's suggestions less useful than PyDev's integrated "Code Analysis;" PyChecker was simply wrong too often.

Another shortcoming is the lack of the ability to create and save "projects" containing information such as the correct PYTHONPATH for a given codebase. Without this, SPE was unable to figure out most of my imports in one of the projects I on which I tested it. (Stani says this should be easy to add for a future release.)

SPE's code completion was weakest overall. It seems to be primarily vim-style completion: if a symbol is used elsewhere in the same file, e.g., "", it can guess "foo" as a completion after you type "self." There are a few cases where it is smarter than this, but not many -- primarily, it could complete top-level constructs imported from a module, but it was helpless once you started instantiating objects from that and asking about those.

It is worth noting that, especially as open-source projects go, SPE's documentation is pretty decent. The manual is fairly comprehensive and up-to-date, and includes some helpful tutorials. (Stani provides an ad-free PDF version of the manual as a thank-you for donations to the project.)


Komodo has at least two large features that the other IDEs do not: support for multiple (dynamic) languages, and a real integrated gui builder, targetting Tk. (There is a dialog in the 3.5.2 build that warns you that code completion--"AutoComplete"--is only supported in Perl and Python right now, but ActiveState's CTO was in the audience and said he believes completion is supported in all 5 languages now. I'd doublecheck this if I had any others installed at the moment, but I don't.) I work in Python full time, but if you work in multiple languages Komodo is pretty much the only option if you want something more sophisticated than Emacs.

Komodo's is also the only Tkinter gui builder I'm aware of that's actually worth using. (Although if you're open to using wxWidgets instead of Tk, wxGlade is free and quite good.)

As far as I can tell, ActiveState has fixed the parsing and autocompletion problems I noticed in 3.1. Perhaps the only major remaining shortcoming is the lack of a real "go to definition." "Find symbol" is essentially text-based, and although the preview pane of where potential matches are found is cool, it's a lot less useful than having a real introspection-based approach. (It also feels kind of slow.)

On a lower-end machine, Komodo is as snappy as SPE and much more responsive than Wing or PyDev. (I was floored when I found out Komodo is built on... mozilla! Do a find for .js and .py in the lib directory. Crazy.) The difference probably won't be noticable on any machine built in the last couple years, but if you have a (really) low end machine, you may want to take this into consideration.


Wing still gets the little things right more often than the competition. One small example: if you have a multiline expression, pressing tab on the second line lines things up The Right Way. With the others, pressing tab... inserts a tab. (4 spaces, actually.) I suppose this could be called a matter of taste; mine is shaped by years of Emacs use. Which (I confirmed) the Wing developers share, so maybe that's why I tend to like their decisions in such matters.

Overall, Wing's completion is clearly best-of-breed right now. For instance, Komodo is unable to complete the tkinter widgets generated by its builder--try typing, say, "self._button_1."--but Wing is able to do so. There are other cases where Wing out-completes Komodo--another is the file() example mentioned with PyDev. Wing also completes locals for you, which is more useful than it sounds until you try it. (The one thing Komodo does better here is that besides giving you a list of symbols, Komodo's completion also visually indicates whether each symbol represents a function or a field.)

Wing's Emacs mode is by far the best. If you're curious, my litmus test for a good Emacs mode is, "Does it make you use a mouse where the keyboard should work perfectly well?" Wing does not; opening a file with C-x C-f brings up a minibuffer (tab-completed, of course) for file selection. No mouse needed! (My litmus test for a _really_ good Emacs mode is a kill ring; Wing doesn't do this yet.)

With version 2.1, Wing is introducing a vi mode, too, but I have no idea what the litmus test is for a good vi mode.


Komodo and Wing are polished, solid choices. Both have excellent debuggers and source-control integration. Both, frankly, will frustrate you less than PyDev or SPE at this time, if you spend a lot of time coding. Wing Professional is about 1/3 less expensive than Komodo. (I talked with several people who weren't aware that both ActiveState and WingWare offer painless, fully functional free demo licenses for one month. So if you're curious, it costs you nothing to try.)

PyDev + Extensions is in the same price range as the Komodo and WingWare personal editions. (All are around $30.) Komodo's personal edition is slightly less crippled than Wing's: Komodo's leaves out the gui builder and source control integration; Wing's also leaves out the Source Assistant panel (basically, the calltips functionality) and some debugger features.

If the PyDev can shake the bugs off it will become even more compelling. I suspect that PyDev's relative bugginess may be due in part to its lesser opportunity to "dogfood" -- the other IDEs are written in Python and their developers, I'm sure, primarily use their own product. PyDev is written in Java, so this isn't an option.

As noted previously, SPE is the only really free choice left. It's still rough around the edges in a lot of ways, perhaps most notably with the non-integrated debugger, but it's better than the other free options. (I covered more of those in the last review. It wasn't pretty.)

My own choice hasn't changed; after revisiting the latest versions of each product, I think Wing Professional still fits my particular needs best.

Feature matrix

PyDev SPE Komodo Wing IDE
Signals syntax errors Yes Yes Yes Yes
Keyboard Macros No No Yes Yes
Configurable Keybindings Yes Yes* Yes Yes**
*Through external configuration file
**Weak UI; expect to do a lot of manual browsing
Tab Guides No Yes Yes Yes
Smart Indent* Yes Yes Yes Yes
*Knows to de-indent a level after break/return/etc. statements
Code completion Decent* Poor* Good** Excellent
*See review text for discussion
**Also, indicates methods vs fields (but not properties)
Call tips During completion Yes Yes Yes*
*"Source Assistant" provides calltips and docstrings in a separate panel
"Go to definition" for python symbols Yes* Yes ("Browse source") No** Yes
*Supplemented with textual analysis; overall best
**"Find symbol" is basically a find-in-files text search
Templates Yes No Yes Yes
Source Control Integration Eclipse* No CVS/Perforce/SVN CVS/Perforce/SVN
*CVS is standard; plugin availability varies for others


PyDev SPE Komodo Wing IDE
Conditional breakpoints Yes Yes+ Yes Yes
+SPE has no integrated debugger but includes winpdb
Debug-integrated Console Yes Yes+** Yes Yes
**"Special commands" make winpdb's console somewhat cumbersome
Debug external programs* Yes Yes+ Yes Yes
*E.g., a script processing a web server request


PyDev SPE Komodo Wing IDE
GUI Builder No Wx* Tk No
*the free WxGlade builder is distributed with SPE, but not integrated with it
Emulation Emacs (poor) None Emacs (poor) Emacs (good); VI (?)
Documentation Poor Decent Excellent Good
Approximate memory footprint 150MB 10MB 50MB 50MB
Unique features Code Analysis;
basic refactoring
UML diagrams;
PyChecker integration
Multilanguage; save macros;
regular expression builder
Scriptable with python

You should also keep an eye on 'pida'.

Altough it's still very much a work in progress it has support for version control (cvs, svn, darcs, arch, bzr, ...), code browsing, integration of the gaspacho gui-designer (PyGTK), a documentation browser, pastebin submission & history, a TODO list, integration of your favourite editor, projects, ...

I'm not really interested in PIDA or other "generic" IDEs that don't have a deep understanding of Python. (If I were satisfied with that, I'd stick with Emacs.)
Like I said, pida is a work in progress and 'keep an eye on it' as it progresses. ;-)

It already has some (limited) python "understanding" (like the code structure browser, the gui designer & integration of pylint, pyflakes & pychecker). And from reading the author's comments on IRC there is more to come. (In some ways it's a bit like Eclipse--an IDE framework/platform to build an actual IDE on.)

PS: I tried PyDev, SPE & WingIDE in the past, and IMHO only WingIDE has something "extra" in its "understanding" of Python...
Dabo ( is an ambitious project that is coming along nicely. V1.0 is projected for the end of this year, and they have done pretty well at sticking with their release roadmap.

What is interesting about Dabo is that the authors are coming from a full-featured, object-oriented, data-oriented development environment (Visual FoxPro), which is much more capable than anything available in Python today. They are unlikely to be satisfied until that have made as a good an environment in which to work in Python.
Dabo is trying to solve a different problem--a complementary one, really.
Hey, and what about the code-completion with auto-import that Pydev Extensions gives you? (I find that one of the most useful ways of code-completion and it wasn't even mentioned in below the code-completion session in the review).

-- It gives you all the globals and makes the import for getting to that global automatically (check

Also, the review is not really correct when saying that you don't get a debug-integrated console. In Pydev Extensions 1.0.2, you do have a debug-integrated console (check

And I know the docs are still not 100%, but I think it could deserve a 'decent' and not 'poor' -- have you been able to found it at the 'manual' session in ?


Hi Fabio,

I did not mention pydev's completion of globals because it didn't (and still doesn't) work for me, even a little. Auto-import is pretty cool, though, if a bit slow sometimes.

I fixed the debug console feature matrix. Thanks for the correction.

Re the docs, well, I guess you could say that the bar has been raised since my September review: the pydev manual is a lot better now than, say, Boa Constructor's, but BC isn't in this review for very good reasons. :)
It appears that you have a problem in your interpreter configuration (the problem you had with cStringIO and wxPython appears to be because of that too).

Have you checked if your interpreter is OK? (tutorial explaining how to configure and check your configuration:
and the 'next pages' explain how to configure your project)

If you upgraded from a version earlier than 1.0, this could happen (from 1.0 onwards, all the configurations are backwards compatible, but earlier versions could have this problem.)
I used a fresh install of pydev (and eclipse!) for this review. My interpreter config looks exactly like your manual screenshot.
And your project has the pythonpath correctly set too?

If you do xml| Ctrl+Space it does not show any global in your workspace? (it only shows after you type at least 3 chars because otherwise it could get too slow...)
Ah... your manual page doesn't make it clear that you have to manually request the completion each time. It works with ctl-space (when I turn off Emacs bindings).
I'll make it clearer ;-)

The autocompletion is only for simple tokens (self, print, etc) and after '.'

For others, you NEED request it with Ctrl+Space...

So, did you like it?
I don't tend to write "from x import y" as much as "import x... x.y," so writing "x.y" and then doing the quick-fix to add the import flows better for me. But I can see how this would be useful if your style tended the other way.
Well, modules show in that completion too (together with classes, methods and global variables), so, you should be able to use it even in your style ;-)

p.s. Just fixed the homepage
What about Eric3. It's a nice Python IDE, IMHO the best free Python IDE.
I was sufficiently unimpressed with Eric3 the first time around that I didn't feel the need to review it again.
I enjoy Wing the most out of these IDEs, although it irritates me that their built-in shell doesn't start up in the project directory and their debugger acts strangely about throwing exceptions. Consequently, I find myself migrating back to Komodo on occasion, although their autocompletion is brain dead.

I'm glad someone is reviewing these IDEs with the ideas that a) yes, people do want features that actually work. Hopefully at some point, we'll get an IDE that gets all of the features right.

I don't know why it's taking so long for all these IDEs to mature, but it makes me roll my eyes every time someone says "have you looked at this IDE" when it's still in a beta state. Please go away and inform me when you have a stable, mature product instead of a bug-ridden hack.
I'm not sure why you say Komodo is the only 'multilanguage' IDE; Eclipse probably supports more languages than any other IDE; I've personally used its Perl, Ruby, C/C++, Make and Java environments, but dozens (possibly hundreds) more exist.
Eclipse may support multiple languages, but PyDev does not, and the plugins for non-Java languages are mostly nowhere near as robust as PyDev. So equating Eclipse's multilanguage support with Komodo's is misleading at best.
You missed JpyDbg , which is both available FOR FREE as plugin from Jedit or Netbeans with lot of features comparable to the other listed here

Like I told the PIDA guy, I'm not interested in "generic" editors/IDEs like JEdit or Netbeans, even with a debugger plugin.

One litmus test is, if it doesn't do instrospection-based code completion in at least some cases, it doesn't qualify.
May I please correct the PIDA url,
What do you think about pyxides?
pyxides is vapor at the moment, but Stani certainly seems passionate about it and he obviously has a track record of being able to deliver. Should be interesting to see what happens there.
I don't know why it's taking so long for all these IDEs to mature

IDEs are huge complex beasts to write, even harder to write well, and Python is still a comparatively small market. I'm guestimating any decent IDE has 100 years of effort in it -- Wing IDE has about 16 and I'm fairly sure our wish list is another 84 years long! ;-)

But we're getting there...
How about Visual SlickEdit? I really don't know much about the feature set other than they have Python support. A very experienced programmer friend of mine swears by it for his programming.
What about the IDLE editor that comes with Python (the windows version at least)? I need a bit of ammo on why we should look beyond what comes in the package. A very sparse feature matrix?
Well, yes. IDLE supports virtually none of the features I talk about here.
Ever considered PyScripter?
and activegrid??
i just tried out pyscripter, very impressive... especially considering I've never heard of it before
It seems activegrid is coming along nicely, though I've only perused their site and not worked with it yet.
Post a Comment

<< Home

Powered by Blogger

Attached Files

To refer to attachments on a page, use attachment:filename, as shown below in the list of files. Do NOT use the URL of the [get] link, since this is subject to change and can break easily.

You are not allowed to attach a file to this page.