Variables

Variables Definition

• A placeholder for a value.

• Can refer to complex types.

• Generalized to include semantic concepts like closures.

Variables and Memory Locations

• Refer to explicit memory locations.

• Some languages provide location info (e.g., &var in C).

• Java's Unsafe class provides similar functionality.

Aliasing Definition

• Occurs when two variables point to the same memory location.

• Modifications through one alias affect the other.

• Leads to confusing code and difficult bugs.

Six Attributes of a Variable

• Name

• Address (L-Value)

• Value (R-Value)

• Type

• Extent

• Scope

Names (Identifiers) in Programming

• Identify virtual entities in programs.

• Design choices vary:

  • Case sensitivity

  • Length restrictions

  • Lexical rules

  • Clashes with reserved keywords.

Binding Definition

• Association between an entity and an attribute.
• Determines connections between language elements and properties.

Static vs Dynamic Binding

• Static binding occurs before execution and remains unchanged.
• Dynamic binding occurs during execution and may change.

Allocation and Deallocation

• Allocation: binding variable to an address.
• Deallocation: unbinding variable from an address.
• Can be static or dynamic.

Extent Definition

• The time between allocation and deallocation.
• Period during which a variable stores a meaningful value.

Static Variables

• Bound to a memory location at initialization time.
• Extent is the whole program execution.

Stack-Dynamic Variables

• Allocated from runtime stack upon declaration.
• Deallocated when procedure block returns.

Explicit Heap-Dynamic Variables

• Allocated/deallocated by explicit runtime commands.
• Examples: malloc/free in C, new/delete in C++, all objects in Java.

Implicit Heap-Dynamic Variables

• Memory allocated with value assignments.
• Deallocation occurs with reassignment.

Static Type Binding - Type Declaration

• Variable introduced with explicit type and initial value.
• Common in languages like Algol, C/C++, and Java.

Static Type Binding - Type Inference

• No explicit variable types; inferred from usage.
• Examples include various types in Fortran and Perl.

Dynamic Type Binding

• Type binding at runtime based on assigned value.
• Can change during execution.

Extent for Different Variable Types

• Static: whole program execution.
• Stack-dynamic: duration of procedure call.
• Explicit heap-dynamic: explicit allocation/deallocation.
• Implicit heap-dynamic: implicit allocation/deallocation.

Scope Definition

• The part of code where a variable can be referenced.
• Affects extent, impacting garbage collection.

Local Variables Scope

• Declared within a program block.
• Exist only within that block.

Static Variables Scope

• Whole program scope.
• Temporarily hidden by local variable name clashes.

Lexical Scope

• Aligns scope to statically determined areas of source code.
• Determined by program structure.

Dynamic Scope Definition

• Determined at runtime based on control flow.
• Use is uncommon in modern languages.

Dynamic Scope Example (Perl)

• In Perl: local $x creates a dynamically scoped variable.
• Access depends on call stack.

ECMAScript Global Scope

• Variables declared outside any function are globally scoped.

• Accessible throughout the program.

ECMAScript Local Scope (Function)

• Created by function parameters and variables inside functions.

• Parameters and variables are local to that function.

ECMAScript No Block Scope (var)

• No block scope exists with var.

• Variables inside blocks are scoped to the containing function.

ECMAScript Object Properties

• Accessed via object instance.
• Example: property attached to constructed object.

ECMAScript Closures

• Function retains access to variables from the outer function's scope.
• Inner function can access outer variables.

ECMAScript Prototype Chain

• Properties on an object's prototype are accessible to instances.
• Instance properties can override prototype properties.

OCaml Scope - Function Parameters

• Function parameters are in scope throughout the function body.
• From introduction until the end of function definition.

OCaml Scope - Local Variables

• Local variables are in scope only after the 'in' keyword.

• Limited to the expression following it.

OCaml Scope - Recursive Bindings

• let rec allows recursive references within its own definition.

• Bound name is in scope before the 'in' keyword.