Static typing
Static typing
Static typing is a feature of programming languages in which type checking is performed at compile time, as opposed to dynamic typing where type checks occur at runtime. Languages that employ static typing require every variable, function parameter, and return value to have a known type before the program is executed, either through explicit annotations or type inference. This allows the compiler to detect type errors—such as attempting to add a number to a string—early in the development process, reducing the likelihood of runtime failures.
Proponents of static typing highlight several advantages: earlier detection of bugs, improved runtime performance (because type checks do not need to be performed during execution), and better tooling support (e.g., autocompletion and refactoring). Critics note that static typing can lead to more verbose code and reduce flexibility, as some patterns (like heterogeneous collections) may be harder to express. However, modern languages with strong type inference, such as Haskell and Rust, mitigate verbosity while retaining static guarantees.
History
The concept of static typing dates back to early high-level languages. Fortran (1957) required variables to be declared with implicit or explicit types, and Algol (1958) introduced a more formal type system. During the 1970s and 1980s, languages such as Pascal and C further entrenched static typing. The past two decades have seen a resurgence of interest in static typing with the rise of languages like Java, C#, Go, and TypeScript (which adds static type checking to JavaScript). Research in type theory has also led to advanced features such as generics, algebraic data types, and dependent types.
Features
- Compile-time type checking
- Explicit or inferred type annotations
- Elimination of entire classes of runtime errors (e.g., type mismatches)
- Often combined with strong typing, but the two concepts are distinct – a language can be statically typed yet weakly typed (e.g., C) or strongly typed and statically typed (e.g., Haskell).
- Used in systems programming, enterprise applications, and safety-critical software.