Type Systems

The topic of type system keeps comming up when I hear people discuss programming languages. So let's summarize it.

Dynamic vs Static Typing

I like the definition of pythonconquerstheuniverse:

In a statically typed language, every variable name is bound both a type (at compile time, by means of a data declaration) and an object.

In a dynamically typed language, every variable name is bound only to an object.

Something you can do in a dynamic language, but not in a static language:

foo = "bar"
foo = 9

So the model you have in mind is different. In statically typed languages you imagine variables as containers for specific types of information. In dynamically typed languages, you imagine variables as post-it notes.

The advantage of statically typed languages is less confusion.

Strong vs Weak Typing

Continuing with the definition of pythonconquerstheuniverse:

In a weakly typed language, variables can be implicitly coerced to unrelated types, whereas in a strongly typed language they cannot, and an explicit conversion is required.

What you can do in weakly typed languages, but not in strongly typed languages:

foo = "hello"
bar = 1337
foo + bar

Instead, the strongly typed language needs something like that:

foo = "hello"
bar = 1337
foo + str(bar)

Note that this is a spectrum, but the example from above is where I draw the line.

I'd say strong is to be prefered, but not too strong. For example, if I add a float and a double I would not want to get an exception. Maybe.

Explicit vs Implicit Typing

In an explicitly typed language, all variable types are directly given by the developer.

In an implicitly typed language, the language can infer some of the types.

Note that dynamically typed languages are always implicitly typed. Python likes to call that "duck typing": If it walks like a duck and quacks like a duck, it is a duck.

Overview

See also

• Wikipedia: Comparison of programming languages by type system