Concepts
5,907Terms and methods explained by more than one lecturer. Each opens at the minute it is taught.
Systems & CS
633The first 400 are shown. Search or choose a field to narrow the list.
- 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.
- RecursionA programming technique where a function calls itself to solve smaller instances of the same problem.
- Garbage collectionAn automated memory management system that reclaims memory occupied by objects no longer in use by the program.
- ClosureA property of a means of combination where the results of combined elements can themselves be combined using the same means.
- 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.
- Greatest common divisorThe greatest common divisor of two numbers is the largest positive integer that divides both numbers without a remainder.
- 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
- QueueA collection data structure operating on a first-in, first-out (FIFO) basis where new elements are added to the end and removed from the beginning.
- Race conditionA bug caused when multiple threads access shared data concurrently and at least one access is a write, leading to unpredictable results.
- StackAn abstract data type operating on a Last In, First Out (LIFO) basis.
- 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.
- Digital signaturesA cryptographic mechanism to verify the authenticity and integrity of a message using a secret key to sign and a public key to verify.
- 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.
- Binary searchAn algorithm that finds the position of a target value within a sorted array by repeatedly dividing the search interval in half.
- Fibonacci numbersA sequence of numbers where each number is the sum of the two preceding ones, starting from 0 and 1.
- IsolationThe property where execution of one transaction is isolated from that of other transactions ("all by myself").
- B-treeA B-tree is a self-balancing tree data structure that keeps data sorted and allows searches, sequential access, insertions, and deletions in logarithmic time, optimized for systems that read and write large blocks of data.
- Formal verificationThe use of tools to check mathematical proofs.
- LatencyThe time delay between a request for data and the response.
- RangeA function that generates a sequence of integers following a pattern based on start, stop, and step arguments.
- SyntaxThe structure or grammar of a language, including word order rules that determine sentence meaning.
- Data abstractionA methodology that isolates the way data objects are used from the way they are represented.
- Object-oriented programmingA programming paradigm where everything is an object that can be created, manipulated, and destroyed.
- 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.
- Functional programmingA programming paradigm that avoids side effects and mutable state, treating programs as mathematical functions.
- Pattern matchingA method of processing text by providing a template or pattern and letting the system figure out how to match text against it.
- Recursion treeA tree representing the costs of subproblems at each level of a recursive algorithm to solve recurrences.
- 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.
- Data raceA condition occurring when multiple threads access the same memory location concurrently and at least one of the accesses is a write, resulting in undefined behavior.
- 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.
- Merge sortA sorting algorithm that recursively divides a list into two halves, sorts them, and then merges the sorted halves.
- 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.
- Model checkingA technique that conceptually checks all possible executions of a program on a small model.
- PageRankAn algorithm for calculating the relative importance of web pages based on links to them.
- RefactoringRestructuring existing computer code without changing its external behavior to improve non-functional attributes.
- SemanticsThe meaning or understanding attached to symbols, going beyond mere syntax.
- 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.
- YieldA mechanism where the kernel pauses the current process to allow other processes to run.
- AlgorithmStep-by-step instructions for solving some problem.
- AtomicityA property of a transaction where all its constituent parts are executed or none of them are.
- DebuggingThe process of writing code and eliminating bugs or mistakes in a computer program.
- DecompositionThe process of breaking a problem down into smaller, self-contained, and manageable parts or modules.
- Lambda expressionsExpressions that produce anonymous procedures without needing to explicitly define them with a name.
- Page tableA data structure used by a virtual memory system in a computer operating system to store the mapping between virtual addresses and physical addresses.
- 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.
- Abstract data typeA high-level description of a data structure that defines its behavior and operations, independent of its implementation.
- Address spaceThe entire set of unique locations in memory.
- AttributesExtra keywords and information attached to LLVM IR constructs like instructions, operands, functions, or parameters.
- 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.
- Hash tableA data structure that uses a hash function to map keys to values, implemented as an array of linked lists.
- HypergraphA generalization of a graph where edges can connect any number of vertices, used to represent coupling among subsets of subsystems.
- ListA conventional way of representing a sequence of things as a chain of pairs.
- 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.
- Speculative executionA technique to improve the performance of CPUs where the CPU guesses a branch outcome and starts executing down that path before it knows whether it really should be executing it.
- TruncationThe phenomenon in integer division where any fractional part after the decimal point is discarded because the operation only uses integer-based math.
- VariableA named storage location in memory that holds a value.
- Base caseThe first part of an induction proof that shows the statement is true for the initial value, usually zero.
- CertificateA digital document containing a web server's name, its public key, and a signature from a certificate authority.
- CollisionA situation in a hash table where two different keys map to the same hash value.
- Divide and conquer matrix multiplicationA recursive algorithm for multiplying matrices by subdividing them into blocks and arranging their layouts consecutively in memory.
- Euclid's algorithmAn ancient algorithm for computing the greatest common divisor of two numbers.
- 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.
- InterruptsSignals that cause the processor to pause its current execution and handle an event.
- Lazy evaluationAn evaluation strategy that delays expression evaluation until its value is needed, avoiding unnecessary computation for data constructors and selectors.
- Least recently usedA page replacement policy that evicts the page that has not been accessed for the longest period of time.
- 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.
- ObjectAn entity in Python that has an internal data representation and a set of procedures for interaction.
- 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.
- PredicateA procedure that returns a boolean value (true or false) indicating whether a condition holds.
- Property-based testingA general testing technique that checks properties over randomized inputs to cover a wide range of values.
- SchedulerThe core real-time operating system component that checks task priorities and decides task execution order.
- 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.
- Translation Lookaside bufferA hardware cache that stores recent virtual-to-physical address translations to speed up memory access.
- TupleA collection of values in Python that is immutable, meaning its values cannot be changed after creation.
- Virtual realityA computer-generated simulation of a three-dimensional environment that can be interacted with in a seemingly real or physical way.
- Write-ahead logA recovery protocol where change records are written to a separate log file before database pages are flushed to disk.
- LinearizabilityA strong consistency model where operations appear to take effect instantaneously at some point between their invocation and response.
- Critical sectionA piece of code that can only be executed by one thread at a time, providing mutual exclusion.
- Declarative knowledgeKnowledge expressed as facts that are true for all time, without any inherent time sequence.
- Fault toleranceThe ability of a system to continue operating properly in the event of the failure of one or more of its components.
- Split-brainA failure state in distributed systems where a network partition causes multiple nodes to believe they are the primary leader, accepting conflicting updates.
- TaskA sequence of one or more operator instances.
- Buffer overflowA vulnerability that occurs when a program writes more data to a buffer than it can hold, overwriting adjacent memory.
- Cache-oblivious algorithmAn algorithm designed to exploit the memory hierarchy without knowing the block size B or the cache size M.
- CompilerA program that translates one language to another, such as source code to machine code.
- For loopA control flow statement for iterating over a sequence of values.
- IterationAn iterative process is one whose time complexity is proportional to the input and whose space complexity is constant ().
- Late materializationA strategy where only necessary join keys and record identifiers are passed between operators, fetching full attribute values only when required.
- MethodsFunctions that come built-in with specific data types or objects.
- 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.
- PaxosA consensus algorithm used to achieve agreement among distributed nodes.
- ReplicationMaintaining multiple copies of the same data on different nodes to increase performance and availability.
- ScopeA variable only existing in the context in which you defined it.
- While loopA control flow structure that repeatedly executes a block of code as long as a specified condition remains true.
- Assembly languageA low-level programming language that sits between C and machine code, containing human-readable instructions for a computer.
- Asymptotic complexityTheta notation denotes the asymptotic complexity of a function by looking at the dominant input term and dropping lower-order terms and constants.
- 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.
- Certificate authorityA trusted entity that issues digital certificates to bind public keys to specific identities.
- CheckpointingSaving the entire state of a running operating system and its processes to be restored later.
- CommentsNotes to self or other humans written into code using // that are ignored by the compiler.
- 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.
- Dirty bitA bit in a page table entry that indicates whether the page has been modified since it was loaded into memory.
- ExpressionAn operation in the query with zero or more input expressions that the optimizer evaluates for equivalence.
- Feedback loopA mechanism or person that provides honest criticism and information on how to improve.
- File descriptorAn integer in user space that the kernel interprets using a process-specific file descriptor table to reference open files.
- Formal parameterThe variable name specified in a function definition that acts as a placeholder for the actual values passed during a call.
- InheritanceA mechanism where a child class inherits all data and behaviors from its parent class.
- MapA general procedure that applies a given function to each element of a list and returns a new list of the results.
- NonceAn arbitrary number used in cryptographic communication to ensure freshness and prevent replay attacks.
- 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.
- StringA sequence of characters stored together, represented as an array.
- Syntactic sugarSyntax within a programming language that is designed to make things easier to read or to express, while being an abbreviation for a more complex underlying construct.
- TransactionA sequence of operations on data that appears atomic to other users.
- Von Neumann bottleneckThe throughput limitation in a Von Neumann architecture caused by the single data bus connecting the processor and memory.
- -greedy algorithmAn algorithm that mostly acts greedily with probability while selecting a random action with probability , resulting in linear total regret.
- 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.
- Backward chainingAn inference method that starts with a goal/hypothesis and works backward to find supporting assertions or rules.
- Bounded contextA boundary within which a domain model applies and terms have specific, unambiguous meanings.
- Cache coherenceThe mechanism by which multiple processors caching the same block ensure they all see a consistent state.
- CachingStoring frequently accessed data in a faster, temporary storage layer to reduce load on the primary database.
- Cactus stackA stack structure that supports multiple views of the stack in parallel.
- Caller-saved registersRegisters that a function is allowed to modify, so the caller must save them if it needs their values after the function returns.
- ChannelsSynchronous queuing synchronization primitives in Go that lack internal storage by default.
- CheckpointA saved point in computation used to limit the scope of recomputation during failures.
- ChecksumA 16-bit field used by software to verify that an IP or UDP packet has not been corrupted during transmission.
- 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.
- Conjunctive normal formA representation of Boolean formulas as a conjunction of clauses, where each clause is a disjunction of literals.
- 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.
- Data-oriented designA program design approach focused on data layout and how the hardware processes it for performance.
- Demand pagingA memory management scheme where pages are loaded from disk into RAM only when they are accessed by the running program.
- Dependency graphA graph built by userspace and managed by the kernel that dictates the execution order of GPU submissions.
- 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.
- ExceptionAn error raised during program execution when an unexpected condition is encountered.
- Foreign function interfaceAn approach used in languages like Gleam to declare external functions and their types to call code written in another language safely.
- ForkA system call that creates a new process which is an identical copy of the calling process.
- Forward chainingA rule-evaluation method where new assertions are progressively added to the database by matching rules against existing assertions according to rule priority and tie-breaking order.
- FrameAn entry or location in the buffer pool memory that can be used to install a page.
- Function callA function call invokes a defined function by name and passes arguments, causing Python to execute the function body and return a value.
- 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.
- Imperative knowledgeKnowledge that describes how to accomplish something through a sequence of steps or an algorithm.
- Instruction-level parallelismProcessor hardware exploits instruction-level parallelism by finding opportunities to execute multiple instructions simultaneously in different pipeline stages.
- 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.
- Iterative processA process whose state can be summarized by a fixed number of state variables and a fixed rule for how they update, running in constant space without building up deferred operations.
- IteratorsProcedures that are called and yield values one after another until finished.
- JoinA SQL clause used to combine rows from two or more tables based on a related column between them.
- Load effective addressAn x86 instruction used by compilers to compute simple integer arithmetic as well as memory addresses.
- Log sequence numberA unique identifier for a log record in a database, used to track the state of the database and ensure consistency.
- Man in the Middle attackAn attack where an intermediary intercepts and potentially alters communication between two parties while making each believe they are communicating directly with the other.
- 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.
- MechanismsMachines, devices, or contrivances invented or fitted to a particular use or purpose, such as a hash table.
- Memory management unitA hardware component responsible for resolving address translation requests from virtual to physical addresses.
- MicrocodeLow-level code that implements instructions and control logic inside a processor.
- MmapA system call that maps a file into the virtual address space of a process.
- 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.
- PollingA technique where the CPU repeatedly checks a device's status register to determine if it has data, rather than waiting for an interrupt.
- ProbeA monitoring object attached to a wire that automatically prints a message whenever the wire's signal changes.
- ProcedureAn algorithm, a series of steps for computing something.
- ProcessA dynamic computational activity directed by rules that evolves over time and manipulates data.
- 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.
- ProtocolA stripped-down struct or class that defines functions and vars without any implementation or storage.
- RdtscAn x86 instruction that reads the time-stamp counter in hardware, returning clock cycles since boot.
- Reference countingKeeping a count of the number of references or pointers to a physical page so it is only freed when the count reaches zero.
- 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.
- Selection sortAn algorithm that repeatedly scans the unsorted portion of a list to find the smallest element and swaps it into its correct sorted position from left to right.
- SelectivityThe fraction or probability that any tuple from an input will be emitted as part of the output for a given predicate or operation.
- SettersA function in some class that sets some value.
- Snapshot isolationAn isolation level where every transaction gets a full snapshot copy of the database to simulate isolated execution.
- 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.
- StreamsA data abstraction with a constructor and selectors, functioning as a signal flowing between signal-processing boxes.
- Symbolic executionA technique for analyzing a program by treating inputs as symbolic variables rather than concrete values to explore all possible execution paths.
- Test-driven developmentA software development process where you write tests before the implementation to design the system.
- Unit testingA software testing method by which individual units of source code are tested to determine whether they are fit for use.
- 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.
- Virtual machineA simulation of a computer that is accurate enough to run an operating system.
- Write-back cacheA caching strategy where modified dirty pages are buffered in memory and not immediately written to disk.
- 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.
- Return valueThe value that a function produces and provides back to the caller after it has finished executing.
- 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.
- DictionaryA collection of keys and values that allows associating something with something else in Python.
- DynabookA conceptualized portable, interactive personal computer for children that functions like a book to support literacy and learning.
- Higher-order proceduresProcedures that take other procedures as arguments or return procedures as results, capturing general patterns of combination.
- Memory leakA memory leak happens when a program allocates memory using malloc but never calls free to release it back to the system.
- 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.
- Abstraction barrierA boundary that separates the use of a data object from its concrete representation and implementation details.
- ArrayA collection of data values that are stored contiguously in the computer's memory.
- BarrierA point in the program where every thread must arrive before any thread can continue.
- Class variableA variable and its value that are shared between all instances of a class.
- ConditionalsProgram structures that allow execution of different code blocks based on whether a condition is true or false.
- Embedded languageA language built on top of an existing host language (like Lisp) by defining procedures and abstractions that capture the desired domain structure.
- Indentation in PythonIndentation is used syntactically in Python to define blocks of code and scope rather than curly braces.
- Instance variableData attributes defined with self.XXX that are accessible with dot notation for the lifetime of the object.
- InterpreterA program you install on your computer that reads source code top to bottom, left to right, and translates it into zeros and ones.
- LoopThe ability in Python and other programming languages to do something again and again in a cycle.
- Metalinguistic abstractionControlling complexity by picking a new design language to highlight different aspects of the system.
- 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.
- Side effectsActions performed by a function, such as printing to the screen, that do not return a value.
- Substitution modelThe simplest model we have for understanding how procedures and processes work by evaluating operators and operands and substituting arguments for formal parameters in procedure bodies.
- 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.
- TrapA mechanism that transfers control from user mode to the kernel in response to an interrupt, exception, or system call.
- Type castingConverting an object from one data type to another, such as a Fraction to a float using __float__.
- Wishful thinkingA design strategy where you assume a procedure or data representation already exists to build higher-level procedures, deferring its implementation.
- 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.
- AliasingAliasing occurs when two variables refer to the same mutable object in memory, so that changes made through one variable affect the other.
- Amortized costA way to express the time cost per operation on average over a sequence of multiple operations, such as spreading the cost of sorting a list across many subsequent searches.
- ASCIIA mapping from decimal numbers to letters and characters called the American Standard Code for Information Interchange.
- BooleanA data type that can only be true or false.
- 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.
- Break statementA statement that breaks out of the most recently begun while loop.
- Cilk spawnA Cilk keyword that grants permission for the named child function to execute in parallel with the parent caller.
- Cilk syncA synchronization statement that blocks execution until all previously spawned child tasks in the current function have returned.
- 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.
- ConsAn operator that takes two arguments, x and y, and constructs a pair whose first part is x and second part is y.
- Crash recoveryThe process of restoring a database to a consistent state after a system failure.
- Cuckoo hashingA hashing technique that uses multiple hash functions and multiple tables, evicting and re-hashing elements on collisions to ensure lookups.
- Data structureA way by which you can structure your data using a computer's memory in interesting and clever ways to solve problems more effectively.
- Delta encodingAn encoding scheme that stores the difference between adjacent values in a column rather than the absolute values.
- Dependent typesTypes that depend on values, representing more powerful type systems being adopted into languages like Haskell.
- DHCPA network protocol used to configure devices dynamically for network connectivity.
- Distributed transactionsOperations that involve reading or modifying data across multiple different servers.
- DocstringA multi-line comment using triple quotes that acts as a specification or contract for the function's inputs and outputs.
- 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.
- EnvironmentA special structure where pairings of names and values are stored.
- ETLThe process of extracting data from operational sources, transforming it to a standard format, and loading it into a data warehouse.
- External fragmentationA condition where free memory is split into small blocks separated by allocated memory blocks, leading to poor spatial locality.
- F-stringA formatted string literal that evaluates expressions inside curly braces at runtime and converts them to strings.
- 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.
- Flow stateA mental state where everything is just working and the user is deeply immersed in the activity.
- FreeA function used to return previously allocated memory back to the operating system.
- Garbage collectorA mechanism that automatically reclaims memory that is no longer in use by the program.
- Higher-order functionsFunctions that can take other functions as arguments or return them.
- IndexingSyntax that lets you go to a specific spot inside of an array, usually starting from zero up to n minus one.
- Input functionA function that prints a prompt string to the console, waits for user keyboard input, and returns that input as a string.
- Internal fragmentationMemory waste caused by allocating blocks larger than what the user requested.
- Intra-query parallelismIntra-query parallelism improves the performance of a single query by executing its operators in parallel across multiple resources or workers.
- KarmaThe belief that one's actions, specifically helping others, will eventually lead to positive outcomes for oneself.
- 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.
- LatchA low-level protection primitive that protects critical sections of a DBMS's internal data structures from other workers.
- Len functionA Python function that returns the length or number of elements in a list or sequence.
- MallocA function used to allocate a specific number of bytes of memory.
- 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.
- Means of combinationA way of combining simpler pieces into expressions that can themselves be treated as elements of other expressions.
- Message authentication codesMessage authentication codes are cryptographic codes used for integrity and authenticity in communication protocols.
- Monolithic kernelAn operating system architecture where the entire kernel runs in a single address space.
- Multi-version concurrency controlA concurrency control mechanism that maintains multiple physical versions of a logical database object to allow readers and writers to proceed without blocking each other.
- Order of growthThe rate at which the resource requirements of an algorithm grow as a function of the input size.
- 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.
- PixelAn individual dot on a computer or phone screen that has associated numerical color values.
- PointerA variable whose purpose is to store the memory address of another variable.
- 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.
- QuorumA subset of nodes in a distributed system that must agree on an operation before it is considered successful, ensuring consistency and fault tolerance.
- Recursive definitionA definition of a procedure or function in terms of itself, such as the exponentiation function calling itself.
- Recursive processA process that builds up a chain of deferred operations, requiring memory proportional to the number of recursive steps.
- Regular expressionsA way of using patterns to validate inputs or to extract information from strings.
- Relational algebraA procedural query language consisting of fundamental operators used to query and manipulate relations.
- Return statementA keyword used inside a function to end its execution and pass a resulting value back to the caller.
- SelectorA procedure that extracts parts from a compound data object.
- 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.
- Special formAn expression that does not follow the normal rules of evaluation for a combination.
- ThresholdsA level or point where actual progress meets what is needed to be effective.
- TLBA cache that stores recent translations of virtual memory to physical memory addresses.
- TombstoneA marker in a database that labels a deleted item as invisible rather than actually removing it.
- Two-phase lockingA pessimistic concurrency control method where transactions acquire shared locks on read items and hold them until commit or abort.
- UnificationThe process of determining the substitutions that make two symbolic expressions identical.
- 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.
- __Init__ methodA special method used to initialize the contents and attributes of an object when it is instantiated from a class.
- __Str__ methodA special dunder method that returns a string representation of an object when it is printed or converted to a string.
- Abstract syntax treeA tree representation of the abstract syntactic structure of source code written in a programming language.
- AgendaA data structure that organizes future actions by time to schedule and execute simulated events.
- AjaxA technique using JavaScript to get more data from the server asynchronously without reloading the entire browser page.
- 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.
- Applicative order evaluationAn evaluation model where operands are fully evaluated first before substituting them into the operator procedure.
- 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.
- Balanced treeTrees designed to avoid degenerate cases by keeping the height logarithmic relative to the number of nodes.
- BatchingGrouping expensive operations together to amortize their costs and improve overall performance.
- 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.
- BitboardsA board representation technique using 64-bit words where individual bits correspond to board squares containing specific pieces.
- Block structureA way of packaging internal procedures and definitions inside a main procedure definition.
- BlockchainA public ledger where people can only add items in an append-only fashion never removing them.
- Branch mispredictionA branch misprediction occurs when a CPU incorrectly guesses whether a conditional branch path will be taken.
- Branch-and-bound pruningPruning branches in the search tree based on properties and cumulative costs once the bottom of the tree is reached.
- BufferingThe use of queues to temporarily store data between independent entities to handle bursts and decouple processing.
- Bus factorA risk indicator measuring the impact of losing key team members who hold exclusive knowledge about specific components.
- Busy-leaves propertyA property of Cilk's work-stealing algorithm where every active leaf frame in the invocation tree is being executed by a worker.
- Butterfly networkAn indirect network topology functionally equivalent to the Omega network, prone to tree saturation under high contention.
- C programming languageA foundational programming language used in CS50 for writing text-based code.
- Cache memorySmaller, faster volatile computer memory that the CPU can access more quickly than regular RAM, categorized into levels like L1, L2, and L3.
- Call stackA stack segment used to store data and memory in order to manage function calls and returns.
- Callee-saved registersRegisters that are preserved across function calls and whose values must be maintained by the called function.
- Causal consistencyA consistency model where writes that are causally related must be seen by every node in the same relative order.
- 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.
- Channels in goChannels are a synchronization and communication primitive used to pass data between concurrent go routines.
- CiphertextThe scrambled, encrypted text resulting from applying an encryption function to plaintext.
- ClassA blueprint or mold that allows you to invent your own custom data types in Python and give them a name.
- CohortA group of nodes in a distributed system that participate in a consensus protocol together.
- Compiler optimizationCompiler flags such as -O3 that automatically improve execution speed of code.
- Compound procedure applicationApplying a procedure to arguments is done by evaluating its body in an environment extended with the parameter bindings.
- Compressed sparse rowA data structure for representing sparse matrices using three arrays to store only non-zero values and their positions.
- Computation dagA directed acyclic graph that models the dynamic execution of a parallel program.
- Constant patternsConstant patterns enable simpler primitive checks by matching against specific constant values within patterns.
- Continuous integrationThe process where written source code by one or multiple people goes through tests and program analyses.
- Conway's lawOrganizations which design systems are constrained to produce designs which are copies of the communication structures of these organizations.
- CookiesA very simple way to implement state in a stateless protocol like HTTP.
- CoordinationTimes when we intentionally want different threads to interact with each other and wait for each other.
- Copy on writeA strategy where a system makes a copy of blocks at the time a transaction closes, avoiding actual copies until a newer transaction needs to write to that block.
- DAGA directed acyclic graph represents the dependencies of expressions in the pipeline to enable parallelization.
- Data encryption standardDES is a symmetric-key block cipher that was widely used in early protocols like Kerberos version 4 with a 56-bit key size.
- 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 oriented programmingA programming paradigm centered on the separation of code from data and the organization of data around hardware realities.
- 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.
- Database partitioningSplitting a single logical table into disjoint physical segments that are stored and managed separately.
- DatumAn atomic fact in the database composed of the entity, the attribute, the value, the transaction, and the added value.
- Deadlock detectionA mechanism to identify and resolve situations where two or more threads are waiting for each other to release resources.
- DebuggerAn industry-standard tool used to examine and control program execution to find logical errors.
- DecryptionA mathematical process that transforms a seemingly random string of bits back into a readable message.
- DelayAn operation that takes an expression and produces a promise to compute that expression when asked.
- DependenciesA source of complexity where a piece of code cannot be read, understood, and modified independently from other parts.