Bracket & Parenthesis Drill
( ) [ ] { }
Every passage contains: ( ) [ ] { }
QWERTY layout assumed. Backspace corrects; uncorrected errors count against net WPM.
Square brackets and curly braces share two physical keys on a standard layout — the same two keys, Shift deciding which pair you get. [ and ] sit there unshifted; { and } are the identical keys held with Shift. Parentheses live somewhere else entirely, up on the number row as the shifted versions of 9 and 0. That's the real reason typists who never confuse a comma with a full stop still produce a square bracket where a brace belongs: two of these three pairs are, physically, the same key. The practice path's Symbols: Brackets & Braces lesson introduces this same three-pair confusion once, in a guided pass; this drill is where the shift-versus-location distinction gets tested at length.
The passage pairs each bracket type with short filler words — (one), (two), (see below), [one], [again], {value}, {set} — then nests them: ([nested]), {[mixed]}, (a[b]c), {x(y)z}. Nesting adds a second problem on top of the shift decision: closing marks have to come back out in the reverse order the opening ones went in, the same discipline a line of code enforces on anyone who writes it. A few entries are pairs with nothing between them at all — (), [], {} — typed with no editor auto-inserting the second half.
Why This Drill
Because [ ] and { } are the same two keys with Shift as the only difference, a bracket mix-up here is a shift-state slip rather than a location slip — the finger found the right key and still produced the wrong mark. Parentheses, on the number row and shifted from 9 and 0, sit far enough away that they rarely get confused with either; the confusion this drill targets is specifically between square and curly.
([nested]), {[mixed]}, (a[b]c) and {x(y)z} test something a flat pair like (one) never does: which bracket closes next. Opening three different pairs in a row and then closing them back out in reverse order is the same discipline the TypeScript Typing Drill needs constantly, isolated here without any of the surrounding code syntax competing for attention.
The bare pairs — (), [], {} — are worth their own mention because most code editors auto-insert a closing mark the instant you type an opening one, so a programmer's fingers can quietly get used to only ever pressing half of each pair. A plain typing surface does no such thing; both keystrokes are required, which is a small but real difference between how this drill behaves and how a lot of everyday coding does.
Two Keys Doing Four Jobs, and One Pair Living Elsewhere
[ and ] are their own unshifted keys; held with Shift, those same two keys produce { and }. Parentheses don't share that arrangement at all — they're Shift plus 9 and Shift plus 0, up on the number row, physically distant from the square-and-curly pair. That's why parentheses rarely get swapped for anything else in practice, while square brackets and braces, sharing a location and differing only by Shift, are the pair this drill is really built to separate — a shared-key, shift-only distinction the Semicolon & Colon Drill tests in a simpler, single-key form.
Closing in the Order You Opened
A single bracket pair only ever asks one question: open or close? A nested one like ([nested]) or {x(y)z} asks a second question on top of that — which mark closes first? The innermost pair has to shut before the one surrounding it, the same rule anyone writing a nested clause with the SQL Typing Drill or a function call runs into constantly. Typing the marks in the wrong order here doesn't produce a wrong key so much as a structurally broken pair, a different kind of mistake from hitting } instead of ].
An Empty Pair With Nothing Auto-Inserted
(), [] and {} look like the easiest entries in the passage, but they remove a crutch a lot of programmers don't realise they lean on: most code editors type the closing mark for you the moment you open one. This drill doesn't, so an empty pair here is two keystrokes rather than one keystroke and an assumption.
Frequently Asked Questions
Why do square brackets and braces get confused more than parentheses do?
[ ] and { } are the same two physical keys, separated only by Shift. Parentheses sit on the number row instead, physically apart from that pair, which is why they rarely get mixed up with either one.
What actually goes wrong when typing something nested, like ([nested])?
The most common slip is closing the marks in the wrong order — shutting the outer pair before the inner one, rather than working from the inside out the way the nesting requires.
Does a code editor's auto-closing feature make this drill less useful for programmers?
If anything it makes it more useful — an editor that inserts the closing mark for you removes half the keystrokes brackets normally require, so a plain typing surface that doesn't do that is closer to what your hands need to be able to do without that assistance.
Why does the passage include completely empty pairs like {}?
To isolate the pure open-close motion from everything that normally happens between the two marks. An empty pair still needs both keystrokes typed correctly and in order, without any content in the middle to help carry the rhythm.
Does this drill cover angle brackets, like the ones used in HTML or TypeScript generics?
No — angle brackets are a separate pair on separate keys with their own shift behaviour, covered on the TypeScript Typing Drill instead. This set is limited to the three bracket types conventionally called brackets and braces.
Which hand types which bracket pair?
All three pairs sit on the right hand's outer edge — parentheses on the far right of the number row, square brackets and braces one row down, right beside where the right pinky and ring finger already work.