Vim is not simply a keyboard-controlled version of a conventional editor. Its normal mode treats editing as a composable command language: you combine an operation, a count, a motion or text object, and then repeat the result. That design can make repetitive changes remarkably efficient, but it also creates a steep learning curve. Elliot Williams’s August 8, 2016 Hackaday article makes a case for understanding that model rather than treating Vim as a contest entry in the old vi-versus-Emacs debate.
What Williams means by calling Vim a language
In a conventional editor, typing and editing usually happen through the same interaction style. Vim separates them into modes:
- Insert mode is for entering text. You type characters, words and lines much as you would elsewhere.
- Normal mode is for editing. Keystrokes move the cursor, delete or change text, search, paste, record macros and invoke other operations.
Williams describes the distinction this way: “Vi is something else. It’s a programming language for editing text that’s disguised as an editor.” The point is not that every keystroke is mysterious; it is that normal-mode commands can be combined according to a consistent grammar.
Verbs, modifiers and objects
A change command such as c is an operation. A count changes how many times it applies, and a motion or text object specifies the text it should affect. For example:
Recommended Free Tools
#1 Best Overall
cawmeans “change a word,” including the surrounding word boundary selected by theawtext object.ci)means “change inside parentheses,” leaving the parentheses themselves in place.c5wmeans “change the next five words.”
After the command completes, Vim enters Insert mode so you can type the replacement. Press Esc to return to Normal mode and issue another editing command.
Why modes can help with repetitive edits
Williams’s argument is that typing new prose is mostly just typing, while editing often consists of repeated, structured actions. A modal editor reserves Normal mode for those actions instead of requiring a separate shortcut for every variation.
The dot command
Pressing . repeats the last complete editing action. A practical sequence is:
- Use a search such as
/oldNameto find the first occurrence. - Perform one transformation, for example a change or deletion.
- Press
nto move to the next match. - Press
.to apply the same transformation there.
The search movement and the edit remain separate: the search finds the next location, while . replays the edit. This is useful when the same change appears many times but still needs a human check at each match.
Counts, motions and text objects
Counts let one command scale without creating a new shortcut. Motions can move by characters, words, sentences or structural locations; text objects describe units such as a word, quoted string or parenthesized region. Once learned, the same editing verb can operate on each of those targets.
Command-line mode for document-wide operations
Vim’s command-line mode begins with : and is suited to operations that address a file or a range rather than the current cursor position.
Rank #3
Confirmed substitution
:%s/one/two/gc searches the entire file (%) and substitutes two for one. The g flag handles multiple matches on a line, and c asks for confirmation before each replacement. Confirmation is important when the same text can appear in different contexts.
Save and quit
:wq writes the file and quits. Keeping this command in command-line mode reinforces the division between editing text and controlling the document or session.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Shell and file insertion commands
:rreads a file into the current buffer.:!runs a shell command.:r!runs a shell command and inserts its output at the cursor.
These commands connect the buffer to ordinary command-line tools without requiring a separate copy-and-paste workflow.
Registers and macros: storing text and actions
Registers
Registers are named storage locations. Deleted or yanked text can be placed in a register and pasted later; registers can also hold recorded command sequences. This gives Vim more deliberate storage than a single undifferentiated clipboard.
Recording and replaying a macro
- Press
qfollowed by a register name, such asqq, to start recording into registerq. - Perform the Normal-mode commands you want to automate.
- Press
qagain to stop recording. - Press
@qto replay the macro. Repeat it with@@for the most recently executed macro.
Macros are powerful because they capture a sequence, not merely one replacement. They are best used after testing the sequence on a small number of lines; an incorrectly targeted macro can repeat the wrong action quickly.
A compact tour of useful commands
| Command | Purpose |
|---|---|
I |
Enter Insert mode at the beginning of the line. |
A |
Enter Insert mode at the end of the line. |
u |
Undo the most recent change. |
CTRL-r |
Redo an undone change. |
/pattern |
Search forward for a pattern. |
f{character} |
Move to the next occurrence of a character on the line. |
gg=G |
Reindent the entire file using Vim’s indentation rules. |
g; |
Jump to an earlier change location. |
CTRL-] |
Follow a tag or help link under the cursor. |
CTRL-t |
Return through the tag stack after following a tag. |
CTRL-n and CTRL-p |
Move through insert-mode completion suggestions. |
These commands are building blocks, not a list to memorize in one sitting. Their value increases when combined with motions, counts, registers and ..
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →How to learn Vim without drowning in commands
- Start the built-in tutorial. From Vim, run
:help tutor. It provides a guided introduction inside the editor. - Learn the mode transition first. Practice entering Insert mode, pressing
Esc, moving in Normal mode and undoing withu. - Add a small command grammar. Learn one or two operators such as
d(delete) andc(change), then pair them with familiar motions and text objects. - Practice repetition deliberately. Use search, make one change, move to the next match and use
.. Later, record a short macro. - Keep a recovery habit. Use
uandCTRL-r, and test substitutions with the confirmation flag before accepting every match. - Delay a large plugin setup. Williams recommends learning the core editor before installing a large collection of extensions. The historical article mentions shell integration, vi-style Bash Readline mode, browser extensions and Vim-style browsers; those examples date from 2016 and should not be read as a guarantee of current availability.
Williams characterizes mastery as continuing practice rather than a course that can simply be completed. His personal account—five years of Vim use at six to eight hours a day in 2016—is autobiographical, not a measurement of typical users.
Is Vim really better than Emacs?
There is no controlled benchmark or current product comparison in Williams’s article, so “better” depends on the work and the user. The useful distinction is the interaction model:
| Axis | Vim’s approach | What the article establishes about alternatives |
|---|---|---|
| Interaction | Modal: Insert mode types; Normal mode edits. | Emacs is presented only as the contrasting, mostly non-modal tradition; no detailed current comparison is supplied. |
| Command composition | Operators combine with counts, motions and text objects. | No equivalent feature-by-feature analysis is provided. |
| Repetitive edits | ., searches, registers and macros target repeated transformations. |
No benchmark establishes that Vim is faster for every workflow. |
| Discoverability | High initial memorization cost; the mode distinction is unfamiliar to many beginners. | The article does not score discoverability for Emacs or other editors. |
| Extensibility | Plugins and integrations can extend the model. | The article does not compare current plugin ecosystems. |
| Learning curve | Steep at first, with benefits that grow through practice. | No population study or completion-time statistic is supplied. |
Choose Vim when composing small commands and repeating precise transformations fits your work and you are willing to practice. Choose another editor when immediate discoverability, a mostly non-modal workflow or a different extension model matters more. The evidence here supports a design explanation, not a universal winner.
What the 2016 article can—and cannot—prove
Elliot Williams’s Hackaday article was published on August 8, 2016. It is an opinionated tutorial and defense of Vim, not a current benchmark, user survey or independent study. Its strongest lesson remains conceptual: Vim separates typing from editing and gives Normal mode a composable grammar. Whether that grammar improves your work depends on the kinds of changes you make and the practice you are prepared to invest.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
