Explain linear types, affine types; and the etymology of these words

What if you could not copy a piece of data, and what if deleting it were a computer science sin? In standard programming, information is treated like mathematical platonic ideals—infinitely replicable and effortlessly discarded. Substructural type systems, however, treat data like physical matter: tangible, scarce, and bound by conservation laws. ## The Physics of Code: Linear vs. Affine In programming language theory, substructural type systems restrict the structural rules of weakening and contraction. To understand these restrictions, we turn to the foundational work of Jean-Yves Girard on [Linear Logic](https://en.wikipedia.org/wiki/Linear_logic). A **linear type** guarantees that a variable is used *exactly once*. It can neither be duplicated (no contraction) nor implicitly ignored (no weakening). If you instantiate a linear object, such as a file handle or a cryptographic key, you must explicitly thread it through your computations and ultimately consume it. An **affine type** relaxes this constraint slightly, requiring that a variable is used *at most once*. This allows for weakening but forbids contraction. You can safely discard an affine resource without using it, but you still cannot duplicate it. This is the mechanism powering the ownership model in the [Rust programming language](https://www.rust-lang.org/), where the compiler prevents data races by ensuring unique ownership of heap-allocated memory. As Philip Wadler famously observed in his seminal paper, [A taste of linear logic](https://doi.org/10.1007/3-540-52592-0_60): > "An object of linear type can be thought of as a physical object... a file can be opened, read, and closed; but it cannot be duplicated." ## The Etymology of Scarcity The terms *linear* and *affine* are borrowed directly from linear algebra, representing a beautiful conceptual bridge between geometry and logic. * **Linear**: Originating from the Latin *linearis* ("belonging to a line"), a linear transformation in mathematics preserves the origin ($f(0) = 0$). In the context of logic and types, it reflects a strict one-to-one mapping where every input corresponds exactly to an output. No resources are created from nothing, and none vanish into the void. * **Affine**: Originating from the Latin *affinis* ("bordering on" or "connected with"). In geometry, an affine transformation is a linear transformation followed by a translation ($f(x) = Ax + b$). It does not necessarily map the origin to itself. In type systems, this "offset" translates to the freedom to discard: you have the strictness of linearity, plus an extra dimension of freedom (the ability to allocate a resource but choose to "translate" it into nothingness by dropping it). By imposing these physical constraints on virtual spaces, computer scientists can guarantee memory safety and protocol compliance at compile time without the overhead of a garbage collector. ## Follow-up questions 1. How do structural rules in Gentzen's sequent calculus map directly to the behavior of linear and affine types in programming? 2. What are the specific theoretical trade-offs between Rust's affine type system and a strict linear type system when designing an operating system kernel? 3. How does session type theory utilize linear types to guarantee deadlock-free communication protocols?