I understand them through examples :)
First, Lexical Scope (also called Static Scope), in C-like syntax:
int x = 5;
Every inner level can access its outer levels.
There is another way, called Dynamic Scope used by first implementation of Lisp, again in C-like Syntax:
int x = 5;
int x = 10;
any function that call
will print 5
will print 10
The first one is called static because it can be deduced at compile-time, the second is called dynamic because the outer scope is dynamic and depends on the chain call of the functions.
I find static scoping easier for the eye. Most languages went this way eventually even Lisp (can do both, right?). Dynamic scoping is like passing references of all variables to the called function.
An example of why the compiler can not deduce the outer dynamic scope of a function, consider our last example, if we write something like this:
if(/* some condition */)
The call chain depends on a run time condition. If it is true, then the call chain looks like:
dummy1 --> fun()
If the condition is false:
dummy2 --> fun()
The outer scope of fun in both cases is the caller plus the caller of the caller and so on.
Just to mention that C language does not allow nested functions nor dynamic scoping.