One Year Later: Review of PyCharm 2.7 from a Vim User’s Perspective | Hacker News Reader

One Year Later: Review of PyCharm 2.7 from a Vim User’s Perspective

andrewbrookins.com

79 pointslauriswtf39 comments

It's very similar to RubyMine; JetBrains' Ruby (Rails) IDE. For the first time in my life I said to myself, "I _need_ to buy this software for my professional toolkit."

It's priceless. The same benefits you mentioned, while being really useful in exploring model associations, Rails API autocompletes and more. I used to use Sublime Text, but really; when I'm working on a big project, I _want_ those extra features to let me know if I'm mucking things up by using the wrong models or missing associations or exploring the codebase.

Money well spent.

RubyMine and PyCharm are both handicapped IntelliJ IDEA spin offs.

You could buy IDEA and run RubyMine and Pycharm as plugins. ;)

It's annoying when the specialized versions release before the IDEA plugins are tested and released. Reading about the cool new features and not being able to find them in IDEA sucks. :-)

I can only agree, PyCharm ist really great work by JetBrains, i love it.

What i think he really missed in features though:

- VCS integration is really really good

- Plugins for the Atlassian suite (never open Jira in a browser again!)

- virtualenv support

- remote debugging and execution and uploading support

- vagrant support

Indeed. Virtualenv support is fantastic: have a virtualenv dir already there? No problem, PyCharm will detect it. Want to create a new one? Why, let PyCharm do it for you, it will even install packages!

The only outstanding gripe I have is the lack of full PyQt support in the autocompletion / intelligent import features. I know it's a hard problem and there are hacks, but if they could fix it for good it'd make it The Only True Python IDE for me.

Totally. And as someone who runs a linux and mac machine the "personal license" is awesomely down to earth.

Especially when you bought it on black friday or christmas or whenever they had 75% off :P

I am considering buying IntelliJ next time they have such an offer..

I regret not buying Intellij Ultimate during their End of the World sale.

VCS integration is pretty good. I still tend to use the command line for most stuff though, so I didn't include that feature in my review. Still, there are nice things like having a graphical indicator of changed lines in a file since the last commit -- showing in the left margin of the file -- that I like, and it's probably worth a section.

I tried remote debugging and Vagrant tools and haven't used them very often since, so I didn't include them in the review.

I don't use Atlassian software except BitBucket repos, which the VCS plugin (and my command-line Git-fu) seems to handle fine.

However, I do use PyCharm's virtualenv support all the time, and it's pretty nice. Good point there and I should probably add something about it in the project management section.

WebStorm is my editor of choice, and it has most of the same strengths.

It's amazing though how complicated an IDE can be to develop. I'm not surprised JetBrains really specializes. TeamCity, while good, does not approach the sophisticated of something like PyCharm.

Conversely, the joke at WWDC was that Xcode 5 brings Apple's native tools into the year 2011.

One thing that doesn't turn up in that review: default key bindings.

See: http://www.jetbrains.com/pycharm/docs/PyCharm_ReferenceCard....

vs: http://www.jetbrains.com/pycharm/docs/PyCharm_ReferenceCard_...

You'll notice a few major differences, like control-N on windows == apple-O on a mac.

Just weirdly inconsistent and irritating when you're jumping back and forth between different machines.

I'll totally +1 for the terribly average support for themes too. Copy the xml files into my colors/ folder by hand? Really...?

Other that that it's fantastic though~

Yeah, I should probably have a "Multiple Platforms" section in there to discuss issues like that different key bindings. Since I've remapped almost everything, I don't notice it as much.

IntelliJ and friends are great, but the default keymap is a train smash on most common Linux distros. Whoever thought ctrl+alt+right arrow was a good navigation shortcut?

Unless they fix their 64bit Linux version [1] I'm not bothering try it out again and give up within a few minutes.

http://www.reddit.com/r/Python/comments/182siy/pycharm_27_is...

Try adding these lines:

  -Dawt.useSystemAAFontSettings=on 
  -Dswing.aatext=true
  -Dswing.defaultlaf=com.sun.java.swing.plaf.gtk.GTKLookAndFeel

to the pycharm64.vmoptions file.

Hmm, I have a hard time seeing a difference, but this is a large screen and a decent computer. What uglieness should be fixed by this? I use Oracle Java 1.7.0_21-b11 64-bit. Those hundreds of Java flags are a mystery to me.

It tells AWT to use anti-aliased fonts, same for Swing, and then set the LookAndFeel to GTK.

When I originally tried these, they did nothing for me.

And now that I think about it, I wonder if it had something to do with my KDE setup and how it handles GTK stuff. That could be another thing that changed for me that fixed it. Because it did get better recently but I don't know why.

The issue is with Swing, not JetBrains products alone and I sympathize with them but I can say it was bad enough for me that I just couldn't use their stuff on my primary work machine.

I posted that comment.

I run Fedora 18 with KDE on a 64 bit machine. When the new Android IDE came out based on IDEA I downloaded it to take a look at it. I opened it up and much to my surprise the fonts looked pretty good. I opened up PyCharm and it looked good too.

It had been a while with a lot of updates to Fedora including KDE, Java and so on. So I don't know where the problem got resolved but it seems pretty good now.

I think it is worth noting - I never had a problem on my 32 bit system running the same OS and what not. This was also an issue for all my swing apps on that machine - not just the JetBrains stuff.

java swt in linux is still horrible (yes i know there are workarounds such as patching your font [1]).

but if you use jedi and by extension things like youcompleteme[2], vim-dispatch etc. the only thing that's really missing is debugging support and refactorings.

omnisharp[3] does pretty cool refactorings with nrefactory. and the author youcompleteme is interested in having youcompleteme work as some sort of ide daemon, where you could for example add stuff like refactorings as ide features.

vagrant and virtualenv support sounds interesting though.

[1] http://gleamynode.net/articles/2280/

[2] https://github.com/Valloric/YouCompleteMe/

[3] https://github.com/nosami/OmniSharp

I want to believe. I suspect that hacking at large codebases with emacs/vim isn't the way we're going to build complex codebases over the next few decades. But I downloaded the free trial and got out of there after about 5 minutes and went back to shell + emacs. I just can't see how I'd ever really be in control with this complex layer between me and the actual python/django processes executing on my laptop. Without meaning to be gratuitously insulting (but being insulting) I do think IDEs like this make sense for code monkeys in large organizations. But for someone whose job involves actually writing the infrastructure of their django project (as opposed to relying on another department), I'm still not seeing it.

Can you elaborate? How do you feel PyCharm removes control? Does it setup your environment in a way which prevents customization?

It doesn't. It doesn't do anything to your project.

It does offer awesome VCS integration features. It does offer a powerful debugger. And it gives you an JavaScript IDE that doesn't suck. VIM just cant handle modern JS code.

PyCharm also gives you PEP8 and JSLint support. And its intelligent autocomplete is awesome and makes programming in dynamically typed languages a breeze.

OP just couldn't be bothered to give the product a chance. While he is smugly juggling dozens of shell instances I let the IDE do the work for me.

Jetbrains is making the best IDE around.

Smug attack accepted, I deserved that :) I tried to address some points related to your reply in my comment above.

It's not that it makes things impossible, it's that it inserts a complex layer between me and the stuff I'm working with. That means the set of possible explanations for something not working correctly is expanded. With pycharm, in addition to the inevitable reasons one always has to consider, I additionally have to consider:

- I used the pycharm UI incorrectly -- I didn't tell it to do what I intended to tell it to do.

- pycharm is not configured for my project correctly

- there is a bug in pycharm

Testing and debugging software is hard enough; it's best to choose a work environment that minimizes the number of possible explanations for what has gone wrong and that means running `manage.py whatever` directly from a shell. I can see that for certain classes of problems one would be confident that the IDE was working correctly, and you could debug in pycharm with perhaps greater power than using pdb in a shell. But if there's a possibility that the problem is infrastructural -- e.g. with your test runner, or the test invocation -- and not actually in the application code, then you'd want to work with python/django directly, not with a complex GUI application. In the projects I work on, that possibility is always there :)

You can use an IDE and still run and test your code from the command line, and this is often a good idea when it's unclear what the IDE is doing. The IDE still serves as a better editor.

You could. But mastering just one of those interfaces is already quite an overhead.

Well, if you plan on using the command line then you don't need to learn to run programs in the IDE. You can just learn the other stuff.

But there's no doubt about it, learning to use an IDE is an investment. It's not needed for "hello world" but pays off when using complicated API's or refactoring a large application. And nearly all the API's we use these days are complicated; languages that don't have large standard libraries aren't used much.

The irony is that people who don't use IDE's spend large amounts of time configuring their text editors. How much of an investment is it to learn vi?

"But I downloaded the free trial and got out of there after about 5 minutes"

Well, at least you could quit it easily. New user of vim would be a perfect random generator at this moment. I don't believe one can judge a tool one didn't use for longer period of time.

That depends on the language. Big Java codebases are very hard to develop without good IDE, because good IDE can make a lot of problems with some language go away. With Java, this is mostly about syntax checking and incremental builds, code generation, packaging and suggestion of classes, methods and data types.

Python doesn't really have problems similar to Java, so Java-style IDE doesn't seem necessary, while the language design makes some of the best features of Java-style IDEs hard to implement (but my last experience with similar IDEs was few years ago, so that might be fixed problem).

Now, the problems with python (concurrency and general slowness) are impossible to fix with IDE, so they might not be necessary. Still, IDEs are _integrated_ and thus allow you to set up development environment quickly and efficiently -- think about what if you moved to different computer, or even to different platform? Your shell scripts might not survive that, but IDE would. And being integrated has other advantages -- yes, any developer can (and should be able to) use git directly from command line. But editor that shows you which lines have changed since last commit, and who edited this part of file and when is useful. You can do that with git from terminal, but just seeing the former in editor, and getting the latter just by moving the mouse to the right spot can be helpful.

Of course, lot of the things IDEs do are about team cooperation, and won't really help single developer.

I first tried PyCharm when I had to do a project for the Boxee platform , it was my first time doing anything in python and it helped greatly. Even back then the autocomplete was great, debugging just worked and for a complete noob it was perfect. Since then I switched to the full blown IntelliJ IDE and never again will I use anything else.

I've used PyCharm constantly for the last few years and its great. A few things about the Django integration annoy me (some valid template constructs are marked as invalid) and the refactoring sometimes causes more headaches than its worth (changing the wrong things). Other than that its great.

For those wondering, us Emacs creatures use Rope + ropemacs + rope-mode to achieve the same thing. Vim has access to the same tooling more or less.

From the article:

> Rope-based completion was always unreliable, slow or both.

I haven't used rope. Is the author wrong about this?

Not in my experience. On Mac OS X in emacs, vim, and sublime text 2 rope based auto complete is pretty poor compared to PyCharm, X Code (5 which I've been using the beta since it's release pretty heavily is really REALLY good at this compared to 4), and Visual Studio.

I've used PyCharm before, IME people that complain about Rope autocompletion aren't adding the virtualenv to their Rope search paths.

As for slowness? only on init. After that, it's as close to instantaneous as it gets.

I am a huge fan of VIM's design (and by extension EVIL http://www.emacswiki.org/emacs/Evil in Emacs, which is what I use most of the time), and I agree that all to most of this is achievable in Emacs.

I really like Jetbrains products though, and when I am on Windows those are my goto tools as I don't have the UNIX user space to leverage alongside Emacs or VIM.

They provide a great environment for those languages that don't have great support outside of commercial IDEs or for people turned off by Emacs/VIM.

My first experience was using IDEA for Java (both VIM and Emacs support for Java is an area where they are weakest somewhat surprisingly) and I was very happy with IDEA, so I tried PyCharm later on when I was on Windows and using Python there.

However, Emacs makes use of Python's REPL much more fluently than what I've experienced in PyCharm where the IDE has no interaction with the REPL outside of user engagement.

PyCharm in comparison seems entirely ignorant that it has a REPL it can exploit and integrating tightly with it would pay dividends.

Coming from Emacs where REPL integrations tend to have at least some sense of intelligence about them this was jarring.

PyCharm's intentions though are also very nice and isn't something I've found in Emacs or VIM to the same extent.

The IDE still has the same trait I've seen in Eclipse, VisualStudio, XCode, and Jetbrains' products though where it makes determining what the project entails into an overly complicated affair though, an area where VIM and Emacs have less red tape to get into.

There seems to be a great deal of improvement in that area for tools to get into where they are smarter without requiring so much user facing bureaucracy up front.

On one hand we have Emacs and VIM that largely pretend there is no such thing as a project and that tools could perform actions on that as a unit.

Then on the other side IDEs want to recognize that a project is an actionable unit and that it is a unit but then engage in 20 questions just to get started on a project and even after that get easily confused when moving files around.

Anyways, as far as IDEs go, Jetbrains' products have been the most enjoyable to use.

I do wish they were full open sourced though so that contributing improvements voluntarily wasn't a comparatively precarious trade off compared to VIM or Emacs or whatever open source tools you use.

Also, I wish IDEAVim was a lot nicer support of VIM's features than what it currently has so that I didn't have to want for some functionality at times.

Both the Emacs and VIM or typical IDEs have a lot of room for improvement in general though, tooling could be a lot nicer and homogenous across languages to the extent possible.

I really wish anyone would run with Bret Victor's idea of closing the feedback loop in programming (http://vimeo.com/36579366) adamantly and also implement Douglas Crockford's idea of scope based coloring everywhere (https://www.youtube.com/watch?v=dkZFtimgAcM), the latter of which I really want in functional languages like Haskell/OCaml.

Those two alone would add significant utility to the available tools.

After seeing Crockford's scope based coloring idea syntax based coloring seems incredibly superfluous even though I use it myself.

It really feels like we are in a tooling stone age with a great deal of retreading and regression in some respects despite having a lot more man-months thrown at the area.

ideaVim is Open Source and contributions are welcome. https://github.com/JetBrains/ideavim

The only major downside I found is its nonnative feel since it's written in Java. Otherwise, it's the best.

Reply on news.ycombinator.com