An Honest Comparison of VS Code vs. JetBrains – 5 Points | Hacker News Reader

An Honest Comparison of VS Code vs. JetBrains – 5 Points

blankly.finance

52 pointsthunderbong39 comments

VS Code has come a long way and Is overtaking JetBrains by innovation speed it seems, largely thanks to its rich plugin ecosystem. However, I think it is not quite there yet, largely due to bugs which need to be ironed out.

My observations from daily driving VS Code insiders for half a year:

- stuff breaks and will not work for multiple weeks. this is especially frustrating if you use setups which are considered “exotic” by the devs (like having IPv6 disabled). But that is Insiders for you.

- Remote dev support is a lit better than JetBrains (also it is not in the free editions of JetBrains)

- UI customizability is miles ahead in JetBrains. Just an example: there has been a Ticket open in VS Code to enable moving the outline view to the right side of the UI for years and they say it is not possible because that would need some large refactor.

- JB Debugger is more convenient and easier to use

- Tests and TDD work better out of the box in JB. No finicky manual switching between test output and Debut Console needed like in VS Code.

- VS Code language servers seem to be quicker in building index. I had Pycharm Stuck in a seemingly infinite Index Rebuild multiple times.

- setting up languages and projects in Vs Code can be exhausting and seemingly impossible sometimes (Monorepo…)

- finally: refactor methods are wayyyy ahead in JetBrains products. Since VS Code depends on open source implementations by plug-in maintainers/language servers for these, they tend to vary a lot from language to language.

I could go on and on. But my general feeling is that VS Code is more flexible and has more features at the cost of a worse UX, largely due to its open source nature. JetBrains has a way better UX and is more solid (hello enterprises!) and will eventually catch up to some of the more Revolutionary new VS Code features, but it has a lot slower update cycle.

If you want to get work done and your use case fits into a JB product, use it. If you want one application that can do everything under the sun, get VS Code.

Given how many avoid as much as possible to pay for their tooling, versus what happens in other professional fields, as long as Microsoft keeps shipping VSCode (naturally paid with Azure and Office profits), long term what JetBrains does better won't matter.

If JetBrains was so sure about their customer base they wouldn't have started with a VSCode competitor.

VSCode is clearly a threat as any large firm market dumping is to any company. But JetBrains have seen off free competitors many times before. They matured in an environment where the go-to IDE was Eclipse, also free, also funded by a behemoth.

The thing is that without profits to justify continued investment, executives at firms like Microsoft or IBM eventually get bored of old projects and quietly defund them. JetBrains seems to try to limit the number of free-for-browny-points projects it runs. There are some, most notably Kotlin, but by and large cool but expensive-to-develop new features are things you pay for, e.g. Code With Me.

That gives JB sticking power. Also, Java/JVM has been a good platform for them over the years. The tools they're using are fundamentally well designed and it shows. Classical Visual Studio got knocked out of the race a long time ago, partly because it was written in C++ and failed to make the jump beyond 32 bit Windows. It took forever to go to 64 bit and never made it to non-Windows platforms. The JVM largely abstracted JetBrains from both transitions (albeit in recent times they've had to become co-maintainers of Swing), allowing them to focus on just adding features. And Java's general features and robustness compared to HTML5/JS mean they can ship features and improvements at an incredible pace.

They have historically also dogfooded their own philosophy. IDEA was never rewritten from scratch. It's been continuously upgraded and refactored for 20 years now. I actually worry a bit that they're losing this and becoming more "California" with efforts like Fleet and Space because those look suspiciously like large rewrites rather than incremental refactorings. Space might take off but I have grave doubts about Fleet. The way they developed Kotlin with great Java interop and even an auto-converter tool, and then started using it in IntelliJ development, is a much more JetBrainsy thing to do.

Rider hardly matters to Windows development as it can only do a subset of Windows development is all about.

As for Java, Red-Hat and Microsoft are the ones integrating Eclipse into VSCode.

In what concerns Kotlin, the child's future is pretty much dependent on JetBrains/Google marriage happiness.

Exactly. The fact that Jetbrains challenged and survived many excellent free IDEs proves that they offer real value that many people are willing to pay for. I generally love and prefer free and open source software, but I pay for my own IntelliJ license.

I remember when people kind of looked you strange when you mentioned that you used IntelliJ instead of eclipse for Java development around 2006. The weirdness peaked when they found out you decided to pay for the license out of your own pocket because you were tired to have to explain why eclipse was not good enough for you.

> If you want to get work done and your use case fits into a JB product, use it. If you want one application that can do everything under the sun, get VS Code.

You can buy all JB products for about $200. So while no one app does everything under the sun, they cover most things one way or another.

Except little things like refusing to support JNI development, which Eclipse and Netbeans support out of the box for at least since 2005, and Google has customized Android Studio to support it, given the NDK.

They rather sell InteliJ + Clion licenses for that purpose.

I’ve reported many bugs and created or been routed to vote for a lot of feature requests for Pycharm.

It does feel like jetbrains covers most things, but if you use the tool constantly you start to notice items that have been languishing in their tracker despite long standing community requests.

For example .env support to load environment vars into the IDE’s Run and Console is only handled by plugins.

Not only do these break occasionally, but there is a security problem because these plug-ins often handle secrets.

There’s a solid backing for pulling this into the IDE, but jetbrains hasn’t acted on it.

Another example is providing UI for the git flow style development.

Although many consider this to be a legacy style compared to trunk-based, git flow continues to be in very active use.

The plug-in for this behavior, I believe, for all jetbrains IDEs at this moment is still broken for 2021.3.

> VS Code language servers seem to be quicker in building index.

This largely depends on which language server. VS Code simply refuses to deal with a multi module Go repository I interact with regularly because the language server doesn’t deal well with that and it’s considered “unusual”. Meanwhile IntelliJ has had no issue with it. Heaven help you with VS Code if you’re using Bazel and want things to Just Work with regards to code navigation and so forth.

To be fair Bazel can be sketchy on IntelliJ too, especially with Go (although enabling gomodules fixed a lot of those issues for us).

True - the Bazel plugin often lags significantly behind IntelliJ releases too. That said it's a world apart from the basically broken experience you get in VS Code all the time.

> due to bugs which need to be ironed out > My observations from daily driving VS Code *insiders* [emph. added]

I think at least some of your concerns here about bugs that need to be ironed out is that you are using the Beta channel as a daily driver instead of the Production version.

Yes, that is why I explicitly stated it in my comment that I use insiders.

However, it is not so simple, I only started using insiders because of the aforementioned problems with IPv6 which were not solved in the regular releases for 2+ months, but were already solved in insiders.

It is not so simple as to say all of these bugs wouldn’t happen if I used the stable release branch. It goes both ways. I got some new bugs and I lost some old ones, it is a two-sided sword.

And even the stable releases are too buggy too really rely on it, because a lot of bugs and/or problems (also some I mentioned in my comment) are present for months/years.

> For example, I found myself preferring the JetBrains method with how merge conflicts are resolved as the interfaces laid side to side instead of stacked on top of each other. Not really a determining factor in the end.

The side by side by side merge conflict resolution is so good that even if JetBrains had a product that did only that, I would use it instead of any other for any conflict of significance.

One feature I wish both had is the ability to edit files locally and immediately sync changes remotely in a one way sync. We can do this with various sync utilities but it would be great if the IDE had the option to merely specify an ssh target machine/directory.

I know I’ve done something like this a few years back.

There is now this feature: https://www.jetbrains.com/help/idea/remote-development-start...

edit: I was using the deployment feature. I can’t remember if it was fully automatic or if I had to hit a button to push changes. https://www.jetbrains.com/help/idea/deploying-applications.h...

I use primarily JetBrains IDEs (namely WebStorm and Goland). For Go, it’s unsurpassed. The refactoring are generally smarter than what’s implemented in gopls (which is the language server that VSCode uses). For example, catching the common “assert implements interface” (var _ interfacetype = concretetype) idiom and offering to stub out the missing methods.

They recently launched some remote dev tools (mentioned in the post), but they’re very sensitive to network latency since it’s essentially (afaict) just forwarding the window (the whole IDE has to be installed on the remote server). VSCode far surpasses this for me (essentially just tunneling the file system operations and terminals). Doing Linux specific dev work from my MacBook, VSCode is my go to.

I personally use Goland for Go and Rust. Until a couple of months ago (during the Advent of Code) I was under the assumption that you can use the debugger with Rust only in CLion. Apparently this changed and I can simply pay for Goland (awesome IDE!) instead of Goland + CLion

Debugging Rust on Goland, compared to VSCode is way better. Not only because of the debugger UX, but also because Goland as an IDE for Rust (code completion, types recognition and speed) is miles ahead of VSCode (despite I think they use the same backend).

> JetBrains for non-students isn’t

IntelliJ and PyCharm community editions are free (and open source). They're missing some of the more advanced features, and you're stuck in that one language, but both work well if that's your use case.

And by the time you are reaching the bounds of what the community editions allow you to do (as in what is only available in the ultimate editions) you are probably doing some hefty work that is up to professional standards beyond a tinkerer.

You can also install JetBrains’ official plug-ins and use IntelliJ for any language.

InteliJ's code analysis and refactoring capabilities in its most-supported languages (Java and Kotlin) are miles beyond anything else. There's basically no comparison.

Debugging is generally easy with IDE. I use Emacs for writing code, but when it comes to debugging nothing beats a proper IDE! It just makes things a lot easier.

Although GDB can be scripted using python, but I haven't found a better way to do it by myself. If someone knows that it will be awesome!

It would really be awesome to have some quick-start guide on hacking GDB for making it more usable for intermediate programmers!

JetBrains is great. I fully subscribed with them for years until I switch to vscode. I found myself less dependent on the intelligence features these days. And I use 10+ languages daily and 20+ different languages monthly. Really looking for one for all.

I think you will like JetBrains Fleet. However, it is still in beta and from my experience testing it, I guess it won’t launch before the second half of the year.

For me VS Code/Sublime/etc are all really cool lightweight editors that you can bolt a bunch of things onto to make them a full featured IDE. JetBrains (IDEA for me) comes with all of that out of the box and playing nicely with each other (sometimes plugins don't coexist nicely with something like VS Code/Sublime). Sure I had to install a few more plugins for framework-specific things but my plugin managing is much easier with IDEA vs VS Code.

At the end of the day use what works best for you but for myself I'm happy to pay for IDEA, it's worth every penny.

I tried JetBrains prior to using VSCode for my C++ stuff. JetBrains would run one or more cores at 100% for extended periods of time when building apps containing linux headers + wt headers + boost headers (this wasn't for the compile, this was for the syntax and variable lookup stuff). Each new line I typed seemed to perform a whole new build in the clangd LSP.

Support couldn't seem to support me.

I would probably still be on that IDE if not for that.

VSCode seemed to handle the incremental builds in a much better sane fashion.

I must be missing something - I don't find Rubymine or Pycharm (or Webstorm) to possess anything that IntelliJ doesn't. I use Goland on the side, fine, but the other three seem fully-incorporated into IntelliJ.

What am I missing? I gather that at one point, they might have been ahead, but updates are fast and frequent these days.

(I say this having just shifted projects from both Rubymine and Pycharm into IntelliJ recently, having wondered what I was doing.)

I know with PHPStorm, you can open from projects on a remote server and work remotely. That isn’t in the File menu on IntelliJ. There may be other difference, but that’s the only one I’ve noticed.

Hmm, thanks - going to look

RubyMine is the only IDE I've seen that seems to actually get Rails projects ie. the relationships between models, controllers, partials, .erb files, etc... For single-language completion I've found language servers and Emacs are just as good, but Jetbrains seems to be on another level when it comes to contextual understanding when using a framework like Rails.

Jeremy Liu, thank you for this quality article. And thanks to all the commenters. This is the kind of material I love to see on HN.

I use PyCharm JetBrains for most of my development work, the testing/debugging setup just works too good out of the box.

I just wish PyCharm 100% copied the way search/find works in VS Code. PyCharm search and find is so awkward, and VS Code's is so good.

In what way is it better? Honestly asking because I actually find search in IntelliJ based IDEs much cleaner and easier to use.

I think it is unfair to compare a free product with an expensive one. I have used both by the way, and paid out of my own pocket.

To rate value, anything divided by zero will win, so that gets ignored. But even at a reasonable price VS Code would be fantastic.

Second there is a phenomenon (it probably has a name) where if you pay enough for something you feel a need to promote its value.

Personally I have been happy enough with both.

Why? Time is money, and pretty sure everyone makes more in an hour than the cost of using a Jetbrains product for a month...

I called it a phenomenon to distinguish it from hard logic. I can find pseudoscience to support the idea but, sitting in the park, can't find anything I would rely on. So I guess for now it's just my observation.

I've been using IntelliJ Community (2019.3, to be exact) as my daily driver since it came out, and all the way back to 13.x before that.

Recently, I've been using VS Code because it's used in a class I'm taking, and here's my experience:

0) The lack of polish in VS Code is astounding.

What is all this telemetry bullshit? I had to spend 15 minutes unchecking all the different telemetry boxes, and I'm sure they're still collecting data.

Checkboxes won't check, the UI freezes up all the time and requires a restart, the interface jumps around all the time.

Hints and autocomplete cover up the code and get in the way, and turning them off also takes 15 minutes of unchecking things in the settings, while the checkboxes do not always uncheck on the first click AND jump around when I try to check them.

I don't know how anyone manages to use it day-to-day without tearing all their hair out.

As a counterpoint: I paid for jetbrains and switched back to VSCode as I prefer it for my needs.

Reply on news.ycombinator.com