Vim Explained: The Editor That Never Dies

Introduction

Every few years someone declares Vim dead — replaced by VS Code, replaced by AI editors, replaced by something newer. Yet Vim, released in 1991 and descended from vi (1976), is still everywhere: preinstalled on nearly every Linux server, embedded in editors as a plugin, and loved by developers who edit text all day. The reason is not nostalgia. Vim changes how editing works: instead of reaching for the mouse, you compose edits like sentences.

Modes and motions: editing as grammar

Vim's central idea is modes. Most editors have one mode: type and it appears. Vim has several, and the two you live in are:

  • Normal mode — the default, where keys are commands, not text. Pressing j moves down, w jumps a word, dd deletes a line.
  • Insert mode — entered with i, where keys type text as usual; Esc returns to Normal mode.

Commands compose like grammar: a verb, then a motion. d (delete) + w (word) = dw, delete a word. c (change) + i + " (inside quotes) = ci", change the text inside quotes. Once that grammar clicks, editing becomes fast in a way mouse-driven editing never is: you describe the edit, Vim performs it, and your hands never leave the keyboard. Add search (/pattern), macros (recorded keystroke sequences), and :s substitutions, and repetitive edits collapse to a few keystrokes.

The honest trade

Vim's trade is its learning curve: the first week is famously painful — new users famously cannot even quit (:q! exits without saving, if you ever need it). Configuration is a rabbit hole, and modern conveniences like inline AI completions or rich debugging need plugins or a Neovim setup. The rule of thumb: Vim when you edit text constantly, work on remote servers, or want keyboard-speed editing; a GUI editor like VS Code when you want batteries included and a gentler start — noting that many developers get both, running Vim keybindings inside VS Code.

Takeaway

Vim is a modal editor: Normal mode for commands, Insert mode for typing, and commands composed as verb plus motion. It trades a steep first week for editing speed that compounds for years — which is why, fifty years after vi, it is still not dead.

Comments

Post a Comment

Popular posts from this blog

Swift Explained: Apple's Language for iPhone, Mac, and More

Introduction Swift is Apple's language for its platforms: iPhone, iPad, Mac, Apple Watch, and Apple TV. Introduced in 2014 to replace the older Objective-C, it was designed to be safe, fast, and — unusually for a systems language — genuinely pleasant to read and write. Even if you never ship an app, Swift teaches one idea every developer should understand: optionals. Optionals: saying "this might be missing" Most bugs in app development come from one cause: code assuming a value exists when it does not. Swift makes that assumption impossible to hide. A value that might be missing is wrapped in an Optional, and you must unwrap it before use. var nickname: String? = nil nickname = "Waqas" if let name = nickname { print("Hello, \(name)!") } else { print("No nickname set.") } String? means "a String, or nothing". The if let unwraps it safely: inside the block, name is guaranteed to exist. There is no way to accidentally us...
Read more

Flutter Explained: One Codebase, Every Screen

Introduction Flutter is Google's framework for building apps from a single codebase: write once in Dart, and ship to iOS, Android, web, Windows, macOS, and Linux. It powers apps from Google Pay to the New York Times crossword app. Its core idea is simple and radical: everything on screen is a widget, and the interface is rebuilt from data whenever that data changes. Everything is a widget In Flutter, there are no separate concepts for layout, styling, and controls — everything is a widget, nested inside other widgets like HTML elements, but in code: import 'package:flutter/material.dart'; class Greeting extends StatelessWidget { @override Widget build(BuildContext context) { return Center( child: Text( 'Hello, Sara!', style: TextStyle(fontSize: 24, color: Colors.teal), ), ); } } Center positions its child, Text displays words, TextStyle styles them — each a widget, composed by nesting. Layout widgets (like Row, Column, ...
Read more

Go Explained: Simple Code That Runs Fast

Introduction Go was built at Google for a specific frustration: large programs that were slow to build and hard to read. The answer was a language that is deliberately small — fewer features, but the right ones, done well. If you know one programming language already, Go will feel familiar within an hour. The interesting parts are not the syntax, but two ideas: goroutines and channels. Goroutines: cheap concurrency Most languages make running things at the same time feel heavy — threads, thread pools, and careful setup. A goroutine is Go's lightweight version: you start one by writing go in front of a function call. package main import ( "fmt" "time" ) func say(text string) { for i := 0; i < 3; i++ { fmt.Println(text) time.Sleep(100 * time.Millisecond) } } func main() { go say("hello") say("world") time.Sleep(500 * time.Millisecond) } The go say("hello") line does not wait — it st...
Read more