Fleet, a Lightweight IDE from JetBrains
blog.jetbrains.com
blog.jetbrains.com
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.
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.
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)
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
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)
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.
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.
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)
I never bothered with paying for extra plugins and know Visual Studio since version 5.
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 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?
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.
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.
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.
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.
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.
I don't know if that's their actual intent, but I can hope.
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.
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.
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.
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.
Well, you are the technobabbler... :-P
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.
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.
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?
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?
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.
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.
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.
...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.
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.
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.
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.
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.
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.
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.
private person: 150€ intellij only, 250 € all products
corporation: 500 € intellij only, 650€ all products
[0]: https://www.jetbrains.com/store/comparison.html#LicenseCompa...
You can use it for commercial projects. The intent, though, is that only you can use that license of the product. So with my Jetbrains purchase I can work on personal projects at home, or (if corporate IT allows it, apparently they do here) install it on my office computer and work on corporate projects. But I cannot install it on a laptop at the office and walk away, letting others use that license.
You are.
> Purpose of use: General commercial
It just can't be reimbursed.
There are other products that are $199 USD for the first year.
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.
> 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.
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.
All their IDEs are if competitive means "they cost a little bit but they actually work and aren't loaded with invasive telemetry."
That was asked more than once in the comments but got no reply.
Not to mention they have an excellent multi database system management tool called data grip. But you go on and keep using VS code to manage your databases. Have fun with that.
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.
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.
Then, if you are successful, port your workflow to VSCode running in Linux.
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.
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.
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).
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.
That said, your thesis about the relative difficulty of doing this for C++ vs Java seems hard to argue against, and the rapid, continuous growth in C++'s surface area and complexity since C++11 surely hasn't helped.
I will have to admit that VS Code remote features are straight up amazing.
That said, it’s been years since I tried IntelliJ. Am I missing some significant productivity improvement, for TS/JS development?
Usually though JetBrains' editor is used by other languages, which don't yet have as good open language servers, like Java/Kotlin/Scala/C#...
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...
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.
- "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.
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.
And then JetBrains come out with this... That's certainly pleasant to see!
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.
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.
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.
and if I'm going to pay for something like an IDE it needs to be rock solid when the free competition is competent.
however, your tone in this thread implies you're not a neutral player in this. do you have any relation with intellij/jetbrains?
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.
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?
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.
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)
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.
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.
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
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).
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).
I can imagine if this becomes a succes they will update all their IDEs or use Fleet as the new platform.
> 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
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).
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.
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.
JetBrains says the problem is “users are unaware of what an IDE can do” but maybe it is the other way around?
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.
VSCode does it to some extend, but the difference is night and day.
Same goes for most vim/emacs vs. ide discussions :)
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.
The feeling knowing I can relentlessly refactor my code without breaking a thing and not having to worry about typos is just wonderful!
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.
The only solution that works OK is Projector, but I can achieve the exact same thing but less buggy with VNC.
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.
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.
> ...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.
They are turning VSCode into a first class experience when coding mainframe style across OpenShift, IBM Cloud and Azure.
The next decade in tooling will hopefully be promising!
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.
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.
We used CLion and Webstorm. At the time, CLion did not have remote debug but VScode did, which triggered the trial. Switching from webstorm to vscode for webdev was trivial.
From our team perspective, using JB didn't produce noticeably faster turnaround or less bug. It was no brainer to forgo the subscriptions and just use VScode.
For a while, the only thing affected was developer comfort. But everyone adapted very fast and surprisingly, new members to the team are also most likely familiar with vscode already.
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.
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...
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.
And if it is Java, would be there any Substrate VM / Graal tools going into it.
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.
If Fleet supports Wayland natively I might give it a try, otherwise it's dead on arrival for me.
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.
Besides this, I never really felt that Linux was an afterthought though. At least from my experience using CLion.
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 \
"$@"
That was all I was saying.
I will admit that I don't know what your point is. Are you under the impression that the Java platform is lightweight?
In addition to your spurious claims about native code:
- code_1.62.3-167137107_amd64.deb: 77.4 MB
- ideaIC-2021.2.3.tar.gz: 795 MB
That's a >10x factor.
I 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?
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.)
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...
[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.
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.
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.
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.)
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.
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?!
https://youtrack.jetbrains.com/issue/JBR-3729
tells that JetBrains have been working on a JDK17 version of JBR for 2022.1, which amazingly, is almost upon us. I am looking forward to seeing what it's like!
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.
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".
Try the Rider EAP with .net 6 - I find native arm64 .net flies on my M1 mac mini and M1 Max 14" MBP.
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.
Curious, why do you think that?
I hope they support wayland natively but its just not necessary atm.
The first distro to use Wayland by default was Hannah Montana Linux, 10 years ago. Only recently have more widespread distros started using Wayland by default.
Java is old, and Wayland is comparatively new.
In the thread someone from JB mentions it's mostly JVM + some Rust
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.
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 :)
I wonder if they have plan to use Kotlin Native. But dogfooding is always good.
Are their IDEs interfaces available in multiple languages too?
Note that i do speak several languages and my native language isnt English. Still, please dont complicate my programming with translations.
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, 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.
So whats the point in having the menus, debugger etc translated, except for extra confusion?
Would you like the build config files translated too?
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.
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.
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.
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.
The idea being (no pun intended) that you can do remote pair programming
In person you can gesture. That's the hole that collaborative editing can fill.
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.
> 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 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.
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.
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.
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 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.
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.
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.
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.
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.
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.
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.
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.
This one clearly is a self-inflicted wound.
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.
JetBrains is amazing, but I hate waiting for it. It stops me from starting work. Maybe that's just my problem.
I take 30 minutes to get into flow state, how long the IDE takes to start is irrelevant.
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).
Who are intended to use this?
And why does it matter that it's not open source?
> And why does it matter that it's not open source?
Mostly people want open source but they'll happily abandon it for convenience. That's how Gmail won over Dovecot.
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.
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.
Not using any of the above mentioned anymore, so I'm not teaming for one site.
Java itself doesn’t have that slow of a startup.
For instance, given some Java program/project:
1. Clock time from selecting "Run" in the IDE to first line written to stdout (to measure startup time)
2. Clock time from selecting "Debug" in the IDE to breakpoint hit and debugger able to inspect stack (with breakpoint on line N)
3. Total memory used with open project, with single editor window open.
4. Total memory used when breakpoint hit.
5. Clock time from selecting "Run tests" in the IDE to test results are displayed
6. Clock time from selecting "Debug tests" in the IDE to breakpoint hit and debugger able to inspect stack (with breakpoint on line N)
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.
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
Many places will spend 500$ to decline a 200$ expense.
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).
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.
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
Been using it 19 years now.
I love IntelliJ and have paid for it for years now so I will probably check this out. VSCode has always felt too different.
Please confirm your birth date.
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 ;-).
The number of users pining for Vim and Vim bindings is greatly exaggerated.
Vim, not even once.
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.
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.
For comparison, the most downloaded plugin is Kotlin, which has 34 million downloads, followed by Scala, which has 22 million downloads.
Number of downloads is a rather poor proxy for actual usage.
I happily pay hard cash for what is my primary work tool …. a really capable IDE.
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?
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.
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.
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.
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.
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?
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.
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.
And also the speed. PyCharm was by far much faster (I mean specifically the code parsing, auto completion, etc).