Static Typing | Dynamic Typing | Type Inference

Static Typing

• Definition: In statically typed languages, type checking is done at compile time. This means that the types of all variables must be known before the program runs.
• Advantages:
• Early detection of type errors.
• Potential for optimizations during compilation.
• Improved performance in some cases.
• Examples: C, C++, Java, Rust.

Dynamic Typing

• Definition: In dynamically typed languages, type checking is performed at runtime. Variables can hold values of any type, and their types can change over time.
• Advantages:
• Greater flexibility in coding and fewer constraints when writing code.
• Easier to prototype and iterate quickly.
• Examples: Python, JavaScript, Ruby.

Type Inference

• Definition: Type inference is a feature of some programming languages that allows the compiler to automatically deduce the types of variables based on the context and usage without explicit type annotations.
• Relationship to Static and Dynamic Typing:
• Type inference can be found in both statically typed and dynamically typed languages.
• In statically typed languages with type inference (like Haskell or TypeScript), the compiler infers types at compile time, providing the advantages of static typing while reducing boilerplate code.
• In dynamically typed languages, inference occurs at runtime, which can lead to type errors if not handled carefully.

Summary of Relationships

• Static vs. Dynamic Typing: They represent two ends of the typing spectrum—statically typed languages catch errors at compile time, while dynamically typed languages do so at runtime.
• Type Inference: Serves as a bridge, enhancing the usability of static typing by minimizing the need for explicit type declarations, while not conflicting with the principles of dynamic typing in languages designed with that paradigm.