Where editors usually have editing shortcuts, vim has an editing grammar.

So you can copy (or select, or replace, or delete, or any other editing verb) N arguments or blocks or lines or functions or any entity for which vim has an editing noun, or around or inside either of these, and you only need to remember a few such editing verbs and nouns and adjectives in order to immediately become much more effective.

It’s so effective that switching back to a regular editor feels annoyingly clunky. (I guess that’s why many offer vim plugins these days.)

Better: you can record entire editing sentences and replay them. Ever had to make the same change on dozens of lines? Now you can do it in seconds.

Now of course, replaying a sentence, or several sentences, is also a sentence of its own that you can replay in another file if you want.

It’s neat. :)

Honestly the best bit is just not feeling the need to take my hand off the keyboard and use the mouse. I don’t think I can quantify the time saved, but I can tell you I really notice when I’m using software that makes me have to switch.

I am logged into various servers via ssh constantly and nano or vim (or at least vi) are installed pretty much by default everywhere.

Its not so much about the time saved its about being allowed to stay in a mental state of flow since all actions in Vim and similars are built from foundational navigation language chunks. It feels less like editing and more like communicating. All these random little “I can do this command” is just people trying to show examples of how the language of editing to do weird and interesting things. So the answer isn’t so much “I work faster” in Vim as it is “I work with less mental overhead in Vim”

Just being able to jump to the top of the file, bottom of the file, beginning or end of the line, or directly to a regex pattern match or particular character already gives me some of the same satisfaction as a video game with really tight movement controls. (I also like being able to jump to lines by number, manipulate lines by number or range, and I like being able to get to the top, bottom, or middle of the screen with one or two keypresses.)

In the same vein, deleting arbitrary lines at a time, performing external operations only on lines that match a particular pattern, and saving macro recordings of repetitive manual changes all feel like multiplicative powerups. Heck, incrementing and decrementing with ^a and ^x feels like one more little cheat code. Bouncing on parentheses with % makes structured files easy to get around in.

These are all things I’ve done with some regularity over the years.

I do most of my work on my laptop, which has a really shitty touchpad (a system76 pangolin 12). Using the touchpad to scroll, move around, etc. feels clunky and frustrating. Using my wonderful keyboard feels amazing, quick, and responsive. Honestly, that’s the main reason I use neovim; touchpads, especially bad ones, just feel clumsy, imprecise, and inefficient.

Now I’ve gotten used to typing nv and, in under 30 milliseconds, getting a full-featured, LSP-supporting text editor. Other editors trigger my impatience now 😂. The features are secondary to me, they’re not what makes nvim great.

If there were two things that are a game changer for me though, they would probably be <C-o> (mixed with plugins like trailblazer) and the incredible ease of use that vim macros offer.

Coding in neovim, I don’t know that I am that much quicker or more efficient. Maybe with certain actions I am, but its probably n9t measurable.

What I do get though, is a sort of flow state. It’s like playing a video game where I try to edit text with the fewest keystrokes possible. It’s genuinely fun and I can code longer since its fun.

Time saved is not the most important part. Here is my opinion:

• it is very satisfying to use. Once it becomes muscle memory, vim just gets out of your way, and you feel like you’re one with the computer. Your ideas flow freely from brain to document.
• neovim is highly customizable and scriptable. You can make it do many things, many of which were never even conceived by the developers.

One thing I haven’t seen mentioned is that not moving between mouse and keyboard so much reduces the risk of getting an RSI. So even if it didn’t make you faster it would still probably be worth it to find a keyboard based workflow.

I use Helix and would suggest you try it (at least to start off with) as it is easier to learn than vim and does not require plugins or a complex config. To answer your question I will go from the less to more advanced/complex:

1. Move a line to a new position in the file/another file (takes a couple of seconds)
   1. x then d to select a line (pressing N times will select N lines) and delete it (delete will also copy to the clipboard)
   2. navigate the cursor to the new location
   3. p to paste in a new
2. Navigating around a file:
   1. jumping to a function/class definition by pressing g then d when on a function/class usage.
   2. getting a list and navigating to class/function calls when the cursor is on a class/function definition by pressing g then r.
3. Multi cursor editing - I use this to make edits to multiple places at once. I most recently used this to extract the names of 30 tables that are used in a SQL file. This probably took ~5 seconds and I barely thought about it. To do this I used:
   1. % to select the entire files contents
   2. s to search
   3. typed "FROM "
   4. pressed enter to create cursor at all locations matching the search
   5. v then g then l to select the rest of the line
   6. space+y to copy to the system clipboard.
   7. paste into a document where I needed to list the tables
4. Using a terminal workspace manager (zellij) with helix and a git tui app (gitui) so that I can easily make code changes, commit, push, ,run tests, move to a new repo and more without leaving the keyboard.

There is actually a helix community on programming.dev: [email protected]

I use vim bindings in vscode, but I’m trying to switch to neovim.

It’s hard to talk about efficiencies without use cases but here’s some that I like:

• Compared to using mouse, text selection is just much easier in vim. Instead of accidentally highlighting an extra space and clicking somewhere on accident which gets rid of my selection, vim lets me go directly to the end of the word and be precise about where I’m selecting.
• I remember before I used vim, I would count the number of times I hit the backspace or delete when I had heavily nested parentheses. With vim I just type the exact number I want, and if I were to undo that operation I also know exactly what was changed, whereas when counting there’s always the possibility of miscounting or pressing delete without counting.
• I don’t have to scroll. I can jump 100 lines in less than a second. Instead of searching through long files to find where I left off, I just generally remember what line number I was at, then I can simply just jump back.
• Forces me to type better. Before vim I had really shitty typing form(I don’t know what it’s actually called) but switching to vim shone a light on exactly how I was typing wrong, and now I type faster.
• Using the % operator you can jump between brackets or parentheses. This comes in handy especially when you want to highlight the inside of a function call, or just jump to the end of a pair of brackets

I’ve been using vi since my mentor at an internship sat me down with a copy of “Unix in a Nutshell” and told me to learn it. This was before I discovered Vim, so I think I was using nvi which had very limited in-editor help. It was a struggle, especially compared to the resources available today.

Around the same time, circa 1999, Tom Christiansen (of Perl fame) wrote an essay called “Zenclavier: Extreme Keyboarding” which still speaks to me, and is worth the read.

In brief, I’ve never been able to “zen out” in a typical non-model text editor, at least not the way I can with [neo]vi[m]. It’s hard for me to overstate how great it is to not have to reach for the mouse - or even outside the home row of the keyboard. Christiansen calls this the “penalty zone” - any time you need to move your fingers away from home row, you’re breaking flow. And when programming, it’s something we have to do all the time!

There are other editors that support this kind of thing, like Emacs. Even VS Code and Visual Studio can be navigated entirely with the keyboard if you’re willing to memorize their keybindings. But they generally rely on “chorded” keystrokes, which put your fingers into sometimes tortured positions (the old unix editor holy war joke is that Emacs stands for “Escape Meta Alt Ctrl Shift”). And often you still have to reach for keys in the “penalty zone”, like PgUp/PgDn/Home/End.

I’m biased, having used vim keybindings in basically every editor I’ve programmed in for the last 25 years. It would be impossible for me to go back now. There are other modal editors, like Helix and Kakoune. They’re basically like vi, but they reverse the order of the keybinds - which has some really nice features, and I might even suggest you try those before getting sucked into vim-land like me. But I do think modal editing, in general, is where it’s at for pure text. Especially programming, but I use it all the time for other tasks like formatting textual data files interactively.

Anyway. Maybe it’s a cop-out, but I think it’s something you have to experience to really appreciate.

I’ve been using vim as my daily driver for development for the last 8 years.

There are a million things I could talk about regarding vim’s editing language, consistent interface, scriptability, performance (seriously, I’ve opened 1GB+ files and vim barely breaks a sweat), etc., but one thing I’ll highlight that most people don’t talk about is vim’s ability to interface with other tools. It’s what takes vim from a great editor into a full-fledged development environment. You can:

• Read the stdout of any shell program into a vim buffer (:help read !)
• Use the contents of a buffer as stdin to any shell program (:help write !)
• Filter a portion of the buffer through any shell program, replacing the contents with that program’s stdout (:help !)
• Parse the output of a program or the contents of a file into a set of entries for quick navigation (:help quickfix, :help make)
• Insert the output of a shell program into the current buffer (:help <C-R>=, specifically when used with the :help system() function)
• Control arbitrary jobs with vimscript and communicate back and forth with code

And much more. I use all of these every day: the output of git commands give me filepaths I can jump to with gf; a range in vim selected with the v command gives me line numbers to pass to git log -L to see the history of a section of code; the current filepath of the vim buffer is pass to many different shell commands to do processing with that file; the symbol under the cursor is passed as an argument to the open command on macos to lookup external (company-specific) documentation in a Web browser. And many, many other things. Unix is my IDE, and vim is at the heart of it.

Stockholm syndrome

Is there any good interactive VIM/Helix tutorial/practice tool? I imagine something like hotkey trainers for Starcraft, or keyboard typing trainers. It gives you a task, and measures time how fast it takes you to do it, giving you hints about best keybindings in the process. I did find https://www.openvim.com/ , which is great to learn what options there are, but I’m missing the trainer part of it giving you tasks and scoring you on them, that you can drill in to learn it quicker.

Also, it’s missing macros and some of the more advanced stuff, which would also be great if included.

One of my favorite emacs features is the VHDL stutter mode (which replaces certain repeatedly-typed characters with operators), as well as an easy to get to rectangle select, and it just being decently fast compared to something like VSCode. I also never have to take my hands off of the keyboard, because it’s all right there. It just feels better to me.