You mean: spend untold hours scripting and recording interactions that give you about 10% of capabilities of a modern IDE.
I've personally seen long-time vim users switch to Idea after looking over my shoulder.
For information, not all vim users are trying to reimplement the capabilities of a modern IDE in vim.
Some of us are just fine with vanilla vim/vi (and derivatives) because we are comfortable enough with the *nix environment [1] and don't need IDEs' fancy GUIs and integrations with stuff such as code completers, repls, debuggers, tag browsers, linters, etc.
In my opinion if one needs the full capabilities of a modern IDE right in their editor one should go with a modern IDE.
Trying to turn vim into a modern IDE with a zillion of plugins and glue scripts is a leisure activity and a time sink. Or just for the people who want to look cool [2].
I think this is the mindset you are criticizing.
[1]: Read: Already "spent untold hours" in the past, for better or worse
[2]: This is not bad per se. How are we going to impress nerdy girls otherwise? Your development environment doesn't always have to be about "work". Some people are also understandably after a certain kind of "hacker aesthetics". I mean looking at Idea's interface you can't feel like Neo entering the Matrix. Who cares about productivity??
> Trying to turn vim into a modern IDE with a zillion of plugins and glue scripts is a leisure activity and a time sink.
Haha. That's true :) It's possible there's this conscious/unconscious bias against IDEs and "all the cool kids use vim/emacs". So people use those editors, but consciously/unconsciously crave the quality-of-life improvements that many IDEs (or just many other editors) provide. Even the simplest ones like file lists. Or symbol look ups. And then, yeah, it's down the rabbit hole of chasing the plugins, and configurations, and scripts.
I experienced all this myself with emacs (I never grokked vim beyond some basic commands).
Goto definitions, intelligent autocomplete, inline diagnostics, smart renamers, type hints and more are all available.
All with very little configuration and it works the same no matter the language (as long as it as SLP support).
For example: in VSCode you can select/hover over any expression and it’ll tell you the computed TypeScript type. None of the current language server tools for Vim (eg ALE) give you that information [0]. Why would I live without this useful feature just to use Vim? I love Vim, but I love knowing the type the TS compiler thinks an expression is even more, especially when good enough Vim emulation is available.
You can define your own popup(:h bexpr) however you feel, including per-filetype or buffer. Instead of simply operating on the variables it defines to you can also work upon the selection by querying the register(:h quotestar) instead.
As an example, I like displaying wordnet¹ popups when writing prose. Occasionally, I'll also dump diction² output in to a popup too.
However, I do think that using messages(:h :messages) might make more sense for selection info in general. That way you can select a text, call a map to display information, and still easily recall that data when you're in another place via :messages at a later time. Depends entirely on your use case, and once again how interested in writing the functionality you are.
- IDEA understands bindings to Symfony's sprawling YAML configuration files. So jumping between PHP code using a config value and the YAML file defining the value is one shortcut/click away. And more, and more: https://www.jetbrains.com/help/phpstorm/symfony-support.html
- Refactoring: even a small thing like renaming a variable, a method, a config value. Changes propagated through all affected files (with preview of changes). It's impressive even for dynamic languages like PHP: https://www.jetbrains.com/help/phpstorm/refactoring-source-c... For languages like Java? Oooh, boy, see submenues on the left https://www.jetbrains.com/help/idea/refactoring-source-code....
- Symbol search. You know a function name, you can't remember the file? Symbol search for the function name. It's fuzzy, too. https://www.jetbrains.com/help/idea/searching-everywhere.htm...
I think searching was the primary thing that drove people to try IDEA. And I've seen it again and again with emacs and vi users: they spend significantly more time searching for code than I do. Because most of the time the best you have grep/ag/ripgrep which just search through files as and leaves figuring out context to the user.
- Usages. Shortcut/Cmd+Click on anything, see where that anything is used/invoked. Without searching. https://www.jetbrains.com/help/idea/find-highlight-usages.ht... That was another big thing that fascinated people. Very useful in large legacy projects.
This is off the top of my head for that particular job.
But in general, there are significantly more things like identifying errors and suggesting fixes, large-scale refactorings, understading the plethora of test frameworks and letting you run the tests however you like, debugger integrations, stepping through automatically disassembled code for Java and .net during debugging etc. etc.
* CamelCaseMotion, allowing select/delete/change of just one or a number of segments of a camel case or snake case name
* surround.vim, allowing single commands to (for example) change the () surrounding a text to [] or “ to ‘
* a simple one-liner to change a literal Python string to a f-string and back without losing the current edit position
And in general the power of the motion + action vocabulary that lets you compose edits on the fly once you have the motions and actions under your fingers. You don’t even have to think to type ysiw” to put “ around the current word, for example, or vt)~ to change the case of everything up to the next ).
I just select the word (Option/Alt + ArrowUp) and press “. Same for parentheses, brackets, curly brackets and single quotes. ;)
> or vt)~ to change the case of everything up to the next )
Since selection in IDEA is context-aware, pressing Option/Alt + ArrowUp will select the word, then the group (e.g., an expression in parentheses, or a key-value pair in HTML/JSX), then the outlying group (e.g., the scope block, or the tag) and so on up until the full file is selected. For any context/group.
It doesn't have a built-in camelCase transform, but there is a plugin :)
So, in general, an IDE usually provides a much more generic set of commands that are applicable in a wide variety of situations, and that are usually context-aware. Not some very specific situations like "if I'm in this particular place, and I do this particular thing, then do that particular thing".
There's nothing "mouse-driven" in developing with IDEA. Well, except window/panel management. It is objectively bad.