Read `[abc]`, `[^0-9]`, and `\d \w \s` and predict the single character each accepts, expand every shorthand into the explicit set it stands for, and tell when a class is tighter than a literal.

You wrote `[0-9]` to match a digit and it worked, so you wrote `[cat]` to match the word 'cat', and it matched a single letter instead. Brackets count characters differently than you expect.

Pin a match to the input's edges with `^` and `$`, isolate a whole word with `\b`, branch with `|`, and predict which substring the eager engine commits to when the bar's reach and the anchors collide.

You wrote `cat` to find the animal and your search lit up `category`, `scatter`, and `bobcat` too. The pattern matched a run of letters anywhere it could sit, because nothing told it where to stand.

Trace how a quantifier repeats just the token on its left, watch greedy take the maximum and hand characters back while lazy `+?` grows from the minimum, and tell which span each numbered, non-capturing, or named group captures.

`.+` reads like "grab a few characters." Aim it at `<EM>first</EM>` and it swallows everything to the line's end, then hands characters back one by one until the closing `>` finally has something to match.

Compile a regex into an NFA one operator at a time, stamping a two-state fragment for each literal and ε-wired forks, loops, and seams for the operators, and predict the graph each one adds.

You type `a(b|c)*` into a regex tester and hit go. Before the engine reads a single character of your input, it has already thrown your pattern away and replaced it with a little map of states and arrows.

Run a string through an NFA by carrying the whole set of states the engine could occupy, expanding it for free across ε-arrows on every step, and deciding the match from whether the accept state lands in the final set.

You hand the engine the pattern `ab|ac` and the string `ac`, expecting one marker to walk the graph state by state. Instead it lights up several states at once and advances every one of them on each character.

Turn an NFA into a DFA by naming each reachable state-set as one DFA state, then watch the conversion stay cheap until a pattern makes the state count double toward 2 to the n.

Run `ab|ac` through the NFA and the engine juggles a live set of states on every character, the cloud you watched last topic. Now imagine drawing every cloud it could ever form, once, before a single character arrives.

Sort the real engines into the two families that either compile a machine or explore choices, see why one can never hang while only the other supports backreferences, and pick the family a given constraint demands.

The pattern `\d{4}` runs about the same speed on every engine you try. Swap in `(a+)+$` over a long run of letters and one engine answers in microseconds while another climbs past a full minute, same input, same regex.

Walk a backtracking engine through a pattern with capture groups, predict the span each numbered group records, and trace why a failed branch erases the capture it just wrote.

Run `(a|ab)c` against the string `abc`. The first parentheses grab `a`, the match stalls one character later, and the engine quietly swaps that `a` for `ab` before the pattern finally lands.

Use `\1`, `\2` to match the exact text a group already captured, predict why that re-read forces the backtracking engine class, and decide when a backreference fits versus when structure needs a different tool.

Write `(\w+) \1` and the engine matches `the the` but walks right past `the cat`. The second token is not the pattern `\w+` running again, it is the exact word the first group already grabbed.

Trace why `^(a+)+$` matches instantly but hangs on a near-match, count the equivalent splits the engine retries on failure, and defuse the blowup with an atomic group, a possessive quantifier, or a rewrite.

The regex `^(a+)+$` matches `aaaaaaaaaa` in well under a millisecond, yet hand it `aaaaaaaaaa!`, one character longer and one character wrong, and the same engine on the same machine freezes for seconds, then longer for every `a` you add.

Query the Unicode property table with `\p{L}`, `\p{N}`, and `\p{Script=Arabic}`, predict what `\w` actually matches in a given engine, and reach for property escapes when ASCII assumptions break.

Type `\w+` to grab a word and run it on `café`. In a browser's regex engine the match stops at `caf`, dropping the `é` on the floor, the same silent cut you would get on `naïve` or `Zoë`.

Match a whole user-visible character with \X when the dot would split it into codepoints, predict when two spellings of the same glyph fail a literal pattern, and normalize both sides before matching.

Run the pattern `.` against the accented `à` and the engine hands back a bare `a`, the accent left sitting in the string. One key on your keyboard, two numbers underneath, and the dot only ever takes one.