vim: از بقا تا تسلطvim: From Survival to Mastery

One day you SSH into a production server to change one line in a config file and discover the machine has no IDE and no GUI — just a terminal and an editor that has been on every Unix system for decades: vim.

Or, more simply: you run git commit without -m, the screen changes, everything you type does something strange, and Ctrl-C does not save you. That is the famous "stuck in vim" moment.

This chapter starts from zero — assuming you do not even know how to quit — and goes far enough that you can do a repetitive refactor with one macro in ten seconds, make the right call inside a git rebase -i, and give a senior-level answer in an interview.

1. Why vim still matters

Nobody is asking you to write an entire Spring Boot service in vim; that is what your IDE is for. But there are four situations where vim is not a preference, it is reality:

• Servers and containers. Practically every Linux distribution ships vim or vi. Inside a pod or a VM there is no GUI, and application.yml or nginx.conf has to be changed right there.
• git. git commit, git rebase -i, git tag -a and git add -p all open an editor, and that editor is very often vim.
• Cloud-native tooling. kubectl edit deployment/api opens a temporary YAML in your editor and ships it to the API server when you save; crontab -e and visudo behave the same way. If you don't know the editor, you don't know the command.
• Raw speed on text. Once you see text as structure (word, block, paragraph), an edit that takes thirty seconds elsewhere takes two seconds here.

2. Emergency rescue: how to get out of vim

Before any teaching, the exit card:

1) Press Esc  (a few times does no harm)
2) Type:  :q!   then Enter   → quit without saving
   or type:  :wq  then Enter  → save and quit

Why Esc first? Because you were probably in insert mode, so your keystrokes were being added to the text rather than issuing commands.

• E37: No write since last change — unsaved changes: :q! to discard, :wq to save.
• Several files open — :qa! closes them all.
• The screen is frozen — probably the terminal's Ctrl-S, not vim; Ctrl-Q releases it.
• vim disappeared — Ctrl-Z suspended it, it is not dead; type fg in the shell.

3. The modal idea: the single most important concept here

In a normal editor the keyboard always does one thing: produce characters. Everything else needs modifiers, a mouse, or a menu — so 26 letters are "wasted" on typing alone.

vim makes a different trade: modes. In normal mode d means delete, y means yank (copy), p means paste; to type text you must explicitly enter insert mode.

Diagram: the vim mode state machine — نمودار ماشین حالت modeها در vim.

stateDiagram-v2
    [*] --> Normal
    Normal --> Insert: i a o I A O c
    Insert --> Normal: Esc
    Normal --> Visual: v V Ctrl-v
    Visual --> Normal: Esc
    Visual --> Insert: c s
    Normal --> CommandLine: colon slash question
    CommandLine --> Normal: Enter or Esc
    Normal --> Replace: R
    Replace --> Normal: Esc

Esc is far away — three alternatives. Ctrl-[ is exactly equivalent and works everywhere. Ctrl-c is nearly equivalent but skips InsertLeave autocommands and abbreviations. A mapping (inoremap jk <Esc>) works too, but will not exist on someone else's machine — so learn Ctrl-[.

4. Opening, saving, quitting

vim app.yml            # open a file (created on write if missing)
vim +42 app.yml        # open and jump to line 42
vim +/timeout app.yml  # jump to the first match of "timeout"
vim -R app.yml         # read-only
vim -d old.yml new.yml # diff mode
vim -u NONE -N app.yml # no vimrc, no plugins, modern behaviour
vim -O a.py b.py       # side by side (-o for horizontal splits)

5. Motions: moving without a mouse

A motion is a command that moves the cursor. They matter for navigation and — more importantly — because they are the input to operators.

h left    j down    k up    l right

Word-wise movement:

w   start of next word        b   start of previous word
e   end of word               ge  end of previous word
W B E   same, but "word" = anything between whitespace

On user.profile.email, w treats the dots as separators and stops three times, while W sees one word — a difference that matters on file paths, URLs and Java package names.

Within a line:

0   column zero      ^   first non-blank character
$   end of line      g_  last non-blank character      40| column 40

Within the file:

gg  first line        G     last line        42G or :42  line 42
H M L   top / middle / bottom of the screen
Ctrl-d half page down   Ctrl-u half page up
Ctrl-f page forward     Ctrl-b page back
zz  centre the current line   (zt top, zb bottom)
{   previous paragraph   }   next paragraph   ( ) sentences
%   jump to the matching bracket, brace or paren

Targeted movement with f t ; ,:

fx  forward to the next x        Fx  backward to the previous x
tx  forward to just before x     Tx  backward to just after x
;   repeat that search           ,   repeat it in the other direction

On repository.findByStatusAndCreatedAfter(status, cutoff); with the cursor at column zero, f( puts you straight on the opening paren — far better than twenty presses of l.

Counts. Every motion can be multiplied: 3w, 5j, 2}. For vertical jumps turn on set relativenumber so each line shows its distance from the cursor and 7k stops being a guess. But if you catch yourself counting lines with your eyes, you picked the wrong tool: over longer distances a search, :42, or a mark beats a count.

6. The grammar of vim: where it all clicks

Here vim stops being "an editor with strange keys" and becomes a small language for editing text:

[count] operator [count] {motion | text-object}

That is verb + object. The operator is the verb (delete, change, copy); the motion or text object is the object.

Diagram: anatomy of a vim edit command — نمودار ساختار یک فرمان ویرایشی در vim.

flowchart LR
    A[count: optional number] --> B[operator: d c y gU gq]
    B --> C[motion or text object: w e dollar ap iw]
    C --> D[operation applied to that exact range]
    B -.doubled operator.-> E[dd yy cc gUU]
    E --> D

A text object is a stronger idea than a motion: instead of "from here to there" you say "the thing I am inside of".

iw / aw   word (aw also grabs the trailing space)
is / as   sentence        ip / ap   paragraph
i( a(  or  ib ab   parentheses      i{ a{  or  iB aB   braces
i[ a[   brackets     i" a"  and  i' a'   quotes
it / at   inside an HTML/XML tag  /  including the tag

Read these as you would think them:

ciw   change the word you are on
ci"   change what is inside the quotes
da(   delete the parenthesised block including the parens
yi{   yank what is inside the braces
dap   delete the whole paragraph
>ip   indent this paragraph one level
gUiw  uppercase this word

Ctrl-a is a hidden gem: put the cursor on a number and press 5Ctrl-a to add five — perfect for bumping a version in pom.xml or a port in a compose file. Note that old vim treats numbers starting with 0 as octal; modern defaults.vim disables that with set nrformats-=octal, which you must add yourself if you wrote your own vimrc.

If what you copied is "linewise" (from yy or dd), p puts it on the next line and P on the previous one; vim remembers the register's type.

7. Undo, redo, and the cheapest superpower: the dot

u        undo        Ctrl-r   redo
U        undo all changes on the last edited line (itself a change)
.        repeat the last change

. is the smallest command with the biggest payoff: any normal-mode change — a ciw with new text, a dd, a >> — repeats with one keystroke. Burn this into your fingers: change once, then just move and press .

/timeout      ← find the first occurrence
ciw duration  ← change it
Esc
n .           ← next, repeat      n .    ← next, repeat

Why is . sometimes better than :%s? Because :%s/old/new/g is blind — it applies everywhere, including where it should not — while n + . gives case-by-case control at nearly the same speed. Rule of thumb: more than ~15 occurrences with a precise pattern → :%s with the confirm flag; fewer, or with exceptions → n + ..

Undo is a tree, not a stack. Undo a few times, type something new, and the old branch survives:

:earlier 10   ten changes back      :earlier 5m  the file five minutes ago
:earlier 1f   the state at the last write        :later 30s
g-  /  g+     walk the whole undo tree by time         :undolist

:earlier 1f means "put the file back to what I last saved", without losing the way forward.

To keep undo history after vim exits, put set undofile and set undodir=~/.vim/undo// in your vimrc and create the directory. The trailing double slash builds the undo filename from the full path so same-named files don't collide. Read the security section too: those files keep old content on disk.

8. Insert mode: entering it well, and tricks inside it

To add a semicolon at the end of a line: not $ then a then ;, just A; and Esc.

Ctrl-w    delete the previous word     Ctrl-u  delete back to the insert start
Ctrl-t / Ctrl-d   add / remove one indent level
Ctrl-r a  insert register a       Ctrl-r =  evaluate and insert, e.g. 24*60 → 1440
Ctrl-o    run one normal-mode command, then return to insert
Ctrl-n / Ctrl-p   complete a word from the open buffers
Ctrl-x Ctrl-f     complete a file path     Ctrl-x Ctrl-l  complete a whole line

Take Ctrl-n seriously: with no plugin at all, three letters of applicationEventPublisher plus Ctrl-n is enough. Vim 9.2 also offers fuzzy insert-mode completion via set completeopt+=fuzzy (see :help 'completeopt'; the value does not exist in older versions).

9. Search and substitute

/pattern   search forward        ?pattern  search backward
n          next match             N        previous match
*          search forward for the word under the cursor (whole word)
#          same, backward        g* / g#   same but without word boundaries
:noh       turn off match highlighting

You will use * constantly: cursor on a variable name, press *, cycle with n.

set incsearch    " jump to the first match as you type
set hlsearch     " highlight every match
set ignorecase   " ignore case
set smartcase    " unless you typed an uppercase letter yourself

Together they mean /user finds both user and User, while /User finds only User — exactly what a human brain expects.

vim regex basics

.        any character         *  zero or more of the previous
^  $     start / end of line   \|  alternation
\<  \>   word start / end boundary
\d \w \s digit / word char / whitespace   (\D \W \S are the negations)
[abc]    character class       [^abc]  negated class
\(...\)  group (the backslash is required)   \1 \2  backreferences
\+  \?   one-or-more / zero-or-one          \{2,5}  repetition range
\zs \ze  start / end of what actually counts as the match

The extra backslashes are annoying; the \v ("very magic") prefix moves the syntax close to PCRE:

/\v(get|set)[A-Z]\w+     ← without \v you must write /\(get\|set\)[A-Z]\w\+

Substitute: :s

:[range]s/{pattern}/{replacement}/{flags}

:%s/\vlocalhost:8080/api.internal:8443/g     " replace throughout the file
:%s/timeout/duration/gc                       " with per-match confirmation
:%s/\v\s+$//e                                 " strip trailing whitespace
:%s/\v^(\s*)-/\1  -/                          " indent YAML list items by two
:'<,'>s/,/,\r/g                               " turn each comma into a newline
:%s/\v(\w+)\.(\w+)/\2.\1/g                    " swap two parts (backreferences)
:%s/pattern//gn                               " count only, change nothing
:%s//new/g                                    " empty pattern = your last search
:%&&                                          " repeat the last substitute with its flags

With flag c, vim waits on each match for one key: y yes · n no · a all the rest · q stop · l this one and stop · Ctrl-e/Ctrl-y scroll to see context.

:global — the most powerful command in vim

:g runs an Ex command on every line matching a pattern; :v (or :g!) runs it on every line that does not match.

:g/DEBUG/d                     " delete every line containing DEBUG
:v/ERROR/d                     " delete every line without ERROR (log filtering)
:g/^\s*$/d                     " delete blank lines
:g/TODO/normal A  <-- check    " append a note to every TODO line
:g/^import/sort                " sort the import lines
:g/pattern/t$                  " copy each matching line to the end of the file
:g/pattern/normal @q           " run macro q on every matching line

Combining :g with macros is one of vim's biggest levers.

grep -E 'ERROR' app.log | grep 'checkout' | tail -200 > /tmp/slice.log
vim /tmp/slice.log

10. Visual mode: select first, then act

Sometimes you don't know which motion covers exactly the range you want; visual mode lets you select, see it, then apply an operator.

v  charwise     V  linewise     Ctrl-v  blockwise
o  jump to the other end of the selection (to extend from that side)
gv reselect the previous selection

After selecting, every operator you know works: d c y > < = gU gu gq J r ~.

Visual block: column editing

Ctrl-v is what other editors call "multi-cursor". Scenario: comment out ten lines of a .env file.

1. put the cursor on column one of the first line
2. Ctrl-v       ← enter block mode
3. 9j           ← build the vertical block
4. I            ← insert at the start of the block
5. #            ← type it
6. Esc          ← the magic: it is applied to every line

The critical detail: the text does not appear on the other lines until you press Esc. Many people assume it failed.

11. Registers: vim's many clipboards

vim does not have one clipboard; it has dozens. Each is a register, addressed with ":

"ayy   yank the line into register a      "Ayy  append to register a
"ap    paste register a                    :reg  show all registers

"+y  copy to the system clipboard      "+p  paste from it
"_dd delete without clobbering your copy     "0p  paste the last yank
q:   the command history window (editable; Enter runs the line)   q/  same for searches

On a minimal server or container, vim is usually built without X11 support and "+y fails with E353; there, use the terminal's own mouse selection (hold Shift when mouse=a is on) or move the file with scp.

12. Macros: record one edit, replay it a thousand times

A macro records everything you press into a register so you can replay it — vim's strongest tool for repetitive work.

Diagram: the macro record-and-replay loop — نمودار چرخه‌ی ضبط و پخش macro.

flowchart LR
    A[q then a register letter] --> B[perform the edit normally]
    B --> C[q to stop recording]
    C --> D[@a to replay once]
    D --> E[@@ to repeat the last replay]
    D --> F[10@a to replay ten times]
    D --> G[global command with normal @a]

Suppose you have a list of names and want every line to become "alpha",:

qa          ← start recording into register a
I"          ← go to line start, insert, one quote
Esc
A",         ← go to line end, quote and comma
Esc
j           ← move to the next line ← this key is critical
q           ← stop recording
20@a        ← run it twenty more times

Four rules that make a macro reliable:

1. Start with an absolute motion (0 or ^) so it does not depend on the cursor's position.
2. End by moving to the next item — usually j or n.
3. Do not fear a large count. When the macro hits the end of the file or a command fails, vim aborts the remaining repetitions itself, so precise counting is unnecessary.
4. Prefer :g over counting — :g/^\s*log\./normal @a runs only on the lines that matter.

A macro is just a string in a register, so it is editable: paste it into a scratch buffer with "ap, fix the raw keystrokes, put it back with 0"ay$ — or set it directly with :let @a='...'.

13. Marks and jumps: spatial memory

ma   mark the current spot as local mark a (a-z, within this file)
mA   global mark A (works across files)
`a   return to that exact line and column        'a  to the start of that line
:marks   list all marks

Automatic marks vim maintains for you: where you were before the last jump · . `` the last change · `` ^ where you last left insert mode · " `` where you were last time this file was open · `` [ `] the last yank or paste · '< '> `` the last visual selection.

Ctrl-o   go back in the jumplist
Ctrl-i   go forward in the jumplist (this is Tab)
g;  g,   move through the changelist (previous / next change)
:jumps   list the jumps

Think of Ctrl-o as the browser back button: after a gg, a /pattern or a jump to a definition it returns you where you were. To return and keep typing where you left off, gi does it in one keystroke.

14. Buffers, windows, tabs: getting the mental model right

"Tab" means something different in vim than in a browser or an IDE:

• Buffer = a file loaded into memory; not necessarily visible.
• Window (split) = a viewport onto a buffer. Several windows can show the same buffer.
• Tab page = a layout of windows; a workspace, not a file.

Diagram: buffers vs windows vs tab pages — نمودار رابطه‌ی buffer و window و tab page.

flowchart TD
    F1[(file on disk: App.java)] --> B1[buffer 1]
    F2[(file on disk: app.yml)] --> B2[buffer 2]
    B1 --> W1[window A]
    B1 --> W2[window B]
    B2 --> W3[window C]
    W1 --> T1[tab page 1]
    W2 --> T1
    W3 --> T2[tab page 2]

:e path/to/file    open a file             :ls  or  :buffers   list buffers
:b 3               go to buffer 3          :b confi  go by partial name match
:bn  :bp  :bd      next / previous / delete
Ctrl-^  (Ctrl-6)   toggle between the last two buffers — the daily workhorse

By default vim refuses to leave a modified buffer (E37); set hidden removes that restriction and nearly every serious user has it on. Remember :ls marks unsaved buffers with + and :wa writes them all.

Splits:

:sp [file]  horizontal    :vs [file]  vertical    (or Ctrl-w s / Ctrl-w v)
Ctrl-w h j k l   move to the left / lower / upper / right window
Ctrl-w H J K L   move the window itself to an edge
Ctrl-w =  equalise sizes       Ctrl-w _  and  Ctrl-w |  maximise
Ctrl-w c  close this window (the buffer stays)   Ctrl-w o  keep only this one
Ctrl-w T  move this window into a new tab page

Tab pages: :tabnew [file] · gt / gT next and previous · 2gt go to tab two · :tabclose · :tabonly.

Finding files without a plugin

With set path+=** and set wildmenu, :find UserServ<Tab> locates a file anywhere in the project tree and :b User<Tab> searches the open buffers. To search content:

:vimgrep /\vTODO|FIXME/ **/*.java
:copen           " the quickfix window with the result list
:cnext  :cprev   " go to the next / previous result
set grepprg=rg\ --vimgrep\ --smart-case   " with ripgrep installed, :grep is far faster

** covers every subdirectory including node_modules and target/, so exclude those via wildignore (see the starter vimrc) or :find will freeze on a monorepo.

netrw: the built-in file browser

netrw ships with vim and needs no installation: :Ex (or :Explore) browses the current file's directory, and :Sex / :Vex / :Lex do the same in a horizontal split, a vertical split, or a left side panel.

15. Settings and a .vimrc explained line by line

vim works without config, but ten lines of settings move it from "tolerable" to "pleasant".

Where does vim look for its config? It checks several places in order and the first one found wins. If none exists, $VIMRUNTIME/defaults.vim is loaded, which already gives sensible modern behaviour (nocompatible, incsearch, syntax on, filetype plugin indent on, scrolloff=5).

Diagram: vimrc lookup order at startup — نمودار ترتیب پیدا کردن فایل تنظیمات هنگام راه‌اندازی.

flowchart TD
    A[vim starts] --> B[system vimrc is read first]
    B --> C{VIMINIT env var set}
    C -- yes --> Z[first match wins, stop searching]
    C -- no --> D{HOME/.vimrc exists}
    D -- yes --> Z
    D -- no --> E{HOME/.vim/vimrc exists}
    E -- yes --> Z
    E -- no --> F{XDG_CONFIG_HOME/vim/vimrc exists}
    F -- yes --> Z
    F -- no --> G[load defaults.vim from VIMRUNTIME]

A starter .vimrc where every line has a reason:

" ---------- basics ----------
set nocompatible          " modern vim behaviour, not ancient vi emulation
filetype plugin indent on " filetype detection plus its plugins and indent rules
syntax on                 " syntax highlighting
set encoding=utf-8

" ---------- display ----------
set number relativenumber " absolute number on the cursor line, relative elsewhere
set laststatus=2          " always show the status line
set scrolloff=5           " keep 5 lines of context above and below
set showcmd wildmenu      " show the partial command plus a completion menu

" ---------- search ----------
set incsearch hlsearch
set ignorecase smartcase

" ---------- indentation ----------
set expandtab             " turn Tab into spaces
set tabstop=4             " how wide an existing Tab character looks
set softtabstop=4         " how many spaces pressing Tab inserts
set shiftwidth=4          " one indent level for >> and <<
set autoindent smartindent

" ---------- file behaviour ----------
set hidden                " allow leaving a modified buffer without writing
set autoread              " reload if the file changed outside vim
set undofile
set undodir=~/.vim/undo//   " persist undo history across sessions
set directory=~/.vim/swap//

" ---------- navigation ----------
set path+=**              " recursive :find across the project tree
set wildignore+=**/node_modules/**,**/target/**,**/.git/**,**/build/**
set splitbelow splitright " new splits open below and to the right
set mouse=a               " enable the mouse (resizing splits, scrolling)

" ---------- security ----------
set nomodeline            " do not honour settings embedded inside files

Run mkdir -p ~/.vim/{undo,swap} first, or vim will error when it writes.

Three commands for debugging config:

:so %                     " reload this vimrc without restarting
:set shiftwidth?          " show an option's current value
:verbose set shiftwidth?  " and which file and line set it

:verbose set X? is gold: when a plugin overrides your settings, it names the culprit.

16. Plugins, briefly and with judgment

Since Vim 8 there is a built-in package manager, so simple plugins need no external tooling:

mkdir -p ~/.vim/pack/mine/start          # loaded automatically at startup
mkdir -p ~/.vim/pack/mine/opt            # loaded on demand with :packadd
git clone https://github.com/tpope/vim-fugitive ~/.vim/pack/mine/start/fugitive
vim -c "helptags ALL" -c q          # index the new plugin's help files

With many plugins, vim-plug is the common lightweight choice:

curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
  https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

call plug#begin('~/.vim/plugged')
Plug 'tpope/vim-surround'      " change the quotes/brackets around some text
Plug 'tpope/vim-commentary'    " gcc to comment a line
Plug 'tpope/vim-fugitive'      " git inside vim
call plug#end()

Then inside vim: :PlugInstall, :PlugUpdate, :PlugClean (remove plugins dropped from the config) and :PlugUpgrade (update vim-plug itself).

17. vim inside git

git opens an editor for commit messages, interactive rebases, git add -p with e, and git tag -a. Which editor? The precedence is well defined:

Diagram: how git resolves which editor to launch — نمودار انتخاب ادیتور توسط git.

flowchart TD
    A[git needs an editor] --> B{GIT_EDITOR env var}
    B -- set --> Z[launch it]
    B -- not set --> C{core.editor in git config}
    C -- set --> Z
    C -- not set --> D{VISUAL env var}
    D -- set --> Z
    D -- not set --> E{EDITOR env var}
    E -- set --> Z
    E -- not set --> F[fall back to vi]

git config --global core.editor "vim"
git config --global core.editor "vim -f"   # -f means do not fork; needed for GUI editors
export EDITOR=vim                          # other tools read this too
export KUBE_EDITOR=vim                     # kubectl checks KUBE_EDITOR, then EDITOR

kubectl edit follows the same shape: KUBE_EDITOR, then EDITOR, then vi on Linux (notepad on Windows). crontab -e and visudo honour VISUAL/EDITOR.

Writing a good commit message in vim

Write a short imperative summary on line one, leave a blank line, type the body, reflow it with gqap (the convention is 72 columns), then ZZ.

The most important trick: :cq means "exit with an error code". git reads that as "the user gave up" and cancels the commit or rebase — more decisive than deleting the text, and inside a git rebase -i it is the difference between "cancel" and "execute a half-edited plan".

diff and merge

git config --global diff.tool vimdiff
git config --global merge.tool vimdiff
git difftool HEAD~1 -- src/App.java     # compare inside vim
git mergetool                            # resolve conflicts in the four-window layout

git mergetool --tool=vimdiff opens four windows: LOCAL · BASE · REMOTE across the top and MERGED below. The layout is configurable through mergetool.vimdiff.layout, where + opens a new tab and , a vertical split.

Diff-mode keys:

]c   /  [c      jump to the next / previous change
do  (diff obtain)   pull the change from the other window
dp  (diff put)      push the change to the other window
:diffget LOCAL      in a four-way merge: take from a named buffer
:diffput            send to the other buffer
:diffupdate         recompute the diff after manual edits

Vim 9.2 improved diff mode: the linematch algorithm aligns changes using similar lines, far more readable on messy conflicts:

set diffopt+=linematch:60

18. Security and production hygiene

An editor on a server is not harmless. Things that actually matter:

Modelines. vim can read settings from a comment inside the file itself (# vim: set ts=2 sw=2:). That once led to arbitrary command execution: CVE-2019-12735 (fixed in Vim 8.1.1365) let a crafted file run system commands merely by being opened. Modelines are far more restricted today and expression evaluation requires 'modelineexpr', off by default — but where you open unknown files, set nomodeline is a free extra layer.

Open unknown files in a neutral environment.

vim -u NONE -N suspicious.log     # no vimrc, no plugins
vim -Z suspicious.log             # restricted mode: no shell commands
view suspicious.log               # same as vim -R, read-only

Editing root-owned files. The correct pattern is sudoedit (or sudo -e): it opens a temporary copy as your normal user and writes it back as root. With sudo vim you run a full vim as root — one that can :!sh and reads local config with those privileges.

Side files leak data. The swap file (.file.swp), the backup file (file~) and the undo file all keep content on disk. If you edit secrets on a server, disable them for those paths:

autocmd BufNewFile,BufReadPre */secrets/* setlocal noswapfile nobackup noundofile viminfo=

A real example: editing a migration file on a server

Say you must add an index to a migration; the contents differ per database engine:

-- V12__add_index_on_orders.sql
CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_orders_customer_created
    ON orders (customer_id, created_at DESC);
ANALYZE orders;

-- V12__add_index_on_orders.sql
CREATE INDEX idx_orders_customer_created
    ON orders (customer_id, created_at DESC) ONLINE;
BEGIN
  DBMS_STATS.GATHER_TABLE_STATS(USER, 'ORDERS');
END;
/

Where does vim come in? For the same index across several tables: select the block with Vjj, y, p a few times, then rename with :%s/\vorders/order_items/g. vim only changes text; whether the migration is correct belongs to sql-mastery and rdbms-tuning.

19. When to use nano instead

nano (current stable release: 9.1) is a non-modal editor with its key menu printed at the bottom: Ctrl-O write, Ctrl-X exit, Ctrl-W search, Ctrl-K cut, Ctrl-U paste. If it is installed and your job is a thirty-second change, using it is not weakness — it is picking the right tool.

20. Practice drills

The best first investment: run vimtutor in a terminal — an interactive ~30-minute tutorial that ships with vim and works on a temporary copy, so nothing is at risk.

Run these drills on a scratch file, repeating until you stop thinking about them:

1. Survival: type a few characters, quit without saving; then save and quit, once with :wq and once with ZZ.
2. Movement: navigate a source file using only gg, G, }, {, Ctrl-d, Ctrl-u, f, ;. Ban the arrow keys.
3. Grammar: on a function, run ciw, ci", ci(, dap, yi{, >ap, gUiw, pressing u after each.
4. The dot: find a word in five places with * and change each with ciw + n + ..
5. Substitute: write a :%s with the c flag, then rerun it with the n flag to count only.
6. Block: comment ten lines with Ctrl-v + I + #, then uncomment with Ctrl-v + x.
7. Macro: turn a 20-line list of names into a JSON array; @a once, then 19@a.
8. Registers and navigation: put five lines into register b, paste them into another file, then bounce between spots with ma, `a and Ctrl-o.
9. git: commit without -m, reflow the message with gqap, then repeat and abort with :cq.
10. Getting help: open :help motion.txt, follow a tag with Ctrl-], come back with Ctrl-t. Navigating :help matters more than memorising any single command.

21. Cheat sheet: the commands that cover 95% of real use