Re: Real-life examples of lexical binding in Emacs Lisp

[Pascal J. Bourguignon]

Rusi <rustompmody@gmail.com> writes:

> On Saturday, May 30, 2015 at 6:20:13 PM UTC+5:30, Pascal J. Bourguignon wrote:
>> Rusi  writes:
>> 
>> > I'd say you are getting this from the wrong end.
>> > Today (2015) dynamic scoping is considered a bug
>> 
>> "Bug" is too strong a word here.
>> 
>> 
>> > In 1960 when Lisp was invented of course people did not realize this.
>> > This is just a belated bug-fix
>> 
>> It is actually in 1960 (or a few years after) when LISP was invented,
>> that people realized there was the so called "Funarg problem".  During
>> the 60s this problem has been studied, several (faulty) solutions
>> proposed, and eventually the notions of lexical binding vs. dynamic
>> binding and environments were elaborated.
>
> I dont understand why the funarg problem is at issue here.
>
> If foo calls bar (not nested within foo)
> And bar references x which it does not define
> The natural expection is a 'Variable undefined' error.
> However in a dynamic scoping discipline, you will get the error if
> foo does NOT define x; else bar will get foo's private x.
> I dont see how this can be regarded as not buggy -- no need to bring in
> functional/higher-order aspects at all.

It's not buggy, because it's the behavior of this tools.

You cannot complain that chainsaw section arms and legs: this is the
behavior of chainsaws.  Just learn how to use them for good use: section
only trees or zombies.


The funarg problem shows that what was wanted with the introduction of
lambda was not dynamic binding, but lexical binding, so that closures
could be created by lambda.


>> Other languages such as Fortran and Algol had already something like
>> lexical binding, but it was actually as accidental as the dynamic
>> binding of LISP, and of no consequence, since in those languages it was
>> not possible to create closures anyways. 
>
> There is somebody-or-other's law (sorry cant remember the reference) to the 
> effect:
> When a language is designed from ground up it usually gets scoping right.
> When a language slowly evolves out of mere configuration into more and more
> features into full Turing-completeness, it invariably gets scoping wrong.
> Examples (in addition to Lisp): perl, python, lua and most famously javascript
>
> I conclude:
> a. Scoping is a much harder problem than appears at first blush
> b. Compiled languages tend to get it more right than interpreted

When LISP was designed, the notion of scoping was just not considered.
It's the invention of LISP and the detection of the funarg problem that
made people think about it, and eventually invent lexical binding and
environments.


-- 
__Pascal Bourguignon__                 http://www.informatimago.com/
“The factory of the future will have only two employees, a man and a
dog. The man will be there to feed the dog. The dog will be there to
keep the man from touching the equipment.” -- Carl Bass CEO Autodesk