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.
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.