Reflections on IDEA vs VS Code
archive.vn
archive.vn
Every IDE function appears to be better implemented in JetBrains, whether it's Code Analysis, Refactoring, Navigation, Running/Debugging, Running Tests, adding new files, git integration or contextual functionality like adding package references etc. Everything is just better in JetBrains.
I see VS Code as an ubiquitous smart editor platform with zillions of plugins that's half way between a glorified text editor and an IDE which I use a lot for quick dev changes, quickly searching a folder, front-end UI development, trying out new languages or writing docs. But if I have to start a long dev session I turn to JetBrains which I find far more productive.
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.
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
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.
They're not just simple configuration changes from each other
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.
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.
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 use PyCharm and WebStorm daily, and CLion for Rust projects at the moment.
https://intellij-rust.github.io/2021/03/01/changelog-142.htm...
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
Or may be there are better ways to do so. Anyway just enable what you need.
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.
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...
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.
There are differences in default config, and sometimes the independent versions have a faster release tempo, but it's the same language code.
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.
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.
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.
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.
I prefer jetbrains like you, but some people like their apps to be really snappy.
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
Doing the same in Jetbrains IDE is painful, but possible.
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 :)
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,...)
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.
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).
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.
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.
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)
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.
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.
Can you give me an example of what you mean?
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.
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.
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.
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
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 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 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.
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.
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.
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.
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>.
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.
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.
VSCodes Java, Python, and Golang support is miles behind IntelliJ.
FWIW, on my team at Microsoft where we write a lot of Go, theres a 50/50 split between IntelliJ/GoLand devs and VS Code devs and more people have switched to IntelliJ from VS Code than vice versa.
But that does not carry over to all languages. When working on web apps with a Java backend, I still prefer Idea because it's better for Java and close enough for TypeScript so it comes out ahead over all.
It does. All languages are basically the same. They parse to ASTs that you can manipulate programmatically. If those ASTs are strongly typed, you can safely perform refractors. What makes IntelliJ good is the base framework JetBrains uses, the same one they use in WebStorm, PyCharm, etc. VSCode is that same thing: an adaptable base and I’m sure making it on par for Java if it isn’t already will happened is only a matter of time if they invest.
...no surprise, why would they waste their time on it? They give zero fruitcakes about Java.
Let’s just say, 3rd party plugins (like the redhat Java language support) are.... not of the same quality... as the Microsoft plugins.
On the other hand, we’re talking about Microsoft. If you lived in the 90s, I find it hard to imagine how you can see Microsoft in any other light. I know: different times, different leadership. But still: it seems possible that they’ve got a huge vision for this and want to do the equivalent of Internet Explorer 1 and 2 just to be out in the market, so they can come back and do versions 3 and 4 as their position has become entrenched.
Microsoft doesn't seem to be investing that much, if anything, on languages other than JS/TS; it is delegating all on the OSS community through plugins. And while some of the plugins are really good, in my experience they don't even come close to the native capabilities of Jetbrains products.
Extend: have a plugin system that everyone can contribute to (sounds like eclipse or IntelliJ CE) and even make money off of. Plugins don't have to be free.
Extinguish: make your own plugins with full refactoring support etc. for the languages you see most actively used (everyone uses it for Go and Python now? Make a good enough plugin for that. Nobody uses it for Erlang anyway? Leave it to the community)
The good old MS in action.
I understand that VSCode is part of a grand strategic plan that goes beyond revenue, but I seriously doubt that they'd be willing to internally maintain the absolute truckload of code that would ensue from getting to feature parity with Jetbrains on languages like Java or Python. I'd wager at some point the quality would derail, or someone would pull the plug altogether on such a cost sink.
And that's one of the things I love about Jetbrains products. I'm actually delighted to pay for a product that I use every day for ~8 hours and which I think is extremely well-designed, knowing that the money is going to a company of craftsmen who do that, and only that.
Once you've killed off the competition, a lot of other things don't really matter much any more. From the money perspective, it's a well known strategy to loose money to kill off the competition. It's just about who has the deeper pockets/better stomach for it. Microsoft has traditionally been able to do it and I have no doubts that they would still have the stomach for it. I don't know if their pockets are still as deep as they used to be. Windows (and Office etc.) used to be so dominant and such a cash cow that it enabled a lot of the other strategies, but then again they also had to get Windows to that point first. The landscape looks a bit different nowadays I'd wager, given Apple's and Google's footholds on mobile but then again, I wasn't really old enough back in the day, to really compare from my own experience, what the landscape looked like back then with Apple, Amiga, Atari, SGI, Sun etc. in the mix.
I know about it and don't need a Wikipedia link to enlighten me, thank you.
In my comment I questioned your application of that theory to reality by raising concerns about the cost/benefit analysis from a Microsoft perspective.
I don't think you're accurately scoping the undertaking of getting VSCode to feature-parity with Jetbrains products in Java, Python, etc., nor the potential benefit for Microsoft. My contention is that the gap between Jetbrains and VSCode outside of JavaScript/TypeScript is massive, and that while VSCode is strategically important to Microsoft, they don't have the incentives to even try to extinguish Jetbrains.
But instead of addressing any of the concerns in my original comment, you've just pretty much gone on your own unrelated tirade.
Also, Microsoft ultimately lost the browser wars and many of the similar crusades that they undertook in the 90s and early 2000s, so maybe they've learned a few things along the ways.
We have a difference in opinion it seems on how much money we think Microsoft might be willing to pay for it and other items as well. That's fair enough. How any of that is a tirade is honestly quite nebulous to me but I probably won't be able to change your mind, even if I tell you that it wasn't written by the furiously typing mad dog you probably imagined.
Let's structure it, so you see how I thought I was addressing things:
> truckload of code
I.e. costs a lot of money: "it's a well known strategy to loose money to kill off the competition"
> pull the plug altogether on such a cost sink
Addressed in "Microsoft has traditionally been able to do it and I have no doubts that they would still have the stomach for it"
> feature parity with Jetbrains on languages like Java or Python
The rest that starts with "I don't know if their pockets are still as deep as they used to be." and which also includes "The landscape looks a bit different nowadays I'd wager" is basically me acknowledging that your opinion is different on this than mine and that I can see that potentially their cost/benefit analysis would lean towards your interpretation. They are trying to cover the Java side well enough with the Redhat maintained plugin. If Redhat does a good enough job to take customers away from Jetbrains that plays into Microsoft's strategy without spending a lot of cash on it. Brilliant.
It's an evolving thing too and as you point out in your reply here, MS did loose the browser wars eventually. The market changes all the time through technology breakthroughs for example and people are actively working against EEE tactics too. I for one am glad that MS lost the browser wars and to address one thing that I did not comment on (on purpose because I was concerned with the EEE discussion and not whether or not one or both of us like JetBrains):
> I'm actually delighted to pay for a product that I use every day for ~8 hours
I absolutely agree that IntelliJ is awesome and I don't want to miss it or use anything else. I don't even use vscode for FE code, unlike most of our FE developers. I'm traditionally a BE guy but have no qualms about doing FE work as long as you don't make me do pixel perfect reproductions of designs in CSS :)
That said, giving something away can still make you money or ensure that your competition does not make money either. This comes down to being a large enough entity to support that strategy, which I personally think Microsoft still is.
If I'm Microsoft, I can give away a "base IDE", enlist volunteers and other companies that can even make a buck themselves for quite some time (and spend some money myself) to kill two birds with one stone.
1) I can bind developers to my platform. From the 2019 annual shareholders report: "Beyond GitHub, we are investing to build the most complete toolchain for developers — independent of language, framework, or cloud. Visual Studio and Visual Studio Code are now the most popular code-editing tools in the world. And TypeScript is one of the fastest-growing programming languages."
2) Where I deem necessary use it to kill off competition by driving them out of business. For quite a few companies, the price point of the IDE that their developers use is important i.e. the choice that companies give their employee is: Use vscode or IntelliJ Community Edition (or something else that's free but we're not paying) and it's very hard to explain developer productivity increases to the bean counters.
I suspect MS will be selling VSCode premium, as I mentioned elsewhere on this thread, they are already maintaining closed components.
Meanwhile JB survive the assault, continue to invest in their core product (which have been incrementally evolved for decades and were never rewritten from scratch), and come out the stronger party. They cannot lose interest or make self-destructive decisions because the IDEs are their core revenue stream.
> They cannot lose interest or make self-destructive decisions because the IDEs are their core revenue stream.
But this can be said about Microsoft as well. IDEs are not the core of their revenue stream, but they're near the core, because "developers, developers, developers, developers" is still true. They're a software company, they make operating systems, a cloud platform, and hardware. They need to provide developer tooling. If IDEs aren't their core revenue, they're certainly near the core. If Microsoft hasn't been making money on IDEs lately, they have in the past, they see other people are, and they're certainly going to try and get back to that if they can.
They could try to do a reverse JetBrains and introduce an enhanced for-pay version. Supposedly they're already starting to do that with Python support, it seems. But starting commercial and going free is a lot easier than starting free and going commercial, in terms of user loyalty.
Why would you doubt this? Microsoft is huge compared to JetBrains and revenue opportunities of code editors have been clearly demonstrated since the 80s. Microsoft sold how many billions of dollars of Visual Studio in the 90s? Plus the red flags are already popping up: Microsoft is already not open sourcing Python language tooling [0].
VS Code fails me for anything that isn't JS/TS in the worst way.
It becomes obvious that Jetbrains understands MSFT's own language (TS) better than VSCode the moment you actually need real IDE-like features (such as refactors) to work.
Anecdotally, I know other devs in the same situation. You wouldn't pry WebStorm from their cold dead hands, even with an excellent free offering like VSCode. But I also know some who don't understand why you would pay for WebStorm when VSCode is free, which is reasonable (though if they took WS for a spin, they might change their minds).
Now that I write mostly Python and JS there is no contest at all. I get all the JS/TS goodies, plus absolutely amazing Python features.
Like GP is saying, I don't think JetBrains and VSCode even compete that much. Maybe VSCode will capture a good part of the JS world - which is huge of course - but I think WebStorm will maintain a decent foothold there no matter what, and I think JetBrains will remain very strong in other languages.
It is hard to complain about free tools though. For a Free tool, VSCode, gopls and the Go extensions are great.
If you want more stability, polish and features, pay the $8/month for Goland?
It's still not perfect but my experience doesn't match that.
Android Studio could hang whole mac while "indexing" and often need to "reset caches and restart" while works just fine in VS Code.
Assuming you mean “prettier” rather than prettifier (which a cursory Google did not show up as being a popular thing), the way to do this is to add a prettier config block to a package.json or a .prettierrc file, and then click “yes” when the IDE asks you “use code format based on prettier config”.
I did this not more than 10 minutes before writing this comment, on whatever the latest (shipping) version of IDEA available with whatever version of prettier came from `npm install` this morning - may save you a few mins next time the IDE is screaming at you.
You do have to pay for Goland also.
I'm also using it for Rust, but it's missing CLion's powerful debugger UI - but I think that gdb is good enough :-)
For Ruby, I'm lost without RubyMine--I work on a huge codebase and lean on the superfast search (with default "*.rb, !*test*" files) a lot, usually restricted to a project subfolder.
I'm really glad they renamed Gogland to GoLand--gland is weird (unless maybe I'm doing Monads in Haskell or something).
I do agree with the other comments that the language server is buggy but it works quite well when it works. I may be a bit bias when dealing with tooling since I came from Xcode where workflow breaking bugs was the norm.
I’m [redacted], I don’t mind that being public for a bit to avoid playing tag :)
I was pretty set with my Atom setup but it was clear that it is mostly EoL'd.
(and I'm aware that I still have less features than if I was using a full featured IDE, but I'm still very productive and also happy)
I used to work together with someone who didn‘t catch basic errors in VueJs and Symfony projects in VSCode because (idk) somehow it can‘t do it or some plugin is missing.
On the other side there‘s me with PHPStorm and WebStorm with full project inspection support and detailed analysis about code available at a glance.
Maybe I just don‘t know how to do that in VSCode but VSCode does not feel like an IDE but rather a Notepad++ on steroids to me. Sure, you can do the job in it but that‘s not the reason I pay a lot of money to JetBrains each year.
Edit: typo
With the latter you skip setting up your environment and just start doing your thing. The former is more barebones in this regard. It lets you build your own IDE from plugins and a ton of configuration options.
As someone who likes to have one app for everything code related (from Markdown to the programming languages I use, to config files and to LaTeX) I like to "bring my own furniture" for the unique combination of needs I have.
Thus it makes perfect sense to me that VSCode is regularly underestimated regarding its IDE capabilities. Stock VSCode is indeed just "Notepad++ on steroids". You have to invest some time to build it up into a fully fledged IDE.
My opinion: JetBrains IDEs beat every single other IDE/editor hands down (Visual Studio -- not Code -- comes close). The level of integration and polish is unmatched. I use PyCharm on a daily basis at work and the level of productivity I get out if it is far beyond what I get from any other IDE/editor. I've been developing a hobby kernel recently using C, and initially used VSCode; it was OK. Then I thought I'd give JetBrains CLion a try and I never looked back. I happily paid for license and it's been a well spent investment.
I tried VS Code a couple of years ago for a few months for some scripting languages, it really is not bad, however JB IDEs are better for Java, Python, Ruby,.. even for frontend development - support for Angular and React is great.
I bought the "all products pack" for individuals - it something like 15 bucks per month - for me it would be silly not to use it.
(I have heard complaints that the JetBrains IDEs are much slower on Macs, which also corresponds with my limited experience of using their IDEs on a Mac.)
I'm not super exploratory, because it always seems that I have a project due in two weeks, but given that I have pickd up two of the BEAM languages, but am always lagging on learning Ruby and Haskell. These days - I'm starting to wonder about the utility of learning another language, other than re-learning Smalltalk out of nostalgia.
What do you think Visual Studio is lacking the most compared to JetBrains?
There's also something I can't express about productivity when I'm using a JetBrains IDE. I remember over a decade ago when I added ReSharper as a plugin to VS and all of a sudden I felt the IDE come to life, with a level of assists I haven't seen in VS proper. Of course VS has caught up now, but ReSharper was way ahead of it in those days.
It's also clear that MS is focusing their efforts with VS on cloud integration (VS Online, Azure, etc), rather than sweating the little details that make you even more productive day-to-day. That's probably why they let VS Code eat the bottom of the market, knowing that MS shops will still pay for MSDN subscriptions.
I don't think they keep ahead simply by hard work and sheer luck. Once you look under the hood at Intellij it's clear that they have significant architectural advantages.
While VS Code is a text editor that uses LSPs to provide refactoring and navigation, Intellij is a refactoring engine with a good text editor on the front. Under the hood Intellij is a structured editor operating on abstract syntax trees. ("psi nodes" in Jetbrain's parlance.)
The hard part of creating an LSP is providing things like refactoring and navigation support, and these are exactly the things that IntelliJ provides for its language plugins. To achieve a given level of refactoring and navigation support an LSP developer needs to expend significantly more effort than a jetbrains plugin developer.
From my vantage point Jetbains doesn't seem to be staying ahead by hard work and luck as much as by an intelligent architecture and design that allows them to produce high-level, high-value features with less effort.
[ It's worth looking at IntelliJ's plugin SDK. https://plugins.jetbrains.com/docs/intellij/psi.html ]
IntelliJ runs its language plugins in-process, using object oriented APIs. VS Code runs language plugins out-of-process with an RPC protocol to the backend.
The latter has some advantages if you want to re-use the language's "native" compiler, assuming there is one. However, this isn't quite as useful as it sounds. Compilers parse text into ASTs and do transformations on them, yes, but, they are not IDEs and the needs of an interactive "presentation compiler" are very different to the needs of a batch-oriented normal compiler. The OP's article overlooks this: it just blithely assumes that building an IDE on top of the regular compiler is always better than writing a dedicated IDE support from scratch. The truth is more nuanced.
Meanwhile, the costs of going out-of-process with RPC are enormous. Beyond the obvious performance, bandwidth, memory overhead and latency problems, the Language Server Protocol spec is 100 pages long and still growing. Despite being a protocol and thus theoretically language neutral, in reality it's a JS/TypeScript API. In fact the protocol is so much a JavaScript API that there's no direct way to represent it in a conventionally typed language: for example the Response.result field is totally dynamically typed and can be anything at all.
Worse, because LSP is just a protocol, there's no platform to help you implement it. IntelliJ platform is full of classes you can compose, subclass or use to simplify the task of writing plugins. VSCode is not like that.
My ultimate goal for quite sometime now was to pack all my development dependencies inside containers or cloud-init files to keep my host bare-bone and have reproducible/shareable setups anywhere anytime. Before I was an Emacs fan. I tried multiple combination of Emacs, Tramp and containers but it failed: there always was a package that didn't played well and kept looking for stuff at the wrong location. After a while, I was fed up to make low-level fixes in random packages. I also tried weird setup with Nix for the same exact bad result.
So I took my nerd pride away and tried VS Code with containers and ssh: - https://code.visualstudio.com/docs/remote/containers - https://code.visualstudio.com/docs/remote/ssh
It just worked. The experience was flawless. In a matter of second, it blew the competition away like nothing. Nowadays, I cannot live happier: I clone the repo i need to work. It comes with a development Dockerfile. VS Code starts the container and everything is there for working. If I need a beefier host, I spin up a cloud VM with cloud-init and 5 minute later the setup is ready without any manual intervention. Any extension I tried in marketplace worked.
In my opinion, the Emacs/Vim communities clearly missed a golden opportunity for a more larger adoption.
All I wanted was my code to run anywhere, and my local machine to be the IDE.
mutagen.io ended up being my answer. After learning how it worked, I got it set up and it works really well. I'm mostly doing PHP development these days, and have a LAMP stack running as docker containers on a server.
The sync is nearly instant (99% of the time), the rare conflicts are easily resolved, and of course debugging still works.
The only thing I'm missing is collaborative editing, which I still have to jump over to VS Code to do. I haven't tried out two people using `mutagen sync` on the same instance of code, but that could be a really interesting solution if it works.
An editor agnostic solution to collaborative/pair coding would be really fantastic.
As for the conflicts, I chose the option of one way sync, with everything being overwritten by what's on my local machine if there's a conflict. Works like a charm, since the remote machine will only ever produce build artifacts and run them, which I don't need to sync back to my machine.
They just copy their init.el/vimrc to the server, Emacs/Vim users have been able to do this (coding on remote environments without all the kludges) since forever ;) and personally, I find it superior to vscoce's remote plugin since your editor and tools sit on the same machine.
For GUI editors, I agree that vscode's remote development extension is a killer feature and nothing can't match it today.
Unfortunately this doesn't work well if your connection has a high latency though, which I think is what VScode does really well.
Asking mainly because I think this is cool, but the whole setup (lots of random binaries in the server) is not so different to an AppImage of emacs+xpra (if you could do tha) and the times I tried, the thing was _very_ picky about connection losses/timeouts...
Yes, I did try this and although I don't particularly need remote editing, the fact that it took me less than 2 minutes to setup a remote editor with auto-complete and other IDE features was pretty amazing.
I run my editor on my desktop, and expect to be able to work on whatever remote server I need to.
I've been working on an LSP implementation lately, and I have to say so far the reality falls short of the promise. I feel like what LSP should be is a clear, simple interface for implementing IDE-like features for any language, but my experience is that it is incredibly arcane and difficult to use.
The main issue is the documentation. It has a high-level intro about what LSP is, which is basically marketing, and then it has some sort-of details about (maybe) all the interfaces supported by LSP. But I was sorely lacking that "middle" documentation about how to practically get set up and do things. I had to piece a lot of things together through blog posts, and reverse engineering mature LSP implementations like rust-analyzer. And the documentation you do have of the individual interfaces is kind of weird. Like LSP is a JSON-RPC protocol, but documentation of the objects involved is all C# code, which is never really explained. And many of the concepts, like what a 'code lens' is, what properties it has, and how it would appear in an editor are never explained, so you just have to look up VSCode documentation to figure out what any of this means.
I feel like LSP is sold as a general framework for IDE-independence, but working with it feels a lot more like you've just given access to some of the internal API's in VSCode via JSON-RPC, and other editors have just adapted to this.
LSP is a great concept, but I can imagine if you really approached this problem from scratch, you could probably reach a much better, more sensible result.
As far as I know, the LSP specification only accepts PRs once there is a reference implementation. So you can literally just run VS Code with verbose logging turned on for the reference language server and inspect the communications.
I did my learning by literally following the VS Code guide (the reference implementation) https://code.visualstudio.com/api/language-extensions/progra... and implementing each feature one by one.
You simply return an object following the interface and features magically work. It's wonderful. I added the "Outline" feature in VS Code, and the similar feature to show all symbols in a file in vim in about 2 hours.
> And many of the concepts, like what a 'code lens' is, what properties it has, and how it would appear in an editor are never explained=
Well, no, because they're not specified. How vim displays a code lens might be very different to how VS code does.
“You have to run VSCode to reach a working understanding” seems like a pretty far cry from the stated goal of the project of decoupling the language features from the code editor to me
Well that and use utf-8 string indexing (which is easier for every other language than javascript): https://github.com/microsoft/language-server-protocol/issues...
As for the language server protocol, nothing stops IDEA from doing the same. But while technically cool, it really doesn't matter as long as my programming language of choice works. I don't care how it works. In my anecdotal example, the community made Elm plugin for IDEA was even for a long time miles ahead of the one for VSC.
Rust-lang has an official dual-licensed MIT/Apache language server protocol implementation (RLS) under active development. In my view it’s currently a better experience than the custom IntelliJ one.
Instead of collaborating though I see IntelliJ continuing on the path of their custom implementation. Every week RLS gives an update on their progress and so does IntelliJ on their rust plugin, but it just seems like so much duplicates effort.
>>>>>>>>>>>>>>>>>>>
Aleksey Kladov: The limitations here are not specific to the Rust language, but a general for command line vs IDE compiler.
The main thing is that the command line (or batch) compiler is primarily optimized for throughput (compiling N thousands lines of code per second), while an IDE compiler is optimized for latency (showing correct completion variants in M milliseconds after user typed new fragment of code). As usual with throughput vs latency, these two goals require pretty different optimizations (and even high-level architectures). In general, it's hard to retrofit low latency requirement on a compiler which was developed solely with big throughput in mind.
Another thing is difference in handling invalid code. A traditional compiler front-end is usually organized as a progression of phases, where each phase takes an unstructured input, checks the input for validity, and, if it is indeed valid, adds more structure on top. Specifically, an error in an early phase (like parsing) usually means that the latter phase (like type checking) is not run for this bit of code at all. In other words, "correct code" is a happy case, and everything else can be treated as an error condition. In contrast, in IDE code is always broken, because the user constantly modifies it. As soon as the code is valid, the job of IDE ends and the job of the batch compiler begins. So, an IDE-oriented compiler should accommodate an incomplete and broken code, and provide IDE features, like completion, for such code.
I haven't checked in a while, but RLS was sub-par for a long time (feature- and latencywise). Tight integration has its benefits if you can afford it (and apparently they can). So I guess as soon as they can get the same properties from RLS as from their own implementation they'd switch. But if it meant having to rewrite a lot of stuff that suddenly also becomes available to competitors that seems like a dumb move.
Not to mention, JetBrains typically are at the forefront of IDE support for a language, they start working on it before there are any open source tools around to base work off of. Even with mature languages like C#, the JetBrains C# language backend predates Rosslyn by a good decade I think.
Meh. I don't think that's his main point. The two advantages of vscode he points out are:
- browsers, and by extension Electron, are the best funded cross-platform GUI
- vscode offloads language support to compilers (or other third-party tools) via LSP (Language Server Protocol)
Electron apps are... slow craps. But it seems to be a problem of implementation, as vscode is slick and fast. In my own anecdotic experience, faster than IDEA.
As for LSP, you don't care how it works, since it works now. But will it support as many languages as vscode in the future?
Sure, that's speculation, but he gives a sound argument: it offloads the burden of maintaining the language integration to the community at large (or even to the language team itself). By creating a LSP server, you add support for vscode, vim, emacs, or even... Intellij. Hard to pass.
LSP support on Intellij is a community plugin, far from first-class experience. And if it does become first-class, why then would people choose it over vscode? If both are LSP based, vscode is faster, free, and extensible in the most widely used language.
And here's something less speculative, editor usage from stackoverflow surveys:
- 2017[0] -> vscode 24.0% intellij 23%
- 2018[1] -> vscode 34.9% intellij 24.9%
- 2019[2] -> vscode 50.7% intellij 25.4%
Disclaimer: I don't think LSP is great, yet. Most of the servers are still rough around the edges, but as an emacs user, I have big hopes for them.
[0] https://insights.stackoverflow.com/survey/2017#technology-_-...
[1] https://insights.stackoverflow.com/survey/2018#development-e...
[2] https://insights.stackoverflow.com/survey/2019#development-e...
Regardless, I find it remarkable that IntelliJ hasn't lost an inch of ground (it's even made modest gains) despite VSCode's explosion.
We have had licenses for WebStorm, PyCharm and IntelliJ Ultimate depending on what the Dev in question was doing in his job. So some of that market share/use is hidden.
While I get the point of LSP, as I wrote in another comment an IDE is much more than understanding the AST of the language and providing autocomplete.
I don't get your point about usage. What is it supposed to show? Even though VsCode is growing fast, JetBrains products are also growing and thus has a merit to them?
That's my take, anyways. I'm biased as I personally wouldn't use Intellij if not for the community that made Emacs mode plugins for it. I also tend to costumize more than your average programmer.
But tooling becomes broader and more complex year after year (too complex, maybe), so I don't see in the futur any company being self sustained on that front.
Obviously the author cares about it. It’s basically an article from a personal blog, what makes you think that the author should write for your own use instead of theirs?
They are sharing their thoughts on the topic, and that’s it.
And at a philosophical level, I would imagine that having those IDE features in VS Code at Jetbrains' level of polish would be viewed as beneficial to everyone involved.
The issue is that on one hand you have an entire salaried dev organization whose sole purpose is to create the best IDE possible, and on the other you have a scattered array of open source devs who only work on the polish as much as they have free time. LSP simply came too late to the party. Everything we like about IntelliJ is now both battle-tested from thousands of man-hours of development and also impractical to architect as a separate language server. The more people that use a hypothetical JetBrains-developed language server, the less editor market share they retain.
Another hypothesis I have is that since some language servers are supported officially by the people who develop the language itself, their time becomes split between working on the language and maintaining the LSP support. Any extra time spent on one separate project takes away from the other.
This whole argument that VS code takes over seems to be assuming the Language Server Protocol and Electron is a vastly superior ecosystem. I haven't seen any evidence of this being true. It's probably an improvement over the older Visual Studio ecosystem, though.
Sure seems like this argument is just another version of, "Well, it's Java, so it's enterprise/corporate/boring".
They're both open source ecosystems, and that's great. And I'd rather work with the JetBrains or VS Code ecosystems, then say, Eclipse, even though all of them are open source. (I haven't met many Android devs yearning for the Eclipse-based Android development environment.)
Edit: to clarify that open source commment
I have no idea how you would morph (say) IntelliJ's Java support to use a LSP without basically throwing everything away and starting over.
Caveat: I never worked at Jetbrains, but I did work for two years supporting Android Studio and IntelliJ at Google, which involved a lot of work in its internals.
I just haven't any evidence that the LSP is creating a disruption, which is what the article is asserting.
Right now, it seems like you still have Microsoft as the main driver of the VS Code ecosystem with a few other contributors, and JetBrains really drives a lot of its ecosystem, with a few contributors. Not really seeing much of a difference, and, it doesn't seem like the products or business of JetBrains is significantly challenged by VS Code.
I mean, I haven't heard anything like Google deciding that VS Code will replace Android Studio, right? If the LSP was a true disruptor, I'd think that after a few years, that would be true. I'm sure eventually there will be more and better support for Android development in VS Code, but that probably won't displace Android Studio much.
Or, just maybe, their products are excellent.
This piece is interesting but is is not more than an opinion piece. There is very little in there that actually compares the two products. Feature-wise or how the developer experience is.
It would be interesting to read an objective comparison. Does any site/magazine review developer products?
For the way I work, it fits very well.
- I write nearly exclusively a mixture of CPP and Typescript. Particularly in projects which mix these languages (and for Typescript as a whole), I have not found anything better. - I use the remote SSH feature heavily. I have a bottom of the range MacBook Pro but I use a reserved t3a.xlarge instance in AWS for all my development. It’s blazingly fast and I know that if my laptop was to explode I could be working again in 5 minutes (which is important to me being self employed) - Any software that I ship to clients I ship with a container configuration. Even if they do not use VSCode themselves, if they have a problem they can spin up my exact development environment and run tests, step through debug etc. - GitHub settings sync seems quite useful although I have not needed to use it yet.
However, VSCode weak points:
— Terraform support is awful. Hashicorp seem to have completely broken the related plugins since they took over maintenance of them.
- The CPP debugging experience is not as rich as full Visual Studio (which is fair enough). I occasionally miss things like the memory window.
- Java/Groovy support is poor.
Overall, 10/10 happy VSCode user.
LSP needs to make 2 major improvements in order to to get wider adoption:
- Improve package/runtime support detection (Go modules, npm, virtualenvs, etc). IntelliJ shines here.
- Create one bundled cross-language LSP container or something that all the editors out there can use. Currently its a mess to configure and run all the language servers and what not. This leads to a broken half-assed end-user experience.
Once #2 happens, I think the whole editor ecosystem will feel a lot better for all the editors. Everyone is poorly reinventing the wheel right now.
I’ve always been able to add the VSC plugin for a language and everything just works. With JetBrains it felt like the first thing I was gonna have to do on every project on every one of my computers was set up a bunch of custom scripts to do really basic stuff.
To be clear, I really am questioning what I missed, not the parent. Everyone here says Jetbrains is more convenient and I felt like my first task was always 3 hours of setting it up.
Sounds like something went wrong. These both get auto configured for me. I even get correct completion suggestions to disable the rules inline or at the file level for both eslint and pep8. The only thing I’ve had difficulty with is Prettier but that was improved recently. Email is in the bio if you need any help :)
But this may be a recent improvement, I only work on Python sporadically. My next wish for IDEA's Python plugin is Poetry support.
The second thing you're asking about sounds more like a unified LSP client which is totally possible. It would actually be pretty easy. VSCode could actually improve this a lot since language clients are mostly boilerplate.
All that said I think you're undervaluing what LSP/DAP actually gets you. It's a language agnostic API for PL tools, which includes compilers and virtual machines. All you need to be able to do is parse JSON and you can begin writing a reactive compiler that integrates into any code editor.
Not having read the article, I think the main difference is that IDEA as a traditional IDE is a monolith, while VSCode interestingly and somewhat unexpectedly integrates a lot of different tools. With LSP, the VSCode team created something quite interesting. And the most interesting aspect is that an LSP server can be accessed from many other editors. I personally have grown to like VSCode. While I previously switched between eclipse and vim, I now use mostly VSCode, RStudio (which I still prefer for R code due to some details), and VIM, mostly for maintaining todo lists and my markdown wiki.
https://www.jetbrains.com/research/python-developers-survey-...
https://www.jetbrains.com/research/python-developers-survey-...
https://www.jetbrains.com/lp/python-developers-survey-2019/#...
https://www.jetbrains.com/lp/python-developers-survey-2020/#...
My view is that if “a real IDE” (I use quotes as this is subjective and said in a bit of a tongue-in-cheek manner) gives you even 3% performance boost, it’s well worth paying 100 euro per year especially if you are making tens of thousands using it.
Overall though this “IDEA vs VS Code” situation is interesting because it reveals something about cultural situation in the developers’ community.
People in this thread mentioned brilliant factors among those IDE/editors, but the 2 cents I want to add is their difference is related to the way they work, or how people work on them.
VSCode: LSP reflects the mentality of VSCode - it's extensible, it's working but it usually doesn't offer first-class experiences. It usually aims to serve the intersection or the common part of languages first, then the specific language.
The idea is very akin to Emacs, in which the community tries to find the abstraction of functionality, and then people can work on different implementations at the same time - there's Helm for completion, and Flycheck for checking in the first place, then there's a whole bunch of implementations. The good is it solves the m*n problem, but the bad is the experience is not good as tailored for specific languages. Actually, one specific struggle in the Emacs community right now is choosing between LSP and language-specific plugins.
Intellij: It is on the other side of the spectrum. It's polished, feels pragmatic for major languages they're targeting. Unlike LSP and VSCode, It was aimed to be the best Java IDE, and it did it. Now you can see the inheritance panel for a lot of languages that don't even really care about inheritance.
So IMO it's like Conway's law. The key difference between VSCode and Intellij is because of the way they work - VSCode was built on community, and Microsoft is more like a facilitator. While IntelliJ is driven by a single company, and the plugins and communities are supplement features.
https://youtrack.jetbrains.com/issue/IDEA-226455#focus=Comme...
It never worked, not even close and I ended up dumping it and returning to VS Code because the remote stuff (particularly to linux VMs and containers) was a deal-breaker.
Real missed opportunity I thought, it had been a long-standing bug when I looked into it, and very very oversold as functionality present in the professional version.
I've been using Kotlin for about a year now at work. I feel that "IDEA has good Kotlin support" isn't quite the right way to say it. It's become clear to me that the language is explicitly designed to be read and written in IDEA. Receivers (changing `this` per-scope) and `it` (to a lesser degree) are really poor syntax features to read in plaintext. But IDEA automatically adds the plaintext for you so you don't notice.
Genius business move by JetBrains. Get some corporations hooked on some sugar on top of Java, and now they have to pay that fat license forever.
This is a direction jetbrains has been going in for a while. Have a look at the failed https://www.jetbrains.com/mps/
The syntax features I mention only make any sense period within IDEA. But it's just a syntax feature. The value-add is very low! But it's pervasive in Kotlin. That creates the lock-in. In fact, pumping IDEA's seeming value is those features' biggest impact on the average Kotlin developer.
The majority of the valuable code I've written in my life has been Haskell. I do just use emacs, but I heavily use ghci (free and flexible) to aid my understanding.
But most of that Haskell was conceived while I was doing the dishes. So far, my Kotlin has been too tbh.
So IDEA isn't solving the actual critical path of software problem solving. Kotlin and IDEA are sugar for the masses. Nothing more. And I'm pretty sure they know what they're doing when they aren't drunk on their kool-aid.
I think whether you care strongly about syntax is just personal preference. For example, I prefer Elixir to Erlang, TypeScript to JavaScript, and Kotlin to Java even though they could be/are implemented by transforming source code to source code.
On receiver scopes specifically, they make simple DSLs very easy to implement. Arguably needing a DSl is a symptom of design flaws, but Android has a lot of those so receiver scopes makes Android programming a lot nicer.
Edit: I would call this more than syntactic sugar:
interface MyScope {
fun frob()
}
fun foobar(content: MyScope.() -> Unit) {
let scope = MyScopeImpl()
scope.apply(content)
scope.getResultInternal()
}
fun user() {
foobar {
frob()
}
}You can look at my profile and various papers we've published about why code on laptops is both hard technically and draw your own conclusions beyond that.
As an aside, I also use IntelliJ on my own projects for Rust. The Rust LSP is getting there, but nothing beats IntelliJ Rust yet, and that's been my experience across the suite. JetBrains tackles the hardest 20% of the problems (like partial compilation and indexing) and executes extremely well.
i had to do this for a while. Genuinely awful experience over the citrix thing and best possible connection situation.
> As an aside, I also use IntelliJ on my own projects for Rust. The Rust LSP is getting there, but nothing beats IntelliJ Rust yet,
Thanks for saying this. I'm trying to pivot to using rust for a greenfield project. Just gave up on the emacs rust set up as it was tremendously frustrating to use
It's not quite good enough on my bandwidth to make me switch from VSCode for remote work, but it's pretty close. And the day it is, I will be thrilled to abandon VSCode's horrible Go plugins.
In my experience, IDEA is just better in the things it does well and just worse in the things it doesn't. Without spending days searching for extensions and configurations, Jetbrains' products beat Code every time when it comes to Java and the related ecosystem. When it comes to C/C++, Clion is one of the best IDEs there are, and VS code can only get close through extensions and a buttload of JSON.
For frontend, both suck equally as much, but that's just because modern development has turned into a Javascript mess and frontend developers seem to make it their personal mission to change up and replace the entire ecosystem every five years. No IDE can keep up with such an ecosystem without becoming janky and unpredictable.
The language server feature of Code makes it excellent for languages that weren't originally included in the product. For example, Clion has Rust support, but that support comes nowhere near what VS Code can do with the Rust Analyzer addon. Other languages have similar problems with Jetbrains' products; the language server for Code makes it integrate with other languages so well that the two barely even compete.
But, for most of the work I do, the advantages of VS Code seem irrelevant to me. If you develop in a quirky or brand new language, use WSL2 (because you can't or won't use normal Linux) or if you're writing C# code on and for Windows, then it makes sense to use Code, but I just don't see a lot of people with these problems.
The biggest advantage of VS Code I can see is that through its addons, it gets to become fully-featured for free. You might argue that it's open source as well, but as far as I know there's still functionality that Microsoft has hidden away (C# debugging) in open source builds due to licensing issues. In my opinion the pricing on Jetbrains' tools is pretty good; the tools have increased my productivity enough that I'm more than willing to invest in these tools.
Yeah, the owner of those archive.* websites blocks CloudFlare DNS because of some hate-boner for CloudFlare [1]. Really unfortunate, honestly.
The only feature I miss is the local history. It is nice to be able to aggressively hash out code to solve a complicated problem and revert to the state 1 minute, 5 minutes, or 20 minutes ago or at least look at the diff.
When I juggle between vim, sublime, VS Code and PHPStorm/IDEA. I tend to come back to IDEA for any project bigger than a few files since the after the indexing the refactor, code analysis, search and auto import functionality is so reliable that I just love the ease of use. I still have the free education license and a company license so I am not sure whether I’d pay for JetBrains out of my own pocket but difference in the tooling is night and day, it’s much more robust and quicker to get stuff done than VS Code in my experience
I read somewhere that Jetbrains is valued a billion dollars these days. With zero investor funding. This is a very very serious business with smart leadership.
The idea vs. code is something i don't buy. Each has its use cases. Idea has great tools for android development, it's just tightly geared towards that, which is especially good for someone that is not a main android developer and need to those extra wheels. While vscode is my go to editor for everything else, including java ee.
It can be a remote workstation you'd otherwise have to RDP into it. Sometimes RDP is annoying due to network conditions. Via vscode this works great, even at the worse case scenarios of connection drops. Mind you, it's not just source code editing, but debugging, local server management during iterative development. Experience is just like if it was local. Can have multiple projects (directories) opened at the time via a single vscode instance, or multiple instances of vscode running different projects (or modules of the same project) all connected to the same ssh target.
It can be a local container filled with tons of prerequisites/deps, like application server runtimes, support files, all that stuff that i don't necessary want (or need) to pollute my host just because of that one thing right now i will be working on. I just destroy that container when i don't need it, or do anything with it without fear of consequences on the main host. Another case would be a container that perfectly mimics final production environment with all its config.
It's a real shock when I occasionally try an IntelliJ product and it just swallows up my entire project repo and injects lots of magic.
There's absolutely pros and cons to both. And I don't see them as competing for the same class of editor.
I guess it's kind of IDE vs. Text editor. Though Code certainly looks more like an IDE every month.
Don’t get more wrong; look at Teams, it clearly works to offer a low/zero cost inferior product that is integrated into existing products, so fair call.
...but all that technical stuff? Oh come on; the jetbrains products are better, at basically everything; the only reason more people dont use them is that you have to actually pay for them.
Sure, vscode starts more quickly on a low end machine when you have no plugins installed, but the quality of plugins varies wildly and so does the memory use / speed of vscode when you have them installed.
...and the tools it offers for most languages is simply... inferior; there simply no other way to describe the support for Java, kotlin, go, rust, python, c#.
So... you know, in some ways it does feel like a disruption going on, but not because of technical reasons; Microsoft is just playing the “we have lots of money” card.
Golang or IntelliJ with the Go plugin just work. I have been trying to use Code instead of IDEA for 3 years and it is just not worth it. VSCode startup also is not as fast anymore, so that USP is gone as well.
Debugging features are not even comparable, the difference is day and night.
I tried fixing it again and again but never in my whole journey has there been a moment where everything just works, just as Goland did since it became stable.
It is cheaper to use IDEA Ultimate instead of wasting a few minutes every day fighting with my IDE.
There were multiple instances where i practiced a live coding session for some talk or other a day before and after arriving to the venue Code language support just broke for some reason or other. This happened like 50% of the time. One time if destroyed a lot of the session because it just automatically did nonsensical imports during my live coding!
My switch away from WebStorm was with the rise of compile-to-js languages. I asked myself, do I get more from a new language than a fully fledged IDE with JS-only support? And I choose to go Sublime and then VSCode.
In a fast moving industry there is simply no way I'm going to wait for an IDE vendor to implement everything I want to use.
I don't think that was the main goal. The main goal was giving a standardised protocol for implementing language support in IDEs, so instead of needing n * m implementations for n IDEs and m languages, only m implementations are required. The idea that you could use the language's compiler to implement this was only a bonus (and it's not a very good one in practise: the requirements on parsing and analysing code as it's being edited are very different from when compiling. That's the core reason for rust-analyser taking over from RLS. Without the LSP concept you could just as well build the compiler as a library into whatever plugin architechture you had).
Edit: corrected autocorrect
Needing to buy thirdparty addons to get basic refactoring tools? Because for a very long time that was the VS experience, it was incredibly bare-bones compared to the equivalent Java IDEs.
However the end user doesn't really care about the beauty of the Eclipse meta meta model and think more about why it takes so long to start or why it uses to much memory compared to notepad++.
Also while Vscode is written in typescript/javascript, it uses V8 for the javascript VM which is very fast.
However the slowness of Java on the desktop is a bit overblown by people's past experience I think .... improvements to garbage collection and hotspot optimisation, and elimination of applets have certainly made a big difference to the type of stalls that used to make people say these things.
For example why iOS is so fast? It renders everything in separate process. (This is why Flutter will always be a garbage by reimplementing this in main thread).
I bet it just too much and too old to rewrite to new shiny things.
I still had it installed for quick edits until I found out about Panic's Nova and then uninstalled it and paid for that - the look and feel, and responsiveness of a native application just can't be beat.
However, there is a third way. Both developer tools and compilers can be seen as special cases of a much simpler and more general pattern known as a graph database [3, 4, 5].
[1]: https://en.wikipedia.org/wiki/Don%27t_repeat_yourself
[2]: https://en.wikipedia.org/wiki/Unix_philosophy
[3]: https://www.youtube.com/watch?v=WxyyJyB_Ssc
However, for me VScode is always open, and I frequently open files with VScode from the terminal
code filenameOf course for single one off files I prefer to open in sublime because of how much faster it is.
Personally I switch between Sublime Text 4 and Intellji depending on the task, VSCode in my opinion isn't outstanding in either performance, polish or features
Maybe Emac 28's speed increase will change the landscape a bit
VS code has been relegated to a text editor with my work changing from mostly JS to mostly C++, and `code X` or opening up a JSON file is just slow enough for a little internal groan to come out.
Certainly not XCode levels of groan, but slow enough to move me anyways.
I honestly really started to enjoy developing again. Intellij let's me focus on the problems I'm trying to solve. It does a ton to help remove the boilerplate of programming. The things that I really use it most for:
- 1. quick fixes. Automatically adds imports and cleans up code with a key command
- 2. reformatting. I just reflexively reformat everything as I go
- 3. show parameters. Cmd P shows me what I need to call functions
- 4. find usages. Jumping through code is so fast and easy
- 5. syntax highlighting. So many options. But the ones I use most are showing issues as I type, and clicking on a variable and it highlights its usages
But I also bought the pro license for myself and happily renew every year. A lot of the features and upgrades I don't even use - they are for languages that other people use. But I am happy to support the product and get features that I do use.
And so, it baffles me even more that AWS weren't in the conversation to acquire GitHub (or if they were, that they failed to acquire them). Seems like a huge miss to me.
> Meanwhile, JetBrains seems to be staying afloat mostly thanks to hard work and sheer luck.
Setting aside their colossal IDE efforts for a minute, Kotlin and the ecosystem JetBrain's building alone shows their level of competence. Truly amazing to put in so much effort while also making the business work. I mean, in a world of F/OSS languages, frameworks, and IDEs this is no mean feat.
Maybe Gitlab?
I guess its a case of sunk investment, but having got to the point of understanding top to bottom how Eclipse works I find that it still beats everything else in terms of presenting me with a completely comprehensive framework for developing at a high level of complexity across multiple languages and environments. Every time I move to another tool I find them better on the surface but missing these deeper features that enable dealing with super complex infrastructure across many projects in many languages.
examples?
I have projects where pieces are written in PHP, python, Java, Groovy and Javascript and these can all be open at once and do things like, set breakpoints in each step of a flow that executes across them all and follow a process end to end to inspect where it is going wrong.
It may well be this is somehow all possible in IntelliJ but the times I have tried it out I couldn't work out how to do anything as sophisticated as what I routinely do in Eclipse. It could barely highlight the errors in one project correctly without launching Gradle, let alone propagate that downstream to all the dependencies.
"What bothers me about JetBrains is the fact that they seem to be playing along. Judging by the talks on their recent conference, IDEA goes more elephantine, more corporate, more complex. (...) In this regard I will mention two announcements: the CodeWithMe technology and a lightweight "IDEA viewer" product. CodeWithMe allows one IDEA instance to run another instance remotely to allow for collaborative work. Even the color scheme and the shortcuts are provided by the master instance, if I understood that correctly. That is very Java and very corporate, no doubt. The IDEA viewer is another step in the same direction: let the IDE run somewhere else, maybe on a server, and let people use a lightweight client "on a laptop in a cafe". I seriously doubt it will work well in an average cafe though. Their WiFi tends to be unreliable. Given this degree of dependence of the client machine, spotty WiFi will cause a developer to smash his laptop against the coffee machine."
Talk about underming your own case.
CodeWithMe is what VS Code calls "Live Share" and "IDEA viewer" is what VS Code calls "Visual Studio Code Remote Development" (the SSH part), and has been available since forever in Emacs too.
I've been using this to develop in CLion running on a beefy remote Linux server from my Mac. Overall it works quite well, with just a few teething issues.
Then vscode came along. Again it's great but not polished. Mishmash of plug-ins that may be supported and may do what you want.
To be fair. Intellij needs to refactor their ui. It is not great. By default ugly. And material ui is not officially supported and buggy.
The reality is yes they go for corporate because idk why but developers refuse to pay for an ide license. By hell developers earn a ton thry could afford one.
Not to mention, Pycharm, PHPStorm, GoLand, Clion,Webstorm etc all have consistent UI and shortcuts. You learn one and it's quick to pick other ones.
Yes I still use vim for console coding sometimes, but Jetbrains is where I got most of my productivity these days.
- Test runner
- visual diff tool (gitlens isn't quite good enough)
I've been thinking about what I'd miss from VSCode if I switched back and I cant' really come up with anything other than I really love https://shadesofpurple.pro/.
So why did I switch? Basically everybody is using VSCode on screencasts, at work, etc. for TypeScript and JavaScript and I wanted to see what the fuss was about. It's not better, and I don't really understand why it's popularity.
Btw I am pretty impressed with Quick fix and autocomplete functionality for VS code. It's IMHO pretty great for text editor.
- The refactoring keyboard shortcuts and facilities (moving functions from one file to another, UX for renaming, etc.)
- I found code introspection and autocomplete to be more accurate
- I perceived WebStorm to run better on my machine. The initial load time was longer, but after that the latency of different actions seemed better (again, this was just my perception, on my machine).
- Preferred how many things came installed by default on WS vs having to install plugins on VSCode.
- The Live Templates feature was better than the equivalent code snippets feature.
- The command palette felt more intuitive, I could find things that occurred to me much easier than in VSCode's equivalent.
- The git UX which you mention
Those are a few things that come to mind. VSCode may have significantly improved in these dimensions over time - I wouldn't know because I only use for writing markdown and sometimes to compare my working code base with another code base in a second window.
CLion (the C/C++ variant of the JetBrains IDE family) introduced built-in support for the clangd language server in 2018. It's not perfect (https://youtrack.jetbrains.com/issues?q=clangd), but they improve the integration with every release. I leave it turned on by default now.
They'll either go out of business or get bought out by another corporate conglomerate and their products released for free.
I have only one wish for JetBrains IDE - can we have one singular one with everything in it, not CLion for C++, and then Dart working on most, but Flutter only in some, or Java, or C#, etc.
I'm not surprised the set of plugins is different for each use case. I don't need a Java IDE with CMake plugins, so I don't care if latest CMake plugin conflicts with the Maven plugin (as an example). I'm not _sure_ this is the motivation for per-language products, but I strongly suspect it is.
I need something that I can sit down, install some libraries on, config a bit within, and then it works to some extent that I can start coding and with one click it can compile and run. I also need intellisense out of box for a better coding experience. Debugging experience should also be pleasant without installing anything. Of course it's a bonus point if there is a plugin system and I can potentially write my own.
I tried Vim and realized that:
- It will take many months to reach the same comfort of an IDE out of box. - I'm reaching 40 and don't have many months to live, so wasting any for anything not in my target list should be a sin. - I probably won't code professionally for my life so it's OK not to learn a lot of things (e.g. I only Git with myself) - If somehow coding becomes my profession I should be able to use the same IDE for work as well. - My coding skill is too low to make any advertised productivity increase of the Vim/Emacs people looks insignificant comparing to the time I nheed to debug some trivial errors.
Thus I dropped any learning towards Vim/Emacs/VSCode. However if I want to pick up one of them it's going to be Emacs because I really like its note taking facilities.
what about Intellij with Rust plugin? Install plugin, start coding. Done.
And I can't imagine doing Java in anything else than Intellij (have tried Eclipse at some point)
In general, for Java and Python, Intellij is much more polished and functional.
The debate seems similar to some language comparison like JavaScript vs Go. There is a place for each - IDE and a Code Editor, Interpreted and Compiled - and for every problem - big corporate project, small open source repo you should just use the appropriate tool.
And even their poster child language, Typescript, is handled by the code editor in a manner that's borderline unusable. If you ever used WebStorm the inability of VS Code to autocomplete with types defined in the same project is mind boggling.
All this said I still reach for it a lot, until I have to stare at a red file with an error on a line that's no longer there until you restart the whole thing and question my sanity.
that's unheard :o
The story of IDEA vs VS Code is a story of low-end disruption, straight from the textbook. There is an emergent competitior that is not yet feature-rich but it is not elephantine yet and its technology has an unique advantage. The key technology here is probably the Language Server Protocol; it offloads programming language related smarts directly to the compiler (typically), thus relieving the IDE from supporting a hundred programming languages with all their warts and twists. As the compiler is the ultimate authority on the matters of language, that seems like a wise move: reusing instead of reimplementing. The other technology is Electron and, by extension, a browser engine based GUI. Given how much money was put into browsers, that is probably the most mature multiplatform GUI framework in existence.
That situation may catch the IDEA family between a rock and a hard place: it has to outdo compilers on one side and browser engines on the other side. Specifically, in their primary line of business. Which may easily become an unwinnable bet.
So far it looked like textbook low-end disruption, except for one thing: the disruptor is an old fat incumbent while the disrupted party is a (relatively) young emergent competitor. That is the funny part. Clearly, the MS leadership has read the book.
What bothers me about JetBrains is the fact that they seem to be playing along. Judging by the talks on their recent conference, IDEA goes more elephantine, more corporate, more complex. That is easy to understand: a corporate user pays a lot. But, that is the classic low-end disrupted trajectory that leads to the very same corner where IBM DB2 sits. They will retain some deep pocketed customers, but all the interesting things will be happening somewhere else.
In this regard I will mention two announcements: the CodeWithMe technology and a lightweight "IDEA viewer" product. CodeWithMe allows one IDEA instance to run another instance remotely to allow for collaborative work. Even the color scheme and the shortcuts are provided by the master instance, if I understood that correctly. That is very Java and very corporate, no doubt. The IDEA viewer is another step in the same direction: let the IDE run somewhere else, maybe on a server, and let people use a lightweight client "on a laptop in a cafe". I seriously doubt it will work well in an average cafe though. Their WiFi tends to be unreliable. Given this degree of dependence of the client machine, spotty WiFi will cause a developer to smash his laptop against the coffee machine. Then, the developer will have to pay for both. I experienced similar issues with JetBrains YouTrack in the past: it was an awesome issue tracker, unless you use a poor connection or the server is too far away. Then, it was unnerving. So I assume, that will be stress-free on a wired connection only. Whether the developer is using a laptop or a workstation is of secondary importance then: it is wired. Still, that feature fits some corporate behavior patterns, so it may entrench IDEA better in that environment.
In addition to the rock and the hard place, IDEA seems to be caught in one more aspect. GitHub is now a MS property, so in the future VS Code is expected to be more and more integrated into GitHub. That pretty much catches all the young and hip audience in a MS owned behavior loop. Which certainly shows some very competent strategic planning. Meanwhile, JetBrains seems to be staying afloat mostly thanks to hard work and sheer luck.
Intellij has had a technology similar to LSP (and much more complete) a decade before it's "invention" and do leverage compiler APIs. Which btw allow intellij to support LSP (apparently) https://plugins.jetbrains.com/plugin/10209-lsp-support
The only point here is: Vscode has better and earlier support for niche technologies This does not at all outweight the tremendous gap between vscode support for non-niche technologies versus the excellence of intellij support of non-niche technologies, it's two different worlds comparing them is proof of pure ignorance.
The point on code with Me is nonsensical, vscode (and atom before through teletype) supported real time pair programming before, jetbrains is here playing catch-up (for once)
However the point on Electron enabling better rendering performance is actually true, skia is just the fastest 2D renderer to exists and it's time for people to understand that objectively on this aspect native gui toolkits are obscolete. This is why JetBrains has made skia bindings for Java and develop jetpack compose for desktop which Wil enable them to reuse the chromium rendering engine (skia) for Intellij IDEs while allowing their frontend to be in jvm languages (which are multiple time faster than js) However I believe that skia alone isn't enough and a lot of engineering effort must be made to match the chromium rendering performance (cf the various flutter performance issues(yes Ionic has faster rendering))
One must understand that adding more features does not equal making intellij slower, given enough engineering resources. Actually intellij IDEs are quite fast nowadays and it improve regularly.
Regarding the github.com argument for Microsoft: It's simple, intellij has perfect support for github, you can create pull request from the IDE and the only remaining improvements to make should not make a huge difference.
I want what you're having.
I've been actually trying DataGrip these past weeks and even though I only used it lightly and I'm on a pretty decent computer, it's terribly sluggish. Is there a magic option to make it run faster?
You can increase the available ram to intellij in the settings (under the help section if I remember correctly) My old thinkpad was really slow with Idea because my RAM would easily overflow and therefore spam swap usage. The secret sauce is to go for 16GB of ram, any developer deserve it.
Also if you feel adventurous, by going to the EAP release channel you will get optimization earlier (at the cost of some rare additional bugs) Also always be up to date by using the jetbrains Toolbox and checking download update automatically.
If you turn mitigation=off on your Linux you will get better perf in general at the price of enabling an extremely hard and slow security threat.
They better invest A LOT MORE into solving slow startup and performance issues that are plaguing their IDEs since the beginning
Time to ditch Java on the desktop, or invest in a native AOT compiler / or use GraalVM
I'm curious what situations people are finding JetBrains' speed to be impacting usability.
I never understood why people use the terminals built into their IDE. Can you explain the use case for this? Genuine question.
I do certain stuff via the command line and other stuff via the IDE. But switching between windows and just using the native tool for its own job seems the most natural to me. Is there some sort of awesome integration or something that I'm missing out on?
Is this windowing support somehow superior to using regular windowing and shortcuts? I ask because I personally find that getting used to a new set of shortcuts takes considerable time and creates frustration when you mix em up. I switched to IntelliJ from eclipse and wanted to learn IntelliJ native shortcuts instead of using eclipse settings. There's something to be said for everyone to 'speak the same language' when interacting and helping each other.
Anyhow back to windowing, I personally like to just have whatever application I use to be open full screen (minus any menu bars, docks etc). and having the same set of shortcuts to interact with any window (CMD-TAB or CMD-~ works the same on all of them - substitute CTRL-TAB for Windows) is awesome. Similarly I know some people use a tiling window manager and I would gather that it would even be beneficial if each internal window in IntelliJ could be detached and arranged by that window manager (sort of like Photoshop/Gimp does on Mac) using its own shortcuts.
An example in frustration for me is the debugger in Chrome. The times I've closed the Chrome tab because I wanted to close the open file (which looks like a tab to me) with CMD+TAB is staggering ;)
Caveat: I might be biased by seeing people awkwardly click around to find the right internal window and then the terminal or other tool is way too small to be useful if you ask me.
Another 'integration' into IDEs that I don't understand is the source control. They also in many cases rename functions which makes for awkward conversations. Though they seem to learn e.g. people have an easier time now to find the function in IntelliJ if I ask the to show me the 'git blame' as it's called "Annotate with git blame" now. Whether a current employer gives me Windows, Linux or Mac OS, I work on Java and have IntelliJ or do whatever else, using command line git and gitk and Kdiff3 will always look and behave the same.
And, so far I've never found a source control integration that I really like more than using command line git or, on specific occasions, standalone git GUI clients.
IDEA is fast once it starts up. It's not supposed to be used as Notepad (or Vim).
Curious how often you start your IDE? For me it's at most once every few days.
But then, I use Eclipse which has amazing multi-project support so there is nearly never a need to restart to switch contexts - its just choosing a different working set ...
are people in this website not supposed to be programmers? or it's too late to expect programs to be fast again?
I think this is key - WHO knew that you could build out a billion dollar business from developer tools.
FWIW Eclipse and NetBeans also broke in other places in my code base too (all related to generics), so maybe just Java developers have no idea how those weird parts of the spec surrounding generics, type inference, and capture conversion work.
I tried VS Code to analyze some Go code and it just downloaded a bunch of ghetto stuff from random people's githubs and ran their build scripts or whatever. It broke of course and I gave up as I was new to Go and didn't want to dig into "why thing here wants this version of this and that". Currently using 30 day trial of Goland, which at least works out of the box. This is after trying ctags and cscope after realizing they are basically glorified grep.