Questions: Type Systems Overview

Question 1

Which of the following correctly describes the relationship between static/dynamic typing and strong/weak typing?

• A. Static typing always implies strong typing; dynamic typing always implies weak typing.
• B. They are orthogonal dimensions — a language can be any combination of the two.
• C. Strongly-typed languages must check types at compile time.
• D. Dynamic typing means the language does not have types at all.

Answer: (B)

Static/dynamic describes *when* types are checked (compile-time vs. runtime). Strong/weak describes *how strictly* type mismatches are handled (rejection vs. coercion). Python is dynamically but strongly typed — it checks at runtime and refuses `'hello' + 5`. C is statically but weakly typed — it checks at compile time but permits many implicit pointer/integer coercions.

Question 2

A statically-typed language guarantees there will be no type errors at runtime.

• T. True
• F. False

Answer: False

Static typing eliminates many type errors at compile time, but not all. Downcasts, null pointer dereferences, and unchecked array accesses are type-related runtime failures that slip past static checkers. A sound type system (like Haskell's) gives stronger guarantees, but most mainstream static type systems are intentionally unsound to allow useful patterns.

Question 3

Why is a type system described as improving program correctness rather than just documentation?

Model answer: A type system actively enforces constraints — the compiler or runtime rejects programs that violate them. Unlike comments or annotations, types are checked mechanically, so they catch real bugs (e.g., passing a string where an integer is expected) before the code runs. They serve as machine-verified specifications.

Types are often presented as documentation, but their real value is enforcement. When semantic analysis (the prerequisite) resolves names and scopes, the type checker then verifies that every operation is applied to compatible types. This catches a whole class of logical bugs at the earliest possible stage.