Program Execution & Runtime Concepts

← Back to Domain-Specific Families

Abstractions about how programs are translated, optimized, run, and fail, covering compilation and transformation (compilers, basic blocks, profile-guided optimization, rematerialization), runtime memory behavior (working set size, thrashing, register windows, runahead execution), execution-time defects and weaknesses (heisenbugs, buffer overflows, injection), and data protection like incremental backup.

27 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.

• Basic Block — A single-entry, straight-line run of compiler instructions whose represented control transfer occurs at its exit boundary.
• Binary-to-Text Encoding — A paired rule that writes bytes as text-compatible symbols and decodes conforming text to recover the represented byte content.
• Buffer Overflow — A memory-write failure in which data is written beyond the valid end of its intended buffer.
• Chain Loading — A running executable hands primary control to a separately loadable successor stage through a platform-defined loading interface.
• 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.
• Continuous Data Protection — Continuously retain data changes so an earlier state can be reconstructed within a bounded recovery window.
• Data Migration — Transfer a defined dataset to a target system and hand its authoritative use to that target under a suitable fidelity criterion.
• Elapsed-Time Memory Decay — A recurrent-model update that uses elapsed time to contract carried state or stale input toward a target before incorporating the next observation.
• Exception chaining — Exception chaining rethrows a caught exception inside a higher-level exception while preserving the original as its cause.
• 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.
• Incremental Backup — A recoverable backup point captures changed data since a prior protected state while retaining the bases and references needed to reconstruct the whole.
• 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.
• 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.
• 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.
• Iteratee — A resumable stream consumer that processes externally supplied input chunks and returns a result or a continuation requesting more input.
• Object graph — A point-in-time graph view whose nodes are runtime objects and whose directed edges are direct or chained object references.
• Oblivious RAM — Preserve logical memory reads and writes while making observed physical access traces indistinguishable for equally long request sequences.
• Profile-Guided Optimization — Use measured program behavior to choose later or adaptive transformations at the code sites that generated the profile.
• Program Profiling — Measuring a running program's resource use or execution events and attributing them to functions, source lines, or call paths under a specified workload.
• Program Transformation — Program transformation rewrites a program under an explicit relation between the old and new program's behavior.
• Register window — Call-indexed remapping of fixed architectural register names onto portions of a larger physical register file, often overlapping adjacent windows for argument handoff.
• Rematerialization — Recompute a needed intermediate at its later use instead of retaining or retrieving it, trading extra work for less storage or data movement.
• Reorder Buffer — A reorder buffer tracks out-of-order instruction results in program order so architectural effects retire from an eligible oldest prefix.
• Runahead Execution — Runahead execution checkpoints a stalled processor, pseudo-executes ahead for useful prefetches, then restores state and replays normally.
• 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.
• Thrashing — Repeatedly evict still-needed units from a fast memory tier, forcing costly refetches that displace useful computation.
• Working set size — Working-set size is the memory footprint of the input and intermediate data required to solve a particular problem instance.