Adversarial Exploits & Structural Boundaries

Abstractions spanning computing's boundaries and their failures — adversarial exploitation of trust and decision boundaries (supply-chain attacks, evasion, model theft), foundational fixed-capacity structures (hash tables, integer overflow, complexity classes), and code smells where responsibility sits at the wrong address (feature envy, lazy class, long parameter lists).

12 abstractions in this family — domain-specific abstractions that sit near one another in structural-signature space (k-means over structural-signature embeddings). Each is shown with its short description.

• AI Supply-Chain Attack — The compromise of an upstream AI-pipeline component — training data, weights, packages, eval sets — by an adversary who exploits the deployer's trust in the producer's channel rather than breaching the perimeter, so the poisoned artefact is imported voluntarily.
• Complexity Class — Sort computational problems into a small lattice of named strata — P, NP, PSPACE, and their kin — by the resource bound they admit under a fixed model, so that placing a problem by one reduction transitively imports its whole feasibility profile.
• Evasion Attack — Craft inputs that fall on the benign side of a deployed classifier's learned decision boundary while preserving their malicious payload — exploiting the gap between the boundary and the true concept it was meant to represent, so near-perfect test accuracy coexists with near-zero robustness under attack.
• Feature Envy — Flag a method whose cross-class field and method accesses to another class outnumber accesses to its own, signalling that the behavior lives at the wrong address and should be relocated to the class whose data it operates on.
• Hash Table — Store key-value pairs in a fixed-capacity array by computing each key's index with a hash function, so the address is derived from the content and lookup, insertion, and deletion run in expected-amortised O(1) independent of collection size.
• Input Manipulation Attack — Recognize an adversary crafting inputs to a fixed decision system so it produces a preferred output, by taking as the unit of analysis the gap between the input manifold the system was specified against and the manifold the attacker can construct.
• Integer Overflow — The failure mode where an arithmetic result exceeds a fixed-width integer field's range and the runtime silently writes back a wrapped value with no trap or flag — so downstream code trusts a number that is no longer what the computation demanded.
• Kerckhoffs's principle — Design a cryptosystem to stay secure even when the entire algorithm is public, confining secrecy to the key alone — because a leaked key is cheaply rotated while a leaked algorithm cannot be replaced without rebuilding the whole system.
• Lazy Class — The code smell in which a class (or function, module, package) carries too little responsibility to justify the overhead it imposes — the defect living in the economy, not the behaviour, so a correct, clearly-named boundary can still be flagged when its carried value fails to clear its enumerable tax.
• Long Parameter List — The code smell in which a function requires many separately-supplied inputs at its call boundary because internal complexity was offloaded onto callers — the defect being not the count but hidden co-variation structure that belongs inside the interface.
• MapReduce — A distributed-computation model that processes oversized datasets in two stages — a stateless map over each record and a key-scoped associative reduce — so that once the programmer honours that contract, the runtime handles parallelism, fault tolerance, and locality, with the shuffle as the single cost-governing synchronization point.
• Model Theft — Clone a deployed model's valuable function from its outputs alone by treating it as a high-bandwidth oracle — querying it, harvesting (input, prediction) pairs, and fitting a substitute — so the IP boundary becomes a price set by extraction cost, not a wall.