Concept of Binding

• Binding is an association between an attribute and an entity.
• An example of binding is between a variable and its type or value.
• Another example is between an operation and a symbol.

The concept of binding

• Binding time is when the binding takes place.
• Possible binding times:
  • Language design time: Example is binding operator symbols to operations.
  • Language Implementation time: Example is binding floating point type to a representation.
  • Compile time: Example is binding a variable to a type in languages like C or Java.
  • Load time: Example is binding a C/C++ local static variable to a memory cell.
  • Run time: Example is binding a non-static variable to a memory cell.
  • Link time.
• Error detection is easier at compile time and more difficult to detect at runtime.

Binding of Attributes to Variables

• A binding is static if it occurs before runtime and remains unchanged.
• Static binding occurs throughout program execution.
• An example of static binding: Variable type in Java.
• Dynamic binding occurs during execution or can change during execution of the program.
• An example of dynamic binding: Variable type in Python.
• Static binding occurs before runtime.
• Dynamic binding occurs during runtime.
• Static binding cannot change.
• Dynamic binding can change.
• Static binding is less flexible.
• Dynamic binding is more flexible.
• Static binding is more efficient.
• Dynamic binding is less efficient.
• C, C++, Java, and C# are examples of languages with static binding.
• Python, JavaScript, PHP, and Ruby are examples of languages with dynamic binding.

Storage bindings & lifetime

• Storage binding design determines the fundamental character of imperative languages.
• Allocation involves getting a cell from a pool of available cells, assigning it to the memory cell.
• Deallocation involves putting a memory cell back into the pool.
• Lifetime of a variable is the time during which a variable is bound to a specific memory cell.

Type Bindings

• The binding of a variable to a type has design issues.
• How is a type specified?
• When does the binding take place?
• Explicit declaration: A program statement is used to declare the types of variables. Example: C++ int myVar.
• Implicit declaration: A default mechanism for specifying variable types. Example: Perl @x array.
• Type inference determines the type of a variable from context. Example: C# var value = 12.
• Dynamic type binding has a type specified by the assignment statement. Example: x = 10 means x is an integer, then x = "Hello" means x is now a string.
• With explicit declaration, the advantage includes readability.
• With explicit declaration, languages are safer.
• Implicit declaration offers writability.
• Implicit declaration offers faster coding.
• Implicit declaration reduces reliability, and types cause hidden bugs.
• Dynamic type binding enables flexibility/variable usability.
• Dynamic type binding has a runtime cost for type checking.
• Dynamic type binding means that error detection at compile time is reduced.

Categories of Variables by lifetimes

• Static variables have memory bound before program execution begins.
• Static variables remain bound until program termination.
• Static variables may be global variables.
• Static variables support history sensitive programs.
• Static variables are efficient due to direct addressing.
• Static variables have reduced flexibility and do not allow for recursion.
• Storage cannot be shared amongst variables with static variables.
• Static variables are in C/C++.
• Static variables are in Java (C++ static in class definitions).
• Static-Dynamic variables, storage bindings are created when the declaration statements are elaborated.
• Static-Dynamic variables' types are statically bound.
• Static-Dynamic variables Elaboration occurs during run-time.

Static-Dynamic Variables

• Elaboration entails storage allocation when execution reaches from the runtime stack.
• Deallocation occurs when the scope exits.
• Scalers (variables that had one value at a time) --all attributes except storage and addresses are statically bound
• Normal local variables are in C functions.
• This setup supports recursion and conserves storage.
• It has an overhead of allocation and deallocation costs.
• Sub programs cannot be history sensitive and are inefficient for references.
• In Java, C++, C#, method variables are by default stack dynamic.

Implicit Heap-Dynamic Variables

• Bound to Heap storage only when assigned values
• All attributes bound every time a value assigned
• Deallocation/Allocation caused by assignments.
• Example: All variables in APL all strings I always in Perl, JavaScript, PHP
• This is flexible for generic code.
• There is loss of error detection.
• This is inefficient.

Explicit Heap-Dynamic Variables

• Allocation and Deallocation by explicit directives
• Specified by the programmer, which take effect during execution
• Variables are nameless and referenced via pointer or reference variables.
• Allocated/Deallocated to the heap.
• Heap is disorganized.
• Pointer/reference variable created as scaler variable
• C++ new operator creates variable, returns its address.
• Java objects are heap dynamic/Uses implicit garbage collection(no explicit delete)
• C++ supports new like C#.
• This provides for custom dynamic storage management (Linked list, trees).
• It is often unreliable (difficult to use correctly) and inefficient.
• It is difficult to implement and costly.

Static Type Binding

• Type of variable is determined before runtime and remains fixed throughout execution
• Type checking is performed at compile time
• Languages example: C, C++, Java
• Advantages: Early error detection and Improved performance
• Disadvantages: Reduced Flexibility.
• Serves as a static type.

Dynamic Type Binding

• Type of variable is determined during runtime and can change during execution
• Type checking is performed at runtime
• Types are associated with values rather than variables
• Languages Example: Python, Javascript, Ruby.
• Advantages: flexibility and rapid prototyping
• Disadvantages: Increased runtime overhead and potential runtime errors.