Concepts
5,907Terms and methods explained by more than one lecturer. Each opens at the minute it is taught.
Systems & CS
261- Moore's lawThe observation that the number of transistors that can fit on a chip doubles approximately every two years.
- AbstractionThe concept of hiding internal implementation details and exposing only an interface to the user.
- Garbage collectionAn automated memory management system that reclaims memory occupied by objects no longer in use by the program.
- MemoizationAn optimization technique used to speed up computer programs by storing the results of expensive function calls and returning the cached result when the same inputs occur again.
- DeadlockA situation where two or more threads are unable to proceed because each is waiting for the other to release a resource.
- GroupA set along with a binary operation that satisfies closure, associativity, the existence of an identity element, and the existence of an inverse for every element.
- Virtual memoryA mechanism that maps virtual addresses to physical addresses to provide isolation and memory management.
- ConcurrencyThe ability to run multiple tasks by interleaving execution on a single core or multiple cores, giving the illusion of simultaneous execution.
- Hash functionA function that maps any object (or hashable object) to an integer.
- ModuleA WebAssembly package containing procedural game or server logic that can be dynamically updated at runtime.
- ParallelismParallelism describes true simultaneous execution of multiple tasks on multiple cores
- Race conditionA bug caused when multiple threads access shared data concurrently and at least one access is a write, leading to unpredictable results.
- Amdahl's lawA formula giving the theoretical maximum speedup in latency of the execution of a task at fixed workload that can be expected of a system whose resources are improved.
- Page faultAn exception that occurs when a program accesses a virtual memory page that is not currently mapped to physical memory.
- Big O notationA mathematical notation used to describe an upper bound on the growth of a function.
- Formal verificationThe use of tools to check mathematical proofs.
- LatencyThe time delay between a request for data and the response.
- ThreadExecution units scheduled by the operating system, allowing multiple execution paths in a process.
- VectorizationThe process of converting scalar operations into SIMD (Single Instruction, Multiple Data) operations to improve performance.
- Pattern matchingA method of processing text by providing a template or pattern and letting the system figure out how to match text against it.
- Artificial neural networksA machine learning approach using networks of neuron-like units to process information modeled on brain topology.
- CompactionThe process of compressing a large log of operations into a smaller, more efficient snapshot.
- Compare-and-swapAn atomic hardware instruction that compares the contents of a memory location with a given value and, only if they are the same, modifies the memory location to a new given value.
- ConcatenationString concatenation uses the plus operator to combine the individual characters of two strings into one new string object.
- ConsistencyThe property where if each transaction is consistent and the database starts consistent, then it ends up consistent.
- ContextA mapping of virtual to physical locations as dictated by the contents of the page map.
- KernelA special, always-running program that acts as the guardian of computer resources and manages hardware interfaces.
- LockA mechanism used in databases to protect database objects and contents across entire user transactions.
- MetaprogrammingA technique where programs have the ability to treat other programs as their data, allowing a program to read, generate, analyze or transform other programs.
- RefactoringRestructuring existing computer code without changing its external behavior to improve non-functional attributes.
- SemaphoreSemaphores are synchronization primitives that control access to shared resources between tasks by maintaining an internal counter.
- SIMDSingle Instruction, Multiple Data, a technique where a single CPU instruction performs the same operation on multiple data points simultaneously.
- TensorA multi-dimensional array of numerical values, generalizing vectors and matrices to higher dimensions.
- DecompositionThe process of breaking a problem down into smaller, self-contained, and manageable parts or modules.
- Run-length encodingA data compression technique where sequences of the same data value are stored as a single data value and count.
- SpeedupThe ratio of the time of the sequential program running on one processor divided by the time of the parallel program running on P processors.
- Address spaceThe entire set of unique locations in memory.
- CAP theoremA theorem stating that a distributed database can simultaneously provide at most two of three guarantees: Consistency, Availability, and Partition Tolerance.
- Concurrency controlMechanisms that manage concurrent access to database objects to ensure correctness.
- ConsensusAn algorithm where several nodes want to come to an agreement about a single value or proposal.
- Distributed systemsSystems composed of multiple autonomous computers that communicate over a network to coordinate and appear as a single coherent system.
- Error-correcting codesECC detects and corrects low-bit errors in stored data by using redundant information called parity.
- Eventual consistencyA consistency model in which a database guarantees that, if no new updates are made, all replicas will eventually converge to the same value.
- HypergraphA generalization of a graph where edges can connect any number of vertices, used to represent coupling among subsets of subsystems.
- ScalarizationAn optimization where the virtual machine eliminates heap allocation by breaking down value objects into their individual primitive components.
- Simulated annealingA probabilistic local search technique that allows moves to worse states with a probability that decreases over time, mimicking the physical annealing process to escape local optima.
- TruncationThe phenomenon in integer division where any fractional part after the decimal point is discarded because the operation only uses integer-based math.
- CertificateA digital document containing a web server's name, its public key, and a signature from a certificate authority.
- Divide and conquer matrix multiplicationA recursive algorithm for multiplying matrices by subdividing them into blocks and arranging their layouts consecutively in memory.
- Full adderA more complicated digital circuit abstraction built from two half-adders and an OR gate that takes two input numbers and a carry-in, producing a sum and a carry-out.
- InliningReplacing a function call with the actual body of the function to avoid function call overhead.
- MemoryRandom access memory consists of bytes on circuit boards, functioning as a canvas of addressable storage locations.
- Merkle treeA tree structure of cryptographic hashes used to create an unambiguous summary of a log's contents.
- ObservabilityThe practice of using metrics, JFR, and OpenTelemetry to catch runtime misbehaviors and performance regressions.
- ParameterA compile-time construct in Mojo similar to template arguments in C++, used to parameterize structs and functions.
- PatternA plan that shows parts, how they face each other, join, stand off, and work together to form a whole.
- PersistenceThe requirement that servers write critical state to disk or non-volatile storage so it survives reboots and power failures.
- Property-based testingA general testing technique that checks properties over randomized inputs to cover a wide range of values.
- Stream processingAn engineering approach to decompose systems by transforming entire streams or sequences of data rather than managing state changes instant by instant.
- ThroughputThe amount of data or number of queries a system can process in a given time.
- TransistorEssentially a switch just like a light switch, except it uses an electrical signal instead of a mechanical action to let electrical current flow or not.
- Critical sectionA piece of code that can only be executed by one thread at a time, providing mutual exclusion.
- Fault toleranceThe ability of a system to continue operating properly in the event of the failure of one or more of its components.
- TaskA sequence of one or more operator instances.
- Late materializationA strategy where only necessary join keys and record identifiers are passed between operators, fetching full attribute values only when required.
- Optimistic concurrency controlA concurrency control method that assumes conflicts are rare, allowing transactions to proceed in a private workspace and only checking for conflicts at commit time.
- Partial orderA way of ordering events in a distributed system where some events have a defined sequence, but others are concurrent and unordered.
- ReplicationMaintaining multiple copies of the same data on different nodes to increase performance and availability.
- Bloom filterA probabilistic data structure used to test whether an element is a member of a set, which may return false positives but never false negatives.
- Computer architectureTraditionally focused on the software-hardware interface and its implementation using microarchitecture.
- Cost modelAn internal cost representation used by the optimizer to estimate and compare the physical execution cost of different query plans given a database state.
- ExpressionAn operation in the query with zero or more input expressions that the optimizer evaluates for equivalence.
- File descriptorAn integer in user space that the kernel interprets using a process-specific file descriptor table to reference open files.
- Operator overloadingA feature of object-oriented programming where built-in operators like multiplication have customized behaviors when applied to user-defined types or objects like strings.
- Random access memoryThe physical memory hardware in a computer where data and program variables are stored.
- State machine replicationAn approach to replication where replicas use FIFO-total order broadcast to broadcast updates and apply them deterministically.
- Actor modelA conceptual model of concurrent computation where 'actors' are the universal primitives of concurrent computation that communicate via message passing
- AnnotationsMappings between instruction addresses and code ranges to add descriptive metadata to specific code instructions.
- Condition variableA condition variable allows threads to synchronize based on the actual value of data, waiting until a specific condition becomes true
- Conflict resolutionThe process of handling multiple conflicting updates to the same data item in a distributed system.
- Constant foldingAn optimization technique where constant expressions are evaluated and replaced with their hardcoded values at compile time.
- CoreThe processing unit inside a CPU that performs arithmetic, logic, and memory operations.
- Domain-specific languageA programming language specialized to a particular application domain.
- Early materializationCopy the values for the attributes in outer and inner tuples into a new output tuple immediately.
- End-to-end encryptionA secure communication method where only the communicating users can read the messages, ensuring that intermediate servers or third parties cannot access the plaintext.
- Event sourcingA pattern where changes to application state are stored as a sequence of events.
- Foreign function interfaceAn approach used in languages like Gleam to declare external functions and their types to call code written in another language safely.
- Half adderA digital circuit component used for adding two numbers together on inputs A and B, producing a sum and a carry.
- High bandwidth memoryMemory chips integrated on a GPU board to satisfy the massive data bandwidth requirements of highly parallel processing engines.
- Hyper-threadingA technology built into a CPU that makes a single physical core present itself as multiple logical cores to the operating system.
- InteroperabilityThe ability of different systems to communicate and use data throughout an organization.
- Io_uringAn asynchronous I/O interface for Linux that uses submission and completion queues to bypass system call overhead.
- JoinA SQL clause used to combine rows from two or more tables based on a related column between them.
- Materialized viewA database object that stores the result of a query, allowing for faster access than recomputing the query.
- Mechanical sympathyDesigning software with an understanding of how the underlying hardware works to achieve better performance.
- MicrocodeLow-level code that implements instructions and control logic inside a processor.
- PartitioningA method that specifies along each axis how you want your data to be partitioned into distinct sub-tensors.
- PhishingAn attack where a threat actor creates a realistic clone of a login interface to trick users into providing their credentials.
- Programming as theory buildingThe view that a program is the visible part of a theory held by its programmers, explaining why it is the way it is and how it can change.
- Remote procedure callA remote procedure call is when a function or method call made in a program is underneath translated into some kind of network communication to execute on another node.
- SelectivityThe fraction or probability that any tuple from an input will be emitted as part of the output for a given predicate or operation.
- Static analysisA way of analyzing the source code of your program before it even runs and looking for potential problems.
- Step functionA function that takes a process ID, local state, and event, and returns a new state and a set of messages to send.
- User-defined functionsUser-defined synchronous or asynchronous functions that operate on row-level data within the PixelTable runtime.
- Vibe codingA style of coding where you fully give in to the vibes, embrace exponentials, and forget that the code even exists.
- RowHammerA phenomenon where repeatedly activating and deactivating a DRAM row causes disturbance errors in adjacent or neighboring rows.
- OLAPA database system designed to process complex analytical queries on large volumes of data for decision-making.
- ShardingA technique for scaling a database by partitioning data across multiple servers, where each server holds a subset of the data.
- Two-phase commitA distributed algorithm that ensures all nodes in a distributed system either commit or abort a transaction.
- DynabookA conceptualized portable, interactive personal computer for children that functions like a book to support literacy and learning.
- RuleA transformation of an expression to a logically equivalent expression, divided into transformation rules and implementation rules.
- Top-down optimizationA query optimization strategy that starts with the desired result and works down the tree to find the optimal plan.
- BarrierA point in the program where every thread must arrive before any thread can continue.
- OLTPA database workload characterized by finding individual tuples using indexes and supporting frequent updates.
- Predicate pushdownMoving predicates down to the lowest possible point in the query plan, below join operators, to filter out data early.
- Query optimizerA component of a database system that transforms a logical query plan into a more efficient physical execution plan using rules or cost estimation.
- Same-origin policyA security policy that restricts how a document or script loaded from one origin can interact with a resource from another origin.
- SerializabilityA property of a transaction system where the outcome of concurrent transactions is equivalent to some serial execution of those transactions.
- SynchronizationSynchronization defines an order constraint between threads so that you can say this thing happens before that thing.
- System callA mechanism for a user-level program to request services from the operating system kernel.
- Work stealingAllowing a worker to take work from another peer to re-balance the workload.
- Access methodsThe way that the DBMS accesses the data stored in a table.
- Bottom-up optimizationAn optimization strategy where the planner starts with nothing in the query plan and iteratively adds physical operators to reach the final goal.
- Clock skewThe time difference between two clock edges.
- Code specializationGenerating specific code or instructions for a query to avoid giant switch statements and indirection.
- CompilationThe strategy of taking a program and lowering it to the language spoken by the machine.
- ConnectorA software component that allows a middleware layer to communicate with a specific back-end database management system.
- Cuckoo hashingA hashing technique that uses multiple hash functions and multiple tables, evicting and re-hashing elements on collisions to ensure lookups.
- Delta encodingAn encoding scheme that stores the difference between adjacent values in a column rather than the absolute values.
- Domain name systemA system that resolves domain names into IP addresses by sending requests to specialized servers.
- DRAM refreshThe process of periodically reading and rewriting data in DRAM cells to prevent data loss due to charge leakage.
- ETLThe process of extracting data from operational sources, transforming it to a standard format, and loading it into a data warehouse.
- False sharingA performance issue that occurs when independent data elements sit on the same cache line, causing cache lines to slosh back and forth between threads.
- First-ready first-come first-servedA DRAM scheduling policy that prioritizes row hits first, then oldest requests, to maximize row buffer hit rate and throughput.
- Garbage collectorA mechanism that automatically reclaims memory that is no longer in use by the program.
- IndexingSyntax that lets you go to a specific spot inside of an array, usually starting from zero up to n minus one.
- Intra-query parallelismIntra-query parallelism improves the performance of a single query by executing its operators in parallel across multiple resources or workers.
- Kernel bypassA technique that allows user-space applications to access network or storage hardware directly, bypassing the operating system kernel to improve performance.
- Lamport clockA logical clock algorithm where each node maintains a local counter that increments on local events and gets updated upon message receipt to track causal relationships.
- Last writer winsA conflict resolution mode where if two people change data at the same time, the system picks one based on a timestamp and discards the other.
- Materialization modelA query processing model where each operator processes its entire input all at once and emits its entire output as a single result set before the next operator begins.
- Monolithic kernelAn operating system architecture where the entire kernel runs in a single address space.
- PAX (partition attributes across)A storage layout that combines row-based and column-based storage by partitioning data into pages and then storing attributes within those pages in a columnar format.
- Pessimistic concurrency controlA concurrency control protocol that prevents conflicts by holding back transactions before problematic reads and writes can occur.
- Physical loggingPhysical logging records the byte-level changes made to a specific page.
- Pipeline BreakerOperations in query execution that require all input data to be processed before producing output, such as sorting or joins.
- PolymorphismPolymorphism, which used to be called generic procedures, is a way of thinking about classes of these servers.
- Program synthesisAn area of research aimed at automatically generating programs from specifications.
- Projection pushdownEliminating redundant attributes early in the query plan before pipeline breakers to reduce materialization costs.
- Query optimizationThe process of searching for an efficient execution plan for a given query, which is an NP-hard problem.
- Relational algebraA procedural query language consisting of fundamental operators used to query and manipulate relations.
- Sequential scanScanning through large chunks of data sequentially without using index lookups.
- Single instruction, multiple dataA class of CPU instructions that allow the processor to perform the same operation on multiple data points simultaneously.
- SmalltalkAn object-oriented programming language based on SIMULA with graphical user interface features.
- Software prefetchingInstructing the CPU to fetch future memory addresses into cache ahead of time to avoid execution stalls in scan loops.
- ThresholdsA level or point where actual progress meets what is needed to be effective.
- TombstoneA marker in a database that labels a deleted item as invisible rather than actually removing it.
- ValgrindA tool used to check and diagnose memory usage and bugs in programs.
- Vectorization modelA query processing model where each operator emits a batch of tuples instead of a single tuple, utilizing tight for-loops over arrays for hardware efficiency.
- Vectorized executionAn execution model standard in modern OLAP database systems where batches of data are processed at once.
- Work-stealing schedulerA scheduler where idle processors steal tasks from the queues of busy processors to maintain load balance.
- AliasAn alias occurs when multiple names refer to the exact same object in memory, meaning that modifying the object through one name affects all others.
- Apache IcebergAn infrastructure and file format extension to Parquet for maintaining catalogs about data files in an object store.
- Asynchronous propagationChanges are sent and propagated without assuming immediate communication or coordination between nodes.
- AVX-512Intel's 512-bit SIMD extensions providing new instructions for data conversions, scatter, and permutations, split into selectively provided groups.
- Backward compatibilityEnsuring new systems allow easy trial without lock-in, can revert to upstream, and avoid dangerous workarounds.
- Big Theta notationA mathematical notation that bounds a function both from above and below by another function up to constant factors.
- Binary diffingPlacing the same instruction in different places and comparing the resulting bytes to study instruction encoding.
- Bit masksUsing individual bits in a machine word to represent subsets of cities for fast set operations.
- Branch mispredictionA branch misprediction occurs when a CPU incorrectly guesses whether a conditional branch path will be taken.
- BufferingThe use of queues to temporarily store data between independent entities to handle bursts and decouple processing.
- Butterfly networkAn indirect network topology functionally equivalent to the Omega network, prone to tree saturation under high contention.
- Challenge-response protocolA protocol where a trusted device sends a challenge input to an unknown device, which evaluates a PUF and returns a response signature for authentication.
- Change data captureThe process of capturing changes made to a database and streaming them in real time to another system.
- Continuous integrationThe process where written source code by one or multiple people goes through tests and program analyses.
- CookiesA very simple way to implement state in a stateless protocol like HTTP.
- DAGA directed acyclic graph represents the dependencies of expressions in the pipeline to enable parallelization.
- Data flow graphA representation of a computation as a directed graph where nodes are operations and edges are data dependencies.
- Data movement bottleneckThe performance and energy limitation caused by moving large amounts of data between storage/memory and processing units.
- Data partitioningDividing a dataset into smaller, manageable chunks to fit into GPU memory and enable parallel processing.
- Data warehouseA centralized repository for storing and analyzing large volumes of structured data.
- DifferenceAn operation implemented as the intersection of the left type with the negation of the right type.
- Direct manipulationAn interfacing technique that allows users to interact directly with a concrete system.
- Discrete log problemGiven a multiplicative group of integers mod a prime, a generator , and an element h = gˣ pmod p, find .
- Double bufferingUsing separate field buffers for reading and writing data during stencil updates to avoid read-after-write hazards.
- DRAM timing constraintsRules governing the sequence and minimum number of cycles between different DRAM commands to ensure correctness.
- eBPFExtended BPF provides high performance filtering, JIT compilation, and in-kernel summary maps for event tracing.
- Embedded DBMSAn in-process, serverless database management system that runs within the same address space and process as the client application.
- Equi-depth histogramHistograms where bucket widths vary so that the total number of occurrences in each bucket is roughly the same.
- Equi-width histogramHistograms where counts are maintained for groups of values in buckets of the same width.
- Escape analysisA compiler analysis to determine whether an object allocated in a method can escape the method's scope.
- Extended Berkeley packet filterA technology that allows dynamically loading safe, event-driven programs into the OS kernel to execute logic without communicating with user-space code.
- Fault injectionThe practice of intentionally introducing random errors and degraded environmental conditions to verify that a system does not break.
- First-come first-servedA DRAM scheduling policy that maintains a queue and serves the oldest request first.
- Floating point representationFloating point numbers are represented as a pair of integers consisting of significant digits and a base-2 exponent.
- FuzzingUsing genetic algorithms and profiling to automatically generate and guide inputs to explore a program's state space.
- Hash joinA relational operator with three phases (Partition, Build, and Probe) used to join two relations based on a join key.
- High performance computingComputing using supercomputers and parallel processing techniques to solve complex computational problems.
- HyperLogLogA sketch algorithm used to estimate the number of distinct elements in a set in a single pass.
- Index scanThe DBMS picks an index to find the tuples that the query needs.
- Inter-operator parallelismLooking at the operators in a tree and executing multiple operators simultaneously in an orthogonal way.
- Inter-query parallelismExecuting multiple disparate queries simultaneously to increase throughput and reduce latency.
- Interface definition languageA specification language used to define system functions and manage host interop cleanly across boundaries.
- Intra-operator parallelismDecomposing an operator into independent fragments that perform the same function on different subsets of data in parallel.
- JIT compilationCompiling code just-in-time for execution, enabling hardware-specific performance without emulation.
- KV cacheA caching mechanism for key and value vectors in transformer models used to speed up inference.
- Link time optimizationAn optimization technique that enables whole-program optimization in the compiler.
- LivelockA state where a system is busy processing interrupts but fails to make progress on the main task, leading to packet loss.
- Log-based replicationA method where a leader maintains an append-only log of events that followers read sequentially and apply to their own database copies.
- Logical query planAn expression at a high level of what the query wants to accomplish without specifying the underlying algorithms.
- Logical replicationAn API that applications use to get a logical representation of the write-ahead log in the form of inserts, updates, and deletes.
- Lowest common ancestorPre-process a rooted tree to quickly find the lowest node that is an ancestor of both given nodes and .
- Map ReduceAn algorithm built around specific hardware characteristics to handle huge data collections by mapping and reducing inputs.
- Neuromorphic computingComputing architectures that operate based on triggers and events rather than a fixed clock rate, similar to the human brain.
- Non-uniform memory accessA hardware architecture where the cost of getting from any location in memory to any thread can be different.
- Non-volatile storageStorage mechanisms like hard drives or flash drives used to store checkpoints or logs of system state across power failures.
- One-way functionA function that is easy to compute in the forward direction by a polynomial-time algorithm, but hard to invert.
- Operating system kernelAn operating system kernel controls address spaces that can confine computations completely.
- Parametric typesTypes that take a parameter, such as a dimension or a type, enabling simple shortcuts for common cases while supporting complex configurations.
- PasskeysA passkey is a replacement for passwords that uses public key cryptography where a private key stays on the user's device and a public key is stored on the service.
- Perfect hash functionA hash function that guarantees no collisions such that different keys always map to different values.
- Performance counterA function typically used in the real world to figure out how long an actual program or a function takes to run with high accuracy.
- Persistent data structuresData structures that preserve their previous version when modified, providing immutability and persistence.
- Physical planA plan defining the specific execution strategy and algorithms used to execute operators, depending on the data's physical format.
- Prefix sumAn algorithmic operation that computes running totals of an array to determine memory offsets for parallel writes without race conditions.
- Process modelA DBMS's process model defines how the system is architected to support concurrent requests and queries.
- Query pushdownThe process of sending query operations to the underlying database system where the data resides to minimize data movement.
- Random accessJumping to scattered physical locations across a storage device to retrieve non-contiguous data blocks.
- ReactorA software component that maintains local state, has local events, and processes events in timestamp order.
- Read disturbanceA phenomenon where accessing one DRAM row inadvertently causes bit flips in adjacent rows, breaking memory isolation.
- Remote direct memory accessRDMA enables reading and writing memory directly on a remote host over hardware protocols without OS intervention.
- Resource acquisition is initializationA technique where resource acquisition is bound to object construction and release is bound to object destruction.
- Restrict keywordA C/C++ keyword telling the compiler that arrays are distinct memory locations for the lifetime of the pointers.
- Ring network topologyA network topology where each node is connected to exactly two adjacent nodes forming a closed loop with linear cost scaling.
- RouterA special type of switch that translates and routes traffic from one network zone to another network zone.
- SandboxingRunning builds in an isolated environment that restricts file access strictly to declared inputs and outputs.
- ScalabilityThe property where increasing system resources by a certain factor yields a proportional increase in performance or throughput.
- Semi joinsA join operation where the result only contains columns from the left table, used in distributed DBMSs to minimize the amount of data sent over the network.
- Sequential accessAccessing contiguous blocks of data in storage to minimize expensive physical arm movements or connection overhead.
- SketchesProbabilistic data structures used to generate approximate statistics about a dataset.
- Sliding windowAn optimization technique for modular exponentiation that reduces the number of multiplications required.
- SQLOSA user-mode NUMA-aware OS abstraction layer inside SQL Server that manages hardware resources, task scheduling, I/O scheduling, and logical locks.
- Static single assignmentAn invariant where a register is defined by at most one instruction in a function.
- Stored procedureA subroutine available to applications accessing a relational database management system that can be invoked outside of a SQL query.
- Struct paddingUnused bytes inserted by a compiler between struct fields or at the end of a struct to satisfy alignment requirements.
- SubstraitAn open-source query plan format used to translate logical plans from various database systems into a format that Sirius can execute.
- SwitchA networking device that allows multiple messages to be routed across switch ports from different hosts to different hosts.
- System R optimizerA pioneering cost-based, bottom-up query optimizer that serves as the foundation for most modern database optimizers.
- Tagged pointersStoring additional metadata in the unused upper bits of 64-bit pointers.
- Tail recursionThe optimization in an evaluator where restoring continue points directly to the caller rather than stacking intermediate evaluation states.
- Task parallelismA workflow pattern where multiple steps have parallelism among tasks but also maintain sequential dependencies from one workflow stage to the next.
- Time travel debuggingThe ability to go back to an arbitrary moment in a system's execution and interact with it as if it were live.
- TranspilationThe process of converting source code from one programming language or dialect to another.
- True random number generatorA device or mechanism that generates random numbers from a physical, non-deterministic entropy source.
- Type inferenceThe compiler process of determining the types of outputs and intermediate values given the types of the inputs.
- Unknown unknownsThe worst type of complexity where it is not even clear what you need to know in order to make modifications.
- Use-after-freeA memory corruption vulnerability where a program continues to use a pointer after it has been freed.
- Valiant's algorithmAn oblivious routing algorithm that balances network load by routing packets through a randomly chosen intermediate destination first.
- WorkerThe DBMS component that is responsible for executing tasks on behalf of the client and returning the results.
- Zero cost abstractionsLanguage features like closures, exceptions, and traits that do not add any extra runtime overhead.
- Zone mapsPre-computed aggregates for attribute values in a page that the DBMS checks first to decide whether to access the page.