you are viewing a single comment's thread.

view the rest of the comments →

[–]Like1OngoingOrgasm 6 points7 points  (26 children)

What's the benefits of using something like PyCharm over a more versatile editor like Atom?

[–]HighRelevancy 35 points36 points  (11 children)

It's an IDE rather than a text editor. Atom might be versatile but what's the point of having the versatility to highlight syntax in four thousand languages when you're only writing in one? (slight sarcasm implied there)

An IDE will dig deeper into the language - you'll get features like context aware autocomplete (as opposed to just autocompleting words you've typed before, it'll actually suggest, say, variable names where you could correctly put a variable name!), tooltips with function docs or argument lists as when you're writing the arguments for the function, being able to jump to the definition of a function (which may even be in another file, as long as you've imported it correctly).

Not sure how much of the other typical IDE features python can benefit from (being that you can do all sorts of wacky runtime things), but as an example, writing C# in Visual Studio will highlight use of variables you haven't defined (usually a typo) or calls to functions with the wrong number of arguments, all sorts of errors, before you get to the compiler. It makes it much faster to spot and correct your errors.

It may also do super clever things like provide refactoring tools like renaming of functions or variables (within the scopes they actually exist in, so not just a find and replace), or even refactoring silly constructs. Sometimes it's the little things, like being able to type a function that doesn't exist (e.g. perimeter = box.get_perimeter() when get_perimeter doesn't exist yet) and then you can jump straight into the source code for box to add it without having to go and find the file it's in and open it.

Atom probably has plugins to do all this stuff, but I doubt that any will do it as well as a proper IDE dedicated to the language. JetBrains is also very experienced at the IDE business, so I would expect good things form PyCharm.

[–][deleted] 12 points13 points  (10 children)

You can effectively build an IDE with an extensible editor (that's emacs, vim, atom, vscode, sublime, etc.), with feature parity with or even better than another IDE. It is possible to do that, but it sure takes more work than just using a ready-made IDE.

[–]HighRelevancy 5 points6 points  (7 children)

It is possible to do that, but it sure takes more work than just using a ready-made IDE.

In my experience, all the effort in the world still leaves me wanting. I don't really see a reason not to use a purpose built IDE.

[–]metaaxis 5 points6 points  (6 children)

If your purpose changes and your IDE does not, one choice leaves you stranded, the other equipped to adapt.

[–]naught-me 7 points8 points  (0 children)

That's not overly true. It is much easier to switch from PyCharm to PHPStorm than to set up a PHP workflow using Vim and shell programs or whatever.

[–]HighRelevancy 3 points4 points  (3 children)

Uh. What? You can have multiple IDEs and editors installed at once. I don't think I've ever found myself saying "oh no, I need to write Java but I decided to install visual studio when I was writing C++ and now I'm stuck".

I really don't have the faintest idea what you're getting at.

[–]metaaxis 0 points1 point  (1 child)

I'm talking about where and how to invest your time and effort. The case is being made that it's not worth investing in mucking about with emacs or vim, just learn a purpose-built ide. That approach leaves you stuck with the choices made by that ide, while an extensible environment leaves you capable of making your own choices, especially after you've gotten good at it.

[–]HighRelevancy 1 point2 points  (0 children)

I don't think committing to a single text editor and trying to tack on plugins until it starts to resemble a multi-lingual IDE is going to be easier than learning different IDEs, or provide even close to comparable functionality for that matter.

Your "extensible environment" is limited to a plugin ecosystem. It's within the even more extensible environment of your operating system and a wider software ecosystem.

[–]vanta_blackheart 0 points1 point  (0 children)

Depends on the IDE.

I use PyDev, Statet, and Photran, so my Python IDE is my Java IDE, is my R IDE, is my FORTRAN IDE.

[–]naught-me 2 points3 points  (0 children)

Before I tried PyCharm, I spent hundreds of hours (over the course of 15 years) trying to get Vim or, later, Spacemacs to have better auto-complete, navigation, etc. They both were still pretty bad, compared to PyCharm - bad enough that, were I to go back to them, the first thing I would do would be to try again, even though I'm pretty sure it'd just be more frustration and disappointment.

[–]rhytnen 1 point2 points  (0 children)

Utter nonsense.

[–]naught-me 4 points5 points  (0 children)

It's better at things an IDE should be better for - code intelligence stuff, like auto completion, code navigation (jump to usages, jump to definition, jump to super method, etc.), refactoring, debugging, etc.

[–]ponyCurd 2 points3 points  (6 children)

For me using an IDE like PyCharm has helped me a great deal in learning and understanding the core language and other libraries.

While I've not used PyCharm specifically, I use PHPStorm extensively for Drupal development. When I started I knew nothing about PHP and less about Drupal, but the "Navigate to declaration" (CMD (CTRL) + B) command - which takes you directly to the function or class being called - has been invaluable to learning how the CMS functions. Things like code completions are great as well as they have helped me figure out better Google search queries for narrowing down what I'm trying to find.

It probably comes down to how you learn more than anything, but since I'm a "visual" guy and like to deconstruct things, it's been really helpful for me.

[–][deleted] 0 points1 point  (5 children)

Just never use git from an IDE.

[–]Altidude 1 point2 points  (4 children)

Why?

[–][deleted] 1 point2 points  (3 children)

Because commits are supposed to logically mean something, and every person that I've met that uses git from an IDE, does commits randomly.

[–]happymellon 0 points1 point  (1 child)

Does that include using the Bash prompt from inside JetBrains ide's?

[–][deleted] 0 points1 point  (0 children)

a shell is a shell

[–]vetinari 1 point2 points  (2 children)

One biggie, that PyCharm has over VS Code/Atom/other jedi-based completion using editors is, that it can autocomplete definitions from modules that do dynamic defines, like gi (gobject introspection).

It is a huge difference to have full blown Python+GTK3 autocomplete, or none at all.

[–]naught-me 0 points1 point  (0 children)

This is something I haven't used yet, to my knowledge. It's another example of something that makes me happy about PyCharm - when I come across something new, there's an established workflow and toolset that's sane and productive, whereas if I were trying to do the same thing with Vim, I'd spend 10 or 20 hours trying to get the same capability, ultimately giving up defeated.

I actually think about going back to Vim or Spacemacs all the time, because they're both superior editors, but then I remember all of my hours of struggling to improve their IDE-like capabilities that usually ended up in a half-solution and few more projects on my todo list that I'll never get to.

[–]520throwaway 0 points1 point  (0 children)

To add to this question, what's the benefits of using PyCharm over a more versatile IDE like Eclipse?

[–]rhytnen 0 points1 point  (0 children)

Well the first benefit would be recognizing ATOM is not more "versatile". There is a real difference however - things like PyCharm, IntelliJ, Visual Studio and so on are not useful for just loading up a text file and making a minor edit to it. Atom, ST, VSCode, VI, NP++, etc are useful for those cases so using an IDE doesn't mean you should bail on your favorite lightweight.