Dynamic vs Lexical Scope

When code refers to a variable that isn't a parameter or local binding, the language must decide how to resolve it: lexical scope looks at where the code was written, walking outward through the enclosing blocks in the source text, while dynamic scope looks at the call stack at runtime, using whichever binding is currently active regardless of where the referencing code physically sits in the source. Modern Common Lisp is lexically scoped by default, but it retains dynamic scope for a special category of variables, making it one of the few mainstream languages where you can observe both scoping disciplines side by side.

In lexical scope, a lambda or nested function resolves a free variable by looking at the let/defun/lambda forms textually enclosing it at the point it was written, and this is exactly what makes closures work: the lambda always finds the same binding, no matter who calls it or from where. (let ((y 10)) (lambda (x) (+ x y))) will always add the y bound in that specific let, regardless of what other y might happen to be dynamically active somewhere up the call stack when the lambda is eventually invoked.

Common Lisp special variables, declared with defvar or defparameter, and by convention named with *earmuffs*, behave dynamically: a let that rebinds a special variable creates a new binding that is visible to every function called during the dynamic extent of that let, not just to code textually inside it. *standard-output* is the classic example: (let ((*standard-output* my-stream)) (some-function-that-prints)) redirects output from any function called inside that let, even one defined in a totally different file, because the lookup happens by call-time context rather than lexical position.

The danger of dynamic scope is 'spooky action at a distance': a function's behavior can change based on bindings set up far away in the call stack, by code the function's author never saw and couldn't have anticipated, which makes dynamic-scoped code harder to reason about locally. This is precisely why Common Lisp restricts dynamic scope to variables explicitly declared special (via defvar/defparameter, or a local declare special) rather than making it the default for every variable, an ordinary let-bound variable is always lexical, so accidentally shadowing it can't silently change some unrelated function's behavior three calls up the stack.