Hacker News new | past | comments | ask | show | jobs | submit login
Fleet, a Lightweight IDE from JetBrains (jetbrains.com)
718 points by bmc7505 56 days ago | hide | past | favorite | 413 comments

There’s a real opportunity here for JB.

If they’re prepared to give this away for free, and make money off of upselling folk on hosted remote dev envs (or licensing the server side to cloud providers) then this could actually compete with vscode.

They basically don’t have any other product that is competitive with vscode.

…but, I’m skeptical they’re willing to make the jump to freemium based on their other SAS product offerings which have… hm… not been hugely lucrative.

I've used Jetbrains products for a long time, both as a student, and later professionally.

Jetbrains products are free for students, and paid for professional use. In my opinion, the pricing of the product is spot on. My company pays about ~200 euro per seat per year, which is a good price for the quality tooling you get.

In my experience, VSCode is not competitive with Jetbrains products. Their products come with support and good documentation. The proposition is clear and you get exactly what you pay for.

So please JetBrains, do not jump on the freemium bandwagon. Just have us pay for a professional tool without constantly being pushed to some SaaS product offering.

If yout think about it, Jetbrains is more a counter part to Visual Studio then VSCode.

Vscode was more a advanced text editor to compete with atom. But I don`t see it losing it`s grip of the market anytime soon. Theres lot of tools that use vscode as base, that will be difficult for them to convert, like platformio IDE for example.

To be fair the same could be said about Sublime Text, yet here we are.

If JetBrains releases a free tool that competes well with VSC on core features, I don’t see why the community wouldn’t adopt it.

VSC is far from perfection, it’s only a step up from ST in that it offers a few more tools by default.

Platformio does already have a quite good plugin for CLion.

Tools are also free for open-source development: https://www.jetbrains.com/opensource/

And for educational use (teachers) as well.

So I don't see a reason to jump on the freemium bandwagon. They offer a lot for free already.

I wouldn’t call this “free for open-source development”. It’s free for open-source development as long as the developer receives no money. This would literally be stricter than Visual Studio Community except that last I checked the latter refused to work without an online account for more than a month.

Needless to say, JetBrains are free to license and price their stuff however they want. But omitting this particular caveat to “free for open source” when important community-led projects regularly struggle to support themselves leaves a bad taste in my mouth. (The same kind of condition was, for example, used to chase curl off the free tier of Travis CI[1].) To their partial credit, JetBrains themselves only make this omission in the first sentence on the linked page and add “non-commercial” in the second.

[1]: https://github.com/curl/curl/issues/7150

That is a good point. My perspective was too pessimitic as never having real money from OSS projects in general.

My company was a straight up full JetBrains shop. To the best of my knowledge we didn't have the need for any support from JetBrains at all. Do you mind sharing which aspect of support were you refering to?

> Jetbrains products are free for students, and paid for professional use. In my opinion, the pricing of the product is spot on. My company pays about ~200 euro per seat per year, which is a good price for the quality tooling you get.

well, they're in violation of the licence if thats true. The 150€/250€ licence is for private people, companies have to pay 500€/650€.

/edit: i guess non of the people that are responding to me can read. he specifically said that the company is paying for that and the price of non-intellij licences don't overlap with 200€ on any tier I can see.

That’s the first year pricing, it goes down significantly by the third year. A larger company could potentially negotiate a discount on top of that. Each of their applications can also be subscribed to individualy as well, some for around 200 euros.

As far as I know you are allowed to use the individual license commercially [0], it is just that you cannot reimburse it from a company. I wonder where the line is and if you are allowed to use the individual license as a freelancer.

[0]: https://www.jetbrains.com/store/comparison.html#LicenseCompa...


You can use it for commercial projects. The intent, though, is that only you can use that license of the product. So with my Jetbrains purchase I can work on personal projects at home, or (if corporate IT allows it, apparently they do here) install it on my office computer and work on corporate projects. But I cannot install it on a laptop at the office and walk away, letting others use that license.

>I wonder where the line is and if you are allowed to use the individual license as a freelancer.

You are.

> Purpose of use: General commercial

It just can't be reimbursed.

You're missing something: larger companies can negotiate significant discounts when they buy in bulk. This applies even more for a product with negligible marginal cost.

Unless they're only paying for a single product ( vs the all products pack? )

no, thats was why i wrote two numbers each; completely spelled out:

  private person: 150€ intellij only, 250 € all products
  corporation: 500 € intellij only, 650€ all products 

They never said IntelliJ. Pycharm is $199 USD for the first year for a corporation.

They said Jetbrains, not IntelliJ.

There are other products that are $199 USD for the first year.

JetBrains are not opposed to giving IDEs away & upselling which they're already doing for their Intelli IDEA Community [1] and PyCharm Community IDEs [2].

Since this is a direct answer to VS Code's dominance, I expect they'll do something similar and have a free version that can can be run on commercial hosting options, e.g. Space, Cloud & Docker.

[1] https://www.jetbrains.com/idea/download/

[2] https://www.jetbrains.com/pycharm/download/

And you can regularly use their IDEs for free through the Early Access Program. No license required.

I love VS code, but insisting that its parsing is even nearly as good as anything from Jetbrains is laughable. Working with Rust in VS code is no where near as good as IntelliJ for example, and their Javascript `intellisense` is best in class.

Agreed. Working with rust in e.g. CLion (or even the free PyCharm CE with Rust plug-in) beats vscode by a large margin, it's nowhere near comparable, especially when working with larger projects often requiring major refactoring etc.

Which Rust language server did you use?

In vscode? Why RLS? rust-analyzer of course

Some people install RLS because they haven't heard about rust-analyzer. Anyway, debugging is out of scope, but try filing issues for any other problems you run into.

Having used IntelliJ for a long time I would agree in all cases except rust and flutter. Flutter IntelliJ is not bad but rust analyser in vs code is miles ahead of IntelliJ rust.

Have you tried using rust-analyzer with VS Code? I find it to be a little rough around the edges but mostly pretty great. I used the Rust plugin for IntelliJ a couple of years ago and remembered being disappointed.

I've never used IDEA and friends for JavaScript. Are they not using the LSP?

They've historically done a lot of things on their own for JS. So perhaps VS Code + TS language server isn't quite on par with their JS tooling (which works a lot better with TypeScript type definitions, though, so perhaps it's just mostly the same as well).

However, what I personally hated was that there's so many squiggly underlined things ... in red, yellow, green and what other colors, each of which (regardless of color) could be either ignored or an actual error. Granted, that's how easy it is to properly check JS code for whether it does something sensible, but I didn't really find it helpful, especially because issue categorization and accuracy was so random.

> Granted, that's how easy it is to properly check JS code for whether it does something sensible

> especially because issue categorization and accuracy was so random

Stockholm syndrome is strong with this one. =)

the reason you didn't find the IDE suggestions helpful is exactly because of how difficult it is to reason about dynamic language code. the tooling is basically just guessing and expecting you to deal with the noise on the off chance it found something.

I've ended up deciding for myself to never write JS and instead using TypeScript. So far it's working well. I just couldn't really see all that random guessing by the IDE as an advantage. If the only way to figure out whether the code is broken is to run it, then it's pointless to guess potential problems on every single expression because dealing with those takes more time than just testing the code – or results in the developer completely ignoring all diagnostics.

Which Rust language server did you use in Code?

I don't see why they won't go the freemium route with Fleet. You can see it in IntelliJ already - CE is more than good enough for almost everything you want to do, but if you want tighter integration with Spring or other web frameworks, you can spring (pun intended) for Ultimate. Fleet could be like that - everything is baseline "good" with a bunch of first-party paid extensions that add a bunch of powerful capabilities - sort of like ReSharper for VS.

> CE is more than good enough for almost everything you want to do

...as long as you use Java (or another JVM langue) to do it. Unfortunately they don't offer a Community Edition for most of their other IDEs (PHPStorm, GoLand, CLion etc. etc.), although those are mostly based on open source languages too.

> They basically don’t have any other product that is competitive with vscode.

All their products are very competetive, even when paid. A license for any professional developer is a no brainer (in my opinion anyway).

If they want me to pay more for a next gen Jetbrains IDE I’d do so without hesitation.

I really hope it's free too. Otherwise it makes no sense. As a customer paying for full IDE(Rider) I won't kneecap myself by paying for vscode alternative, even though I really hate working in vscode. If they make it free, they could get a big chunk of the market, especially if they actually provide it with IntelliJ level of autocomplete, refactorings, multicursor support etc. They have quite a lot of money from regular IDEs, if they can release this for free and monetize cloud support, I think they'll be fine. It probably won't take away money from fully fledged IDE users anyway, but I'd love to have IntelliJ-vscode alternative.

>If they make it free, they could get a big chunk of the market, especially if they actually provide it with IntelliJ level of autocomplete, refactorings, multicursor support etc.

If they did that, then why would anyone buy IntelliJ?

I understand why Microsoft came out with VSCode. They didn't have anything to offer for developers who weren't already bought into the Windows/.Net stack. VSCode was an effort to reach out to those developers and tell them, "Hey, even if you don't use Windows, even if you've never touched C#, we still have something to offer you."

JetBrains isn't in that position. Their IDEs are cross-platform (though, admittedly, some platforms are more equal than others). Moreover, their IDEs are all they have. They're not like Microsoft, where sacrificing some Visual Studio sales can be justified as a way of attracting developers to the broader platform.

I really don't understand the product strategy here. Either they keep Fleet cut down, disadvantaging it in comparisons against VSCode, or they make it full-featured, and cannibalize IntelliJ license renewals.

What's the long-term play that I'm missing?

IntelliJ is clunky as ef, and slow as hell. It's really powerful but feels really ancient, and isn't native on anything. I hate Java. I hope this is their attempt to completely bypass the old platform and create a new product from scratch, starting with vscode parity but eventually reaching the power of IntelliJ and replacing it wholesale.

I don't know if that's their actual intent, but I can hope.

You hate Java but are okay with the DOM as an editor…

What does "DOM as editor" mean? As in the HTML DOM and manipulating it directly? How is that an editor/IDE? Maybe I'm misunderstanding you.

My only experience with Java is as an user, and it's never been positive. Whether it's the applets of yore or the modern Java apps, there's always performance, memory, JRE issues and terrible, second-rate UIs. Maybe the language itself is beautiful, I wouldn't know, but the user experience is terrible.

Java does trade off memory for better performance (and power saving!), but it is an extremely fast platform with state of the art GCs and JIT compilers and one of the biggest open-source ecosystems. It’s not the best for desktop UIs but even a decade old GUI will work just fine on the latest edition (seriously, I found some random algorithm visualizer in a jar from God knows where and it just ran perfectly). And it’s not like there is one ultimate solution for GUIs unfortunately.

OP refers to VSCode being built on web stack. But AFAIK there is little to none actual DOM manipulations after initial setup since everything is rendered on canvas.

at that point why don't they just use native + skia ? Seems weird to build a web based editor to then just use canvas.

At a guess, they're probably sticking with it because it enables Javascript/Typescript as an interfacing language for plugins which, given the language's popularity and cross-platform nature, is probably part of the reason the plugin catalogue is so large.

I have this dream that eventually VSCode will just be React Native in disguise.

Second rate UI? The IntelliJ UI is pretty great, it's very well optimized and has a billion features. I don't think any new IDE would look significantly different. There are only so many ways to do buttons, scroll bars, trees and editors.

I don't actually mean IntelliJ in particular, but Java having its own UI kit. Nothing looks or feels native on any platform. I've heard something about a graphical widget kit that emulates native on Java, but as far as I can tell IntelliJ (and most Java apps I've seen) don't use it.

Though since you mentioned IntelliJ, I find its UI pretty hectic too, a hodgepodge of 90s-style MDI and modern tabs and split panes. Some of the most common patterns (going between the terminal, code editor, debugger, git, npm, and DB browser) requires navigating between like seven different places in no logical arrangement.

Why is npm a tab bar in the lower left, the actual npm list in a pane above it, git/terminal debugger on the bottom, the code editor in the upper right, the db browser in the upper right sidebar (which isn't even visible by default), the db query itself in a tab mixed with the code editor, the debugger output in the bottom but the button to start it in the top toolbar...

I can never find the features easily because I don't know which pane or tab group it's supposed to be in. In something like VScode, the features are categorized in a hierarchy and arranged in layers in the left sidebar in a sensical drill-down pattern. Xcode is visually cleaner too.

It's not just about the presentation of UI widgets (scroll bars, etc.) but how they're arranged in terms of information architecture, discoverability, cognitive load, diving down, etc. Everything is a "module" of equal value competing for screen real estate and together it is pretty visually overwhelming, especially to new users. More important things like the terminal or debugger shouldn't have the same level of prominence as the less important things (profiler, R jobs). Not all features get used with the same frequency, or in the same contexts, but IntelliJ organizes them all pretty flat.

That's just me, though. It's like a lesser version of the MS Office "toolbars vs ribbon" debate. If Jetbrains actually tried to overhaul their UX, they'd probably see a mass exodus of wizened old beards.

I think the criticisms of layouts are fair. WRT native UI, there's SWT which was used by Jetbrain's primary competitor Eclipse, but obviously users didn't care that the widgets were native because in the end IntelliJ has a much higher market share.

This is probably because not many apps really use native widgets anymore on any platform. It's not even clear what the native UI toolkit on Windows is anymore, due to the numerous aborted attempts to replace Win32 that didn't quite take off.

The Swing widgets IntelliJ uses aren't any worse than native widgets and some are actually much better, for example, any tree view in IntelliJ supports excellent typeahead search, many text inputs are in fact full blown code editors and so on. I don't feel I'm missing anything by them not being Cocoa.

I completely agree with the UI criticisms. I love JetBrains, but brrr. On a fresh install, it's a throwback, and not in a good way.

Thankfully the Material UI extension exists. With this enabled, it's actually one of the best looking pieces of software I use. It still ignores system themes, but the colors are customizable and the UI elements look fresh and slick.

Hey, thanks! That does look a lot better. Still doesn't fix the layout, but at least it looks like Old Android instead of Windows 3.1... a big improvement!

> I can never find the features easily because I don't know which pane or tab group it's supposed to be in.

In an attempt to be helpful, in case you don't know about it, the shortcut ctrl-shift-a brings up a quick search box of every action, pane, or other ui in IntelliJ. You don't have to drill down to get places, you can just jump there directly.

This is my preferred way to navigate too. I was already in the habit from using Sublime Text, and it's actually not too far off from the Spacemacs UI either.

That does help, thank you! I use the search bar all the time (shift shift shift), but didn't realize "Actions" meant IntelliJ commands... thought they were referring to Github-like macros. Damn you, ambiguous technobabble!

> Damn you, ambiguous technobabble!

Well, you are the technobabbler... :-P

I believe they are referring to using vscode, which is based on Electron. Thus, instead of native code, it’s HTML based (although, not necessarily DOM based).

I have both. VSCode is noticeably faster. How do you know jetbrains new editor isn't a "Dom editor"?

I kinda hope JB built it as a native editor and just uses a scripting language for plugins.

Because VSCode is a fancy text editor, not a full-blown IDE like intellij. Even with myriads of extensions, the gap is real between the two.

> How do you know jetbrains new editor isn't a "Dom editor"?

> Because VSCode is a fancy text editor, not a full-blown IDE.

What does that have anything to respond to the question?

I kept seeing people making this claim as if there is a definition of what an IDE is. VSC has project-wide code anyalysis and step debug. It may not be a good IDE in YOUR opinion but tell me what definition of IDE are you using?

In the comments on the article someone from JetBrains said it was coded in Kotlin and Rust.

> If they did that, then why would anyone buy IntelliJ?

I think the general idea is that it's a lightweight editor(like vscode) that stays lightweight with as many features as it can from IntelliJ. If you work on decently sized project you'll still want to use full IDE. If you want to force yourself to work on a big project with vscode, nothing is stopping you. But would you realistically switch from IntelliJ to vscode? Probably not, even though it technically supports (almost?) everything you need.

In my case f.e. I'll continue to work using Rider, but I'd like to be able to open some minor html/js/other projects(like our Azure B2C Templates, or my Azure DevOps extension project which is mostly powershell) in something smaller. Currently I can do that using vscode, but I'm not a big fan of vscode itself so it's usually just annoying.

>But would you realistically switch from IntelliJ to vscode?

No, of course not. VSCode's support for Java is a hot mess, and that doesn't look to be changing any time soon.

But would I switch from PyCharm to VSCode? I made that exact switch at work a little while ago and I haven't looked back.

RedHat seems to be working pretty hard to make that experience better. For a long time, there has been a need to be "somewhere in between". While Eclipse, Netbeans and IntelliJ have been all about the entire Java EE/Application Server experience. Some folks didn't need all that just to write a few Spring Boot microservices. Sure the IntelliJ Maven task tab makes things super easy. Some folks are okay with typing out those commands on the CLI. So, VSCode with syntax highlighting, auto-imports, and some smart completion is enough to get the job done.

How is VS Codes support for Java a hot mess? For the most part as long as you use maven or gradle it works perfectly fine.

I think polyglot IDEs like VSCode serve a different niche to PyCharm, CLion etc. In a professional context, you usually end up doing 80% of your coding in one language, so it only makes sense to use an editor that semantically understands the language to amplify your coding. One common use case where I resort to IntelliJ tools is refactoring methods/classes/variables, since it feels so much safer.

My personal take is that IntelliJ stands to gain a lot of developer goodwill and gets the proverbial foot in the door by putting Fleet at the forefront.

I mean, even if a lot of licenses get cannibalized, they could always resort to selling user data. I don't think IntelliJ is that sort of company though, they seem pretty ethical from what I know about them.

> In a professional context, you usually end up doing 80% of your coding in one language, so it only makes sense to use an editor that semantically understands the language to amplify your coding.

Another consequence of that point is that VSCode is this editor if your main language is TypeScript. At work we use VSCode for JS/TS, and Visual Studio for C#/C++ on Windows.

Fleet will likely become part of the "All Products Pack" which at this point costs $149 annually pre-tax (personal license), with special add-on integrations for several targeted cloud environments being rental add-ons.

The personal license All-Products-Pack is great. I'm prevented by the license from ever expensing it but I spend every day immersed in PyCharm, IntelliJ IDEA, DataGrip, and soon GoLand. I can open as many simultaneous copies as I need on personal and work computers, Windows, macOS, and Linux.

Given what developers are paid, I’m perfectly happy to pay for it myself to save myself the hassle of dealing with procurement.

> What's the long-term play that I'm missing?

Bet: They’re building the core for all of their future products.

Start free, gain momentum, have “pro” addons, slowly start offering products like WebStorm but built on top of Fleet.

> What's the long-term play that I'm missing?

Sell Fleet only as part of their all product pack? Make Fleet the new product for $15/month that can gobble up huge chunks of VS code developers?

VSCode origins precede that idea, it was born as the Monaco editor for editing in Azure, before it came into the desktop, also the main architect behind it is Erich Gamma.


Maybe they want to sell more Space licences.

>If they make it free, they could get a big chunk of the market

If they make it free they could get a big chunk of nothing.

I've never understood programmers willingness to devalue their own trade like this.

They could compete with VSCode, but what would be their competitive advantage? Being a pale imitation of VSCode with fewer features and tied to an online offering that has less mindshare than Github doesn't seem to me like it's a winning strategy.

They managed to sell in the past a C# plugin for Visual Studio, so people paid money on Visual Studio and this company convinced them to pay more and buy a plugin for a Microsoft language and a Microsoft IDE, people paid because it is a great product (for their projects). IMO they for sure can improve on VS Code, I bet they could sell you plugins better then MS can create and I think this is because when you are closer to your user you focus on the important stuff and no dude with a vision pushes things into a shitty direction.

From my daily experience I can oopen a file and see what parts of the code were created in VS Studio or other basic editors, they have linting errors all over the place, I am not sure if the defaults are shit or if the linters are shit but I can confirm I can tell what (JavaScript)code was not made with a good IDE.

I worked in Visual Stduio, Eclipse ,Intellij, QtCreator, and VS Code , and I am paying for Intellij because it makes me more productive , this might not apply on your specific project or your personal workflow.

P.S. I still use my terminal tools like cat,tail,grep, diff so I am not a guy that needs pretty GUIs and I run an old Kubuntu LTS so I am not the person that looks at software at some identity badge.

When teammates ask me why my VS setup feels so fast compared with theirs, my answer is quite simple, I don't use resharper.

But similarly my nano feels faster then youur VS setup, the important part is if how productive you are. Sometimes is a good idea to see what makes your IDE or plugins slow, for web dev you can probably improve your IDE performance but telling it to ignore certain files and folders like the node_modules folder or the .min.js files.

Though the conclusion is that ReSharper slowness and price is worth it because Microsoft IDE is substandard and for some reason all the MS billions can't find a few competent devs and a competent manager to handle the problem( they are probably still fighting on merging the GUIs or how to name their garbage APIs in Azure ... yeah I am working with some backend MS APIs and their are garbage like created by teams that hate each other)

Actually the conclusion is that most people that advocate for Resharper aren't aware of VS Rosylin plugins, and most of them are like those that buy SLRs, but actually only need the features of a compact camera, but it feels good to carry that SLR around.

I did not work with .Net and Windows in a long time so maybe this time Microsoft done something good, from my experience MS does all the evil/stupid stuff first and only when forced they attempt to do a good job.

Question if this cool plugin is so good and is from Microsoft is it bundled in Visual studio or easy to install from a GUI or is still a work in progress and you need to track the git master branch?

I still hate MS they failed to promote C# and .Net, if for example Silverlight would ahve been open sourced and made cross platform then most of the SPA could have been crated today with a decent language with a decent standard library , then for smple web pages and forms we would add some JS here and there. But MS had to try to make the shit Windows only then kill it and embrace the JS/node garbage

> Actually the conclusion is ...

Don't forget the time component. A lot of c# shops standardized on Visual Studio with resharper when a lot of alternatives either didn't exist or were notably worse (at least in function; resharper was always terribly slow iirc)

That's mostly Visual Studio's problem with multithreading, process communication, and 32-bit memory size limitations.

Rider (basically Intellij with Resharper plugins) is incredibly fast and productive in comparison, and VS 2022 is finally catching up with the move to 64-bit.

Why should I bother to pay for an IDE that only has a subset of the features of IDE developed by the platform owner?

It's just as many, if not more features, and overall more productive unless you need something only VS can do (like some advanced debugging). Only VS2022 can finally match some of the speed.

You either already know the difference between VS+Resharper and Rider and are just looking to argue, or you don't and you're missing what it can actually do.

Try to do Windows development with Rider then show us how it tops VS on its turf.

Here are some basic examples to get you going,

- mixed language debugging across any .NET language and C++

- development of MFC, ATL, COM, WinRT components

- integration of said components with .NET code

- hot code reloading on mixed .NET/C++ code

- GPGPU debugging

- integration of SharePoint, Dynamic, Sitecore, Office, SQL Server plugins

- code navigation across binary modules, include native ones

- code rewriting mocking framework (Fakes)

A world where ReSharper hadn't existed would have the same old craptastic minimal refactoring tools that VS 2013 had. I'm glad JetBrains is pushing Microsoft to improve

Borland taught me to always bet on the platform owner instead of playing catch-up with third parties.

I never bothered with paying for extra plugins and know Visual Studio since version 5.

It will use the same intelligence as what drives intellij today, which can be turned on for the occasional project, yet it will start fast enough for opening random files with syntax highlighting, something I personally use vscode for.

Also, what may not have been mentioned, that intelligence can run both locally, as well as hosted somewhere else, eg. on a much more powerful server computer.

> They basically don’t have any other product that is competitive with vscode.

All their IDEs are if competitive means "they cost a little bit but they actually work and aren't loaded with invasive telemetry."

Where do you come up with such a ludicrous statement? Try using VS code for python development and then use pycharm before you sit here and tell me that they don't have any other product that is competitive with VS code.

Not to mention they have an excellent multi database system management tool called data grip. But you go on and keep using VS code to manage your databases. Have fun with that.

My company used to have JetBrains toolkit for every developer and we trialed VSCode for a year. There was no noticeable difference in productivity. We then switched to VScode and canceled all subscriptions to JetBrains because we have no more reason to pay JetBrains anymore.

> If they’re prepared to give this away for free

That was asked more than once in the comments but got no reply.

Whenever I try to use something other than IntelliJ (generally VS Code) I'm always struck by how awful the code completion and auto-imports are. I really hope we can get a lightweight editor with those two functions working properly.

However, I don't see how you can do either of those features well without a lot of indexing of the codebase. And indexing is a major reason why IntelliJ so so clunky.

With same languages? Whenever I stray away from C#/Java world, I am amazed how bad the IDE experience is for other languages, but that's because most other languages have features which don't play well with IDEs (dynamic typing, templates, macros, anything compile time).

IntelliJ has much superior code completion even for dynamic languages such as Python and Clojure. I seem to recall having tested Javascript too, but I could be misremembering there as its been a while since I didn't use use Typescript.

VS Code is actually pretty good at Typescript though, so I could be wrong about JS.

I don't think you are wrong. I used IntelliJ at my previous employeer because VS Code sucked for straight JS.

I will have to admit that VS Code remote features are straight up amazing.

Webstorm is amazing for typescript. I have to use VSCode for work and I'm easily 20% slower because of it.

I agree (even though it pains me to). I've thought about it a lot and I think it's because in the Java world, unlike most other worlds, the IDE is basically mandatory. I've worked in a few different java shops and the project was built around the IDE and required it.

I think you have it backwards. Java is actually very well designed in many ways, and that means that it's easy to make really good IDEs so they are popular.

In contrast it's really hard to make good C++ code intelligence features. For many many years Microsoft was the only one that had done it (as far as I know).

It's been a little while since I've worked with C++ professionally, but the project was cross platform so I'm not sure Windows and Visual Studio was ever a feasible option.

Most of us were using Xcode, but at some point I discovered CLion and it felt like a big step up. Having proper CMake integration instead of needing to regenerate Xcode projects really helped, plus I've often found Xcode to be quite unresponsive and never really liked the way it tries to be different with stuff like code navigation (recent versions seem to be better with how they handle tabs etc.)

But CLion is relatively recent. Quite possibly VS was the only IDE that did that stuff well for quite some time.

Not sure what time scale you had in mind with "many many years" but the commercial third-party extension Visual Assist has been the only serious option for robust and scalable C++ code navigation (and related features) in Visual Studio since the late 1990s, early 2000s until the present day. Visual Studio's built-in Intellisense has been trying to play catch up (and has somewhat closed the gap), not the other way around. There were also widely used products like Source Insight focusing on offline whole-program code analysis and navigation, but they weren't really designed for integrated development.

That said, your thesis about the relative difficulty of doing this for C++ vs Java seems hard to argue against, and the rapid, continuous growth in C++'s surface area and complexity since C++11 surely hasn't helped.

Auto import and code completion play nicely with IntelliJ for both Go and Rust IME.

Rust-analyzer has been improving massively in the last year or two and it's auto-import and code completion are pretty rock solid now IMO.

I came to VSCode from TextMate, so my expectations were minimal, but I can’t think of anything more to wish for from its completion and auto-imports. I’m generally using it for TypeScript which is probably its strongest use case. But even untyped JavaScript is pretty good: local type inference is alright, JSDoc types nearly on par with TS, automatic type acquisition for dependencies is better than manual installation in TS.

That said, it’s been years since I tried IntelliJ. Am I missing some significant productivity improvement, for TS/JS development?

Given that VSCode is built in TypeScript, and it existed primarily for JS/TS in the beginning this is expected. You don't get whole lot of more from JetBrains/Fleet in that case.

Usually though JetBrains' editor is used by other languages, which don't yet have as good open language servers, like Java/Kotlin/Scala/C#...

A colleague of mine and I tried to asses VS Code vs. Intellij IDEA for vanilla JS & Typescript + Vue. Him a heavy VS user, me more at home with Intellij. In both cases we concluded Intellij proved superior, though both were usable.

Even though I wouldn't classify it as "awful", I do agree with the sentiment. Whenever I use Clion, I feel I need to have vscode also on the same project to mitigate the shortcomings of it's code completion and even search.

Clion's support for CMake is particularly enfuriating, with it's propensity to actively replate a target's name with filenames, even if they do not match in caps, which makes absolutely no sense at all and feels it is doing it's best to get in the way and sabotage your productivity.

Counter argument, I tried c/cpp/cmake development in vscode, but got so fed up with breaking plugins. Configuring… fixing new config options for plugins… Or spell checkersuggesting to rename functions i call… or duplicate shortcuts from plugins…

That I bought clion and got stuff up and running for the biggest part in minutes. I am a looong time pycharm user though. Cmake integration is great for my projects. Embedded mostly.

IDE’s are very personal tools. Im an ide guy, always have been. Do use vscode occasionally though, it is great to test new prpgramming languages, or open big files pycharm chokes on.

I have a bit of an off-topic question for you: I'm developing a single app for Windows in 3 languages: C#, C++, and Typescript using Visual Studio and I get excellent autocomplete/integration support. However I'm looking towards porting it to Linux, and I'm looking at some other IDE. Is there something that can handle building/debugging/autocomplete for these 3 that's not VS?

Try moving to VSCode on Windows, see if you can re-create your workflow there using plugins.

Then, if you are successful, port your workflow to VSCode running in Linux.

Perhaps also intellij with the language specific plugins? Separately, all these languages work fine. What’s the build tool?

Msbuild haha. I use it to build the C++ and C# parts, and to trigger npm build on the typescript part. For C#, I'm perfectly happy with it, however for C++ I'm looking for something cross-platform. CMake maybe? Is there something better?

Have you tried a C/C++ lsp server like https://github.com/MaskRay/ccls? Works with vscode/whatever you want, and just targets your Makefile (using bear to generate the dependency graph).

> Have you tried a C/C++ lsp server like https://github.com/MaskRay/ccls?

I never tried it and to me that's not acceptable or desirable. I want an IDE/text editor that works, and not adopt yet another tool that needs maintenance and configuration and attention.

It takes about 5 minutes to set up. It's easier than Clion to use imo and works with far more project types, even the Linux kernel. But if your barrier to using a tool is it can't require any setup or configuration... well I can't help you there.

the language servers do the indexing now. intelliJ does not use them?

I just hope the remote development features will actually work adequately in this.

They tried to get that stuff working with existing IDEs multiple times [0][1][2][3], but they are all broken in their unique ways.

Whenever I see them announce something new in the remote development space I always jump in right away and try it out, discover it is broken too, and then go back to using VS Code remote dev features.

For local dev I still use JB stuff, but it is simply too broken and awkward for remote.

[0] https://www.jetbrains.com/help/pycharm/configuring-remote-in...

[1] https://lp.jetbrains.com/projector/

[2] https://blog.jetbrains.com/blog/2021/11/29/introducing-remot...

[3] https://www.jetbrains.com/code-with-me/

Agree. I paid for PyCharm on the basis that a) it all just worked in the community edition, and b) it offered remote development in professional (this was a main selling point over community).

I quickly discovered that b) was false (or extremely oversold) compared to VSCode and switched back, couldn't get PyCharm working remotely and saw the loooong-standing issues on the bug tracker that indicated it wasn't a priority despite the marketing.

I still admire the plug-in-and-go-ability of PyCharm, but no longer trust it to fork out money for features which are clearly not what they are implied to be.

Perhaps the latter has changed; I'll await the reviews.

This is also the main reason I switched from PyCharm to VS Code at the start of the pandemic, which I think was really a really fortunate circumstance for the latter IDE. Even though PyCharm is a superior IDE, its remote development features were really broken, while VS Code nailed it.

I think all from posted by you remote dev envs fill other use-case and niche.

- "Code with me" is a Zoom/Google Meet with a code sharing.

- "Projector" provides Web view alongside of typical desktop-app IDE sharing. If you need example, there was a nice submission week ago that touches that topic [0].

- "Editing by SSH" - way another niche. Connect via SSH to remote machine, edit and synchronize your changes over the SSH. Nothing new, I guess Python and PHP devs love to use it. I have been recently using it, while I was tinkering with Raspberry Pi.

- "Remote development" or some kind "developer-machine-as-a-service" idea (JetBrains Space / Gateway), which is close to Projector, with a difference the machines are rented or managed by the company (burst usage). Ironically, it is nice idea even for small companies (<150), where employees were given low-spec PCs or some cheapest M1 laptops. All problems with CPU compatibility or other limitations to resources are solved by using a beefy remote machine.

For a person who used various way of remote coding in my life. I think all of those are complementary and I don't see any burden there. I hope they will keep and improve them over next years.

[0]: https://news.ycombinator.com/item?id=29304667

Out of curiosity, what doesn't work for you with Code With Me? The only thing I can think of is that the "client" also needs to have Code With Me installed, instead of a possible browser integration like VSCode has.

Code With Me is amazing except when it doesn’t completely work it doesn’t work at all.

Command + click doesn’t always work if there’s a lot of latency, many times the „follow other developer“ feature turns off randomly, often the search breaks or doesn’t work at all, the video & audio inside the IDE causes lag and massive amounts of load (so much that many of our devs switched to discord).

For what it’s worth it works mostly great when the developers pairing together are in the same country, but it’s pretty bad when i.e. a developer from Berlin, Germany pairs with one from Columbus, Ohio. So I guess it’s a latency problem.

Ah got it, that indeed does sound like it needs some work still. Thanks for the reply!

Code with Me working or not is completely a tossup. I ended up paying for another service completely despite me having access to Code with me because it was never reliable. Me and the other user were having issues with it connecting 1/3 times and that's never fun having to waste time fixing a tool.

OUCH! could you please specify in what region and when have you experienced such a terrible connection?

My coworker was in North Africa and I was in France.

Code with me works okay. Far better than "Zoom share desktop".

Wish they offered complete package - remote machines, deploy pipelines, actual compute, all enveloped with best practices.

Huh, just the other day i was talking about how JetBrains products succeed in being some of the best IDEs around, but fail at the use case of just wanting to edit text files, where Notepad++, Visual Studio Code, Emacs, Sublime and vim could all be preferable to it: https://news.ycombinator.com/item?id=29362960

And then JetBrains come out with this... That's certainly pleasant to see!

thats funny I've always found jetbrains IDE to be error ridden annoyances where I end up spending more time dealing with problems the IDE has caused than developing software.

I think that's not the typical experience. I've certainly gotten occasional errors, but for me it's been a solid and reliable set of tools over the years. I started using it for Java, and have since used their Ruby, Python, and webdev versions happily for many thousands of hours.

it was primarily android and gradle issues honestly within its jetbrains IDE.

jetbrains itself has performance issues, and you need to muck around too much to get them working properly.

the JVM also causes issues resulting it having to tune the environment params to get decent performance. JB makes tons of assumptions and attempts to be helpful in ways that just are not; precompiling automatically, running massive indexing jobs causing the machine to bog down, assuming it has the right to modify your environment.

these are all things I just do not want to think about when in essence I'm navigating directories and editing files with fancy hover tooltips.

the standalone versions are okay usually depends on the language. I just want an editor with code linting regardless of the language.

vscode in that respect has been a god send. install language server and you're done. performance is generally good and the background tasks seem thus far havent completely bogged down my machine.

Yeah, if you just want a text editor and not an IDE, you probably shouldn't be using an IDE. Those things that are "just not" helpful to you are very helpful to others.

Personally, I very much want an actual IDE for a lot of my work. So I'm happy to buy a fast machine with plenty of RAM and then give the IDE a good chunk of it. But I'm glad they're making Fleet for folks with other preferences, and I'm sure I'll be using it myself when I just need to open one or two files and make quick edits.

no I want my IDE to be functional without destroying my system performance or fucking up my codebase. jet brains is a massive offender here. it doesn't need to be. I have a giant machine ~128GB of RAM and 24 cores. the fact I have to tune my IDE is insane.

the not helpful issues with jetbrains are when it crashes, slows down my system, prevents me from modifying files because reasons, modifies my build configurations in unsafe ways because it thinks it knows best, interferes with CLI run commands because it doesn't safely check that it can modify files owned by other applications.

I'll grant you these are generally issues with the individual plugins within jetbrains. why deal with all that when I don't have to? Why deal with the performance issues the JVM has when I don't have to?

vscode I get autocomplete, debuggers, decent linting, decent performance. that's an IDE in a nutshell. not a text editor.

I'm happy you enjoy JB, great. it doesn't change any of the above and havent seen any indicators that the above has changed or will change in the future for it. hence I don't use it.

fleet may be promising in this regard. but don't feel the need to jump ship when I already have remote code editing in vscode. which is the only real first class feature fleet has to distinguish itself from other IDEs.

That's just very different than my experience. Across a number of years and a few different major languages, from coding solo to working with teams. The only tuning I have to do is to tell it that using more RAM is ok. I'm sorry you're having those problems, and if you ever want to dig in on fixing them, drop me a line. But please understand it's pretty far off the median experience.

while I appreciate the offer; there is nothing to dig into here. jetbrains just doesn't bring anything to the table compared to other options. and it lost my trust on reliability in a massive way due to android studio and never really performing well at its core function, writing software, compared to things like sublime, vscode, even vim/emacs; once configured.

and if I'm going to pay for something like an IDE it needs to be rock solid when the free competition is competent.

It may not bring anything to the table for you. I would find it helpful if you phrased your criticisms in a way that didn't deny the possibility that others might find plenty of value.

perfectly happy how I've phrased my criticisms. if jetbrains wants glowing reviews, then they can make a glowing product. I've been upfront where my issues reside, how they impacted me and they are well known issues with the tool. I'm not the first to make these comments nor will I be the last.

however, your tone in this thread implies you're not a neutral player in this. do you have any relation with intellij/jetbrains?

I pay them money to use their IDE and have for some years. No other relationship.

I don't have any problem with you criticizing them. I have a problem with you stating your criticisms in ways that sound like it's more than just your experience.

For example, you wrote, "you need to muck around too much to get them working properly". This is not true. I don't need that. You apparently did need to do some mucking around that was too much for you.

Or you write, "JB makes tons of assumptions and attempts to be helpful in ways that just are not". Again, that might not be helpful for you. But it's very helpful to me. And clearly to lots and lots of other people given how popular their tooling is even though it costs actual money.

I think this sort of universalization and projection is unhelpful and ask that you not do it.

> jet brains is a massive offender here. it doesn't need to be. I have a giant machine ~128GB of RAM and 24 cores. the fact I have to tune my IDE is insane.

You are doing something very wrong if that's the case. I have 2 big projects open in my IDE (GoLand), it has not been closed since Nov 16 and as I type this it is using ~3.8 GB of RAM and ~3% CPU on my work 2019 Mac Book

My personal travel laptop is ~2014 era thinkpad T430, an outdated machine and it has never once hiccuped while running the IDE.

This is almost certainly a "you not JetBrains" problem.

it was android studio stuff at the time. I just tapped out of using it jetbrains related tooling after that experience.

the point I was making is that it wasn't an under powered machine that causing issues as implied by the responder.

sadly the issues I was having at the time were not just me all of them were documented / reported in the github issue tracker for flutter/android studio.

I think the basic intellij config is set at max 2 gigs of RAM, so it doesn’t really matter how many you have unless you change that.

I really don’t know how did you manage to crash it, even with misbehaving plugins it will manage the situation gracefully (usually with a notification that this plugin had an exception) but will continue to run perfectly. Modifying files due to locking sounds like a Windows issue, and has nothing to do with intellij.

I really don’t know what have you configured for all these things to happen — what language was that project written in?

> I think the basic intellij config is set at max 2 gigs of RAM

yes, that is the conservative JDK defaults iirc; its likely unrelated to intellij specifically. I only mentioned the system specs because the other commenter was like 'i buy nice machines and give the editor tons of RAM'. but thats the cost of them using java. I don't want to tune my editor to ensure its responsive and can get its job done.

> Windows issue, and has nothing to do with intellij

except I exclusively run linux. ;)

> what language was that project written in?

early days for a flutter app. most of the issues most certainly due to the plugins themselves.

it was primarily gradle tasks running without prompting and fucking up my build.

I didn't configure anything. the experience was so bad I just bailed out, switched to my standard stack vscode and the command line stuff and never looked back.

Wait, all of this complaint is for a niche language in "early days" and you didn't even bother to try giving it more RAM? For a guy who just had to suggest I was a shill, that's a lot of information you left out of your initial judgement.

> yes, that is the conservative JDK defaults iirc; its likely unrelated to intellij specifically

No, it is explicitly set by intellij through its vmoptions file. The JDK by default uses as much as half of all available RAM (that is for maximum usage. It doesn’t start there)

> I've always found jetbrains IDE to be error ridden annoyances where I end up spending more time dealing with problems the IDE has caused than developing software.

My personal experience has been pretty much the opposite of this, as someone that uses Java almost every day and other languages occasionally (.NET, Python, PHP, Ruby, JS/TS, SQL, a little bit of Go).

If i had to rank all of the IDEs that i've used from the most productive/stable to the least, it'd go about like this:

  - IntelliJ IDEA: the best way to write Java, and the best of JetBrains' products, period
  - most other JetBrains IDEs: Rider (a bit slow, but a lot of good features), PyCharm (slow to start, but nice to use), PhpStorm (no complaints, it's just that Laravel refactoring is way behind what Java gives you), RubyMine (one of the better options for Rails, despite its dynamic nature, autocomplete just works), WebStorm (a pretty good way to write JS/TS, even with some outdated and obscure codebases, like ES5 with AngularJS and no webpack), DataGrip (a bit niche since other IDEs cover a lot of the other functionality, but also present in the ecosystem), Goland (just recently started using, similarly usable); all of those are definitely worth the Ultimate subscription of their products IMO
  - Visual Studio: a pretty good IDE that has a similarly slow startup to Rider but feels good afterwards, especially for developing against Windows and doing .NET, perhaps better than Rider in some regards, though i hate the VS Installer with a passion, still haven't removed all of the crap it installed, years later, and the checkboxes for the features you may/may not want are confusing and it's a massive waste of space (though i guess the Python etc. integrations are nice for some + Azure stuff); also has the most tutorials for it out there
  - NetBeans: my darling a few years ago, completely free, reasonably capable and has some other tooling based on it (e.g. jMonkeyEngine SDK), if it had better framework integration and wasn't so dead, i'd gladly keep using it, since the keybindings are perhaps some of the most sane i've ever seen; also supports PHP and C/C++, but those are a bit weaker here; also really slows down with large projects
  - Eclipse: i hate Eclipse, some people swear by its workflows, but i've used plenty of horrible software that decided to use it as a platform and did so poorly (4EM tools, model driven development tools for generating source code, some random remote'ish development platforms) though it's also really poor on its own, as a regular Java IDE; unhelpful, inconsistent and slow
  - Android Studio: perhaps one of the few tools that are worse than Eclipse (aside from obscure SWI-Prolog IDEs and some ASM IDEs), i don't know what went so wrong here, but it's slow, chugs memory, makes the CPU hit 100% usage with 4 cores and just generally feels like a bad solution, i'm not sure where JetBrains went wrong, but since last trying it about 3-4 years ago, i haven't picked it back up since
I'd probably put some other IDEs, like QtCreator near Visual Studio, but i don't have enough experience with it or C/C++ development myself to say for sure. Apart from that, VS Code would be near the top as far as snappiness goes and near the bottom as far as features go (or in the middle with enough plugins, provided that nothing breaks).

That's about it, each IDE has its advantages and disadvantages.

For example, even IntelliJ might need you to dig through the VM and memory options when you want to open projects that approach 1M SLoC, since the defaults might not be good enough.

Oh, and in regards to DB tools, MySQL Workbench would have the #1 spot (since the modelling and forward/backward engineering and schema sync functionality is to die for, when planning things), DataGrip the #2, pgAdmin the 3# (the UI just feels non-native and bad, cumbersome to use, unresponsive) and SQL Developer would be near the bottom, after whatever else software i'd decide to list (horrible whenever you try to do anything apart from just writing and executing SQL, e.g. the modelling bits have failed to save and later re-open files pretty consistently).

see this might be the difference I don't distinguish between intellij and its various spin offs. Most of my interactions with its ecosystem have been through Android Studio.

and it was so horrible I won't touch the others for any length of time. I also havent developed in java for over a decade until recently (for work, only touch java if you pay me).

To me it sounds like this is used to test a rewrite of all their IDEs because it is written from scratch.

I can imagine if this becomes a succes they will update all their IDEs or use Fleet as the new platform.

Over year ago JetBrains released a post showing they don't understand why VSCode eats their market:

> Still, we don’t deny the information could be a bit skewed – even with the weighting we give to our survey results – given that this is from the JetBrains State of Developer Ecosystem survey, and one of JetBrains main products is IntelliJ IDEA. However, that is not to say that this is not totally unreasonable, as if we look at other surveys, IntelliJ IDEA is usually one the most used IDEs, and usually has around a 55-60% share of users. VS Code is growing which is concerning, not from a competitive point of view but actually from the point of view that there is clearly a lack of understanding of what an IDE gives you. VS Code is a code editor with some features that you’d find in an IDE, and extensions that can provide additional functionality – so if people are turning to VS Code for developing it may imply that developers don’t know what a fully-featured IDE can give them. In the web space it is understandable to use an editor as web developers are typically working with dynamic languages, and often use other tools like browser plugins to give them what they need. But in Java, especially professional Java, you really get a lot out of a good tool that has integration with the application server and you can really use the analysis and refactoring and everything.

Specifically this part:

> VS Code is growing which is concerning, not from a competitive point of view but actually from the point of view that there is clearly a lack of understanding of what an IDE gives you.


People moved from IntelliJ to VSC because it was faster, simpler and language-agnostic, instead JetBrains blamed users for not using advanced features like CPU profiling which most people don't use daily. They are jumping on simple-editor train now. Better late than never

> People moved from IntelliJ to VSC because it was faster, simpler and language-agnostic, instead JetBrains blamed users for not using advanced features like CPU profiling which most people don't use daily. They are jumping on simple-editor train now. Better late than never

From my experience, most people who nowadays start programming, flock to vscode because it's free, used in most tutorials and then they simply do not understand why a certain paid IDE could be better, because they never tried it. Which is right with their statement. People keep parroting about greatness of vscode because it gets them through the day of making hello world apps and never have to actually debug more complex code or work with bigger codebases. Does it work in big projects for some(usually experienced) poeple? Sure. Is it the best way of working? Usually no(in my opinion at least).

I agree with this a lot - I went through a progression from simple -> full IDEs personally - writing a mix of PHP and JS for the web, along with C# for console apps, some python, and some terraform - I used to use a mix of a generic text editor with syntax highlighting and full MS Visual Studio.

Then it was VS Code, because VS Code gave me basic code completion and debugging which beat the text editor, and was massively faster than full MS Visual Studio. But VS Code's debugging features are buggy at best, PHP is a community supported language only, the .NET support is very easy to get tremendously confused/broken, and Python support for code completion never seems to work for locally installed packages etc.

Now I use the JetBrains suite of IDEs - PHPStorm, Rider, PyCharm do code completion, suggestions, etc on a scale that none of the VS Code community or MS plugins provide. PyCharm has really nice support for dealing with Pipenv. Rider has a NuGet integration. Rider debugging has always worked for me. An official JetBrains plugin provides the single best terraform authoring experience I've used. For me it really is the best solution.

Yes, the JetBrains IDEs are heavier than VS Code, and yes they cost money, but you're not cobbling together a solution from a disparate set of plugins and crossing your fingers. There's actual support.

With web development I find there's a lot of resistance to paying for dev tools - people are used to free. Additionally practically everyone seems to suggest VS Code at entry level to new developers. But once your project is non-trivial, it really isn't that good of an experience, in my opinion.

I tend to agree.

It's a bit like the dynamic vs. static typing situation. New comers often prefer languages like Python at first for their simplicity, only to "rediscover" that static typing is so much more manageable later in their career.

My career has been the opposite. I grew up on C, C++, then Java. Now I'm on dynamically typed languages and appreciate their advantages and prefer them.

I also grew up on C then Java. Now I mostly work with Python but when things get serious I usually turn to JVM languages.

The feeling knowing I can relentlessly refactor my code without breaking a thing and not having to worry about typos is just wonderful!

Yeah context is required for these discussions. Anyone will love coding small digestible functions in python in a jupyter notebook. It's really fast. You might make a lot of mistakes (wrong import, wrong type, incorrect variable reference etc) but since the edit/refresh cycle is instant, it's not a big deal. Let's see how you feel about Python trying to application that has to be industrial strength and grown quickly for a business.

VSCode has debugging built in and can connect to various runtimes.

Not that I ever use that - I prefer sticking with the language native tools, and I rarely require anything beyond inspecting runtime values and simple benchmarking.

Maybe this comes from the perspective of Java, where you need an IDE to do proper debugging, building/starting an application requires a gazillion command line arguments, and you have layers upon layers of abstraction to drill through? Those are pains worth taking away, but don't apply to all languages or platforms.

Recently CLion got decent Rust debugging. While I love rust-analyser and its integration with VSCode, the debugger in CLion is worth its weight in gold (like a ton or so).

Would I prefer a native IDE for Rust? Maybe one that doesn't require 4GiB of Ram to operate? Yes.

But bar for IDEs today is very high.

Refactoring, "show me where this class, function, variable is used", "show me a class hierarchy", "analyze my code and tell me where I'm not using best practices and suggest the best fixes and apply my selected one", are places where a full-fledged IDE shines. An editor won't do those, or most of those. A 15-minute task turns into a 20-second blip.

VSCode does all of the former, at least for the two main languages I work with, TypeScript and Go. Prettier, ESLint and golangci-lint handle the style checks.

JetBrains says the problem is “users are unaware of what an IDE can do” but maybe it is the other way around?

Currently I am using Emacs and Goland as my main IDEs/editors and have tried vscode but the thing is - what vscode can support entirely depends on what LSP server can support. This can make or break vscode. For example - both vscode/emacs (via lsp-mode) throw errors/warnings in multi-module go projects. Even worse, if you are hacking your build chain the way some projects like Kubernetes do(via staging directory), lsp-server refuses to work entirely in `staging/` directory of the project.

I also saw that switching branches can confuse lsp-server.

All of these problems are basically non-existant in Goland(Intellij).So depending on complexity of a project, I would day it is worth using an IDE.

What’s nice that Jetbrains does in Typescript that VSCode doesn’t is automated refactoring. I can change or move a function anywhere in my project and all references are automatically updated.

VSCode does it to some extend, but the difference is night and day.

That last paragraph is wrong but I'm too tired to explain why for the millionth time.

I’d love to hear why. Would be the first time for me :)

You mean like the 64000 packages required for a simple hello world with 34 vulnerabilities and ads, and what takes more time to “compile” for trivial AST-manipulations than a god-damn optimizing compiler do?

I switched from a JetBrains IDE to VS Code for one reason: I don't want to build a C++ codebase on my laptop. It requires a lot of processing power, takes a long time, kills the battery, and makes the fan go off.

I'm willing to use VS Code Remote and sacrifice some features to not have to deal with that. My employer doesn't really care if I provision a big EC2 instance for development. I'll take a look at Fleet a little later on.

Jetbrains now has a remote agent, works decently.

I've tried all of JetBrains' remote working solutions (there are confusingly many now, 3-4?) and they all seem unusable for my use case, where VSCode (or indeed ssh + vim) just works. And my use case is not particularly special, C++ with CMake and some wrapper scripts to pull in dependencies.

The only solution that works OK is Projector, but I can achieve the exact same thing but less buggy with VNC.

I moved to VSC because I need one editor, one keyboard shortcuts to learn for 4 programming languages I use daily. I use it on quite big projects, openapi-generator and keycloak and it's fine, I like it, but my teammates tell me I'm a weirdo for using it.

I use vscode because it's very flexible and does 99 percent of what a "full ide" does but at 10x the speed. I have a few thousand other developers who produce great extensions for me that do many things. I've also used just about every ide in existence over my career and I've never used a feature that vscode didn't have built in or in an extension.

You're making the same mistake they are by assuming developers are just ignorant of what an ide is, and it's going to sink intellij eventually.

Vscode is more than suitable for big projects, Its not just for hello world projects. VSCode is best tool for TypeScript/JavaScript/Dart. For Java/C# it probably is not.

You should really try out JetBrains' TS/JS features. It's great, as good as anything VSC can give you, and if you're used to their IDEs (say, for Ruby, which is nowhere near as good on VSC) you're better off using the JB IDE.

I didn't say jetBrains IDEs are not good, I said VSC is good for most use cases

> do not understand why a certain paid IDE could be better, because they never tried it

Same goes for most vim/emacs vs. ide discussions :)

I wouldn't go as far as to say that they don't understand, merely that a different viewpoint was expressed:

> ...there is clearly a lack of understanding of what an IDE gives you.

This is most definitely true for many people who have largely gotten used to dynamic languages and have only used text editors or have only experienced VS Code with plugins, because it's wonderfully easy to run and use, even if its feature set is lesser than that of many of JetBrains' products.

Where it all gets a bit muddier is finding the distinction between "not knowing" and "not caring/needing".

For many use cases out there, VS Code with plugins will be more than enough!

But for working on an enterprise Java/.NET/... codebase and applying refactoring across dozens if not hundreds of files, something a bit more might be necessary. When working with the Eldritch abomination that the Spring framework and its many integrations are, you better have tooling that provides you with smart hints, fixes and autocomplete suggestions, as well as context sensitive parsing of your dozens of XML/YAML configuration files and their values.

When you're trying to trace down a race condition across hundreds of proxied Java classes, where the framework rewrites and calls your code with reflection so it's really hard to actually debug anything outside of your code, you better have a good debugger and the possibility to use conditional breakpoints, otherwise if you can only catch any type of exception, you'll be sitting there for half an hour just to get to the specific state that you're looking for.

Edit: i'd say that all of the autocompletes and suggestions (e.g. "you can use a lambda here", or "you don't need all of this cruft for implementing a functional interface") can actually be beneficial to getting to know a language or a framework better.

I tend to agree with the sentiment, but when you have Red-Hat and Microsoft collaborating into bringing all possible IDE features that matters for Java BE development into VSCode, that really hurts into JetBrains pocket.

They are turning VSCode into a first class experience when coding mainframe style across OpenShift, IBM Cloud and Azure.

That's a very fair point to make, but as a consumer, that's probably a good thing - having a healthy competition in the industry, it seems that even the likes of Eclipse are attempting to branch out somewhat: https://theia-ide.org/

The next decade in tooling will hopefully be promising!

> People moved from IntelliJ to VSC because it was faster, simpler and language-agnostic,

Did many people move from IntelliJ to VSC? From what I've seen, VSC is mainly used by people who previously haven't used a full IDE.

It's also not clear to me that they're "a jumping on a simple-editor train". Given that with one click you can turn on "fully functional IDE bringing smart completion, refactorings, navigation, debugging, and everything else that you’re used to having in an IDE" I don't think it's actually simple. It's just a quick-to-open IDE where the user in in control of when to pay the extra startup cost for the fancier features.

Yeah my company canceled JB Toolbox subscriptions because there was no noticeable team productivity gain for using JB after we tested out and compared with vscode for a year.

We used CLion and Webstorm. At the time, CLion did not have remote debug but VScode did, which triggered the trial. Switching from webstorm to vscode for webdev was trivial.

From our team perspective, using JB didn't produce noticeably faster turnaround or less bug. It was no brainer to forgo the subscriptions and just use VScode.

For a while, the only thing affected was developer comfort. But everyone adapted very fast and surprisingly, new members to the team are also most likely familiar with vscode already.

> clearly a lack of understanding of what an IDE gives you

That might not be a point in their favor. Once VS Code came out, a lot of programmers that were simply following their earlier training and using an IDE, learned how much you can do in a text editor. I've seen lots of "Why would anyone write code with Notepad?" over the years. This was largely rooted in Java, where the only option was to use an IDE. VS Code dispelled the myth that real programming has to happen in an IDE.

Gonna draw a comparison here.

People loooove dynamic langues, no-sql etc.

But from all my experience, once you start getting into bigger projects, maintenance etc. they become a detriment.

So they start with a simple IDE and avoid the IDE with the kitchen sink. Because ultimately they don't know what they are losing/going to lose.

> I can imagine if this becomes a succes they will update all their IDEs or use Fleet as the new platform.

Fleet may very well be the main focus for IntelliJ in the future. It is highly moduralized [0], which makes it seem like they're going after github.dev, stackblitz.com, replit.com and not just VSCode.

[0] https://www.jetbrains.com/help/fleet/1.0/architecture-overvi...

Often, there are one or two voices inside of a company that have the same complaints as customers, but they can't get any traction on the issue until users complain about it. I've been on several projects where we coached or were coached about asking our boss to ask their boss for something with a specific keyword that they could use for leverage.

In college, I left my ATM card in a machine and the person behind me pulled out the max daily limit on my account. I don't think the cops were able to ID him off of the grainy back-lit video from the machine. This was a new model of ATM that had worse ergonomics than the previous one. Turns out someone at the bank already hated these machines, and he arranged to refund me the lost money (which I'm fairly sure now he would have had to do anyway) in exchange for a signed complaint that he could add to his evidence trove.

"People are dumb. A person is smart." also applies to companies.

The thing is that if you're too rude when you make a complaint, you make bad evidence. If you're too polite, the same is also true. "We should fix this because this totally happy customer said we should" might work once in a while but it's easier to sell your boss on "customers are pissed about X which is also pissing me off." I struggle to find the right line between the two when I have to call customer support. Since I don't usually like to call CS at all, when I do it's usually because I'm pretty spun up.

To me it sounds like they are trying to counter the assault of VSCode onto their market share.

I am wondering if it is still written in Java. It will be interesting to see how a light weight Java Editor compete against another light weight Web / DOM Editor.

And if it is Java, would be there any Substrate VM / Graal tools going into it.

Looking through the features, and the similarity of the architecture, looks like this is meant to compete with VS Code. Even the Settings implementation has the same global/user/workspace hierarchy; there's the 'trusted' code concept too. The one thing that might make it stand out is the smart mode: lightweight editor by default, and enabling it brings in the heavier IDE features.

Anecdotally I've stopped using Jetbrains IDEs due to the bloat factor and their relatively poor Linux support, where VSCode has been providing excellent support and still manages to stay lightweight (though, it's starting to get notification heavy, isn't it?). Fleet is aimed at people like us so I'm willing to give it a try, but expectations are low.

I've been using WebStorm exclusively on Linux with i3 for more over 3 years. I haven't run into any issues with it at all. Even the JetBrains Toolbox and automatic updates works fine.

What do you see as poor Linux support?

Not op, but for me the lack of native Wayland support is a deal breaker. And running it through XWayland has various issues (focus is broken, issues with HighDPI screens, etc).

If Fleet supports Wayland natively I might give it a try, otherwise it's dead on arrival for me.

As far as I know jetbrains did start to write a wayland backend for sway. But it is most probably a project with very low priority.

My mistake on the wording, I should have said "mediocre", perhaps. I can't edit the comment now, oops sorry.

I am referring to lack of an installer, and also the default shortcuts which clash with the distro, and in general I've seen features come to Linux a lot later. So a better way to put it is that Linux feels like an afterthought to Jetbrains. I do follow and also raise issues you on YouTrack but find they often languish.

Their IDEs are still overall pretty good, but I gravitate towards VS Code now.

The installer is called jetbrains Toolbox. Never had any issues on systems with i3, gnome, sway...

Installing single IDEs is clunky. Basically it's up to you to put it where you want and then create any shortcuts you may need. Flatpaks make this easier but I would rather not use them.

Besides this, I never really felt that Linux was an afterthought though. At least from my experience using CLion.

No Jetbrains toolbox handles all of that for you by default. And let you override defaults if needed.

I get what you are saying, but you are aware VSCode is an entire web browser with a small coding engine. Jetbrains IDEs while built with Java are at least native code. Jetbrain IDEs are also full IDEs, not notepads with a few extras. It's rather hard to compare the two, a proper comparison would be something like Visual Studio.

> you are aware VSCode is an entire web browser [...] Jetbrains IDEs [...] are at least native code

So? You wouldn't tell a non-programmer something like this about an app that they use and expect it to make a difference. The results—the effect that the program produces—is the only thing that matters. If JetBrains manages to produce an IDE where you're constantly confronted with bloat while you're using it, and using something else would alleviate some of that pain, whether the alternative is "native code" or not, then that's the only thing that matters—not architectural purity.

(Side note: is the fundamental theorem behind your statement even true? If I download and run IntelliJ right now is it bytecode running on the JVM, or is it Java/Kotlin AOT-compiled to native object files? Poking around 'ideaIC-2021.2.3.tar.gz', there are an awful lot of classfile-containing JARs in `lib/`, and `bin/idea.sh` ends like this:

    # ---------------------------------------------------------------------
    # Run the IDE.
    # ---------------------------------------------------------------------
    IFS="$(printf '\n\t')"
    # shellcheck disable=SC2086
    "$JAVA_BIN" \
      -classpath "$CLASSPATH" \
      ${VM_OPTIONS} \
      "-XX:ErrorFile=$HOME/java_error_in_idea_%p.log" \
      "-XX:HeapDumpPath=$HOME/java_error_in_idea_.hprof" \
      "-Djb.vmOptionsFile=${USER_VM_OPTIONS_FILE:-${VM_OPTIONS_FILE}}" \
      -Djava.system.class.loader=com.intellij.util.lang.PathClassLoader -Didea.vendor.name=JetBrains -Didea.paths.selector=IdeaIC2021.2 -Didea.platform.prefix=Idea -Didea.jre.check=true -Dsplash=true \
      com.intellij.idea.Main \
Non-side note: no matter what the answer is, don't get sidetracked into thinking that it makes a difference to what actually matters.)

You clearly missed my memo, the above message was saying they avoid JetBrains because of bloat, while using literally an entire browser to "avoid bloat".

That was all I was saying.

In fact, you said more than that, hence my quote—which is a real quote, unlike the made up one in your comment—the words you're attributing to the person you reference don't appear anywhere in their comment. (Also, separately, that's not really an appropriate use of the idiom to miss the memo.)

I will admit that I don't know what your point is. Are you under the impression that the Java platform is lightweight?

In addition to your spurious claims about native code:

- code_1.62.3-167137107_amd64.deb: 77.4 MB

- ideaIC-2021.2.3.tar.gz: 795 MB

That's a >10x factor.

I keep seeing discussions on a full IDE vs an editor like VSCode. People are claiming VSCode is poor with autocompletions and other features only a full IDE can accomplish.

I use Pycharm, Webstorm, and VSCode and I don’t see the huge difference. Is it more apparent on certain languages?

They stated in their blog https://blog.jetbrains.com/idea/2020/09/a-picture-of-java-in...

> In the web space it is understandable to use an editor as web developers are typically working with dynamic languages, and often use other tools like browser plugins to give them what they need. But in Java, especially professional Java, you really get a lot out of a good tool that has integration with the application server and you can really use the analysis and refactoring and everything.

> VS Code is growing which is concerning, not from a competitive point of view but actually from the point of view that there is clearly a lack of understanding of what an IDE gives you

So my main question is what do full blown IDEs do that an editor like VSCode cannot?

For my job I spend a lot of time working on a python package that uses threads. I’ve found that pycharm’s debugging tools are much better than vscode’s when it comes to threads. Also, auto imports are possible while I don’t think I’m able to do that in VScode.

If someone can tell me how to set up VSCode to do this better, I would love to know. However I also need to be able to support other engineers who typically don’t work on the package but might need to drop into the code. It is much easier to tell them to download the community edition of pycharm and start working than it is to walk them through setting up another editor/ide.

I don’t particularly like pycharm, and don’t use it when I don’t have to, but in this case it’s the right tool for the job. (So far.)

What do you mean by auto imports? If you type a function, type, or other token in VS Code that is not part of the scope, but exists in the environment, it will suggest and complete an import for you. At least for Typescript.

It's not great in Python from my experience. Much worse than PyCharm, at least.

Yes it is much more apparent with typed languages (and starts to show with typed Python as well).

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact