
“Do What I Mean”: Name Resolution in Programming Languages - wcrichton
http://willcrichton.net/notes/specificity-programming-languages/
======
Animats
Variable shadowing should be an error. If you have to answer the "which X is
this" questions the author covers when reading code, the language is too
confusing. Better to get a compile time error.

~~~
whyever
I disagree. Shadowing can be very useful when transforming types that
represent the same thing. For example, rebinding a variable to be immutable.

~~~
swsieber
Another one is traversing enums in Rust:
[https://docs.rs/syn/0.15/syn/enum.Expr.html#syntax-tree-
enum...](https://docs.rs/syn/0.15/syn/enum.Expr.html#syntax-tree-enums)

~~~
Animats
Those are examples of why shadowing is bad. Too-cute use of a risky feature.
When looking for usage of a variable by search, it's helpful that there not be
shadowing. Cuteness means trouble for maintenance programmers.

------
matheusmoreira
> Imagine that function A binds the variable FOO, and calls the function B,
> which calls the function C, and C uses the value of FOO.

Languages that lack dynamic scoping typically propagate a reference to a
"context" through the B function. One can see this common pattern in threading
libraries such as pthreads, for example. The A function creates a data
structure that contains everything C needs, passes it to B as the "context"
parameter and it is then forwarded to C.

It's more verbose but also more explicit.

------
mannykannot
While the opinions of Mssrs. Steele and Stallman should not be lightly
dismissed, and I think I can see where they are coming from, the marketplace
of programming languages seems to have voted against dynamic scoping to an
extent that it has not, for example, chosen definitively for or against static
typing. Dynamically-scoped variables are rather like globals, but with the
added complication that each one is a stack.

~~~
repsilat
Concrete solutions to Stallman's objection in lexically scoped languages
include,

\- Callable objects that store `FOO`, and

\- Closures that capture `FOO`.

I'm pretty leery of argumentum ad populum. I think we went with lexical
scoping for a few clear reasons, and I don't know if the reasons for dynamic
scoping are compelling. I would love to hear more of them, though.

~~~
mannykannot
My comparison of dynamically scoped variables to globals might be wrong, but,
unlike my comment on the way languages have developed, it is not an argumentum
ad populum.

It has been a while since I worked with dynamically-scoped programs, but I
found it harder to reason about how they worked. Maybe it was just because I
was less familiar with the technique.

It might be that all forms of beyond-local scoping multiply the difficulty in
reasoning about programs (especially in the presence of mutable data), and
dynamic scoping is a more powerful form of it, increasing the opportunity for
setting up difficult-to-follow situations.

The issue of ease of understanding is a different one than ease of extending,
and I would judge the former to be more important, all else being equal.

