1 Introduction to Typing
This chapter motivates and frames type systems as the layer that gives meaning to raw bits and prevents entire classes of errors before software runs. It defines types as classifications that constrain allowable values and operations, and a type system as the rules that assign, check, and enforce those types—at compile time or at run time. The discussion ties correct typing to real-world reliability and security, highlights the proofs-as-programs insight (types as propositions, programs as proofs), and situates TypeScript within a broader trend: increasingly powerful static type systems and stronger guarantees across mainstream languages.
The core benefits of typing are shown through practical examples. Correctness improves by turning potential run-time failures into compile-time errors and by shrinking the program’s state space so “bad states” become unrepresentable—an effect that also hardens security. Immutability preserves earlier checks and eliminates data races; encapsulation (e.g., private members) protects invariants behind clear interfaces; composability emerges from generic, reusable building blocks (like a parameterized “first” function instead of many ad hoc variants); and readability increases when type signatures communicate intent and constraints, with type inference reducing boilerplate without sacrificing static guarantees.
The chapter contrasts dynamic versus static typing and weak versus strong typing, showing how deferring checks to run time or allowing implicit conversions undermines guarantees, while static, strong typing surfaces errors early and avoids surprising coercions. It explains where inference fits—types are still checked statically even when not written explicitly. Aimed at practicing programmers (with TypeScript examples but language-agnostic lessons), the book promises a practical, low-math tour: starting from primitive types, then composition, function types, and subtyping, advancing to generics for abstraction and reuse, and culminating in higher-kinded types—equipping readers to design safer, more modular, and more understandable systems.
A sequence of bits can be interpreted in multiple ways
The sequence of bits typed as a signed 16-bit integer. The type information (16-bit signed integer) tells the compiler and/or runtime that the sequence of bits represents an integer value between -32768 and 32767, ensuring the correct interpretation as -15709.
Source code is transformed by a compiler or interpreter into code which can be executed by a runtime. The runtime is either a physical computer or a virtual machine, like Java’s JVM, or a browser’s JavaScript engine.
declaring a type correctly we can disallow invalid values: the first type is too loose and allows for values we don’t want (😈, 💀). The second, more restrictive type, won’t compile if the code tries to assign an unwanted value to a variable.
Summary
- A type is a classification of data that defines the operations that can be done on that data, the meaning of the data, and the set of allowed values
- A type system is a set of rules which assign and enforce types to elements of a programming language.
- Types restrict the range of values a variable can take, so in some cases what would’ve been a run-time error becomes a compile-time error
- Immutability is a property of the data enabled by typing, which ensures values don’t change when they’re not supposed to
- Visibility is another type-level property which determines what components are allowed to access what data
- Generic programming enables powerful decoupling and code reuse
- Type notations make the code easier to understand for readers of the code
- Dynamic typing or “duck typing” determines types at run-time
- Static typing checks types at compile time, catching type errors which otherwise would’ve become run-time errors
- The strength of a type system is a measure how many implicit conversions between types are allowed
- Modern type checkers have powerful type inference algorithms which enables them to determine what are the types of variables, functions and so on without you having to explicitly write them out
In the next chapter we will look at primitive types, which are the building blocks of the type system. We’ll learn how to avoid some common mistakes that arise when using these types and see how we can build pretty much any data structure from arrays and references.
Programming with Types ebook for free
