Go Typing Drill

:= { } ( ) * & .

Every passage contains: { } ( ) * & . · :=

Net 0 wpmGross 0 wpmAcc 100%

func Total(rows []Row) int { return total reader := &FileReader{Path: path} total += r.Count } for _, r := range rows { if err != nil { reader := &FileReader{Path: path} value, ok := cache[key] defer file.Close() rows := make([]Row, 0, 16) } ptr := *reader total += r.Count rows := make([]Row, 0, 16) defer file.Close() return nil, err return total } return total ptr := *reader rows := make([]Row, 0, 16) rows := make([]Row, 0, 16) if err != nil { if err != nil { reader := &FileReader{Path: path} } total += r.Count return total return nil, err return total defer file.Close() return total total := 0 reader := &FileReader{Path: path} rows := make([]Row, 0, 16) ptr := *reader ptr := *reader value, ok := cache[key] }

QWERTY layout assumed. Backspace corrects; uncorrected errors count against net WPM.

This drill's required set is seven characters — brace, parenthesis, asterisk, ampersand and period, plus the colon and equals sign that make up :=. That's the smallest set in this batch apart from the SQL Typing Drill's six, and it isn't an accident: six of this passage's fifteen lines contain the short declaration operator, more than a third of everything typed, which means most of the drill's real practice comes from repeating a small number of motions rather than meeting new ones.

:= itself is two presses on the same right pinky with Shift released in between — a shifted semicolon-key press for the colon half, then an unshifted press of the very next key over for the equals half. That's a different discipline from the Rust Typing Drill's double colon, where Shift stays held across both presses rather than dropping away partway through.

reader := &FileReader{Path: path} packs three separate ideas into one short line: the declaration operator, an ampersand glued directly to the type name right after it, and a brace that follows FileReader with no space at all — a different habit from func Total(rows []Row) int {, where the opening brace does follow a space, a few lines earlier in the same file.

Why This Drill

Because := recurs in six of fifteen lines, this drill's real value is in how often the hand repeats one specific two-key, one-finger sequence rather than in variety. rows := make([]Row, 0, 16), total := 0 and ptr := *reader all ask for the identical motion, which is exactly what makes getting the shift-release timing right, rather than merely reachable, worth practising here.

Set directly against the Rust Typing Drill's ::, the contrast is specific rather than general: both operators use the right pinky twice, but Rust holds Shift across both presses while Go releases it between the two — two languages built around a nearly identical hand motion that differ in exactly one detail, whether the modifier stays down or lets go partway through.

Go's brace also can't be typed on autopilot. func Total(rows []Row) int { follows a space with its opening brace, the ordinary pattern most typists expect; &FileReader{Path: path} attaches the same character directly to the word before it instead, with no space at all, so the hand has to read which kind of line it's in rather than reaching for the brace the same way every time. The Code Typing Test is the place to see how that reading holds up once several languages are mixed together rather than practised one at a time.

A Shift Released Halfway Through a Two-Character Operator

:= starts with a shifted press of the semicolon key for its colon half, then releases Shift for an unshifted press of the key right beside it for the equals half — one finger, two presses, and a modifier that comes and goes between them rather than staying down for both.

The Smallest Symbol Set in This Batch, and Why That Matters Here

Seven required characters is fewer than any of this batch's other languages apart from SQL's six, and six of this passage's fifteen lines repeat the same short declaration operator. The narrowness is the point — a language with few operators to choose from asks a typist to get very good at a small number of them rather than reasonably good at many.

A Brace That Sometimes Follows a Space and Sometimes Doesn't

func Total(rows []Row) int { opens its body with a brace one space after int. reader := &FileReader{Path: path} attaches the identical character directly to FileReader with no space at all, since it's building a value rather than opening a block. Both are correct; a typist can't rely on a single fixed rule for either one.

An Ampersand and an Asterisk With Nothing Before Them

&FileReader{Path: path} and ptr := *reader both press their symbol directly against the identifier right after it, with no space separating the two. Neither character is doing arithmetic or joining two finished words here — one takes a reference, the other follows one back to its value.

Frequently Asked Questions

Why does := feel like one motion rather than two separate keystrokes?

Because it's used so constantly through ordinary Go code — six of this drill's fifteen lines contain it — that the shift-then-release sequence starts to feel like a single gesture rather than two deliberate presses.

Is := typed the same way as Rust's ::?

Both use the right pinky twice, but Go releases Shift between the colon and the equals sign, while Rust's double colon holds Shift across both presses — the same finger, a different modifier discipline.

Why does this drill have fewer required characters than most of the others in this batch?

Go's own syntax simply uses fewer distinct operators than languages like Rust or TypeScript, and this drill's seven-character set reflects that directly rather than leaving anything out.

Does the opening brace in Go always follow a space?

No. func Total(rows []Row) int { does, but reader := &FileReader{Path: path} attaches the brace directly to the type name with no space, since it's constructing a value rather than opening a function or loop body.

Why are & and * pressed directly against the words that follow them here?

Because both are taking a reference to, or following one back to, whatever comes right after — a prefix operation rather than something sitting between two already-complete words the way the same asterisk works in the Maths Operator Drill.

Does Go's small symbol set make this drill less useful than the others in this batch?

The opposite, if anything — fewer distinct characters means each one gets repeated more often within the same amount of practice text, which is exactly the condition that turns a motion into something typed without conscious thought.