Switching from Vim to Intellij | Hacker News Reader

Switching from Vim to Intellij

browntreelabs.com

186 pointscpow85258 comments

>Everything is pre-configured: You don’t have to worry about setting up tags, or YouCompleteMe, or NERDTree. I can’t tell you how many times I open a new project, perhaps in a different language, and everything works great out of the box. It’s a total sigh of relief.

I agree 100% here, if you value these types of IDE tools I don't recommend going to Vim. It frankly sucks at this stuff, it wasn't meant for it and it's not the type of things you can easily tack onto a codebase not meant for it. Doesn't stop people from trying of course, and some do an amazing job at it, but it rarely reaches the same level of polish and simplicity as good IDE solutions.

But on the other hand, please consider the Zen of dumb tools: I code all day in Vim and I don't use YouCompleteMe, NERDTree or anything like that. I use dumb, language-agnostic completion and dumb, language-agnostic FZF and Rg for searching and navigating the source code. If I'm feeling fancy I use universal-ctags, but if it's not here FZF and Rg do a good enough job.

Is it as fancy and fully featured as an IDE? No. But like the author I like when stuff just works, and dumb tools work reliably regardless of what I'm editing. It works in emails, it works in man pages, it works in custom DSLs, it works in config files, it works in HN comments if I decide to edit them there. And it's always instant.

+1 on vim with fzf and rg being enough for almost any task. I use that setup for most things and then when I need something with a little more syntactic awareness, I pop open my IDE.

The killer thing for me is how IntelliJ has the best cross-language embed support.

So it not only knows when strings in my python code are sql queries, but it autocompletes in those strings against my actual schema

And I recently learned that it will open the embedded language in its own editor pane (ala editing code in org mode, if that means anything) and can be a less distracting way to edit without the mental encode/decode cycle

It may have been implied by the "it autocompletes" statement, but it runs analysis on that code, too, catching bad practices such as logic errors, common mistakes, and unused code (where applicable)

One can influence its embedded language detection via `language=RegExp` (or whatever the language id is) while inside a comment right above the embedded language literal: https://github.com/JetBrains/intellij-community/blob/idea/20...

How do you hook vim up to email and HN comments?

Email is easy if you are using mutt. HN comments... I'd like to know that, too. Before Firefox switched to WebExtensions, there was a plugin that opened gvim when you pressed some hotkey while the focus was on an textarea. Now there is textern, but it requires some additional binary.

There still are plugins, you just need a helper tool on your system to run the actual commands.

Tridactyl provides the feature but if you just want external edit without the intrusive vim binding layer you can try Textern, it worked well back when I tried it.

For email mutt is obvious, but I also recommend aerc, though it's still beta and does crash sometimes. And I'm writing this from w3m, in which you can just navigate to a textarea and write to it in your $EDITOR. For general browsing it's not that great due to its lack of js/css support, but I find it great for commenting on forums which usually still work with html forms. Interestingly, w3m used to work with gmail as well, but sadly you can no longer log in without javascript.

I use qutebrowser, and one keystroke opens vim. When I close the editor the contents of the Vim buffer appear in the browser text-entry input.

I know vim isn't for people who want everything set up out of the box.

But I think installation of the extensions for LSP / completion / navigation etc.. features could've been easier. In my limited experience, it's a hassle getting these tools to work.

This will get a lot simpler in the next couple of months when Neovim 0.5 ships with built in LSP support.

Wow. Good to know. Thanks.

> But on the other hand, please consider the Zen of dumb tools: I code all day in Vim and I don't use YouCompleteMe, NERDTree or anything like that. I use dumb, language-agnostic completion and dumb, language-agnostic FZF and Rg for searching and navigating the source code. If I'm feeling fancy I use universal-ctags, but if it's not here FZF and Rg do a good enough job.

I understand this preference, but it's also important to recognize that you are essentially programming with one hand tied behind your back when you are choosing to use such tools instead of an IDE when one is available.

For example, free IntelliJ can do "Data flow from/to here" analysis on your code for Java (probably others as well), which analyzes your whole project and finds all the code paths that use/provide a value for a variable, at any depth of calls. For a medium-sized product, finding the same information with Rg is easily 30m of work; if you need to navigate between the levels to find a bug, you'll lose even more time.

Also, refactoring tools that an IDE can give you make certain programming tasks trivial at 3-5 key presses which would easily be a 2 day change in a medium project using basic text processing tools.

Especially now that most IDEs also support VIM or emacs key bindings, it is very rarely a good idea for medium-to-large codebases to rely on text processing tools instead of a full IDE. Note that I'm also considering vim/emacs+language server or similar extensions as an IDE (though LSP has quite a way to go, especially on the refactoring side).

For small projects, or for languages with poor code analysis support, I do agree that these advantages don't amount to much and personal preference and familiarity amounts to much more than any tools an IDE can give.

I land in the "if you need an IDE, you already took a wrong turn" school of thought, basically Paul Graham's position in this old post: https://news.ycombinator.com/item?id=72710

granted, we don't always get to choose what language we use or what code bases we inherit.

That's a very strange attitude from someone who proselytizes Lisp, the language which pioneered IDEs about 30 years before other languages really had anything comparable.

Emacs, for Common Lisp, is still a much more advanced IDE than many languages have. It used to actually be a significant ingredient in the secret sauce that made Lisp so powerful - an advantage which it has thoroughly lost to IntelliJ/Visual Studio in my opinion.

There's a school of thought that Slime in Emacs is such a different beast from what is generally considered to be an IDE that it doesn't belong in that category. My guess is that pg belongs to that school.

I guess that is because Emacs is just a fraction of what Common Lisp environments are capable of, so what gets happy with what they can get (as free beer).

> it's also important to recognize that you are essentially programming with one hand tied behind your back

I understand what you're saying but as someone who went the other way (from IDEs to Vim exclusively) I disagree (except for Java, for Java an IDE is mandatory as a result of the way the ecosystem/culture has developed in an IDE centric way).

There are benefits to lack of features. It's a tradeoff of course, but I find that the super simple language agnostic Ctrl+N autocomplete gets me 85% of the way there, and it's so predictable to me that I don't usually need to even look at the menu. I fly through it. With IDEs I find myself having to think about it more closely, and look at subtext for context. That's just one example.

So while I don't disagree with you necessarily, I think IDEs also (metaphorically) require tying some part of your hand behind your back. They are just different parts.

I don't disagree with you. However, I think your example is not great and it's pretty representative of what I've seen many people who prefer vim use.

To me, writing code is a relatively minor part of software development, so auto-complete and such are nice to have features, but not crucial. Dumb auto-complete is absolutely good enough, even for Java.

Reading code, especially navigation and analysis, is a much greater part of the day to day experience that I for one have, and here grep is so inferior to code analysis tools that I really don't understand how people can use it.

Note that I am currently an Emacs user (company won't pay for GoLand), but the extra value added by lsp-mode is maybe a quarter of my productivity.

You make a great point: I wasn't considering code navigation. I did indeed get a ton of value from that back in the day.

For most of what I do the symbol is defined/used in the same file, so a simple `*` (Shift + 8) will get what I need it, but when it doesn't then I'm relegated to grep (I actually use a tool I wrote myself called findref[1]). It gets me 70 to 80 percent of the way there, but that's it.

To me that's "good enough" that when combined with the other benefits of plain vim over an IDE (especially ability to work over SSH like it's local, which I do a lot), it's worth it to me.

[1]: https://github.com/FreedomBen/findref

Sure, I completely agree that you get 70-80% of the way there with very simple tools, and there is value in that.

Just one note about SSH: Emacs and VSCode have a nifty way of doing the opposite of how you use vim over SSH: I can run Emacs on my own system and edit remote files directly and even run remote commands. This has the nice advantage that I get to use my own customized Emacs but still edit files on all sorts of remote systems, including stuff like kubernetes-mode or other niceties.

VI (or VIM) the text-editing language is terrific. VIM the text editor is just a basic editor like notepad, that just happens to speak VI[M?] the language.

IDEs exist that also speak most of the language. IdeaVIM is an extension to IntelliJ that speaks 90% of VIM the language (and also gets some things wrong). I live in IdeaVIM almost all day.

I switched from vim to Webstorm, which is based on IntelliJ. I agree with most of this article. IdeaVim is a pretty good vim emulator (although not perfect, but none of them are).

There's something to be said by having sane defaults that do exactly what you want. Probably my biggest issue with vim is you can easily find yourself in no man's land because your setup inevitably becomes uniquely your own. For example I used coc.nvim in vim, and although it worked great overall, I would often find autocomplete text sitting in an unnamed buffer that I would have to clean up. Despite googling like crazy and even asking for help in a couple vim communities, I could not solve this problem that seemingly only I had.

The article touches upon this as well, saying a 50 line tsx file doesn't work for the author in vim. For me a 1000 line tsx file works just fine, so the author managed to dig a unique hole for themselves there too, most likely.

Totally agree with your point. Tools that allow great personalization are obviously more prone to generate weird problems unless you know what you're doing™. Or to quote a famous philosopher "With great power comes great responsibility".

Emacs Evil mode is the exception here. It’s possibly better than Vim itself.

I keep hearing statements like this and I want to believe. I really, really do. I see the value in Emacs Lisp vs. vimscript immediately, though I feel that Lua in neovim is making up ground there.

I've tried evil-mode a few times over the years. Most recently I tried Doom Emacs twice. I _really_ want to experience the hype of org-mode. I want something like org-mode in my life. I am a heavy notes taker and I can see the value org-mode offers and I am willing to make the jump for it alone... But, I can't figure out how to get a proper workflow in Emacs that gets me to where I am in vim today. I just can't get it to click.

For what it's worth, I've been using vi(m) since the early/mid 2000s and my workflow is almost entirely terminal based for almost everything that I have ever done as a professional and hobbyist programmer. To the point that I feel like I cannot be as productive in ecosystems that are GUI based.

I started using Vim in mid/late 2000s, and successfully switched to Emacs. Without knowing your specific gripes, it's hard no know what'll end up helping you, but here are my two cents:

- use emacsclient and have aliases for emacsclient -c and and emacsclient -n for popping up a new frame or using the console, respectively. I even have a window manager binding to open a new Emacs client window

- Rainer König is the best at getting across org mode workflows. if you like watching nerdy videos, go watch him.

- keep vim around, I still use it, sometimes, but with no or veery minimal config.

- centaur tabs and the new tab stuff can help vim people who like tabs. I just got used to buffers.

- M-x is really Emacs' primary UI. don't try to think of a million and one key bindings up front, just bind what you find yourself using M-x a lot for. You just need a nice completing read like ivy, helm or so, but doom has that.

- use magit. While many claim that org-mode is the Emacs killer feature, I'd say magit is even more important if you code. There simply is no better git interface, nothing comes close. You think git the new porcelain is cool? Magit is a git jacuzzi.

Thank you for this list, I appreciate the effort. I've got some time off of work next week and the kids won't be home, so I'll spend the day digging into this.

To add onto this - I'm a huge org-mode user. If you're on iOS I highly recommend BeOrg[1]. It's the best org-mode app for iphones. It's highly extensible on it's own since you can put in settings and run scheme in a config file[2].

You can purchase extensions for it which are all pretty cheap. You can also pay for a membership to get all extensions - this costs only $10 a year.

The creator of the app is very active in the forums and is constantly updating and improving the app. I love it and it has made my usage of org-mode on the go much easier.

[1]: https://beorgapp.com/ [2]: https://beorgapp.com/manual/scripting/

I'd like to add: org-mode is overwhelming, so just take it easy. Set up a notes folder, sync it to the web, and just use org as a plain markdown/todo list editor for a while. Perhaps add org-roam (like vimwiki with backlinks). Then, only if you feel the need to, give org-capture and/or the calendar/agenda features a try. Don't force yourself to use some obscure feature just because it's there in the manual on page 587, or because you saw someone on Youtube rave about it.

I switched to Doom Emacs about two years ago and while I miss the insane performance and simplicity of vim sometimes, the positives overall outweigh the negatives once you get over the initial differences (workspaces, command names, etc.).

I absolutely love magit. I tried using to emacs as my main development tool but couldn't be bothered to learn a proper workflow yet. I also tried learning org mode but I have no use case for it yet. But magit is just the best frontend for git.

It's not an orgmode replacement, but there is vimwiki (https://github.com/vimwiki/vimwiki) for a degree of organizational support.

I spent quite a bit of time with vimwiki Saturday and today. I really like it. I already stored most of my digital notes in plaintext files so this is a really nice migration path for me. Thanks a lot for the advice!

FWIW, I use Emacs 100% of the time inside tmux.

I used to use Evil mode and now I use God-mode[1].

Evil is great, but you end up having to know Vim keybindings and some Emacs keybindings since Evil doesn't cover everything.

It certainly can with additional Evil extensions and modifying your .emacs, but I still felt like there were some parts of Emacs where I needed to know Emacs key bindings.

God-mode works since it just makes it so that you can use Emacs keybindings without modifier keys. Everything works out of the box. Best part is that you can install extensions without needing to come up with Evil keybindings for them.

[1] https://github.com/emacsorphanage/god-mode

Is it possible to do inoremap jk <ESC> yet in Evil? That's a huge optimization for a really large minority of Vim users and without that, Evil definitely isn't Vim's equal.

Key chord is a nice package for vanilla Emacs at least https://www.emacswiki.org/emacs/KeyChord

That's really no challenge ;)

Have you taken a look at Evil-Escape[0]? I've bound the keys to "fd", because that feels natural, but it's trivial to do "jk". This package works on much more than just insert/normal mode switching as well.

[0] https://github.com/syl20bnr/evil-escape

Can you explain why do you think Evil is so good? I'm an Evil user too and I'm happy with it but I fail to see why it is better than many vi clones.

I've recently been picking up Emacs for org-mode. Evil does not support settings such as `:set nu` or a thousand other settings that I use once in a blue moon but expect to just work. Even `:wq` attempts to close all buffers, `:e` doesn't open files as expected, I could go on.

IdeaVIM get 90% of VIM right, and some things wrong (such as `u` for undo also undoing movements). Evil gets 95% of VIM right. But I have high hopes for NeoVIM allowing an actual first-class VIM implementation to be embedded, not copied, into an IDE or even Emacs.

Can you expand on that?

For me, :wq closes the current buffer. For me, :e works as expected.

There might be a built in alternative to :set nu. How do you expect that to work?

For me, `:wq` saves the current file and attempts to close all buffers, though thankfully asks if other unsaved buffers should be saved before closing.

I was wrong about `:e`, it does work.

Instead of `:set nu` I'm using Alt-X UpArrow+ to find `display-line-numbers-mode`, which does what it says. But there are other settings which I have on muscle memory macro that do not work, such as `:set wrap!` which I use often with my portrait monitor.

I was thinking there might be something interesting here. Then I got to this line:

  "I started a new job working on a large typescript React project. Vim couldn’t handle opening a TSX file larger than 50 lines without crashing."

And I was like LOL WUT? The author's case in this regard woudl be stronger if they helped us understand what was actually going wrong. Bad plugins? Conflicting macros? I'm pretty sure that simply opening a 50 line TSX file does not normally crash vim.

Well, the thing about Vim and Emacs is that the users are expected to figure out configuration problems like these. That's not a point in favor of Vim and Emacs.

Right -- the argument here isn't against Vim per-se, but the entire ecosystem of plugins and configuration that's needed to work and be productive.

Sure, there are a bunch of choices for you to use... but now you have another problem -- there are a bunch of choices.

Exactly. If you argue the pros of vim/emacs using the power that comes with access to extensibility functionalities, it seems intellectually hishonest to not consider the ecosystem and customization issues also for the cons.

Well, some mixed feelings on whether or not it's a point in favor or not. Just like any system, don't install plugins/copy+paste config that you don't understand or can't maintain. I've been able to open tsx files with linting/highlighting/testing plugins and everything works as expected.

On the flip side, if you want easy configuration, then yes, vim/emacs/similar are not necessarily the right choices for you, but I don't think that means they are generally bad options.

> Just like any system, don't install plugins/copy+paste config that you don't understand or can't maintain.

I don't think this advice makes sense at all. I can't maintain cc-mode and I don't understand how it works, yet I rely on it.

Users should not be expected to understand how the TypeScript autocompletion works in order to get it working. I can open VS Code on a TypeScript project and get autocompletion working just based on the tsconfig.json, much of the time.

Oh, I don't mean like you could maintain the library, just the configuration it may expect you to provide it.

agreed 100%.

libraries live or die based on their interface.

I guess it really depends on where you want to spend your time. Time spent customising and tweaking my tooling is time not spent focusing on my core work.

Hence why, despite my interest in Fish, I'm still just making do with Bash, I just can't justify the time to make a proper switch.

Indeed, I routinely edit files in vim that are many GBs in size.

Note that you can still use <favoritesmalleditor> for those big files and the IDE for all the rest. I am using emacs with IntelliJ Idea (one shortcut or action to open current file or selected file in the file list if you don't want to open it in IntelliJ) . I'm using that when I need to edit orgmode files or do complex text processing on a file.

Right, The point was about configuration. I had a configuration that worked for a couple years, then I start a new job and the config breaks on the first 50+ line TSX file. Now I have to go and find the culprit, find a replacement plugin (in this case, yajs JS parser was slowing things down). and before I knew it, I was re-configuring everything again. I was more criticizing the ecosystem of plugins and how brittle some may be.

That's definitely a huge issue. I've had the same experience of having to spend hours to a day getting my configuration set up for a new language. I think part of the problem is that there's no basic config for a language (as with other editors) from which users can tweak, mostly because anyone who tried to get vim users to standardize on any defaults other than those shipping with vim itself would be strung up and horse-whipped as a purveyor of bloat. Vim is a great editor and I love using it, but many community members have a "leet" attitude that discourages new users who need help.

It would be a whole lot easier if someone put together a set of basic configs for various languages that had language servers, completion, etc. and everyone referred new people to those. It's much easier to tweak and replace stuff than to assemble an entire config wholesale.

I was using ALE for autocompletion and such, but having switched to COC, I find its support for TypeScript to be far superior.

This is relevant because COC is basically a system for talking to language servers.

https://github.com/neoclide/coc.nvim

Yep, I too have switched to it and pair it with CCLS for my C/C++ development. It works great after learning it and does significantly reduce the overhead needed for new languages. It's a little tricky to set up for new users, but it's nice that things have improved so much.

> Bad plugins? Conflicting macros? I'm pretty sure that simply opening a 50 line TSX file does not normally crash vim.

These are not questions I've ever had to ask myself in the ~8 years I've been using IntelliJ IDEs for coding full-time.

Maybe it's easy to fix vim in this case, but it's really annoying to constantly have to Google your problem, find a fix, test out new configs, etc.

I left Linux after 20 years for the same reason. I'm happy to pay a small amount to have highly-paid software teams figure these things out for me.

Once coding no longer was on the critical path of my employment (as a middle manager in a large tech company) I went back to vim from IntelliJ with nothing more than syntax highlight and autoindent. The reason? I wanted to know my programming languages better.

Instead of auto-imports and auto-complete I was forced to have java/scala docs open for whatever library I was using. Beyond giving me better muscle memory for the core language libraries, this had the interesting side effect of only using well documented libraries.

The lack of jump-to-definition also made me think more about dependencies in the code I was writing since they would require a cognitive leap and reasonably heavy context switch. Since cross-file refactoring requires bash-fu and is also a heavy process, this furthered my desire to minimize coupling.

I can't say I'm more productive and if I were coding day in and day out for my day job I would probably still use IntelliJ (especially for large Java code bases that were crafted by advanced IDE usage), but I find coding to be a more holistic endeavor now.

IntelliJ lets me read library code way easier. I now pay out of pocket to get IntelliJ just for that privilege.

This used to be the case for me. With the growth of LSP and DAP, it's no longer an issue, and I'm back in Emacs for the vast majority of my daily work (including Java).

I hope LSP beats JetBrains products. It's an open standard and lets language designers focus on their language instead of tooling.

Don't get me wrong, JetBrains products are well polished and productive. I just don't see them being able to compete in the long-term with LSP, which is free and more attractive to language designers.

> this had the interesting side effect of only using well documented libraries

That's great that you get to choose your own libraries. I'd wager most people that are using IntelliJ (or any IDE) also don't often have much of a choice in libraries they're using.

IDEs never seemed to appeal to me when I was writing 100% of my own code. When I migrated to using more and more OPC (other peoples' code), whether project legacy stuff, or third party libraries, the ability to more quickly scan/jump/drill into that OPC, the more value I realized from various IDEs. Mostly JetBrains these days (interested in pairing with folks with their newish 'code with me' plugin/service), but vscode and eclipse make their way in to my life for small periods now and then.

That sounds awfully close to "books will ruin the world. If people stop memorizing their scriptures they'll stop believing" and complaints against progress.

"I write by hand. Using a typewriter will take me away further away from the essence of 'writing'" etc...

"Why would I email? Fax works fine for me and I get a hard copy" etc...

To me it sounds more like if you use orthodics, the muscles in your feet will weaken over time.

> That sounds awfully close to "books will ruin the world. If people stop memorizing their scriptures they'll stop believing" and complaints against progress.

Ok, so wow! No! Definitely not the message I was trying to convey. I love books, have many of them, don't read as much as I'd like, but would _certainly_ love to have more of them memorized! I'm always jealous of those folks who can recite poems from memory and the like.

> "I write by hand. Using a typewriter will take me away further away from the essence of 'writing'" etc...

Off (my) topic, but because you brought it up, writing by hand does increase memory retention! (https://www.scientificamerican.com/article/a-learning-secret...)

> "Why would I email? Fax works fine for me and I get a hard copy" etc...

Well... I do have a very nice laser printer and tend to print whitepapers even though I have a really nice iPad to read them on.

So I guess all of the above could add up to me being a bit of a luddite, which I accept, but really I guess I was just expressing my way of retaining and improving my own knowledge of programming languages that I like. Hard copy reading, hand writing (which I don't actually do much of) and navigating scaladocs instead of tab-completion helps me do that.

As I also said, if my job depending on my coding output, I would absolutely use a full featured IDE of one sort or another.

Totally agree with this. I much prefer being really slow and actually learning a language and writing code I understand vs banging out a thing for work with stackoverflow and an IDE.

> Instead of auto-imports and auto-complete I was forced to have java/scala docs open for whatever library I was using. Beyond giving me better muscle memory for the core language libraries, this had the interesting side effect of only using well documented libraries.

I guess that's nice to know, but it's also almost trivia. I write better code faster in an IDE and navigate existing code faster, and this is having worked in vi, VS Code, and IntelliJ.

Switching from a bicycle to a truck. Vim is NOT an IDE. Yes a lot of people try to make it one, but Vim is not very good at it. You need a lot of additional small tools to even come close to a full-blown IDE in functionality.

It's a text editor.

I share that perspective, but then I guess it comes from using VI (then VIM) for a long time. When IDEs came along, I appreciated what they added in terms of references and build integrations, but as far as being editors of text, they didn't do much for me. Managers of complex text, yes.

Came along into UNIX world, I was dismayed when comparing my Xenix VI experience with Turbo Pascal for MS-DOS, let alone the Windows 3.x versions.

Or even against programmers editors like SlickEdit.

Sure, an IDE comes with all the tools and features right out of the box. But not everyone needs all of them. I don't see a problem with combining tools, which is really easy with Vim as it already runs in the terminal.

I installed a couple plugins in Vim. But those all provide features I actually use and they barely affect performance. But more importantly I just prefer the Vim approach: start out with a minimal UI and feature set and only add or tweak what is needed. No weird and distracting auto-formatting while I'm still typing, more intuitive tabs/buffers and nothing running in the background all the time. I might be an outlier because most editors and IDEs have standard configs that I find distracting and frustrating, but I rather put a motor and bags on my bicycle than start cutting down a truck.

I've tried for years to find the right combination of plugins and configs to make vim (and now neovim) as comfortable as IntelliJ for "large" languages (like Java & Scala), and I still can't do it.

I actually very much agree with you that IntelliJ's all-batteries-included bits can be distracting and frustrating at times, and it's annoying to track down and disable the stuff you don't want. The memory usage makes me cry; occasionally the OOM killer murders it on my 16GB laptop.

But IntelliJ actually does all the things I want it to, reliably, and (mostly) without fuss. vim/nvim just... doesn't. Or I haven't figured out how to get it to do it after hours of trying, which amounts to the same thing.

It makes me super sad, because a part of me rebels at having to use a giant IDE to be productive, but that's just been my experience. I too would rather put a motor and bags on my bicycle than start cutting down a truck, but I haven't found a motor and bags that fit and work right for me, after more work than is reasonable trying.

Yes, Java projects are the reason why I still sometimes use an IDE as well. I agree that there still are some gaps when using normal editors and when you really rely on those features it sucks.

I like how those two choices are starting to converge from both sides, thanks to language servers offering a more standardised way to make editors a bit smarter, as well as other programs getting plugins for using NeoVim as backend for text editing. I just don't feel like any of those two solutions is mature yet.

IDE by what standard? IDE only means integration of tools, not neccessarily that the integration is state of the art. Go back 10, 20 years, and what IDEs could do back then, Vim can now too. On some parts, it's even touching the realm of modern IDEs (mostly because of LSP and VS Code's effort to make it possible for editors).

There are also now "distributions" of vim-configurations, which are taking care of delivering the IDE-experience out of the box and maintained by someone else. Also, don't forget that vi(m) by design is meant to be integrated as the editor-component in the environment of the unix-shell. So it always was part of an IDE from the beginning.

Though, it's true that there is an limit on how much it can do with it's momentary ability and architecture. It's textual, so it' can't copy the GUI-Components of modern IDEs or the assistants. Meaning it will likely always stay a second rate-IDE. But I guess that's ok. You don't need to be the best at every aspect of the workflow. At the end the final results are what matter.

As a long-term Emacs user, I started really enjoying typing with Vim bindings (evil mode).

It feels to me that Vim is great at the low-level process of editing text. Everything else is fine - as good as any power editor, but not inherently great. This is the complement of Emacs, which to me is exactly the other way around.

I've tried evil mode a couple times over the years, but slight behavioral differences threw me off my game. I don't remember exactly (it was years ago on the last attempt), but it was something small like the cursor position being slightly different after some operation like shifting a line.

My "problem" is that since I've been using the same editor for 30 years, I don't tend to think too much about the manipulation of text. So even the tiniest of behavior changes is unsettling to me.

Though I could probably adapt.

I should try it all again (maybe not emacs, but something), and really set up everything well for auto-complete and such (mainly C and Rust). My current vim setup (using pathogen) is sort of a mess.

for me, the basic keybindings are what matter. I use a full fledged ide, but still have vim bindings. When you become comfortable enough, editing becomes quicker and more in line with my train of thought. Thought->action->code change becomes very quick

For me, a killer feature of evil-mode is the "hybrid" state (`evil-disable-insert-state-bindings`) that allows to use emacs (aka readline) keybindings in insert mode.

When I have only a minor edit to make in the middle of typing something (like transposing two characters) it saves me the back-and-forth with the normal mode and it's really sweet.

It probably makes me an heretical freak, but I'm definitely hooked. I guess I am condemned to live the rest of my life in emacs now.

Same, I use a mix of Emacs and Vi bindings. Now I can only function in Emacs.

But I write R/python/markdown, so it works out fine for me.

I want to switch to using Spacemacs and use Evil but on Windows 10 I'm having no luck getting that working due to some weird errors when emacs starts and tries to install the packages. So for the time being I'm stuck using vim.

Spacemacs is overly complicated. Try Doom, or just start with vanilla Emacs, and add Evil.

Thanks. I will try that.

And if you're going to use WSL, check out:

https://medium.com/@elecming/the-ultimate-emacs-hacking-tuto...

I confirm that, switched from an overly complex config to spacemacs then a year later to doom. Doom feels much more polished, faster and require a lot less configuration, at least for my use case.

Sounds like the errors I got installing spacemacs. I think... I forced it to work by changing the access permissions on a folder that spacemacs itself had created.

Portacle worked really well for me on Windows 10, while learning Common Lisp. It's a nice base of settings that can be esiliy expanded upon. Vanilla Emacs was a nightmare. Once I got comfortable with Portacle, I swapped out the emacs folder with the a v28 build for much better performance. Much better than Space/Doom Emacs (on Windows).

I don't really care how good emacs or vim are for text editing, I always crave a good IDE as text editing is just a small part of writing code. It may be because I'm using java/kotlin, and the stuff a good IDE can do there is much more than in some other languages. But the refactoring, find usages, debugging, building, etc is just so smooth and integrated I've become an IntelliJ fanboy.

Refactoring tools do more harm than good and they exist to duct tape the complexity path some programming languages set you on by adding more complexity.

That's... an interesting take. I'm not sure it's well founded, could you expand on your thought?

The refactoring tools in JetBrains products are amazing for me. Renaming a variable and having all uses within scopes renamed too is great. Renaming classes by patterns is also great. Being able to move definitions to new files and have it update all my imports etc is great.

Not sure I see any downsides to optional tools

I mean, Java is pretty notorious for sprawling names like INetworkSessionManagerFactorySidecarControllerFactoryHelper. It's pretty hard to argue that that phenomenon isn't driven by the ubiquity of IDEs in the Java community.

With high-powered auto-completion and one-button refactoring, your brain stops processing the full name. No one's incentive to pause for a minute and come up with thoughtful variable names. For most developers it's too mentally tempting to just puke out some CamelCase word salad, because the IDE hides all the effort of having to read/write/remember unfortunate names.

That's a valid complaint, but at the same time it's not always easy to come up with a good name from the start. I often find myself putting in placeholder names for variables/functions because I'm really not sure what it's going to encompass by the time everything is finished. IDE refactoring makes it easy to clean up names after spending some time with the feature and better understanding what the scope of each function is going to be.

It's great to pause and come up with meaningful names and I agree more developers should do it, but refactoring is a normal part of coding and I'd rather have an easy way of renaming things as the code evolves.

Somebody who is too lazy to choose a good variable name in IntelliJ would also have chosen a bad (or even worse) variable name without the tooling. I don't buy that argument.

For class names it might be true that long compound names are driven by auto suggestions from the IDE. But I'm wondering if they're really as bad as their reputation. Somehow it's similar as for variables. You can still come up with more meaningful names if you want but I admit that auto suggestions do more harm there.

I think the parent post was attributing longFuglyCapsUnpronouncabeName type identifiers to the Java language/culture, As much as (just) the editor?

I’m biased, though. I HATE gigantic supposedly “self documenting” (but utterly impossible to actually say aloud) identifiers.

My ideal identifiers are 2, maybe 3, syllables, with dashes or underscores, with actual documentation of WHY anything visible beyond The scope of a single function is used.

I guess any piece of code will have someone who finds it horrifying. I prefer long, self documenting identifiers over short (often misleading) ones any time.

Sure IDEA is primarily aimed at the JVM market, but I use IDEA's refactorings in Python, Go, Bash etc.

And I'm unsure about your point about meaningful names - IDEA typically won't suggest a name when renaming an existing language artifact - type, class, object, method, function etc.

It will when extracting an expression into a variable, based on the context it was derived from, and that's actually a pretty good heuristic - e.g., if the expression being extracted is

    <some_var> = dependency.get_campaign_results()

It'll suggest things like

    campaign_results
    campaigns
    results

Most of which are what a developer would usually use in that situation.

I'm not aware of any languages so simple that renaming an identifier and its usages isn't a useful feature.

How often do people rename identifiers for that to be a particularly useful feature? If it's not that often, you might be served fine with something like

  sed -i 's/foo/bar/g' **.rb

It's not precise, so it might take some manual work and tweaking with the patterns, but for how often I've had to rename identifiers, it works good enough to handle the bulk work.

A bit of forethought when first naming things works wonders, too.

Refactoring is an essential part of software development. sed is not gonna cut it. The same way that inserting a newline character every 80 or so characters cannot be called source code formatting

Refactoring doesn't consist only of renaming identifiers, and for the portion that it does, regular vim features like `/`, `c`, `n`, and `.` or macros or such are often enough.

That only works if the identifier name is unique across your files. What if you have a field on class "Zoo" named "containers" and you want to replace it with "animal_containers", but only for the "Zoo" class? There are probably other usages of "containers" in the code, with no easy way for something like sed to distinguish between "zoo_instance.containers" and "car_instance.containers".

You need an editor that can understand "this usage of 'containers' refers only to class 'Zoo', so I should find all variables of type 'Zoo' which reference the 'containers' field and change those."

> That only works if the identifier name is unique across your files

hence

> It's not precise, so it might take some manual work and tweaking with the patterns

and like I said,

> for how often I've had to rename identifiers, it works good enough to handle the bulk work.

> You need an editor that can understand

No I don't, because renaming across many files is rare enough that I don't need it.

Most of the time, I do refactoring before it's gotten out of hand and so regular vim features like I mentioned in another comment are typically enough.

In other words, I think such understanding by the editor is too much complexity (and language-constrained, at that) for little reward.

So much so, that I suspect a lot of programming languages not see wider adaptation because of crude tooling. What good does it make to have advanced language features when the development experience is subpar?

I would suspect if a language advertises it has superior reasoning capabilities about code that should also enable a superior IDE experience as well. Where are those IDEs?

No kidding, I tend to wait for Jetbrains to support things officially before seriously trying new languages. I just need my refactoring tools.

It's worth noting that the IntelliJ IDEA Java IDE was Jetbrains' first and it is written in Java. A few years later they invented Kotlin with a focus on strong IDE support. The language was designed from the beginning with tooling in mind.

And still I feel that tooling for Kotlin lacks behind the tooling for Java (but still far superior to many other languages).

Most important problem missed with fancy IDE:

Tiny monitor.

Its like looking at your source code thru a paper towel tube instead of in VR.

Even if you can get a bigger monitor and give up on laptops, you'd STILL get to see more code at once using VIM.

Its "nice" and "interesting" I can see my build system innards on the left and with effort I can click them in and out but in practice people are lazy and just don't get to see as much.

> Even if you can get a bigger monitor and give up on laptops, you'd STILL get to see more code at once using VIM.

At my preferred font size I get ~60 lines of code on a 27" screen in CLion, and at the very most you could get 65 lines in with no borders at all, at least two lines would also be used by vim. So... 3 more lines? For using an editor instead of an IDE? No thanks.

With PyCharm I've managed to hide every single part of the UI besides the editor itself (I only had to get one plugin for the last bit, main menu toggler) and just use keybinds to show parts as I need them, so it's definitely a problem you can solve if you like

When I use JetBrains I have three 27" monitors - one in portrait - and multiple files open simultaneously in all of them, plus build messages, file lists, and run logging. And (sometimes) the debugger.

For some projects I have different language environments - like CLion and PyCharm - open simultaneously. With a browser in the background for checking docs and StackOverflow.

I suppose I could do all of that in Vim too, but I'm not sure why I'd want to.

There are things I'd improve about JetBrains, not least the ability to effortlessly open the same project on different machines. Currently that's clunky for some languages.

But generally it's a damn fine product.

This has generally not been an issue for me, and I code on a 13" laptop most of the time, with no external monitors. Even with all panes but the editor pane closed, there's still the toolbar, tab bar, status bar, and a bit more space taken up, but in practice I just don't find that it matters.

Regardless, "can fit more code on one screen" is not even in my top 10 list of things I look for in my development environment.

You'd like IDEA's distraction free mode then.

> In Distraction-free mode, the editor occupies the entire main window with the source code centered. All other elements of the UI are hidden (tool windows, toolbars, and editor tabs) to help you focus on the source code of the current file. You can still use shortcuts to open tool windows, navigate, and perform other actions.

https://www.jetbrains.com/help/idea/ide-viewing-modes.html

AKA Zen Mode in VSCode (F10)

At the same time some people are using plugins like limelight and goyo too see less in their vim setups.

My IntelliJ tips:

- exclude folders from indexing

- disable unused plugins

- install a theme like Nord

- setup debugging

- make sure you can run unit tests from the IDE

- add JSdoc tags so that IntelliJ can detect type mismatches.

- setup scopes in your project view to show only the files that you are working on.

And these are my personal preferences:

- Disable smooth scrolling

- Disable animations

- Disable code folding

- Hide status bar, navigation bar, toolbar. If you need something use the actions menu... Ctrl (or Cmd) Shift A.

My font settings: Monoid size 14, line spacing 1.5, greyscale antialiasing.

And check out distraction free mode + full screen

> - add JSdoc tags so that IntelliJ can detect type mismatches.

Yes, it's so awesome when colleagues writing lots of useless stuff into the code so they IDE can show some fancy popups here and there.

Yeah, truly useless... I mean, why would you spend $0.0001 dollars in computing power to verify all types in your program if you can spend orders of magnitude more money to have a human do it by hand orders of magnitude slower and less reliably?

Nobody has money for that. Just add the type annotation and let the stupid computer do it, which is what people have been doing for decades anyways.

It seems you have totally forgotten what computers are for. You have much to learn, young padawan.

I use Vim at work, a few light plugins for Go and I'm off. I'm not bothered with auto complete or any of that stuff, and it works great for me.

In my spare time I dabble in Unity, and what I always get stuck on is the IDE for the C# code. It used to come with an IDE that was pretty good, which I forget the name of. Autocomplete and other things worked out of the box. These days it comes with Visual Studio and I find it a pain. Auto complete, etc doesn't work, and getting it to work seems very complicated. I then go on the internet, and someone says VS code is good, so I try that, but run into the same issues integrating with the Unity libraries and so on, and before I know it I have spend a day just on trying and failing to configure IDEs and it's not that much fun to be honest. It sounds like Intellij might be better? I don't know.

At this point I just go back to writing Go in Vim where I am happy and don't have to spend so much time fighting to be allowed to write code.

for unity work you can use Rider, which is basically intellij for C#

Minus several relevant tools from Visual Studio.

I guess it is fine if one only cares about ASP.NET Core, and enjoys a little Java to power their .NET development stack.

I recently switched from IntelliJ IDEA Ultimate to VS Code for Go development (side project), because I don't want to pay for it, when I'm no longer a student. With Golang VS Code works great after getting used to it. The Go plugin is not available for the community edition. For Java and Android development I always used (and still use) IDEA because it's feels much better than Eclipse.

You could always just use the early access builds, which are free, and usually don't have any major bugs whatsoever.

While an OK option if you're optimizing only for money spent on tools, I would still say this is not a good idea. There are bugs and depending on your workflow can be pretty dramatic show stoppers. Value your time more, upgrade when you need new features/solving a problem but otherwise I think stability in your tooling is very valuable.

I pay for pycharm and still used EAP releases for a year without encountering stability issues. I turned EAP off only because it kept breaking my plugins.

I went the other way around (from VS Code to IntelliJ), it has some refactoring support and the like, and I have to work and switch between a few languages during an average work day. VS Code is fine for a lot of things, but not as powerful as intellij.

That said, main downside to IntelliJ is IMO speed and input lag in editor windows, mainly in TSX files. I admit it's a complex language and the fact that Prettier runs on save probably isn't helping either, but still. It has trouble resolving imports, some are done automatically, others you have to select a quick fix options for, and sometimes both work and you end up with the import itself getting munged.

Interesting my frustration with VSCode (for typescript) was that everything felt sluggish compared to Idea. I guess that may be something where hardware configuration and organization of project matter?

VS Code for Go is really good, your move makes total sense.

I was a happy VS Code user (after being a happy VIM user for a while) until I switched jobs from Go codebase to Ruby and then I quickly jumped back to IntelliJ. So far (for me) this is the only editor that correctly figures out most of the definitions and locations of methods/classes/etc.

Intellij IDEA is my go-to tool when working with the dynamic beast Ruby.

Well, actually Intellij IDEA is my overall go-to tool, also now when I work with Go again mostly.

If you plan to be a professional software engineer, then I recommend just paying for the best tools. The price of one hour of an engineer's salary (give or take) can pay for the entire IntelliJ suite for a year.

Sheesh, I wish I was worth $500/hr. I guess I'm not professional enough.

IntelliJ is $149 for a personal license.

That's still more like a couple of hours :)

That's for the full suite, too. Pycharm covers a lot of web dev beyond python and personal is only $89 first year, $71 second and $53 third.

And you don't need to continue your subscription unless you want continued updates. My PyCharm 'subscription' lapsed around two years ago, and I'm only planning on purchasing a new fallback license for the upcoming 2020.3 release because their excellent vim-mode plugin finally supports jump lists, but requires a newer version than the one I originally paid for - and I'm honestly happy to pay them again.

And you will love the new version! So much changed these last too years.

And they allow one to use the personal license at work, so long as no one at home is simultaneously using that license (I'm paraphrasing, and also cognizant that "at work" and "at home" now mean something radically different than this time last year) : https://sales.jetbrains.com/hc/en-gb/articles/207240855-Can-... (going up one level has all kind of interesting other licensing FAQs)

I actually still do that even though work bought me an IJ license because my personal _suite_ license covers more tools

Same. I like using the tools for any personal projects, and it's worth the price for the individual use subscription.

"All Products Pack" for individuals is $250/yr, first year, dropping to $200 for year 2 and $150 for year 3+.

Still quite a lot more than I make in an hour, but definitely not $500. Are you looking at the organization pricing?

The definition of "best" is often subjective and may boil down to familiarity.

On the other hand, betting on open-source tooling may be a good way to increase the chances that your "best" tools will still be available in the future.

give or take 14 hours for me!

For work I currently have to use an old Eclipse version in a slow virtual desktop infrastructure. But yeah I know it's worth paying for good tools.

It gets down to $150 a year which I think is a pretty good deal all things considered.

You should try the redhat java plugin for vscode. You won't even know that you're using eclipse :)

I'm still holding out for proper IDEs with embedded neovim at the core. Vim has a few killer apps I can't live without - custom text objects, vim-surround, and vim-sneak.

This is the dream. Vim for text manipulation, surrounded by a legit IDE.

This already exists in the inverse; LSP.

surround is ported to ideaVim, some other plugins too.

vscode has that, basically connects to a background neovim instance. I use the same vimrc (with minor tweaks for easymotion) for both neovim in cli and in vscode. Although at work I'm still using webstorm with the vim emulator

It might be worth taking a look at Onivim2 (https://onivim.io)

Yeah, I've been following that one for a while, I pre-ordered it. I was a little disappointed they switched from neovim back to vim. I'm sure the engineering reasons were sound, although I didn't understand them and it made me a little less excited about the project.

Not sure how to feel about the goal of vscode plugin compatibility. I'd hope for a vim based ide to kind of "be its own thing".

Why do you prefer neovim to vim? I tried both and as of vim8 there wasn't anything keeping me on neovim so I switched back. I figured any neovim features would be handled by the IDE side

- Built in LSP support

- Moving away from config and plugins in VimL, which is extremely idiosyncratic and awkward to use, towards lua and other languages via rpc

- Long term health of the project - neovim feels like a truly community driven project, whereas Vim seems bottlenecked by Bram and his specific desires. Neovim has also gone to great lengths to make the source easy to maintain long term.

- inccommand (https://neovim.io/doc/user/options.html#'inccommand')

- saner defaults

"Switching" seems like a strong reaction, but there's something to the feeling the author describes.

I use vim quite a lot, every day. I also use IntelliJ IDEA every day. And yes, there's a bit of mental switching I do, and every now and then I use vim navigation keys while in IDEA, but generally it works for me. Different tools for different jobs.

Then again, I have no trouble loading reasonably large documents in vim, so maybe I don't have mine quite as customized as the author.

BUT I relate to the feeling of not being quite sure that all of my customization are quite enough, of not using vim to its full potential. Or even 10% of its potential.

I'm the same way. The wires don't really seem to ever get crossed for me. When I'm using intelliJ, I honestly find that I'm not really typing all that much. I'm either reading/navigating code (and therefore ctrl-clicking on identifiers or using shortcuts for finding usages etc), or typing in a pretty linear fashion that is the sort of thing I'd be in insert mode for the entire block anyway. So when I spend most of my time navigating/reading, it feels really good to have a robust first-class experience with the relevant features in your chosen environment. I know vim can do all that stuff, but it's all tacked on and never (IME) doesn't feel tasked on. Whereas the IDE understands the semantics (the AST) in a way that vim/ctags likely never will.

Some of this is particularly strong due to the language I use most - Java - where the IDE is nearly bulletproof in terms of finding exactly, only, and all real usages of identifiers (it won't ever get confused by two different identifiers with the same name) which isn't true for pycharm/python (though it does a good job honestly, but you can't blindly trust it like you can with intelliJ). I could see how someone would find pycharm not quite as much of a win over ctags, though IMO it still is.

[edit] That said, I still use vim quite a lot. I wouldn't use anything else for editing config files or just examining text content. Especially since you can pipe to it - seldom a day goes by when I don't "| vim -" instead of less or anything else.

Piping into vim is new to me, thanks for the tip.

It's not just vim, either — most command-line tools let you write "-" where you'd usually write a filename, which tells them to use stdin as the file.

> BUT I relate to the feeling of not being quite sure that all of my customization are quite enough, of not using vim to its full potential. Or even 10% of its potential.

There's a lot of built-in features in vim without requiring the installation of plugins. So, you might not need to customize it at all to use more of its potential, just read the manual.

I use and love both, together and apart.

Vim has the advantage of being portable and installed everywhere. I can also create a new file quickly, easier than IJ.

IJ has great Perl support and, the main reason I use it, a sane integrated Git GUI, the only one I've been able to use without tearing my hair out.

Because I'm freegan, I also get free entertainment in the form of IJ's "basic" support for js, html, css.

This post might give some ideas about configuring .ideavimrc https://medium.com/@danidiaz/configuring-ideavimrc-de16a4da0... Although one person's finely honed vimrc is another's absurd unergonomic configuration.

Surprised to not find mentioned one of (neo)vim's main selling points for me - works in a terminal! GUIs, desktop apps are a complete non starter for me.

Give me a well designed commercial, terminal-based editor ( with a vim backend of course ), and I will happily pay for it.

Until then, it's nvim with mostly working plugins and I'm happy.

I guess it is time to revive Turbo Vision.

I made a similar switch and now use CLion instead of pure vim.

For a long time I thought I would miss vim editing experience but IdeaVim is the best vim emulation plugin I've ever seen and I hardly can remember a vim feature that is missing in IdeaVim.

Though I have to accept occasional UI freezes and huge memory consumption of CLion.

The amount of different completion plugins in Vim is something that I also suffered a bit. I tried many of them (YouCompleteMe, Deoplete, Coc.nvim) but none of them really worked properly.

For the moment I mostly code in Python and I settled with a very minimal setup:

1. Linting: python-mode. IMHO it provides very good linting out of the box

2. Completion: jedi-vim. Jedi for python is great. Even though with this minimal setup the completion is not asynchronous I still think it's great.

It took me some time and a recent pruning to actually arrive at this minimal setup. I totally feel it with the author that finding the right set of plugins in Vim can be a bit overwhelming.

I have been using Jetbrains IDEs for a long time now, started with PyCharm and made my way through Webstorm to CLion for uni. It's great, but the RAM cost has been too high for me.

I've been slightly switching the opposite way, using vim more and more for smaller stuff and opening the IDE only for larger projects or work stretches. I definitely love the value of vim as a nifty tool, my workflow is noticeably faster.

As an aside, that cheeky :wq is not missed by me at all, :x all the way!

As for ram usage, I currently have two huge java projects open, and three elm/frontend projects with all the shared packages opened as modules, and it's about 5GB. While it's certainly more than a text editor (still less than chrome lol), is it really so bad? My laptop got 64GB of ram and 34GB of those are sitting unused and 8GB is just cache. I actually prefer it to use more ram than having to recompute stuff or load from disk.

well, there is your answer. You can afford to have it open, I'm running on 8GB ram so the jetbrains ram usage has a considerable cost.

If you are a developer and you can't afford a machine that has more than 8 gigs of RAM, what are you even doing?

studying :)

Are you still in school? If yes, well just take RAM into consideration next time. If no, get your boss to buy you a decent laptop immediately.

yep first year. Funnily enough, I have a laptop grant from uni, waiting to see how those ARM Macs turn out.

Or consider getting a better PC with more ram and faster nvme drives for the same price.

> and it's about 5GB.

IMO yes. My machine has like 8 total and Chrome monopolizes quite a bit.

and lately for me it's been Zoom and Discord on top of Chrome and Jetbrains. Trying to write code while on a call is a recipe for memory giving up.

The computer I bought as a "poor" (western) student in 2012 had 16 GB ram. I can't really see any professionals stuck with 8 GB ram nowadays. As I said, even Chrome will kill a computer with that amount.

So I can see it being an issue, I just think an IDE isn't optimized for that kind of usage, I guess? I acknowledge I'm speaking from privilege here, though, and that probably non-professional users would like to use this software as well.

Fair—I think this ties into a difference into the ubiquity of powerful systems and internet in the west. For example, up until not too long ago, I could not just blindly afford to have a 2GB visual studio toolset downloading in the background for rust without completely blocking the wifi. In general though, that size is literally peanuts.

For what it's worth, I just took a glance at required PyCharm specs.¹ They recommend 8GB and minimum 2GB ram, which seems a bit dumbed down. I can't imagine anyone being able to properly run it without at least 4 gigs of ram even if they have nothing else running.

[1] https://www.jetbrains.com/pycharm/download/#section=windows

Intellij just seems so incredibly bloated and slow to me. I still think older Visual Studio versions (not vscode) as the high water mark for any IDE I've ever used.

I remember lots of talk how intellisense might be harmful http://www.charlespetzold.com/etc/DoesVisualStudioRotTheMind...

IntelliJ feels like coding underwater. The only reason I ever use it when I have to or when I get tired of typing page after page of awful verbose Java APIs.

Intellij is definitely an amazing tool, but if you are comparing it to Vim, then I don't believe it is a correct nor fair comparison.

Vim is not an IDE, and adding an infinite amount of plugins with the purpose of making it IDE-like, then complaining about how slow it is and how much it crashes, and how much better a proper IDE is, is IMHO a misconception of the true power of such a tool like Vim.

in what was is it not fair? People use Vim to produce software and they use IntelliJ to produce software. IDEs try to do a lot more out of the box than an editor, and editors try to be really extensible

What does the author mean by "setting up copy/paste? I've been using vim for about 20 years and just do "+y and "+p

They prob mean copies outside of Vim.

Yes, I was specifically talking about copying things to and from vim, with/without tmux. Maybe its not a huge issue to all, but I always forget when I set things up on a linux machine vs. Mac OSX

gvim on mac/linux/windows will use the + register for the system clipboard. I'm pretty sure that a terminal vim with gui support compiled in will do the same (I know it does on Linux/X but haven't tested on mac or windows in a while).

This is true, but often terminal vims don't have clipboard support. For example the vim that is bundled with Ubuntu does not. This can be especially confusing for people new to vim, or sometimes you jump onto a random machine and find that "+y does not work.

I guess that's another thing to add to my list of "reasons Ubuntu is terrible" it's a minor complaint, but good to know.

[edit]

FWIW, "gvim -v" will probably give you clipboard support in a terminal on ubuntu, and ubuntu might have an "alternatives" tool to make the "vim" in your path have X support. "The Ubuntu packager compiled vim with the feature I want disabled" is a poor argument against vim; it would be like someone saying "I switched away from vim because I wanted to write plugins in Python" just because the packaged version of vim they use has python integration disabled.

"+y yanks to the system clipboard.

"+p pastes from the system clipboard.

I've found it to be a colossal pain in the ass in WSL, since the emulated linux clipboard isn't synced with the windows clipboard. I have to :wq, cat the file, and ctrl-ins to copy.

That's not vim specific though, right? If you ran e.g. vscode inside WSL you would have the exact same problem?

I'm not sure about the specific instance of vscode. Since it's a gui app, I don't think you can run it inside of wsl. You can use a plugin to connect to wsl, but I don't think that's quite the same thing, and I wouldn't expect it would allow clipboard sharing.

The general point is right though. This is an issue with any terminal program that either doesn't allow selection of text, or has a system for selection of text that's separate to that of the terminal emulator.

I used a tool called lamonade that let you access the clipboard of Windows via a socket server.

https://github.com/lemonade-command/lemonade

If you set up VcXsrv (an X-server) then your clipboard will be shared between WSL and Windows and Vim will work as long as you have +clipboard support in your copy of Vim without doing anything extra.

I made a video tutorial around setting it up at: https://nickjanetakis.com/blog/getting-copy-paste-to-work-in...

I used this(https://www.github.com/maple3142/dotfiles/tree/master/.vimrc) to let you yank directly into Windows's clipboard. It was copied from a stackoverflow answer, but I don't remember where is it.

Do you have "+y and "+p configured to use the system clipboard? Does that work for you even when running vim over ssh?

1. I don't have them "configured" that's how it works out of the box.

2. Why would I run vim over ssh when I can use netrw with a local vim?

I've never been able to get netrw to work when mixing Windows and Linux machines and that's the environment I work in. Plus, I usually need to do more than just edit some file and so I rely on screen.

I just fired up a windows VM; using the msys distribution that comes with Git for windows, the scp protocol "Worked for Me" but sftp did not.

As an aside, I just tested it and "+y and "+p work fine with vim over ssh if you enable X11 forwarding. Apparently you may need to use "gvim -v" rather than "vim" on Ubuntu though.

To understand Why Modes Are Wrong™, consider Bret Victor's Inventing on Principle:

https://jamesclear.com/great-speeches/inventing-on-principle...

An app is the Ultimate Mode, of course, and there is a contextual sweet spot where you can draw the line between universality and contextual exclusivity.

This line depends on "nearness" (or familiarity) and your short & long-term working memory, but in general humans seem to enjoy universal modalities like Select/Cut/Copy/Paste that do not require you to switch into "Cut Mode" or "Copy Mode" while you are working with text, i.e. heritable context should provide heritable modes.

And yet, religious Vim users champion granular modes above all, including Selection and Edit modes. My conclusion is that they are either very wrong, or serious users have different neural architectures.

I wrote a similar comparison here:

https://henrikwarne.com/2012/06/17/programmer-productivity-e...

I've got to say that I am still solidly in the IntelliJ IDEA camp.

I've been using JetBrains tools since 2004/2005, and I've become so attached at the hip to IDEA, CLion, etc. that it has become hard for me to work in anything else. And it's really bitten me recently because the codebase I work in (C++, Chromium based) just won't index in CLion, it's so massive that CLion just pukes. That and with my remote work situation I'm really down to mostly using CLI tools, so it's back to Emacs (which I like, and have made work for me, but it's ... not the same)

I fear someday having to do job interviews and having to get up on a whiteboard or use some half-assed shared-coding IDE, because my fingers and eyes, they really want JetBrains products there... I don't type out for-loops, I use generators, etc. etc. it's all so much faster...

Ironically though many think CLion as a better IDE than Eclipse CDT, Eclipse CDT actually works smoothly for large projects like Chromium (https://chromium.googlesource.com/chromium/src/+/master/docs...), Firefox (https://developer.mozilla.org/en-US/docs/Mozilla/Developer_g...) or the Linux Kernel. I've successful used it with Chromium when doing some WebRTC development.

Last time when I praised CDT for embedded Linux developing, I was downvoted by these vim/clion lovers...

Agree with the article. I love Vim, but mostly use webstorm for the same reasons.

I just find all jetbrains products run like molasses, even with a 12-core machine with 32GB ram. I work fairly quick, and get frustrated when my editor holds me up.

Surprised to hear about the crashing issues with typescript, but I don't have any experience there.

JetBrains products seem hit or miss for me.

AppCode is way snappier for me than Kotlin-in-IDEA. AppCode is also more likely to shit the bed and not be able to find a standard library class with ctrl-click.

PHPStorm has never given me trouble.

which part runs like mosasses: the indexing? typing visual latency? bootup time? etc?

All of the above.

I work at a Java shop, amongst thorough-bred IntelliJ users. But I comfortably get by with using Vim/tmux/ctags alone. I do write simple utilities that'd help me be productive. Sure, I could have relaxed in an armchair had I used an IDE, but I feel most at-home with text-speaking utlities, Vim being my go-to editor. Besides, I learned a thing or two while writing those utilities. Masochism? Maybe.

What matters to me is simple, composable, stand-alone utilities. I don't hesitate using GUI or IDE-like tools when it's appropriate to do so. What worries me, though, is that the continued investment and excitement in monolithic tools may mean that newer languages and technologies will be serving those users alone. Simplicity and minimalism may be a thing of past.

I switch from Vim to IntelliJ and then back multiple times every day - one is for fast editing of smaller codebases and the other is for sprawling codebases. One thing I've noticed about IntelliJ though (and any other IDE), is that eventually I manage to get the thing configured into some inconsistent state that I can't figure out how to get out of and I have to restart everything from scratch before I can get things working again - up to and including deleting the entire IDE and reinstalling it. The bad thing about command-line editing is that it doesn't do any magic for you. The nice thing is that it doesn't do any magic to you.

Every few weeks I get my (vscode) IDE into a state where it no longer autocompleted and I have to reinstall it. Have yet to encounter the problem with emacs

I have my intellij idea pretty exhaustively customized for years and i have never had any of these issues described here. you might need to be careful about which plugins you're using.

I knew it was another stack that made the switch.

I use emacs for Clojure and I've been using VSCode for Typescript projects. Both had the largest communites of relevant developers making the best tools. And VSCode has the best TS plugins and the latest cool stuff.

Plus with VSCode I can use VIM mode, which does enough of the job (you know than 90%, minus the 10% which will never be the same).

But I still use Vim for everything else (RoR, JS, Elixir, Haskell, etc). Nothing beats vims speed, portability, or my familiarity and perfection of the config I spent 10yrs tweaking to my liking,

> And VSCode has the best TS plugins and the latest cool stuff.

I don't know why or how, but JetBrains IDEs (WebStorm, IntelliJ, etc.) have much better TypeScript support than VS Code. I've used them both on the same project, and it's painful to use VS Code.

The main advantage of the JetBrains IDEs is that their built-in hinting/linting and code sense are much better. VS Code will fail to warn me about things that JetBrains does by default.

(I say this as someone heavily using eslint, by the way.)

My coworker uses a Jetbrains version for Rails and swears by it. I gave it a shot but couldn't get into it 100%. I wouldn't say it's bad. In my experience of mostly frontend work, I give vim #1, Code #2, and JetBrains x edition #3.

Something about Code just works well for me for Typescript/Vue frontend work. But TBH I haven't tried TS in JetBrains. All I know is all the main TS devs seem to use Code and all the latest and greatest plugins get there first. It takes quite some time for them to filter down to Vim's community.

Maybe I'll give it another shot one day as TS matures.

I can't get on with IDEs, I find them too heavy and difficult to customise. I used vscode for a while in vim-mode but it's not as ergonomic as my neovim configuration.

I can get documentation for a function by pressing K and jump to the definition or do a global rename using some other key combination. I work on a few tens of languages but have language servers integrated for them all and have installed syntax highlighting for everything in existence.

Overall it's easy to manage and modify, and performs well.

I've switched back and forth between VIM and VSCode for the past year and eventually VSCode won. While I was generally more productive in VIM, some things like auto imports[1] in a large library were too big a deal to give up.

My frustration with VSCode has been growing lately though as our codebase has swollen and many of the neat features have been breaking or missing the mark. Plus it has this annoying new behavior where it pops up two things at once which makes distraction free typing difficult.

Fair warning, please also check out JetBrains' IdeaVim plugin for modal editing. I got somewhat serious RSI from vanilla IntelliJ from using the mouse and all the ctrl/cmd modifier commands. Although I currently use emacs with boon modal editing, I'm sure JetBrains would take good care of you with their vim simulation layer. An ergo keyboard helps, too.

I install Ideavim as one of the first plugins after I install IntelliJ. It works a treat and combines the best of modal text editing with the power of a full IDE like IntelliJ. Can't recommend it enough.

just use the damn text editor or ide of your dreams

also, question your workflows that you think are necessary. maybe they all are! a lot arent

i can get away with so much (basically) vanilla vim in a decently large codebase, but i know some of the lower level backend folks really really lean into heavy vim plugins and or ides because their loop/awareness is much diff than mine

Recently I've started using Vim bindings on my VSCode setup and although initially I was much slower than usual, now I feel confident enough to not touch the mouse most of the time. What I did was go through vimtutor every day before starting work as a warm-up and then slowly I started searching and reading around things I can improve.

I don’t know about intellij but I did use Webstorm for a few years, nice UI, but eventually it just slowed down to a crawl and was unusable. The support team kept saying to wait for the next release, which never fixed the issue. Very bad experience. Changed IDEs and all the slow down issues disappeared instantly. I won’t try them again.

I am the opposite, I paid full bundle version for Intellj(all its IDEs) annually, but still feel I can code more efficiently under vim, so I spent two weeks to fully configure my vim early this year and now it's my daily IDE, i have not touched Intellj since Jan,2020, life is much better after switching from Intellij to vim for me.

Little off topic, but it unfortunate that the ultimate edition doesn’t include C/C++ and I have to buy yet another pack of “all products” to get that. I pay out of pocket and have yearly subscription. Not sure if the next thing they make for, say Rust, will be yet another thing to buy

Isn't CLion rolling in Rust?

Currently that's where their Rust plugin runs. I could see them breaking it out into its own editor like they have with GoLand.

The Rust plugin runs well in the free ones (IDEA & PyCharm)

One thing you can't do in vim (that I'm aware of) is write code using proportional fonts. I know I'm an outlier here. An HN post actually converted me.

I use Input Condensed proportional font. I love it. I have a hard time with vim because everything feels so ... wide and spaced out.

As a longtime WebStorm user I would really appreciate a WebStorm + let’s say PyCharm vs IntelliJ. I’m a bit happy by the default configuration of each dedicated IDE, rather than clicking around in IntelliJ and fix stuff. What’s your opinion on that?

According to this JetBrains engineer, WebStorm is a subset of PyCharm:

https://intellij-support.jetbrains.com/hc/en-us/community/po...

It is not obvious from that Pycharm is actually a complete web developer IDE tool. But it has to be to support Django, it's html templating, and associated js.

Pycharm goes further and supports React and modern web toolchains as well. I suspect jetbrains would rather have you buy an intellij license if possible.

Reading it, think he's speaking conceptually. In practice it's more that PyCharm and WebStorm are both IDEA's base framework + language extensions. In the case of WebStorm you get IDEA + the HTML5/web dev extensions and in the case of PyCharm (commercial edition, anyway) you get IDEA + both the Python and the web dev extensions.

I believe RubyMine is the same, if not all of the other paid IDEs in the Toolbox. They all include WebStorm's functionality since you can build a web app in pretty much anything, at least on the back end.

Absurd he doesn't mention https://github.com/JetBrains/ideavim

Does Intellij have remote extensions like Code? That's THE main reason I started favoring Code over Vim. Code's plugins working seamlessly over SSH is wonderful.

Is there something like Code-Server/Theia for IntelliJ?

What problem does this solve?

Never been an ide guy but if you like vim and considering switching to something else because of it can’t handle certain files, consider switching to neovim.

One thing about Intelij, that’s surprising is it’s written in Java. I am not sure what optimizations they do but it doesn’t feel sluggish for the most part.

> Everything is pre-configured: You don’t have to worry about setting up tags, or YouCompleteMe, or NERDTree.

I don't have to worry about any of that with Vim either. I have a dotfiles repo on github which I sync to any new machine I set up. There's a script inside which symlinks the configs and .vim directory into my homedir. I've been using this for 15 years with very minor tweaks. It works.

Intellij sucks! It forces you to buy the latest macbook if you want to develop for Android normally.

VIM is the best. VIM uses less than 2gb ram. Be like VIM.

I guess for stupid rich people point and click is nice, but don't force me to use slow crashing Intellij. I did not even know the beach ball was still a mac feature until I used intellij to write Kotlin.

I have a 2016 macbook and android studio runs fine along with a copy of IDEA, 10 chromes (electron), outlook, etc. Maybe you have a different problem?

The jetbrains folks run a great bug tracking system; you can register and report any beachball inducing bugs; that's a big focus for them.

you were unhappy with the plugins. learn vim the right way and ditch plugins altogether.

Agreed, as Vim/Neovim has risen in popularity recently it seems there is a trend of people thinking it’s only usable if you install these 57 plugins, and a large number of these users seem to have blind spots on Vim’s native capability.

The autocomplete feature is a great example of this. I do not use an autocomplete plugin at all, but rather use Vim’s native ins-completion. Combined with a language server and a lightweight LSP client (I use vim-lsc) this works beautifully.

I am excited for some of the upcoming changes in neovim however. I think the introduction of treesitter for syntax highlighting and a native LSP client will both be huge

I've checked out a build of neovim, and the native LSP is rudimentary but even in that form, very slick.

I am often torn with the same conundrum - I've been using neovim for Ocaml, and I really just like vim as an editor, but having inline linting is really really nice. But it's also really, really complex to configure, and it detracts from why I love vim so much - if I wanted an IDE, I'd be doing my Scala work over in Intellij.

I'm still contemplating whether I can get what I want with a second window a file watcher running build commands.

Agreed the treesitter is also really exciting.

Can't believe no one has posted this yet. I just use org mode

can you use Intellij like vim? with command mode etc

Yeah, one of the most popular plugins changes the input scheme to be very similar, if not identical, to vim.

Yes, it has a vim emulator, ideavim. It's far from perfect, but I would say it's better than most.

https://github.com/JetBrains/ideavim

Yeah there's a vim plugin https://plugins.jetbrains.com/plugin/164-ideavim

Yes, there's an official IdeaVim plugin [1]. I'm not sure how deep the rabbit hole goes, I just use it for basic vim goodness, and shy away from advanced stuff. But sure, modal editing, movements, macros, search, etc, are all there.

[1] https://plugins.jetbrains.com/plugin/164-ideavim

There is a (or more than one?) Vim plugin with fairly good support. However, it is not Vim. Most of the common Vim operations work but others are broken.

For example, I've found the weirdest bugs when using visual block, especially in column mode. It just completely mangles everything.

Yes, but it's way slower and you can only open one project at a time due to it using all if your ram

A lot of stuff is built for autocomplete these days. Hard to say that's not the future of app dev.

you forgot the big advantage of using intellj which is using docker image for sdk

... is this an advantage? I especially don't want to run docker on a mac any more than I have to.

Dudes be comparing text editor to IDE, and then writing :wq thinking they're vim evangelists.

In the end, they are both tools developers use to write codes. I don't see why they can't be compared to each other.

vim is just a set of well-thought key bindings and commands. JetBrains built highly successful business on providing "working from the box" IDEs. Not to mention vim's buffer concepts, entirely different from usual tabs.

Article literally goes "I tried to build ultimate IDE from vim, sometimes it's good, sometimes not, but then I discovered this not that free tool called IDEA and damn it works".

Reply on news.ycombinator.com