Part of it feels like it comes from a different development philosophy.

Vscode is a "text editor" or a "code editor". Usually this means that it's fairly lightweight, supports every language under the sun, is highly configurable and extensible, but doesn't have a lot of very in-depth features, and also partially relies on third-party extensions for deeper functionality.

Jetbrains on the other hand works on IDEs built for one specific language explicitly. Consider CLion for C, it's only a couple of years old!

They put a lot of resources into supporting a language and all its relevant workflows. Phpstorm for instance has built-in support for three different standalone code quality checkers, composer (package manager) support, deep language understanding with highlighting, warning, errors, refactorings, generators etc, doc comments, code formatting, support for different testing frameworks, a built-in debugger, etcetcetc...

While that's great, you shouldn't go edit python code in Phpstorm. It supports syntax highlighting and maybe a couple of other small features, but that's it!

In short, code editors usually cast a really wide net with a lot of configurability and extensibility, while (jetbrains) IDEs tend to go really deep on a single language or workflow, with less extensibility, and deep configurability within the supported language itself.

I wonder if you have had the chance to use a Jetbrains IDE with a professional license. Doing so gives you access to more or less the content of all the other "flavors" as plugins (it's basically all IntelliJ underneath).

For example, I've been using PyCharm for both our python backend _and_ our React + Typescript frontend, all in the same project window, with the same features regarding syntax, linting, refactoring, tests, debugging, etc.

I have. IntelliJ ultimate edition still has fewer features for PHP specifically than Phpstorm.

Presumably not because it actually has fewer features, but because "the debugger" now has 150 options instead of like 5.

Also, these super-featured IDEs still won't support languages that Jetbrains doesn't have a specific IDE for. For instance, Delphi. Sure they'll support syntax highlighting somehow, and there might be one plugin.

VSCode probably has 20+ search results if you look up Delphi

As someone who used to develop in Delphi for my day job, but has been mostly out of the loop for the last ~10 years, this really got me curious: do people actually use VSCode for Delphi? I mean, Delphi already comes with an IDE, including a GUI ("Forms") designer - that was its killer feature back in the nineties, that you could slap together a GUI app as quickly as in good ol' Visual Basic, but backed by a compiled language. Maybe the text editor is better in VSCode, but still I imagine it's pretty hard to deliver the same experience as with the "native" Delphi IDE? So I can understand that JetBrains doesn't see a huge market for that (unless they could become the official Delphi IDE, like they did with Android Studio).

I have current Delphi project with heavy GUI. I'd be out of my mind to use VS Code for it. I use VS code for scripting stuff where it more or less shines (JS, Bash scripts etc). Same for C++ - Visual Studio/QT Creator and CLion fill my needs way better than VS Code can ever do.

No clue, I just picked a random not super mainstream language as an example.

I'm sure vscode is terrible for Delphi, but I'm willing to bet that the experience (with whatever third party plugins exist) will be better than any jetbrains product.

And I think JetBrains' strategy is fine in that regard: either do it well or don't do it at all.

Generally, they should come in the next version. Or that was their stance for PyCharm/IntelliJ ultimate.

It also kills performance when you have so many languages configured.

I did not try that myself, but I think that you can switch enabled plugins with a simple text file. So you should be able to write simple BAT files to launch Idea for different sets of plugins if you need to.

Or may be there are better ways to do so. Anyway just enable what you need.

Just 5row money at the problem and configure your machine with more memory. Docker for Mac already eats a ton so I’m not sure there aren’t other good reasons to do so.

It does not for C/C++, you need CLion for that.

You can also use Resharper C/C++ in Visual Studio and Rider C++ for Unreal Engine.

I've been using it for the last 3 years. At first it was slow, and running out of memory (it was in-process in Visual Studio, which is limited to 32-bits), but now that they've moved a lot to out-of-process it's much better!

I don’t know what version you use but Visual Studio 2019 is so full of bugs that it crashes multiple times a day or I simply restart it as some features such as codelens simply stop working and it becomes cumbersome to find references. Im sure they’d get their s__t together in the next version but so far I’m stuck with a crappy IDE. I’ve had a similar VS experience in the past and while it works it’s okay when I can upgrade i am super reluctant to do so. Yes, MS does push half baked versions quite often

And Rust, as the debugger only works for Rust in CLion.

I use PyCharm and WebStorm daily, and CLion for Rust projects at the moment.

Debugging is also available in PyCharm starting with the 2021.1 EAPs:

https://intellij-rust.github.io/2021/03/01/changelog-142.htm...

This has been my experience with JS as well. No difference between Webstorm or IDEA with a few minutes spent on configuration.

It really depends on the language and IDE.

For example I used to just own Idea Ultimate and use the language plugins, but the workflows were always inferior to using the dedicated IDE for that language.

So I now have the full JetBrains suite and use a mix of Rider, CLion, PyCharm Pro, AppCode etc...

Yeah, I basically use IDEA as Rubymine instead of using Rubymine. It's a fantastic polyglot IDE, and for my uses it supports all the latest Ruby + Javascript workflows.

There are some contradicting layout schemes across the languages and for that I'm glad Jetbrains provides the language specific flavors.

There is most certainly a lot baked into the language-specific editors that isn’t in IDEA proper.

That said, the fact that they all share IDEA’s gubbins makes it massively easier to jump between languages and frameworks for small jobs than I ever thought would be possible.

Having a set of tailored environments that also share keybindings and most common features makes for a fantastic (and really under-appreciated) value proposition.

That is incorrect. It is the same code running underneath.

There are differences in default config, and sometimes the independent versions have a faster release tempo, but it's the same language code.

I'd love to be proven wrong, but I don't believe this is correct.

The IDE shell is the same, but in (for example) Rider there are features that are in Rider but not in IDEA.

Likewise RubyMine. I suspect WebStorm and PhpStorm, too.

There just isn’t a C#/.NET plugin for IDEA that replicates the Rider functionality, though. Same with CLion and AppCode. They do ship Ruby and Python and PHP plugins. The JavaScript/web dev stuff is baked into all of their IDEs.

Which means IDEA does not contain all the features of the individual IDEs.

The thing is, I’m confident in saying the plugins don’t replicate 100% of the feature set of PhpStorm or WebStorm either, but I’d defer to someone from JetBrains who has first hand experience.

If you're confident, what features don't they have?

I subscribe to all their products so I can verify this :) I'm not sure why they don't have C# or C plugins but my guess is that it's because there's enough extra work in those IDEs that they want more money for them. Rider contains the ReSharper backend, which is a completely different application from IntelliJ.

Turns out 99% of my work is in something like Java, Python, or JS. Once you include other JVM languages, C++, PHP, and Ruby, IDEA's coverage is huge. They even have C#, Objective C, and Switft offerings, but there's something to be said for staying in those ecosystems.

One thing to note is that you can use IntelliJ and install the official plugins for each language. For example you can bring the WebStorm functionality to IntelliJ, or install the database plugin to get an embedded Datagrip window. (Which is really neat because you can then get SQL syntax highlighting and such based on your actual DB)

Well just note that this doesn't work with all combination of languages. Try installing CLion on webstorm for example.

IntelliJ ultimate is the main IDE. Everything else is a version of IntelliJ that has been configured for a specific language. IntelliJ should, theoretically, be able to behave like any of the sub-IDEs, but the reverse is not true.

Theoretically yes. In practice no. Each IDE has workflows and features tuned to their respective domain.

They're not just simple configuration changes from each other

The simplified setup for modules in the language-specific IDEs alone makes them worth it IMO. It’s great that the plugins in IntelliJ cover basically everything but CLion, AppCode and Rider - but if I’m working on Python, JavaScript, PHP or doing database work I’ll still fire up Pycharm, WebStorm, PHPStorm and DataGrip respectively because there’s less overhead getting my project imported (and DataGrip is more useful as a standalone DBA tool because I open it and all of my connections are right there).

Given the individual license cost difference between IntelliJ Ultimate and the All Products Pack is minimal it’s worth it, especially given it’s cheaper than IntelliJ + CLion separately.

Even just using the correct language terms is helpful. IntelliJ modules contain packages, because that's how Java works, which makes it super confusing when your modules are python packages and its subunit (called package in the UI) is a python module.

Yeah by the time you need two IDEs you might as well just get the suite.

It also worked out well for me because I bought Ultimate on sale, and the suite was discounted for existing owners. So it's really been good savings. Regardless, given the time savings the IDEs give me, they pay themselves off pretty quickly.

As much as that is true, I have a license for all of them and always use a few of them instead of the main IDE: CLion, Goland and Rider being the ones that are really much better for their respective domains because they are so different.

How does the open source IDEA plus php plugin experience compare to phpstorm?

The plugins for alternative languages (PHP, Python) are available only for IntelliJ Ultimate / paid. It's not available in free / open source IntelliJ

So either [1] you buy IntelliJ Ultimate & get Java + other languages (PHP, Python, Ruby, etc except .NET and C++)

or [2] you buy the language specific IDE (cheaper) like PhpStorm, PyCharm, etc

That didn’t used to be the case. You used to be able to add the Python plugin to the free IDEA ide and that would give you java + pycharm - but only the free tier features of pycharm.

However, if you used the paid IDEA, adding the Python plugin gave you full PyCharm capabilities EXCEPT that IDEA was always based on version N of the core IDE platform where PyCharm was based on N+1 version, i.e. the smaller pycharm IDE sometimes had some newer platform features than the IDEA ide which led to occasional differences between IDEA + Python plugin vs PyCharm.

I switched to VSCode last year and let my licence lapse for Intellij so things may have changed.

What i will say, despite having moved to VSCode and being entirely happy - Intellij is the better platform. It’s the difference between 80% and 99% though, and the VSCode 80% is good enough. If i went back to full time dev, i would buy another jetbrains licence.

Intellij allows you to install pretty much most of the features from all the other jetbrains IDEs as plugins. Additionally most of their IDE's have the ability to code in several other languages seperate from the core experience. Almost all of their IDE's can for example integrate with the javascript ecosystem.

I think you're making a mistake here. Essentially behind the scenes there's one jetbrains IDE. This IDE is a single platform that can take plugins and code in any language and be customizable to your hearts content.

ON the surface however Jetbrains doesn't exactly release this IDE to the public. They deliver different configurations and different defaults on TOP of this IDE, then they lock it down a little and ship each one of these profiles under a different name. All these IDE's are basically different bundles of plugins running on the exact same core platform.

That's why CLion is only a couple years old and still really good. It's because all Jetbrains needed to develop was a plugin and shove it into an existing ecosystem.

This is no different then Vscode when you think about it. Both are coding platforms that can be plugged with new features, it's just that jetbrains locks some of this customization down and sells their IDEs with bundles of plugins that offers a better core experience.

What makes Jetbrains better is this focused and higher quality bundle of features that feels cohesive. What makes jetbrains worse is that this central platform they're developing for is bloated. Everything is slow, takes forever and can lock up.

If Jetbrains just did something to speed up the platform then pretty much IMO it beats anything Vscode has to offer.

A faster/lighter JetBrains IDE would beat everything in VSCode... except for price. CLion and WebStorm and PhpStorm cost money, there's no dedicated Rust IDE yet, and you have to pay money for CLion or (IntelliJ Ultimate) (not Community) to debug Rust programs.

There is already a Light Mode version of IntelliJ designed to compete with Sublime Text and maybe VS Code. It's not entirely obvious that it exists and they need to market it way better, but if you run "idea whatever.txt" from the CLI and the IDE isn't already open, you'll open in light mode. It starts nearly instantly because it's not loading all the plugins and project infrastructure.

I didn't know about light mode. I'll definitely try it out.

And still, it's really cheap if you consider the amount of work you have to put into configuring other products like VS Code where you end up with an inferior experience. I think it pays off.

For a professional, jetbrains basically pays for itself within a day of starting to use it (in my opinion). I know a lot of people prefer VS code, but I frankly cannot imagine why.

Well being free is still a benefit. And it is much faster then then any jetbrains IDE.

I prefer jetbrains like you, but some people like their apps to be really snappy.

The only thing where I really perceive VS Code to be faster is startup

The rest might be a tiny bit slower but it more than makes up for it with better UI/UX, code always feels a bit awkward

This really depends. If I open 20 large projects in the same vs code workspace it literally dies.

Doing the same in Jetbrains IDE is painful, but possible.

> Almost all of their IDE's can for example integrate with the javascript ecosystem.

That’s mainly because they don’t have a Javascript specific editor. I cannot even syntax highlight groovy files in PhpStorm, even though I’m paying for the full pack.

But I think that is literally my only gripe with Jetbrains :)

> That’s mainly because they don’t have a Javascript specific editor.

I guess Webstorm doesn't exist in your book?

I'm pretty sure the reason is that you might want to use the same ide for backend and frontend (e.g. GoLand, PyStorm,...)

IntelliJ IDEA Ultimate + PHP (and other) Plugin doesn't work?

Not to their other ides, just for Intellij.

The plugin infrastructure for VS Code along with excellent first party support for JS/TS has helped it grow very fast. But in languages other than TS the mishmash of plugins of varying quality really degrade the experience. The opinionated approach and strong first party support just makes Jet Brains product much cleaner. I use both a lot.

Indeed, I haven't used VS Code a lot but my few experiences with it were largely figuring out which of the available plugins for a particular function was the "right" one, with all of them sitting at various levels of "working". The IntelliJ, Sublime, and heck even TextMate 2 plugin experience is cleaner in that regard.

I use both. IntelliJ being a paid personal subscription. I like both. But VsCode excels in their remote editing capabilities. Sometimes I work on code that will only compile on a Linux and I am on a Mac. It is not just remote debugging - the whole environment including language server works flawlessly via remote while making you feel like local development.

It is good for two good IDEs to survive. I don’t want one of them to win. There is room for two.

I only wish the opensource development model of plugins (for both IntelliJ and VsCode) doesn’t come to bite us one day with a rogue developer inserting malware. The whole review/reputation system should be like Apple App Store

VS Code Remote Containers is another cool feature. You can develop inside any Docker container locally. This could essentially mirror whatever image you have deployed into Kubernetes, GKE, GCS, etc.

Ref: https://code.visualstudio.com/docs/remote/containers

Worth noting that IntelliJ latest beta has this feature as well. You can remote run/debug in remote docker containers and WSL2 VMs.

This right here is what could get me to switch.

I could theoretically host an IDE on a workstation and develop from anywhere with a browser.

Unfortunately it's not ideal yet - remote editor wouldn't let me touch files not owned by session user (even when I could sudo) and similar issues.

I still mostly just SSH onto a workstation for any of my personal work, but every month or two I'll check out the latest batch of self-hosted remote IDEs. My favorite by far (with caveats -- a few of your favorite extensions have licensing issues, and the mobile UI is garbage) is a fork of VS Code designed for doing exactly that. Check out https://github.com/cdr/code-server.

I went this route with code-server[1]. But later decided against it because some shortcuts don't work in the browser. Also installing and managing code-server on those VMs had started becoming a chore.

I am using remote-ssh instead. Hassle-free and works like charm.

Can't comment on sudo issue because I mostly log in using root.

[1]: https://github.com/cdr/code-server [2]: https://marketplace.visualstudio.com/items?itemName=ms-vscod...

I think that sounds about right. I see vs code as a jack-of-all-trades, master-of-none type of tool. if I want to try something in a new language or just edit some text real quick (I find vs code has better than average support for weird text encodings) but keep a familiar ui, I go with vs code. if I'm going to be doing some more in-depth work, I'll spend the time to learn a purpose-built tool. I mostly write c++ for windows, and I find vs code can't really compete with its big brother (bloated as it is) here.

This sums it up for me. For languages with a dedicated Jetbrains IDE (Java, Ruby, Python, etc) Jetbrains will be better experience hands down.

For everything that doesn’t have the premium experience, I find that just using plugins isn’t as effective.

For example, the experience of using IDEA with the Elixir plugin hasn’t been great despite a lot of development. It seems like it constantly loses the proper SDK if I jump between projects.

The VS Code experience has been a lot better for Elixir though. Just works. The moment Jetbrains releases a dedicated Elixir IDE I’d jump for it though.

Why the assumption that a separate editor needs to be released? IntelliJ with language plugins is better.

I agree. Intellij ultimate is the best polyglot work environment I've ever used. The primary project I work on has Java, kotlin, groovy, python, typescript, js, shell scripts, dockerfiles, various configuration files, etc. Intellij Ultimate handles them all equally well as the more specific language flavors in my experience.

Hadn’t been my experience thus far.

Not sure how many devs code in a single language these days. I go back/forth between Go, Dart, and C++ every day, so using one IDE like VSCode (with the familiar features from extensions to shortcuts to snippets) is a big help.

I do have to maintain libraries in several languages, basically every JetBrains IDE has built-in first-class support for JS/TypeScript + all popular Web file formats irrespective of whatever backend language you're developing in.

For C#, F# & VB I use Rider.

For Dart, Java & Kotlin I use Android Studio, but if I need to do a lot of development with Java/Kotlin I'll bounce to IDEA.

For TypeScript/JS npm projects I use VS Code for small changes, but bounce to WebStorm for longer sessions.

For the Swift package I use Xcode for development & VS Code for git, update docs & run publish scripts. Unfortunately ran into issues trying to build my project with AppCode.

For all other languages (used to develop project templates & packages for https://gist.cafe) I'll use VS Code, but that's mainly because I don't have the IDE installed. If I had to spend more than a couple of days working on a language that JetBrains offers a dedicated IDE for I'll most likely be installing & trying that out, before falling back to VS Code (JetBrains All Products Pack + Unified Toolbox Updates makes this effortless & feasible).

Jetbrains provides plugins for Intellij that support almost every other language they have a "dedicated IDE" for. That's what I do and it supports almost every language I throw at it. The exceptions that I know of are Rider and parts of Android Studio

It’s worth noting you can set up shared settings between every Jetbrains IDE which will sync up all of your keybindings, color schemes, etc.

I've never got it to work reliably between different types of IDEs (Android Studio and Intellij for example)

I think the vast majority of devs work in a single language, at least on a day to day basis.

I wish JetBrains looked exactly into that, and deliver one IDE with above (^^^).

I don’t since you end up with either complex configuration to surface language specific tasks. Having well thought out defaults, tools, etc by separating them out into different IDEs allows for ease of use you couldn’t get with one IDE to rule them all approach. Yes, they sell different IDEs that share a large core but I think the incentives are well aligned for sustainable business focused on developer satisfaction.

Nah. Would have to disagree on this front. These should still work. After all each language/runtime is defined by some underlying template (for example in Visual Studio - .vcxproj for C++, .csproj for C# in .NET, etc.). I don't see reason all of this to work under one Umbreall IDE, even if I have to pay more for it - I'd rather pay for it, than the bundle I'm getting now.

if you use intelliJ ultimate edition you have official plusing for all languages for ex: I work on golang, scala, python and JS using intellij ultimate.

I have to look again, but I don't think C++ and Rust were available from there...

There is an Intellij official plugin for Rust. https://plugins.jetbrains.com/plugin/8182-rust

A somewhat radical rephrasing would be that the IDEA products occupy the space that used to be held by Borland IDE or something like Quick Basic whereas VSCode seems more like an Emacs for the javascript age. (which I find surprisingly fitting, considering how according to The good Parts javascript is just a scheme with curlies)

I agree, I'm a long term IntelliJ polyglot, and I watch people in pair programming or video call refactor in VSCode and I feel sorry for them. Stuff goes sideways badly with dynamic languages, worse, they don't have a grip on it.

Simple stuff like code formatting and structure of files isn't well respected by vscoders <I find>.

IntelliJ got a bad wrap I guess because it all started with Java. I'm glad I had a short gig in Java to discover IntelliJ back then. I really think their software, although getting quite complex now, and the plugins can be a little sketch, is the best IDE out there <unless you're a vim nerd who swears by vim and will die on a sword for it>.

The almost perfect Vim support is why I pay for JetBrains’ AppCode over xCode. Second I simply don’t think I’d be able to code both Java and Swift without having a similar workflow between IDEs. To me the development experience makes the difference between loving or hating the work.

Jetbrains IDEs performance is so abysmal I quickly get annoyed and move to something else. Same with XCode.

I find VSCode to be the most feature rich editor whose speed I can tolerate. VSCode is by no means ideal in terms of resource consumptions or startup speed but the community picked up VSCode for the golden path in the languages I code with (rust, node.js, frontend js) and using other lighter editors is a significant downgrade.

Sublime was incredibly promising but it's not enough feature wise for my experience. I'd literally throw money into a native and more performant/lightweight VSCode.

NB: IDEA performance is improved drastically by giving it more memory. Basically every time someone complains about perf issues with IDEA it's because their heap limit is too low. It can be configured via the help menu.

One of the unfortunate (or fortunate?) design decisions in IDEA is that there's an explicit and user configurable tradeoff between performance and memory usage, but the defaults are far too low. And if it's too low only the most very recent versions can detect this and tell you what to do about it.

There are several projects attempting to develop a native smart editor. For Mac users there is Nova (https://nova.app/) and for the Vim crowd there is Onivim (https://onivim.io/).

I have used neither of them but I find them intriguing, especially when I wait for my VSCode cursor to catch up with my typing.

I switched from VSCode to CLion (IDEA variant) and its Rust plugin because... well... it actually works for complex C++ code. VSCode requires a restart every 10 minutes while working with a moderately complex C++ code base with some complex template logic.

Since I switched I've really come to like the polish and completeness of the thing. I have confidence that it will actually work, and it almost always does. It's fatter than VSCode in some ways (especially RAM) but that's what 16G or more of RAM on a laptop is for.

Even with plugins, VsCode feels like a text editor + syntax highlighter for single files. Jetbrains feels like a project-first language introspection tool. It knows how the languages (Python, Typescript, Rust etc) work, how their functions, data structures, modules etc interact.

I agree with you.

JetBrains IDEs are more thorough, kind of Apple like vertical integration while VS Code is more like Windows: hack everything together.

From a experimental standpoint I highly prefer VS Code, since writing add-ons for JetBrain was too complicated for me in an affordable time. VS Code shines here.

I think that this flexibility really is a different beast. For example, workflow optimization is becoming a thing in software development. In my department, I turned VS Code into a somewhat low-code editor for Web development. This could not have been achieved using JetBrains.

Agree, PHPStorm for me is a productivity monster

I agree, I also think sibling comment about vs code being a generic text editor is a fair point.

I’ve tried to move to vs code several times as I like using the “default” (same reason I use Ubuntu) but webstorm is just better IMO.

There are plenty of quirks when you aren't coloring in the lines in Jetbrains, though. Formatting with Rubocop on save in Rubymine is nearly impossible to do successfully in my attempts.

VS Code is also pretty nice for free. I wouldn’t use it professionally if I had Idea. But for home use, free is pretty ok.

in my experience Intellij looks better if you have coded in Inttellij first (especially Java) and then moved to othet tools.

Intellij offers a lot of custom behaviours that IMO programmers start coding the "Intellij way" (let's call it Intellij muscle memory for lack of a better definition) on the other hand going from vi to Emacs to Sublime to VSCode is less of a problem and people tend to honestly judge strength and weaknesses of each one.

For example magit is so good (for me) that until the magit plugin for VSCode came out I kept an instance of Emacs running only to interact with the git repository.

Intellij git integration in comparison, in my opinion, it's barely usable and generally counter intuitive.

BTW the java plugin bundle for VSCode replicates 95% of the features of Intellij, except for some formatting styles and a few of the refactoring facilities that I could not reproduce, I switched from Intellij to VSCode without looking back. There's even a keyboard bindings plugin for VSCode that perfectly maps IJ keyboard shortcuts.

If only the VSCode java ecosystem was refined as it is today 2 years ago when the project I am working on started, I would have never even downloaded Intellij.

If I had an euro for every time I had to "Invalidate cache and restart" on Intellij to make it recognize some trivial change, I would be rich now.

Having said that: they are different products for different targets.

Intellij has a huge advantage in corporate environments where conformity, uniformity and easily replacing team members are paramount, VSCode is an highly customizable code editor that fits a different use case where each member of the team prefers to customize the working experience as much as possible.

> Intellij git integration in comparison, in my opinion, it's barely usable and generally counter intuitive.

Disagree. I use it all the time. It's sooo nice to have the different changelists. Easy to make changes that I don't want to accidentally commit by putting them on a different changelist (like pointing to a different database). And it can be split even in the same file, much more easily to commit parts like this than using git -p.

> BTW the java plugin bundle for VSCode replicates 95% of the features of Intellij,

If you only look at the textual java code, perhaps. But it lacks the awareness of the rest of the java ecosystem that Intellij provides.

I think the git support used to be worse but now it is pretty great imho.

> But it lacks the awareness of the rest of the java ecosystem that Intellij provides.

Can you give me an example of what you mean?

Something Java accidentally did was be impossible to code without an IDE, in part because of its type system. People wrote really good IDEs for it, aided by the type system. At some point, they realized they could use what they learned and adapt the IDE to other languages.

At least most of our java program is written by us. Compared to visual studio (not vs code) where a wizard will generate thousands of lines of config no one dares to touch again or know how to modify.

It wasn’t accidental. JavaBeans were explicitly designed for “wiring up” UIs in IDEs and are the reason the horrible getters/setters are ubiquitous in Java.

It’s also why NetBeans was a part of Java for so long (is it still?)

The main reason I started using IDEs was automatic imports. Funnily enough, when I went from VSCode to GoLand, one of the things I miss is the import management, which is better in VSCode. But for everything else, especially refactoring, GoLand is better.

> Intellij git integration in comparison, in my opinion, it's barely usable and generally counter intuitive.

You're going to have to explain that one to me. I don't know what part of `ctrl+k`, comment, `ctrl+enter` to commit is difficult. Keeps my hands on the keyboard and head in the code. Time to push? `ctrl+shift+k`. Update? `ctrl+t`.

I have yet to find any IDE that performs as well as IntelliJ et al.

> I don't know what part of `ctrl+k`, comment, `ctrl+enter` to commit is difficult.

who said difficult?

training wheels are not difficukt to use, but that's not how biking actually works.

> I have yet to find any IDE that performs as well as IntelliJ et al.

fortunately, there are different kinds of people.

Forgive me, 'unusable'. Hardly training wheels in any case.

I had the exact same feeling arriving into projects using PyCharm: somehow I could feel PyCharm's influence over the code and ignorance of the non-IDEA tools (e.g. makefile/isort/black, which are usually superior/easier to use than the mouse oriented interface of PyCharm). I even use a phrase for the way they are developed: PyCharm oriented development.

VSCode is better at first, unless you need to work with Python 2.7, where it fails completely: there is no good lsp for it (intellisense fails), and working this problem around by downgrading to ctags does not work either.

The best I can say about them is that both has decent multi cursor implementation.

> in my experience Intellij looks better if you have coded in Inttellij first (especially Java) and then moved to othet tools.

I have started with notepad and moved through vi, Eclipse, VSCode and then IntelliJ. Out of these I used Eclipse and IntelliJ for Java and IntelliJ wins hands down when it comes to the quality of the features, atleast for Java.

> Intellij offers a lot of custom behaviours that IMO programmers start coding the "Intellij way" (let's call it Intellij muscle memory for lack of a better definition) on the other hand going from vi to Emacs to Sublime to VSCode is less of a problem and people tend to honestly judge strength and weaknesses of each one.

Since I didn't start with IntelliJ, I didn't have any baggage of muscle memory etc but the ease of refactoring and the quality of autocomplete/suggestions of refactoring takes it beyond an editor to almost a companion. It doesn't nag and you are free to ignore its suggestions but hell those are pretty good suggestions. I use a few keyboard shortcuts like jumping to definition and checking usage so I don't have any keyboard focused attachment to IntelliJ. Infact I use vi keybindings in both VSCode and IntelliJ.

> Intellij git integration in comparison, in my opinion, it's barely usable and generally counter intuitive.

IntelliJ's git integration is definitely not barely useable and not counter intuitive either (I started with command line git and then worked on IntelliJ). The only gripe I have is that occasionally I want to create a branch from a tag and I need to do that from the command line. Everything else works seamlessly.

> If I had an euro for every time I had to "Invalidate cache and restart" on Intellij to make it recognize some trivial change, I would be rich now.

I've had to do invalidate cache and restart about 2 times in last two years so while it is not a great use of my time when I have to do it, its not a big bother considering it is rare for me.

> Intellij has a huge advantage in corporate environments where conformity, uniformity and easily replacing team members are paramount, VSCode is an highly customizable code editor that fits a different use case where each member of the team prefers to customize the working experience as much as possible.

In my team, the average period folks have been with the firm is 3 years so easily replacing people is not a priority (because they are not leaving left, right and center). Also, I'm not even sure if that makes any difference, because its not like we are coding style nazis carrying out IntelliJ dictated formatting (we use Sonarlint for linting and only expect people to code in a manner that is easy to understand and maintain). Almost all team members have used Eclipse / VSCode and atleast for Java, after they used IntelliJ, they haven't gone back to either.

> Almost all team members have used Eclipse / VSCode and atleast for Java, after they used IntelliJ, they haven't gone back to either.

I was also using it because my team was using it and it holds value to share a screen and watch the same thing or when debugging an issue replicating the same exact steps, having different tools can make it harder.

My point is that when you have a stable setup any setup is good if it's good for you, Intellij is better on some things but worse on other that I personally value more

the git integration for example, which works backwards compared to how git works: stage/commit/push

in Intellij I am presented with all the tracked files already staged, the commit message box is already filled with the last one, files are showed as a tree instead of the classic list with paths and I have to look for untracked files that are collapsed by default.

Magit is much simpler and intuitive IMO.

> I've had to do invalidate cache and restart about 2 times in last two years so while it is not a great use of my time when I have to do it, its not a big bother considering it is rare for me.

I wish it was like that for me.

Or probably I am simply doing something wrong but no amount of Google fu helped me to avoid the issue, the only thing that works is pushing the damned "invalidate and restart" button (and sometimes running mvn idea:idea from the command line, but I gather it is obsolete and not actively supported anymore)