Static typing

Static typing requires that the type of every variable and expression be known at compile time. This is achieved through explicit type annotations (as in Java) or through type inference (as in Haskell and modern C++ with auto). The compiler uses this information to verify that operations are applied to compatible types, rejecting programs that would cause type errors at runtime. For example, adding a string to an integer is a compile-time error in statically typed languages, preventing a whole class of bugs before execution.

Static typing also enables type safety, meaning that well-typed programs cannot exhibit certain runtime errors. This property is formalized in type theory, where languages like ML and Haskell are known for their strong static type systems that guarantee memory safety and prevent many runtime exceptions.¹

Static typing is not monolithic; it ranges from nominal typing (as in Java, where type compatibility is based on explicit declarations) to structural typing (as in TypeScript, where compatibility is based on shape). Some languages, like C, allow unsafe casts that bypass the type system, while others, like Rust, enforce strict rules to ensure memory safety without garbage collection.²

The main trade-off is between safety and flexibility. Static typing catches errors early and improves performance, but it can be more verbose and less flexible than dynamic typing. However, modern languages with type inference, such as Kotlin and Swift, reduce verbosity while retaining static guarantees. Research shows that static typing can reduce certain types of bugs, though the overall impact on productivity is debated.³

One lesser-known aspect is gradual typing, which allows mixing statically and dynamically typed code within the same program. Languages like TypeScript and Python's mypy implement gradual typing, enabling incremental adoption of static checks in dynamic languages.

Another niche area is dependent typing, where types can depend on values, as in Idris and Coq. These systems can prove properties like array bounds at compile time, but they are complex and rarely used in mainstream development. Additionally, static typing has historical roots in the 1950s with languages like Fortran, which used type declarations to optimize memory layout, a practice that evolved into modern type systems.⁴

Static typing has shaped software engineering practices, enabling large-scale refactoring and IDE support such as autocompletion and code navigation. It is a cornerstone of safety-critical systems, where runtime errors are unacceptable. The rise of languages like Rust and Go reflects a renewed interest in static typing for systems programming, offering memory safety without garbage collection.⁵

Future directions include more expressive type systems, such as refinement types and effect systems, which aim to capture more program properties at compile time. Research continues on making static typing more ergonomic and integrating it with dynamic features, as seen in the development of gradual typing and the adoption of type hints in dynamic languages.⁶

Type inference

The compiler's ability to deduce the type of an expression without explicit annotations.

Type safety

The property that a program cannot cause certain runtime errors due to type mismatches.

Gradual typing

A type system that allows static and dynamic typing to coexist in the same program.

Dependent typing

A type system where types can depend on values, enabling more precise program verification.