predictive parsing
Imagine a parser that never guesses and then regrets it. At every fork in the road it glances at the next token and knows immediately, with certainty, which way to go, no trying a path and backing up. Predictive parsing is top-down parsing done this confident way: by looking ahead a fixed number of tokens (usually just one), it always predicts the correct production without any backtracking.
The trick is a parsing table computed once from the grammar. Rows are nonterminals, columns are possible next tokens, and each cell names the single production to use when you are expanding that nonterminal and see that token. The table is filled using FIRST and FOLLOW sets: roughly, put rule A -> alpha in the cell for token t whenever alpha can begin with t (and, if alpha can vanish to the empty string, whenever t can follow A). A driver program then runs with an explicit stack instead of recursion: it pops the top symbol, and if it is a terminal it matches the input, while if it is a nonterminal it looks up the table cell for that nonterminal and the current token, and pushes the right-hand side of the chosen rule. No cell ever holds two rules in a well-behaved grammar, which is exactly what guarantees no backtracking.
Predictive parsing is the practical, table-driven form of LL parsing, and recursive descent is its hand-coded twin. It is fast (linear time) and gives precise error reporting: when the table cell for the current nonterminal and token is empty, you know immediately the input is malformed and exactly what was expected. The catch is that the table can only be built without conflicts if the grammar is LL(1); grammars with left recursion or common prefixes must be transformed first, and some grammars cannot be made LL(1) at all.
For S -> if S | print, with FIRST(if S) = {if} and FIRST(print) = {print}, the table has one entry per token: cell [S, if] = (S -> if S) and cell [S, print] = (S -> print). Seeing the token if, the parser picks the first rule with no doubt and no backtracking.
A parsing table maps (nonterminal, next token) to exactly one rule, so no guessing is needed.
Predictive parsing only works without backtracking when each table cell holds at most one rule. If two rules land in the same cell, the grammar is not LL(1) and must be rewritten or parsed by a more powerful method.