Skip to content

Programming
ProgrammingAll of Programming
How one language or tool really behaves: the mechanism, a snippet that runs, and where it breaks.
- Go
- Java
- Python
- Rust
- TypeScript and React
- JavaScript
- CSS
- Motion
- Shell
- Vim
Engineering patterns and architecture
Engineering patterns and architectureAll of Engineering patterns and architecture
Language agnostic system design, including how GoByte is built: patterns, reliability, data, security and agents.
- Design patterns
- Architecture
- Reliability
- Data
- Security
- Agents
Marketing aid
Marketing aidAll of Marketing aid
Tool neutral playbooks for the job GoByte measures: attribution, launches, affiliates and social.
- Playbooks
- Attribution
- Launches
- Affiliates
- Social
Using GoByte
Using GoByteAll of Using GoByte
Task oriented guides for people with a GoByte account: links, QR codes, bio pages, analytics, the API and MCP.
Use cases
Use casesAll of Use cases
One customer type, one GoByte setup: what to build, what to measure and where it stops working.
Product and company updates
Product and company updatesAll of Product and company updates
Releases worth a story and how GoByte works. Kept small on purpose.
- Product
- Company

Sign in

.vimrcCourse

Vim

The text on the line, then a text object, an operator with a motion, the dot command, a register, and a global change.

The line is the order

linetextitem latte = "oat"

6 lessons, in orderFree to read

Start lesson 1: Vim from zero: the text is the data

Syllabus

Basics

The types, explained, then an object you can name and call.

01

Vim from zero: the text is the data

2 min read

A Vim buffer is text. w moves to the next word. On the line item latte = "oat", w from the start lands on latte.
```
item latte = "oat"
```
```
latte
```
02

Vim from zero: a text object is the thing you act on

2 min read

A text object names a span of text. i" is the inside of the double quotes. di" on item latte = "oat" deletes oat and leaves the quotes.

Builds on lesson 1.
```
di"
```
```
item latte = ""
```

Practice

A rule that prevents a bug, then a program that uses the object.

03

Vim from zero: an operator needs a motion

2 min read

An operator does nothing until it has a motion. dw deletes from the cursor through the next word. On item latte = "oat", with the cursor on item, dw leaves latte = "oat".

Builds on lessons 1 through 2.
```
dw
```
```
latte = "oat"
```
04

Vim from zero: the dot command repeats the change

2 min read

The dot command repeats the last change. cwadd turns the word under the cursor into add. Dot on the next order line does it again.

Builds on lessons 1 through 3.
```
0cwadd<Esc>
j0.
```
```
add latte = "oat"
add muffin = "warm"
```

Further

One more idea, then a program that puts the pieces together.

05

Vim from zero: a register holds what you yanked

2 min read

A yank copies text into a register. "ayi" on item latte = "oat" copies oat. "ap puts that note at the cursor. The register is the clipboard you can name.

Builds on lessons 1 through 4.
```
"ayi"
```
```
oat
```
06

Vim from zero: a global command repeats one change

2 min read

:g runs a command on every line that matches. :g/^item /normal cwadd changes each order line that starts with item and a space. A note line stays.

Builds on lessons 1 through 5.
```
:g/^item /normal cwadd
```
```
add latte = "oat"
note keep
```

Readings

Shorter pieces in the same language. Any order is fine once the lessons feel familiar.

Vim macros: a register full of keystrokes 2 min
GoByte Skills #27: a Vim macro is just keystrokes in a register. Record once with qa, paste it as text, edit it, yank it back, then run it on every line. The only program whose bug report reads: it did exactly what I did.
Vim's dot command: repeat any change 2 min
GoByte Skills #26: Vim remembers your last change as keystrokes, and . replays them at the cursor. Motions are not recorded, so shape the change to carry its own position: A, not $a. One key of automation, no YAML.
Vim operators and motions: a grammar 2 min
GoByte Skills #25: Vim commands are a verb plus a noun. d waits for a motion, 2w says how far, and every new motion works with every operator. Plus why cw breaks the pattern on purpose.