CMS 710 · Beyond the Four Modules

Module 4 says a variable has a scope and a lifetime. In fact a variable is best understood as a six-tuple of attributes, and scope and lifetime are two of the six. This framing turns a two-item answer into a six-item one.

Aliases

Two names bound to the same memory address are aliases. Pass-by-reference creates one deliberately: inside void f(int &x), the name x and the caller's variable are aliases for one location. Aliasing is powerful but damages readability and reliability, because a change through one name silently changes the other · which is precisely the risk column in the pass-by-reference table.

Binding and binding time EXTENDS THE SCOPE QUESTION

A binding is an association between an attribute and an entity · between a name and a type, or a name and a memory address. Binding time is when that association is made.

Static (lexical) vs dynamic scoping THE NATURAL FOLLOW-UP

Module 4 distinguishes global, local and block scope. A deeper question asks how a non-local name is resolved · and there are two answers.

x = 10                     # global

def show():
    print(x)               # which x?

def caller():
    x = 99                 # local to caller
    show()

caller()

STATIC scoping  → prints 10   ← Python's answer
DYNAMIC scoping → prints 99   (would look up the caller)

The conclusion to write: languages overwhelmingly chose static scoping because it lets a reader · and a compiler · determine the meaning of every name from the program text alone, which serves the design goals of readability and reliability from Module 1.

Referencing environment

The referencing environment of a statement is the complete collection of names visible at that point. Under static scoping it is the local declarations plus those of all enclosing scopes; under dynamic scoping it is the locals of every active call. It is the formal way of saying "what is in scope here".

The five parameter-passing models EXTENDS TEST Q4

Module 4 gives by value and by reference. The full family, classified by direction of data flow, is:

Design considerations for parameter passing

1. Efficiency · copying large objects is expensive, which argues for reference
2. Safety · one-way (in mode) passing protects the caller's data
3. Whether results should be returned through parameters at all, or only through return values

How the three course languages actually do it

Multi-paradigm languages. The three course languages are all multi-paradigm: C++ supports procedural, object-oriented and generic programming; Python supports procedural, object-oriented and functional; JavaScript supports procedural, object-oriented (prototype-based) and functional. A question asking which paradigm a language "is" is usually asking you to notice exactly that.

The three implementation methods

The phases of compilation · and where Module 3's trees live

The symbol table runs alongside every phase, holding each identifier's name, type, scope and address · the six attributes of §1 in one data structure.

BNF and EBNF

BNF
<assign>  ::= <id> = <expr>
<expr>    ::= <expr> + <term> | <term>
<term>    ::= <term> * <factor> | <factor>
<factor>  ::= <id> | ( <expr> )

EBNF adds shorthand
  { }  zero or more repetitions
  [ ]  optional
  ( | ) choice
<expr> ::= <term> { (+ | -) <term> }

How a grammar encodes precedence: in the rules above, <term> handles * and sits below <expr>, which handles +. Because multiplication is generated deeper in the tree, it is evaluated first · exactly what Module 3's parse tree for a + b * c shows. That connection is worth a mark on its own.

Static and dynamic semantics

Three ways of describing dynamic semantics

Type checking, coercion and equivalence

• Type checking · ensuring operands of an operator are of compatible types.
• Coercion · an implicit, automatic type conversion performed by the language. JavaScript's "5" + 2 → "52" is coercion, and it is why weak typing lowers reliability.
• Casting · an explicit conversion requested by the programmer, e.g. (double)x.
• Name type equivalence · two variables have the same type only if declared with the same type name. Strict, safe.
• Structural type equivalence · same type if their structures are identical. Flexible, but two unrelated records that happen to match become interchangeable.

Exception handling · worth knowing in outline

An exception is an unusual event, erroneous or not, detectable by hardware or software, that requires special processing. Exception handling lets a program intercept it and respond rather than terminate.

C++      try {
             risky();
         } catch (exception &e) {
             cout << "handled";
         }

Python   try:
             risky()
         except Exception:
             print("handled")

Its contribution: exception handling improves reliability, and Module 1 names it explicitly as one of the ways a language achieves that goal.

The trade-offs to quote in any design question