Computer Science

← Back to Domain-Specific Abstractions by Domain

28 domain-specific abstractions whose origin domain is Computer Science.

• Command–query separation — A design principle requiring each method either to change state as a command or return information as a side-effect-free query, but not both.
• Computation Tree Logic — A branching-time temporal logic whose formulas pair universal or existential path quantification with next, eventually, always, or until modalities over Kripke structures.
• Context model — A formal or semi-formal structure for representing, maintaining, and exposing environmental context to a context-aware system.
• DATR — A declarative node–path–value equation language for compact lexical knowledge bases with default inheritance, override, path extension, and query evaluation.
• Distributed lock manager — Coordinate named lock ownership and compatible access modes across cluster nodes so shared resources retain mutual-exclusion and recovery guarantees despite concurrency and membership change.
• Dry Run (Testing) — Traverse an intended command, procedure, or system execution while suppressing or substituting consequential effects, exposing planned actions and precondition failures before committing a live run.
• False sharing — Diagnose performance loss when independent data accessed by different processors occupy one coherence block, so writes trigger invalidation, transfer, and reload traffic as though the data were logically shared.
• Formal Language — Treat a precisely delimited set of finite strings over an alphabet as an object independent of any one grammar, recognizer, or interpretation.
• Formula Calculator — Capture a complete mathematical expression as an editable representation, then parse and evaluate it under declared grammar, precedence, associativity, arity, and numeric-context rules when the user commits the calculation.
• Fuzzy rule — Represent a graded IF-THEN relation whose linguistic antecedents and consequent are fuzzy sets, then compute a consequent degree or fuzzy output through declared connective, implication, aggregation, and output conventions.
• HBJ model — Estimate a message-passing parallel algorithm's cost by separating maximum per-processor computation from latency-and-bandwidth communication over regular block permutations.
• Hoare Logic — A compositional program logic that proves precondition–command–postcondition judgments by rules aligned with program constructs, using assertions and invariants to reduce global correctness to local proof obligations.
• Homomorphic Secret Sharing — A secret-sharing primitive in which servers locally evaluate an allowed function on input shares so their output shares reconstruct the function value without revealing the inputs.
• Luby transform code — A rateless fountain-code construction using sparse random bipartite combinations and XOR operations to recover source symbols from slightly more encoded symbols than the source count.
• Measure (Data Warehouse) — A fact-level or calculated quantity in a dimensional model whose value is summarized within dimension contexts under declared grain, unit, and aggregation semantics.
• Object graph — A point-in-time graph view whose nodes are runtime objects and whose directed edges are direct or chained object references.
• Pattern Language (Formal Languages) — The formal language generated from one constants-and-variables pattern by consistently replacing each variable with a nonempty terminal string while preserving every constant.
• Plaintext — Identify data in the input-to-encryption or output-from-decryption role at a declared cryptographic layer, regardless of human readability, while separating that relative role from cleartext exposure and message encoding.
• Processor Sharing — An ideal preemptive service discipline that divides a server's instantaneous capacity among all jobs currently present, usually equally or by fixed weights.
• Prototype-based programming — An object-oriented programming paradigm in which objects inherit behavior directly from reusable prototype objects rather than from classes.
• Reinforcement learning — Learn a policy for sequential action from evaluative reward generated through agent–environment interaction, balancing exploration, delayed credit, and long-run return.
• Signedness — A programming-language type property that determines whether an integer representation and its operations include negative values or instead use a nonnegative modular range, affecting conversions, comparison, overflow, and interfaces.
• Specification language — A formal language used to state what a system must do at a higher level than executable implementation code.
• SPQR Tree — A canonical tree representation of a biconnected graph's decomposition at separation pairs, whose S, P, Q, and R skeletons expose series, parallel, edge, and rigid triconnected structure and reconstruct the graph through paired virtual edges.
• Temporal logic of actions — Specify state-machine behaviors with predicates over states, actions over current and next states, temporal operators, and explicit stuttering invariance for concurrent-system reasoning.
• Tree Sort — A comparison-sorting method that inserts items into a search tree and emits them by in-order traversal, making output order depend on the tree invariant and runtime depend on tree height.
• Variable-Length Encoding — Assign source symbols codewords of unequal lengths under an explicit decodability rule, trading average length against parsing complexity, error propagation, synchronization, and source-model mismatch.
• Virtual Desktop — Expand a graphical workspace beyond one physical screen by retaining windows in multiple switchable contexts or in a larger logical surface and exposing only the selected viewport at a time.