Dynamic Scoping

Question

Early implementations of the Lisp language employed dynamic scoping, but modern Racket implementations do not. This turns out to have important implications for abstraction and modularity. Specifically, dynamically-typed systems can interfere with our expectation that the implementation of the body of a function is not relevant to code that calls upon that function. I.e., if we have a call like (sqrt 16), we don't actually care which algorithm is used to compute a square root, or how that algorithm is expressed, e.g., via recursion or a loop, as long as a correct algorithm and implementation are chosen. Explain how dynamic scoping can break this expectation for some code (hint: consider what could happen if someone changes a higher-order function like map or foldl).

Answer 1

As an example consider the standard Lisp function map.

In some flavors of Lisp you can write a function foo containing

(map 'list (lambda (x) (sqrt x)) '(1 4 36))

which computes the square root of each element of the given list.

So the above expression would evaluate to '(1 2 6).

However, you could write a different map function that visits the given list in reverse,

resulting in (6 2 1).

By looking at the implementation of foo you cannot tell which version of map

will be in the dynamic environment invoking foo, and hence which version

of map will be called by foo.

In contrast, if the scoping were static then foo would always invoke the global map,

independently of any re-implementation of map available at run time.