Static typing
Static typing is a type-system discipline in which program types are determined or checked before execution, typically during compilation or static analysis.
Essential TypeScript 5, Third Edition
A static type is a type checked for program values and expressions during compilation rather than only during execution.
- How it is used
- Constrains JavaScript value use during TypeScript development so incompatible arguments and operations can be reported by the compiler.
- How deep it goes
- Works through annotations and inference with compiler errors, then identifies unions, guards, special types, and configurable null checking.
- Examples
- Uses tax calculations and a to-do collection to expose wrong argument types and a string result used in arithmetic.
- What you can do after
- Apply it via TypeScript annotations and inference to detect incompatible values before running the compiled JavaScript.
Read how Essential TypeScript 5, Third Edition explains static typing →
Rust Servers, Services, and Apps
Static typing determines and checks program types before execution, generally during compilation.
- How it is used
- Uses compile-time type checking to support safe application backends and software infrastructure services.
- How deep it goes
- Defines compile-time checking and inference, but does not descend into compiler implementation or type-system internals.
- Examples
- Uses unspecified variable types, compiler inference, unresolved types, and conflicting type constraints as examples.
- What you can do after
- Evaluate programs for type correctness before execution and interpret compiler feedback about inference failures or conflicts.
Read how Rust Servers, Services, and Apps explains static typing →
Functional Design and Architecture: Examples in Haskell
A statically typed language checks the types of program constructs before execution, typically during compilation.
- How it is used
- Uses compile-time types to design valid-by-construction functional programs and reduce reliance on debugging.
- How deep it goes
- Explains compiler-gated error classes and domain modeling with algebraic data types, but does not detail type-system implementation internals.
- Examples
- Uses Shape and area definitions, an invalid area call, a compiler mismatch, and measurement-unit errors as examples.
- What you can do after
- Evaluate and design domain models that let compilers reject mismatched operations before execution.
Read how Functional Design and Architecture: Examples in Haskell explains static typing →
React in Depth
A static type is a type assigned and checked during program analysis before the code executes.
- How it is used
- Uses static typing to catch mismatches before execution and make React code more reliable and maintainable.
- How deep it goes
- Works through parameter annotations, inference, unions, and component props, but does not detail type-checker internals.
- Examples
- Tests a Fibonacci function with invalid arguments, restricts status values, and defines React component props.
- What you can do after
- Apply it via TypeScript to annotate function parameters and React props, infer result types, and catch incompatible values.
Grokking Simplicity
A type system that checks and constrains the types of program expressions before execution.
- How it is used
- Uses compile-time constraints to catch invalid field names and other type mistakes before execution.
- How deep it goes
- Defines compile-time checking and contrasts it with run-time checking, but does not explain type-system internals.
- Examples
- Uses field-name strings, TypeScript, Java enums, Haskell discriminated unions, and a JavaScript run-time validation alternative.
- What you can do after
- Evaluate whether compile-time checks or run-time checks better protect names and types in a chosen language.
F# in Action: A Revised Edition of Get Programming with F#
A static type system assigns and checks types during compilation rather than primarily during program execution.
- How it is used
- Supports safer application, web, scripting, and domain-modeling work by moving many bug checks into compilation.
- How deep it goes
- Defines compiler-enforced types, type inference, and domain wrapper types, but defers detailed inference mechanics.
- Examples
- Uses even-number filtering and squaring composition, plus City and Country wrapper types in an Address model.
- What you can do after
- Evaluate/understand how compiler-checked, specific types can encode business rules and prevent incompatible data from being combined.
Read how F# in Action: A Revised Edition of Get Programming with F# explains static typing →
100 Java Mistakes and How to Avoid Them
A static type system determines and checks the types of program expressions before execution.
- How it is used
- Uses compile-time type checking to prevent avoidable cast failures and make variable, parameter, and return-type contracts more precise.
- How deep it goes
- Explains safer declarations, guarded casts, inspections, and generic type-erasure delays, but does not develop type-system internals.
- Examples
- Uses Object-to-String processing, equals implementation, generic iteration, and IntelliJ IDEA cast inspections as concrete cases.
- What you can do after
- Apply it by choosing concrete types, guarding required casts, adopting pattern matching, and reviewing unchecked-cast warnings contextually.
Read how 100 Java Mistakes and How to Avoid Them explains static typing →
Kotlin in Action, 2E
Static typing is a language discipline in which the type of every expression is determined at compile time.
- How it is used
- Uses compile-time type knowledge to catch invalid member access, inconsistent calls, and selected run-time failures earlier.
- How deep it goes
- Explains compiler checks, inferred declarations, static extension dispatch, nullability, and type checks, without detailing compiler internals.
- Examples
- Uses inferred integer variables, View and Button dispatch, nullable strings, and Any-to-String type checks.
- What you can do after
- Apply Kotlin’s type system through inferred declarations, nullable types, compiler-checked calls, and statically resolved extensions.
Julia as a Second Language
Static typing is a language property in which types are associated with expressions and checked before a program runs.
- How it is used
- Frames the tradeoff between catching type mistakes before execution and supporting interactive, performance-demanding scientific work.
- How deep it goes
- Defines when type checks occur and compares development workflows, without developing formal type rules or a static-type checker.
- Examples
- Contrasts compile–launch–load iterations on a large dataset with interactive analysis, alongside examples of statically typed languages.
- What you can do after
- Evaluate/understand it as an early-checking property while distinguishing that property from the compilation and interaction workflows discussed alongside it.
Read how Julia as a Second Language explains static typing →
Go in Practice, Second Edition
Static typing determines and checks program types through analysis before execution, typically during compilation.
- How it is used
- Uses static analysis to check Go program types before execution while supporting practical development of large systems.
- How deep it goes
- Defines compile-time-oriented checking and contrasts runtime typing, but stops short of compiler internals or a detailed type-system formalization.
- Examples
- Illustrates explicit and inferred Go declarations alongside comparisons with Python, PHP, JavaScript, and TypeScript.
- What you can do after
- Evaluate/understand how Go checks types statically while retaining selected conversion and type-switching conveniences.
Read how Go in Practice, Second Edition explains static typing →
Learn Haskell by Example
Static typing is a language property in which types are determined or checked before program execution and do not change dynamically during runtime.
- How it is used
- Frames compile-time checking as a safety mechanism while structuring Haskell data and function definitions.
- How deep it goes
- Defines compile-time type checking, runtime type stability, inference, and explicit signatures without descending into compiler internals.
- Examples
- Uses Haskell signatures such as `name :: type`, inferred definitions in GHCi, and the expression `x * x`.
- What you can do after
- Evaluate/understand how compile-time checks and inferred or explicit types constrain Haskell definitions.
Pro Angular 16
Static typing is a language feature in which declared or inferred types are checked before program execution and incompatible assignments can produce compiler errors.
- How it is used
- Uses static typing to define Angular application data models and make JavaScript development more familiar to C# and Java developers.
- How deep it goes
- Explains the TypeScript-to-JavaScript compilation relationship and demonstrates typed model fields, but defers comprehensive language coverage.
- Examples
- Demonstrates typed TodoItem and TodoList classes with string, boolean, array, and readonly collection types.
- What you can do after
- Build it from scratch by defining simple TypeScript data models that compile into browser-executable JavaScript.
Related concepts
- TypeScriptused by · TypeScript is a statically typed superset of JavaScript that adds type-system features and is compiled to JavaScript.
- Kotlinincludes · Kotlin is a statically typed general-purpose programming language that targets the JVM and other platforms and interoperates with Java.
- Rustused by · Rust is a statically typed systems programming language designed for performance, concurrency, and memory safety without requiring garbage collection.
- Goincludes · Go is a statically typed, compiled, garbage-collected programming language with built-in support for concurrency.
- F#includes · F# is a statically typed, functional-first, multiparadigm programming language in the .NET ecosystem.
- dynamic typingcontrasts with · Dynamic typing is a typing discipline in which type information and checks are determined primarily at runtime rather than fixed statically for variables.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.