Understanding how different languages implement their type systems and the benefits behind each is an important piece of knowledge for every developer to have: > In programming languages, a type system is a logical system comprising a set of rules that assigns a property called a type to the various constructs of a computer program, such as variables, expressions, functions or modules.[1] These types formalize and enforce the otherwise implicit categories the programmer uses for algebraic data types, data structures, or other components (e.g. "string", "array of float", "function returning boolean"). ## Static Type Checking > Static type checking is the process of verifying the type safety of a program based on analysis of a program's text (source code). If a program passes a static type checker, then the program is guaranteed to satisfy some set of type safety properties for all possible inputs. ### Weakly Static **Examples:** - C - C++ ### Strongly Static **Examples:** - C# - Java - F# - Scala - Haskell ## Dynamic Type Checking >Dynamic type checking is the process of verifying the type safety of a program at runtime. Implementations of dynamically type-checked languages generally associate each runtime object with a type tag (i.e., a reference to a type) containing its type information. This runtime type information (RTTI) can also be used to implement dynamic dispatch, late binding, downcasting, reflection, and similar features. ### Strongly Dynamic **Examples:** - Python - Ruby - [[Elixir]] - Clojure ### Weakly Dynamic **Examples:** - Perl - Javascript ## Links - [Type Systems](https://en.wikipedia.org/wiki/Type_system) - [Typed Elixir Discussion](https://elixirforum.com/t/typed-elixir/1388/32) - [Incremental Strong Typing](https://danielbmarkham.com/incremental-strong-typing/)