The vi Editor — Modes, Navigation, Yank-Put, Recovery and Search

Formalize — What "modal, keyboard-driven, terminal-resident" means.

• Modal means the same key does different jobs in different modes (see 7.2). In insert mode j inserts the letter j; in command mode j moves the cursor down. Mode decides meaning.
• Keyboard-driven means every action has a key or key-pair. No menus, no mouse dependency. yy copies a line, p pastes it, u undoes.
• Terminal-resident means vi draws its user interface with terminal character cells, not a graphical toolkit. It works over any Secure Shell connection, inside a docker exec session, on a headless Raspberry Pi, or on a serial console where no window system exists. The editor needs only stdin/stdout and a terminal capability database.

Why this matters for systems programming: systems code is often built and debugged where it runs — on the target machine. You edit a Makefile, a kernel module source, an /etc/nginx/nginx.conf, or a shell script on the machine that will execute it. Having an editor that is always present on Unix-like systems removes a deployment dependency.

Purpose of the drill. The exercise asks you to create a file with a supplied paragraph and then press distinct characters while in command mode, in insert mode, and in command-line mode to see what each key does. The point is to make mode-dependence physical. The same key w inserts the letter w in insert mode, jumps a word forward in command mode, and types the character w as part of a :w command after a colon. Until you feel this shift by trying it, the description stays abstract.

Formalize — Three modes defined.

• Insert mode (also called edit mode) — typed characters are inserted into the buffer as text at the cursor. Backspace deletes within the insert that started the session; you cannot backspace past where that insert began. Prompt feedback is minimal — the text simply appears.
• Command mode — keys are interpreted as navigation or edit commands, not text. h j k l move, w b jump by word, yy yanks a line, p puts, u undoes, : enters command-line mode. You normally start here when you open a file with vi filename.
• Command-line mode — entered by typing : while in command mode. A colon appears at the bottom and you type a line-oriented command there. : plus w writes the buffer to disk, :wq writes and quits, :q attempts to quit (warns if unsaved changes remain), :q! abandons changes, N1,N2y yanks a range, :set nu shows line numbers, :!cmd runs a shell command without leaving vi.

Symbol note: we use Esc for the Escape key, Enter for Return, and : to mean the colon prompt itself. When we write :w we mean colon then w then Enter.

State transitions — The hub model.

• Start state: opening with vi filename lands you in command mode.
• Command → Insert: i inserts before cursor, a appends after cursor, I inserts at line start, A appends at line end, o opens a new line below, O opens above, s substitutes a character, c changes through a motion, R enters overstrike. All begin an insert that ends with Esc.
• Insert → Command: Esc (one press, sometimes two if you are unsure) moves cursor back one character and returns to command mode. The beep when you press Esc already in command mode is confirmation.
• Command → Command-line: : moves you to the colon prompt. You remain there until you finish the command.
• Command-line → Command: Enter executes the command and returns to command mode; Esc abandons the command and returns as well.
• No direct Insert → Command-line path: you must Esc to Command first.

Think of Command mode as the hallway: every room connects to the hallway, but rooms do not connect directly to each other.

What to open and why it matters. The session uses concrete files. One demo opens sample.c with vi sample.c, notes that an empty or unsuitable file is not ideal for the navigation drill, exits, and then opens content.txt with vi content.txt containing a short literary passage. The passage used was:

Woods are lovely, dark and deep, but I have promises to keep. And miles to go before I sleep and miles to go before I sleep.

The wording is pinned because later drills search for specific words and yanking relies on repeated words. You may use any paragraph of two to three lines, but keeping this exact passage reproduces the class results for search (three) and word jumps.

Formalize — Precise behaviour of w and b.

• Trigger: issued in command mode only. In insert mode w inserts the letter; after : it is a letter in a file command.
• w — move cursor to the beginning of the next word. If the cursor is inside a word, it jumps to the start of that word's successor; if on whitespace, it jumps to the start of the next non-whitespace word. Punctuation such as commas and periods count as word boundaries for lowercase w.
• b — move cursor to the beginning of the previous or current word. If the cursor is at word start, b goes to the previous word start; if inside a word, it goes to that word's start on first press and to the prior word on the next press.
• W / B — same geometry but punctuation does not break the word; only whitespace does. So on file,name.txt w would stop at , and ., while W hops the whole token.
• Counts prefix: 3w moves three words forward, 4b moves four words back. The count multiplies the motion exactly as 5yy multiplies yanks — a pattern that repeats across vi.

Counts as muscle memory. The lecture drill says: press w three or four times in a row and watch the jumps; then press b three or four times and watch the reverse. Each press counts as one word step, so three presses of w advance three words. The direct faster form is 3w — same result, one command. This counting habit is not incidental; it transfers directly to yank and delete counts such as 5yy or d2w. Vi multiplies motion by count uniformly, so learning to count w trains you for y and d.

Edges — Line start versus file top. The class considered how to move to the top of the document. Home moves to the beginning of the current line — useful but it does not reach line 1 if you are on line 20. Reaching the file top needs a command that addresses absolute line numbers from command mode.

The canonical answers from companion references are:

• gg — go to first line, first column (Mnemonic: "go go top").
• 1G — go to line 1 (G is "go to line", prefix is line number).
• :1 or :1 Enter — command-line way to go to line 1.
• G alone — go to last line (no prefix means bottom).

Similarly, 0 is beginning of current line (column 1 even if blank), ^ is first non-blank of current line, \\$ is end of current line. The 0 versus ^ distinction matters on indented code.

The lecture left the full answer as a short investigation: try these keys on content.txt in command mode and keep a note for your own reference sheet. That deliberate discovery is part of vi's learning design — the manual is usable, but trying on a known file cements memory.

Formalize — Commands in the (count)(command)(motion) family. In vi a yank means copy without removal and a put means paste, and synchronization is via an internal buffer (also called the yank buffer or unnamed buffer). Every command below must be in command mode; Esc first if you are in insert or at the colon prompt. After : presses, use Esc or Enter to return.

• yy — yank current line. Also Y. Yanks the whole line including its newline, regardless of cursor column.
• n yy or nYY — yank n lines starting at current line. 5yy yanks five lines; message 5 lines yanked confirms.
• yw — yank word: press y then w. Yanks from cursor to start of next word (equivalently, to end of current word plus trailing space). Variant y\\$ yanks to end of line, y0 to line start.
• p — lowercase put: paste buffered content after current line (for line yank) or after cursor (for word/character yank). Cursor ends on the first character of pasted text for line puts.
• P — uppercase put: paste before current line (for line yank) or before cursor (for word yank).
• u — undo last change. Repeated u in classic vi toggles; in Vim it steps back through changes. Ctrl-R redoes in Vim.

General pattern: vi commands follow (count)(command)(motion). d2w and 2dw both delete two words; similarly 3yy and y3y overlap, but 5yy is the idiomatic count-first form.

After versus before — The placement rule.

• Lowercase p — put after current line (for line yank) or after cursor (for word yank). Demo showed yanking a line and using p to create lines below the cursor.
• Uppercase P — put before current line (for line yank) or before cursor (for word yank). If cursor is on line 3 and you press P after a line yank, the new line becomes the new line 3 and the old line 3 shifts to line 4.

Memory aid: lowercase p = "put after (push down)"; uppercase P = "put before (push up)". Same buffer, no re-yank needed to switch.

Quick table:

Formalize — Buffer mechanics.

• Definition: a buffer here is a dedicated memory area inside the editor session that holds the most recent yanked or cut text. It lives in RAM associated with the vi process, not as a visible file.
• What writes the buffer: any yank (yy, n yy, yw, y\\$, colon :...y) and any delete or change that removes text (dd, dw, x, c, etc.) overwrites the same unnamed buffer path. The buffer always reflects the last operation that moved text into it.
• What reads the buffer: p, P, and :put read the current contents and insert at the cursor using placement rules from 7.4.5. The read does not empty the buffer — you can p repeatedly and get the same text each time.
• Visibility: the buffer has no on-disk file. Its content is confirmed two ways: the message n lines yanked after a count yank, and the result of a paste. Absence of a message for yy alone does not indicate empty buffer.

Overwrite rule in full detail. The buffer follows a last-write-wins policy with no history in the default slot. Sequence matters:

1. yy on line A — buffer = line A.
2. yw on word B — buffer = word B; line A is no longer available via p in that slot.
3. 5yy on lines C — buffer = five-line block C; word B is gone.
4. p p p — three copies of block C appear; buffer still = block C after each put.
5. dd on line D — buffer = line D (cut, not yank, but same path).

Practical rule: yank then put before the next yank, unless you intend to replace. If you need two distinct snippets at two destinations, interleave: yank snippet 1 → go to dest 1 → put → go back → yank snippet 2 → go to dest 2 → put. Do not batch all yanks then all puts.

Message as confirmation: after 5yy vi shows 5 lines yanked; after :7,9y it shows 3 lines yanked. Treat these as readouts of buffer size. For single-line yy absence of a message does not mean empty — verify by pasting into an undoable buffer.

Formalize — Colon yank and put syntax.

• General form: :N1,N2y where : enters command-line mode, N1 is start line number, N2 is end line number, comma separates, and y means yank the inclusive range N1 through N2.
• Examples: :2,4y yanks lines 2, 3, and 4 — three lines. :7,9y yanks lines 7, 8, and 9 — three lines. :1,5y yanks first five lines.
• Special addresses: :1,10y lines 1-10, :.,+3y from current line (.) three ahead, :\\$y last line, :%y whole file (% = 1,\\$).
• Yank destination: the inclusive range goes to the same unnamed buffer that yy/yw use.
• Paste options after any yank: return to command mode and press p/P, or stay at colon and type :put (or :put! to put before). :put without address puts after current line, exactly like p; :7put puts after line 7.
• Interchangeable: a range yanked with :N1,N2y can be pasted with plain p; a line yanked with yy can be pasted with :put. Both draw from the same buffer.

Tilde ~ means "no file content on this screen row," not "empty line in file." Vi fills screen rows beyond the end of the file with a tilde in blue at column 1 so you can distinguish a real blank line (a line that contains only a newline) from a screen row that has no file backing. A real empty line occupies a line number and is yankable; a tilde row has no number and cannot be yanked because it is not data.

When the demo pastes a block that includes an empty line (line 9 empty), the pasted block shows a blank pasted line (genuine empty content) and then, on the next screen row below the file end, a blue ~. That juxtaposition proves the empty line was genuinely copied. If you count pasted lines, include empty lines in the count. The 3 lines yanked message already includes them.

Formalize — Temporary copy as recovery mechanism.

• Definition: a temporary copy (also called swap or recovery file in Vim) is an extra file vi maintains and updates as you edit, separate from the file you opened. Location is typically near the original or in a configured swap directory; Vim names it .filename.swp.
• Lifecycle: on vi filename open, vi creates or reuses the temporary file and tracks the original. Edits accumulate in the buffer and are flushed to the temporary file periodically and on certain actions. On normal save-and-quit (:wq, :x, ZZ) the temporary copy is cleaned up. On abnormal termination, the temporary copy remains.
• Why it matters for remote edits: the class stressed editing over Secure Shell where the connection can drop at any time. Without a shadow copy, unsaved changes would be lost completely. Because vi kept a temporary copy that tracked edits, work up to the last flush is still available for recovery.
• What the shadow contains: the buffer state at the time of last update, not the last disk write. Recovery shows you that state so you can save it back to the original.

Convenience path — Auto-detection on plain open. Current implementations (notably Vim) add a prompt so manual -r is not always needed. If a temporary recovery file exists and you simply run vi filename again without -r, vi detects the mismatch between the original file and the shadow and prompts at open time.

Typical prompt choices:

• Recover / Open Read-Only + Recover — loads the shadow content into the buffer (same as vi -r).
• Delete swap / Abandon — discards the shadow and keeps the disk file as is.
• Quit / Abort — exits without deciding, leaving the choice for later.
• Diff / Show differences — in some builds shows swap vs disk.

Choose according to whether you want unsaved edits back. After choosing to recover, the same final step applies: inspect and then save with :w or :wq. After choosing to keep the disk file, you may need to manually delete the .swp file if it persists.

Relationship between the two paths: manual vi -r filename and the auto-prompt are the same mechanism surfaced at different times. Manual -r explicitly asks for recovery; auto-prompt surfaces the decision when you happen to reopen. Both feed the same shadow into the buffer and both require an explicit save.

Platform note from references: Linux users who see E325: ATTENTION Found a swap file and cannot edit should note the .swp file path shown in the message and handle it — do not leave the swap forever or every open will warn. The lecture adds that on Linux you may need to delete the .swp manually otherwise the file will not be editable.

Formalize — Search commands defined.

• /text — search forward for text starting from cursor toward end of file. The forward slash / indicates forward direction. As you type, many builds highlight the match near the cursor — a live preview before you press Enter.
• ?text — search backward for text starting from cursor toward beginning. The question mark ? indicates backward direction.
• Both are command-mode commands. In insert mode / inserts the character; after : it is part of a file command. Press Esc first.
• Pattern /text or ?text is a character string that can be a whole word, part of a word, or phrase. Spaces included before or after the pattern are part of the pattern. Classic vi also supports full regular expressions for variable patterns (e.g. words starting with capital, line-start anchors), covered more in later chapters; for now treat the pattern as a literal string.
• On Enter the cursor jumps to the matched occurrence. If no match exists, vi reports pattern not found and does not move. If wrapping is enabled (default), a search that reaches the end continues from the opposite end and shows Search hit BOTTOM, continuing at TOP (or TOP for backward).

The reference point is the cursor, not the file top. Search starts where the cursor sits, not from line 1. This explains the lecture's live question: with cursor at the very last character, searching for a word that occurs earlier such as three, a forward /three finds no match ahead and would need to wrap, while a backward ?three finds the occurrence behind without wrapping. The conclusion drawn was that backward with ? was the correct choice because the target lay behind the cursor.

Consequences:

• Placing cursor at top and searching forward with / walks the file top-to-bottom in natural order.
• Placing cursor at bottom and searching backward with ? walks bottom-to-top.
• Repeated n walks forward through occurrences in the order ? or / defined; N walks the reverse. Cursor moves after each jump, so the reference point for the next n is the match you just landed on.

Repeat without retyping — n and N. After a search, the last pattern stays available for the session so you can walk through all matches:

• Lowercase n repeats the last search in the same direction originally issued — next forward for a / search, next backward for a ? search.
• Uppercase N repeats in the opposite direction — stepping backward through matches for a / search and forward for a ? search.
• Also / Enter repeats forward and ? Enter repeats backward without retyping.

Operational detail shown in class and emphasized: after typing /three or ?three you must press Enter before n or N will step. If you type the pattern and press n without Enter, the editor has not yet accepted the search — n does nothing or inserts unexpectedly. The required sequence is: ?three Enter then n then n then N to step back.

Wrapping interaction: when repeated n reaches the last occurrence and continues, vi shows Search hit BOTTOM, continuing at TOP (or the TOP variant for backward) and continues from the opposite end. That message is informational — the search wrapped and landed on the first/last match again.

Single-line character finder — f and F. Beyond file-wide / and ?, vi offers a single-line finder issued in command mode:

• f followed by a character finds the next occurrence of that character forward within the current line only. Example: cursor at line start, type f? (keys f then ?) — cursor jumps to the ? character on that same line if it exists ahead. It does not print anything; it only moves the cursor.
• F followed by a character finds backward within the current line. Capital F searches toward column 1.
• Limits: f and F operate only within the current line. They do not cross line boundaries, unlike / and ?. For multi-line search use / and ?; for quick intra-line edits use f and F.
• Companion commands ; repeats the last f/F in same direction, , repeats in opposite direction. t/T are variants that land just before/after the character (until), useful for change commands like ct, to change up to a comma.