Why I am switching from Vim to IntelliJ
Tags: vim, intellij, ruby, programming
Published: 2020-11-05 14:10:27

---
title: Why I am switching from Vim to IntelliJ
published: true
description: Why I am switching from Vim to IntelliJ. It mostly boils down to convenience, speed of setup, and programming happiness.
tags: vim, intellij, ruby, programming
cover_image: https://browntreelabs.com/static/8805418a02fe96f9f449cb5057c0e95e/1ac29/vimlogo.png
canonical_url: https://browntreelabs.com/from-vim-to-intellij/
---


From Vim             |  To IntelliJ
:-------------------------:|:-------------------------:
![](https://browntreelabs.com/static/8805418a02fe96f9f449cb5057c0e95e/1ac29/vimlogo.png )  |  ![](https://browntreelabs.com/static/d2f6c44d5d9d14c9e66176feeb648fbf/2bef9/intellijlogo.png)

## In the beginning, a love affair

For the last 10 years or so, I have been a die-hard Vim user. I was introduced to Vim on my first programming job. It was almost an instant connection for me. I fell in love with the minimalism of only needing a terminal to do work; and the power of stringing together commands, like words, to edit programs and text.

The love affair I have with Vim stuck with me throughout my career and remains strong to this very day. When I was a junior-level release engineer, working on small scripts, Vim was amazing. Later, working as a Ruby on Rails Engineer, Vim was still an amazing editor. Thoughtbot, Hashrocket, and countless other agencies, companies, and individuals contributed to the community (and cult) of Vim. That community pushed my knowledge, comfort, and understanding further and further.

Eventually, I was running tmux and Vim together in the terminal. With sufficient plugins and dotfiles, I was CRUISING through codebases. I could write tests, run them, refactor code, and run commands with absolute ease.


<hr/>


![](https://browntreelabs.com/static/c088aa0c91b04d0725177c7b04c624c0/9b29b/vim-and-tmux.png)

<center><i>Vim and tmux... were so amazing</i></center>


<hr/>


## Old feelings fade

Lately, though, I have been feeling a little underwhelmed by Vim. Even with my sophisticated dotfiles, knowledge, and Plugin setup; something felt off. 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.

Within the last few years, I tried my hand at programming mobile applications. Flutter and Dart -- although supported by an LSP -- was not running very well on my Vim setup. After giving Android Studio a shot with Flutter, it felt like a whole new world.

## Android Studio with Flutter -- The tipping point
<hr/>

![](https://browntreelabs.com/static/2dcc652b86c5e6e9506eaded15001bb0/0784f/android-studio.png)
<center><i>Android Studio was a game changer</i></center>

<hr/>

All of a sudden, I had everything at my fingertips. Auto completion, Auto formatting, snippets, and documentation lookup was all set **By Default**. I actually understood the Flutter framework much better because Android Studio made deep framework code easy to debug, inspect, and explore. Not to mention, the Vim integration was **fantastic**. This was the best of both worlds. I had amazing editing, minimal configuration, and Vim keybindings!

When picking up a new language or framework in Vim, I would spend hours configuring plugins, dealing with linting, and looking up documentation. With and IDE like Android Studio, all of this came pre-built without any configuration.

Android Studio was something of a revelation for me. I began thinking to myself, "If this is so great for Flutter, wouldn't this be great for my other projects?".

## Vim to VSCode to Webstorm to IntelliJ
I am now working almost exclusively on IntelliJ IDEA. It is the JetBrains defacto editor that includes plugins for almost anything:
 * Ruby on Rails
 * Ember
 * Angular
 * Typescript
 * React
 * The list literally goes on forever
 
Every project I work on -- like this Gatsby blog in React, my corporate Typescript React job, or my Ruby on Rails side projects -- All work within this one editor.

I had a brief stint with VSCode but, to me, it appeared to have the same flaws I disliked with Vim at the time. It was slow with large files, and it felt sluggish with complicated programs and complicated programming languages (like typescript and tsserver).

I also had a long affair with WebStorm, which was mostly great. I did; however, find it odd to be using an editor **ONLY** made for a few programs. If I wanted to run a Ruby on Rails app in Webstorm, I was SOL. I thought it was a little silly to run RubyMine, Webstorm, and Pycharm on one machine. If I wrote code in all three languages, shouldn't one editor be able to handle it?

Eventually I wound up running IntelliJ with plugins that handle any programming need I may have. And for now, I am very happy. There are, of course, many cons with IntelliJ. But I truly believe the Pros outweigh the Cons.


## Vim and IntelliJ, a Pros and Cons list:

I still think Vim is a great editor and I love to break it out every once in a while. But I believe the pros of IntelliJ outweigh the cons of Vim at this point in my career. Here is an overview of my thought process.

### Pros and Cons of Vim

>When picking up a new language or framework in Vim, I would spend hours configuring plugins, dealing with linting, and looking up documentation.

#### ***Pros:***
 * **Minimalist.** All you need is the terminal, and that is it. You don’t need to open multiple windows, Tmux and Vim together were **awesome** for this.
 * **Gets you into the Flow:** . Vim [gets me into "The Flow"](https://en.wikipedia.org/wiki/Flow_(psychology)) better than anything. I just need to move my fingers a bit, and I’m in/out of windows, buffers, splits, etc… I specifically remember smiling when I was coding with Vim, because it just felt so fun sometimes.
 * **Extensible:** It's been around forever, Thoughtbot, Hashrocket, and many community members contributed greatly to it.

#### ***Cons:***
 * **Very steep learning curve:** Vim takes a long time to learn, and you’ll never stop learning it. This is not a problem with more experienced users like myself, but I thought it was worth mentioning.
 * **Inconsistent Plugins:** Quick, tell me the best plugin for auto-completion in Vim. ALE/Omnicomplete? YouCompleteMe? VimCompletesMe? DeoPlete? There is an insane number of plugins for any task you may have. And not all plugins play together. This has become slightly better with the emergence of LSPs; however, I constantly find myself playing with plugins to make things work better, only to dislike the setup and go for another mix of plugins later. Having dot files are nice, but when you switch computers/systems, you have to install pip3/python for some packages, node/npm/yarn for others, and for some, you’ll have to cd into the dir where its installed and run a makefile! (looking at you, YouCompleteMe)
 * **Doesn’t always play nice with everything else:** I have had countless configurations with Vim. Vim standalone, NeoVim, Vim with Tmux, and MacVim/GUIVim. They all have strengths and weaknesses, but there is always one thing in common, it doesn’t play very well with every computer system. Try to set up copy+paste on Vim on a Mac, done? Ok great! Now do it for Linux. There are so many workarounds and hacks to get everything to play well together. When you get it set up, its nice, but sometimes its rough. I find myself reading old blog posts to remember how I set up yank + paste on my system-wide clipboard over and over.
 * **Isn’t very fun with complex codebases in complicated languages (like typescript):** I remember starting a new job that used typescript, and there were a lot of engineers working on some really cool problems. After getting Vim/ ENV vars/ etc… all set up, I go to start woking in Vim and **BAM**, any file over 20 lines freezes and its incredibly slow to work with. Sure enough, my javascript parser/highlighting plugin (see my point above about plugins) was not efficient, and it was bogging down everything. So I had to settle for a lesser parser that performed better. A similar thing happens with prettier, eslint, and tsserver. If you need your code to be auto-fixed with these technologies, its blocks read/write. Even when your IO is blocked for only a short amount of time, it makes for a trudging, slow-as-molasses feeling when writing code.
 
### Pros and Cons of IntelliJ

>All of a sudden, I had everything at my fingertips. Auto completion, Auto formatting, snippets, and documentation lookup was all set **By Default**.

#### ***PROS:***
 * **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.
 * **File watchers are powerful:** There is a thing in IntelliJ called file watchers. You can set arbitrary tasks to run after you edit/save/type in a file. This can be super powerful when you have more advanced tasks you need to run in your codebase like: sorting imports, running specific eslint rules, or running rubocop after saving a file.
 * **Everything plays nicely with your OS:**  I can’t tell you how many times I set up Vim and tmux on a new OS, like linux. I’ll run all my dot files, configure anything crazy I missed. Compile the plugins that need compilation. Fix any small issues that happen between Vim/tmux/linux (or Mac, whatever). Then I’m programming, and I have to copy+paste something, and BAM, I lose 4 hours configuring copy and paste correctly between Vim/tmux/
 * **Complicated codebases and languages are handled easily:** After using IntelliJ (or Webstorm), all my problems with my large Typescript codebase went away. Everything gets indexed, parsed, highlighted, and rendered correctly. There are very few hangups when working with complicated codebases, and the exceptions are usually much easier to deal with than with Vim.


#### ***CONS:***
 * **Complicated Interface:** The interface to IntelliJ is somewhat, complicated. There are a lot of tools, dropdown menus, and configurations. This is definitely a daunting thing at first, but once you get used to it, its not a big problem at all.
 * **Memory Usage:** IntelliJ does eat up a bit of RAM on my machines. I believe this memory usage is worth it though. You're paying an upfront price to index, tag, and cache programs, so your editing experience is smooth as butter. VSCode and Vim (with plugins) only do this lazily; therefore, your programming experience with complicated projects becomes very awkward and slow over time.
 * **Difficult configuration for some tasks:** Again, this is something you get used to with time. Some configuration options with IntelliJ are less than ideal. For example, when setting up auto-formatting for eslint, you have to go through a couple hoops to set up a file watcher in IntelliJ. Once you understand this concept though, its fairly straightforward and easy to use with other tools.
 
In the end, I have decided that the pros for IntelliJ greatly outweigh the cons. I have been really happy with the platform and look forward to using it in the future.

If you've made it this far, congrats, you're really amazing. I wonder; though, are you feeling the same way I was? I am not sure I'm alone in this thinking or not. I'm sure in 6 months you can find a post about how I switched back to Vim.  But for now, I'm really enjoying this experience.

Either way, thanks, signing off for now.
## :wq