Names, Variables, Binding, Scope

Tags: #◇Computer Science #◇CSADPRG #◇Conceptual #◇Names, Variables, Binding, Scope

◇Overview

This document discusses the fundamental concepts of names, variables, binding, and scoping in programming languages. It explains the distinction between names, reserved words, and keywords, explores the attributes of variables (such as name, address, type, value, lifetime, and scope), and distinguishes between static and dynamic bindings as well as static and dynamic scoping mechanisms.

◇Key Definitions

Name (Identifier): A string of characters that identifies an entity (e.g., variables, functions, parameters, expressions).
Keyword: A special word that has special meaning in a certain context (e.g., goto in Java).
Reserved Word: A special word that cannot be redefined or used as an identifier by the programmer.
Variable: An abstraction of a computer memory cell or a collection of cells. It has attributes such as Name, Address, Type, Value, Lifetime, and Scope.
Address (L-value): The physical machine memory location associated with a variable. Multiple variables sharing the same address create an effect known as aliasing.
Type: Determines the range of values a variable can store and the set of operations that can be performed on it.
Value (R-value): The actual contents of the memory cell.
Binding: An association between an attribute and an entity (e.g., between a variable and its type, or an operation and its symbol).
Scope: The spatial range of statements wherein a variable is visible and can be referenced.
Lifetime: The temporal duration during which a variable is bound to a specific memory location.
Referencing Environment: The collection of all variables that are visible within a specific statement.

◇Theoretical Framework / Concepts

Binding Times

Binding occurs at different stages depending on the language design and implementation:

Language Design Time: Examples include binding operator symbols to operations (* for multiplication) or defining reserved words.
Language Implementation Time: Example includes the range of values for a primitive type being defined by the specific compiler implementation.
Compile Time: Types of variables and their names are typically bound during compilation for statically typed languages.
Link Time: Resolving external functions across different compilation units or libraries (e.g., printf in C).
Load Time: Binding static variables to absolute memory cells via the OS loader.
Run Time: Binding of non-static variables to memory cells, or binding data types to variables in dynamically typed languages.

Variable Type Bindings

Static Type Binding: Occurs before runtime and remains unchanged during execution. Types can be specified through explicit declarations (e.g., int x = 1;) or implicit declarations via naming conventions or context-based type inference (e.g., var num = 1;).
Dynamic Type Binding: The type is not specified by a declaration but bound during assignment at runtime. It provides flexibility for generic programming but can lead to less reliable code (loss of compiler error detection) and comes with a runtime cost for type checking and dynamic storage allocation.

Storage Bindings and Lifetime

Static Variables: Bound to memory cells before execution and remain bound until the end of execution. They are highly efficient but lack flexibility (cannot support recursion) and do not share storage spaces.
Stack-dynamic Variables: Bound to memory from the run-time stack when execution reaches their declaration (elaboration). They support recursion and conserve storage by sharing memory space across subprograms, but incur runtime overhead for allocation/deallocation.
Explicit Heap-dynamic Variables: Nameless variables allocated and deallocated explicitly by the programmer during runtime (e.g., via malloc or new). They are useful for complex data structures like linked lists but are difficult to manage properly.
Implicit Heap-dynamic Variables: Bound to heap storage automatically only when assigned values. They offer the highest degree of flexibility but have significant runtime overhead and loss of compile-time error detection.

Organization of Run-time Memory

Code & Global/Static Data: Reside in fixed memory addresses.
Stack: Highly organized memory closely managed by the CPU used for temporary variables and function calls.
Heap: Disorganized, dynamically allocated memory that is not tightly managed by the CPU directly.

Scoping

Static Scoping (Lexical Scoping): A variable's scope can be determined prior to execution just by examining the source code structure. It resolves variables to their nearest enclosing lexical scope. Variable hiding occurs when a local variable shares the same name as a variable in an outer scope.
Dynamic Scoping: Scope is determined at runtime based on the dynamic calling sequence of subprograms. It allows subprograms to easily access their caller's local variables without passing parameters but significantly harms readability, prevents static type checking for non-local variables, and degrades performance.

Named Constants

A variable that is bound to a value exactly once. They improve readability, aid maintenance (serving as a single source of truth), and help parameterize programs by replacing "magic numbers" with descriptive names.

◇Examples

Edge Cases in Identifiers

Fortran Special Words: Fortran has no reserved words, meaning statements like IF (IF.EQ.THEN) IF=IF*THEN are technically valid.

Dynamic Type Binding in Python

『』

PYTHON

list = [1, 2.71, 3.14]
list = "characters" # Type dynamically changes at runtime based on the r-value

Static vs Dynamic Scoping Walkthrough

『』

JAVASCRIPT

function big() {
    function sub1() {
        var x = 7;
        sub2();
    }
    
    function sub2() {
        console.log(x);
    }
    
    var x = 3;
    sub1();
}

In a statically scoped language, the call to sub2() resolves x to 3 (searching from sub2 outwards to big).
In a dynamically scoped language, the call to sub2() resolves x to 7 (searching the call stack: sub2's caller is sub1, which has x=7).

Variable Hiding and Scope Resolution in C++

『』

CPP

#include <iostream>
using namespace std;

int x = 2; // Global x

int main() {
    int x = 3; // Local x hides global x
    
    cout << x;   // Output: 3
    cout << ::x; // Output: 2 (Using scope resolution operator to explicitly reference global x)
    
    return 0;
}

Previous Topic: ◇Evolution of Programming Languages
Next Topic: ◇Data Types
Related Notes: ◇Data Types, ◇Memory Management

NAMES, VARIABLES, BINDING, SCOPE