Type Binding and Type Safety

Type Binding

• Definition: Specifies how and when a type is associated with a variable.

Static Type Binding

• Type is determined before runtime.
• Explicit Declaration: Type is directly stated in the code (e.g., int x;).
• Implicit Declaration: Type is determined by convention (e.g., in Basic, Perl).
  • Advantage: Increased writability.
  • Disadvantage: Reduced reliability.

Type Inferencing

• The compiler deduces the type based on context (e.g., C#, Visual Basic, ML, Haskell, F#).
  • Example: var sum = 0; (sum is inferred as int).

Dynamic Type Binding

• Type is determined during runtime through assignment (e.g., JavaScript, Python, Ruby, PHP).
  • Example: list = [2, 4.33, 6, 8]; list = 17.3;
  • Advantage: Increased flexibility.
  • Disadvantages:
    • High runtime cost due to dynamic type checking.
    • Difficult type error detection during compilation.

Static vs. Dynamic Type Checking

• Dynamic Type Checking: (JavaScript, Python)
  • Easier to code, harder to debug, slower execution.
• Static Type Checking: (Java, C#, C, C++)
  • Harder to code, fewer runtime errors, better optimization.

Strong Typing

• Definition: Enforces strict rules on type usage and interchange.
  *Example: Java, Python.
• Advantages: Type safety, readability, maintainability.
• Disadvantages: Less flexibility, potential boilerplate.

Language Examples

• C and C++: Not strongly typed (e.g., function parameters not type-checked).
• Java and C#: Strongly typed (due to explicit type casting).

Type Safety

• Definition: Ensures that only allowed operations are performed on data based on its type.
• Type checking can occur at compile time or runtime.
• C/C++: Not type-safe.
• Java and Standard ML (SML): Type-safe.

Strong vs. Weak Typing

• Type Safety: Degree to which a language prevents type errors.
• Strong/Weak Typing: Severity of restrictions on mixing types and implicit conversions.