đŸ Archived View for dioskouroi.xyz âș thread âș 29377515 captured on 2021-11-30 at 20:18:30. Gemini links have been rewritten to link to archived content
-=-=-=-=-=-=-
________________________________________________________________________________
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.
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?
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.
> _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...
https://sales.jetbrains.com/hc/en-gb/articles/207240855-Can-...
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
https://www.jetbrains.com/idea/buy/#commercial
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.
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?
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.
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.
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).
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 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!
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 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 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.
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.
> 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.
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.
https://www.youtube.com/watch?v=MUGWOdN3JHU
> 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?
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)
> _"...unless you need something only VS can do..."_
Yea, you just want to argue.
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.
> If theyâre prepared to give this away for free
That was asked more than once in the comments but got no reply.
> 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."
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?
Wish they offered complete package - remote machines, deploy pipelines, actual compute, all enveloped with best practices.
Code with me works okay. Far better than "Zoom share desktop".
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.
> 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.
https://blog.jetbrains.com/idea/2020/09/a-picture-of-java-in...
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.
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?
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 :)
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 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.
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
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.
> 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:
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.
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.
> 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.
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.
> _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...
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.
To me it sounds like they are trying to counter the assault of VSCode onto their market share.
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}}" \
${IDE_PROPERTIES_PROPERTY} \
-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.
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.
Yes it is much more apparent with typed languages (and starts to show with typed Python as well).
I don't think the relative ease of writing extensions for VSCode can be overlooked. There's a relative explosion of extensions addressing a lot of niche needs for various markets. My experience is that many of them aren't terribly good, or were good but are no longer maintained, etc. If/when JB makes it more straightforward to write extensions, there may always be a perception different. VSCode extensions in TypeScript will be easier for many curious folks to address vs Java/Scala-based plugins for JetBrains.
Yeah but the quality is pretty mixed. A lot have performance problems, and maintenance is spotty.
Touched on that with "My experience is that many of them aren't terribly good, or were good but are no longer maintained, etc"
But... I realize now my comment was edited some during writing, and I merged two different directions I was heading in in to one comment, and didn't really finish either direction...
You're correct that the quality is mixed at best, and... discovery is a pain. I regularly use phpstorm, and when working with others using vscode, I see they've gone through multiple php plugins for vscode, with varying success, and almost nothing comes close to the built-in functionality with JetBrains. The "live share" aspect of vscode is really nice (and 'codewithme' is OK too) but I've rarely been on a team where people ever paired enough to make it a useful or regular part of work.
The 'remote' thing is where vscode has really seemed to rocket ahead in the last year or so (just my own observation from colleagues). I didn't understand the attraction, then... on thinking about it more, I guess I can somewhat understand the attraction, but it's not something I've felt compelled to pursue - it's felt like a step backwards. Maybe that will be something I revisit in 2022...
If this can be 90% of the basic VSCode editor experience then I'm interested. Full props to VSCode's more advanced workflows[0], but I've mostly bought into jetbrains for that use case at this point. If I can fill the basic slot with a jetbrains product it fits well into my goal of a uniform tooling experience across everything. Fingers crossed for a good product that'll push both it and vscode to be better.
[0]I use vscode as a basic text editor that can handle lots of files in a multi directory workspace because it's fast at it, plus markdown rendering and some basic autocomplete. I don't use the debugging features, navigation, or anything similar in it, but like I said, I give it full marks for being capable there, it's just that's outside my use case.
Little bit offtopic; I try jetbrains ide's every time I get a new laptop; lately Rider for a 1m+ LoC c# project on my 16gb m1. It is unusable. I like the features but it is so incredibly slow... and it gets even slower as the day goes on.
The culprit is the JDK11-based JBR. I was ready to dump JetBrains tools due to their lagginess, but with some deviousness (which might not suit you), I now have them running slipperier than a wet fish, by using JDK15/16 and JAOTC.
Instructions are here:
https://iam.georgecox.com/2021/11/24/making-jetbrains-ides-r...
(I am very keen to tell people who are in the same despair as I was about how slow JetBrains apps are out of the box -- hope it's not considered bad form to link to one's own blog post about it.)
I will try this now; thanks for that!
please email me if you have any corrections / suggestions for improvement for the instructions :-)
Please note that the JBR is a custom build that contains a number of important changes and fixes, and it's not recommended to replace this. For M1 support, it's much better to use an M1 compatible JVM and .NET runtime. Rider 2021.2 is an Intel build, because when it was released there was no M1 compatible .NET Runtime.
Rider 2021.3 has an M1 build, and makes a big difference. It's currently in preview (
https://www.jetbrains.com/rider/nextversion/
) but will be released in the next week or so.
Liberica offers an M1 JVM
https://bell-sw.com/announcements/2021/03/12/Liberica-on-App...
I wonder if JetBrains has some incentive to keep Mac users happy at the expense of others, because there is no justification for the unacceptably bad performance of CLion, PyCharm, and IDEA with a version 11 JDK on Linux, given how much better it is on JDK 15/16.
I have never seen any indication that they have are going to address this, nor have they even acknowledged that it's a problem, nor that they intend to upgrade from JDK 11 to something more up-to-date. Still, they have 1 year and 10 months from now until the end of active support, so perhaps this might provoke them into action.
The fact that JBR even exists is a red flag. Should every vendor ship their own JVM?!
I was under the impression that the JBR is missing a number of important changes and fixes that have already been mainlined into OpenJdk.
Would love to see some examples of this please :-)
If you're not using the EAP build of Rider, you're running an Intel IDE on that M1 laptop (see:
https://rider-support.jetbrains.com/hc/en-us/articles/440192...
).
Try the Rider EAP with .net 6 - I find native arm64 .net _flies_ on my M1 mac mini and M1 Max 14" MBP.
That's strange. When I open a 1m+ LoC in Rider it takes around 2GB of RAM [1] but is still very workable.
Ofcourse it is not extremely fast but I am always impressed this even works with all the code hints, indexed code and what not.
By the way, sometimes a corrupted cache can be a problem. You can fix this via File -> Invalidate Caches.
[1] AMD Ryzen 9 3900X, 32GB RAM, NVMe disk. Ubuntu.
Just in case you haven't tried that yet, increase the IDE's memory heap size. That solved the problem of sluggishness for me.
Why hasn't Java added an option for automatic heap sizing for the desktop application use case (or any use case, for that matter)? Seems like a no-brainer thing to add, so I guess there are Reasons(tm).
It is configured by jetbrains (I guess to not use as much memory as Java would default to)
It has. Modern JVMs can use as much memory as they "need" to, but for some reason JetBrains don't use this feature. I think after they upgrade to Java 17 they'll get it. But this has really killed their brand for a long time. 99% of the time people complain about their IDEs being slow it's because the app is GC thrashing and burning CPU rather than increase heap size.
I was under the impression that every gc still defaulted -Xmx to 25% of available memory.
Have you waited for indexing to finish?
https://www.reddit.com/r/ProgrammerHumor/comments/9v7i1w/tha...
Which bits are slow?
I have 3 main development computers on which I use CLion. One is shared duty workstation/server with 20 cores and 512GB RAM another is main desktop desktop with 16 cores and 128GB RAM and 3rd is tiny small factor PC with 8 cores and 128GB RAM which I drag around to summer cottage etc.
CLion is very fast on either. I guess gobbles of RAM counts. I also have laptops with 32GB RAM each but did not try it on those as I no longer use laptops for development (no business need).
Still as my main development language for backend is C++ I mostly use Visual Studio. Especially since their preview version allows seamless development / debugging on remote Linux server. Hard to describe but it just fits me better, feels more "natural".
As a long-term pycharm user that recently migrated to VSCode im quite happy to see jetbrains building this. My main gripe with their stack is that I work across many languages and workflows and I like to use the exact same keymaps configurations and so on and pycharm just didn't give you that.
I really love the idea of the virtualized file system allowing you to develop anywhere. I hope this works well. Comparably, VSCode's remote containers really do a poor job of allowing one to develop over ssh connections, which I do constantly.
Why not use intellij ultimate? You can easily add all the language plugins (mod clion based ones).
Why? Because I'm a second class citizen in a java IDE. No thanks. The marketing is also quite clear on the target audience
https://www.jetbrains.com/idea/features/
Not really, tbh. IntelliJ Ultimate + the Ruby extension is RubyMine with a different name. Likewise with Go and JS, and I'm sure it's the same for php etc. but I can't speak for those. I've used this setup when I was testing out a bunch of languages for fun.
The plugins are not updated as quickly as the language-specific IDEs, sometimes they are several months behind on newer features. Not really a big deal if you wait a few months to update your Python version, but it's annoying if you update early.
I used to use only IntelliJ until a few years ago a Python feature I wanted was in PyCharm but not IntelliJ. I think it was related to the typing module? I can't quite remember. I've just stuck with PyCharm for python ever since.
edit: But also, I've never had any issue copying my key configs between PyCharm, Rider, IntelliJ.
But they could solve that without rewriting the whole platform
It is not true for C#, you need Rider for that. That is the only exception I am aware of, though.
It is my experience as well. I only use CLion for Rust and C. All the rest (Python, TS, Kotlin, Ruby, Scala) I do in IntelliJ.
Be that as it may, I've used Webstorm and Intellij Ultimate with JS plugins and the experience was pretty much identical.
I _really_ hope it's not Electron-based.
Official response:
https://blog.jetbrains.com/blog/2021/11/29/welcome-to-fleet/...
_Itâs written in Kotlin mainly, a little bit of Rust for native parts, Skiko (Skija + AWT)_
_The UI framework is similar to Compose, but we started when Jetpack Compose wasnât there :)_
Damn I was hoping to see some GraalVM AOT Java Magic.
I wonder if they have plan to use Kotlin Native. But dogfooding is always good.
I think that would have been a great case for Kotlin native.
I really hope it's not Java mess either: no Wayland support, lags
Really? I'm using their IDEs on Fedora 35 with Wayland. Seems to be working fine.
Now disable XWayland and try again
No chance of that, everything they do is in Java...
It's actually Kotlin aka "I Can't Believe It's Not Java!"
Makes sense given that Kotlin is their own in-house language.
To be fair, Wayland is still new (compared to how long Java has existed), and Java/OpenJDK may improve support in the future.
Wayland is almost 15 years old by now, and it's on track to be enabled by default on most distros as well.
there also isn't a reason for them to use it xwayland works fine for the usecase.
I hope they support wayland natively but its just not necessary atm.
XWayland does not work fine for multi-monitor setups with mixed dpi. All XWayland applications will look blurry and there is no intention to fix this for XWayland because its already considered obsolete.
x11 has problems this is known. not moving to wayland isn't a regression its just maintenance of the status quo.
Yes, I also hate Java so much!
Apparently it's not:
https://twitter.com/himanshub16/status/1465238053979447296
In the thread someone from JB mentions it's mostly JVM + some Rust
(the tweet:
https://twitter.com/hhariri/status/1465239810050830338?s=20
)
Unlikely. The rest of their programmers toolset are mostly java based.
Google translate from a dev vacancy:
You will be surprised, but we decided to create a new IDE from scratch and put together a bold team with a proven success track in creating tools inside JB. And right now we have a prototype and a bunch of bicycles.
Our program consists of several parts that communicate with each other over the network.
The first part is an editor that is written in a new cross-platform UI framework. When we made this framework, we were inspired by React.js and Swift UI.
The second part is a small program written in Rust that tells about the arrangement of files on disk and starts processes. File watcher, process monitor and HTTP client in one binary.
The third part is a server that analyzes the source code of the project. It can be IntelliJ, ReSharper, or LSP server.
This architecture adds flexibility: if you run all the parts on one computer, you get a classic IDE. And if on different machines, it will be convenient to work in the cloud or in a container.
Now that's interesting, let's hope it's not immediate mode based and is closer to SolidJS (without Virtual DOM) than modern React, which clearly has no long-term future.
I guess they mean their GUI framework architecture is close to React's architecture rather than actually using JS for GUI.
> modern React, which clearly has no long-term future
Curious, why do you think that?
they didnât say itâs a JS framework though
The UI is probably written with compose
https://github.com/JetBrains/compose-jb
I believe so as well. Compose is very similar to Electron. Jetbrains Toolbox (which uses compose) uses 500mb memory which is on par with what Electron would use for such a simple app.
Why would it be similar? It doesnât need all the unnecessary abstraction of a browser/DOM. Also, initial memory usage doesnât mean it scales the same way from then on.
It uses JVM and JVM tends to hunk all memory for object pools so it can allocate fast if needed.
I just checked. On my Windows laptop from work it uses 18.5 MB in the background. It uses 220-240 MB in the foreground though. Which seems totally unnecessary.
I already ditched the Toolbox app on macOS, because it marks the binaries as Intel only (while they're universal). The IDE's built in updater seems fine if you're only using the stable versions. So I think I'm just going to remove the Toolbox app from all my machines.
I really hope that's not the case - at least the browser has an excuse of being a scripting platform, a 3D and 2D rendering and layout engine, a video streaming platform, a database, a server and who knows what rolled into one - that Toolbox thing hopefully has less than 5% of that in its codebase.
Except Electron is 8 years old, and Compose desktop has started active development half a year ago.
Same. Similarly, since VS Code is the obvious comparison here, I really hope they're planning to open source the basic version of this once it's out of beta. I could really see myself using this if it manages to be both open source and _actually_ lightweight and not a 300+ MB blob.
Although I only speak English I greatly appreciate the fact their blog is available in so many other languages.
Are their IDEs interfaces available in multiple languages too?
Sheesh. Please no.
Note that i do speak several languages and my native language isnt English. Still, please dont complicate my programming with translations.
I'm in your same boat, English as a second language and I dislike having to use my native tongue for dev-related concepts, it just doesn't work.
IDE language isn't tied to the language used in your codebase
Parent has a point, there are so many things that don't even make sense in other languages, for example in my native language we don't have a word that corresponds to "Refactor", any possible translation would be weird and hard to understand, that's why I've never used an IDE in a language other than English.
It's got nothing to do with "the language used in your codebase", whatever you mean by that (programming language? natural language used in strings?)
Yes, I agree that certain things are complicated to be translated correctly
Yes, almost all programming languages use English keywords.
Yes, for international collaboration, English is a must.
However, many non-native English speakers who are complete programming beginners do tend to have trouble with the locale the editor is in. Imagine you want to change a certain setting but don't know the correct English word for it. Or all the warnings, errors and hints the editor throws at you. Everything is in a language you were not born with. Personally I know a handful of people who struggle with English itself, but that shouldn't be a requisite to use the editor alone.
As for my "tied to the language": parent comment didn't specify how the IDE affected their programming workflow, so I went with a general statement.
The thing is, if you want to stay up to date with programming you cant afford to wait for Information in your native language anyway. Unless youre a complete beginner.
So whats the point in having the menus, debugger etc translated, except for extra confusion?
Would you like the build config files translated too?
I'm sure the Academie Français has made up an authorized word like rererefateurellement.
I don't understand this approach. Obviously you'll have a choice. And those who struggle with English would love to have a choice as well.
Instead of learning english those people will now struggle both with english and programming, it is really a disservice. And when you'll collaborate with people using poorly translated terminology you'll struggle too.
This is such a self centered colionolist attitude.
Not everyone is going to be collaborating with foreigners. Even if a programming language is based around an English view, many company APIs may be based on their own primary communication language. Or it may just help someone who's still great at communicating in English to work more efficiently, when English isn't their primary language.
Choice is good. Don't force your English centric world view on everyone.
It might look like there is a choice, but there is one good option and many bad ones.
As long as english stays lingua franca, it will be the default language of every specs, docs and tool that matter. Even if development happens outside of anglosphere - nobody wants to get locked out of international community. There is just no getting away from this, unless Yellowstone eruption erases most of US and China gets to be a world leader.
> Not everyone is going to be collaborating with foreigners
Sure, someone can work for a pittance on an internal market. Handicapping you career like this is an example of a bad choice that I'm talking about. You wouldn't even be able to get a job in any decent company without going through an english language test first. This isn't obvious only if you yourself live in US and naively think that every other country is equally ripe with opportunity.
English is my second language and my knowledge of it is far from perfect.
Still after decades of development my brain simply refuses to understand any IDE or anything development related for that matter in any language other than the English.
And it's been that way even when I did not understand nearly any English.
It seems they aren't.
Side question: One thing they highlight is that this supports live collaboration, including simultaneously working on the same files. Can anyone describe a productive way of working where that's helpful and not confusing? When would you choose to work that way rather than e.g. pair programming with a single IDE or splitting up work in different branches?
Shared editing of a document seems mostly fine but occasionally confusing, but code has to be internally consistent, and it seems like two parties trying jointly complete a feature on the same copy of a repo might be slower than sequencing if A's intermediate changes can prevent B from building/testing what they just wrote, etc.
I think your example of pair programming is where it's useful (and what they highlight in their current integration in their existing products)
The idea being (no pun intended) that you can do remote pair programming
I guess, my assumption is that for pair programming only one person ought to be actually writing code at a time, you should be looking at the same files at the same time, and you likely want to have some live voice and/or video channel open to discuss what you're doing, etc. So, I kinda think that as janky as it feels, screen share of a normal IDE over zoom ends up being a less disjointed experience than zoom + "collaborative" IDE where you might each be looking at different files or different parts of files.
Iâve used the collaboration feature on IntelliJ when peer programming and it has been excellent.
You still look at the same files together, but you donât need to annoyingly explain where to change things or move around.
I highly recommend giving it a shot.
I think anyone should be able to take over as needed. Having done pair programming with coworkers over zoom, it's painful when I have to describe where I want them to click, and you have to resort to saying line numbers or describing constructs.
In person you can gesture. That's the hole that collaborative editing can fill.
One use case is, pair programming for remote work.
I'm not sure what the use case is, for small tasks I have Sublime Text, for full on work, I have JetBrains. This /looks/ like a strange place between ST and VSCode
Same.
> _For years folks have been asking us, âJetBrains, when will you create a lightweight editor?â_
I sure never did. If anything, I want their IDEs to be _more_ involved and sophisticated.
Otherwise I'm likely going to cancel our company subscriptions next year, VSCode is starting to overtake e.g. PyCharm in terms of developer comfort.
So I really hope this is just a tech demonstrator to renew the architecture of their proper IDEs and they'll be picking up momentum on the latter as well.
I've worked in 4 different software shops over the last 15 years. My general observation is the developers who rely on heavily automated/magic tooling are significantly outclassed by those who use the terminal + a basic text editor.
Terminal + Vim or Emacs/VSCode (depending on configuration) is not only all you need, it also produces developers who understand the systems they work with.
I know a lot of people will disagree but my advice to more junior guys is always get rid of the toys and learn the tools.
I do most of my stuff inside Emacs, but I wouldn't say that makes me a superior engineer to someone who uses a suite of JetBrains IDEs. In fact, for every benefit I gain from working in emacs and a terminal, there are plenty of trade-offs in terms of the amount of convenience I lose.
I _could_ recreate much of this with my emacs config, but that's an investment of my own time that isn't being spent on the actual project I want to work on. So one day I'll get around to it when I feel like it's worth moving that work into my emacs environment. But until then, I'm quite happy to fire up GoLand or IntelliJ and get a complete end-to-end integration between the language and the editor, without needing to configure _anything_.
I'm not sure the developer who uses an IDE is worse off than someone who can wrangle a terminal and minimal editor. If anything, it's just one choice of cognitive burden over another. Nothing better or worse.
This is not my experience at all. If anything, junior or mid developers that use IDEs rarely even use all the "advanced" features like inline debugging and source control features. The more senior developers maximize the value they get from tooling.
Knowing what gets run is orthogonal to using an IDE. Like, you are free to not click on that green run button and use the in-built terminal console at the bottom, but even so â will vim/emacs whatever suggest me new language features that may be superior to what I know? Will it catch trivial to see problems even before I compile my program?
Also, autocompletion, in-built documentation can be a great tool to learn as well (I read much more documentation due to a quick hotkey showing me it, than I would manually hunting it down). And I know that these tools can be customized to do all these, my experience is that with so many tools they tend to be buggy and slow, and still only support a handful of features that a full-blown IDE does.
Jetbrains IDEs will step into framework/library code/stack-frames/variables that you didn't write yourself and let you trace the full context of your code ... that's insight and knowledge no straight-editor will give you.
This is the kind of stuff that sounds believable when you start programming. I can tell you as someone that read HN since high school and invested time in buyinh a t480, trying out distros, and learning emacs and vim I can say its just another hobby.
You can spend days making the best dotfiles and learning every CLI tool that doesn't mean you understand the systems you work on any better than anyone else it just means you have programming related hobbies outside of work which is a much better explanation for the correlation that you're observing. I don't know why we are inferring causation there.
Your choice of tools is not that important, but learning the features of those tools is important.
Also on giving up magic tools, as a FANG engineer you interact with many magic tools every day which you scarcely understand. It would be better if you did understand those tools as tenured FANG engineers do but as a software engineer at a big company picking your battles is the most important skill you can learn.
Bit of a sweeping, overgeneralisation don't you think? Don't see how the quality of the developer correlates to their choice of environment.
I learned programming with paper, pen, match boxes to represent unary turing machines, and printed out language manuals, I'm afraid you can't out-hipster me with just emacs.
And you completely miss the point: I'm fully aware that they exist, and that's the problem. Lightweight yet modular editors are such a crowded market that I don't see a realistic way for JetBrains to successfully compete in it. They don't have the same community momentum that emacs/(neo)vim have, nor do they have the resources of Microsoft. People who _like_ IDEs are the only target demographic they have, it would be foolish to neglect those to muscle into a market crowded with very successful free products.
But they would be stupid to start from scratch. They intend to reuse all their superior intellisense, code analysis programs and make it available through a unified API for both their current tools and this newly built one.
If anything, they just want to build up a new frontend and the first look on that will be an âeasyâ one with a vanilla code editor.
I have to agree with you. At least in my experience this seems true (with a few exceptions). I feel that devs that rely on auto-complete and such of an IDE are never really forced to know the libraries and code they're using. To me it feels like training wheels they never take off, and therefore can never move at full speed.
But maybe it's just that due to the popularity of these IDEs, many newer devs are using them while older, more experienced devs are still using what they're used to.
Quick edit: I work with some junior devs who all use IDEs. It pains me when I ask them where some code is and they only give me the filename and not the full path. I guess this is because that is what is most prominent in the IDE.
> It pains me when I ask them where some code is and they only give me the filename and not the full path.
This one clearly is a self-inflicted wound.
And I've seen developers who use Vim/Emacs/VSCode spend more time doing the same thing the other guy using an IDE would have done earlier and continued with important stuff.
Although, if we go by your logic, wouldn't doing everything without an editor be even better? Because the indication and advice you're giving is that people using right tools that help their life are suddenly worse at doing their job.
Which is just bullshit.
This is a false dichotomy. You say "developers who rely on heavily automated/magic tooling" and "those who use the terminal + a basic text editor.". What of those that use heavily automated tooling but understand it? Of course people that understand stuff are better than people that don't, but this isn't directly correlated to terminal and IDE.
> I know a lot of people will disagree but my advice to more junior guys is always get rid of the toys and learn the tools.
You could make the same argument for writing assembly by hand, which will surely improve your skills. But that doesn't mean that a compiler is a toy. Those that learn and know the tools know their value. Senior developers at my work have a deep knowledge of lots of tools, because these tools can be very useful and save you a lot of time. They also build tools for others, to encode their knowledge and make everyone save some time.
For sure. I like IntelliJ, all I want is for it to be snappier; it gets pretty laggy with bigger files (like, more than one screen), it seems to have to do a lot of work that interrupts the main UI thread when it comes to redoing syntax highlighting and error checking.
I mean, the main reason why I'm not using vs code for most of my work is because it's cmd+click to go to definition isn't as good, auto/hotfixes aren't as good, and refactoring support is pretty much nonexistent.
I donât know why Jetbrains doesnât already switch to a newer jdk. I found this tutorial (only the vm options part) to make intellij really snappy:
https://iam.georgecox.com/2021/11/24/making-jetbrains-ides-r...
It basically changes the jdk to version 16 (I used one from the openjdk website, not azul) where the new low-latency ZGC garbage collector is available and increases the default heapsize. Now I have a quite large project open with 1.5GB memory used, and it is really smooth all around with no stutters.
> I sure never did. If anything, I want their IDEs to be more involved and sophisticated.
Personally I want the language functionality to be involved and sophisticated, and the IDE itself to be as lightweight and simple as possible. Jetbrains IDEs come with a decent performance penalty from the IDE itself, and I think eliminating that would be a great benefit.
It's a Sublime/VS Code replacement for people who use heavy JetBrains IDE with a huge benefit of UI/shortcut consistency and sort of fluent transition between both ends.
Looks like it places itself a little above VSCode, thanks to its Intellij code engine. Also remote coding means you could have a much beefier machine elsewhere and code on a notebook on the go, for example.
Isn't it already possible using Intellij? Would have to see just how much "lightweight" it is to justify the concept
It is supposed to be fast, but starts up in âsecondsâ. Shame.
VS Code also starts in "seconds" on my machine, so if that's what they're targeting it's probably a success.
Vim/Neovim is practically instant, everything else it too slow in my book.
Considering the tools developers use in general (Visual Studio, VS Code, Eclipse, IntelliJ, Netbeans, various DB browsers, etc.), application start up time doesn't seem to be an important concern for the majority.
My IDE stays open (I keep all the common projects I work on open and just switch between them as needed). I rarely reboot. Startup time is completely irrelevant.
You typically leave an IDE open most of the time, and maybe start it up in the morning at most a few times a week.
For that, a cold launch time of a couple of seconds (VS Code) is fine, tens of seconds (Eclipse, XCode) is annoying.
Opening new files definitely needs to be instantaneous.
Yeah turns out the language server and other IDE features are resource intensive. Who knew. TextEdit also starts in under a second.
Why not starting them asynchronously? That's how Neovim does it. The editor starts instantly and the language server integration is enabled once the language server is active.
I use Vim with a language server and 10 other plugins that give me almost everything JetBrains offers. Only thing JetBrains is so much better at is fixing merge conflicts.
Vim still starts instantly, and I never have to wait for it to index anything.
JetBrains is amazing, but I hate waiting for it. It stops me from starting work. Maybe that's just my problem.
On a given workday I always have at least one window of vscodr open that makes opening new files much faster than a cold start like vim et al are used
Once vs code and similar are up, the observed latency in opening additional files is what matters to most devs though.
Doesnt' really matter in my daily life if some IDE takes 0.1 or 10 seconds to start, since it's done so rarely. Might be more annoying with an editor if you're opening files often, then it starts to add up. Or if the editor is slow with editing and scrolling big files, like VSCode is.
exactly this.
I take 30 minutes to get into flow state, how long the IDE takes to start is irrelevant.
On my old laptop, it took like 15 minutes to start IntelliJ IDEA
_Space Fleet_
The goal is not to replace VSCode (hardly any money in there) or Intellij but to fill a gap in the Space offering. Space is IMHO JetBrain's main strategic initiative for the next 10 years (and very promising).
What do you mean by space?
https://www.jetbrains.com/space/
Reading this comment thread, itâs weird to me how entitled software developers seem to be about free tools. Is it really that insane to pay $100 (or whatever) for something you use all day every day?
I would love the future IDEs to be fast with low footprint instead of slow monsters running Javascript in browser behind.
Is VS Code slow? I mean, Notepad is faster, but considering that VS Code is JS-based, it's actually fast and responsive.
Is this the beginning of JetBrains trying to reiterate what MS did with VSCode + Copilot?
After I spend a couple of weeks with Copilot I must say it works more or less as advertised (the exceptions are funny though) and there is no comparable product in sight. In the business of development tooling this is probably a feature not to miss in the long run if you prefer to stay in said business.
I realize there is Copilote integration for JetBrains IDEs as well. But it's one thing to have access to a resource. And another to have control over it.
While weâre all here, does anyone know how to make CLion a lot snappier? It seems to get reeally slow once youâre working on a pretty sizable codebase
You can try these steps
https://iam.georgecox.com/2021/11/24/making-jetbrains-ides-r...
If it's in Java it's not exactly lightweight.
VSCode is Electron. You can't be more heavyweight.
You never started any Java-based IDE, did you? You can smack tons of plugins into VSCode, enable them all and it still loads faster.
Not using any of the above mentioned anymore, so I'm not teaming for one site.
Even with all those plugins it does a fraction of what IntelliJ provides, so it is apples to oranges.
Java itself doesnât have that slow of a startup.
Java gui libraries are slow to start. Java starts fast but then GUI starts to load and it takes time.
If it's got IntelliJ's keybindings, I'm game. I've been a JetBrains user/customer for just under 20 years, and my brain is now hardwired for them. I've got a residual part of my brain that can do Emacs, but VSCode has never been pleasant for me, so I'm into this if they can do it right.
This file's contents may not be suitable for people under the legal age.
Please confirm your birth date.
Fleet is not open source, offers little over VS Code and is not as fully featured as the full JetBrains IDE's.
Who are intended to use this?
The program isn't even publicly available yet. How can you conclude that it provides little over VS Code?
And why does it matter that it's not open source?
> And why does it matter that it's not open source?
I honestly find this question really weird. Do we really have to explain such basic things nowadays? It may not be important to you, it is extremely important to me, and (apparently) xyproto.
And that's why you're not using Windows, Mac, Android, or iOS, but only Linux, correct?
Mostly people want open source but they'll happily abandon it for convenience. That's how Gmail won over Dovecot.
That's exactly why, free/open source enthusiasts are just the minority type to prefer freedom or privacy over convenience.
The non open source part is a bummer but its not Electron based. So its gotta be faster than VSCode.
People like me who like all the other JetBrains IDEs and have a toolbox subscription anyway.
As long as it isn't Electron-based, I don't care.
I can see this being huge in a team with tight tool parity. I probably wouldn't use it as a freelancer, but remembering back to when I worked at an agency where we all had the same software and a pool of environments for all the different clients, this would have been the perfect tool.
I know we all want to be special snowflakes, but my advice for a fast moving coherent team tooling includes having everyone on the same environment and using the same tools, so that you can share knowledge and master your tools as an individual and a team. Troubleshooting becomes much more reasonable, and we can all share the useful shortcuts we slowly build up over time.
That's one of the downsides of tech moving so fast, no one masters anything, as a generalized industry we're eternally noobs.
I love Jetbrains products.
I happily pay hard cash for what is my primary work tool âŠ. a really capable IDE.
Supported Language: Java, Kotlin, Python, Go, JavaScript, Rust, TypeScript, JSON
Coming Soon: PHP, C++, C#, HTML
Right now 307 Comments I am surprised no one has mentioned it. Ruby isn't even on the Coming soon list.
I'm excited to see this and signed up for the preview. It's just in time for M1 Pro MacBooks. I spent hours stuck on the _very first_ thing I tried coding on my new laptop because of a missing linux-aarch64 binary wheel on PyPI and had to figure out what was happening and how to build it from source.
If this is priced close to JetBrains' other products and works decently well I could see myself signing up for it. The subscription would pay for itself in one averted experience like this a year :P
I struggle to see this as "lightweight," unless they mean "just on my machine." The maintenance burden to the organization looks quite ridiculous.
I would love to see a version of this which can run on an iPad. Combined with the Magic Keyboard and it would make a nice code environment in conjunction with a server, or a cloud instance.
I marvel at those of you who can code on an iPad. How are your eyes so good? I have a 32" monitor running at like 120% zoom and can still barely read the code. Curse my ancient eyes!
Not that exciting tbh. You showed nothing new and it's probably going to be paid software (closed source for sure), and comparing that to VSCode + Copilot (which is blowing my mind day by day) I don't see why would I switch. And that pair programming session is so faaaaaake.
My issue has never been the actual cost of JBs products, but rather I have to go and justify myself to a manager to get a license. That's something which of course is not a factor when you're using open source stuff, but maybe I'll still buy this for my personal use. Vs code was supposed to be a lighter weight visual studio, but at this point it's hell bent on becoming just as bloated.
I suppose something like: âHey pal, you pay me 400k a year. How about we spend 200 bucks a year to make me 10% more productive?â
It depends on your company.
Many places will spend 500$ to decline a 200$ expense.
I wonder if this a reaction to Microsoft gaining developer mindshare through VSCode, Github codespaces and other integrations around VSCode?
It could also have been a response to requests for better remote development support due to the WFH situation in the last ~1.5 years.
Don't know if there is a way for use to know which one though.
Does the remote development focus mean that it will also provide a better WSL integration than the rest of the Jetbrains line-up?
I see no mentions of WSL even though it might be a strong selling point specially if this is going to compete with VS Code.
"We're asked, over and over again, by the guidelines and by moderator comments, not to editorialize titles like this." tptacek
Really weird name for an editorâŠ
I love IntelliJ and have paid for it for years now so I will probably check this out. VSCode has always felt too different.
How does it compete against their other products? This seems to contain more than PyCharm and Gogland.
Yes! As someone who uses IntelliJ for writing primarily Perl, I welcome this.
Does it have support for LSP?
Yes
https://www.jetbrains.com/help/fleet/1.0/architecture-overvi...
They said it does
Someone is getting too scared from VSCode and decided to counter-attack.
With compose for desktop announced, I was wondering when a new interface would be unveiled. Looks like they are using the migration to the new stack to experiment with a lightweight alternative to vscode. I wonder if it also uses kotlin native and moves away from JVM, doesnât seem likely since they say they are sharing code processing backend with IntelliJ.
It uses a client-server architecture, with with code-completion and other IDE features provided by a server separate from the editor client. I suppose that means you might need the JVM for the IDE back-end, but there's no reason why the editor can't be native.
https://news.ycombinator.com/item?id=29378010
Thanks, sounds exciting. This definitely propels IntelliJ into the future. Beat of luck to them:)
I donât think kotlin native would beat the JVM in performance though, only at memory usage. Not even Graal AOT beats it for long-running tasks and I imagine it has a bigger mindshare behind it.
Vscode online pressure?
definitely!
Got vim keybindings?
How it is different from all other JetBrain IDEs?
Hopefully they keep their promise and the IDE stays lightweight with time!
And their debugger, i hope i can use it to debug native programs..
If the debugger is open, that alone will be massive
That is one area where VSCode sucks, specially for native programs
I am thrilled to hear about the âdevelop locally, build remotelyâ feature.
omg I'm in love with jetbrains now
Oddly similar to vscode. Always loved Jetbrains' IDEs better.
Hopefully they won't be stupid enough to deprecate them. I feel a much better effort would be to heavily work on optimizing performance for their existing suite of IDEs (or perhaps re-write them in Rust or something more suitable than Java/Kotlin).
All java applications are horrible.
DataGrip IDE from Jetbrains requires 966 MB memory just to work with a single (!!!) query file that has few lines of SQL.
I also opened a huge project in Visual Studio 2022 that contains thousands of files and it only needs 735 MB memory (however previous versions were much slower and less memory efficient).
So, avoid Java at any cost. Even JavaScript-based VSCode is much faster that any Java application.
Built from scratch ehh? I wonder what itâll be priced at. It seems promising. DOA without vim bindings though.
What? Vim bindings is not a deal breaker for majority of users.
The decisive factor will be what does it bring over vscode?
> The decisive factor will be what does it bring over vscode?
Hopefully a native, non-electron mess. I'm excited to check it out. Plugins should fix any holes with respect to vim mode ;-).
> DOA without vim bindings though.
The number of users pining for Vim and Vim bindings is greatly exaggerated.
I wish it wasn't though. I am so addicted to vim :/. Not even a hard core vim script maker or anything though and every 9 months I try to either add IDE features to vim (and give up) or add vim features to an IDE (and give up).
Vim, not even once.
I had a very overcomplicated set-up to for JS/TS/web stuff and recently I decided I'd like to simplify a little.
So now I just install Neovim and then clone LunarVim :) Yeah, my own custom config is probably more slimline, but LunarVim has more functionality and started up faster than my personal config.
I disable a few things and tweak some bindings, but other than that it let's me actually develop things rather than tweaking my config.
Maybe I'll revisit this in the future, but for now I'm happy and probably more productive.
Ah, thanks for the reminder ! I had heard about it some time ago on HN but didn't get back to it. Will give it a try asap.
Not a vim user myself, but it seems like Neovim is getting close to what you want. Of course, there's always Emacs with Evil mode.
Onivim was what I wanted but alas the project ran out of money
https://github.com/onivim/oni2/issues/3811#issuecomment-9103...
I really wanted a visual debugger I could use with the mouse like the one from Visual Studio Code.
So far there a no visual debugger tool like in any of the GUI project I know of that embed neovim.
The IntelliJ vim plugin has over 11 million downloads.
For comparison, the most downloaded plugin is Kotlin, which has 34 million downloads, followed by Scala, which has 22 million downloads.
I downloaded it many times myself bet never get used to it. There are too many conflicts with other key bindings.
Even I have Kotlin downloaded, and I've never ever used it.
Number of downloads is a rather poor proxy for actual usage.
Sure, for users who don't mind not having it. But for me I can't use anything without it. I vim all the things: my browser, my editor (vim of course), and will sure as shit shill for anything that makes more than a half baked effort to cater to my vim obsession. So for <i>me</i> it's a deal breaker, might not be for you.
For years folks have been asking us, âJetBrains, when will you create a lightweight editor?â
So we gave you anything but a lightweight editor. Lightweight editor implies speed, focused purpose, simplicity. What we get instead is remote collaboration, cloud functionality, and a distributed architecture.
Does this thing support language server protocols for the listed language or will it continue to use Jetbrain's implementations?
What can Fleet do that VSCode doesn't already do better? I'm looking at the architecture description [1], and it seems like it's set up almost identically to how VSCode handles remote editing and language servers. Sure, Fleet is integrated with JetBrains' Spaces, but will that ever stand up to Github's offerings?
I use both VSCode and JetBrains' IDEs in my day-to-day work so I would consider myself as having one foot in either camp, but I'm really struggling to come up with anything positive to say about Fleet, and the description that they've posted isn't doing anything to help me with that.
[1]
https://www.jetbrains.com/fleet/#distributive
Well, I mean to be fair the coding services for most languages in vscode other than js (ie java, c, rust, python, go, php, c#, ruby specifically) suck totally compared to the JB tooling.
Letâs not play âpretend vscode is amazingâ here today.
The plug-ins for many languages are of massively varying quality and some of them _really suck_.
The only thing they having going for them is being free.
So⊠Itâs pretty questionable to say:
> What can Fleet do that VSCode doesn't already do better?
Obviously, support languages with the full range of JB tooling, that is _categorically better_ than the pathetic support vscode offers for, say, c#.
âŠbut, those tools cost $$, and if you mean, âis it _worth paying for_ the things Fleet can do over vscodeâŠ?â Well⊠itâs hard to say.
Probably not for most vscode users.
Yep. Honestly, if Jetbrains made a perfect clone of VSCode, but with all the language support and plugins I use remade in high quality, I'd be happy to pay for it.
>Well, I mean to be fair the coding services for most languages in vscode other than js (ie java, c, rust, python, go, php, c#, ruby specifically) suck totally compared to the JB tooling.
I have to disagree. JetBrains' tooling is superior for Java and Kotlin. For C#, Visual Studio is pretty good these days, even without Resharper. For everything else VSCode is unquestionably better. I can just point VSCode at a directory full of Python files with a virtualenv, and VSCode just "gets it", and lets me jump right in to editing, with autocomplete and suggestions. With PyCharm, I have to manually configure the interpreter root, set the project root, and wait for it to do a bunch of indexing before I can do anything at all. Yes, once it's all set up, I have _marginally_ better suggestions, but as VSCode's Python tooling gets better, that setup cost becomes less and less worth it.
>The plug-ins for many languages are of massively varying quality and some of them _really suck_.
Agreed, but that cuts both ways. I would argue that, at this point, VSCode's Calva plugin for Clojure is superior to IntelliJ's Cursive. Similarly, I found VSCode's Rust plugin to be easier to set up and get started with in a WSL environment than the Rust plugin for CLion. Sure, VSCode's support for Java is a garbage fire and its support for Kotlin is nigh non-existent, but as far as I'm concerned, both sides have pretty huge blind-spots when it comes to languages that are "second-class citizens" for their respective ecosystems.
>Obviously, support languages with the full range of JB tooling, that is _categorically better_ than the pathetic support vscode offers for, say, c#.
Whether the tooling can be categorically better is difficult to say. After all, the architecture of Fleet is pretty much the same as the architecture of VSCode. They're both editors which use a client-server architecture to enable suggestions and remote editing. I'm not sure how much of JetBrains' IDE work will translate over, and I'm not sure how much of it they want to bring over. As I stated in my other comment [1], unlike Microsoft, JetBrains doesn't have anything except its IDEs. They don't have a cloud platform that is more important to them than IDE sales. The IDEs are everything to them, and instead of making the IDEs better they're off chasing taillights.
This seems like a mid-2010s Mozilla maneuver (like FirefoxOS) and I hope it doesn't do as much damage to JetBrains as FirefoxOS did to Mozilla.
[1]:
https://news.ycombinator.com/item?id=29377859
> For C#, Visual Studio is pretty good these day
Weâre not talking about visual studio. Weâre talking about vscode.
You wanted to know why someone would use it over vscode: the answer is that vscode has poor support for some languages.
Whether you personally prefer the vscode tooling in say rust, to the debugger in clion is your personal choice; but you are misrepresenting the situation if you say the latter, with different/more features, is of no value to anyone.
> I'm not sure how much of JetBrains' IDE work will translate over, and I'm not sure how much of it they want to bring over.
Well, if you caveat your opinion with the assumption that the product will be worse than their other existing products, poorly executed and poorly supported, thatâs a fair reason to think it wonât be any good.
âŠand to be fair, jetbrains _have_ struggled with their various online service offerings.
âŠbut, if you _assume itâs a failure_ donât ask why you might think it would _be useful_.
Youâve already decided that without trying it. What can I say? Youâre right. If itâs shit, there no reason you would use it over vscode.
Maybe it will be; I personally, donât think itâs clear at this point thatâs the case, yet.
>Youâve already decided that without trying it. What can I say? Youâre right. If itâs shit, there no reason you would use it over vscode.
Microsoft had a clear incentive to make VSCode not shit: Azure, Visual Studio Online, and, later, Github. But what is JetBrains' incentive to make Fleet good?
How should I know wtf their product plan is?
Maybe they want to transition people from âpays x per monthâ for an IDE license to âpays per hour of usageâ on Spaces as a payment model because itâs more granular which means more reliable billing? (Same as yearly -> monthly they did previously?
Maybe they have analytics that shows year-on-year decline in desktop IDE usage vs. hosted IDE usage and they want to be part of that market?
Maybe they want to gather a big base of free-tier users that they can up sell hosted plans to?
Why do you think theyâre doing it? âCause theyâre a bunch of clueless idiots?
Come on, jetbrains is many things, and not all of them good, but clueless idiots they are not.
Fleet may end up being a failure because it is _poorly executed_, because it conflicts with the goals of other teams, or for product reasons (eg. turns out itâs $30/month).
âŠbut itâs not a _forgone conclusion_ at this point. Come on dude, give it the benefit of the doubt ffs.
Why would you cling to vscode and never try anything else, and critique anyone for _even trying_ to make something similar, or maybe better?
Thatâs weird.
>Come on, jetbrains is many things, and not all of them good, but clueless idiots they are not.
They don't have to be clueless idiots to make bad decisions. Mozilla wasn't staffed by clueless idiots either, but they still did FirefoxOS. Microsoft is definitely not staffed by clueless idiots, but they've made more boneheaded decisions than I can count.
>Why would you cling to vscode and never try anything else, and critique anyone for even trying to make something similar, or maybe better?
I never said I was clinging to VSCode. In this thread, I mentioned that I use both JetBrains products and VSCode. I switch between the repeatedly over the course of a workday, and so I see the contrast between them repeatedly. What I don't understand is why JetBrains is making a product that is like VSCode but with fewer features and less developer mindshare?
You keep saying, "Give it the benefit of the doubt," but why should I do that? Every year JetBrains' products gets slower, more memory hungry, and stagnate in terms of features. Now, instead of actually focusing on their IDE platform, I see them devoting resources first to Spaces, and now to Fleet. Yes, _for the moment_ IntelliJ is still the class leading Java IDE. Kotlin, same, but JetBrains owns Kotlin so it's no surprise that their tooling is the best. But other than those two specific ecosystems, JetBrains is falling behind.
PyCharm used to be peerless, but VSCode caught up. Their Go tooling is behind VSCode (and so far as I can tell, always has been). Their Rust support is inferior. In Typescript and Javascript, the advantage belongs to VSCode, even by your own admission. They might have a better PHP editor, but who cares? PHP isn't nearly as relevant as it used to be.
From my perspective, JetBrains is going down the exact same trajectory that Mozilla went down when Google came out with Chrome. Instead of buckling down and focusing on making their core product truly excellent, they diluted themselves on all sorts of side projects that, while interesting, never had a real chance of replacing the one product that they're known for.
The last time I compared the Python support in VSCode to PyCharm, the difference was still very huge when it came to more complex situations, where PyCharm usually handled the situation much better.
And also the speed. PyCharm was by far much faster (I mean specifically the code parsing, auto completion, etc).
Hard disagree on speed. PyCharm, in my experience, has better support for refactoring and jump-to-definition/declaration, but it comes at a huge cost in speed. PyCharm will quite happily lock up, even on a high-end Macbook Pro, as it reindexes everything, just because you had the temerity to add a package to requirements.txt. VSCode chugs right along, staying responsive, picking up the new code in the background.
Hi, I'm with JetBrains. Can you describe the "lock up"? Indexing in general is background.