[Semaphor]

> Surprised to hear people say that it could be a step up from VSCode.

VS Code is very* lightweight. Both in speed and in features. Comparing it with IntelliJ makes it seem very basic. Now, for some people that’s okay, but JetBrains IDEs are full-blown IDEs.

*: Compared to something like JetBrains tools, or literally any other electron software.

[petesergeant]

Could you give some examples of the differences I would see as a TypeScript developer using a “full-blown IDE” over VS Code.

[5e92cb50239222b]

For TypeScript there's little difference since most of TypeScript support comes from the same language server running in the background (there's an option in the menus to restart it if it breaks, same as in vscode).

Although autocomplete is better (especially for pure JS), it doesn't warrant paying for a license IMHO. Personally, I use IDEA for TS because I use it for other languages where it blows everything else out of the water (so muscle memory).

Also, if you're doing server-side development, it has a very good built-in client for two dozen databases (which pretty much replicates the functionality of their DataGrip product), so you get decent data editing / import / export / DDL support, and excellent autocompletion for your SQL (interspersed among TS code, or not — doesn't matter).

Edit: also, 100% of their products' funtionality can be used from keyboard. I don't touch the mouse at all. I think vscode can support something like that, but with very heavy customization (and even then I'm not sure). Out of the box it pretty much forces you to use the mouse for many things.

[jackcviers3]

I almost never use the mouse in vscode, emacs keybindings and the command pallete and keyboard shortcuts created any time I touch the mouse. But I also don't get everything I want, (like macros and web browsing and face customization and rectangular editing) that I get with emacs, so I only use vscode for liveshare.

Incidentally, I use and pay for tabnine (another ai assistant) in emacs and it's fantastic - single line completions are superior to whole snippets I have to read with copilot, and don't get me out of my flow.

I am surprised the tabnine company completions are way easier to work with than in vscode. With grouped backends, company lsp + company tabnine is great. I'd encourage kite users to try it. Well worth the money.

[ColonelPhantom]

Even if JetBrains does support your language more "natively", what makes it better than using a language server?

As a student I can use JetBrains tools for free but personally, I'd much rather use something like VSCode combined with clangd than e.g. CLion, as I don't see anything that would make CLion better, while the JetBrains UI is downright cluttered.

As for keyboard use, the command pallete (Ctrl+Shift+P) is right there and should be able to do anything. And thanks to the magic of language servers you can use any editor you like, including (Neo)Vim or Emacs, while keeping most of the capability for language specific stuff.

[5e92cb50239222b]

A couple of things off the top of my head.

— advanced refactoring for all supported languages: implement interface, extract interface, automatic "generification" for methods and classes, stuff like that. Saves quite a bit of manual typing.

— built-in database client (which I have already mentioned) which also provides autocompletion for database/table/column names, both for SQL queries, and various supported libraries like ORMs.

— navigation (jump to definition/declaration, find all references, etc.) works everywhere: any supported programming language, XML, files like JSON schema, YAML, you name it. For example, you can put the cursor to a primary key of a table, press your "find all references" shortcut, and it will show the list of all foreign keys referencing that primary key. Same with things like URLs on the client side (for example, the first argument to the browser's fetch() function) — put the cursor on the URL, press "jump to definition", and it will jump to the controller method that implements that URL, including the correct HTTP verb if there are multiple method for that URL. This is just one example, there are dozens of little things like that. All that makes it much easier to work with fullstack projects (to me at least).

— the UI and its "control interface" (so to speak) is consistent. For example, you use the same key combination to jump through search results, list of issues, list of references, etc. etc. Same for other key combinations — they jump make sense, you press what you think will work and it usually just works.

— it also supports fuzzy search everywhere, not just in the command palette. For example, you open up the list of databases, start typing in the name of the table (or database, or foreign key, or procedure, or whatever), and it highlights matching entries and lets you jump between them. Press Up and Down to go though its suggestions. The same mechanism works in filesystem tree, search results, issue list, and so on.

> JetBrains UI is downright cluttered

All of that can be hidden. I have the filesystem tree to the side, the main editor taking 90%+ of screen real estate, and the tab bar on the top, everything else is hidden behind a keypress.

> As for keyboard use, the command pallete (Ctrl+Shift+P) is right there and should be able to do anything

This is not the same at all. Everything can be done through keyboard shortcuts without typing in obscure commands (even though fuzzy search helps, it's pretty slow).

You should use what you think is convenient, I'm not forcing anyone. The more pressure you put on JetBrains by using the alternatives, the better for us.

[jasonjmcghee]

A few that come to mind for me:

Searchable local history (with selective reverting / diffing) is a large value add for me.

The debugging experience is quite good.

The git integration works well- especially blame / navigating through reflog with diffs.

Autocomplete suggestions / behavior is better than alternatives, in my experience.

Auto-fix suggestions / behavior is better than alternatives, in my experience.

[origin_path]

They're launching a new UI that's more VSCode like, way less cluttered:

https://blog.jetbrains.com/idea/2022/05/take-part-in-the-new...

[Semaphor]

It’s not just a new UI, it’s ~~crippled~~ faster to be more like VS Code and not cannibalize their existing IDEs.

[jasonjmcghee]

My understanding is there's Fleet, their VSCode competitor, which sounds like you're referring to, and the UI refresh, which parent is referring to.

The UI refresh is the same IDE under the hood, just way simpler. I control the IDE primarily through command palette (I think many do?) so decluttering would be great- the UI is unnecessarily complex when you can press a key and type a few words to do what you want.

[culi]

I feel like most of these can be accomplished in VSCode with an extension... We use GraphQL at my work and the amount of coworkers I've run into that don't have the GQL extension installed kinda surprises me. It makes a huge difference so part of me wonders if the criticisms of VSC not being "full-blown" enough is just people not being aware of available/relevant extensions (also probably why VSCode now randomly suggests possibly relevant extensions now)

[animuchan]

In my experience JS autocomplete in IntelliJ isn't better, it just shows more stuff. Most of it unrelated and won't work / will be `undefined` if chosen.

It does, however, teach junior developers that the autocomplete is unreliable, which is a good thing I guess — I've seen juniors in statically typed languages like Java fail coding interviews because they couldn't remember any of the syntax, the knowledge was contained in the autocomplete and didn't transfer to a whiteboard.

[marginalia_nu]

I do agree IntelliJ's autocomplete is kinda crap out of the box. But if you turn off all the machine learning stuff it's back to being alright.

> I've seen juniors in statically typed languages like Java fail coding interviews because they couldn't remember any of the syntax, the knowledge was contained in the autocomplete and didn't transfer to a whiteboard.

Is this really a problem? How much Java code does anyone write on a whiteboard outside of an interview or teaching setting?

[animuchan]

This is only a problem if they wanted to get hired, and then failed the interview because even the basic syntax of their language of choice is unknown to them in the slightest.

I didn't invent the rules, I'm just doing the interviews, occasionally from both sides of the table.

(However if I did invent the rules, I'd probably still require e.g. a Java developer to know Java at least a little bit. Is this really controversial?)

[smaudet]

Their support is also often stellar - if something breaks in a free product, get ready for some free support also (read, none, DIY).

And, maybe you think fixing your IDE yourself makes you a better developer - if you are building IDEs, maybe, sure. I'm more than happy to outsource that a company which does this as its bread and butter.

Microsoft, on the other hand, sells (or tries to) enterprise office solutions. They may have optimized for a single use-case (TypeScript), outside of promoting their web-strategy (typescript), I wouldn't expect them to care one lick about VSCode, once it stops being particularly important.

Its also not open source (VSCode), so I would have no qualms regarding that - there is (https://github.com/microsoft/vscode) OFC but the license for the product everyone uses is not (https://code.visualstudio.com/License/). Similar story for Jetbrains - https://www.jetbrains.com/opensource/idea/ is open source while of course IntelliJ, Webstorm are not (https://www.jetbrains.com/opensource/idea/)

[taink]

To be fair, there is a FOSS binary distribution of VSCode -- VSCodium[1], though it is maintained by the community. It operates in a similar way (licensing-wise) to IntelliJ IDEA Community vs. Ultimate.

[1] https://vscodium.com/

[kikimora]

I write a bit of TypeScript recently in both VSCode and WebStorm, I also have many years of experience using both tools. Started with VSCode since it lightweight and this is what I use to edit most of the text. Unfortunately VSCode had troubles indexing the project, refactoring, figuring out types and navigating between methods. Everything works but VSCode hangs for a few seconds every time I do an action that needs a code analysis e.g. go to a method definition. Most of the time it was faster to search and replace rather than to rename a method. WebStorm was the opposite - opens in a few seconds, but then everything works instantly.

[Semaphor]

While I use it for TS/Vue projects, my main experience of differences is with C# and Java, so I’m afraid I can’t.