Strong vs. Weak Typing

Note#114

notes
Published

2023-09-12

The concepts of strong and weak typing lack universally accepted definitions, leading to diverse interpretations. A common misunderstanding is to associate the type declarations with strong typing. This is despite the fact that compilers in languages like Go or Rust can infer types, thus not requiring explicity declarations by the programmer, which contradicts the initial association. And optional type annotations are often mistakenly linked with weak typing. Moreover, type declarations are sometimes incorrectly associated with static typing, and type annotations with dynamic typing.

It goes beyond that, but static typing involves type checking at compile-time, whereas dynamic typing involves type checking at runtime.

Regarding the spectrum of strong and weak typing, I tend to define it based on how rigidly a language adheres to type constraints during operations.

Strongly Typed Languages

  • In strongly typed languages, a variable, once declared with a specific data type, cannot be assumed to be another type without an explicit conversion.
  • Operations between incompatible types are usually disallowed without an explicit conversion.

Example in Python

number = 17
letter = "A"
combined = number + letter  # Raises TypeError: unsupported operand type(s) for +: 'int' and 'str'

Example in Go

var number int = 17
var letter string = "A"
// combined := number + letter  // This would result in a compile-time error.

Weakly Typed Languages

  • Weakly typed languages allow variables to be used as though they were of different types with no explicit conversion.
  • The language tries to deduce the operation contextually, which can lead to unpredictable results.

Example in C

int number = 17;
char letter = 'A';  // ASCII value of 'A' is 65.
int combined = number + letter;  // combined will be 82.

Example in JavaScript

let number = 17
let letter = "A"
let combined = number + letter  // combined will be the string "17A".

References