I used to think VS Code was going to be a threat to JetBrains IDEs considering how fast its iterative development was (thanks in large part to the productivity of JS + Web renderer) but its never seems to quite be able to reach the feature-set, polish & intelligence of JetBrains IDEs.
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.
I don’t really see IntelliJ and VSCode as competitors. VSCode competes with atom and other full-featured text editors (vim, emacs) ... its got great adoption amongst the newer generation of programmers that think those editors are old school and user hostile.
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.
Interestingly, as an emacs user, I am really rooting for the success of VSCode. The existence of the Language Server Protocol means that I have a horse in this race. Emacs users that use the same language server as VSCode users directly benefit from this relationship. So even though VSCode is competing with Emacs for market share, it is very much collaborating with Emacs (and other text editors that use LSP) in making language features comprehensive for everybody.
It's more complicated. Microsoft waits until everybody adopts LSP for, say, Python, and then slowly moves to a proprietary language server, explicitly forbidding its use outside VSCode:
I feel the same. I couldn't do Scala with vim if it wasn't for LSP and Metals.
(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)
Any resources you could recommend for getting started re LSP with emacs?
I personally started with lsp-mode[1] and just went from there.
I think the textbook (i.e., The Innovator's Dilemma) model for a disruptive technology is specifically one that starts out looking like it only competes in a different (typically lower-value) market, right until it's eating your lunch.
Yup. $200 per year (!!!) vs free is a world of difference.
I agree. They are not competition at all.
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
It's likely a missing plugin. As an avid VSCode user I would liken the difference of VSCode and IntelliJ IDEs with the difference between an unfurnished apartment and a fully furnished apartment.
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.
Interesting. I have used IntelliJ for Java for as long as I can remember and can't imagine using anything else. For JS and Go I use VSCode. I wonder if it's just what I started with and am used to. I've tried to use Intellij a couple of times for Go, but end up back on VSCode.
I dont know how you’re productive with VS Code and Go... I watch my coworkers live code with it sometimes and they are struggling. The lang server crashes constantly and stuff like autoimports or code complete barely works. I sometimes want to scream while watching them struggle.
I've read about those issues, and used to get them occasionally, but haven't really had them in a long time. Maybe my projects aren't large enough to cause any issues?
Been using it daily for +1year and that doesn't sound like my experience at all.
Same pretty much the same for JetBrains stuff. Constant screaming about how to configure their autoformatter compatible to prettifier for specific settings. Not supporting required configs out of the box. And build and IDE often live in completely different worlds. For example, project moodel at gradle and at IDEA is completely different and IDEA one is much more limited. And so on.
Android Studio could hang whole mac while "indexing" and often need to "reset caches and restart" while works just fine in VS Code.
> Constant screaming about how to configure their autoformatter compatible to prettifier for specific setting.
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.
Be sure they're updating. There's no prompt or anything that I've seen in my environment to do so.
It's still not perfect but my experience doesn't match that.
I think only recently did the gopls become turned on by default for the Go plugin for VS Code. I've been using it for years and have never had any major issues.
The quality is really getting better but it is my experience that you still have to restart the language server (or the integration?) multiple times per hour on any non-trivial project. It is frustrating but it also becomes a habit to quickly reach out to that shortcut in case completion, formatting or intellisense randomly stops working.
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?
Really? Never had issues personally
I'm the same way. Java/Kotlin in IDEA, front-end (js/ts/css) in VSCode, and Go can be either but usually VSCode. I don't really want/need more than what VSCode provides for it.
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 work on a large rails codebase as well but within a docker container doing emulation because ARM. How does RubyMine perform then? Last time I tried it felt sluggish.
Do you mean the search itself or other parts? Quite possible that I've become accustomed to the parts that are slower being used to IDEA. e.g. I accept the 'indexing' operation sometimes on startup or the now rare garbage collection pauses.
Goland is great if you have IntelliJ muscle memory, I haven't tried using IntelliJ directly for Go though, Imagine it's probably sub-optimal.
You do have to pay for Goland also.
I love Goland, and it's honestly one of the products that I very much like to pay for. You can eventually pay a one time fee and use it forever (without updates).
I'm also using it for Rust, but it's missing CLion's powerful debugger UI - but I think that gdb is good enough :-)
The Rust plugin for IDEA Ultimate allows for debugging. I've used it while trying to contribute to open source software.
That’s how every JetBrains IDE subscription works, though. If you pay for a year, you get the version at the start of that year for perpetuity.
If you have IntelliJ ultimate, Goland is installable via the Go plugin for free. I use IntelliJ for go/js/python using their plugins and they work as well as the native apps (pycharm, webstorm, goland). Although it is a bit tougher to configure because you treat things more as modules.
I would (and do) use goland directly, but i think intellij handles the basics. I only use intellij for rust, and it does well enough there as well
On my team that works on Rust I think there’s a similar split between Clion and vscode. I prefer vscode fwiw
At this point, I don't think VSCode competes with Atom.
As in VSCode never got to parity, or vice versa?
In the past five years or so I haven't bumped into anyone who would use Atom. When Atom came out, it picked up some steam, but I'd say VS Code has already won that race by far.
I switched from Atom to VSCode only 6 months ago.
I was pretty set with my Atom setup but it was clear that it is mostly EoL'd.
Who use atom anymore?
I'm a current MS intern, curious what work ya'll are doing in Go. Would you be up for a call sometime?
Ex MS employee (and former intern). Somewhat new to Go (and using VSCode full time) - but it's the language of choice for my job right now. Go seems to be popular in backend apps (non windows mostly) where concurrency and performance are important. The tooling around go for performance profiling and optimization are rather good IMO, and quite friendly if you are accustomed to Unix style CLI tools.
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.
Email me your MS alias and I'll reach out over Teams on Monday. Email is my profile.
The email field in an HN profile is private. You have to add it to the About field if you want others to see it.
Thank you. I might be missing something, but not seeing an email in your profile here and not seeing anything plausible in internal search.
I’m [redacted], I don’t mind that being public for a bit to avoid playing tag :)
I haven’t tried the Java integration but based on using VSCode for TypeScript I could imagine feature parity. VSCode is so good that it makes me concerned Microsoft is just using it to eat at JetBrains until they up and start charging for it in the future. Not sure how else to see it.
So VSCode is very, very good for TypeScript. Hell, I'm pretty sure VSCode itself is written in TypeScript!
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.
My experience is the opposite with VSCode and TS, actually.
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.
> But that does not carry over to all languages.
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.
This is what Microsoft does. Their #1 thing is being in the market even if the product is bad. They’re delegating now, but wait until they’ve established their foothold, leveled up the core framework. Then they’re going to stop delegating one language after another.
The language server is a really small part of an IDE, though. IDEA has soo many Java specific features I use every day (like maven, spring and other tools, debugger, hot reloading, profiling etc), and other non-language specific stuff like db viewer.
It’s possible they lack vision and focus for this thing, such that they go out and do “Java support” without making it good or caring about it.
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.
Reality check, Microsoft is a Java vendor nowadays, after having bought jClarity, has a seat at OpenJDK table, official Java blog in English and Chinese on MSDN, and Java is the only plaform that has biggest parity with .NET features on Azure.
Actually, Microsoft cares a lot about Java and they invest resources on it. Why? azure
Python is not a strongly typed language and renaming variables in such a language is a minefield. I've used PyCharm and WebStorm and never felt comfortable using their variable rename facilities for Python and Javascript. If they do it better than rope then that's good, but you need to write those languages in a very specific if you want IDE renamings to succeed. IMO, that rope fails silently might be viewed as more of a feature than a bug :). Anyway, I'm sure it will be improved.
Eventually LSP will be totally solved.
> All languages are basically the same.
Well that settles that, then.
Thanks for playing folks wrap up the site! We’re done here.
I think VSCode is really good, but even when I was only writing JS I ended up preferring WebStorm. I like its refactoring tools and command palette better, and I also prefer its "batteries-included" rather than "plugin-first" approach (although I do have a few plugins on JetBrains products always, such as Vim, there are significantly fewer than in VSCode)
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.
I feel like we are kind of ignoring how Visual Studio plays into this, do we really expect Microsoft to replace it with VS Code? I feel like Visual Studio Pro/Ent is more of a competition with other paid IDEs and VS Code won’t be, perhaps somewhat so it isn’t positioned to eat Visual Studio?
I've been programming with various IDEs and text editors for over 30 years. In my formative programming years (1990s) I relied heavily on Borland and Microsoft IDEs. In the 2000s it was a combination of Visual Studio (C/C++/C#) and various editors (PHP, HTML/CSS/JS). In the 2010s I started working across multiple languages: C#, Java, Python, Ruby, Elixir, Scala, JavaScript (also dabbled with Lisp, Go, and Rust); using various tools: Visual Studio, JetBrains IDEs, VS Code, Atom, Sublime, Vim, and even Emacs.
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 had the same experience, used Visual Studio for C++, and years after C#, and Eclipse for Java projects. When JetBrains came along it really shined.
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.
Recently spent a few months going deep on React development and I concur. The support for it was just magical.
This is a decent investment for coders. Good tools make all the difference.
Also proper tools make all the difference. There’s a lot of pro IDE talk in this thread now but text editors exist for a reason
I pay (personally) for the entire Jetbrains tool set. They are damn good. And I guess to be fair, I haven't given a lot of time to VSCode, but TBH: I find that Sublime and IntelliJ cover the spectrum for me (which is Scala, Java, Kotlin, Python, C, Go and Typescript all with git support)
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.
The only reason I use VS Code is when I want to quickly check a file or create a PoC. PyCharm or CLion are just too slow and frustrating, but for bigger projects there is no better option than those, despite being awfully slow.
On what platform are you using these IDEs? I use CLion daily and it is very fast on my Linux machine with a Ryzen 3700X CPU.
(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 think it’s less about the platform and more about the size of the code to index. Text editors are about as fast in a repo with 30,000 files as in a repo with 3. IDEs can take a few minutes to do the indexing necessary to support their code intelligence on bigger repos.
I never really realised this, but IntelliJ feels almost instant on my fedora workstation whereas there is a certain sluggishness on Mac in the ui. Resizing panels, context menus, the terminals.
There’s more too bootstrap so the IDE is slower. Plus setting the project up properly and so on. It’s not as simple as typing ‘$ code <dir>‘ and starting to write as the editor pops up instantly. People’s definition of fast and instant are different. There’s absolutely no way an IDE can start faster than a text editor, otherwise text editors wouldn’t exist.
> (Visual Studio -- not Code -- comes close).
What do you think Visual Studio is lacking the most compared to JetBrains?
Don't get me wrong, I still consider VS to be an extremely powerful IDE. I think it's the best IDE for .NET development, and maybe C++. It also has the best debugger, period. But when it comes to supporting multiple languages, it lacks the consistency, extensions, and integration that JetBrains IDEs enjoy. Admittedly, I haven't used it professionally in about 5 years, so many things may have changed.
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.
Thank you for your answer. VS has indeed changed a lot, especially in the "ReSharper" department. My only qualm would be the performance (startup, loading solutions etc). JetBrains might be better there too.
> Meanwhile, JetBrains seems to be staying afloat mostly thanks to hard work and sheer luck.
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 ]
Thanks for this comment. This analysis of the internals is much more informative than vague divination that the post author pulls from their gut.
We can expand on this analysis a bit.
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 take with VS Code is that their support of development container and ssh is the best and it's a killer feature.
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.
I desperately wanted VS Code's remote development functionality in IDEA, and was keeping track of their remote development feature in YouTrack. When CodeWithMe was released, I was sorely disappointed.
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.
I've spoken to some Jetbrains employees and it seems their vision of remote development is nothing like what VSCode does. No matter how much I explain they just don't seem to understand the advantages of being able to host the IDE in a docker container/remote system. "Docker isn't supposed to be used for that, you deploy to a container, not develop inside one" they say.
Agreed, mutagen is great for remote development.
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.
Jetbrains Projector seems to be their solution. It runs the IDE on the server, and renders the GUI in a browser. Seems experimental so far, I'm running it at home and it's surprisingly far along but still ... Kludgey? A great POC.
I agree 100% that being able to work on a project that actually lives on a remote server, or on Windows subsystem for Linux, or in a container, is a killer feature. It's really awesome. It still wasn't enough to tear me away from GoLand though. I hope JetBrains implements something similar, I think they may have done so already in a limited way for certain languages, but it's not on VS Code's level if I recall correctly.
In my opinion, the Emacs/Vim communities clearly missed a golden opportunity for a more larger adoption.
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.
> 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.
Unfortunately this doesn't work well if your connection has a high latency though, which I think is what VScode does really well.
did you ever try this? or is this just something which you think should be it's distinguishing feature?
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...
Sorry for the late reply,
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.
Fully agree. Also, if you need to debug your code that runs in kubernetes pods, VS Code also smokes other IDEs. In my case, not only the API calls are forwarded from the cluster to my debugging session but I can also consume during debugging some Kubernetes services by using their DNS names. Just awesome.
I'm the same - editing remote code is required - full stop. Of course, VS goes further.. But all I really needed was remote projects with intellisense. Remote debugging, git, and everything else are just bonus.
I run my editor on my desktop, and expect to be able to work on whatever remote server I need to.
Do note that the remote containers extension is not open source (not that we're entitled to that or anything, I just wanted to point it out).
> The key technology here is probably the Language Server Protocol
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 someone who wrote an LSP implementing server 2 years ago (when the documentation was even less complete), I can't really relate to this.
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.
> 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.
“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
I wish they would provide a machine-readable version of the specification: https://github.com/microsoft/language-server-protocol/issues...
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...
Marketing-level docs and then fine-grained API docs sounds very MS.
I would be happy with fine-grained API docs but there's no JSON-RPC spec I could find
As an aside, do you know of anywhere for Language Server implementors to gather and swap stories?
I don't, but I would be happy to know about it if such a space exists
Most of this post is just speculation like "I seriously doubt it will work well in an average cafe though" without much substance. Either test it or report on it, or at least discuss its shortcomings based on some technical merits. And frankly I don't care how well it works on "spotty café wifi". If the wifi sucks I wouldn't sit there and work anyway.
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.
> Most of this post is just speculation like "I seriously doubt it will work well in an average cafe though"
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...
It's important to note that IntelliJ is not Jetbrains' only product. PyCharm has seen a very significant growth during this period too (7.7% -> 13.4%), although PHPStorm has decreased (11.6% -> 7.6%).
Regardless, I find it remarkable that IntelliJ hasn't lost an inch of ground (it's even made modest gains) despite VSCode's explosion.
And you also have to see that they're just special purpuse branded IntelliJs that you can buy for less money.
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.
Why is it an advantage being Electron? If anything, IDEA is also cross-platform. As for speed, VSC is faster as a text editor, but not that much faster for IDE stuff if you try to use it as that. Even slower some times, maybe LSP incurs some overhead IntelliJ don't have to do.
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?
Usage is important, has all editors live and die by their community. Intellij is less dependant on them, as they develop their most important features themselves, but third-party plug-ins are still mandatory nowadays.
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.
One of the things that baffles me is the rust-Lang support.
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.
Besides Typescript, I haven't seen any language server do better in syntax completion and introspection better than the JetBrains equivalent. They probably don't want to work on it because 1. If they write their own they can make it work to exactly what they need, and 2. They would probably not leverage as much working on the OSS version as they'd lose by open sourcing and doing the bulk of the work on what makes them money. That might sound cold but it is not unreasonable.
It's MIT licensed
JetBrains have always developed their own language analyzers from what I've seen. I would bet they have a clear API between a language analyzer and their suite of refactoring and code navigation tools, and it would probably end up being similar to work to support that API through an open source variant VS building their own.
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.
Do you mean rust-analyzer's good experience and progress updates? RLS is in maintenance mode and deprecated in favor of rust-analyzer.
So will rust-analyzer also replace rustc eventually as the main rust compiler? Seems like a lot of overhead to keep two compiler versions at parity.
No, the goals of an IDE-oriented compiler are largely different from the goals of a bulk code compiler. They can / will share substantial amounts of code though. Quoting a developer:
>>>>>>>>>>>>>>>>>>>
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.
rust-analyzer is not a compiler. They plan on sharing a lot of code though.
I use both VSC and CLion, and CLion is a much better experience for Rust IMHO. I know the IntrlliJ only plugin is kind of lacking versus the CLion feature with regards to debugging, but overall I find CLions support to be miles ahead of rust analyzer for stability, speed and ease of use.
A few years ago I contributed to an Intellij plugin with significantly less resources than the rust one. What became clear there was that external tools are glitchy, laggy, frequently crash, and don't quite match Intellij's model of things, native Intellij support will likely always be better.
There is nothing inherently wrong with solving a problem multiple ways. While it's usually good for smaller players in a space to work together, I'm always happy to see others that trod their own path. They can make different choices/tradeoffs, and learn from each other. This usually leads to better outcomes for both of their user bases.
> Instead of collaborating though I see IntelliJ continuing on the path of their custom implementation.
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.
Their code is open source (if tightly linked to their codebase, of course) https://github.com/intellij-rust/intellij-rust
I can think of multiple reasons they may prefer doing it themselves: Differentiation, if they just reuse the same thing everyone else does, they will have no moat or extra features. Or maybe because the language server protocol cannot handle everything IDEA normally provides, so they will have to run some kind of parser etc. on their end anyway. Or that interfacing with an external tool can be buggy or have weird boundaries making certain features harder to implement.
> And frankly I don't care how well it works on "spotty café wifi". If the wifi sucks I wouldn't sit there and work anyway.
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.
Exactly, and I don't see how it would work any less well in a to café than VScode remote SSH.
I don't believe that there's anything preventing VS Code from getting features like refactoring at the level of JetBrains at a fundamental level. One time I wrote an IntelliJ plugin that exposes an LSP server so Emacs could run Jetbrains' refactorings remotely, as a glimpse into such an ideal.
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.
People act as if the language server protocol has no equivalent in JetBrains ecosystem. There are, things like MPS: https://www.jetbrains.com/help/mps/mps-user-s-guide.html, or the platform: https://plugins.jetbrains.com/docs/intellij/intellij-platfor...
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
The language server protocol is diametrically opposite to the way that IntelliJ works. For each language, IntelliJ builds its own internal representation (PSI) of the source code. There are a lot of language specific things, but there are also a lot of commonalities between languages.
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'm not really arguing that the JetBrains ecosystem is equivalent, or necessarily better, than the LSP approach. It's just that this article seemed to base the existence of the LSP as some evidence that JetBrains' approaches with MPS, etc, are "corporate enterprise bloatware", which will be displaced by VS Code.
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.
Isn't eclipse also an open source ecosystem too? that said, I would rather work with either Jetbrains or VS code than eclipse.
Yeah, I didn't mean to say that Eclipse "wasn't" open source, just that these other ecosystems are also. It's not like you have a choice between "Eclipse and commercial".
> Meanwhile, JetBrains seems to be staying afloat mostly thanks to hard work and sheer luck.
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?
I use VSCode for 95 percent of my development and I couldn’t be happier. I use IntelliJ for the other 5 percent (which is just Groovy scripting for a particular product).
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.
I use IntelliJ daily. I think when LSP gets there VSCode can catch up and fill the IDE gap, but until then it doesn't come close to IntelliJ in terms of functionality (though sometimes the perf of IJ makes me want to switch but it has been feeling a lot better on the M1).
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.
This is interesting to me and makes me question what I missed on setting up JetBrains products. I moved away from them because of their lack of support for standard tooling like eslint and pep8. It felt like JetBrains editors wanted me to set up lint rules by their spec and I had to set it up in their editor configs.
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.
> I moved away from them because of their lack of support for standard tooling like eslint and pep8.
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 :)
Huh, how long ago was that? I've been recently using the Python plugin in IDEA while fixing up a rather important script, and it's very good at a) telling me when I'm doing bad PEP8 things, and then adding PEP8 compliant formatting when I tell it to autoformat and b) highlighting type hint mismatches.
But this may be a recent improvement, I only work on Python sporadically. My next wish for IDEA's Python plugin is Poetry support.
Outside of the JVM space, I share the complete opposite sentiment. Go and Rust support in the past few months (close to a year at this stage) have been vastly better with LSP than with intellij (or the more specific products). Rust-analyzer literally just works for me with the vscode rust-analyzer plugin (intellij wouldn't work after a few minutes of googling etc, not a great experience) and I've consistently seen Goland be outperformed in OOTB experience by gopls, as a highly active member in Go online communities catering to helping many new developers.
This comment doesn't make much sense. LSP is just a protocol, implementing package detection is the responsibility of the language server.
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.
We know how LSP works...Run a few of their implementations for various languages and send me a script. I have, it’s not easy. Running the LSP server set for a polyglot programming environment is really hard.
404?
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.
Found it here: https://archive.vn/nNdT1
Temporarily updated the main URL to this. Original was https://gist.github.com/rambingthoughts/c28fc8caa07733443c77... . Thanks
According to Jetbrains' own surveys, VS Code is indeed growing in popularity - from 7% of Python developers in 2017, to 29% in 2020, while Pycharm remained at about 33%:
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/#...
I am wondering a bit what is meant here by “disruption”. As I see the situation, some people seem to believe that as professionals we don’t necessarily have to use “the best tools available” and if you can save a little by getting “almost as good (after some tinkering)” it’s more than acceptable.
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.
I hate to work with JetBrain tools. Whatever machine I am using them on, they feel sluggish and bloated. Starting an editor takes ages and often it is unresponsive or you can feel the delay between character appearing on the screen and your key press. Absolutely dreadful. That being said I still use them, because nothing can quite compare despite these awful flaws. I also use VS Code but only because there is almost no delay between typing `code .` and having an editor ready to type stuff in. It's perfect for quick "sketches" or if you want to check an odd file here and there, but if you want to work on a larger code base, the experience falls short (e.g. navigation between files, searching) With that in mind, there is still a big gaping market hole when it comes to IDEs - create an editor with JetBrains feature set plus make it as fast as VS Code or Sublime and you'll be a winner. One more thing I cannot understand is that literally every editor's search functionality is more or less useless for bigger projects - simple thing like "and" and "or" operators for keywords are yet to be found. Sure some allows you to use regexp, but that is a pain and not how people are used to searching when using e.g. google or github.
The link seems to be dead but here's my thought anyway.
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.
In my opinion, one killer feature of VSCode is the ability to connect to WSL, remote server and Docker container. As someone mainly developing on WSL2, I use this feature everyday. I only use Idea when I need to use Java or Kotlin, because its language support is really good.
> or Kotlin, because its language support is really good.
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.
Or, less cynically, it's time we moved beyond designing languages for the lowest common denominator in editors. Sure I should be able to make tweaks in notepad, but I'm totally fine with that being the less happy path.
This is a direction jetbrains has been going in for a while. Have a look at the failed https://www.jetbrains.com/mps/
That's not exactly what I'm complaining about though.
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 happen to disagree with you both that syntax is irrelevant and that receiver scopes are "just syntax".
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()
}
}Intellij 2021.1 has the feature called run targets, which enable to run your code on a docker environment or on a remote server. It also bring WSL support. https://blog.jetbrains.com/idea/2021/03/intellij-idea-2021-1...
There is also projector and "code with me", but they still have some work to do before they reach feature parity in that regard. At least they are working on it.
https://youtrack.jetbrains.com/issue/IDEA-226455#focus=Comme...
WSL support is in IntelliJ now. Makes it super easy to use jdk/node and other toolchains on the WSL side from IntelliJ running on the windows side
I agree with this; I bought the professional license of PyCharm on the basis of its "remote development" functionality which I assumed would meet the (admitted) easy "it just works" standards of everything else in Idea.
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 seen this being mentioned in other comments, and besides WSL2, I've used PyCharm (a close relative to IDEA) connected to containers, Vagrant and plain VMs for years. I suppose the rest of the IntelliJ products have the same support, and WSL2 being rolled out, obviously?
It looks like JetBrains' Projector went 1.0 last month.
Speaking as a corporate programmer working from home indefinitely, I'd kill for IDEA Viewer. My laptop can't have code on it, so I'm forced to remote desktop to my workstation to use IntelliJ and CLion remotely, which is a middling experience at best. A light protocol for synchronizing the frontend with the IDE backend would be excellent.
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.
It has some semi-minor issues still (e.g. resizing panes, last I tried it, would only move a few pixels before losing the "drag"), and it's not as efficient as VSCode (which is a pretty high bar, to be fair), but there is a "Projector" for many of their IDEs: https://medium.com/swlh/how-to-run-android-studio-on-any-dev...
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.
Wow. I'm amazed they haven't relaxed the no-code-on-laptops rule this year.
> remote desktop to my workstation to use IntelliJ and CLion remotely, which is a middling experience at best.
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
rust-analyzer works very well for me, definitely don't use RLS.
Offtopic: I can't seem to resolve this website through CloudFlare's DNS servers, what's going on here? Are they blocking Cloudflare's resolvers? Is there something wrong with Cloudflare? What is going on here?
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.
Re: Offtopic
Yeah, the owner of those archive.* websites blocks CloudFlare DNS because of some hate-boner for CloudFlare [1]. Really unfortunate, honestly.
Until four months ago I used PHPStorm although I haven't typed a line of PHP code in at least 4 years. Since all my coding is with TypeScript I decided to switch to VSCode and not renew my Idea subscription.
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.
Only? Wow.
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
There is a local history extension in the marketplace. It’s a huge timesaver for me. Check it out
Which one do you like?
For typed languages like Java and Kotlin there is really no competition. IntelliJ is just clearly above every other IDE. For dynamic languages advantages are less clear, but still there. Every time I tried to use VsCode for longer periods of time on my JS/TS projects, I would stumble on many small bugs and problems, usually with extensions that I would loose the nerve and just get back to Webstorm.
It shouldn't be surprising, right? Didn't Kotlin start as a JetBrains project?
It did, and millions of Android developers use Android Studio, which is of course also part of the IntelliJ family. So I'm sure that and the (financial?) relationship with Google has also helped a crazy amount with making the whole platform better.
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.
It is valued more than that, 2/3 of the founders are billionaires now. What I love about their story is they basically just made a great product that developers are willing to pay for and everyone else eventually died.
I almost use always vscode via it's ssh remote development feature. In my experience this thing is flawless and indistinguishable from local development. It's hardly believable how good they've made it.
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.
Just curious but what is the use case for needing to have your source code on a remote server while you’re editing it?
That depends on the person using it, there isn't a fix list provided by the devs of vscode. For me it's some of the following:
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.
Enterprise policy is one use case, where devs must use locked down windows workstations to dev on remote Linux hosts.
Whether accurate or not, my personal perception of IDEA vs. Code is that IDEA wants to own my development workspace while Code just works with whatever files I've decided to check in.
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.
Mmm... Feels more like a loss leader than a technical disruption.
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.
I pay subscription for everything but 99% of time use VS Code. Why? Remote execution for huge typescript project - i moved it to separate mac mini and performance (i can open 5 VS Code without slowing anything at all)
Language support in VSCode for Go breaks in unexpected ways after every update of Go, VSCode or any plugin involved. gopls has not helped at all so far.
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.
Oh and i want to add that VSCode actually created a lot of damage for me.
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!
Funny that the LSP wanted to give IDEs a way to move fast, by getting its info directly from the compiler and then slow compiling languages like Rust built another tool (the analyzer) to make IDEs fast again.
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.
> Funny that the LSP wanted to give IDEs a way to move fast, by getting its info directly from the compiler and then slow compiling languages like Rust built another tool (the analyzer) to make IDEs fast again.
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).
LSP is a huge deal and ought to allow all kinds of new editing tools to empower users with the kind of things we used to get scoffed at by Visual Studio users for living without. Vim is now as "full featured" as VSC and I have some bet winnings to collect.
Edit: corrected autocorrect
> the kind of things we used to get scoffed at by Visual Studio users for living without.
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.
No offense; I couldn't care less about Java personally. I just mean Intellisense (at all) was this hammer I kept getting hit with. IntelliJ too. I just kept on with vim+google and now the playing field is level. And I'm still getting more work done and paying less.
Why are desktop Java apps are always so slow? Applications written in other languages (C#, C++, etc.) are much much faster. Even VS Code, written in JavaScript is faster... I tried hundreds of applications and this was always the case and not just with certain applications.
It's not really Java as a programming langage, you can have light and fast Java code, nor the JVM, it's a pretty fast virtual machine that is just very memory hungry by default. In my opinion it's the community and the philosophy around Java. It's usually a bit over engineered and performances are not taken into account very often. Take eclipse as an example, from a software design point of view it's great and a very advanced. You can for example play with the eclipse modeling framework and it's in another league compared to VS code plug-ins.
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.
Web Browsers are built on multithreaded rendering - Paint, Layout and Main threads. It works really well, but on legacy or native everything is done on the single main thread and everything is jammed into 16ms of a single thread.
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.
My best analogy for this is to think of Java as like a truck and other languages as like vans (C++) or motor scooters (python, etc). Past a critical threshold Java has absolutely amazing performance (sits in same league as C/C++) but if you imagine driving a large truck around town ... you are constantly starting and stopping, turning into alley ways etc - a truck is not going to do too well. But if you actually have to deliver 50 tons of goods, good luck on the scooter. And a well designed Java app can behave like a scooter but its not the default setting because most people in enterprise settings have truck-like problems.
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.
I'm getting a 404. Does anyone have a backup copy?
Found a backup here: https://archive.vn/nNdT1
VS Code is fantastic and I'd rather use it over something like Eclipse, but as a very happy jetbrains recurring subscriber, when my subscription comes up for renewal I can't think of anything that gives me so much productivity for such a relative pittance of cash.
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.
The author frames this as a contest between two architectures: either spend a lot of effort building custom developer tools, or repurpose the compiler as a server for multiple clients. Both approaches have their tradeoffs: the first, as the author mentions, violates DRY [1]. The second violates the Unix philosophy [2].
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
I think JetBrains is much better than VScode for development.
However, for me VScode is always open, and I frequently open files with VScode from the terminal
code filenameI know you can do similarly with the IntelliJ apps. For me I can also do `pstorm filename` and open in PHPStorm.
Of course for single one off files I prefer to open in sublime because of how much faster it is.
This is the same for me, Sublime 4 is faster and more polished than VSCode and Intellji is more feature packed
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
I’ve actually happily reinstalled Sublime Text after almost a decade due to this.
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 found IntelliJ IDEA about 7 years ago. Before that, I had used a number of different editors/IDE's for polyglot development.
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.
> 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.
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.
Yeah or Google. They stopped Google Code (or whatever it was) to move it all to GitHub; I just assumed they'd then buy GitHub. Felt like a much more natural home for it.
Maybe Gitlab?
The price they paid is much higher than what Google could reasonably do. They are not a developer focused company like Microsoft.
Google is an investor in Gitlab
I'll just keep using Eclipse over here in the corner :-)
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.
I used to be an Eclipse zealot. I clung to it even as my co-workers moved to IntelliJ. When I finally made the jump, I found it a huge boost to productivity and stability. I needed for a while on one project to run Eclipse to be able to use an IBM plugin for their rules engine and it was painful how much slower and crash-prone Eclipse was.
> missing these deeper features
examples?
A lot is in the framework level features: I have workspaces set up with combinations of projects configured as dependencies for each other. The perspectives feature allows me to then have specific window configurations for each, and the working sets lets me zero in on a particular subset of projects and files for what I'm working on. The incremental compilation that crosses project boundaries then means I can, for example, jump into something in library, refactor it, immediately (like, less than a second) have all the errors across all the projects across multiple languages show up from this change ... and nearly as easily execute all the unit tests.
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.
The examples the author uses to make the case that Idea is getting "fatter" and "more corporate" are actually things VS Code has too:
"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 can't find an equivalent of remote development on any of the JetBrains IDEs - please could you provide a link?
Projector: https://jetbrains.github.io/projector-client/mkdocs/latest/i...
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.
I don't think it's in it yet. Those are 2 features the author says IntelliJ announced (for the future). Although the first (Code With Me) is already available.
This started with eclipse vs intellij. Eclipse was free and okay. Intellij was paid and polished to hell.
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.
I spent nearly 1 year with VS code before paying for Jetbrains for good. The time I wasted with VS Code and all its configurations from different plugins in json format can't justify the time I lost with IDEs.
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.
You should only compare by specific language/stack. Not as a whole. For Java I’d use IDEA. For JS maybe I’d go with vscode. For Rust I also used IDEA and preferred it over the vscode rust setup. However, didn’t check as of late, maybe vscode rust experience because better now.
The key thing with idea is to have a fast machine - finally with a amd 5600 the speed is not annoying
I couldn't agree more. It was brutal on my work MacBook. The Ryzen with 32GB RAM is heaven.
Yep, can't use them because I have 4GB RAM macbook air.
Rumor is the M1 flies
I mostly write JavaScript/TypeScript (with a little Go in my freetime) and I switched from Webstorm to VSCode in December. Things I miss from Webstorm/Intellij:
- 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.
Well it is free. It's also open source for those of us that believe that's important in its own right.
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 happily paid for license and it's been a well spent investment.
Curious about people who switched to something like Webstorm from VS Code. I've tried it for Typescript development and didnt find much of a difference. I can say webstorm has better , more clean ui for Git, but that's it. Certainly issue was that I could only try it shortly on simple project. Would love it here about some more example from other where to see the differences.
Btw I am pretty impressed with Quick fix and autocomplete functionality for VS code. It's IMHO pretty great for text editor.
Right now I'm primarily using PyCharm, but I made the switch from VSCode to Webstorm a few years back. Here's what I liked better:
- 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.
> That situation may catch the IDEA family between a rock and a hard place: it has to outdo compilers
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.
At the end of the day JetBrains doesn't own a whole cloud office suite that can finance and price dump their competition in the IDE market. They can fight against Microsoft, but US corporate consolidation will make sure that their competitor can just give out "good enough" product for free and destroy their revenue source.
They'll either go out of business or get bought out by another corporate conglomerate and their products released for free.
I have had VS Code load the wrong version of a file. I’m not sure whether it’s loading an older cached version or loading a file with the same name from another folder. The first time this happened and I couldn’t resolve it, I put away VS Code for a couple of years. I tried VS Code again after forgetting all about why I deleted it. I got burned by the same problem. You can navigate right to the file you want to open, and it opens something else.
Never seen this happen. Maybe try to reproduce it systematically and post a bug report?
I use VSCode for most JS work now, but largely prefer Webstorm for big codebases, and wouldn't dream of using anything but PyCharm for python. PHPstorm is a no-brainer unless you're still debugging by using print statements. IntelliJ and Android Studio made me not hate Java anymore. I forgot about GoLand, but haven't encountered an occasion where I felt I needed more tools. When that time comes, I know where I'll go.
I'm having paralysis analysis with VS Code, and trying to choose which plugins to use now. Curation is key, when there tens, if not hundredths of thousands of stars for plugins seemingly doing the same thing.
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 see Jetbrains' role first as a curator of a near flawless collection of plugins for a given purpose.
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.
Another difference is leveraging container orchestration tools (compose on the low end or k8s on the high end) to manage your dev+ environments. The editor used to take a big role in managing that but now I don't want that because I need the dev environment to be highly reproducible and a full environment is usually pretty complex with multiple apps and one or more datastores.
IDEs like IDEA and Visual Studio give me perfect tool for a perfect learning experience: As a hobbyist I'm extremely picky about what I want to learn. For exmaple, when I'm learning C++ and game programming, I'm not interested at all at the inner workings of Git or Makefile or whatever that is not relevant at the moment.
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.
I have no doubt that IDEA is probably more "professional" but I find VS Code is more my preference because of the open source nature of it. I know it has it's warts but it's in a whole different league than IDEA products. However to each his own, I have made a living with open source and that has colored my perceptions of products.
IntelliJ IDEA's Powershell support (via plugin¹) is very poor. Both VSCode (predictably) and Atom are superior. It is the one reason why I keep VSCode around.
I am new to Rust, and started first with VSCode, and I never managed to make plugin work properly. Again, an experienced user will be able to fix the problem, but I am not.
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)
The rust plugin is a common pitfall, install the rust-analyzer plugin and you shouldn't run into any problems in vscode.
I've used both extensively, and for me it boils down to whether I am using Typescript or not, as the code hints for Typescript are much better in VS Code. I've also noticed VS Code suffers less performance degradation with some projects.
In general, for Java and Python, Intellij is much more polished and functional.
The great advantage of a Jetbrains IDE is the solid integration of all the components for a particular language. Bolting together extensions in VS Code has never gotten me close to the efficiency of a dedicated IDE from Jetbrains. I use both for their strengths and always have an instance of both running.
Different problems require different tool sets.
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.
Unfortunately, for a "light-weight" text editor, VS Code is very power hungry, especially if you have more than a few plugins. Yes IDEA is not much better but you get far more for your watts.
C# and F# support is vastly superior in Rifer to the VS Code epxerience.
This! I have been trying to switch to VS Code for dotnet core projects, wanting to ditch Visual Studio. It's clear that Microsoft is - willingly? - keeping VS Code an arm and a leg away from being close to Visual Studio. Refactoring is a hit and miss, the language server will randomly need kicking, code completion is at times outright trying to sabotage you - inserting random classes - and the whole experience makes impossible to consider switching to it.
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.
You have better experience with JS/HTML/CSS in VS than VS Code?
that's unheard :o
VS Code is overrated
For my everyday use the little features, customizzation and shortcut integration make jetbrains the winner
I keep trying to use idea... But that crazy autosave I cannot disable always drives me back to vscode
I think the question we should be asking (rather) is what wold happen to Visual Studio?
Cathedral versus bazaar metaphor potentially interesting here.
Comparing an IDE with an source code editor
The original text has been deleted. Here is the copy: =============================== Reflections on IDEA vs VS Code
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.
VS Code is dead ugly.
That is pretty subjective. Other people would call the Jetbrains products dead ugly and non-standard :-)
I personally don't mind it. I probably would have taken issue with it if there were no user themes, but the ability to dress it up in my favorite Nord colors has assuaged my concerns.
Critique of the post: The belief that LSP are implemented in the compiler is mostly plain wrong. They might or might not be maintained by the same team as the language team but are almost always a separate library that interface through the compiler through APIs. Yes compiler have became much more queryable.
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.
> Actually intellij IDEs are quite fast nowadays and it improve regularly.
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?
I'm very much in the same boat. VS Code isn't the fastest editor around, but it still runs without putting up a fight on my older machines. I even used it on my x201 from more than a decade ago, which happily darts around VS Code while PyCharm feels really sluggish.
Don't know about datagrip, I was speaking for Idea and webstorm anyway they are mostly the same codebase.
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.
I already happen to run an EAP and Linux without mitigations (they're less bad on AMD CPUs anyway). I guess I'll try increasing the heap, but I hope it doesn't need 16 GB for itself.
Thanks. It seems that mine defaulted to 2 GB.
VSCode won't kill IDEA, but it is a huge warning for Jetbrains
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 have been using JetBrains IDEs for about a decade, after having used emacs for nearly two decades. I have never felt that JetBrains was slow, but I hear that a lot here.
I'm curious what situations people are finding JetBrains' speed to be impacting usability.
Sometimes I just want to read code with highlighting. I want to open the project and search for some text in all the files. I don't want to wait for IntelliJ to take 30 seconds to open.
They've had something like that for a year. https://blog.jetbrains.com/idea/2020/04/lightedit-mode/
This is great but it has a lot of limitations. I will give it a try thanks.
You could use grep with vim or nano for quick searches and viewing without even leaving your terminal. Why bother with a GUI at all for that use case?
This idea assumes that one I am familiar with grep and vim or nano and two that I was using my terminal already. Which can be true or wrong. But, the discussion is not about whats the best way for searching for text in a file set. I am just talking about whats the use case in which I prefer VSCode over IntelliJ.
The delineation between those and VSCode seems unclear.
Using Windows, comparing different Jetbrains products to VS Code, I personally experience for example a constant input lag in the terminal (Powershell) emulator (?) on Jetbrains IDEs.
IntelliJ user here. Both on Windows (personal) and Mac OS (work).
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?
That seems to intuitively make sense as a want, if I consider the fact that many other devs tell me that they never want to leave their IDE, even just to open a PR or whatever.
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.
Java is not slow, even JS is not slow. 10% performance improvement doesn't make sense for rewrite.
Java's not slow, but IntelliJ consumes a lot of RAM. On computers with less than 8GB RAM, the constant swapping causes bad performance.
java and JS are slow, it is how they work, they are JIT'd languages running in a VM, this alone makes the program slow by default
are people in this website not supposed to be programmers? or it's too late to expect programs to be fast again?
> slow startup
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 ...
Agreed. I think I restart my IDE roughly as often as I reboot my computer which means I've had IDEA and CLion running for about 22 days right now.
Hot buzz without much substance. You propose hipster driven development. Ignore lessons from the past and repeat all mistakes and deficiencies in super shiny alphabet soup of technology. Look at node.js ecosystem to see where this leads to.
IDEA is fast once it starts up. It's not supposed to be used as Notepad (or Vim).
HN deserve better content than this, while the topic is interesting there are too much errors, unadjusted logical quantifiers and omissions to make this biased writing worth a read.
It's also posted by some anonymous throwaway account that was registered on GitHub three days ago. JetBrains deserves more respect than this. They're not threatened. They're a rising star. They're making tons of money when the rest of the industry thought there wasn't any money to be had in tools anymore. I love them because speaking as a long time Emacs user, JetBrains makes the only IDEs I've seen that simulates Emacs well enough that I can feel comfortable using it. Java is a real pleasure to work with thanks to them and I don't see that changing anytime soon. If they had support for make and assembler then I'd use it while working on cosmopolitan libc too.
> They're a rising star. They're making tons of money when the rest of the industry thought there wasn't any money to be had in tools anymore.
I think this is key - WHO knew that you could build out a billion dollar business from developer tools.
This has me seeing maybe but probably not spending my gov-bux on webstorm
HN deserve better comments than this.
Sure asking for better epistemological quality should be disincentivized.. Do you realize the distopy you imply?
I used IDEA once and it failed to parse or validate my Java code because it lacked the same understanding of generics as javac. So I would be developing my codebase with various red marks everywhere and no confidence in the code navigation tools such as "find all references". Seems IDEA is overrated to me. But I know webdevs have other use cases like automatic CI or whatever and not the slightest desire to be able to statically analyze code. To be fair I stopped using Java since then as I could not ever fully learn all the edge cases, and corners like generics edge cases and JMM have about 3 people in the world who actually talk about them.
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.
Part of it feels like it comes from a different development philosophy.
Vscode is a "text editor" or a "code editor". Usually this means that it's fairly lightweight, supports every language under the sun, is highly configurable and extensible, but doesn't have a lot of very in-depth features, and also partially relies on third-party extensions for deeper functionality.
Jetbrains on the other hand works on IDEs built for one specific language explicitly. Consider CLion for C, it's only a couple of years old!
They put a lot of resources into supporting a language and all its relevant workflows. Phpstorm for instance has built-in support for three different standalone code quality checkers, composer (package manager) support, deep language understanding with highlighting, warning, errors, refactorings, generators etc, doc comments, code formatting, support for different testing frameworks, a built-in debugger, etcetcetc...
While that's great, you shouldn't go edit python code in Phpstorm. It supports syntax highlighting and maybe a couple of other small features, but that's it!
In short, code editors usually cast a really wide net with a lot of configurability and extensibility, while (jetbrains) IDEs tend to go really deep on a single language or workflow, with less extensibility, and deep configurability within the supported language itself.
I wonder if you have had the chance to use a Jetbrains IDE with a professional license. Doing so gives you access to more or less the content of all the other "flavors" as plugins (it's basically all IntelliJ underneath).
For example, I've been using PyCharm for both our python backend _and_ our React + Typescript frontend, all in the same project window, with the same features regarding syntax, linting, refactoring, tests, debugging, etc.
I have. IntelliJ ultimate edition still has fewer features for PHP specifically than Phpstorm.
Presumably not because it actually has fewer features, but because "the debugger" now has 150 options instead of like 5.
Also, these super-featured IDEs still won't support languages that Jetbrains doesn't have a specific IDE for. For instance, Delphi. Sure they'll support syntax highlighting somehow, and there might be one plugin.
VSCode probably has 20+ search results if you look up Delphi
I have current Delphi project with heavy GUI. I'd be out of my mind to use VS Code for it. I use VS code for scripting stuff where it more or less shines (JS, Bash scripts etc). Same for C++ - Visual Studio/QT Creator and CLion fill my needs way better than VS Code can ever do.
No clue, I just picked a random not super mainstream language as an example.
I'm sure vscode is terrible for Delphi, but I'm willing to bet that the experience (with whatever third party plugins exist) will be better than any jetbrains product.
Generally, they should come in the next version. Or that was their stance for PyCharm/IntelliJ ultimate.
I did not try that myself, but I think that you can switch enabled plugins with a simple text file. So you should be able to write simple BAT files to launch Idea for different sets of plugins if you need to.
Or may be there are better ways to do so. Anyway just enable what you need.
Just 5row money at the problem and configure your machine with more memory. Docker for Mac already eats a ton so I’m not sure there aren’t other good reasons to do so.
It does not for C/C++, you need CLion for that.
I've been using it for the last 3 years. At first it was slow, and running out of memory (it was in-process in Visual Studio, which is limited to 32-bits), but now that they've moved a lot to out-of-process it's much better!
I don’t know what version you use but Visual Studio 2019 is so full of bugs that it crashes multiple times a day or I simply restart it as some features such as codelens simply stop working and it becomes cumbersome to find references. Im sure they’d get their s__t together in the next version but so far I’m stuck with a crappy IDE. I’ve had a similar VS experience in the past and while it works it’s okay when I can upgrade i am super reluctant to do so. Yes, MS does push half baked versions quite often
Debugging is also available in PyCharm starting with the 2021.1 EAPs:
https://intellij-rust.github.io/2021/03/01/changelog-142.htm...
This has been my experience with JS as well. No difference between Webstorm or IDEA with a few minutes spent on configuration.
It really depends on the language and IDE.
For example I used to just own Idea Ultimate and use the language plugins, but the workflows were always inferior to using the dedicated IDE for that language.
So I now have the full JetBrains suite and use a mix of Rider, CLion, PyCharm Pro, AppCode etc...
Yeah, I basically use IDEA as Rubymine instead of using Rubymine. It's a fantastic polyglot IDE, and for my uses it supports all the latest Ruby + Javascript workflows.
There are some contradicting layout schemes across the languages and for that I'm glad Jetbrains provides the language specific flavors.
There is most certainly a lot baked into the language-specific editors that isn’t in IDEA proper.
That said, the fact that they all share IDEA’s gubbins makes it massively easier to jump between languages and frameworks for small jobs than I ever thought would be possible.
Having a set of tailored environments that also share keybindings and most common features makes for a fantastic (and really under-appreciated) value proposition.
I'd love to be proven wrong, but I don't believe this is correct.
The IDE shell is the same, but in (for example) Rider there are features that are in Rider but not in IDEA.
Likewise RubyMine. I suspect WebStorm and PhpStorm, too.
Turns out 99% of my work is in something like Java, Python, or JS. Once you include other JVM languages, C++, PHP, and Ruby, IDEA's coverage is huge. They even have C#, Objective C, and Switft offerings, but there's something to be said for staying in those ecosystems.
One thing to note is that you can use IntelliJ and install the official plugins for each language. For example you can bring the WebStorm functionality to IntelliJ, or install the database plugin to get an embedded Datagrip window. (Which is really neat because you can then get SQL syntax highlighting and such based on your actual DB)
Well just note that this doesn't work with all combination of languages. Try installing CLion on webstorm for example.
Theoretically yes. In practice no. Each IDE has workflows and features tuned to their respective domain.
They're not just simple configuration changes from each other
As much as that is true, I have a license for all of them and always use a few of them instead of the main IDE: CLion, Goland and Rider being the ones that are really much better for their respective domains because they are so different.
How does the open source IDEA plus php plugin experience compare to phpstorm?
That didn’t used to be the case. You used to be able to add the Python plugin to the free IDEA ide and that would give you java + pycharm - but only the free tier features of pycharm.
However, if you used the paid IDEA, adding the Python plugin gave you full PyCharm capabilities EXCEPT that IDEA was always based on version N of the core IDE platform where PyCharm was based on N+1 version, i.e. the smaller pycharm IDE sometimes had some newer platform features than the IDEA ide which led to occasional differences between IDEA + Python plugin vs PyCharm.
I switched to VSCode last year and let my licence lapse for Intellij so things may have changed.
What i will say, despite having moved to VSCode and being entirely happy - Intellij is the better platform. It’s the difference between 80% and 99% though, and the VSCode 80% is good enough. If i went back to full time dev, i would buy another jetbrains licence.
Intellij allows you to install pretty much most of the features from all the other jetbrains IDEs as plugins. Additionally most of their IDE's have the ability to code in several other languages seperate from the core experience. Almost all of their IDE's can for example integrate with the javascript ecosystem.
I think you're making a mistake here. Essentially behind the scenes there's one jetbrains IDE. This IDE is a single platform that can take plugins and code in any language and be customizable to your hearts content.
ON the surface however Jetbrains doesn't exactly release this IDE to the public. They deliver different configurations and different defaults on TOP of this IDE, then they lock it down a little and ship each one of these profiles under a different name. All these IDE's are basically different bundles of plugins running on the exact same core platform.
That's why CLion is only a couple years old and still really good. It's because all Jetbrains needed to develop was a plugin and shove it into an existing ecosystem.
This is no different then Vscode when you think about it. Both are coding platforms that can be plugged with new features, it's just that jetbrains locks some of this customization down and sells their IDEs with bundles of plugins that offers a better core experience.
What makes Jetbrains better is this focused and higher quality bundle of features that feels cohesive. What makes jetbrains worse is that this central platform they're developing for is bloated. Everything is slow, takes forever and can lock up.
If Jetbrains just did something to speed up the platform then pretty much IMO it beats anything Vscode has to offer.
A faster/lighter JetBrains IDE would beat everything in VSCode... except for price. CLion and WebStorm and PhpStorm cost money, there's no dedicated Rust IDE yet, and you have to pay money for CLion or (IntelliJ Ultimate) (not Community) to debug Rust programs.
I didn't know about light mode. I'll definitely try it out.
And still, it's really cheap if you consider the amount of work you have to put into configuring other products like VS Code where you end up with an inferior experience. I think it pays off.
Well being free is still a benefit. And it is much faster then then any jetbrains IDE.
I prefer jetbrains like you, but some people like their apps to be really snappy.
> Almost all of their IDE's can for example integrate with the javascript ecosystem.
That’s mainly because they don’t have a Javascript specific editor. I cannot even syntax highlight groovy files in PhpStorm, even though I’m paying for the full pack.
But I think that is literally my only gripe with Jetbrains :)
> That’s mainly because they don’t have a Javascript specific editor.
I guess Webstorm doesn't exist in your book?
I'm pretty sure the reason is that you might want to use the same ide for backend and frontend (e.g. GoLand, PyStorm,...)
IntelliJ IDEA Ultimate + PHP (and other) Plugin doesn't work?
Not to their other ides, just for Intellij.
The plugin infrastructure for VS Code along with excellent first party support for JS/TS has helped it grow very fast. But in languages other than TS the mishmash of plugins of varying quality really degrade the experience. The opinionated approach and strong first party support just makes Jet Brains product much cleaner. I use both a lot.
Indeed, I haven't used VS Code a lot but my few experiences with it were largely figuring out which of the available plugins for a particular function was the "right" one, with all of them sitting at various levels of "working". The IntelliJ, Sublime, and heck even TextMate 2 plugin experience is cleaner in that regard.
I use both. IntelliJ being a paid personal subscription. I like both. But VsCode excels in their remote editing capabilities. Sometimes I work on code that will only compile on a Linux and I am on a Mac. It is not just remote debugging - the whole environment including language server works flawlessly via remote while making you feel like local development.
It is good for two good IDEs to survive. I don’t want one of them to win. There is room for two.
I only wish the opensource development model of plugins (for both IntelliJ and VsCode) doesn’t come to bite us one day with a rogue developer inserting malware. The whole review/reputation system should be like Apple App Store
VS Code Remote Containers is another cool feature. You can develop inside any Docker container locally. This could essentially mirror whatever image you have deployed into Kubernetes, GKE, GCS, etc.
Ref: https://code.visualstudio.com/docs/remote/containers
Worth noting that IntelliJ latest beta has this feature as well. You can remote run/debug in remote docker containers and WSL2 VMs.
This right here is what could get me to switch.
I could theoretically host an IDE on a workstation and develop from anywhere with a browser.
Unfortunately it's not ideal yet - remote editor wouldn't let me touch files not owned by session user (even when I could sudo) and similar issues.
I still mostly just SSH onto a workstation for any of my personal work, but every month or two I'll check out the latest batch of self-hosted remote IDEs. My favorite by far (with caveats -- a few of your favorite extensions have licensing issues, and the mobile UI is garbage) is a fork of VS Code designed for doing exactly that. Check out https://github.com/cdr/code-server.
I went this route with code-server[1]. But later decided against it because some shortcuts don't work in the browser. Also installing and managing code-server on those VMs had started becoming a chore.
I am using remote-ssh instead. Hassle-free and works like charm.
Can't comment on sudo issue because I mostly log in using root.
[1]: https://github.com/cdr/code-server [2]: https://marketplace.visualstudio.com/items?itemName=ms-vscod...
I think that sounds about right. I see vs code as a jack-of-all-trades, master-of-none type of tool. if I want to try something in a new language or just edit some text real quick (I find vs code has better than average support for weird text encodings) but keep a familiar ui, I go with vs code. if I'm going to be doing some more in-depth work, I'll spend the time to learn a purpose-built tool. I mostly write c++ for windows, and I find vs code can't really compete with its big brother (bloated as it is) here.
This sums it up for me. For languages with a dedicated Jetbrains IDE (Java, Ruby, Python, etc) Jetbrains will be better experience hands down.
For everything that doesn’t have the premium experience, I find that just using plugins isn’t as effective.
For example, the experience of using IDEA with the Elixir plugin hasn’t been great despite a lot of development. It seems like it constantly loses the proper SDK if I jump between projects.
The VS Code experience has been a lot better for Elixir though. Just works. The moment Jetbrains releases a dedicated Elixir IDE I’d jump for it though.
Why the assumption that a separate editor needs to be released? IntelliJ with language plugins is better.
I agree. Intellij ultimate is the best polyglot work environment I've ever used. The primary project I work on has Java, kotlin, groovy, python, typescript, js, shell scripts, dockerfiles, various configuration files, etc. Intellij Ultimate handles them all equally well as the more specific language flavors in my experience.
Hadn’t been my experience thus far.
Not sure how many devs code in a single language these days. I go back/forth between Go, Dart, and C++ every day, so using one IDE like VSCode (with the familiar features from extensions to shortcuts to snippets) is a big help.
I do have to maintain libraries in several languages, basically every JetBrains IDE has built-in first-class support for JS/TypeScript + all popular Web file formats irrespective of whatever backend language you're developing in.
For C#, F# & VB I use Rider.
For Dart, Java & Kotlin I use Android Studio, but if I need to do a lot of development with Java/Kotlin I'll bounce to IDEA.
For TypeScript/JS npm projects I use VS Code for small changes, but bounce to WebStorm for longer sessions.
For the Swift package I use Xcode for development & VS Code for git, update docs & run publish scripts. Unfortunately ran into issues trying to build my project with AppCode.
For all other languages (used to develop project templates & packages for https://gist.cafe) I'll use VS Code, but that's mainly because I don't have the IDE installed. If I had to spend more than a couple of days working on a language that JetBrains offers a dedicated IDE for I'll most likely be installing & trying that out, before falling back to VS Code (JetBrains All Products Pack + Unified Toolbox Updates makes this effortless & feasible).
Jetbrains provides plugins for Intellij that support almost every other language they have a "dedicated IDE" for. That's what I do and it supports almost every language I throw at it. The exceptions that I know of are Rider and parts of Android Studio
It’s worth noting you can set up shared settings between every Jetbrains IDE which will sync up all of your keybindings, color schemes, etc.
I've never got it to work reliably between different types of IDEs (Android Studio and Intellij for example)
I think the vast majority of devs work in a single language, at least on a day to day basis.
I wish JetBrains looked exactly into that, and deliver one IDE with above (^^^).
I don’t since you end up with either complex configuration to surface language specific tasks. Having well thought out defaults, tools, etc by separating them out into different IDEs allows for ease of use you couldn’t get with one IDE to rule them all approach. Yes, they sell different IDEs that share a large core but I think the incentives are well aligned for sustainable business focused on developer satisfaction.
Nah. Would have to disagree on this front. These should still work. After all each language/runtime is defined by some underlying template (for example in Visual Studio - .vcxproj for C++, .csproj for C# in .NET, etc.). I don't see reason all of this to work under one Umbreall IDE, even if I have to pay more for it - I'd rather pay for it, than the bundle I'm getting now.
if you use intelliJ ultimate edition you have official plusing for all languages for ex: I work on golang, scala, python and JS using intellij ultimate.
There is an Intellij official plugin for Rust. https://plugins.jetbrains.com/plugin/8182-rust
A somewhat radical rephrasing would be that the IDEA products occupy the space that used to be held by Borland IDE or something like Quick Basic whereas VSCode seems more like an Emacs for the javascript age. (which I find surprisingly fitting, considering how according to The good Parts javascript is just a scheme with curlies)
I agree, I'm a long term IntelliJ polyglot, and I watch people in pair programming or video call refactor in VSCode and I feel sorry for them. Stuff goes sideways badly with dynamic languages, worse, they don't have a grip on it.
Simple stuff like code formatting and structure of files isn't well respected by vscoders <I find>.
IntelliJ got a bad wrap I guess because it all started with Java. I'm glad I had a short gig in Java to discover IntelliJ back then. I really think their software, although getting quite complex now, and the plugins can be a little sketch, is the best IDE out there <unless you're a vim nerd who swears by vim and will die on a sword for it>.
The almost perfect Vim support is why I pay for JetBrains’ AppCode over xCode. Second I simply don’t think I’d be able to code both Java and Swift without having a similar workflow between IDEs. To me the development experience makes the difference between loving or hating the work.
Jetbrains IDEs performance is so abysmal I quickly get annoyed and move to something else. Same with XCode.
I find VSCode to be the most feature rich editor whose speed I can tolerate. VSCode is by no means ideal in terms of resource consumptions or startup speed but the community picked up VSCode for the golden path in the languages I code with (rust, node.js, frontend js) and using other lighter editors is a significant downgrade.
Sublime was incredibly promising but it's not enough feature wise for my experience. I'd literally throw money into a native and more performant/lightweight VSCode.
NB: IDEA performance is improved drastically by giving it more memory. Basically every time someone complains about perf issues with IDEA it's because their heap limit is too low. It can be configured via the help menu.
One of the unfortunate (or fortunate?) design decisions in IDEA is that there's an explicit and user configurable tradeoff between performance and memory usage, but the defaults are far too low. And if it's too low only the most very recent versions can detect this and tell you what to do about it.
There are several projects attempting to develop a native smart editor. For Mac users there is Nova (https://nova.app/) and for the Vim crowd there is Onivim (https://onivim.io/).
I have used neither of them but I find them intriguing, especially when I wait for my VSCode cursor to catch up with my typing.
I switched from VSCode to CLion (IDEA variant) and its Rust plugin because... well... it actually works for complex C++ code. VSCode requires a restart every 10 minutes while working with a moderately complex C++ code base with some complex template logic.
Since I switched I've really come to like the polish and completeness of the thing. I have confidence that it will actually work, and it almost always does. It's fatter than VSCode in some ways (especially RAM) but that's what 16G or more of RAM on a laptop is for.
Even with plugins, VsCode feels like a text editor + syntax highlighter for single files. Jetbrains feels like a project-first language introspection tool. It knows how the languages (Python, Typescript, Rust etc) work, how their functions, data structures, modules etc interact.
I agree with you.
JetBrains IDEs are more thorough, kind of Apple like vertical integration while VS Code is more like Windows: hack everything together.
From a experimental standpoint I highly prefer VS Code, since writing add-ons for JetBrain was too complicated for me in an affordable time. VS Code shines here.
I think that this flexibility really is a different beast. For example, workflow optimization is becoming a thing in software development. In my department, I turned VS Code into a somewhat low-code editor for Web development. This could not have been achieved using JetBrains.
Agree, PHPStorm for me is a productivity monster
I agree, I also think sibling comment about vs code being a generic text editor is a fair point.
I’ve tried to move to vs code several times as I like using the “default” (same reason I use Ubuntu) but webstorm is just better IMO.
There are plenty of quirks when you aren't coloring in the lines in Jetbrains, though. Formatting with Rubocop on save in Rubymine is nearly impossible to do successfully in my attempts.
VS Code is also pretty nice for free. I wouldn’t use it professionally if I had Idea. But for home use, free is pretty ok.
in my experience Intellij looks better if you have coded in Inttellij first (especially Java) and then moved to othet tools.
Intellij offers a lot of custom behaviours that IMO programmers start coding the "Intellij way" (let's call it Intellij muscle memory for lack of a better definition) on the other hand going from vi to Emacs to Sublime to VSCode is less of a problem and people tend to honestly judge strength and weaknesses of each one.
For example magit is so good (for me) that until the magit plugin for VSCode came out I kept an instance of Emacs running only to interact with the git repository.
Intellij git integration in comparison, in my opinion, it's barely usable and generally counter intuitive.
BTW the java plugin bundle for VSCode replicates 95% of the features of Intellij, except for some formatting styles and a few of the refactoring facilities that I could not reproduce, I switched from Intellij to VSCode without looking back. There's even a keyboard bindings plugin for VSCode that perfectly maps IJ keyboard shortcuts.
If only the VSCode java ecosystem was refined as it is today 2 years ago when the project I am working on started, I would have never even downloaded Intellij.
If I had an euro for every time I had to "Invalidate cache and restart" on Intellij to make it recognize some trivial change, I would be rich now.
Having said that: they are different products for different targets.
Intellij has a huge advantage in corporate environments where conformity, uniformity and easily replacing team members are paramount, VSCode is an highly customizable code editor that fits a different use case where each member of the team prefers to customize the working experience as much as possible.
> Intellij git integration in comparison, in my opinion, it's barely usable and generally counter intuitive.
Disagree. I use it all the time. It's sooo nice to have the different changelists. Easy to make changes that I don't want to accidentally commit by putting them on a different changelist (like pointing to a different database). And it can be split even in the same file, much more easily to commit parts like this than using git -p.
> BTW the java plugin bundle for VSCode replicates 95% of the features of Intellij,
If you only look at the textual java code, perhaps. But it lacks the awareness of the rest of the java ecosystem that Intellij provides.
I think the git support used to be worse but now it is pretty great imho.
> But it lacks the awareness of the rest of the java ecosystem that Intellij provides.
Can you give me an example of what you mean?
Something Java accidentally did was be impossible to code without an IDE, in part because of its type system. People wrote really good IDEs for it, aided by the type system. At some point, they realized they could use what they learned and adapt the IDE to other languages.
At least most of our java program is written by us. Compared to visual studio (not vs code) where a wizard will generate thousands of lines of config no one dares to touch again or know how to modify.
It wasn’t accidental. JavaBeans were explicitly designed for “wiring up” UIs in IDEs and are the reason the horrible getters/setters are ubiquitous in Java.
It’s also why NetBeans was a part of Java for so long (is it still?)
The main reason I started using IDEs was automatic imports. Funnily enough, when I went from VSCode to GoLand, one of the things I miss is the import management, which is better in VSCode. But for everything else, especially refactoring, GoLand is better.
> Intellij git integration in comparison, in my opinion, it's barely usable and generally counter intuitive.
You're going to have to explain that one to me. I don't know what part of `ctrl+k`, comment, `ctrl+enter` to commit is difficult. Keeps my hands on the keyboard and head in the code. Time to push? `ctrl+shift+k`. Update? `ctrl+t`.
I have yet to find any IDE that performs as well as IntelliJ et al.
> I don't know what part of `ctrl+k`, comment, `ctrl+enter` to commit is difficult.
who said difficult?
training wheels are not difficukt to use, but that's not how biking actually works.
> I have yet to find any IDE that performs as well as IntelliJ et al.
fortunately, there are different kinds of people.
Forgive me, 'unusable'. Hardly training wheels in any case.
I had the exact same feeling arriving into projects using PyCharm: somehow I could feel PyCharm's influence over the code and ignorance of the non-IDEA tools (e.g. makefile/isort/black, which are usually superior/easier to use than the mouse oriented interface of PyCharm). I even use a phrase for the way they are developed: PyCharm oriented development.
VSCode is better at first, unless you need to work with Python 2.7, where it fails completely: there is no good lsp for it (intellisense fails), and working this problem around by downgrading to ctags does not work either.
The best I can say about them is that both has decent multi cursor implementation.
> in my experience Intellij looks better if you have coded in Inttellij first (especially Java) and then moved to othet tools.
I have started with notepad and moved through vi, Eclipse, VSCode and then IntelliJ. Out of these I used Eclipse and IntelliJ for Java and IntelliJ wins hands down when it comes to the quality of the features, atleast for Java.
> Intellij offers a lot of custom behaviours that IMO programmers start coding the "Intellij way" (let's call it Intellij muscle memory for lack of a better definition) on the other hand going from vi to Emacs to Sublime to VSCode is less of a problem and people tend to honestly judge strength and weaknesses of each one.
Since I didn't start with IntelliJ, I didn't have any baggage of muscle memory etc but the ease of refactoring and the quality of autocomplete/suggestions of refactoring takes it beyond an editor to almost a companion. It doesn't nag and you are free to ignore its suggestions but hell those are pretty good suggestions. I use a few keyboard shortcuts like jumping to definition and checking usage so I don't have any keyboard focused attachment to IntelliJ. Infact I use vi keybindings in both VSCode and IntelliJ.
> Intellij git integration in comparison, in my opinion, it's barely usable and generally counter intuitive.
IntelliJ's git integration is definitely not barely useable and not counter intuitive either (I started with command line git and then worked on IntelliJ). The only gripe I have is that occasionally I want to create a branch from a tag and I need to do that from the command line. Everything else works seamlessly.
> If I had an euro for every time I had to "Invalidate cache and restart" on Intellij to make it recognize some trivial change, I would be rich now.
I've had to do invalidate cache and restart about 2 times in last two years so while it is not a great use of my time when I have to do it, its not a big bother considering it is rare for me.
> Intellij has a huge advantage in corporate environments where conformity, uniformity and easily replacing team members are paramount, VSCode is an highly customizable code editor that fits a different use case where each member of the team prefers to customize the working experience as much as possible.
In my team, the average period folks have been with the firm is 3 years so easily replacing people is not a priority (because they are not leaving left, right and center). Also, I'm not even sure if that makes any difference, because its not like we are coding style nazis carrying out IntelliJ dictated formatting (we use Sonarlint for linting and only expect people to code in a manner that is easy to understand and maintain). Almost all team members have used Eclipse / VSCode and atleast for Java, after they used IntelliJ, they haven't gone back to either.
> Almost all team members have used Eclipse / VSCode and atleast for Java, after they used IntelliJ, they haven't gone back to either.
I was also using it because my team was using it and it holds value to share a screen and watch the same thing or when debugging an issue replicating the same exact steps, having different tools can make it harder.
My point is that when you have a stable setup any setup is good if it's good for you, Intellij is better on some things but worse on other that I personally value more
the git integration for example, which works backwards compared to how git works: stage/commit/push
in Intellij I am presented with all the tracked files already staged, the commit message box is already filled with the last one, files are showed as a tree instead of the classic list with paths and I have to look for untracked files that are collapsed by default.
Magit is much simpler and intuitive IMO.
> I've had to do invalidate cache and restart about 2 times in last two years so while it is not a great use of my time when I have to do it, its not a big bother considering it is rare for me.
I wish it was like that for me.
Or probably I am simply doing something wrong but no amount of Google fu helped me to avoid the issue, the only thing that works is pushing the damned "invalidate and restart" button (and sometimes running mvn idea:idea from the command line, but I gather it is obsolete and not actively supported anymore)
>thanks in large part to the productivity of JS + Web renderer
Oh heavens no. I can't think of a single program written with "web technologies" that is in the same league of complexity as proper desktop applications. And IDEA is already enough of a resource hog; let's not make things worse!
tbh, i like the polish of visual studio over vscode. or atom even.