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 http://utahpython.org/jellis/pycon-ides.pdf, 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., "self.foo", 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.
|Signals syntax errors||Yes||Yes||Yes||Yes|
|Call tips||During completion||Yes||Yes||Yes*|
|"Go to definition" for python symbols||Yes*||Yes ("Browse source")||No**||Yes|
|Source Control Integration||Eclipse*||No||CVS/Perforce/SVN||CVS/Perforce/SVN|
|Debug external programs*||Yes||Yes+||Yes||Yes|
|Emulation||Emacs (poor)||None||Emacs (poor)||Emacs (good); VI (?)|
|Approximate memory footprint||150MB||10MB||50MB||50MB|
|Unique features||Code Analysis;
|Multilanguage; save macros;
regular expression builder
|Scriptable with python|
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, ...
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...
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.
-- It gives you all the globals and makes the import for getting to that global automatically (check http://www.fabioz.com/pydev/manual_adv_complnoctx.html)
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 http://www.fabioz.com/pydev/manual_adv_debug_console.html)
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 http://www.fabioz.com/pydev/ ?
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. :)
Have you checked if your interpreter is OK? (tutorial explaining how to configure and check your configuration: http://www.fabioz.com/pydev/manual_101_interpreter.html
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.)
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...)
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?
p.s. Just fixed the homepage
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.
One litmus test is, if it doesn't do instrospection-based code completion in at least some cases, it doesn't qualify.
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...
Attached FilesTo 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.