What is the difference between static and dynamic typing?

Static typing checks types at compile time, catching mismatches before the program runs (Java, Rust, Go). Dynamic typing checks types at run time, so type errors surface during execution (Python, JavaScript, Ruby). Static catches errors earlier; dynamic is more flexible.

What is the difference between strong and weak typing?

Strong typing refuses to silently mix incompatible types, raising an error instead. Weak typing performs implicit coercions — for example JavaScript turns 1 + '2' into '12'. Strength is about coercion, not about when checking happens.

Can a language be dynamic and strong?

Yes. Python is dynamically typed but strongly typed: it checks types at run time, yet it refuses to add a string to an integer without an explicit conversion. C is the opposite — statically typed but weak, allowing implicit pointer and integer coercions.

What is structural versus nominal typing?

Nominal typing matches types by name or declared inheritance (Java, C#). Structural typing matches by shape: any value with the right fields or methods fits, regardless of its declared name. Go interfaces and TypeScript use structural typing.

What is gradual typing?

Gradual typing lets static and dynamic code coexist in one program. TypeScript and Python with type hints are gradual: you can annotate types where you want guarantees and leave the rest dynamic, with the any type opting out of checking.

Programming Language Typing Reference

Email me this result

Get this tool's output sent to your inbox, plus one useful tool a week. No spam, unsubscribe any time.

Two independent axes of type systems

A language’s type system is usually described along two separate axes: when types are checked (static, dynamic or gradual) and how strictly mismatches are handled (strong or weak). These are independent — Python is dynamic but strong, C is static but weak. This reference compares both axes across major languages, along with nominal-versus-structural and type-inference notes.

How it works

The checking axis is about timing; the strength axis is about coercion:

              Strong typing                 Weak typing
Static     Rust, Java, Haskell, Go       C, (C++ casts)
Dynamic    Python, Ruby, Clojure         JavaScript, PHP, Perl, Lua
Gradual    TypeScript, Python+hints      —

A third dimension is how types are compared. Nominal systems match by declared name (a Dog is a Dog), while structural systems match by shape — Go interfaces and TypeScript accept any value with the right members. Duck typing is the dynamic cousin: “if it responds to the method, use it.” The filter lets you slice the table by checking model and search by name or concept.

Tips and notes

“Strong” and “static” are not synonyms — keep the two axes separate when reasoning.
Structural typing (Go, TypeScript) reduces boilerplate but can hide accidental matches.
Gradual systems let you add types incrementally; any is the escape hatch that weakens guarantees.
Type inference (Rust, Haskell, Kotlin) keeps static code concise without losing safety.