I switched tech stacks from Java on backend to TypeScript on backend and I'm quite happy that I can afford to use VSCode instead of IDEA now. While IDEA is absolutely wonderful IDE with magical capabilities, the speed and the fact that config is obscure complicated XML that can't be easily committed to the repo makes me want to use something else. If had to do java I'd still go with Idea though, whatever that thing from RedHat in VSCode is, it is not even close.

I used to be someone who used sublime when it was cool, then atom then I switched to vim then spacemacs. But I sorta gave up on that stuff cause I hate spending time maintaining configs especially when I switch languages so often. Now I just exclusively use jetbrains IDEs with ideavim and only minimally add configs when I get annoyed enough by something. I like how when I switch languages and use a jetbrains IDE I get a really nice consistent IDE experience and I just need to discover the language specific features as I go no need to maintain some complex configs and try to find the best plugins. I can always trust that the code completion is gonna be pretty smart in whatever language I’m in as well.

My backup IDE is spacemacs for the same reason minus the smart code completion (getting better with lsp).

The only disadvantage is I currently work on a frontend team and I constantly get laughed out the room for screensharing webstorm instead of vscode lol

I'm with you faizshah!

I like WebStorm just because they have a team working on making things work out of the box instead of a group of plugins. When I switch languages, everything is exactly the same.

Does your team really think that WebStorm is for amateurs?

I've seen plenty of projects commit their configuration. You just commit the .idea folder.

Not sure about Idea, but PyCharm directly supports syncing the settings into the git repository. File / Manage IDE Settings / Sync with Settings repository. It autocommits & pushes when you change something. I've been using this for years to sync my settings between home & work computer.

The red hat plugin is the eclipse language server. I’d choose it every time over IDEA personally. It starts fast and the ram usage is way lower, especially when running on the latest vm.

Knowing many keyboard shortcuts in your IDE (or other tools) is very useful. I advocate to create your own cheat sheets. I've written about it here, also covering PyCharm: https://www.augmentedmind.de/2020/04/26/boost-development-pr...

I do so too, with quite similar arguments. I have a blog post about learning all VSCode Shortcuts[1] (did the same for PyCharm) and how it evolved my developing habits. Without learning the shortcuts, many IDE features are not usable. So, if you don't learn the shortcuts, you will not start to use these new features. Consequently, learning shortcuts on the go often does not work.

I fully agree also on creating your own cheat sheets. That's why I have developed an entire app around this idea: KeyCombiner[2]!

It let's you create your own collections, practice them via an interactive trainer and spaced repetition, look them up without context switch through the desktop app's instant look, visualize them on a virtual keyboard, etc.

[1] https://tkainrad.dev/posts/learning-all-vscode-shortcuts-evo...

[2] https://keycombiner.com/

They mention `Key Promoter X` in the article, which looks interesting. Whenever you perform an action, it reminds you what the keyboard shortcut for that action is

I just discovered this a few weeks ago. It is not too annoying where you hate it for shortcuts you don't care about, but just annoying enough where you'll learn some new shortcuts. However, it doesn't discover stuff like swapping between tabs.

I really want this for vscode, but I've never seen an extension like it.

FYI emacs does it too (by default?) and i find it very useful! when i use intelij editors i enable that feature too

Another trick if you don’t know the shortcut is the global search.

Just double click shift and type what you want to do. Eg Indent code. Even if you need to type a lot it’s faster than moving the mouse. As bonus the hotkey is printed in the same menu so you can use it next time.

Vscode has its equivalent at ctrl+shift+p.

> Vscode has its equivalent at ctrl+shift+p

Or F1. I've set this key mapping also in IntelliJ. It's faster to type than twice the same key.

I find it really annoying that the mac version of the IDEA shortcuts is totally different from others since I am using 3 platforms at the same time. In the end I settled with vscode set. And as a bonus I could use the same set for both idea/vscode :/

Going with the VSCode set is a good approach as it has the same bindings as the Chromium DevTools which cannot be changed.

It's really ironical. I want a key set to work on all platforms. In the end the vscode's is the best :/

I believe there's an option to switch between shortcuts in the settings.

There isn't a unified set that works on idea afaik. They are very different unlike other sets which are just thumb on cmd vs pinky on ctrl. If there is one set works on win/linux/mac, let me know.

Acejump looks ace. I really love hop[1] for Neovim, and this is a good alternative for when I'm using PyCharm.

[1] https://github.com/phaazon/hop.nvim

AceJump co-author here. Thank you for the suggestion! If you are curious, you can learn more about some of the unique features AceJump offers and how it compares with similar implementations here: https://github.com/acejump/acejump#comparison

Happy to answer any questions you might have!

I like how acejump is integrated with ideavim: https://github.com/acejump/AceJump#configuring

Will definitely be installing this Monday.

Jet Brains: I love your products so much except for one thing. Keyboard lag. Going to a bare metal linux terminal on 10 year old laptop feels orders of magnitude faster. The joy and pleasure of typing is robbed by keyboard delay :-(

change the boot JDK from the version 11 JBR JDK to version 15 of Azul Zulu.

This didn't really work for me. I already had Azul's Zulu v15 installed so figured I'd give this a try.

I pressed ⌘ ⇧ A and typed "Choose Boot" in Actions, picked "Choose Boot Java Runtime for the IDE", then selected Zulu 15 and restarted IntelliJ… then the outline of main window loaded with its menu, but none of its contents. It was all gray and none of the panels ever appeared. They eventually showed up after I resized the window but I'd consistently get in this state each time the IDE started.

Also, the fonts didn't appear to render correctly. It's hard to say exactly what's wrong with them but the letter spacing and subpixel rendering seemed to be different.

Is there anything else to do to make this work without having to resize the window each time?

Gah. I do apologise. I should have mentioned I am on Linux, where updating to Zulu 15 works like a charm. (Zooming font size in the editor with scroll wheel is ... well, try it before/after :-)) The JBR has some fixes specifically for font rendering among others, on Mac OS X.

Sorry for getting your hopes up. OTOH, Linux on the desktop is pretty good in 2021 :-) In this case, it certainly beats the Mac! :-P

Funny, I used to think myself knowledgeable for knowing what JVM knobs to twiddle out of the box. Now I see that the fact they need adjusting out of the box is a weakness of the platform itself.

Wow. I cannot wait to try this but how is azul different from openjdk in practical terms?

Shouldn’t the latest openjdk release with ZGC be a better option for low-latency?

It would be, were JetBrains IDEs currently compatible with the latest JDK, but they are not, so it's not quite as simple as that, unfortunately.

IDEA and CLion won't start with JDK 16 or later, so I'm using JDK 15 for those. All the other JetBrains IDEs work with JDK 16. In all cases, features using the JCEF [1] runtime library, which is bundled with the JBR [2], will not be available.

I'm using these options on Debian/unstable on all JetBrains IDEs, with both JDK 15 and JDK 16.

  -XX:+IgnoreUnrecognizedVMOptions
  -XX:+UnlockExperimentalVMOptions
  -XX:+UseZGC
  -XX:-UseG1GC
  -XX:C1CompileThreshold=100
  -XX:C2CompileThreshold=5000
  -Xms4G
  -Xmx4G
  -XX:ReservedCodeCacheSize=512m
  -XX:SoftRefLRUPolicyMSPerMB=50
  -XX:CICompilerCount=2
  --illegal-access=permit

Adding -XX:ReservedCodeCacheSize= and -XX:SoftRefLRUPolicyMSPerMB= made all the difference in keeping heap usage down. I have not yet experimented with different values for those parameters.

The option --illegal-access=permit is required on JDK 16, but this option was removed in JDK 17, and because of this (but probably not only this) I haven't yet been able to make any JetBrains IDE work with JDK 17.

In adjusting all of these settings, YMMV depending on your system. Good luck!

[1] https://github.com/JetBrains/jcef

[2] which is currently based on JDK 11

While there are continuous performance improvements, between 15-17 it is probably not visibly so, but thanks for the config!

Ah cool, will try this out. Thanks.

There must be something wrong because they are pretty much best in class in terms of input delay since they improved it a few years ago.

What is wrong is JetBrains shipping a custom build of a version 11 JDK in 2021. Not using the JBR is the quickest way to a responsive JetBrains IDE.

Do you have any basis for this "best in class" claim? Have you tried VSCode recently? I think you'll find that it is much lower latency.

A quick search on the JetBrains bug tracker https://youtrack.jetbrains.com/ suggests that people have had problems over many years across different platforms.

For example: https://youtrack.jetbrains.com/issues?q=linux%20editor%20unr...

>Do you have any basis for this "best in class" claim?

Take a look at these benchmarks https://pavelfatin.com/typing-with-pleasure/#linux

These "benchmarks" are from six years ago in 2015 (which is more than you say "a few years ago") by a JetBrains employee, shilling his own work at the company, on his own blog. [1] Given that six years has passed, those results are irrelevant to today's shipping versions.

Things have evidently got much worse since that study was made. Lately, the editor is plagued not only with delays in syntax highlighting, but also complete lock-ups (keyboard unresponsive in editor panes), requiring the IDE to be restarted.

I have been a paying customer of JetBrains since 2015 and have found the recent offerings to be so goopy and slow that I was ready to cancel and switch to VSCode [2] like everyone else at work. The only thing which stopped me doing so was switching the boot JDK from JBR JDK 11 to Azul Zulu 15 (though I suspect any 15 JDK will have had the same effect.) Cancelling your subscription is the best way to be heard.

Constantly growing and developing software systems collapse under their own weight eventually, and JetBrains' products are no exception.

[1] I find it weird and distasteful that an employee is advertising the company's products in this way.

[2] or emacs, which is wicked-fast with native-comp

The minimap plugin mentioned in this article is unmaintained. Looking at the plugin page, the last version was in 2018 and judging from the reviews, it only works for some users but for many others it no longer does. I would like to know if there is a more mainstream minimap plugin. Does anyone have suggestions?

Is there a PyCharm plugin that maps your functions?

I.e.,

your code is

def function_1 def function_2 def function_3

and the plugin provides clickable links to the function definition

Don’t know about PyCharm, but in other JetBrains IDEs you command-click on a function name and it takes you to the declaration, and command-click on the declaration opens the list of invocations.

Not sure about bare PyCharm, but if I shift click on any function use, it goes to the function definition. When I shift click on the definition, it shows me all of the uses. I use a lot of custom shortcuts for things like refactoring (rename, move up / down the class hierarchy, move to another file, change signature / arguments) and to show quick documentation.

That should be CTRL+SHIFT+click, not just shift click. Muscle memory, heh.

You can do Cmd-F12 to show a popup list of globals, classes, methods, and functions and then you can type to filter the list.

I usually have Structure side panel[1], which shows all of the definition signatures (classes, variables and functions), and probably the thing you mentioned (CTRL+r on linux), and also if you double press shift, it will do a semantic search trough the whole project.

[1] You can see it on the left https://blog.rfox.eu/en/Programming/Tools_I_use/Tools_I_use_...

Scroll wheel click or Ctrl+b does this in pycharm.

Not sure what you mean but listing all functions in the open file is found on the side bar next to your project tree. Or press Alt+7.

In Jetbrains IDEs, with the cursor on the function name press Alt-B. This will jump to the definition.

I did try to use ace-jump in [emacs](https://github.com/winterTTr/ace-jump-mode) but i don't quite get used to it, since it's limited to the current buffer as you see it, i rather use isearch directly or better ace and isearch combined https://github.com/tam17aki/ace-isearch

The idea is, you see something and ace-jump can jump to it. It's not a search function, so it is, as you said, limited to the currently visible text.

Nice, a few more plugins and you'll have a semi-vanilla Vim!

I've been using Vim since 200x (i think 2007, but not sure), some time even as my main editor, but this is simple not true at all.

I've been trying the "built your own IDE from the editor" approach using Sublime, VSCode, and several other editors, but it doesn't work as good as good IDE. Especially the I in the IDE is important. And also that it actually really works and is integrated by someone else. I can't even remember how many times I've got broken things in VSCode, for example when I was using rope (refactoring library) or MS plugins for code analysis.

PyCharm has a superior understanding of the code, which allows you to do refactoring and other things effectively. What convinced me to use it was when I've seen other people use highlevel features like "take this piece of code, move it into own method and set theese default parameters" without even thinking, in split second decisions. I've read Effective PyCharm and kinda decided, that I don't have enough time to try to make my own IDE from things that will never get the integration to the level PyCharm already has. It was a pain (it took me something like two weeks just to map all the keys and set the defaults), but it made me much more effective.

How, vim is an editor, Intelij supports a vim mode(I never tried it since I hate vim) but vim is not an IDE , maybe you wanted to say you put 30 plugins and you get a half implementation of a good IDE.

IdeaVim feels incredibly close to vim. It can read vim configs and supports every motion I use. There's nothing missing.

I like ideavim a lot, but I really hope they integrate an embedded neovim into the IDE like The VsCode community has. There is an open ticket you can show support on: https://youtrack.jetbrains.com/issue/VIM-858

Almost. Occasionally you notice some small differences. But it’s impressive how close it is.

Makes me wish I could compile it myself. Sadly compiling pycharm extensions isn’t for the faint of heart (or drive space).

My essentials:

    - IdeaVim
    - Cmd-/ to split and move right
    - Cmd-<left|right> to cycle through tabs (inspired by iTerm)

I'll add to this Stardock Groupy. Idea cannot open multiple projects in the same window but with Groupy you can simulate it. It will put your idea instances in tabs of a single window. I find it much easier this way to switch between multiple things I have to work on at the same time.

I love jetbrains' products, but I really miss the days where intellij ultimate was essentially an all-in-one release.

I'm in a polyglot environment, and it's frustrating to jump from editor to editor.

Can relate. Key promoter is particularly interesting. What I want to see is something for datagrip that one keys to export all unique values of a certain column.

Just a little warning: multi cursor can fxxx up your code and data in unexpected and horrible ways if you forget to ESC

You can just undo. And when you can't for some reason (you restarted the IDE or something), you can just look at the "Local history" and return back in time to any previous state.