Code Typing Test

Net 0 wpmGross 0 wpmAcc 100%Time 120s

SELECT name, count FROM rows WHERE active = 1 ORDER BY count DESC; const total = rows.reduce((sum, r) => sum + r.count, 0); type Result = { ok: true; value: string } | { ok: false }; type Result = { ok: true; value: string } | { ok: false }; if (index >= 0 && index < list.length) { return list[index]; } if (index >= 0 && index < list.length) { return list[index]; } type Result = { ok: true; value: string } | { ok: false }; grep -rn 'total' ./src | sort | uniq -c > counts.txt .row-list > li { padding: 4px 8px; border-bottom: 1px solid #ddd; } SELECT name, count FROM rows WHERE active = 1 ORDER BY count DESC; for (let i = 0; i < items.length; i += 1) { render(items[i]); } for (let i = 0; i < items.length; i += 1) { render(items[i]); } const total = rows.reduce((sum, r) => sum + r.count, 0); if (index >= 0 && index < list.length) { return list[index]; } const total = rows.reduce((sum, r) => sum + r.count, 0); for (let i = 0; i < items.length; i += 1) { render(items[i]); } .row-list > li { padding: 4px 8px; border-bottom: 1px solid #ddd; } func Total(rows []Row) int { total := 0; for _, r := range rows { total += r.N }; return total } if (index >= 0 && index < list.length) { return list[index]; } def load(path): return [line.strip() for line in open(path)] type Result = { ok: true; value: string } | { ok: false }; if (index >= 0 && index < list.length) { return list[index]; } .row-list > li { padding: 4px 8px; border-bottom: 1px solid #ddd; } def load(path): return [line.strip() for line in open(path)] def load(path): return [line.strip() for line in open(path)]

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

The ten fragments in this test's pool span eight different languages and styles — JavaScript, Python, SQL, Go, Rust, a shell pipeline, CSS — each a short, real, working line rather than an abstract exercise, written for this site rather than lifted from any actual project.

What changes here isn't the WPM formula, which stays identical to every other test on the site, but the character mix the formula is applied to. Ordinary English prose is mostly letters with the occasional comma or period; a line of code inverts that ratio hard — parentheses, braces, semicolons, colons, underscores, angle brackets and arrows show up constantly, often several to a single short line, and each one typically costs more time to reach and release than an ordinary letter does.

Because the standard five-character-per-word convention counts every character identically regardless of what it took to type, a WPM score from this test and a WPM score from a plain prose test are not measuring quite the same effort, even when the numbers come out the same. That's not a flaw in the arithmetic — it's an honest limit of applying one formula to very different kinds of text, and it's worth knowing about rather than pretending the numbers translate directly.

How This Test Works

A two-minute attempt strings together enough fragments from the ten-line pool to fill the time, switching languages and styles as it goes rather than settling into one; because the pool spans eight different languages and conventions, a single attempt might move from a Python one-liner using a colon, to an all-uppercase SQL clause, to a Rust line built almost entirely from angle brackets and colons, with no warning at the switch.

That switching is itself part of what this test asks of you: each language carries its own small conventions — snake_case in Python and SQL, camelCase in JavaScript and Rust, ALL CAPS keywords in SQL specifically — and jumping between them mid-passage means your hands can't settle into one consistent rhythm the way a single-language drill lets them.

The calculation behind that number is untouched — How WPM Is Actually Calculated covers it in full — and a lower score here relative to your usual prose result isn't a sign anything is wrong with your typing.

Who It's For

This suits programmers and anyone who spends real time writing code and wants practice with the specific symbols that dominate it — brackets, semicolons, arrows, angle brackets — rather than the ordinary letters most typing tests focus on almost exclusively. If you want to isolate one language's rhythm instead of jumping between eight of them, the Python Typing Drill is built for that kind of repeated, single-language practice, and the Typing for Coding guide covers the broader habits that help beyond any single test.

It's a poor choice if you want a WPM number to compare against your prose score, for the reasons above, and it's not the place to practice a single language's specific idioms in depth — this test trades depth in any one language for breadth across several, on purpose.

A Character Set That Inverts the Usual Ratio

In ordinary English prose, letters make up the overwhelming majority of characters typed, with punctuation appearing only occasionally. In this pool, symbols and digits are common enough to appear in nearly every line — a single Go fragment in the pool packs in curly braces, a colon-equals operator, and several parentheses in one unbroken statement. That density is the single biggest reason this test feels different from every other timed test on the site.

Why SQL Reads Differently From Everything Else in the Pool

The pool's SQL fragment is the only line written in conventional all-capitals style for its keywords — SELECT, FROM, WHERE, ORDER BY — which means typing it correctly means holding shift through several separate words in a row rather than releasing it after each one. That's a different demand from the lowercase-and-symbols style of the JavaScript, Python, and Rust fragments sitting in the same pool, and it's worth noticing which style is actually slowing you down rather than blaming the test as a whole.

What a Slower Score Here Is Actually Telling You

If your code-test score sits well below your usual prose or word-list result, that gap is informative rather than alarming: it's roughly a measure of how much extra time this particular symbol mix costs your hands relative to plain letters. Programmers who type code daily for other reasons often close that gap over time without ever practicing typing as a distinct activity, simply from repeated exposure to the same handful of symbols.

Frequently Asked Questions

Why is my WPM so much lower on this test than on a regular timed test?

Because symbols and punctuation dominate this passage far more than in ordinary prose, and each one generally takes longer to type than a plain letter even though the standard formula counts every character the same way.

Does this test cover one programming language in depth?

No — it spans eight different languages and styles for breadth rather than focusing on one. For depth in a single language, the Python Typing Drill repeats that language's rhythm instead.

Is indentation or leading whitespace part of what this test checks?

Not really — every fragment in the pool is a single line, so there's no leading whitespace to type here the way there is in a real multi-line file.

Is this a good way to practice typing symbols as a group?

It's a reasonable way to get exposure to a wide mix of them, but a single symbol-focused drill — like Shifted Top Row for the punctuation row — builds that skill more directly than a broad, mixed-language passage can.