PyCharm 2023.1 | Hacker News Reader

PyCharm 2023.1

jetbrains.com

64 pointsplatelminto58 comments

> It has been created to reduce visual complexity, provide easy access to essential features, and progressively disclose complex functionality as needed – resulting in a cleaner look and feel.

Please, Jetbrains, and everyone else out there, I beg you, please stop shipping these redesigned UIs that look prettier but are infinitely times less functional and reduce information density by orders of magnitude. Especially for something like an IDE, with a huge base of power users--all this serves is dumbing down software when the vast majority of your users want the exact opposite.

Agree. And this feels all the more useless that they already had a "low-distraction" mode for a while.

They are trying this with Clion and the toolchain/target interface that works well now. They hid all the targets and one needs more clicks to chose a new one because it became an MRU list. The splitting of the two was nice, but give me all my targets so I can get my work done. The two dropdowns didn’t hurt though, it was always two clicks, but now you can more easily see what toolchain is in use.

I don't mind the changes

And that's fine! But why do software vendors feel the need to shove a new design down everyone's throat, even for those who don't want or care for it?

As far as I can tell, there is an option to opt out of the new UI, but I won't bank on it lasting long.

I guess because it is too hard to support two very complex and different UIs

I've fully moved past jetbrains. The program is slower than every other IDE I use. Any time you reboot or change environments there it takes like 3-10 minutes with my tower. I know that seems like a niche reason, but when no other IDE has this issue, and they have similar/better plugins; why bother?

Since the VIM addon of Spyder, I've been hooked. I personally like the data visualizations the best. They are fast and have lots of features. Seems like spyder is underrated in the python world, although VSCode is ofc incredibly dynamic.

Unfortunately this is very true. My machine has 64 gb of ram 3600, and a AMD Ryzen 9 3900X 12-Core Processor. Even inside openbox jetbrains apps run extremely slow. Tried on windows, tried on mac, i endup in the same place. Sadly I will have to give in to using vs code.

I've got two IntelliJ projects and two Pycharm projects open right now (all of them are of significant complexity), on a 7 year old Macbook Pro with 16 GB of RAM, and they're running fine. There's a small UI lag at times, but nothing that would remotely cause me grief.

But I don't use many plugins, maybe that's the difference.

I don't think any other IDE has "better" functionality. A Jetbrains IDE packs a ton of features (I have tried several alternatives but none come close). The only language where VSCode even seriously competes is Typescript (Rider is much better at C#). I used them originally on 4GB laptop and now on 16GB macbook, and I never found it to be too slow. (the indexing part can be slow, but they mitigated it somewhat by allowing you to download pre built indexes).

I have never spent 5 minutes on any index operation in almost any Jetbrains IDE. You might want to check your VMOptions and see if there is anything in there causing it to be extra slow.

If the OS is Windows, I'd suggest anyone struggling with lag make absolutely certain that the project and scratch folders are excluded from Defender real-time scanning. It makes a huge difference.

I used JB software for years and was a big avocate (I am an amateur dev).

Then I started to mix Python, Go, TypeScript, Vue, ... and had to be juggle between editors. Some features were common, some other not.

I forced myself to fully switch to vscode for a week and after initial struggles this is, for me, by far a better ide.

It misses things but heads a mich better configuration. All languages are consistent and can live together.

I am not coming back.

I hope they also worked on removing the many UI bugs from PyCharm remote: laggy scrolling while in the diff view, some editor settings like rulers at 100/120 chars not working properly, some settings panes lagging out until the editor is restarted, etc etc. I need to develop on a remote VM and I’m using VSCode at the moment because it’s remote story is less buggy, but would much rather be using PyCharm.

The remote feature (Jetbrains Gateway) is so buggy that it made me completely stop using PyCharm, since I’m mostly developing remotely now. Whereas the VScode remote feature works beautifully. I also found their Copilot plug-in to be buggy, and that’s also a must have. It’s a shame because, aside from those things, I really like PyCharm. But those things are absolute deal killers for me.

What issues are you facing? Last time I checked, running headless intellij on a server and editing code on it without ssh latency was a breeze.

There a lots of tiny issues: some UI settings like rulers (or whatever PyCharm calls them, vertical guides that tell you when you’re at 100 chars or something) just don’t work, and don’t show up in the main editor (but they show up in the diffs!). Some editor settings, like the main Python settings pane, just doesn’t load its settings page, and requires restarting the editor. Scrolling diffs with the scroll wheel is so janky and laggy to be unusable, but the main editor scrolls fine. Reconnecting after a short disconnect (open and close laptop lid) takes too long. The git client gets itself into a weird state sometimes where it will create the same 5 files no matter which branch I switch to, and the only way I’ve found to reset that is to delete every trace of IntelliJ off the remote and reconnect.

> It has been created to reduce visual complexity, provide easy access to essential features, and progressively disclose complex functionality as needed – resulting in a cleaner look and feel.

I’ll probably try it out in a while, but the only thing I potentially care about of those things is ”easy access to essential features”. If clean look makes things harder to find, then that would be a sign that they don’t know their users.

But I’ll wait to judge until I’ve tried it.

For what it's worth, as I longtime happy Jetbrains user, I like the new look. I did not feel it hindered access to any of the features I commonly used.

As another longtime user I agree. I think the JetBrains suite had always been showing far too much stuff around the editor that you would pretty much never use. The new layout keeps the stuff you actually want, while putting the extra stuff like 1 additional click away.

And honestly, everything's keybound in PyCharm so if you're someone who tries to optimise your editor usage you probably weren't clicking icons anyway.

This is exactly my feeling. I rarely click anything in any JetBrains apps. I have use keyboard shortcuts for every single thing and regularly add new ones if I've had to click on something more than once. It pains me whenever I see people futzing around with the mouse. I regularly try to encourage my direct reports to embrace the keyboard, it is just so so much faster.

Been using Rubymine, their new look is great and all features I use daily are still easily accessible.

Interesting. I heard many good things about Pycharm, but it kind of looks bloated? How does it compare to VS Code (which is quite good (notebook and repl support mostly), but not great, in particular regarding the debugging experience)?

PyCharm has a great debugger. I am a longtime Pycharm user and have used VScode from time to time for python, and it seems like only now VSCode is catching up.

Pycharm is still better though in the general language support department. However I feel that if you were already a VSCode user, VSCode has become good enough. Pycharm like other IntelliJ based IDEs has many other QoL features which I can't find anywhere else. But if you haven't been using them already I doubt they would seem to make a difference.

For me, it comes down to the cohesiveness of the whole thing. VSCode plugins often feel janky.

The VSCode add-on manager also discriminates against users using VSCodium (The open source build of VSCode without Microsoft's proprietary "telemetry"). They simply will not let you install certain add-ons.

For large codebases PyCharm is superior, as VS Code usually chokes in its JavaScript memory usage before PyCharm's Java. You need to load large symbol datasets in the memory and VS Code seem to be struggling with this.

PyCharm autocompletion, autoimport, red underline errors and type hinting tools are also better than in VS Code.

VS Code Jupyter Notebook integration as better. PyCharm tends to do very badly with complex notebooks.

Using both 5+ years.

+ refactoring in PyCharm works

+ much better git support

People always use bloated as an argument against something. Bloated framework, bloated linux distro, bloated ide…

What really is the problem with having all “the plugins installed”/features, nicely integrated, always compatible, reasonably configurable, maintained and with support vs inflating a minimal editor (framework, *) yourself, without all the advantages mentioned earlier.

Yes it may cost some cheap memory, vs costs of fixing plugins yourself.

My advice: Embrace it. Everything just works. Bloated in many cases is a non argument.

Disclaimer: long time bloated fan. Pycharm, django, monoliths. I rather spend time fixing things that matter.

> Everything just works

That's... That's a huge stretch. I've been on an outdated version of pycharm for nearly a year now because they broke support for docker-compose in a pretty huge way. Moreover, I have yet to have a pycharm project where I didn't need to create my own docker override file.

Interesting, i recall doing that in the early days of the docker integration. It is pretty solid now. Also might have been the weird way that project was setup, but i do not remember the specifics.

Also cannot judge it because you gave no examples.

Maybe your project is an outlier?

Jetbrains IDEs are an industry standard, and has a quantified ROI on time saved.

First thing to think about: Pycharm is an IDE, VSCode is an editor. You're going to bloat VSCode to get anywhere near the functionality of Pycharm.

I believe jetbrains products have made me a better developer as it should provide more context and intellisense to give you guidance away from code smells and bad practices, without becoming a crutch (moreso for statically typed languages).

Also, very fond of the keybindings on macos as they mirror chrome, os, and electron applications.

The IntelliJ git interface makes a lot of sense, and makes many helpful operations easy, like “compare what I have now to this particular commit”. The VSCode git interface, even with plugins like GitLens, seems to make these operations hard to get to, and how VSCode manages diffs with the staging area involved is totally bananas.

Aside from that, PyCharm has a slightly better debugging interface but otherwise it’s quite close to VSCode for Python development. Sane version control is a bit aside though.

Don't forget "compare selection to clipboard"

It's the best IDE you can ever use, not affiliated.

The number of little 'intends' that make your life easier is just next level.

If you are using other IDEs of the intelliJ set you can use all the familiar refactory workflows etc.

VS code support for multiple Python environments and dependency handling (be that requirements.txt or pyenv or…) is really quite terrible compared to Pycharm.

I use PyCharm for my job as well as for personal projects, and it handles large codebases with type annotations very well. I would compare it to Visual Studio (not Code) in the sense that it’s a batteries included deal, which means larger initial size but I use maybe two plugins.

Re type annotations, is there some non-default setting or plugin I am overlooking?

As a long time pycharm user who recently switched to vscode, I have found pycharm's understanding of type annotations to be borderline broken.

  def foo(value: Optional[str]) -> None:
      print(value.replace("bar", "baz"))

mypy and vscode both point out this will fail when value is None, but my pycharm seems to think this is perfectly fine.

To be honest I don’t use the type annotations given by the IDE that much, and I also only encounter them in my work code base (pymongo), so I can’t comment on that part. I was mainly commenting just on its ability to handle large code bases.

VS:Code is not bloated yet. With all plugins accumulated for a certain project type it might be more bloated the visual studio memory wise. So the bloatedness deepends on what one is doing with it

A VS Code setup with all the plugins required to make it do all the things I use daily in PyCharm is far more bloated. The debugger (including REPL) in PyCharm is phenomenal, the way Docker and other integrations work is almost seamless, the git GUI is way better (smart merge!)...

Yes, the memory usage is higher, but spending like 50 € on an extra RAM stick to run the program I spend 70 % of my work (and often free) time in seems pretty reasonable.

I think that while it takes forever to boot up from cold, those monolith-style classic IDEs with their centralized caching (and most important, centralized AST caching) outrun (by a lot) those Language Server Protocol based text editors when you're jumping around and editing code.

Going around code is faster. Global search is faster. Autocomplete is faster. Refactoring is faster.

Using the Java Language Server Protocol in VS Code was very painful even for very trivial Java Spring Boot projects.

Granted, their boot and first pass of project analysis is really slow.

That being said I still use VS Code very often (as a cool text editor, not as IDE), and I have no clue how VS Code boots and feels so snappy when most other Electron apps that I use feel like unresponsive slow garbage.

I'm afraid I lost faith in PyCharm etc when the professional version I paid for on the basis of its promise to allow remote development and debugging didn't remotely (ha!) work.

Switched to VSCode and haven't looked back.

I think that IDEs a becoming more useful since our reliance on LLM tooling for code production increases. That said, why isn't there any good alternative to webstorm?

>That said, why isn't there any good alternative to webstorm?

Sadly all the people who could build one are on HN complaining/nitpicking about the various deficiencies of Jetbrains IDEs :)

The remote Jupyter support is very cool. Is there a managed service out there? I think my organization could benefit greatly from common Jupyter infrastructure, but the calculus changes drastically if my tiny team is on the hook for keeping it running.

Maybe Sagemaker Studio Lab.

https://docs.aws.amazon.com/sagemaker/latest/dg/studio-lab.h...

I’ve been using pycharm pretty much daily for a few years, and switched to the new UI a few weeks ago.

I like it, especially when doing dev work with only one monitor. You might hate it, but it’s worth giving it a shot.

Still a knights battle helmet when it comes to looking on text.

Transparent Modal background to the text is were its at in my opinion. That and buttons on the side. One key to switch into the background. One key to switch the modes.

> That and buttons on the side.

They seem to be experimenting with a new-look UI that has buttons on the side.

I just enabled it quickly here, and it's clearly a VS Code clone. :(

Just reverted back to the standard layout, which I'm more used to.

Hopefully they don't try and force this new layout on everyone. Otherwise, people might as well actually just swap to VS Code.

Yeah, right. People will totally switch to a less powerful IDE just because of a small UI change.

The new UI looks a bit like Visual Studio Code, I think?

Correct. If you choose the dark theme it looks very very close to VSCode.

This is an unfortunate "scared pandering" path especially as visual studio has moved over to macos and Linux. Microsoft can afford to put these out VSCode and VS for free.

Will JetBrains IDEs survive VSCode + GPT plugins combo?

You can run copilot in Jetbrains and a variety of other AI plugins as well

VSCode has dozens of ChatGPT and GPT-4 plugins now, not just copilot/tabnine/kite.

For statically typed languages (java,go,c#,kotlin), I find Jetbrains better than VSCode even when VSCode has copilot and Jetbrains doesn't. The thing is, a Jetbrains IDE makes so many things possible and easy, like refactoring complex chunks of code very quickly, then applying it throughout a large codebase. Unless GPT starts doing more than writing small code for functions, Jetbrains will be fine for some time.

Astro support - interesting

Reply on news.ycombinator.com