How useful is learning VI/VIM for a new programmer?

VIM is not a must, nor a plus for a programmer.

It's all about "choice", I use vim to code for more than 10+ years, although suffers a bit at the beginning due to steep learning curve, I really love this editor and it increased my developing flow for sure.

However it is still a matter of choice, if you don't use vim, there are other candidate editors such like emacs, sublime text or even Notepad++. You can also benefit from many language-specific or platform specific IDE like eclipse, PHPStorm ...etc.

I can tell about the goods of vim, it is capable of ANYTHING, any feature other editor/IDE has can be plugged-in, and it is designed to achive the goal "Minimize the distance your hand moving on keyboard", also makes you "Type less, do more".
Vim is also very light, basically it is still an editor like sublime text/emacs, so starting Vim basically takes only several milliseconds. Some heavy IDE like ecplise/Visual Studio may took seconds to minutes to start.
Vim also has the strongest customization mechanism, it is so flexible and allows to build your own personalized editor, and to collaborate with any other software tools, some common examples are git, compiler/debugger ... etc. It also has the biggest community to develop all kinds of plug-in/color-scheme and to share config files to everybody.

But ofc, since vim comes from vi, one of the oldest editor in Un*x system. It is not very intuitive nor friendly for a novice user. The learning curve of vim is steep, especially at the very beginning.
Also alghough Vim makes every complicated thing possible, it cannot do all the simple tasks easily.

To conclude, Vim is awesome, I love it and many people love it. But learning Vim will NOT dramatically increase your programming skill, it is simply one of the best choices of "editors" to program.

Edited:

To specifically your questions.

2. Many people use it for decades(15 for me), as I know so far, only 2 editors have such kind of 'magic', vi/vim and emacs.

3. I don't think there will be really a completely exclusive feature, I can give some feature that few other editors/IDE have.
a. You can do all the jobs without mouse, moving cursor is always slow. In fact you don't even need to use arrow keys, reduce the time keep moving your hand in between arrow and letter keys.
b. Strong regular expression support and stream text editing.
c. Extremely flexibility and customization power.

4. I don't know any similar one to vi branch(ee-ed-ex-vi-vim),

I’ve been using Vim for 10 years. It took about 8 years for the excitement of continuously gaining new powers (often daily) to wear off. I’ve been faster than everyone around me, and everyone they’ve ever seen (by many people’s admission). I’ve had people watch me code, just to see the Vim powers, and had “jeeze!” and “phwew!” and even 2 “holy bananas!” comments when something I did looked like magic. I’ve had busy producers and managers stop what they’re doing and work with me after seeing that I could transform code as fast as they could ask questions about it. I had one impatient person stay with me for an entire day, collaborating on a shared deadline, because every weird thing they wanted across a bunch of JSON files I could make happen in under 10 seconds. I’ve had emacs zealots say “Yeah, forget it. You shouldn’t learn emacs.” after seeing me use Vim. I’ve saved myself from making, finding a name for, and later cleaning up, or being inundated with hundreds upon hundreds of scripts, because I just knock out the transformations in under a minute manually, as-needed. I could go on and on, but what I won’t do is try to sell you on using Vim, because what I’ve learned after 10 years of trying to get anyone to try Vim and stick with it is that you can’t.

People either have an innate interest in working this way, or they don’t, and if they don’t, they never will. If you were intrigued by what I said in my first paragraph, you might have it. If you thought of reason upon reason to dismiss what I said in the first paragraph, don’t waste your time with Vim. I’ve not once seen someone come around. It starts by being fast at touch-typing, and loving touch-typing, and the feel of the keys. It continues by constantly wanting to learn the hotkeys for everything, and tweak configs for optimum efficiency, and always being a little disappointed by how slow you are, no matter how fast you’ve become. It grows further by accepting on faith the zealoty things most Vim experts tell you, like “You shouldn’t use the mouse; it’ll just slow you down,” and “Don’t use someone else’s vimrc; you must craft your own over time, like a Jedi’s lightsaber.” It builds into something when you start versioning your vimrc and pulling it down to each computer with your other dotfiles, so you can have that custom-built power with you everywhere. It persists as you grow stronger and happier, working ever more efficiently, in a tighter and tighter economy of key presses, speaking in the language of Vim, making things change subconsciously at your whim at nearly the speed of thought.

Related questions

For me, it made a huge difference. It can do everything an IDE can do, so let's start with that as a baseline - you can even hook it into a headless Eclipse if you want. Personally I find a lot of IDE features more of a hindrance than a help, so I won't elaborate there.

So going from Notepad++, Netbeans, and Eclipse to Vim, here's what I noticed:
1) production speed - it's hard to overemphasize how much time you save once you get used to vim's navigation and shortcuts. You'll almost never take your fingers off the home row while coding. The seconds it takes to reach over to your mouse and navigate through menus, and/or engage in complicated key combos add up to hours before you know it.
2) finding/replacing/refactoring: like it or not we spend a lot of time searching code. Vim not only makes searching and replacing a core focus of its interface, it supports powerful perl-like regular expressions (and if you don't know how to use them, you should be learning)
3) macros - are amazing in vim. you can literally record every keystroke and repeat it, and because everything in vim is a keystroke and it supports incredibly flexible and powerful chains of commands, that means you can script a lot of complicated behaviors with a few keystrokes.
4) customization: yes, you can write plugins for Netbeans, Eclipse, and other IDEs if you know the language and want to use it (typically Java, ew). It's just easier in Vim - a simple, powerful scripting language, a huge base of open source code to start with, and a quick iteration process consisting of write script, restart vim, test script - which leads me to:
5) it's fast. no, not "about as fast as you can expect a modern, full featured IDE to be" - it's "leaves your OS' basic plaintext editor in the dust while doing everything a modern, full featured IDE can". vim starts instantaneously. it shuts off instantaneously, even with ungodly numbers of plugins and scripts installed. it refactors, replaces, runs macros, navigates the file system, opens files, highlights their syntax, folds code, populates templates, and everything else your IDE can take minutes to do in fractions of seconds.
6) it ties into the linux/unix/macOS command line directly - anything you can write in a shell script, anything with a CLI, you can run from inside Vim without a plugin or switching tabs or anything nutty like that. Suppose you want to do something silly, like search your filesystem for some files and append all their contents to your current buffer in vim: :read !find . -name "*.txt" -exec cat {} \; (this will work for just about anything, not just find/cat)
7) it works everywhere *nix is found - once you know vim, you are comfortable working on anything and everything that is worth working on, and you can do it directly - no futzing with ftp or running into the server closet with a crash cart to fire up a gui to edit a config file or whatever; your remote system already has the best and most powerful editor you can get, and you can access it through SSH from your desk (and your config files are portable, so making the server's copy of vim behave just like your desktop is trivial). this is how i maintain my sanity while working on servers 1500 miles away.

I could go on. These are just some of my favorite aspects. I also like that it's distraction-free - just me, the code, and my desktop background (I use a transparent background terminal, it's slick). When I want to know something, like how many "TODO" comments are in my CWD, I can ask using the process described in point 6. I don't need a whole sidebar for that kind of stuff; it's annoying.

I am using Vim for the last one and half years, mainly because I haven’t been able to figure out how to exit out of it.* :D

I like Vim. Whether or not you like it — it is extremely useful. When you are working in a console ( doing ssh to a server, or using other stuffs), there is no option other than Vim or Emacs, or some equivalent tools.

I use Vim if I am writing a small file — to be more specific, may be less than 100 lines of code. I don’t feel comfortable with Vim if the file is large and I need to edit and delete a lot of lines of code. In that case, I use Sublime text.

For giant projects with a lot of dependencies, I prefer using IDEs like IntelliJ.

Use of text editors and IDEs depend on what you are doing, and it may also be a matter of personal taste. For example, among IDEs, I am more biased towards the Jetbrains tools — IntelliJ, Pycharm etc.

But, in any ways, learning Vim is useful for a new programmer. It installs inside you a programmer’s pride. In other words, it makes you feel like a programmer. :D

Good luck with Vim !

*Developer Jokes

If you don’t learn a command line text editor, you are handicapping yourself.

Two main reasons:

First, at some point in your career, you will have to run your code on a headless machine (eg, a server in the cloud). Increasingly, this is the most common way that code is deployed, and it is something that I have done at every single job I have had since graduating. That means that any time you want to look at logs and debug your production server, make tweaks to a deployed application, or generally code in the environment where your code will actually run, you will need to do so in an environment without a GUI. The folks who don’t know vim or emacs either end up with an annoying process of SCPing their code up to the server, using xwindow forwarding (laggy), or doing something else horrible.

Second, vim and emacs are more powerful than other text editors. Ad hoc macro recording, a rich configuration language, and a vast community of plugin developers for both tools mean that it will take a long time to learn how to use them well — a decade later, I’m still learning — but you will keep learning and keep getting more effective over time.

Notice, though, that that’s talking about in your career. As a novice? Do whatever is easiest. You already have enough to learn. If you want to play around with vim or emacs, that’s great, but don’t feel pressured to learn everything at once. I started using vim in my third programming course. I know some other folks who started years after graduating. Don’t put it off forever, but if you’re just getting your feet wet, don’t feel stressed.

People will absolutely be using vim and emacs 20 years from now. They are both ubiquitous, and they are among the most popular editors out there. Not only that, they are stickier than most of their competitors — Eclipse might start to lose market share to IntelliJ and Notepad++ might start to lose market share to Sublime, and those tools will likely fade away once the next trendy editors come out, but vim and emacs aren’t really after the trendy market. They’re annoying command line tools. People use them because they’re quite well designed (once you get over the learning curve).

And don’t get too caught up in emacs vs vim. Both of them are powerful tools that serve mostly the same niche. I use vim, and vim is slightly more ubiquitous (eg, vim will likely be available on all servers you ever have to administer, whereas emacs will take an extra command to install), but emacs is also powerful and available in mostly the same places. The key thing is that you actually are, as you say, comfortable with the terminal. I would argue that if you can’t edit your code in the terminal, you aren’t really comfortable in the terminal.

Related questions

Could I live without learning Vi/Vim? Easily. Is it worth learning Vi/Vim? Yes.

I have been using Linux and Vi/Vim for last 8 years, relatively small time yes, even if you can't believe it, there are a lot fans of the 30-years-old vi editor (or its more recent, just-15-years-old, best clone & great improvement, vim). No, we are not dinosaurs who don't want to catch up with the times - the community of vi users just keeps growing.

Yes, there are definite reasons why the vi/vim editing model is just superior to any other out there.

So, Why should you be learning Vi/Vim ?

• Vi is guaranteed to exist on all Unix systems and exists on most Linux ones as well. That kind of broad coverage makes learning it worth it
• Your fingers very rarely have to leave the home row, which means you'll be able to edit text very, very quickly. It's also usually very fast and lightweight even when editing huge files.
• Vi is at once ubiquitous and incredibly powerful, and by learning it once, you gain the ability to exercise that power on pretty much any computer that has a keyboard.
• Vi/Vim's editing features are prolific. It supports macros, multiple clipboards in the form of registers, regular expressions, visual selection including block wise selection, integration with build systems, plugins and themes, and a lot more.

So, how to get started ?

You can learn to use vim in under 30 minutes

Go to your shell and type vimtutor . The tutorial that’s presented is excellent and you’ll be through it in no time. Once you’re done, you’ll have the rudiments needed to get your work done. You won’t be fast yet, no; but you’ll be competent. And even after those 30 minutes, you’re going to start grasping the ideas that make vim so amazing: the brilliant design decision that is modal editing, the composability of commands, the clever mnemonic naming of commands. These will be enough to make you want to learn more.

There are two huge, huge, fallacies in your question:

• Nobody said that you need to learn vim.
• Learning vim is absolutely not a waste of time.

Write your code on a piece of paper, then OCR it, for all I care. Poke holes in cards then feed them to a card reader which interprets them to machine code instructions. Maybe use Visual Studio. Maybe use some other IDE. Maybe use whatever text editor you like, then learn what you’re missing, then try to find it, then repeat until you think you’ve optimized your productivity.

Every person I know, myself included, who felt that learning vim would be hard and yield questionable returns on investment, and then actually learned to use vim, feels really grateful that they didn’t chicken out and actually made the effort of learning it because the benefits are huge, despite the steep learning curve.

If you don’t try it, you won’t know what you’re missing out on. Then again, if you’re happy with using Notepad++, who am I, or anyone else, to tell you not to be happy? Go be happy.

I've been using Vim as my main editor for over a year, as well as Eclipse for over 3 years as well as intellij idea and MS Visual studio, so I feel I understand well the tradeoffs between using a lightweight editor such as Vim and a heavyweight IDE. I wish I'd learned about Vim much earlier. Here is why - the things Vim does better than an IDE:

- 1) Speed. Vim is operated not only without a mouse, but without moving your fingers from the home row keys. Most of programming is making small changes to existing text, and this is much faster to do in Vim. Vim start up and opens files instantly, and you never have to wait in front of the spinny wheel of death while an IDE recompiles your code.
- 2) Power. Vim can do anything an IDE can - there are literally thousands of plugins available, and it's not too hard to write your own. You can edit files remotely over ssh and create macros on the fly to automate repetitive modifications to your files beyond simple find and replace. Everything Vim does is customizable. Want to make Ctrl-L Ctrl-O open the log file for the day before yesterday? Add one line to your .vimrc and it's done.
Another thing difficult to put across in words is that not having to move your fingers off the home row or every wait for the machine really helps to get you in the "Zone", channelling your focus 100% onto the code and how you are changing it, forgetting completely about the mechanics of how you are doing it. I use Xmonad and turn off all status bars and menus so my screen displays code and only code, not so much as a clock or battery indicator is visible to distract my concentration.
- 3) Flexibility. Most IDEs cater to a specific set of languages, but Vim's tools allow you to work at a generally high level of productivity in any language, and plugins extend support for particular languages. This makes Vim great for working in new experimental languages that don't yet have IDE support and to work with config files. Vim can run on a server you are connecting to remotely, which makes system admin much easier. Vim does one thing - edit text - and does it well. The developer is then free to choose their own tools to do continuous compilation & testing, code metrics, etc, without being hampered by the IDE's impose it's own way of doing things on you.

However, there is a price:
- 1) Learning curve. Vim takes time to learn, and more time for muscle memory to make operating it significantly faster than using the mouse.
- 2) Configuration. It's easy to spend vast quantities of time tuning Vim and it's plugins. Until you are a Vim-fu master, I recommend avoiding this by using a ready-made Vim distribution (eg spf). Ignore people who tell you you are 'lazy'!
- 3) Features. For statically-typed languages with mature IDE support (eg: Java, C#, Objective C etc), you will miss out on some IDE features that Vim doesn't provide or that aren't as good as the IDEs such as refactoring functions or advanced auto-completion.

For example, I write a lot of Scala, and ricochet between Vim and IntelliJ. I get frustrated by IntelliJ's speed and switch to Vim. I get frustrated by the lack of auto-import and switch back to IntelliJ. One day someone will write a great Scala Vim plugin and I'll drop IntellJ completely.

This should make clear the answers to your other questions:
- Novices rarely use Vim - too steep a learning curve
- People will certainly still use Vim or it's progeny 15 years from now. (See the NeoVim project, which is refactoring Vim in preparation for the next 10 years of development). Short of having a telepathically-controlled text editor, I simply can't imagine a higher-bandwith way to code.
- The two possible equivalents usually mentioned are Emacs and Sublime Text, but to compare & contrast with Vim is beyond the scope of this answer.

In short, I recomment you learn Vim when:
- you are writing in a dynamic scripting language such as Python, Ruby, Coffeescript, etc;
- you have a firm understanding of programming concepts and are learning your second or third language;
- you are doing a fair bit of *nix work;
- you are writing in a newer language without strong IDE support; or
- you have some time on your hands to learn something new and challenging.

Good luck & have fun!

For a new programmer I can hardly recommend Vi/Vim. Like some people in this thread I only picked it up because I heard that's what all the "hardcore" programmers were using and it's "the most efficient way to code, ever".

While there may be some elements of truth to those beliefs, I think as a new programmer you should be more concerned with learning the concepts that will cause you to produce good quality code and not so much the tooling.

Vim, like any other editor, is just a tool and like a tool there are many others out there that can do the job better (depending on the job).

To answer your questions directly:
Do novices still use it?
I don't know. Most of the folks I interact with who are learning to code tend to use Notepad++

Will there be people still using it 5, 10, 15+ years from now?
Yes. To some people, Vi is probably the first editor they started using and it remains their preference today. Provided they live for another 15 years or so, they may very well continue using it.

What, specifically, can one do with it that you can't with an IDE, editor or GUI equivalent?
I can't recall a specific feature, but the overall draw of Vi is that you can code pretty much an entire project without ever using leaving the keyboard. It's great at document traversal, file retrieval and text editing for sure. Most other IDEs do require some mouse interaction at some point which kinda sorta impacts productivity, but not to a staggering degree.

Is there a software equivalent to VI/VIM?
You must be talking about EMACS. Yeah, that's another story.

You mentioned that you're comfortable with the terminal? That's good. I won't discourage you from learning Vi altogether as you are going to, at some point, need to SSH into a remote computer to update files and such and you're going to need to know how to use a terminal based editor. Even with that use case in mind, I am usually just changing a couple configuration properties here and there and I do just fine with nano (the less powerful, even less talked about but much simpler editor).

It depends. If you are doing web development, it’s essential. Learning Vim is to text editors what learning LISP is to programming. Once you learn it, you will be elite among the neckbeards. If you’re a girl, you’ll have to buy a fake beard, or you can take a pair of scissors to an unconscious C89 programmer, they often have beard to spare. This is actually compulsory by the Vim Mafia.

Stay away from Emacs though, it tends to consume your life. A few weeks of using Emacs and you’ll become a neo-marxist hermit and feel an uncontrollable urge to sleep in a closet on the MIT campus and develop fatty liver disease and ascites from a carb intense ethically driven veganism.

Unfortunately no one can truly explain why you should learn Vim, you have to learn it for yourself. It’s kind of like the matrix, except Vim meetups don’t usually take place in underground leather fetish clubs. Though, they should.

I find this vi thing so amusing I can’t hardly contain myself.

Nearly everyone I went to school with including myself hated vi. We hated it because it was really all we had when working on UNIX. Now you kids consider it a badge of honor or something.

I use VIM all the time for manipulating text files. It’s great. There are ...

I migrated from GoldEd (Amiga) to Vim (Amiga, Linux, Windows) around 1996 and use vim since then. In my life I’ve used a couple of editors and IDEs, including but not limited to ed, µEmacs, Emacs, vi, vim, nano, UltraEdit, GoldEd, HomeSite, Visual Studio, Notepad, Notepad++, VisualAge, Together Control Center / TogetherJ, TurboPascal, Keil µVision, CalmShine, Tasking IDE, Source Insight, NetBeans, Eclipse, IntelliJ IDEA, and a few more. Out of all these options that I have encountered so far, for editing text, vim simply is best.

Disclaimer: I have not yet tried Sublime or Atom myself, they are not included in my personal comparison/experience.

For almost everything, IntelliJ IDEA (or another JetBrains IDE) with IdeaVim (which is a Vim emulation plugin for the JetBrains IDEs) is the combination that by far produces the most quality code in the quickest way, if you know how to use it.

Is it useful for a new programmer to learn vim? It definitely is, and here’s why.

1. There will be headless situations, that is, situations where a graphical user interface will not work. For example, when you ssh into a box, say, a remote virtual server, docker image, and there is no X available, and you need to edit a file there. You will want to know a headless editor in that case.
2. Vim is available everywhere. On Windows, Linux, Mac OS, on the UI, on the Terminal, as well as possibly in your favorite IDE like Eclipse, IntelliJ IDEA, NetBeans, or Visual Studio.
3. Vim is very user-friendly: It allows editing text very precisely and very quickly. And as long as programming involves editing large amounts of text, you want a text editor that is precise and fast. Also, the shortcuts are all easy to remember. There’s a mnemonic for every shortcut.
4. You can do things with vim that not many text editors can do. For example, directly run commands from vim. With just a tiny setup, vim + ctags + GNU make, vim can already perform better than most IDEs for C. You can browse source code, jump from references to definitions and back, list usages of symbols, browse source code pattern searches, compile and build from vim, automatically browsing from error to error, and even integrate vim with gdb and debuggers that feature a similar interface. Or just filter a bunch of lines through a shell command, directly from the editor. Wanna sort a properties file? !sort. Wanna replace text with its MD5 checksum? !md5sum.

However, don’t go vim only. Combine the power of an IDE, like IntelliJ IDEA, with the power of vim, like IdeaVim. The power of vim will support you whenever you have to edit text yourself. The power of an IDE gives you a few other things beyond vim, for example static code analysis on-the-fly, powerful refactoring tools, debugger integration, remote debugging, metrics, to name just a few features.

Watch someone who knows touch typing and has mastered IntelliJ IDEA with IdeaVim develop and refactor code, it looks like magic.