Computer Science & Software

126 domain-specific abstractions whose origin domain is Computer Science & Software.

• Abstract Syntax Tree — Represent a program's grammatical structure as a recursive tree built from a parser, keeping the meaning-bearing constructs and discarding surface details — whitespace, comments, redundant brackets — so two sources that differ only in formatting yield the identical tree.
• 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.
• Atwood's Law — Jeff Atwood's observation that any application that can be written in JavaScript eventually will be — naming the dynamic by which a general-purpose default's accumulated ecosystem advantage colonises a specialist's niche once it crosses a threshold, regardless of the technical gap.
• Authentication Failure — The breakdown of a system's identity-verification, in which a claim is accepted when it should not be — because the procedure checked too little, the wrong evidence, or evidence an impostor could produce — yielding a session that inherits the real actor's privileges and corrupts every control conditioned on 'who is this?'
• Bell's Law of Computer Classes — The empirical generalization that roughly every decade a new, cheaper, smaller class of computer emerges on a new platform technology and displaces the prior class from volume dominance — a discrete threshold crossing derived from continuous Moore scaling.
• Big O Notation — Classify a function by its order of growth — discarding constant factors and small-input detail — so algorithms can be compared by how they scale rather than how fast they run on one machine.
• Bit Rot — The failure mode in which an untouched software artefact loses usefulness over time not because its bytes changed but because its environment moved — 'working' being a relation between a static artefact and a churning world that erodes without upkeep.
• Bloom Filter — A probabilistic data structure that answers set-membership from a compact bit array and k hash functions with a deliberate one-sided error — it may report false positives but never false negatives — so a negative answer is safe to act on.
• Bus Factor — The minimum number of team members whose sudden simultaneous loss would halt a project — a per-capability count of how many people could take a subsystem, credential, or relationship over tomorrow, exposing where tacit human knowledge is dangerously concentrated.
• Byzantine Generals Problem — Formalize distributed consensus under adversarial faults — collapse the unbounded space of misbehaviors into a fault budget f and a population n, then read whether all loyal participants can agree straight off the proven floor of 3f+1 (or 2f+1 with signatures).
• Callback Hell — The readability collapse that results when a sequential chain of asynchronous steps is written as nested continuation callbacks, so indentation depth grows with step count and the code's textual shape inverts the computation's temporal order.
• CAP Theorem — A distributed data store cannot guarantee consistency and availability at once during a network partition, and since real networks always partition, the architect must choose which to sacrifice when one strikes.
• CAP Theorem (and variants) — Characterize any replicated data store by its coordinates on a small set of axes — the forced C-versus-A choice under partition, PACELC's latency-versus-consistency choice at rest, plus granularity dials and the CRDT merge-algebra escape.
• Class Imbalance — Diagnose why a 99%-accurate classifier can be useless: when one class vastly outnumbers the class of interest, additive loss aggregation lets majority examples dominate the gradient, so the model learns to ignore the rare minority.
• Closure (programming) — The runtime value that packages a function's executable code with the bindings of its free variables captured at construction, so that when applied later its free variables resolve through that captured environment rather than the caller's — preserving lexical scope across the gap between where a function is made and where it runs.
• Code Smell — Treat an observable feature of code as defeasible evidence of a deeper design or maintainability problem—not proof of a defect—so inspection triggers a context test and a refactoring hypothesis.
• Cohesion (software / module-level) — Grade how tightly the responsibilities inside one code module turn around a single articulable purpose — from coincidental to functional — reading nameability, isolation-testability, and low-risk replaceability straight off the level.
• Comments as Deodorant — Read the need for an explanatory comment as a diagnostic signal, not a virtue — a clear paragraph explaining a confusing function masks a retirable design problem instead of fixing it, so do the rename or split that retires the comment rather than maintaining it.
• Compiler — Translate a fully specified source language ahead of time into a semantically equivalent target form through a pipeline of formal-interface phases, so the whole program can be globally analysed and optimised once while its observable behaviour is guaranteed preserved.
• 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.
• Confirmation Fatigue — The interaction-design failure where a blocking confirmation prompt fires so often, and so rarely marks a truly consequential choice, that users develop an automatic dismiss reflex that discharges the prompt without reading it — leaving it syntactically present but informationally inert.
• Cross-Site Scripting — Insert attacker-supplied bytes into a server's output so the victim's browser executes them under the trusted site's origin, arising when content is written into a sink without encoding for the context it lands in.
• Cryptographic Hash Function — Turn an arbitrarily large input into a short fixed-length digest that acts as a tamper-evident proxy for it, using three computational-hardness properties — preimage, second-preimage, and collision resistance — so anyone can verify content or bind a commitment but no one can forge or invert it.
• Data Class — Flag an object-oriented class that holds fields with getters and setters but no domain methods as a symptom that its behavior migrated outward into consumers, then resolve the verdict with one role question — should this class enforce its own invariants?
• Data Extraction Through Prompting — The AI-security failure mode in which an adversary crafts inputs that make a deployed language model emit private content — training text, system prompts, retrieved documents — by exploiting the legitimate inference interface, whose breadth exceeds the access-control envelope around the data.
• Data Poisoning Attack — The adversarial-ML failure mode where an attacker corrupts training inputs so the model learns an attacker-chosen behaviour — an upstream contamination that runtime defenses are structurally powerless against and that clean benchmark accuracy cannot detect.
• Dependency Hell — The pathological state where a project's transitive dependency closure holds mutually incompatible version constraints, turning installation into an NP-complete constraint-satisfaction problem that no edge-level patch can resolve.
• Digital signature — Bind a specific message to a specific private-key holder with a short string anyone can check against the public key, confining all remaining trust to one question — does this public key authentically belong to its claimed principal?
• Discoverability Failure — Diagnose why a working feature goes unused: the capability exists and functions perfectly, but no signal on any surface the user samples announces it, so the user's option set is bounded by the visible interface and the feature is operationally nonexistent.
• DLL Hell — The failure mode where programs share dynamic libraries through one global single-version-wins namespace, so an unrelated install overwrites a version another program depends on and silently breaks it — cured by breaking the single-version-wins invariant.
• ELIZA Effect — The tendency of users to attribute understanding, intention, and inner states to a system that produces only fluent, context-appropriate conversational output — a cheap default Theory-of-Mind inference that fires once output crosses a coherence threshold and persists even when the mechanism is known.
• Empty-State Failure — The interface condition in which a view has no content and provides no scaffolding for the absence — no explanation of the cause, no disambiguation among the possible causes (new, filtered, permission, loading, error), and no next action — so the user, left to infer meaning from nothing, typically concludes wrongly that the system is broken or gated.
• Encryption — Transform a plaintext under a key into a ciphertext from which the message cannot be feasibly recovered without the decryption key — a computational asymmetry gated by a secret, so confidentiality depends only on who holds the key rather than on the channel.
• End-to-End Principle — The architectural rule that a function whose correctness criterion can only be discharged with knowledge at the communication endpoints should live at the endpoints, not the intermediate nodes — so any in-network implementation is at best a performance optimization the endpoints must still back up.
• Error-Message Opacity — Diagnose the post-failure interface defect where a system correctly detects and announces a fault but the message omits the repair-supporting content — cause, context, next action, escalation — so the user is told they are stuck without being told how to get unstuck.
• 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.
• Excessive Data Exposure — An API endpoint returns more fields than the caller's role requires, trusting a client-side filter to hide the surplus — but the unfiltered payload is already on the wire, so the surplus must be stripped at the producer via role-scoped projection.
• Fallacy of Homogeneous Networks — The implicit assumption that all nodes, links, OSes, versions, and configs across a distributed deployment are uniform — a missing degree of freedom in the system's model of its substrate that stays latent until deployment crosses a boundary where the uniformity breaks.
• Fallacy of Infinite Bandwidth — Catch the distributed-systems assumption that the network carries whatever data an application generates for free, by reclassifying bandwidth as a finite, shared, budgetable resource and tracking bytes per operation against the capacity of the path.
• Fallacy of One Administrator — Reason about a deployed system as though one authority governs every node it depends on, when it actually crosses many independently-governed administrative domains — so failures concentrate at the unmodeled seams between them.
• Fallacy of Stable Topology — The design-time assumption that a distributed system's addressing and routing graph stays fixed over an interaction's lifetime — dropping the time argument from G(t) — so every cached reference becomes a latent bet that its referent has not moved.
• Fallacy of the Reliable Network — The design-time error of programming a best-effort channel whose packet-loss probability is positive as if it were zero — assuming every message is delivered, ordered, and never dropped, reordered, or duplicated.
• Fallacy of the Secure Network — The mistake of deriving trust in a distributed system from network position — inside the VPN, behind the firewall — rather than from cryptographic verification, treating a known routing path as if it were a verified identity.
• Fallacy of Zero Latency — The design-time assumption that a remote call returns as fast as a local one, dropping the per-hop round-trip term L from the cost function, so that an operation making n network calls is budgeted as free when it actually costs at least n·L and compounds under sequential fan-out.
• Fallacy of Zero Transport Cost — Reject the design-time assumption that moving data between nodes is free by restoring the per-byte cost term to the cost function, so payload volume becomes an explicit design variable budgeted alongside latency.
• Feature Creep — Explain why a product accretes capabilities past net benefit as a governance failure, not a quality one — an approval gate that judges each addition in isolation against its stated cost while structurally blind to the compounding global cost of all additions together.
• 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.
• FLP Impossibility — Prove that no deterministic algorithm can guarantee both agreement and termination for consensus in an asynchronous system with even one crash-fault — by showing an adversarial message schedule can keep the system perpetually undecided.
• Formal Verification — Establish with the rigor of a theorem that an engineered artifact satisfies a precisely stated specification by producing a machine-checkable proof that holds over every input in scope at once, rather than sampling behavior on tested inputs the way testing does.
• God Object Anti-Pattern — Diagnose a maintenance mess as concentrated rather than diffuse: one class or service accumulates outlier fan-in and fan-out to become the integration hub, collapsing modularity so all change-cost, comprehension, and new features funnel through that single node.
• Golden Hammer Anti-Pattern — Diagnose a team applying its familiar technology to a poorly-fitting problem because the acquisition cost of an alternative is visible while the misfit cost is diffuse and downstream, so fluency reshapes what counts as the right tool before fit is ever asked.
• Graph Data Type — The programmatic abstraction representing entities as nodes and relationships as edges behind a traversal/mutation/query interface — insulating algorithm code from the in-memory layout so representation becomes a profiling-driven swap, not a rewrite.
• Graph Database — A persistent store whose native model is nodes and edges with index-free adjacency — so following a relationship is a pointer dereference, not a join, and k-hop traversal cost tracks edges touched rather than total dataset size.
• Greenspun's Tenth Rule — The aphorism that any sufficiently complicated C or Fortran program contains an ad hoc, bug-ridden implementation of half of Common Lisp — because features a language withholds do not vanish but migrate inside the program as defective re-implementations.
• Halting Problem — Turing's proof that no general algorithm can decide, for every program-input pair, whether the program halts or loops forever — established by a diagonal argument that builds an adversary doing the opposite of any claimed decider's prediction about itself.
• 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.
• Heap — Keep the single most extreme element instantly readable at the root of a partially ordered tree, so insert and extract cost only O(log n) under continuous churn by declining to maintain any more order than the extreme requires.
• Heisenbug — Name the software defect whose failure vanishes under observation because attaching a debugger, adding a print, or disabling optimization perturbs the timing window or interleaving it rides on — so disappearance-under-observation is the diagnostic tell, not evidence the bug is gone.
• Hyrum's Law — With enough users of an interface, every observable behaviour will come to be depended upon by someone regardless of the formal contract, so the cost of changing an observable is set by its dependent count, not its documented status.
• Idempotent Consumer Pattern — Build a message consumer so that processing the same message any number of times has the same effect as processing it once, by remembering each message's ID in a dedup store and committing the business effect inside the same atomic boundary.
• Information-Scent Failure — Diagnose a navigation failure as the surface cues a user reads before clicking — link text, labels, snippets — failing to predict the destination's content, so the user invests a click on a wrong prediction and backtracks, hunts, or abandons.
• Injection Weakness — The software-security failure in which untrusted data crosses into a control channel and a downstream interpreter executes it as command, query, or instruction — a collapse of the data/control boundary that a legitimate, often credential-free, input channel is enough to exploit.
• Inner-Platform Effect — A system built on top of another tends to re-implement the host's facilities inside itself, badly, because the embedded sub-system's customisation surface is narrower than the host's while the requirements arriving at it are not bounded by that narrowness.
• 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.
• Insecure Deserialization — Recognize the weakness where a runtime reconstitutes an untrusted serialised byte stream into behaviour-bearing objects because the parser's own semantics execute code during the parse — safe only if the parser's power sits strictly below the runtime it feeds.
• 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.
• Interface segregation principle — The SOLID rule that clients should not depend on interface methods they do not use — decompose a fat interface into role-specific ones sized to each consumer's usage footprint, so a contract change's blast radius is read off the boundary rather than the call graph.
• Interpreter — Execute a program directly from its source or intermediate form by looping fetch-decode-act over one unit at a time against maintained runtime state, producing no standalone binary — so the engine must be present at every run and pays a per-instruction dispatch cost.
• Jailbreak Adaptation — The dynamic in which a distributed community collectively probes a deployed AI system's policy boundary, turns each bypass into a shared public good, and so out-iterates the deployer's update cycle — making the contest a rate race no single patch can win.
• 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.
• Keyboard Trap — The accessibility failure where a keyboard-only user moves focus into a UI element that receives focus but never yields it — an absorbing state in the focus-navigation graph, invisible to mouse users because a click supplies the exit edge they lack.
• Lava Flow (Anti-Pattern) — Explain why obsolete or unused code hardens into a codebase when uncertain dependencies and inadequate verification make deletion seem riskier than indefinite retention.
• 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.
• Mandelbug — Reclassify a chaotic, irreproducible software defect as deterministic-but-undersampled — triggered by a rare joint configuration of hidden state — so effort shifts from finding the right breakpoint to sampling that joint state until the configuration is caught.
• 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.
• Mass Assignment — The web-application vulnerability in which a request-binding layer writes all client-supplied fields directly to a domain object with no allow-list, letting a caller set server-managed attributes like role or owner_id simply by naming them.
• Membership Inference Attack — Determine whether a specific record was in a model's training set by reading the systematic behavioural gap — lower loss, higher confidence — between the samples it saw and statistically matched samples it did not.
• Memory Management — The policy and machinery by which a running program acquires regions of a finite address space at the point of use and safely releases them once no longer reachable or owned — bridging the gap between logic-driven allocation and reachability-driven reclamation against a memory budget.
• Merge Conflict — Halt an automatic merge and hand the decision to a human exactly where two branches diverged from their common ancestor on the same region, because a three-way merge over text can rank a one-sided edit but has no syntactic basis to choose between two competing edits whose correctness lives in intent it cannot see.
• Model Checking — Verify a system by taking a finite-state model plus a temporal-logic property and exhaustively exploring every reachable state to decide whether the property holds universally, returning a concrete counterexample trace on failure.
• Model Inversion Attack — Recover the content of individual training records by treating a deployed model as a constrained inverse oracle — combining predictions-as-evidence with a prior over the input space to solve for the generating input, so 'the model is not the data' becomes a quantitative claim.
• Model Skewing — The adversarial AI-security attack in which a stream of individually-unflaggable, region-biased inputs to an online learning loop gradually pulls a model's decision boundary off the deployer's criterion toward one the attacker prefers — capturing a deployment that launched clean.
• 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.
• Ninety-Ninety Rule — The first 90 percent of the code takes the first 90 percent of the time and the last 10 percent takes the other 90 percent — a deadpan warning that nominal-progress metrics measure only the estimable bulk-work population and never the non-parallelizable, heavy-tailed completion tail.
• No Silver Bullet — Brooks's thesis that no single innovation will yield an order-of-magnitude gain in software productivity within a decade, because past gains already mined the accidental complexity (tool-and-environment friction) and the binding constraint is now essential complexity — difficulty inherent in the problem that no tool can dissolve.
• Null dereference — The failure where code operates on a reference under the unstated assumption that the object exists, while the reference is in fact absent — so the defect is the missing existence-precondition check, not the absence itself.
• P versus NP Problem — Ask whether every problem whose solutions can be verified in polynomial time can also be solved in polynomial time — turning the apparent gap between checking and finding into the open question of whether it is a structural barrier (P ≠ NP) or mere ignorance (P = NP).
• PACELC Theorem — Classify a replicated data system by two regime-dependent trade-offs — availability vs. consistency under Partition, and Else (normal operation) latency vs. consistency — into a four-letter posture from which its workload behaviour reads directly.
• Pointer — A small, fixed-size value that stores the memory address of another object, providing indirect access through three operations — take-address, dereference, and reassign — so linked structures can span non-contiguous storage and mutate in place by rewiring rather than copying.
• Primitive Obsession — The code smell of representing domain concepts that carry structural commitments — units, valid ranges, well-formedness, identity — as bare primitives like int or string, so the type system cannot enforce the distinctions and they survive only as validation duplicated at every callsite.
• Program Realization Strategy — Assign how a formal program is turned into running behavior — by ahead-of-time translation to an independent artifact, direct execution by an always-present engine, or an adaptive mixture — and thereby fix when semantic work and its costs are paid.
• Prompt Injection — Untrusted content delivered to a language model through a data channel is interpreted as instructions rather than material to process, so an embedded directive executes at the model's privilege — the failure being the absence of any in-band boundary between instructions and data, not a lapse in alignment.
• Property-Based Testing — State an invariant that must hold for all inputs of a class and let a framework generate many samples, check each, and shrink any failure to a minimal counter-example — replacing hand-picked examples with systematic search over an input space.
• Public-Key Cryptography — Give each party a mathematically linked public/private key pair where an operation done with one key is invertible only with the other and the private key cannot feasibly be computed from the public one, so confidentiality and verifiable authorship need no pre-shared secret.
• Query Optimization — Let the author state only what result a declarative query should return, then have a separate optimiser search the space of algebraically equivalent execution plans and emit the cheapest one under a cost model.
• Rate-Limit Absence — Diagnose a whole family of endpoint abuses as one defect — a callable action left uncapped whose per-invocation cost to the service far exceeds the attacker's, so no enforced per-source budget separates legitimate demand from adversarial demand driven at machine speed.
• Refused Bequest — Flag an inheritance edge as broken when a subclass accepts a parent's implementation but refuses part of its contract — stubbing, throwing, or silently mishandling inherited members — because that refusal is exactly the Liskov substitutability violation the is-a declaration promised not to make.
• Relational Model — Organize data as typed sets of tuples queried by a small closed algebra of relation-to-relation operators, so any composition is itself a valid query, rewrites preserve meaning, and the logical schema is separated from physical storage.
• Request-Response — Treat any bounded network exchange as one shape — an initiator's addressed request causally paired to one responder's reply over a return path — so the same fixed checklist of addressing, correlation, retry, idempotency, and error handling applies regardless of payload.
• Requirements Volatility — Treat frequent, substantive change in a system's requirements as a measurable churn rate matched against the team's absorption capacity, then flatten Boehm's cost-of-change curve so late changes force only local rework rather than cascading redesign.
• Review — A structured evaluative artifact linking four slots — an identified evaluator, a bounded object under evaluation, a verdict, and a warrant — into a persisted, addressable record, so evaluative testimony becomes aggregable, citable, and revisable.
• Rice's Theorem — Every non-trivial semantic property of programs — anything depending on the input-output function rather than the source text — is undecidable, proved by a generic reduction from the halting problem, so no exact analyzer for such a property can exist.
• Saga Pattern — Achieve all-or-nothing semantics across a multi-step operation that no single ACID transaction can span by pairing each local transaction with a forward compensating action, so a failure at step k runs compensations k-1 down to 1 and leaves the system as-if-nothing-happened.
• Search Algorithm — Solve a problem by casting it as a state space explored with a frontier-ordering strategy, so completeness, optimality, and cost are read off the strategy's name — and an admissible heuristic buys a narrower search without sacrificing the optimal answer.
• Secret Sprawl — Diagnose a credential's danger not by whether its primary store is locked but by whether its copies have spread into more places than the issuer tracks, so revocability collapses and rotation cost scales with the unknown copy count.
• Server-Side Request Forgery — Diagnose the web attack in which an attacker-supplied URL makes a server issue a request under its own credentials and network position, by asking whether the issuer of the intent and the carrier of the authority are the same principal.
• Single-Responsibility Principle — A module should have exactly one reason to change — read as one external change-driver, not one function — so that aligning each boundary with a single driver keeps every edit's blast radius contained.
• Software Entropy — Read a codebase's growing structural disorder as a predictable gradient under continuous modification: locally expedient edits flow toward the vast basin of working-but-disordered states, and order decays monotonically unless restoring engineering effort is continuously reinjected.
• Sorting Algorithm — A computational procedure that rearranges a finite sequence into a specified total order, located in a coordinate space of complexity, stability, and memory, and bounded below by the Ω(n log n) decision-tree floor for comparison-based sorts.
• Spaghetti Code — Diagnose a codebase as unmaintainable by reading its dependency graph: when boundary-violating edges accumulate past a threshold, the cost of any local change scales with the whole system rather than the unit being changed.
• Speculative Generality — Diagnose a design that carries flexibility for imagined future variation not yet justifying its cost by pricing each abstraction as an unexercised option — with no named consumer, credible timeline, or second concrete instance, it is overhead masquerading as foresight.
• Split-Brain Problem — The distributed-systems failure where a network partition splits a replicated cluster into subsets that each elect themselves as write authority and accept divergent writes; guard against it by enforcing that at most one subset — the quorum majority — may write.
• Strangler Fig Pattern — Replace a legacy system incrementally in place by fronting it with a stable interception layer, rerouting one validated request path at a time to the replacement, and retiring the legacy once nothing routes to it.
• Stream Processing — Compute over data as it arrives — one record or small time-window at a time — under a bounded-latency commitment, decoupling when an event happened from when it arrived and using a watermark to decide when a time window is safe to close and emit.
• Strong Consistency — Guarantee that every read of a replicated store reflects the most recently completed write and all clients see one real-time-consistent total order (linearizability), so the system can be reasoned about as a single copy — bought with a coordination round and partition-time unavailability.
• Temporary Field — The code smell in which an object carries an instance variable meaningful only during one operation or state yet visible as permanent structural state everywhere — a mismatch between the field's structural scope (every instance) and its validity scope (the subset where it holds a real value).
• Topological Sorting — Produce a linear order over the nodes of a directed acyclic graph so every edge runs forward — every dependency before its dependent — by repeatedly emitting any node with no unmet prerequisite, well-defined exactly when the graph has no cycle.
• Transfer-Learning Attack — Vulnerabilities, backdoors, or poisoned representations baked into an upstream pretrained model ride intact into every downstream system built on it, because the downstream team's audit boundary encloses only its new layers while the attack surface spans the whole inherited substrate.
• Tree (Data Structure) — The computer-science container for rooted, single-parent, acyclic hierarchies whose recursive type lets every algorithm decompose as act-at-the-root, recurse-on-each-subtree, combine — with operation cost governed by one quantity, the tree's height.
• Trie — A tree of symbol-labelled edges storing a set of strings so that every root-to-node path spells a prefix and strings sharing a prefix share a path, answering prefix queries in time proportional to the query length alone, independent of how many strings are stored.
• Turing Machine — The canonical formal model of computation — finite control plus an unbounded read-write tape governed by a finite transition function — whose one unbounded resource is the tape, and against which computability and complexity are given exact, provable meaning.
• Two Generals' Problem — Prove that no finite exchange of messages can make two parties certain they agree when any single message might be lost, because the last message in any protocol is itself unacknowledged.
• Type Inference — Algorithmically reconstruct the types of expressions from their usage context rather than from annotations, by generating an equality constraint at each syntactic form and solving them by unification to return either each expression's principal (most general) type or a genuine type error.
• Type System — A discipline that assigns every value and expression a type and uses that classification to constrain which operations may legally apply, verifying via compositional typing rules that well-typed programs cannot reach a wrong-kinded state (soundness).
• Version control — Track every change to a corpus of diff-amenable artefacts as atomic, authored, parent-pointed commits forming an append-only DAG, making history a first-class object over which branching, merging, reverting, blame, and bisect become routine graph queries.