Introduction

On Monday, we were looking at the textual regions where a binding is active (the binding's scope).
If for each point in a program for some language, we can determine based on purely textual rule, what binding's a name has, we say the language is statically scoped (like C). If bindings can depend on the active flow of execution we said the language was dynamically scoped (APL, Snobol, TCL, old Lisp).
The rules that determine bindings based on the program are called scope rules.
We then looked at scope rules for BASIC and Fortran.

Nested Subroutines

Algol 60 introduced the ability to nest subroutines. This is allowed in a variety of languages (Ada, ML, Common Lisp, Python, Scheme, Swift, and Fortran 90).
Other languages such as C and its descendents allow classes or other scopes to nest.
In Algol-like languages any constants, types, variables, or subroutine declared with a scope are not visible outside that scope .
For these languages, we have the closest nested scope rule - a name that is introduced in a declaration is known in the scope in which it is declared, and in each internally nested scope, unless it is hidden by another declaration of the same name in one or more nested scopes.
The figure above shows the scope of a variety of variables according to this rule.
Even if a language doesn't support nesting scopes often the language will procvide a collection of built-in or pre-defined objects such as I/O routines, etc. that can be considered to be in an outermost scope which surround the scope in which global objects are declared.

Nested Subroutines and the Stack

As we've already said, the compiler arranges it so that a frame register pointer points to the frame of the currently executing subroutine at runtime.
Using this as a base, target code can access objects within the current subroutine, but what about objects in lexically surrounding subroutines.
I.e., Subroutine A declares subroutine B and C, then calls B and next B tries to call C.
The usual way to handle this is that each frame maintains static link pointer to its parent frame.
Using such a name B could look first for the name C in its own scope, then if not found check the parent scope, and if not found check the parent's parent scope, etc. This is called a static chain.

Declaration Order

If x is declared somewhere within a block B does its scope include the portion of B before the declaration?
In Javascript, if a variable is declared with var then it does, we can imagine the variable is hoisted to the top of the enclosing block.
On the other hand, on Javascript, if a variable is declared with let then it does, not.
We call an attempt to use a name before its declaration a forward reference. In many languages (Pascal, C) this causes a static semantic error.
Pascal has whole block scope, but declare before use rules. This could cause weird interactions:
```
const N = 10;
...
procedure foo;
    const
        M = N;
        ...
        N = 20;
```
One might think that in M=N, N refers to outer constant. This isn't true because N=20 makes N a local constant for the whole block, so M=N is use of N before its declaration.
Many languages relax declare before use in some circumstances, for example, in Java and C# members of a class are visible inside all of a class's methods.
Lisp and Scheme use the letrec construct for whole-block semantics and use the let* constructs declaration-to-the-end-of-block semantics. On other hand, let delcarations don't take effect until after the end of the declaration list:
```
(let ((A 1)) ; outer scope, with A defined to be 1 
  (let ((A 2) ; inner scope, with A defined to be 2 
        (B A)) ; and B defined to be A 
   B)) ; return the value of B
```

Declaration and Definitions

If you have a language that requires names to be declared before use, how can you have recursive data types and functions?
As we've already seen, C and C++ solve this problem by distinguishing between the declaration of object and its definition.
A declaration introduces a name and indicates its scope but may omit its implementation details.
A definition gives sufficient implementation details that a compiler can produce code.

For example,

struct manager; /* declaration */
struct employee {
  struct manager *boss;
  struct employee *next_employee; ...
};
struct manager {  /* definition */
  struct employee *first_employee;
  ... 
};

void list_tail(follow_set fs);  /* declaration */
void list(follow_set fs)
{
  switch (input_token) {
  case id : match(id); list_tail(fs);
  ...
}
void list_tail(follow_set fs) /* definition */ {
  switch (input_token) {
    case comma : match(comma); list(fs);
    ...
}

Nested Blocks

In Algol 60, C89, and Ada, local variables can be declared not only at the beginning of any subroutine, but also at the top of any begin. . . end ({...}) block. For example,
```
void foo()
{
   int i=0;
   i++;
   {
      int j, i;
      j++;
   }
}
```
On the other hand, Algol 68, C (such as C99 and later), allow declaration whenever a statement might appear.
In most languages that allow nested declarations, the nested declaration hides the outer declaration. For example, the inner i above hides the outer i.
Java and C# make it a static semantic error if the outer declaration is local to the current subroutine.

In-Class Exercise

Implement the function:
```
void sort_chars(char *a, char *b);
```
which cycles through two char strings a, b. After it is called, for each location i up to the length of the smaller string a[i] will have the smaller of the original values for a[i] and b[i] and b[i] will have the larger value.
Your implementation should use a nested block and is allowed to have up two additional local variable names (with potential nested block hiding), but is not allowed to make any function calls.
Please post your solution to the Sep 29 In-Class Exercise Thread.

Modules

In order to build a large software project, it is important to be able to divide the effort among programmers in such a way that work can proceed on multiple fronts simultaneous.
One key to doing this is information hiding -- making objects and algorithms invisible to portions of the system that do not need them.
Using classes or static variables within methods, we can hide data, and or names of functions from other parts of the code.
Modules add another layer of abstraction/encapsulation by allowing us to group together a collection of objects, subroutine, variables, types, etc in such a way that:
1. objects inside are visible to each other
2. object inside the module may not be visible outside the module unless they are exported.
3. objects on the outside may not be visible on the inside unless they are imported.
Modules were one of the principle language innovation of the later 1970s and early 1980s appearing first in Clu (called clusters), Modula, Turing, and Ada 83.
In Ada, Java, Perl, they go by the name of package.
In C++, C#, and PHP they go by the name of namespace.

Dynamic Scoping Example

Most of the languages we are familiar with use static scoping (C, Java).
APL, Snobol, Tcl, TeX, early Lisp, and Perl use dynamic scoping.

To understand the difference consider the following pseudo-code:

n : integer
procedure first( ) 
  n := 1
procedure second( ) 
  n : integer
  first( )
n:=2
if read_integer( ) > 0 //*
  second( )
else
  first( )
write integer(n)

If static scoping is used the output is always 1. If read_integer() > 0 and second is called, when it in turn called first, the n in first is the global n not the n local to second().
If dynamic scoping is used, if read_integer() > 0 then second() is called and when first() is called n refers to the n from second(), so the value change to this local n forgotten when second() finishes, so the value of n globally is still 2 and this is what would be written.

Rust

Rust is a programming language developed beginning in 2011 by Graydon Hoare at Mozilla Research.
It was designed as a systems programming language that could be used in place of C because of its comparable performance (in programming language comparison benchmarks only C/C++ are faster) and better safety.
The Linux Kernel now accepts patches in Rust and it is also in use at Microsoft both in Windows and Azure.
Rust can be compiled to a .wasm (WebAssembly binary) file so can be run in web browsers instead of/in tandem with Javascript.
As we have been talking about memory management, and Rust uses a different mechanism then the explicit allocate/deallocate (malloc/free, new/delete, retain/release) of C/C++/Objective-C, or the garbage collection approach of Java/C#/Python, I thought I'd use it as one of the language we learn this semester.
It also has an interesting scoping mechanism.
In terms of language popularity, according to Tiobe.com, it is currently ranked 26 (Sep/Oct 2021), one rank below Prolog, but more popular than Objective-C, Prolog, Julia, Scheme, Haskell, or ML.
The Rust link above gives installation instructions for both *nix (Mac/Linux) and Windows systems.

Hello World

Rust programs typically have the extension .rs
We can make a simple project by creating a new folder hello_world and putting the following file main.rs in it:
```
fn main() {
  println!("Hello world!");
}
```
As you might guess, this declares and implements a function main().
The main() function is the usual main entry point into a Rust program.
println! is a macro which outputs to stdout a string.
To compile this program, we could cd into the hello_world folder and type:
```
rustc main.rs
```
To run the program on a *nix (Mac/Linux) system we type:
```
./main
```
On Windows, we type:
```
.\main.exe
```

Cargo -- The Rust Package Manager

Rust comes with a package manager.
A package manager serve two main purposes:
1. Allows you to control the build of your project like make did for C.
2. It allows you to manage the dependencies of your project on other software/modules to ensure that those dependencies are installed and at the correct versions for your project to work. (This feature is a little like autoconf)
Python (pip), Javascript (npm), PHP (composer), and Perl (cpan) are other languages with package managers.
To redo our hello world with packages, we could cd into our development directory and type:
```
cargo new hello_project
```
This would create a hello_project folder in the current directory. It would have a Cargo.toml file and sub-folder src with a main.rs file (the entry point into code)

The Cargo.toml file (TOML = Tom's Obvious Minimal Language (Created by Tom Preston-Werner, 2013)) looks like:

[package]
name = "hello_project"
version = "0.1.0"
edition = "2018"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

You can modify the above to suit and add dependencies.

Modifying Cargo.toml, Building and Running Projects

Some additional name value pairs we could add beneath [package] are:

authors = ["Me <me@me.com>", "You <you@you.com>",
    "Others <others@others.com>"]
description = "Adds awesome functionality to humdrum program"
license = "MyOpenSourceLicenseV1000"

We are mainly interested in binaries, but to make a new library we could have done:
```
cargo new hello_project --lib
```

To build a project using cargo you can type:

cargo build
//or
cargo build --debug //default
//or
cargo build --releases //more optimizations

This will create a target subfolder where the debug version (for --release, a release version) of your executable could be found.
Typing cargo run would let you run your code.

Publishing Cargo Projects

The site https://crates.io/ is a registry where people can share their Rust Packages.
To publish your package there, you can sign in to the site using your GitHub credentials.
Once logged in, you can go to your account settings at https://crates.io/me, scroll down to API Access, and click New Token:
Once you make an access token, you can save it for use by cargo using a line like:
```
cargo login cioZqMlHFkfKMhbW39WIkaw7uJ86iGJxgUq
```
Make sure to edit your Cargo.toml file so it has description and license attributes set.
Then from within your project directory to publish your project to crates.io, you type:
```
cargo publish
```
To release a new version, simply change the version number in your Cargo.toml file, and do a new publish.
If you decide for some reason you don't want other projects to be able to depend on a particular version you release, you can run a command like:
```
cargo yank -vers 2.0.0
```
and no future projects that use crates.io can depend on that particular version of your project.

Scope Rules, Start Rust

Outline