Anyone wondering whether JetBrains IDEs are still worth it - absolute yes from me. VS code is a UX mess by comparison. Webstorm can be tricky to configure with Typescript but once it’s setup my goodness it’s good.
Unfortunately many new developers don't believe in powerful "power" tools anymore. They like to connect many small tools for an inferior experience and they just scoff at bigger tools for being "too complicated".
I use another big tool which is around 20 years old, and that can do everything and a ton more from a single screen at the same speed or faster, with greater integration.
Yet people don't touch it because it's old, complex, looks ugly and its UI is too dense.
Oh, I forgot, it also includes a learning curve, but the same people devote their lives to "rice" their Vim installations for months.
Switching from a large, complex tool that includes a learning curve is expensive. You set a high bar for switching from Eclipse because you are used to it, paid a learning price and are productive in it. And you are right. But that also means that picking such a tool from a multitude of options should be done after careful consideration, which is exactly what using smaller tools provides.
On a somewhat related note, I want my professional software to only provide a (great) speedup of development. I want them to only do what I could do without them (even if it takes a week instead of a minute). This means I can often look at things that fail to work and understand what is failing. This is also helped by new engineers starting with smaller tools and building up to integrated, distributed tools only after knowing how individual elements work and can be connected. Integrating with a (good) big tool is then not a fight as it brings a "wow" moment -- "instead of doing all this by hand I can do it with a few mouseclicks!". My 2c.
[Talking from the perspective of Eclipse, because it's the only IDE I invested my time in]
In this case, it's not. Eclipse put Integrated into IDE, but doesn't subtract transparency in the process. You can see what it does, tweak every step meticulously if you want, and return to defaults with one click, if you prefer.
What this transparency brings is mental flexibility and understanding. Do I want or need to switch? I'm doing the same thing in Vim or KATE of BBEdit in 15 minutes. Maybe I stumble with a couple of shortcuts, but that's not a problem.
The funny thing is I see the compiler command every time I press build, so it's burned in my memory after a day. While I can read valgrind outputs and understand what it says, Eclipse highlights the lines automatically, so I'm faster. While I can gnuplot performance graphs, Eclipse auto-builds them so they are on my desktop after a 10 hour torture run.
In my case, Eclipse enables me to carry a whole toolbox and more in a single folder, yet all the tools it uses and what it does is so transparent that I can switch away on an instant if I don't get my installation with me, or I'm connecting to a server in a datacenter far, far away.
I don't like to be blindsided by my tools. I like blinkenligths in a way, and Eclipse gives me these blinkenlights while being highly automatic.
So while I understand your case, it doesn't apply to Eclipse, at least, because it's not a strangler, but a great enabler and HUD in my experience.
For the time investing part, I don't grind. I get a tool, and start using it, and when it becomes limiting, I start poking it and learn what feature solves that problem at hand. By that way, I learn the tool as I go, and if the tool can't expand to my needs at some point, it fades away from use gracefully. I don't do "stop, drop, roll" thing while changing tools, so I can't paint a timeline about when I picked a tool and dropped another.
I think the big drawback to eclipse is it's a beast to get setup correctly before it performs well. It's built to support everything, but really does a pretty poor job out of the box.
I primarily do Java development. I started with eclipse, fell away because at the time it had pretty awful maven support. Moved over to Netbeans which has pretty good maven and java support, but went through a somewhat "unsupported" period of time and ultimately I moved over to intellij.
Intellij has been a joy to work with in Java code bases because everything just works and the smart features are actually worth it. Intellij can do pretty major refactors that both netbeans and eclipse can't think of. Further, it has really good code improvement suggestions that neither eclipse nor netbeans had. I can also simply check out any code base and tell intellij to open it and be up and running immediately.
A yellow line in intellij is almost certainly something you can right click on and hit "make better" and you'll have better and easier to understand code as a result.
All that said, you sound like you are working with a C/C++ environment. I've not done a lot with Intellijs clion so I couldn't tell you how comparable it is. It wouldn't shock me to learn eclipse is better as intellij is really well built for dynamic languages, maybe not so much for statically compiled languages.
I have never written Java projects so big that used Maven in any capacity. Instead, I'm using it with C/C++ as you guessed and Python. Also XML, JS and other supported parts of the projects I write go through Eclipse if the projects themselves are beyond a certain size.
For C/C++, Eclipse has a "so-called" indexer, which indexes the whole project, does static analysis on the fly, provides great auto-complete and warns you about gotchas. Since it can read the whole project, it has a better view than a C++ LSP, and it works reasonably fast and provides great detail.
Also, Eclipse has "Linux Tools Integration", which is also a boon for C++ development on Linux.
All in all, it helped me to build a materials simulation code without any memory leaks and with great performance insights, so I can't complain. Plus, I love build and launch profiles of that thing.
In my case it is because I am wary of these tools breaking in a way which cannot be fixed, or services being suddenly revoked for external reasons.
Example: now that I'm a solopreneur I use JetBrains DataGrip, and overall I am very pleased with it. But I couldn't have it on my previous two jobs. One of the jobs restricted my work computer to only allow MySQL Workbench (arbitrary Powershell scripts also were allowed, of course), and the other one didn't want to pay for a licence, no matter how much I pleaded.
So before I had to make due with (admittedly) inferior tools because they were free and available as the lowest common denominator in the general workplace.
Being comfortable with the tools affects a large part of my productivity, and I'm more productive with a crappy-but-familiar toolbox than I am with the unknown spaceship.
All of the tools I use are free software and actively maintained and updated, plus they have very nice logging, so I can diagnose what's happening. I only needed to read the logs because I was young and experimenting with the parts I shouldn't and broke the thing on purpose. However, you can just create a copy of the installation directory to back it up completely.
Again, the tool I gave as an example has integrated configuration snapshots, and if something breaks I can revert to a config 2 seconds or 2 years before, including component versions installed at that time.
To be honest, I probably used that feature at most two times in the last 20 years.
Workplace restrictions something off-limits and I can't tell anything about. The people I gave examples are persons I know and they have no such restrictions in place.
> Unfortunately many new developers don't believe in powerful "power" tools anymore.
I have to use IntelliJ due to Kotlin codebase, but I'm still more of a fun of Emacs and I don't like Idea that much. I think IDEs somewhat lack the power that simpler tools have, which is automation.
One thing I miss from IntelliJ is programmability. That's why I still use Emacs on workplace for anything outside of Kotlin (git, grepping, note-taking etc). I even edit code in Emacs from time to time when it's easier to write a Lisp function which will batch edit code than doing keyboard macro.
Another thing I'm missing from IntelliJ is determinism. Everything is asynchronous, so the same combinations of actions can lead to different results, making automatisation painful.
IntelliJ is very programmable, but it can be a bit intimidating because out of the box it assumes that you want to program it by creating plugins. That's very different to the elisp REPL driven approach. LivePlugin bridges the gap by letting you control the IDE from a repl-like console, building up scriptlets that use the same plugin APIs. There are examples for how to do things like add menu items, explore the semantic PSI trees, trigger refactorings or do whatever else you want to do.
- Tracks the mode globally (rather than per editor), and treats mode-switching as an edit operation (so if you accidentally enter a read-only tab in insert mode then you need to switch to another tab, escape, and then go back to get your keybinds back.
- Doesn't bind escape in sidebar dialogs, so trying to exit insert mode in a terminal or commit dialog just defocuses the sidebar instead
- Still applies its other binds, so even falling back to CUA/IntelliJ keybinds doesn't work either!
- Makes no effort to integrate IntelliJ keybinds, all you get for conflicts is "would you like to lose the Vim or IntelliJ functionality that binds this key?"
The difference is stark when you compare it to something like Evil that actually values the user experience. (How's that for an irony?)
Such vim/emacs configuration aficionados are engaging in a hobby, some under the pretense that it'll make them more effective, but many simply for the fun of it.
I feel like I "earned" the right to use big ugly IDE after learning the underlying complexity the hard way, but that's only for one language.
Jumping into a new language with JetBrains is the difference between me spending 2 hours figuring out a codebase and submitting a PR, and me spending 2 hours fucking around trying to fix things.
An IDE generally adds another complexity layer, esp. if you’re not experienced in the language, that’s true. Maybe the reason I didn’t feel that was the gradual ramp up in using the IDE, and starting to play with a language in the terminal first.
I still don’t use an IDE for projects up to a certain size, but after a certain point, being able to also store all the nitty gritty bits about a project (building, profiles, environment, flags, etc.) in a project saves more time than it requires to set them up.
I have moved to VScode after being a paying Jetbrains customer for 6 years.
The Jetbrains IDEs are clunky and slow, they also have plenty of bugs which remain open for years.
They do offer some really powerful refactoring capabilities but I don’t miss them.
Most of my work is in Go, Rust and Typescript.
I was told by Jetbrains representatives that Fleet is now deprioritized internally, which is a pity.
My experience too, I found myself more and more annoyed because I'd run into something, find a years-old ticket that has never been addressed.
I really liked JetBrains tooling in the past, but that and then they also started hitting me with spammy advertising right after I paid for another year, and just couldn't stand it, refunded and cancelled.
Jetbrains has been my go-to recommendation for years.
Unfortunately they are forcing a VSCode UI on everyone and outright lying about their adoption figures (claiming it's off by default and everyone actively chose to use it). The new UI is just as much a broken mess as VSCode. The only way I can get work done is by using my fallback license for the 2023 versions.
It is apparently inconceivable to JetBrains that power users exist and pay good money for power user tools. JetBrains only cares about VSCode script kiddies anymore.
PyCharm is excellent; have not found anything as good for heavy python development
update: emphasis on "heavy". It's good for python projects. For some one-off script I'm more likely to use Zed. pyCharm indexing drives me nuts sometimes. But Zed lacks the features that I use in pyCharm for larger projects.
Their tools are fantastic and worth the $$ and having worked in the profession for 25 years I have little patience for the variety of elitism I often encounter on jobs that goes along the line of: "I just use vim and (by implication) so should you."
JetBrains has always had issues with performance and slightly clunky UI. But in return there's just a pile of amazing refactoring and analysis tools that nobody else offers.
I pay for tools that make my job easier so I can concentrate on delivering. Working without RustRover or CLion is just unpleasant.
I have an emacs + LSP + Rustic etc configuration which does about 80% of what I can do with RustRover. But it's brittle, slow, and takes work to maintain. VSCode suffers from similar problems (not slow, but brittle and ergonomics are worse).
In my first job, I used C, vi, and cscope. In my second, Java and Eclipse. I was an order of magnitude more productive with an IDE. Some of it was the language (though I was actually pretty good at C and rusty at Java), but most of it came from the rapid feedback loop and improved code discoverability.
The UX of Jetbrains IDE is objectively worse, I will take Rider as example (since I use it everyday).
We can start with basic things: the contrast, in default settings in dark mode for both. In theses conditions, Rider contrast is too low for a screen you have to stare all the day, compared to VS Code.
Commonly used item are in sub menus (in vscode they are sorted by most commonly items on top), common shortcuts requires finger gymnastics.
Unless you have more these feel not only extremely weak but extremely subjective. Please avoid trying to phrase your opinions as some fact it’s a tiring trope these days.
The fact that's the contrast is bad isn't something subjective, the font rendering is also shit and reduce the contrast further.
This is an accessibility issue, not some subjective problem.
- “default theme sucks and is bad accessibility”. On its own this is objectively provable of course except when you’re talking about probably the single most commonly changed setting in a coders primary IDE other than maybe font. Calling the app objectively bad because it chose a bad default theme that gets immediately changed is a weak take
- “hidden menu options” this is the subjective one as I called out unless you can provide examples that are universal.
- “bad keyboard shortcuts” is subjective for the most part but even still is a widely changed option and very easy to fix. So calling the app objectively bad for this is also a weak take.
You can select a simple metric, practicality, that will be objective.
The items in VS Code are sorted the chance you have to use it depending of the context. In rider, commonly used items are in submenu (rename hiding in refactoring), less commonly used items are not in the submenus.
For the keyboard shorcuts, again you can argue practicality as an objective metric. The number of keys for a combo and distance between the keys have a big practicality factor, and Jetbrains IDEs loves F-keys (that you can't reach if you hold a keyboard like ergonomists recommends)
Due to the poor font rendering and colors picked in Rider, by default there is a contrast of 4.77 which is just meet the minimum ratio, and for an app you stare all the day at, it's not enough.
From the firefox docs:
> Having good color contrast on your site benefits all your users
I suggest you to read some research on UX so you can understand that a big part of UX is in fact, not subjective.
Like poor contrast cause reading fatigue on all humans, but at varying level.
And that researchers determined a contrast ratio at which a certain percentage of the population can read without problems.
And yes that's a recommendation because they can't force you to do it, so they recommand you to do it.
That's not the question. The question was "you can change the toolbars and shortcuts in JetBrains Rider, no?"
I presume the answer is yes, from what you said. Then it becomes less of an issue, if not an non-issue.
IDEs and code editors are tools which we live with for a long time. Nobody expects their defaults to be unchanged. Otherwise we'd be all using notepad.exe for coding.
Not having the defaults organized by your tastes is not a valid reason for disqualifying a tool out of the gate.
As a counter example, Electron's font rendering is nothing to drool over, from my perspective, and doesn't give an extra point for using it in my case.
An IDE's literal whole selling point is supposedly being a packaged product that you can just pick up and run with, at the price of not being particularly good at any of the things it does (and usually being pretty expensive).
If you still need to customize everything then, well, what did you actually gain over assembling your environment by yourself from actually competent pieces?
I don’t think so, because the IDE doesn’t carry the language tooling with it, but interfaces with the tooling you already have in place.
That said, every IDE is opinionated about workflows, and if you’re open to adapt to that, the defaults makes sense. Otherwise you slowly hammer it to the shape you want.
For me an IDEs greatest selling point or the infinite flexibility it provides.
The OC point was that VS Code UX "is a mess by comparison", and VS Code UX is fully configurable, therefor if you have a problem with VS Code UX, you are complaining about it's defaults settings.
Also Jetbrains IDEs font rendering is simply awful, it doesn't hold the comparison to electron: https://i.imgur.com/u4ZV2Kd.png
I'll quote an earlier comment of mine written a couple of months ago (with links to the issue tracker)[0], because - after many years of being a happy JetBrains user - I sadly can no longer recommend the IDEs (some worse than others, Rider has been okay, though new features often just don't work at all), since the quality of QA has gotten very bad over the last couple of years:
- The autocomplete popup sometimes froze the IDE completely (and killing the process caused minutes of data loss), open for close to a year
- Since two months ago, the Typescript language server fails to start in Vue projects (due to a broken update by the Vue team). A fixed version of WebStorm was released yesterday, in the meantime you were apparently expected to search for the error message, stumble upon the YouTrack page, and apply a workaround
- Performance is abysmal in a larger React MUI project, think 10-15 seconds for feedback on code changes, sometimes errors just stick around for a good minute or more, or even stay until you manually remove all code and put it back
- In some situations WebStorm makes autocomplete suggestions that aren't allowed - think effectively a type T with keys K | L, where Omit<T, K> leads to only suggesting K properties, while removing the Omit makes it suggest both K and L properties
- After updating from 2024.1.X to 2024.2.Y, the window had no buttons for minimizing/maximizing anymore. Now, this was partially caused by my environment, but after I found a workaround it was closed as "Third Party Problem". Still feels like a regression to me, since my environment did not change.
I've mostly stopped updating the IDE, as almost every version brings new regressions in basic editor features. This morning I updated and tried to copy some text. WebStorm showed me a "Copying..." dialogue for more than 30 seconds.
I just tried Cursor, which is based on vscode. And I couldn't stand it, back to JetBrains in a week. Everything, just everything is inferior. Starting with Git plugins, search etc. So yes, learn the ide, just use JetBrains.
I use both VS Code and PyCharm for Python development. I spend the majority of the time in VS Code, but I’ll jump over to PyCharm when I need to do certain refactorings or code navigation (e.g. implement the methods of an abstract base class, find all methods overriding this method, etc), since PyCharm has much better support for that. Microsoft’s approach seems to be “GitHub Copilot can do it”, but while there are some things Copilot can do that PyCharm can’t, there are other things where PyCharm does it much more quickly or reliably than Copilot does
Yes. Absolutely. But with one caveat: JetBrains is clearly lagging behind in AI features and none of the 30+ LLM plugins come close to the killer feature of Codeium's Windsurf (Cascade). For this reason, I've been using both Windsurf and JetBrains in concert which is a pain but works for now.
I have high hopes for "Junie" but fear it's going to be a while before it's ready for prime time.
Agreed. VScode is fine for me as a markdown editor/log viewer/advanced text editor, but when its time to develop, I can't imagine doing without the IDEA Ultimate productivity boost.
One thing I’ve always liked specifically about Jetbrains is that I think their IDE’s use the best visualization for merge conflict resolution. I don’t use Jetbrains much lately due to my current line of work, but I still find myself reaching for the IDE to resolve particularly hairy merge conflicts
Phpstorm ran out of chances I'll give it. Last three tries all went the same way, permanently stuck indexing a project and being an overdeveloped notepad.exe during that; when vscode and phpintelphense could go from cold boot to code assist in seconds on the same project.
Contrary to that, I used Jetbrains IDEs for a decade, or even longer, and recently I have switched to VS Code for my Go and TypeScript work. Sometimes less is more.
