Computer Science Glossary
Key terms from the Computer Science course, linked to the lesson that introduces each one.
1,061 terms.
A
- accept state
- The accept state is the "Success Exit" — reaching it means you've completed the task correctly
- Lesson 1856 — Accepting and Rejecting States
- Accept states
- Pairs (q₁, q₂) where both q₁ is accepting in M₁ and q₂ is accepting in M₂
- Lesson 1805 — Closure Properties: Intersection
- Access control
- Determining which device can transmit on a shared medium (like WiFi)
- Lesson 1434 — OSI Layer 2: Data Link Layer
- Access tokens
- Access tokens are short-lived credentials (typically lasting minutes to hours) that clients present when making API requests to protected resources.
- Lesson 2539 — OAuth 2.0 Tokens: Access Tokens and Refresh Tokens
- accumulator
- An accumulator is an extra parameter you add to your recursive function that carries partial results downward through the recursion.
- Lesson 871 — Accumulator Pattern in RecursionLesson 1077 — Accumulator and Status Registers
- accumulators
- A helper function is an inner or separate function that takes extra parameters (called accumulators) to carry partial results forward, eliminating the need for work after the call.
- Lesson 229 — Helper Functions in Recursion
- Accuracy
- The fraction of correct predictions. Use when classes are balanced and all errors cost roughly the same.
- Lesson 1499 — When to Use TCP: Application ScenariosLesson 2804 — Performance Metrics SelectionLesson 2835 — Evaluating Logistic Regression Models
- ACLs and DAC
- ACLs and DAC are simple but inflexible—they tie permissions directly to resources.
- Lesson 2533 — Authorization Model Tradeoffs
- Acquire
- Acquire means trying to lock the door—if it's already locked, you wait outside.
- Lesson 1281 — Lock Semantics and Acquire/Release
- acyclic graph
- An acyclic graph is simply a graph with no cycles—no way to start at a vertex and return to it by following edges.
- Lesson 663 — Cycles and Acyclic Graphs
- Acyclic graphs
- Acyclic graphs are simpler to work with for many algorithms.
- Lesson 690 — Cyclic and Acyclic Graphs
- Adaptation
- The team can adjust their daily plan based on progress
- Lesson 2380 — Daily Scrum (Stand-up)
- Adapter
- You bought a European power plug but your outlet is American. You need an adapter to convert one interface to another. The adapter exists because of incompatibility.
- Lesson 2281 — Adapter vs Bridge: When to Use Which
- Address binding
- Address binding is the process of translating these symbolic addresses into physical memory addresses, and it can happen at three different times.
- Lesson 1330 — Address Binding Concepts
- adjacency matrix
- An adjacency matrix is one of the most straightforward ways to store a graph in memory.
- Lesson 669 — Adjacency Matrix: Structure and Memory
- admissible heuristic
- An admissible heuristic is a heuristic function h(n) that never overestimates the true cost to reach the goal from node n.
- Lesson 1003 — Admissible Heuristics
- Advisory locking
- Advisory locking is cooperative: processes voluntarily check and respect locks before accessing a file.
- Lesson 1393 — File Locking Mechanisms
- aggregation pipeline
- An aggregation pipeline is like a factory assembly line for your documents.
- Lesson 1726 — Aggregation Pipeline Basics
- Aging
- Aging is a simple, elegant solution: the longer a process waits in the ready queue, the more we gradually increase its priority.
- Lesson 1258 — Priority Inversion and Aging
- ALL
- The condition must be true for every value in the subquery result.
- Lesson 1607 — ANY, ALL, and SOME Operators
- Amortization
- Occasional rehashing costs are spread across many operations
- Lesson 433 — Average-Case Time Complexity Analysis
- Analogy
- A coffee shop with numbered tickets—every customer is guaranteed service in a predictable timeframe.
- Lesson 683 — Hybrid and Compressed RepresentationsLesson 962 — Bitmasking for Subset DPLesson 1493 — UDP Performance CharacteristicsLesson 2431 — Hash Function Applications: Digital Signatures and MACsLesson 2575 — Lock-Free vs Wait-Free Guarantees
- Analytics dashboards
- Reading slightly stale data (relaxing Consistency) is fine when you're viewing trends, not processing payments.
- Lesson 1665 — ACID Tradeoffs and Real-World Implications
- Analyze structure
- A tree where most nodes have high degree is "wide and shallow"
- Lesson 458 — Degree of a Node and Tree Degree
- anti-dependencies
- WAR hazards are also called anti-dependencies because they reverse the normal flow: a later instruction constrains an earlier one.
- Lesson 1166 — Data Hazards: Write-After-Read (WAR)
- Anti-Entropy
- Anti-Entropy is a background process that continuously compares replicas and synchronizes differences.
- Lesson 2643 — Read Repair and Anti-EntropyLesson 2704 — Anti-Entropy and Gossip Protocols
- any non-trivial property of program behavior
- Rice's Theorem takes this limitation much further: it proves that any non-trivial property of program behavior is undecidable.
- Lesson 1884 — Rice's Theorem Introduction
- application layer
- The application layer is closest to the end user.
- Lesson 1437 — OSI Upper Layers: Session, Presentation, Application
- Architecture choices
- The structure you design determines what functions are reachable
- Lesson 2778 — The Hypothesis Space
- argument
- The actual data you pass in is called an argument.
- Lesson 195 — Function Parameters: Passing Data to Functions
- Arrange
- Arrange is where you set up everything needed for the test.
- Lesson 2225 — Anatomy of a Unit Test
- array
- An array is a data structure that stores a fixed number of elements, all of the same type, in a single contiguous block of memory.
- Lesson 232 — What is an Array?
- assembler
- An assembler is a special program that bridges this gap.
- Lesson 1105 — Assembly to Machine Code Translation
- Assignment
- An AssignmentNode typically holds a target (variable name) and a value (expression AST).
- Lesson 1979 — AST Representation of Statements
- Assignment edge
- An arrow from a resource to a process means that resource is currently allocated to that process (resource → process)
- Lesson 1316 — Resource Allocation Graphs
- Asynchronous
- You drop it in the teacher's inbox and immediately leave. Faster, but if the teacher's desk catches fire before they file it, your work is gone.
- Lesson 2640 — Synchronous vs. Asynchronous Replication
- atomic operation
- An atomic operation is an indivisible unit of work that executes completely without interruption from other threads.
- Lesson 2557 — Atomic Operations
- attack vector
- An attack vector is the specific path or method an attacker uses to inject malicious code.
- Lesson 2458 — XSS Attack Vectors and Payloads
- attributes
- In entity-relationship modeling, attributes are the properties or characteristics that describe an entity.
- Lesson 1613 — Attributes and Domains
- augmenting path
- An augmenting path is a path from the source node to the sink node in the residual network where every edge along the path has positive residual capacity.
- Lesson 1028 — Augmenting PathsLesson 1037 — Augmenting Paths
- Authentication
- Authentication is the process of verifying that someone (or something) is who they claim to be.
- Lesson 2494 — What is Authentication?Lesson 2524 — Authorization vs Authentication
- authoritative answer
- An authoritative answer is when you ask the person directly—they know their own number for certain.
- Lesson 1511 — Authoritative vs Non-Authoritative Responses
- Authorization
- Authorization is what happens when you use your room key.
- Lesson 2524 — Authorization vs Authentication
- authorization code grant
- The authorization code grant is OAuth 2.0's most secure flow, designed specifically for confidential clients—web applications that can safely store secrets on a backend server.
- Lesson 2536 — OAuth 2.0 Grant Types: Authorization Code Grant
- Autonomy
- The team decides task assignments, technical approaches, and daily workflows
- Lesson 2367 — Self-Organizing Teams
- Auxiliary Space
- This O(n) space is called auxiliary space because it's in addition to the input array itself.
- Lesson 303 — Auxiliary Space vs Total SpaceLesson 757 — Mergesort Space Complexity
- Availability
- In distributed systems, availability means that every request to a non-failing node receives a response—without exception.
- Lesson 1733 — Replication in Key-Value StoresLesson 2602 — Availability in Distributed Systems
- AVL tree
- An AVL tree is a self-balancing binary search tree.
- Lesson 531 — AVL Tree Definition and Balance Property
B
- B-tree
- A B-tree is a self-balancing search tree designed for systems that read and write large blocks of data, like databases and file systems.
- Lesson 556 — B-Tree Definition and Properties
- B-Tree index
- A B-Tree index is a self-balancing tree structure that databases use to organize and quickly locate data on disk.
- Lesson 1676 — B-Tree Index Overview
- Backpressure
- Backpressure is the mechanism by which a slow consumer signals upstream components to slow down.
- Lesson 2714 — Backpressure and Flow Control
- balance factor
- A balance factor is simply a number that tells you how lopsided a node's subtrees are.
- Lesson 533 — Calculating Balance Factors
- balanced binary tree
- A balanced binary tree is one where, for every node, the height difference between its left and right subtrees is small—typically no more than 1.
- Lesson 488 — Balanced vs Unbalanced Trees
- Bandwidth
- Bandwidth is your "pipe width." A 1 Gbps connection can theoretically transfer 125 MB/s, but actual throughput depends on network congestion, packet loss, and protocol overhead.
- Lesson 1444 — Bandwidth and ThroughputLesson 2590 — Network Latency and Bandwidth Constraints
- bars
- To separate them into 3 groups, we need 2 dividers (called bars): |
- Lesson 102 — Combinations with Repetition (Stars and Bars)
- base case
- single characters are palindromes
- Lesson 95 — Common Induction MistakesLesson 936 — Longest Palindromic Substring
- Baseball elimination
- Determining which teams can still win a division
- Lesson 1032 — Applications of Maximum Flow
- baseline model
- A baseline model is an intentionally simple approach that establishes minimum acceptable performance.
- Lesson 2784 — Baseline Models and Evaluation
- basic block
- A basic block is a straight-line sequence of instructions with no branches in (except at the entry) and no branches out (except at the exit).
- Lesson 2042 — Control Flow Graphs (CFGs)Lesson 2043 — Basic Blocks and Leaders
- Basically Available
- The system accepts your like immediately, even if other servers haven't updated yet
- Lesson 2699 — The BASE Model: Basically Available, Soft State, Eventual
- Benchmark programs
- Benchmark programs are carefully chosen sets of real or representative programs that everyone runs on their processors to produce comparable performance numbers.
- Lesson 1191 — Benchmark Programs and Performance Testing
- Best case
- O(1) if B is the first neighbor
- Lesson 421 — Separate Chaining: AnalysisLesson 674 — Adjacency List: Operations and Complexity
- Better
- A function that considers all bits of the input evenly
- Lesson 1690 — Hash Function Selection for Indexes
- bias-variance tradeoff
- The bias-variance tradeoff describes how these errors decompose into two competing sources:
- Lesson 2782 — The Bias-Variance Tradeoff
- Big Ball of Mud
- The Big Ball of Mud is a system that has grown organically without any guiding architectural vision.
- Lesson 2308 — Big Ball of Mud Anti-Pattern
- bijective function
- A bijective function is one that is both injective (one-to-one) and surjective (onto).
- Lesson 79 — Function Properties: Bijective
- Binary
- Binary is how routers and network devices actually process addresses
- Lesson 1461 — IPv4 Address Structure and Notation
- Binary Indexed Tree
- A Fenwick tree (also called a Binary Indexed Tree or BIT) is a specialized tree structure that efficiently handles dynamic arrays where you need to:
- Lesson 649 — Fenwick Tree (Binary Indexed Tree) Introduction
- binary min-heap
- A binary min-heap is a tree-based data structure that maintains the smallest element at its root and supports two key operations efficiently:
- Lesson 973 — Dijkstra's with Binary Heap Priority Queue
- binary relation
- A binary relation is simply a subset of that Cartesian product—you pick only the pairs that satisfy some relationship you care about.
- Lesson 67 — Relations as Sets of Ordered Pairs
- Binary Search on Answer Space
- Binary Search on Answer Space means applying binary search to find an optimal value (minimum or maximum) by treating all possible answers as a sorted range and testing whether each candidate answer is feasible.
- Lesson 815 — Binary Search on Answer Space
- Binary Search Tree
- A Binary Search Tree is a binary tree with a crucial ordering rule: for every node, all values in its left subtree must be less than the node's value, and all values in its right subtree must be greater than the node's value.
- Lesson 493 — What is a Binary Search Tree?
- binary semaphore
- A binary semaphore is like a single-key locker for your critical section.
- Lesson 1296 — Mutual Exclusion with Binary Semaphores
- binary tree
- A binary tree is a specialized tree structure where every node has at most two children.
- Lesson 457 — Binary Tree Definition
- Binomial Theorem
- The Binomial Theorem is a powerful formula that tells us how to expand (x + y)ⁿ without multiplying it out the long way.
- Lesson 105 — The Binomial Theorem
- bipartite graph
- A bipartite graph is a graph whose vertices can be divided into two completely separate sets (often called U and V), where every edge connects a vertex from one set to a vertex in the other set—never within the same set.
- Lesson 689 — Bipartite GraphsLesson 703 — BFS for Bipartiteness Testing
- Bison
- YACC (Yet Another Compiler Compiler) was the original Unix tool; Bison is its modern, open-source successor and is largely compatible.
- Lesson 1973 — Parser Generators and YACC/Bison
- bit
- Each binary digit (0 or 1) is called a bit—the smallest unit of data in computing.
- Lesson 1 — What is Binary and Why It Matters
- block
- A block is any section of code surrounded by curly braces {}, such as the body of an if statement, while loop, or for loop.
- Lesson 210 — Block Scope
- blocking
- They must wait (potentially indefinitely) for the coordinator to recover—this is called blocking.
- Lesson 2653 — Two-Phase Commit Protocol
- body
- Imagine ordering at a restaurant: the method is whether you're ordering, paying, or canceling; the URI is the menu item number; headers are dietary preferences or instructions; the body is any customization details.
- Lesson 1515 — HTTP Request StructureLesson 1980 — AST Representation of Function Definitions
- BOM
- A BOM is a special invisible character placed at the very start of a text file to signal:
- Lesson 29 — Byte Order Marks and Endianness
- Boolean
- In computing, a Boolean is the simplest data type—it can only be one of two values: TRUE or FALSE.
- Lesson 13 — Boolean Values and Truth Tables
- bound variable
- A bound variable is one controlled by a quantifier.
- Lesson 53 — Quantifier Scope and Binding
- Bounds checking
- Bounds checking means verifying that an index is within the valid range before accessing it.
- Lesson 264 — String Length and Bounds Checking
- Branch prediction
- Branch prediction is the processor's educated guess about which way a branch will go before it actually executes.
- Lesson 1175 — Introduction to Branch Prediction
- Branch prediction accuracy
- Branch prediction accuracy is expressed as a percentage:
- Lesson 1184 — Branch Prediction Performance Impact
- Breach isolation
- If one service is compromised, your other accounts remain safe
- Lesson 2515 — Password Managers and Best Practices
- breadth-first traversal
- Level-order traversal (also called breadth-first traversal) explores a binary tree by processing all nodes at each depth before moving deeper.
- Lesson 478 — Level-Order Traversal Concept
- broadcast domain
- A broadcast domain is a logical section of a network where any device can send a broadcast message that every other device in that domain will receive.
- Lesson 1456 — Broadcast and Collision Domains
- brute force attack
- An attacker can simply try all 25 possibilities in seconds—a technique called brute force attack.
- Lesson 2397 — The Caesar Cipher
- Bubble sort
- Bubble sort is rarely the best choice in practice, though its optimized version can detect already-sorted input efficiently.
- Lesson 751 — Comparing Elementary Sorts
- buckets
- Bucket sort works by dividing the input range into several intervals called buckets, distributing elements into these buckets based on their values, sorting each bucket individually, and then concatenating all buckets in order.
- Lesson 795 — Bucket Sort: Partitioning the Range
- Build Heap
- Best when heaps are roughly similar in size or you need optimal worst-case performance
- Lesson 598 — Merge Two Heaps
- Builder
- Perfect for constructing complex objects with many optional parameters or configuration steps. Use it when you'd otherwise face telescoping constructors or want a fluent interface. The trade-off is additional builder classes.
- Lesson 2273 — Choosing the Right Creational Pattern
- burst try
- A burst try is a hybrid data structure that combines the best of two worlds: the prefix-sharing efficiency of tries and the cache-friendly compactness of simple arrays or containers.
- Lesson 639 — Burst Tries
- buses
- These paths are typically made of parallel wires called buses that can carry multiple bits simultaneously (e.g., a 32-bit bus carries 32 bits at once).
- Lesson 1079 — Register Transfer and Data Paths
- bypassing
- Data forwarding (also called bypassing) detects when a later instruction needs a value that an earlier instruction just computed but hasn't yet written back.
- Lesson 1169 — Data Forwarding (Bypassing)
- Byzantine failures
- Byzantine failures are far more challenging.
- Lesson 2593 — Node Failures: Crash and Byzantine
C
- cache block
- Instead of making many tiny trips to memory, the cache grabs a whole cache line (also called a cache block) — a fixed-size chunk of contiguous bytes, typically 32, 64, or 128 bytes.
- Lesson 1120 — Cache Lines and Blocks
- Cache effects
- Lock operations themselves are expensive, involving memory barriers and context switches
- Lesson 2576 — Why Thread-Safe Data Structures?
- caches
- Your CPU doesn't fetch data directly from RAM every time—it uses small, ultra-fast memory layers called caches (L1, L2, L3).
- Lesson 805 — Cache-Friendly Sorting Techniques
- Caching
- Caching is storing computed results so you can retrieve them instantly later.
- Lesson 443 — Caching and Memoization
- Caesar cipher
- The Caesar cipher is the most famous example: shift every letter by a fixed number of positions in the alphabet.
- Lesson 2396 — The Substitution Cipher
- Callee-saved
- The called function must preserve these and restore them before returning
- Lesson 2056 — Function Call Code Generation
- Caller-saved
- The calling function must save these before the call if it needs their values afterward
- Lesson 2056 — Function Call Code Generation
- calling convention
- Both sides need to agree on how arguments are passed, where return values go, and which registers can be safely modified—this agreement is called a calling convention.
- Lesson 1104 — Function Parameters and Calling ConventionsLesson 2056 — Function Call Code Generation
- Candidate keys
- Candidate keys are all possible attributes (or combinations) that could serve as primary keys.
- Lesson 1614 — Key Attributes and Identifiers
- canonical cover
- A minimal cover (also called canonical cover) is the simplest equivalent version of your FD set—like reducing a mathematical expression to its simplest form.
- Lesson 1629 — Minimal Cover and Canonical Cover
- capability
- A capability is a protected reference to a resource bundled with specific permissions.
- Lesson 2532 — Capability-Based Security
- capacity
- A cut separates the source from the sink by removing certain edges, and its capacity is the sum of capacities of edges going from the source side to the sink side.
- Lesson 1031 — The Max-Flow Min-Cut Theorem
- Causal consistency
- Causal consistency is weaker than sequential consistency but respects the natural flow of cause and effect.
- Lesson 2613 — Causal Consistency
- Celebrity users
- A social media post from a famous account generates millions of interactions hitting one partition
- Lesson 2690 — Handling Data Skew and Hotspots
- centralized workflow
- The centralized workflow is the most straightforward Git collaboration model.
- Lesson 2194 — Centralized Workflow
- Certificate
- The proposed solution being verified is called a certificate or witness.
- Lesson 1901 — Verifiers and CertificatesLesson 1904 — Examples of Problems in NPLesson 1914 — Verification vs Solution
- Certificate Authority
- A Certificate Authority is a trusted third party that validates server identities before issuing certificates.
- Lesson 1533 — Certificate Authorities and Trust ChainsLesson 2445 — Digital Certificates and Certificate Authorities
- Certificate Repositories
- Databases or directories where valid certificates are published and made accessible to relying parties.
- Lesson 1535 — Public Key Infrastructure (PKI)
- CFGs
- CFGs are like generative recipes — they tell you how to build valid strings step by step through derivations.
- Lesson 1835 — Equivalence of PDAs and Context-Free Grammars
- chain
- In partial orders, a chain is any subset where all elements are comparable.
- Lesson 75 — Total Orders and Chains
- chaining
- Imagine a library where chaining is like books scattered across different buildings (slow to collect).
- Lesson 439 — Cache Performance and Memory LocalityLesson 1691 — Collision Handling in Hash Indexes
- Checking before popping
- Test if the stack is empty before attempting the operation
- Lesson 358 — Pop Operation
- checksum
- A checksum is a numeric summary computed over all the data bits in a frame.
- Lesson 1447 — Error Detection with Parity and Checksums
- checksum verification
- This process is called checksum verification.
- Lesson 2429 — Hash Function Applications: Data Integrity
- child
- A child is a node directly connected to and below another node.
- Lesson 451 — Root, Parent, Child, and Sibling Nodes
- Chomsky Normal Form
- Chomsky Normal Form is a restricted version of context-free grammars where every production follows one of exactly two patterns:
- Lesson 1843 — Chomsky Normal Form
- cipher suite
- A cipher suite is a bundle of cryptographic algorithms that work together to establish a secure TLS connection.
- Lesson 1536 — TLS Cipher SuitesLesson 2448 — Cipher Suites: Negotiating Encryption Algorithms
- Clarity
- calculateDiscount(100.50, "USD") is less clear than calculateDiscount(Money(100.50, Currency.USD))
- Lesson 1554 — Domains and Data TypesLesson 2335 — Primitive Obsession Smell
- Clear mental model
- The code reads like step-by-step instructions
- Lesson 2121 — Imperative Style Tradeoffs
- Client
- The client is the application requesting access to the resource owner's data.
- Lesson 1541 — Socket Fundamentals and Client-Server ModelLesson 2535 — OAuth 2.0 Roles: Resource Owner, Client, Authorization Server
- Clock Cycle Time
- Think of building a house: instruction count is how many tasks you must complete, CPI is how many days each task takes on average, and clock cycle time is the length of your workday.
- Lesson 1185 — CPU Performance Equation Fundamentals
- Clock drift
- Clock drift is how fast that difference changes over time.
- Lesson 2626 — Clock Skew and Clock Drift
- Clock skew
- Clock skew is the instantaneous difference between two clocks at any given moment.
- Lesson 2626 — Clock Skew and Clock Drift
- closure property
- A closure property means that applying certain operations to regular languages always produces another regular language.
- Lesson 1804 — Closure Properties: Star and Complement
- Clustered Index
- Books arranged on shelves by their call number. The index is the organization system. Finding a book by call number means walking directly to its shelf location.
- Lesson 1686 — Clustered vs Non-Clustered B-Tree Indexes
- Clustered indexes
- Clustered indexes are faster for range queries on the indexed column because related rows are physically adjacent—one disk read gets you multiple relevant rows.
- Lesson 1686 — Clustered vs Non-Clustered B-Tree Indexes
- CMS
- CMS is the modern successor to PKCS#7, standardized as RFC 5652.
- Lesson 2440 — Digital Signature Standards and Formats
- co-recognizable
- A language L is called co-recognizable if its complement (the set of all strings not in L) is recognizable by a Turing machine.
- Lesson 1876 — Co-Recognizable Languages
- Coarse-grained locking
- Coarse-grained locking is simple to implement and reason about—just acquire one lock, do your work, release it.
- Lesson 1286 — Lock Granularity and Performance
- Code Generation
- Converting TAC to machine code is mechanical. Each TAC instruction maps cleanly to one or a few machine instructions.
- Lesson 2040 — Three-Address Code (TAC)
- code point
- Unicode was created to give every character from every writing system its own unique number, called a code point.
- Lesson 26 — Unicode: Universal Character Set
- code smell
- A code smell is a surface-level indicator that something might be wrong in your code.
- Lesson 2329 — Introduction to Code Smells
- Codomain
- The entire target set B (what the relation could map to)
- Lesson 67 — Relations as Sets of Ordered Pairs
- Cognitive overhead
- Developers waste time trying to understand whether old code is still relevant.
- Lesson 2307 — Lava Flow Anti-Pattern
- cold-start miss
- A compulsory miss (also called a cold-start miss or first-reference miss) occurs when a program accesses a memory block for the very first time.
- Lesson 1142 — Types of Cache Misses: Compulsory
- collision domain
- A collision domain is a network segment where data packets can collide if two devices transmit simultaneously.
- Lesson 1456 — Broadcast and Collision Domains
- Collision resistance
- Collision resistance is broader: it means finding any pair of different inputs that hash to the same value must be computationally hard—even if you get to choose both inputs freely.
- Lesson 2424 — Collision Resistance
- COMMIT
- COMMIT is the command that tells the database: "I'm done with this transaction, and everything worked correctly.
- Lesson 1656 — Commit and Rollback Operations
- Commit hash
- A long hexadecimal string (like a3f8b21c4d...) that uniquely identifies that commit—think of it as a fingerprint. You typically only need the first 7 characters for most operations.
- Lesson 2175 — Viewing Commit History
- Commit message
- The description you wrote explaining what changed.
- Lesson 2175 — Viewing Commit History
- Compact representation
- One bit per block means minimal storage overhead
- Lesson 1403 — Free Space Management: Bitmaps
- compensating transaction
- A compensating transaction is a separate operation that semantically reverses the effect of a previously committed transaction.
- Lesson 2722 — Compensating Transactions
- Complement
- CFLs are not closed under complement. If they were, combined with union (which they do have), they'd also have intersection (by De Morgan's laws)—which we know they don't.
- Lesson 1848 — Closure Properties of CFLs
- complete binary tree
- A complete binary tree is a binary tree where every level is completely filled, except possibly the last level — and the last level must be filled from left to right with no gaps.
- Lesson 485 — Complete Binary TreesLesson 576 — Complete Binary Tree Property
- complete graph
- A complete graph is a simple graph where every single pair of distinct vertices is connected by exactly one edge.
- Lesson 666 — Complete, Bipartite, and Regular GraphsLesson 688 — Complete Graphs
- Completeness
- Completeness is mandatory (all data must arrive)
- Lesson 1499 — When to Use TCP: Application Scenarios
- Complex Conditionals
- Nested if-statements that are hard to follow
- Lesson 2329 — Introduction to Code Smells
- complexity class
- A complexity class is a collection of problems that can be solved using similar amounts of computational resources.
- Lesson 1888 — Introduction to Complexity Classes
- Computation has inherent limits
- Some problems are fundamentally unsolvable, not just "hard"
- Lesson 1887 — Philosophical and Practical Impact
- computer network
- A computer network is a collection of interconnected devices that can exchange data and share resources.
- Lesson 1431 — Introduction to Computer Networks
- concatenation
- If L₁ and L₂ are CFLs, then L₁L₂ is a CFL. Create a new start symbol: S → S₁S₂.
- Lesson 1758 — String Operations: ConcatenationLesson 1848 — Closure Properties of CFLs
- Concurrency
- Think of it like a restaurant kitchen: concurrency is one chef rapidly switching between chopping vegetables and stirring a pot (progress on multiple tasks).
- Lesson 2544 — Concurrency Defined: Multiple Tasks in ProgressLesson 2545 — Parallelism Defined: Simultaneous ExecutionLesson 2553 — Choosing Between Concurrency and Parallelism
- concurrent operations
- However, operations that aren't causally related—called concurrent operations—can be observed in different orders by different processes.
- Lesson 2613 — Causal Consistency
- Condition
- Condition is checked before each iteration.
- Lesson 180 — Loop Initialization, Condition, and Update
- condition variable
- A condition variable is a synchronization primitive that lets threads:
- Lesson 1304 — Condition Variable Basics
- conditional
- A conditional is a programming structure that lets your code make decisions.
- Lesson 165 — What Are Conditionals?
- configuration
- A configuration is a complete description of the machine at a single point in time, capturing everything needed to continue the computation.
- Lesson 1854 — Turing Machine Configuration
- Conflict detection
- The tool warns about shift-reduce or reduce-reduce conflicts
- Lesson 1973 — Parser Generators and YACC/Bison
- connected component
- In graph terms, a connected component is a group of vertices that can reach each other through edges, but cannot reach vertices in other components.
- Lesson 729 — Connected Components in Undirected GraphsLesson 732 — Counting Connected Components
- connected components
- If a graph is not connected, it splits into separate pieces called connected components.
- Lesson 664 — Connected Graphs and Components
- Connection refused
- The server isn't listening on that port
- Lesson 1550 — Error Handling and Socket Shutdown
- coNP
- In complexity theory, coNP is the class of decision problems whose complements are in NP.
- Lesson 1909 — Complementary Classes: coNP
- Consent
- Consent is the process where the resource owner (the user) explicitly authorizes the client to access specific resources with the requested scopes.
- Lesson 2540 — OAuth 2.0 Scopes and Consent
- Conserve public IPs
- A company with 500 devices might only need one or two public addresses
- Lesson 1465 — Private and Public IP Address Ranges
- Consistency
- But there's a stronger property called consistency (or monotonicity) that goes further: it ensures A* never has to reconsider nodes it's already expanded.
- Lesson 2529 — Policy-Based Access ControlLesson 2639 — Leader-Based ReplicationLesson 2754 — Consistency and Monotonicity
- Consistent formatting
- Consistent formatting means your code follows predictable patterns for indentation, line breaks, spacing around operators, and brace placement.
- Lesson 2313 — Code Formatting and Consistency
- Consolidate Conditional Expressions
- Consolidate Conditional Expressions means combining multiple conditional checks into a single boolean expression or extracting them into a well-named method.
- Lesson 2324 — Consolidate Conditional Expressions
- constant
- In programming, a constant is a variable whose value is set once and can never be changed afterward.
- Lesson 148 — Constants and Immutability
- constructor
- A constructor is a special method that runs automatically when you create a new object.
- Lesson 2125 — Constructors and Initialization
- Consumer
- Lock mutex → check if buffer is empty → if empty, wait on notEmpty condition → remove item → signal notFull → unlock
- Lesson 1310 — Producer-Consumer with Condition Variables
- context-free grammar
- A context-free grammar is formally defined by four elements:
- Lesson 1813 — Context-Free Grammars: Definition and Components
- Continuous adaptation
- The team adjusts their process based on what they learn
- Lesson 2367 — Self-Organizing Teams
- contradiction
- A contradiction is a proposition that is always false, no matter what.
- Lesson 43 — Tautologies and Contradictions
- contrapositive
- Only the contrapositive is logically equivalent to the original statement.
- Lesson 37 — Converse, Inverse, and Contrapositive
- Control flow operations
- For branch or jump instructions, the ALU may compare values to determine if a condition is met, then update the program counter (PC) to point to a new instruction address.
- Lesson 1086 — The Execute Stage
- Convergence
- Convergence means your algorithm successfully reaches a point where gradients are near zero (a minimum).
- Lesson 2821 — Learning Rate and Convergence
- Cookies
- Cookies are small pieces of data that the server sends to your browser in an HTTP response header.
- Lesson 1522 — HTTP Cookies and State ManagementLesson 2497 — Session Management Basics
- Correct interpretation
- the character a followed by zero or more bs (matches: a, ab, abb, etc.)
- Lesson 1774 — Precedence and Parentheses in Regular Expressions
- Correctness
- Correctness means your program produces the right answer.
- Lesson 270 — What is Runtime Analysis?
- correlated subquery
- A correlated subquery is different: it references columns from the outer query, which means it must be re-evaluated for each row processed by the outer query.
- Lesson 1606 — Correlated Subqueries
- counting
- Grouping and counting are optimization strategies that batch information for efficiency.
- Lesson 1405 — Free Space Management: Grouping and Counting
- counting semaphore
- A counting semaphore is initialized to the number of available resources.
- Lesson 1301 — Resource Counting with Counting Semaphores
- CPI
- Think of building a house: instruction count is how many tasks you must complete, CPI is how many days each task takes on average, and clock cycle time is the length of your workday.
- Lesson 1185 — CPU Performance Equation Fundamentals
- CPU utilization
- Think of a restaurant kitchen: CPU utilization is how much of the day your chef is actually cooking (not standing idle), while throughput is how many meals get served to customers per hour.
- Lesson 1245 — CPU Utilization and Throughput
- CPU-bound processes
- CPU-bound processes are computation-heavy—think video encoding, scientific simulations, or cryptographic operations.
- Lesson 1250 — CPU-Bound vs I/O-Bound Processes
- Crash failures
- Crash failures are the simpler, "well-behaved" failure model.
- Lesson 2593 — Node Failures: Crash and Byzantine
- Crashes
- The next malloc() or free() call may read garbage values and crash trying to follow invalid pointers
- Lesson 2090 — Memory Corruption and Buffer Overflows
- Creational patterns
- Creational patterns are design solutions that abstract and manage the object instantiation process.
- Lesson 2264 — Introduction to Creational Patterns
- critical section
- A critical section is a segment of code that accesses shared resources (like variables, files, or data structures) and must not be executed by multiple threads or processes at the same time.
- Lesson 1273 — Critical Sections DefinedLesson 2556 — Critical Sections
- critical sections
- You've seen that race conditions occur when threads interleave unpredictably, and you know that critical sections are code regions that access shared data.
- Lesson 1280 — Mutual Exclusion ProblemLesson 2561 — Synchronized Blocks and Methods
- CRL
- A CRL is a signed list published by a Certificate Authority containing serial numbers of all revoked certificates.
- Lesson 1538 — Certificate Revocation: CRL and OCSP
- Cross edges
- Edges that connect vertices already discovered at the same level or adjacent levels, but not in a parent-child relationship. These edges are "rejected" because they don't lead to new discoveries.
- Lesson 700 — BFS Tree and Parent Tracking
- crossing edge
- Any edge connecting a node from one group to a node in the other is called a crossing edge.
- Lesson 1013 — Cut Property and MST Correctness
- cycle
- A cycle is a closed path in a graph—it starts and ends at the same vertex without repeating any edges.
- Lesson 663 — Cycles and Acyclic Graphs
D
- dangling pointer
- A dangling pointer is a pointer that still holds the address of memory that has been freed.
- Lesson 2088 — Dangling Pointers and Use-After-Free
- data path
- A data path is the physical route data takes as it moves through the CPU.
- Lesson 1079 — Register Transfer and Data Paths
- Database Encryption
- Sensitive database fields (credit cards, medical records) are encrypted with symmetric keys for quick storage and retrieval.
- Lesson 2404 — Symmetric Crypto in Practice: Performance and Use Cases
- Dead Letter Queue
- A Dead Letter Queue is a special holding area for problematic messages.
- Lesson 2712 — Dead Letter Queues and Poison Messages
- decidable language
- A decidable language is one recognized by a TM that always halts—for every input string, the machine eventually reaches an accepting or rejecting state.
- Lesson 1869 — Decidable vs. Undecidable Languages
- decider
- This TM is called a decider because it decides membership in the language.
- Lesson 1868 — What is Decidability?
- decision problem
- A decision problem is any question that has exactly two possible answers: "yes" or "no." Think of it like a light switch—it's either on or off, with no in-between.
- Lesson 1868 — What is Decidability?Lesson 1898 — Decision Problems and Languages
- decision tree
- A decision tree is a hierarchical model that makes predictions by asking a series of questions about feature values.
- Lesson 2838 — Decision Tree Intuition and Structure
- Declaring a variable
- Declaring a variable means officially announcing to the computer: "I'm going to need a box with this name, and here's what kind of data it will hold."
- Lesson 139 — Declaring Variables
- Decompose Conditional
- Decompose Conditional means breaking apart both the condition itself and its result branches into separate methods with intention-revealing names.
- Lesson 2326 — Decompose Conditional: Simplifying Complex If Statements
- Decrement
- The old target's count goes down (you removed a pointer from it)
- Lesson 2105 — Reference Count Operations
- degree of a node
- The degree of a node is simply the number of children that node has.
- Lesson 458 — Degree of a Node and Tree Degree
- degree of a tree
- The degree of a tree is the maximum degree among all nodes in that tree.
- Lesson 458 — Degree of a Node and Tree Degree
- DELETE
- Removing documents by identifier or criteria. Once deleted, the document and its nested data are gone (unless you have backups or soft-delete strategies).
- Lesson 1517 — HTTP Methods: PUT, DELETE, and OthersLesson 1721 — CRUD Operations in Document Databases
- Demand paging
- Demand paging is the strategy of loading pages into physical memory only when they're needed, rather than loading an entire program at startup.
- Lesson 1346 — Page Faults and Demand Paging
- Demultiplexing
- Demultiplexing is the reverse: when UDP datagrams arrive, the OS examines the destination port number in the UDP header and delivers each datagram to the correct application listening on that port.
- Lesson 1488 — UDP Port Numbers and Multiplexing
- Denial of Service
- The "billion laughs attack" uses recursive entity expansion—defining entities that reference each other exponentially—causing the parser to consume massive memory and crash.
- Lesson 2486 — XML External Entity (XXE) Injection
- denormalized
- These are called denormalized or subnormal numbers
- Lesson 1067 — Normalized vs Denormalized Floating-Point Numbers
- deployment pipeline
- A deployment pipeline is an automated sequence of stages that code passes through from commit to production release.
- Lesson 2391 — Deployment Pipelines and Stages
- depth
- In the previous lesson, you learned that a node's depth is its distance from the root, and a node's height is the longest path down to any leaf beneath it.
- Lesson 455 — Tree Height and Level
- Dequeue
- The car at the window gets their order and drives away
- Lesson 376 — Essential Queue Operations
- derivation
- A derivation is a sequence of substitution steps.
- Lesson 1814 — Derivations and Parse Trees
- Design data structures
- The degree constraint affects how you implement tree nodes in code
- Lesson 458 — Degree of a Node and Tree Degree
- Detecting failures
- Deciding if a node is slow or crashed (the partial failure problem you've seen)
- Lesson 2598 — Lack of Global Clock
- Determinism
- A program's execution has exactly one possible outcome. You prove this by showing that if a program can take two different evaluation steps from the same state, those steps must actually lead to the same result. This uses structural induction over your semantic rules.
- Lesson 2026 — Proving Semantic Properties
- Digital Signature
- A digital signature is a cryptographic mechanism that binds a message to its sender, proving both who created it and that it hasn't been altered.
- Lesson 1532 — Digital Certificates FundamentalsLesson 2432 — What are Digital Signatures?
- digraph
- In a directed graph (also called a digraph), edges have a specific direction, shown with arrows.
- Lesson 658 — Directed vs Undirected Graphs
- Direct access
- Finding the status of block n is just a matter of checking bit n
- Lesson 1403 — Free Space Management: Bitmaps
- Direct left recursion
- Direct left recursion is easy to spot: a rule like A → A α | β where the rule name A appears as its own first symbol.
- Lesson 1953 — Left Recursion Problem
- directory
- A directory is a special container in a file system that holds references to files and other directories (called subdirectories).
- Lesson 1411 — Directory Concept and Purpose
- discrete random variable
- A discrete random variable is a numerical outcome of a random process that can only take on countable values.
- Lesson 121 — Discrete Random Variables
- distributed system
- A distributed system is a collection of independent computers that work together to appear as a single coherent system to users.
- Lesson 2588 — What Makes a System Distributed?
- distributed transaction
- A distributed transaction is a transaction that affects data stored on multiple nodes or systems.
- Lesson 2717 — What Are Distributed Transactions?
- division method
- The division method is the simplest and most common hash function technique.
- Lesson 408 — The Division Method
- document store
- A document store is a type of NoSQL database that stores data as self-contained documents rather than rigid rows and columns.
- Lesson 1710 — Document Store Fundamentals
- Domain
- The set of all first elements that actually appear in the relation's pairs
- Lesson 67 — Relations as Sets of Ordered Pairs
- domain of discourse
- The domain of discourse is the set of values x can take (e.g., all integers)
- Lesson 46 — Predicates and Propositional Functions
- dominant term
- The dominant term is the one that "runs fastest" – it grows so much larger than the others that the slower runners become irrelevant.
- Lesson 278 — Growth Rates and Dominant Terms
- Dotted-decimal
- Dotted-decimal is how humans configure and read them
- Lesson 1461 — IPv4 Address Structure and Notation
- Double hashing
- Most resilient, maintaining relatively good performance until the table is nearly full
- Lesson 436 — Open Addressing Performance Characteristics
- Double Submit Cookie Pattern
- The Double Submit Cookie Pattern is a stateless CSRF protection technique that doesn't require server-side session storage.
- Lesson 2469 — Double Submit Cookie Pattern
- downgrade attack
- A user might type http://example.com (without the "s"), giving attackers a window to intercept that first request before redirection to HTTPS occurs—this is called a downgrade attack or SSL stripping.
- Lesson 2453 — HTTPS Best Practices and HSTS
- Drawback
- Requires special hardware and scanning thousands of entries is slow.
- Lesson 1287 — Spin Locks vs Blocking LocksLesson 1371 — LRU Implementation Techniques
- duplicate ACKs
- These duplicate ACKs are like urgent signals saying "I'm still waiting for packet 3!"
- Lesson 1480 — TCP Congestion Control: Fast Retransmit and Fast Recovery
- Duplicate Detection
- The receiver uses sequence numbers to ignore duplicate segments if both the original and retransmitted copy arrive
- Lesson 1476 — TCP Reliability: Retransmission
- Duplication
- The same value scattered across files makes updates error-prone
- Lesson 2323 — Replace Magic Numbers with Named Constants
- Durability
- Durability means that once the queue acknowledges receipt of a message, that guarantee survives crashes and restarts.
- Lesson 2713 — Queue Persistence and Durability
- dynamic dispatch
- This decision happens at runtime (called dynamic dispatch or late binding).
- Lesson 2127 — Method Overriding and Polymorphism
- Dynamic typing
- Dynamic typing means types are checked while the program runs — at execution time.
- Lesson 1997 — Static vs Dynamic Typing Overview
- DynamoDB
- DynamoDB is Amazon's fully managed key-value and document store.
- Lesson 1737 — Popular Key-Value Stores: Redis and DynamoDB
E
- Easier optimization
- The VM can optimize bytecode execution
- Lesson 2033 — Bytecode Compilation: The Hybrid Approach
- Easier to name
- A function doing one task has a clear, descriptive name
- Lesson 193 — Single Responsibility Principle
- edge
- An edge is the link or connection between a parent node and one of its children.
- Lesson 452 — Leaves, Internal Nodes, and Edges
- Edge cases
- Edge cases are unusual inputs that might break your code: empty values, zero, negative numbers, or boundary values.
- Lesson 174 — Common Conditional Patterns
- edge list
- An edge list is the most straightforward way to represent a graph: you literally just list out every edge.
- Lesson 676 — Edge List RepresentationLesson 681 — Representation Trade-offs for Common Operations
- edge relaxation
- In Bellman-Ford, edge relaxation is the fundamental operation that gradually discovers shorter paths.
- Lesson 982 — Edge Relaxation in Bellman-Ford
- edges
- In a graph database, relationships (also called edges) connect two nodes and represent how they're related.
- Lesson 1749 — Relationships and Edge Properties
- effective access time
- The effective access time is the weighted average of all these scenarios based on how often each occurs.
- Lesson 1364 — Effective Access Time with Paging
- Efficiency
- A large data structure can be shared without duplication. Both processes' page tables simply point to the same physical frames.
- Lesson 1349 — Shared Memory via Virtual Memory
- Egyptian fraction
- An Egyptian fraction represents any fraction (like 5/6) as a sum of unit fractions—fractions with 1 in the numerator (like 1/2 + 1/3).
- Lesson 895 — Egyptian Fraction Representation
- elements
- A set is simply a collection of distinct objects, called elements (or members).
- Lesson 58 — Set Fundamentals and Notation
- elliptic curve discrete logarithm problem
- The elliptic curve discrete logarithm problem (ECDLP) is much harder to solve than the traditional discrete logarithm problem.
- Lesson 2414 — Elliptic Curve Cryptography Basics
- Emptiness
- Run a graph search (BFS or DFS) from the start state. If any accepting state is reachable, the language is non-empty. Otherwise, it's empty. Think of it like checking if there's a path to treasure in a maze.
- Lesson 1811 — Decision Properties of Regular Languages
- Empty list
- If tail is NULL, there's nothing to delete.
- Lesson 345 — Deleting from the Tail of a Doubly Linked List
- empty string
- In formal language theory, the empty string is a string containing zero characters.
- Lesson 1757 — The Empty String and String Length
- Enables optimization
- the runtime can parallelize or optimize under the hood
- Lesson 2151 — Declarative Data Transformation
- Endianness
- Endianness describes the order in which bytes are arranged in memory:
- Lesson 29 — Byte Order Marks and Endianness
- entity
- An entity is any distinguishable object or "thing" in the real world that we want to store information about in our database.
- Lesson 1612 — Entities and Entity Sets
- Entity integrity
- Entity integrity means that every row in a table must be uniquely identifiable and actually exist.
- Lesson 1557 — Relational Integrity Constraints
- entity set
- An entity set is a collection of entities that share the same type and attributes.
- Lesson 1612 — Entities and Entity Sets
- Ephemeral keys
- Ephemeral keys are temporary, generated fresh for each TLS session and then discarded
- Lesson 1537 — Perfect Forward Secrecy
- equivalence class
- An equivalence class is the set of all elements related to a particular element by an equivalence relation.
- Lesson 73 — Equivalence Classes and Partitions
- equivalence relation
- An equivalence relation is a relation that satisfies three properties all at once:
- Lesson 72 — Equivalence Relations
- event
- An event is a subset of the sample space—a collection of one or more outcomes we're interested in.
- Lesson 108 — Sample Spaces and Events
- Eventual consistency
- Eventual consistency is a consistency model where, given enough time without new updates, all replicas in a distributed system will converge to the same value.
- Lesson 2697 — Eventual Consistency Definition and MotivationLesson 2699 — The BASE Model: Basically Available, Soft State, Eventual
- Evolution
- The backlog never stops changing. New insights, feedback from working software, and changing business goals all shape it. Items get added, removed, re-prioritized, split, or merged regularly.
- Lesson 2377 — Scrum Artifacts: Product Backlog
- exchange argument
- An exchange argument is a proof technique that validates greedy algorithms.
- Lesson 883 — Exchange Arguments for Correctness
- Exhaustiveness checking
- The compiler ensures you've handled all possible cases
- Lesson 2141 — Pattern Matching
- Expected performance
- The algorithm averages O(n log n) across all possible random choices, regardless of input order
- Lesson 771 — Randomized Quicksort: Avoiding Worst Case
- Expired Certificate
- The certificate's validity period has passed. Like an expired driver's license, it's no longer trusted.
- Lesson 2450 — Certificate Validation and Common Errors
- Explicit casting
- Explicit casting is when you tell the compiler to convert, even if it might lose information.
- Lesson 151 — Type Casting Fundamentals
- Explicit exit
- The thread calls a termination function to stop itself
- Lesson 1238 — Thread Creation and Termination
- Explicit waits
- Explicit waits are targeted: "Wait for this specific condition to be true." For example, wait until a button becomes clickable, a loading spinner disappears, or an API promise resolves.
- Lesson 2252 — Handling Asynchronous Operations
- expression
- An expression is a combination of values, variables, and operators that a computer evaluates to produce a single result.
- Lesson 153 — What is an Expression?
- external mergesort
- The most common approach is called external mergesort, which can handle arbitrarily large datasets as long as you have enough disk space for temporary files.
- Lesson 807 — External Sorting for Large Datasets
- external path length
- The external path length is the sum of the depths of all external nodes (leaves or null children).
- Lesson 490 — Path Length Properties
- Extract Method
- Extract Method is the same principle for code.
- Lesson 2319 — Extract Method: Breaking Down Complex Functions
- Extract Variable
- Extract Variable means capturing a sub-expression's result in a well-named local variable.
- Lesson 2322 — Extract Variable: Explaining Complex Expressions
- Extract-min
- Called V times, each O(log V) → O(V log V) total
- Lesson 973 — Dijkstra's with Binary Heap Priority Queue
F
- F1 Score
- The harmonic mean of precision and recall. Use when you need a balanced view of both, especially with imbalanced classes.
- Lesson 2804 — Performance Metrics Selection
- fact
- A fact is a basic statement that declares something unconditionally true.
- Lesson 2158 — Prolog Syntax: Facts and Rules
- Facts
- Basic truths (parent(alice, bob) means Alice is Bob's parent)
- Lesson 2157 — What is Logic Programming?
- Fast sequential access
- Reading the entire file is blazingly fast because the disk head moves smoothly across consecutive blocks without seeking elsewhere.
- Lesson 1399 — File Allocation Methods: Contiguous
- Fast thread operations
- Creating, destroying, and switching between user threads is extremely quick because it doesn't require expensive system calls or kernel mode transitions.
- Lesson 1234 — Multithreading Models: Many-to-One
- Faster traversal
- Skipping over single-child chains means fewer pointer dereferences
- Lesson 631 — Compressed Tries (Radix Trees)
- FCFS
- FCFS is simple with no starvation, but suffers from poor average waiting time (convoy effect) when long processes arrive first.
- Lesson 1261 — Comparing Scheduling Algorithm Performance
- Feature independence
- Logistic regression assumes features aren't highly correlated with each other (no multicollinearity). When features are redundant, coefficients become unstable and interpretation suffers—imagine trying to credit separate contributions when two features always move together.
- Lesson 2837 — Assumptions and Limitations of Logistic Regression
- Feedback comes late
- stakeholders don't see working software until near the end, when changes are most costly
- Lesson 2354 — Waterfall Strengths and Limitations
- feedback delay
- The feedback delay is Waterfall's Achilles heel: discovering a misunderstood requirement in the testing phase might mean redoing months of design and development work.
- Lesson 2354 — Waterfall Strengths and Limitations
- Fenwick trees
- Fenwick trees are remarkably simpler to code.
- Lesson 655 — Fenwick Tree vs Segment Tree Trade-offs
- fetch stage
- The fetch stage is the first step of the instruction cycle where the CPU grabs the next instruction from memory.
- Lesson 1082 — The Fetch Stage
- FIFO
- FIFO is simpler but can evict frequently-used blocks just because they're old.
- Lesson 1123 — Cache Replacement Policies Overview
- File and Disk Encryption
- Tools like BitLocker and FileVault use AES to encrypt entire hard drives. Speed is critical here—you don't want your computer crawling every time you read a file.
- Lesson 2404 — Symmetric Crypto in Practice: Performance and Use Cases
- File Disclosure
- An attacker can read arbitrary files from the server by referencing them as external entities (like /etc/passwd on Linux systems).
- Lesson 2486 — XML External Entity (XXE) Injection
- Fine-grained control
- You decide precisely how memory is used and modified
- Lesson 2121 — Imperative Style Tradeoffs
- fine-grained locking
- This allows producers and consumers to work simultaneously without blocking each other—a technique called fine-grained locking.
- Lesson 2579 — Concurrent Queue: Linked List Implementation
- fine-grained tests
- In TDD, fine-grained tests are small and laser-focused—each verifies exactly one logical behavior or outcome.
- Lesson 2258 — Test Granularity in TDD
- Finiteness
- A DFA accepts infinitely many strings if and only if there's a cycle (loop) on some path from the start state to an accepting state. Use cycle detection on the reachable portion of the graph. If you can loop back while still reaching acceptance, you can "pump" strings infinitely.
- Lesson 1811 — Decision Properties of Regular Languages
- firstName
- even a single variable is an expression! It evaluates to whatever value is stored in that variable
- Lesson 153 — What is an Expression?
- Fixtures
- Fixtures are pre-defined data sets you can reuse across tests.
- Lesson 2253 — Test Data Management
- Flexibility
- You can change how data is stored internally without affecting external code
- Lesson 1349 — Shared Memory via Virtual MemoryLesson 2123 — Encapsulation and Information Hiding
- floating-point numbers
- These are called floating-point numbers, and computers store them using special data types.
- Lesson 141 — Floating-Point Data Types
- flow
- The flow is a function f(u, v) on edges that represents how much is actually flowing through each edge, subject to two key rules:
- Lesson 1022 — Flow Networks and Definitions
- Flow control
- Preventing a fast sender from overwhelming a slow receiver
- Lesson 1434 — OSI Layer 2: Data Link Layer
- flow network
- A flow network is a directed graph designed to model the movement of "stuff" (water, data, traffic, goods) from a starting point to an ending point.
- Lesson 1022 — Flow Networks and Definitions
- Forced termination
- Another thread cancels it (though this is risky)
- Lesson 1238 — Thread Creation and Termination
- foreign key
- A foreign key is a column (or set of columns) in one table that references the primary key of another table.
- Lesson 1556 — Foreign Keys and References
- formal language
- In the theory of computation, a formal language is simply a set of strings built from a particular alphabet.
- Lesson 1760 — Languages as Sets of Strings
- Frames
- The Data Link Layer sits directly above the Physical Layer and transforms raw bit streams into meaningful, error-checked chunks of data called frames.
- Lesson 1352 — Pages and FramesLesson 1434 — OSI Layer 2: Data Link Layer
- Full Outer Join
- A Full Outer Join is the union of a Left Outer Join and a Right Outer Join.
- Lesson 1581 — Full Outer Join
- Full scan required
- The database must check every bucket or fall back to scanning the entire table
- Lesson 1693 — Range Query Limitations
- function
- A function is a special kind of relation that assigns exactly one output to each input.
- Lesson 76 — Definition and Notation of FunctionsLesson 185 — What is a Function?
- Function inlining
- Function inlining is an optimization where the compiler replaces a function call with the actual body of the function.
- Lesson 2069 — Inlining Functions
- function signature
- A function signature is the complete declaration showing its parameter types and return type—think of it as a contract that promises what the function accepts and produces.
- Lesson 206 — Function Signatures and ContractsLesson 1995 — Type Annotations and Signatures
- function type
- A function type describes the transformation a function performs by specifying two things:
- Lesson 1992 — Function Types
- functional dependency
- A functional dependency (FD) describes a relationship between attributes in a table where one attribute (or set of attributes) uniquely determines another attribute.
- Lesson 1621 — Introduction to Functional Dependencies
- functor
- A functor is any type that holds a value (or values) and provides a way to apply a function to what's inside while preserving the outer structure.
- Lesson 2142 — Functors and Mappable Types
- Fuzzing input fields
- Fuzzing input fields means submitting carefully crafted XSS payloads to every user input point: forms, URL parameters, HTTP headers, even cookie values.
- Lesson 2463 — Testing and Detecting XSS Vulnerabilities
G
- G₂
- Two graphs G₁ and G₂ are isomorphic if there exists a one-to-one correspondence (mapping) between their vertices that preserves all edge connections.
- Lesson 668 — Graph Isomorphism
- Game Boards
- Think of a chess board or tic-tac-toe grid. A 2D array maps perfectly to this layout, where board[row][col] represents each square's state (empty, X, O, or which chess piece occupies it).
- Lesson 249 — Practical Applications of Multidimensional Arrays
- Gang scheduling
- Gang scheduling is a CPU scheduling strategy that schedules all threads belonging to the same parallel application (a "gang") to run simultaneously across multiple CPUs.
- Lesson 1267 — Gang Scheduling
- general binary tree
- A general binary tree is simply any tree where each node has at most two children—there are no rules about what values go where.
- Lesson 495 — BST vs General Binary Trees
- git pull
- git pull is a two-step operation: it fetches changes from the remote and immediately merges them into your current branch.
- Lesson 2203 — Synchronizing with Remotes
- global variable
- A global variable is a variable you declare outside of any function.
- Lesson 209 — Global Variables
- Good distribution
- Keys should spread data evenly across partitions. Using user_id often works well; using country might create hotspots if most users are from one country.
- Lesson 2685 — Partition Keys and Shard Keys
- Good state definitions
- Good state definitions are minimal yet complete.
- Lesson 920 — State Definition and Transitions
- gradient
- The gradient is a mathematical term for the slope (or direction of steepest ascent) of your loss function with respect to your model parameters.
- Lesson 2819 — Gradient Descent Basics
- graph
- A graph is a data structure consisting of two components:
- Lesson 657 — What is a Graph? Vertices and Edges
- Greater branch misprediction penalty
- A wrong guess wastes more in-progress work
- Lesson 1156 — Deeper Pipelines: Benefits and Costs
- Greedy
- Greedy is like grabbing clothes in order of preference until your bag is full — works if items are small and you just want maximum value.
- Lesson 912 — Greedy vs Dynamic Programming Decision
- greedy choice property
- The greedy choice property is the key trait that tells you a problem can be solved greedily.
- Lesson 879 — The Greedy Choice Property
- Group
- A set of users who share access (e.g., a project team)
- Lesson 1392 — File Permissions and Access Control
- guard clause
- A guard clause is an early return statement that handles an exceptional or boundary case immediately.
- Lesson 2325 — Replace Nested Conditionals with Guard Clauses
H
- handle
- In bottom-up parsing, a handle is a substring of the current input that matches the right-hand side of a production rule and can be safely reduced back to its left-hand side non-terminal.
- Lesson 1961 — Handles and Viable Prefixes
- happens-before relationship
- The happens-before relationship is a formal guarantee in the Java Memory Model that defines when changes made by one thread are guaranteed to be visible to another thread.
- Lesson 2564 — Happens-Before Relationship
- Hard affinity
- The process is locked to specific CPUs and will never run elsewhere. System administrators or applications can explicitly set hard affinity (e.g., binding a critical database process to cores 0-3).
- Lesson 1265 — Processor Affinity
- hard link
- A hard link is an additional directory entry that points directly to the same inode as the original file.
- Lesson 1419 — Hard Links vs Symbolic Links
- Harder to balance
- More stages means more potential bottlenecks
- Lesson 1156 — Deeper Pipelines: Benefits and Costs
- hash
- A hash function is a mathematical algorithm that takes an input of any size—a single character, a document, or an entire movie file—and transforms it into a fixed-size output called a hash or digest.
- Lesson 2420 — What is a Hash Function?
- hash function
- A hash function is a mathematical algorithm that takes an input of any size—a single character, a document, or an entire movie file—and transforms it into a fixed-size output called a hash or digest.
- Lesson 405 — What is a Hash Function?Lesson 2420 — What is a Hash Function?
- Hash function overhead
- A complex hash that reduces collisions might actually slow things down
- Lesson 441 — Benchmarking and Practical Performance
- hazard detection unit
- A hazard detection unit is a dedicated hardware component that constantly monitors instructions flowing through the pipeline to catch potential hazards before they cause errors.
- Lesson 1174 — Hazard Detection Unit Design
- head pointer
- The head pointer is a special pointer variable that always points to the very first node in your list.
- Lesson 326 — Head Pointer and Empty Lists
- head-of-line blocking
- However, TCP has a limitation called head-of-line blocking: if one packet is lost, all subsequent packets must wait for retransmission, even if they belong to completely independent streams.
- Lesson 1527 — HTTP/3 and QUIC
- headers
- Imagine ordering at a restaurant: the method is whether you're ordering, paying, or canceling; the URI is the menu item number; headers are dietary preferences or instructions; the body is any customization details.
- Lesson 1515 — HTTP Request Structure
- Heap
- While the stack handles short-lived, predictable data tied to function lifetimes, the heap is a separate memory region designed for dynamic allocation—memory you request at runtime when you don't know size or lifetime in advance.
- Lesson 322 — Dynamic Memory Allocation BasicsLesson 610 — Heap as Priority Queue ImplementationLesson 2078 — Heap Memory Fundamentals
- heapify-down
- Downward bubbling (also called heapify-down or sift-down) fixes this by repeatedly swapping the misplaced element with its larger child (in a max-heap) or smaller child (in a min-heap) until it finds its proper position.
- Lesson 590 — Downward Bubbling (Heapify-Down)
- height
- In the previous lesson, you learned that a node's depth is its distance from the root, and a node's height is the longest path down to any leaf beneath it.
- Lesson 455 — Tree Height and LevelLesson 521 — BST Height and Balance
- height of the entire tree
- The height of the entire tree is simply the height of the root node—the longest path from root to any leaf.
- Lesson 454 — Node Depth and Height
- helper function
- A helper function is an inner or separate function that takes extra parameters (called accumulators) to carry partial results forward, eliminating the need for work after the call.
- Lesson 229 — Helper Functions in Recursion
- Hidden intent
- The method's true purpose becomes obscured by implementation details.
- Lesson 2330 — Long Method Smell
- High bias
- The model makes systematic errors due to wrong assumptions
- Lesson 2809 — What is Underfitting?
- High cohesion
- High cohesion means each module focuses on a single, well-defined responsibility.
- Lesson 2318 — Code Organization and Module Structure
- High contention
- A waiting queue is more efficient than spinning retries
- Lesson 2574 — Performance Characteristics of Lock-Free Algorithms
- High-dimensional data
- The "curse of dimensionality" makes all points seem equally far apart, rendering distance meaningless
- Lesson 2872 — KNN in Practice: Applications and Limitations
- High-volume social media feeds
- If a "like" count is briefly inconsistent between users, that's often acceptable. Relaxing Isolation here means thousands more transactions per second.
- Lesson 1665 — ACID Tradeoffs and Real-World Implications
- Higher term wins
- If a node receives a message with a higher term, it immediately updates its own term and reverts to follower state. Its information is outdated.
- Lesson 2660 — Terms and the Logical Clock in Raft
- higher-order function
- A higher-order function is a function that either:
- Lesson 2133 — First-Class and Higher-Order Functions
- highest information gain
- The feature with the highest information gain is the best choice for splitting, because it reduces uncertainty the most.
- Lesson 2843 — Information Gain
- highest-priority interrupt
- The highest-priority interrupt is handled first
- Lesson 1213 — Interrupt Priority and Masking
- Hindley-Milner type system
- The Hindley-Milner type system (often called HM) is a powerful type inference algorithm that can determine the most general type for any expression in your program automatically.
- Lesson 2009 — Hindley-Milner Type System
- hit rate
- The hit rate is the percentage of times the CPU finds what it needs in the faster memory level without having to go further down the hierarchy.
- Lesson 1114 — Hit Rate and Miss PenaltyLesson 1125 — Measuring Cache Effectiveness
- Hoare Partition Scheme
- The Hoare Partition Scheme is an alternative to Lomuto's approach.
- Lesson 766 — Hoare Partition Scheme
- host
- A host is any device on the network that can send or receive data.
- Lesson 1431 — Introduction to Computer Networks
- hybrid integration testing
- Sandwich integration testing (also called hybrid integration testing) merges the top-down and bottom-up approaches you've already learned.
- Lesson 2240 — Sandwich Integration Testing
- hypothesis space
- In machine learning, the hypothesis space is the complete set of functions (hypotheses) that your chosen algorithm could possibly learn from the training data.
- Lesson 2778 — The Hypothesis Space
I
- ID token
- In OpenID Connect (the identity layer built on OAuth 2.0), an ID token is a security token that contains information about the authenticated user.
- Lesson 2542 — ID Tokens and JWT Structure in OpenID Connect
- identifying relationship
- The relationship connecting a weak entity to its owner is called an identifying relationship.
- Lesson 1619 — Weak Entities and Identifying Relationships
- If-Else
- An IfNode contains three children: the condition (expression AST), the "then" branch (statement or statement list), and optionally an "else" branch.
- Lesson 1979 — AST Representation of Statements
- Images and Graphics
- Digital images are grids of pixels. A 2D array can store grayscale values (one number per pixel), while a 3D array handles color images—image[row][col][channel] where channels represent red, green, and blue values.
- Lesson 249 — Practical Applications of Multidimensional Arrays
- Immutability
- Immutability is the broader idea that once something is created, it cannot be altered.
- Lesson 148 — Constants and ImmutabilityLesson 2132 — Pure Functions and Immutability
- Implementation
- The underlying data structure (array, linked list, etc.) and algorithms used
- Lesson 355 — What is an Abstract Data Type (ADT)?
- implicit conversion
- This is called implicit conversion or coercion.
- Lesson 162 — Type Conversion in Expressions
- in-place algorithm
- An in-place algorithm is one that modifies the input data structure directly, using only a constant amount of extra memory—that is, O(1) auxiliary space.
- Lesson 309 — In-Place Algorithms
- In-place sorting
- In-place sorting is quicksort's biggest win—it uses O(log n) extra space (just for recursion), not O(n) like mergesort.
- Lesson 774 — Quicksort vs Mergesort: Practical Comparison
- incidence matrix
- An incidence matrix is an alternative way to store graph structure.
- Lesson 679 — Incidence Matrix Representation
- Increment
- The Increment is the sum of all completed Product Backlog items at the end of a sprint, integrated with all previous increments.
- Lesson 2105 — Reference Count OperationsLesson 2378 — Scrum Artifacts: Sprint Backlog and Increment
- Indexed columns match query predicates
- The query filters or sorts on indexed columns
- Lesson 1702 — Index Selection for Queries
- induced subgraph
- An induced subgraph is created by selecting specific vertices and automatically including all edges between those selected vertices that existed in the original graph.
- Lesson 667 — Subgraphs, Induced Subgraphs, and Spanning Subgraphs
- Infer overly general types
- The principal type might be correct but not what the programmer intended
- Lesson 2014 — Type Inference Limitations
- inference rule
- In logic, an inference rule is a pattern that lets you conclude something new from existing facts.
- Lesson 44 — Logical Inference Rules
- infinite loop
- An infinite loop is a loop that never stops executing because its condition never becomes false.
- Lesson 178 — Infinite Loops and Termination
- Infinity
- Infinity represents values too large to fit in the available floating-point range.
- Lesson 1068 — Special Floating-Point Values: Infinity and NaN
- Infix evaluation
- Infix evaluation is trickier because of precedence (multiplication before addition) and parentheses.
- Lesson 365 — Expression Evaluation: Infix, Prefix, Postfix
- initial state
- The initial state is your problem's starting configuration—the exact snapshot of the world before you've made any moves.
- Lesson 2728 — Initial State and Goal States
- Initialization
- Initialization means assigning a variable its first value at the moment you declare it.
- Lesson 145 — Variable Initialization
- Inline Method
- Inline Method is the reverse of Extract Method: you take the body of a trivial method and put it directly into the calling code, removing the middleman.
- Lesson 2320 — Inline Method: Removing Unnecessary Indirection
- Inner loop
- Examines all E edges (where E is the total number of edges)
- Lesson 986 — Bellman-Ford Time Complexity
- Insertion sort
- For these, Insertion Sort is actually faster because it has lower overhead and works well on nearly-sorted or very small data.
- Lesson 751 — Comparing Elementary SortsLesson 759 — Optimizing MergesortLesson 800 — Hybrid Sorting Strategies
- Instance
- Instance is the actual data stored in the database at a specific point in time.
- Lesson 1553 — Schemas and Instances
- Instruction Count
- Think of building a house: instruction count is how many tasks you must complete, CPI is how many days each task takes on average, and clock cycle time is the length of your workday.
- Lesson 1185 — CPU Performance Equation Fundamentals
- Integrity binding
- The hash cryptographically binds the signature to the exact message content
- Lesson 2436 — Hash-then-Sign Paradigm
- Integrity constraints
- Integrity constraints are the database's enforcers: they're rules baked into your schema that automatically reject operations violating those invariants.
- Lesson 1659 — Integrity Constraints and Consistency
- Interface
- An interface describes what operations a data structure provides without dictating how they work internally.
- Lesson 355 — What is an Abstract Data Type (ADT)?Lesson 377 — Queue Interface and Specification
- Interfaces
- Interfaces are pure contracts with no implementation at all; they just declare method signatures that any implementing class must provide.
- Lesson 2128 — Abstract Classes and Interfaces
- internal path length
- The internal path length is the sum of the depths of all internal nodes (non-leaves).
- Lesson 490 — Path Length Properties
- Interpretable
- Fewer active features means easier understanding
- Lesson 2811 — L1 Regularization (Lasso)
- interrupt
- An interrupt is a signal that temporarily stops the CPU from whatever it's currently executing so it can handle something urgent.
- Lesson 1209 — What Are Interrupts?Lesson 1214 — System Calls vs Interrupts: Comparison
- Interrupts
- Interrupts are asynchronous and often external.
- Lesson 1214 — System Calls vs Interrupts: Comparison
- Intersection
- The intersection of two CFLs is not always context-free. For example, {aⁿbⁿcⁿ | n ≥ 0} can be expressed as the intersection of two CFLs, but it's not itself context-free (it requires coordinating three counters simultaneously).
- Lesson 1848 — Closure Properties of CFLs
- Intrusion detection systems
- Aho-Corasick is ideal—scan once for thousands of malicious signatures simultaneously.
- Lesson 840 — String Searching Applications and Tradeoffs
- Isolation
- Isolation is the database property that prevents this chaos by ensuring concurrent transactions execute as if they're running alone, even when they're actually overlapping in time.
- Lesson 1660 — Isolation: Concurrent Transaction Independence
- iteration
- Each iteration is a complete mini-project: plan, design, code, test, and deliver.
- Lesson 2356 — Iterative and Incremental Development
J
- Jenkins
- The veteran of CI/CD tools, Jenkins is an open-source automation server that runs on your own infrastructure.
- Lesson 2394 — CI/CD Tools and Infrastructure
- join
- A join is an SQL operation that combines rows from two or more tables based on a related column between them.
- Lesson 1576 — What is a Join?
- judgment
- A judgment is a statement we're trying to prove, like:
- Lesson 2019 — Semantic Rules and Judgments
K
- k-regular graph
- A k-regular graph means every vertex has exactly k edges
- Lesson 666 — Complete, Bipartite, and Regular Graphs
- kernel mode
- Think of it like a high-security building: kernel mode is the master key held by maintenance staff (the OS kernel), granting access to every room, the electrical panel, and fire systems.
- Lesson 1194 — OS Kernel and User Space
- Kernel Threads
- Kernel Threads are created, scheduled, and managed directly by the operating system kernel.
- Lesson 1233 — User Threads vs Kernel Threads
- Key attributes
- Key attributes are special attributes whose values uniquely identify each entity.
- Lesson 1614 — Key Attributes and Identifiers
- key-value store
- A key-value store is the simplest type of NoSQL database.
- Lesson 1711 — Key-Value Store FundamentalsLesson 1728 — Key-Value Store Data Model
- Key-value stores
- Key-value stores are the simplest NoSQL type: they map unique keys to values, like a giant hash table.
- Lesson 1709 — The Four Main NoSQL Categories
- keys and shards
- Instead of mapping keys directly to shard numbers, both keys and shards are hashed to positions on this ring.
- Lesson 2688 — Consistent Hashing
- Kleene plus L⁺
- The Kleene plus L⁺ is similar but excludes the empty string—it requires at least one concatenation:
- Lesson 1762 — Kleene Star and Plus on Languages
- Kleene Star
- If L is a CFL, then L* is also a CFL. Use the production: S → SS₁ | ε.
- Lesson 1848 — Closure Properties of CFLs
- KMP
- Builds prefix function in O(m) time where m is pattern length—worth it for multiple searches
- Lesson 840 — String Searching Applications and Tradeoffs
L
- label
- A label is an optional name for a memory location, marking a spot in your program you might want to jump to or reference.
- Lesson 1093 — Assembly Language Syntax and Structure
- language
- A language is a set of strings, and operations like concatenation let us describe how to build complex languages from simpler ones—essential for understanding regular expressions and formal grammars.
- Lesson 1758 — String Operations: Concatenation
- Large Class
- A Large Class is a code smell where a single class has grown too large—either with too many fields, too many methods, or both—because it's trying to handle multiple responsibilities at once.
- Lesson 2331 — Large Class Smell
- Lasso
- L1 regularization, also known as Lasso (Least Absolute Shrinkage and Selection Operator), is a technique that modifies your loss function by adding a penalty based on the absolute values of your model's weights.
- Lesson 2811 — L1 Regularization (Lasso)
- Late defect discovery
- Integration bugs only surface after everything is built
- Lesson 2236 — Big Bang Integration Strategy
- Latency
- Latency is the delay before data begins to transfer—the time it takes for a single bit to travel from source to destination.
- Lesson 1444 — Bandwidth and Throughput
- Law of Demeter violation
- This is called a Law of Demeter violation (also known as the "principle of least knowledge").
- Lesson 2339 — Message Chains Smell
- layered operating system
- A layered operating system is structured like a cake with multiple tiers.
- Lesson 1198 — Layered Operating System Structure
- lazy learning algorithm
- KNN is called a lazy learning algorithm (or instance-based learning) because:
- Lesson 2869 — Computational Complexity of KNN
- Lazy propagation
- Lazy propagation is a clever optimization: instead of immediately updating all nodes in a range, we mark only the necessary nodes with a "pending update" and defer the actual work until those nodes are accessed later (during queries or future updates).
- Lesson 646 — Range Update with Lazy Propagation
- Leader election
- Leader election is the process by which nodes in a distributed system agree on a single coordinator (the "leader") without external help.
- Lesson 2655 — Leader Election Basics
- leaf
- A node with no children is called a leaf node.
- Lesson 451 — Root, Parent, Child, and Sibling Nodes
- Left child
- stores strings where the current character is less than this node's character (alphabetically earlier)
- Lesson 637 — Ternary Search Trees
- legal transitions
- Understanding these legal transitions is crucial for grasping how an operating system manages running programs.
- Lesson 1221 — Process State Transitions
- let-polymorphism
- In the Hindley-Milner type system (which you just learned), let-polymorphism is a special rule that allows variables bound in let expressions to have polymorphic types automatically.
- Lesson 2013 — Let-Polymorphism
- Lexemes
- Lexemes are the actual strings found in the source code (like count, 42, or +)
- Lesson 1939 — Tokens, Lexemes, and Patterns
- Lexical scope
- Lexical scope means a function can access variables from the environment where it was defined, not where it's called.
- Lesson 2137 — Closures and Lexical Scope
- Lifetime
- Its lifetime is from when the crew builds it before a scene until they tear it down after that scene ends.
- Lesson 212 — Variable Lifetime BasicsLesson 215 — Scope and Lifetime: The Key Difference
- linear recurrence
- A linear recurrence is a sequence where each term is a linear combination of previous terms.
- Lesson 961 — Matrix Exponentiation for Linear Recurrences
- link
- A link is the physical or logical connection between nodes.
- Lesson 1431 — Introduction to Computer Networks
- link bundling
- Link aggregation (also called link bundling, trunking, or bonding) is a technique where you take multiple physical Ethernet cables between two switches and treat them as one unified, high-capacity link.
- Lesson 1460 — Link Aggregation
- linked list
- A linked list is a data structure where elements (called nodes) are scattered in memory, each pointing to the next one through pointers.
- Lesson 324 — Introduction to Linked Lists
- Liveness
- Liveness means "something good eventually happens." In Paxos, liveness means the protocol eventually reaches consensus and terminates.
- Lesson 2649 — Safety and Liveness PropertiesLesson 2650 — The FLP Impossibility ResultLesson 2655 — Leader Election BasicsLesson 2680 — Paxos Safety and Liveness Properties
- Living specification
- The code itself (when clean and well-structured) demonstrates what the system actually does
- Lesson 2363 — Working Software Over Comprehensive Documentation
- load factor
- The load factor is a simple ratio that tells you how full your hash table is:
- Lesson 428 — Load Factor and Rehashing
- load-use hazard
- A load-use hazard is a special, unavoidable type of data hazard that happens when:
- Lesson 1170 — Forwarding Paths and LimitationsLesson 1171 — Load-Use Hazards
- local variables
- You already know that local variables are born when a function is called and die when it returns.
- Lesson 214 — Static Lifetime Variables
- Locality of Reference
- Locality of Reference is the observation that programs tend to access a relatively small portion of their address space at any given time.
- Lesson 1109 — Locality of Reference
- lock
- A lock is a synchronization primitive that controls access to shared resources.
- Lesson 1281 — Lock Semantics and Acquire/Release
- lock contention
- With many CPUs competing for the same lock, they spent more time waiting for each other than actually scheduling work—a phenomenon called lock contention.
- Lesson 1266 — Per-CPU Run Queues
- lock coupling
- Hand-over-hand locking (also called lock coupling) works like a cautious climber on a rope bridge: you never let go of one handhold until you've firmly grasped the next.
- Lesson 2584 — Concurrent Lists: Hand-Over-Hand Locking
- logical address
- In segmentation, a logical address consists of two parts:
- Lesson 1380 — Logical Address Translation in Segmentation
- Logical conjunction
- Logical conjunction is the formal name for the AND operation you've already seen with logic gates.
- Lesson 33 — Logical Conjunction (AND)
- Lomuto partition scheme
- The Lomuto partition scheme is a straightforward way to perform the partition operation in Quicksort.
- Lesson 765 — Lomuto Partition Scheme
- Long Method
- A Long Method is a code smell where a single function or method tries to do too much, making it difficult to understand at a glance.
- Lesson 2330 — Long Method Smell
- Longest Increasing Subsequence
- The Longest Increasing Subsequence is the longest such subsequence you can find.
- Lesson 926 — Longest Increasing Subsequence (LIS)
- Lookahead
- Lookahead means examining the next character(s) without consuming them.
- Lesson 1944 — Longest Match and Lookahead
- Lookup time
- Must compare the tag against multiple entries simultaneously (or sequentially, which is slower)
- Lesson 1136 — Associativity Impact on Conflict Misses
- loop
- A loop is a control structure that repeats a block of code multiple times based on a condition.
- Lesson 175 — What is a Loop?
- Loops
- A WhileNode has a condition and a body (statements to repeat). Similarly, ForNode structures hold initialization, condition, increment, and body.
- Lesson 1979 — AST Representation of Statements
- Loose coupling
- Loose coupling means modules depend minimally on each other's internal details.
- Lesson 2318 — Code Organization and Module Structure
- Lost knowledge
- The longer dead code remains, the harder it becomes to determine its original purpose or whether it's safe to remove.
- Lesson 2307 — Lava Flow Anti-Pattern
- Low cardinality estimation
- The optimizer estimates few rows will match
- Lesson 1702 — Index Selection for Queries
- lowbit
- The key operation is called lowbit (or LSB - least significant bit).
- Lesson 650 — Binary Representation and Index Manipulation
- Lower overhead
- Doesn't require as many kernel threads as there are user threads (unlike one-to-one)
- Lesson 1236 — Multithreading Models: Many-to-Many
- Lower term rejected
- Messages with lower terms are ignored—they're from the past.
- Lesson 2660 — Terms and the Logical Clock in Raft
- Lower threshold
- If page faults are rare, the process has more memory than it needs. The OS can reclaim some frames for other processes.
- Lesson 1376 — Page Fault Frequency
- Lowering
- Lowering is the process of translating IR from a higher abstraction level to a lower one.
- Lesson 2048 — Lowering Through Multiple IR Levels
- LSD
- LSD is simpler: sort all elements at each digit position, always processing the complete array.
- Lesson 793 — Radix Sort: LSD vs MSD
M
- machine code
- But your CPU doesn't understand text—it only understands binary patterns called machine code.
- Lesson 1105 — Assembly to Machine Code Translation
- Maintenance nightmares
- Future developers (including you) struggle to modify code whose purpose is unclear
- Lesson 2306 — Cargo Cult Programming Anti-Pattern
- Mandatory locking
- Mandatory locking is enforced by the operating system itself.
- Lesson 1393 — File Locking Mechanisms
- Manhattan
- Manhattan is more robust to outliers and works better in high-dimensional spaces
- Lesson 2864 — Distance Metrics for KNN
- Manhattan distance
- Relax the rule that tiles must slide legally. Pretend each tile can teleport directly to its goal position. Count the total distance all tiles must travel. This "teleportation version" is easier, so its cost underestimates the real sliding cost.
- Lesson 2755 — Designing Admissible Heuristics
- many-one reduction
- In complexity theory, a mapping reduction (also called a many-one reduction) is a technique where you convert every instance of problem A into an instance of problem B using a transformation function.
- Lesson 1929 — Mapping Reductions
- matchIndex
- The highest log entry known to be replicated on that follower
- Lesson 2665 — Log Replication: AppendEntries Basics
- matching
- A matching is a set of edges with no shared vertices—each vertex is paired at most once.
- Lesson 1047 — Maximum Bipartite Matching Algorithm
- Matrices
- Matrices are perfect for computation and finding properties
- Lesson 68 — Representing Relations
- matrix
- A matrix is simply a rectangular grid of numbers arranged in rows and columns—exactly what a 2D array represents!
- Lesson 248 — Matrix Representation and Operations
- matroid
- A matroid is a mathematical structure that captures the essence of "independence." Think of it as a collection of elements and rules about which subsets are "independent" (valid or allowed).
- Lesson 910 — Matroid Theory and Greedy Algorithms
- max-flow
- The max-flow is the maximum amount of water you can push from source to sink.
- Lesson 1031 — The Max-Flow Min-Cut Theorem
- max-heap
- Every parent is ≥ both children
- Lesson 578 — Heap Order Property: Max-HeapLesson 585 — Heap Structure Invariants
- Membership
- Simulate the DFA on input string w. Start at the initial state and follow transitions for each symbol. Accept if you end in an accepting state after reading all of w. This is the basic DFA computation you've already seen.
- Lesson 1811 — Decision Properties of Regular Languages
- Memento
- A snapshot that stores the originator's state (opaque to outsiders)
- Lesson 2298 — Memento Pattern
- Memoization
- Memoization means storing the result of a function call so if we see those same inputs again, we return the cached answer instead of recomputing it.
- Lesson 443 — Caching and MemoizationLesson 873 — Recursion with Memoization IntegrationLesson 913 — What is Dynamic Programming?
- Memory constraints
- The coordinator node must aggregate potentially large result sets
- Lesson 2692 — Cross-Shard Queries and Joins
- Memory-constrained environments
- Heapsort sorts in-place with only O(1) extra space. If you're working on embedded systems, mobile devices with limited RAM, or kernel-level code where memory allocation is expensive or restricted, heapsort outperforms mergesort's O(n) space requirement.
- Lesson 608 — Practical Considerations for Heapsort
- Mergesort
- Memory available: Mergesort is stable and predictable, worth the O(n) space.
- Lesson 799 — When to Use Which Sorting Algorithm
- Merging
- If neighboring siblings are also at their minimum, you combine the underflowing node with a sibling and pull down a key from the parent to glue them together. This creates one fuller node but may cause the parent to underflow—potentially triggering a chain reaction up the tree.
- Lesson 1683 — Deletion from Leaf Nodes
- message queue
- A message queue is a component that holds messages sent by one part of a system (the producer) until another part (the consumer) is ready to process them.
- Lesson 2707 — Message Queue Fundamentals
- method
- Imagine ordering at a restaurant: the method is whether you're ordering, paying, or canceling; the URI is the menu item number; headers are dietary preferences or instructions; the body is any customization details.
- Lesson 1515 — HTTP Request Structure
- Method overriding
- Method overriding means a subclass provides its own implementation of a method already defined in its parent class.
- Lesson 2127 — Method Overriding and Polymorphism
- microkernel
- A microkernel is an operating system design that shrinks the kernel down to its absolute essentials.
- Lesson 1196 — Microkernel Architecture
- min-heap
- Every parent is ≤ both children
- Lesson 577 — Heap Order Property: Min-HeapLesson 585 — Heap Structure Invariants
- minimal DFA
- A minimal DFA is the most efficient version: it has the smallest number of states needed to recognize the language, making it faster to process and easier to understand.
- Lesson 1787 — Minimizing States in DFAs
- misprediction penalty
- If wrong, the CPU must flush all speculatively executed instructions and restart from the correct path—this is called a misprediction penalty.
- Lesson 1184 — Branch Prediction Performance Impact
- miss rate
- The miss rate is simply the opposite—the percentage of accesses that don't find data in cache, forcing a trip to slower main memory.
- Lesson 1125 — Measuring Cache Effectiveness
- Missing checks entirely
- An admin panel URL exists at /admin, but the server never verifies if you're actually an admin before serving it
- Lesson 2488 — Broken Access Control
- Missing or outdated statistics
- The optimizer misjudges cardinality
- Lesson 1702 — Index Selection for Queries
- mnemonic
- The mnemonic is the human-readable operation name—the actual command you want the CPU to perform.
- Lesson 1093 — Assembly Language Syntax and Structure
- Model too simple
- Using linear regression when the relationship is polynomial
- Lesson 2809 — What is Underfitting?
- Modified files
- Modified files are files you've changed since your last commit but haven't staged yet.
- Lesson 2174 — Checking Repository Status
- modulation
- Signal encoding is the process of representing digital data as a signal suitable for transmission, and modulation is how we impress that data onto a carrier wave (especially for analog channels).
- Lesson 1443 — Signal Encoding and Modulation
- monad
- A monad is a design pattern that wraps values in a context (like "might fail" or "depends on external state") and provides two key operations:
- Lesson 2143 — Monads and Effect Management
- Monotonicity condition
- If opt[i] is the best j for state i, then:
- Lesson 959 — Divide and Conquer Optimization
- More joins
- A query needing data from five normalized tables performs multiple joins, which is computationally expensive
- Lesson 1645 — Normal Form Trade-offs
- More predictable
- Response time is more uniform than FCFS or SSTF
- Lesson 1425 — SCAN (Elevator) Algorithm
- MSD
- MSD is more complex but potentially faster: it creates partitions and recurses into each bucket.
- Lesson 793 — Radix Sort: LSD vs MSD
- Multigraph
- A realistic map showing that two cities might be connected by multiple highways, a train line, and a ferry route—each represented as a separate edge.
- Lesson 660 — Simple Graphs and Multigraphs
- Multiple concerns
- The class handles user input and database logic and business rules and formatting
- Lesson 2331 — Large Class Smell
- Multiplexing
- Multiplexing is the process of combining multiple data streams into one channel.
- Lesson 1483 — TCP Port Numbers and Multiplexing
- mutable character buffer
- A mutable character buffer is like a whiteboard where you can erase and add without starting over.
- Lesson 269 — String Building and Concatenation Efficiency
- mutable state
- In imperative programming, mutable state refers to data that can be modified after it's created.
- Lesson 2114 — Mutable State and Variables
- Mutexes
- Mutexes are designed specifically for mutual exclusion — protecting critical sections.
- Lesson 1303 — Semaphores vs Mutexes vs Condition Variables
- Mutual exclusion
- Mutual exclusion is the fundamental principle that guarantees only one process (or thread) can be inside its critical section at any given moment.
- Lesson 1275 — Mutual Exclusion Explained
- mutual exclusion problem
- The mutual exclusion problem is the formal challenge of ensuring that when one thread is executing its critical section, no other thread can enter its own critical section for the same shared resource.
- Lesson 1280 — Mutual Exclusion Problem
N
- Naive insertion
- Best when one heap is much smaller than the other (inserting 10 elements into a 10,000-element heap)
- Lesson 598 — Merge Two Heaps
- Name Mismatch
- Visiting https://example.com but the certificate is for example.org. This could indicate an attack or misconfiguration.
- Lesson 2450 — Certificate Validation and Common Errors
- NaN
- NaN represents undefined or unrepresentable results.
- Lesson 1068 — Special Floating-Point Values: Infinity and NaN
- Natural completion
- The thread function finishes and returns
- Lesson 1238 — Thread Creation and Termination
- natural join
- A natural join is a type of join that automatically combines two tables by matching all columns that have the same name in both tables.
- Lesson 1584 — Natural Join
- negation as failure
- This is called negation as failure (often written \+ or not in Prolog).
- Lesson 2164 — Negation as Failure
- nested conditional
- A nested conditional is simply an if, elif, or else block that contains another if statement inside it.
- Lesson 170 — Nested Conditionals
- nested loop
- A nested loop is simply a loop placed inside the body of another loop.
- Lesson 181 — Nested Loops
- Network Layer
- The Network Layer is responsible for logical addressing and routing.
- Lesson 1435 — OSI Layer 3: Network Layer
- Network partition
- Node is fine, but you can't reach it
- Lesson 2591 — Partial Failures and Fault Detection
- Network reliability
- If two servers fail independently, the probability both fail is the product of their individual failure rates
- Lesson 116 — Independent Events
- Network Routing
- Determining optimal data packet paths between routers
- Lesson 965 — Introduction to Single-Source Shortest Path Problems
- nextIndex
- The next log entry to send to that follower
- Lesson 2665 — Log Replication: AppendEntries Basics
- No fault tolerance
- If a thread holding a lock crashes, all waiting threads are stuck
- Lesson 2566 — Introduction to Lock-Free Programming
- No head-of-line blocking
- Multiple streams are truly independent at the transport layer
- Lesson 1527 — HTTP/3 and QUIC
- No information loss
- Constraints are applied only when necessary
- Lesson 2012 — Principal Types and Most General Unifiers
- No odd cycles
- This is the mathematical test—a graph is bipartite if and only if it contains no cycles of odd length
- Lesson 689 — Bipartite Graphs
- No ordering preserved
- Keys that are numerically or alphabetically close are scattered across different buckets
- Lesson 1693 — Range Query Limitations
- No relationships
- There are no foreign keys or joins. Each key stands alone.
- Lesson 1728 — Key-Value Store Data Model
- No schema enforcement
- The value can be anything—a string, number, JSON blob, binary data, or even serialized objects.
- Lesson 1728 — Key-Value Store Data Model
- node
- A node is a broader term encompassing any device connected to the network—including hosts, but also intermediate devices like routers and switches that help move data around.
- Lesson 325 — Node StructureLesson 1431 — Introduction to Computer NetworksLesson 1748 — Nodes and Properties
- nodes
- A linked list is a data structure where elements (called nodes) are scattered in memory, each pointing to the next one through pointers.
- Lesson 324 — Introduction to Linked ListsLesson 1750 — Cypher Query Language Basics
- non-authoritative answer
- A non-authoritative answer is when you ask a mutual friend who wrote it down last week—probably correct, but not guaranteed to be current if the number changed recently.
- Lesson 1511 — Authoritative vs Non-Authoritative Responses
- non-blocking mode
- Setting a socket to non-blocking mode means operations return immediately, even if they can't complete.
- Lesson 1549 — Non-Blocking Sockets and I/O Multiplexing
- Non-clustered index
- A card catalog organized by author name. The cards point you to call numbers, then you must walk to the shelves (extra step).
- Lesson 1686 — Clustered vs Non-Clustered B-Tree Indexes
- Non-determinism
- Non-determinism means the same test can pass 999 times and fail once.
- Lesson 2599 — Testing and Debugging Difficulties
- non-leaf nodes
- Internal nodes (also called non-leaf nodes) are any nodes that have at least one child.
- Lesson 452 — Leaves, Internal Nodes, and Edges
- Non-preemptive
- Non-preemptive is simpler and has lower context-switching overhead, but high-priority processes might wait unnecessarily.
- Lesson 1257 — Priority Scheduling: Preemptive vs Non-Preemptive
- Non-preemptive scheduling
- Non-preemptive scheduling means once a process gets the CPU, it keeps it until it voluntarily gives it up—either by finishing, waiting for I/O, or explicitly yielding.
- Lesson 1243 — Preemptive vs Non-Preemptive Scheduling
- Non-repudiation
- You cannot deny signing it later (your private key is uniquely yours)
- Lesson 2432 — What are Digital Signatures?
- Normal forms
- Normal forms are standardized formats that make it easier to compare, simplify, and work with logical expressions systematically.
- Lesson 45 — Normal Forms: CNF and DNF
- normally
- The primary way a process ends normally is by calling the exit() system call (or by reaching the end of its main function, which implicitly calls exit()).
- Lesson 1225 — Process Termination: exit() and Return Codes
- NUMA-aware scheduling
- NUMA-aware scheduling means the OS scheduler tries to run processes on CPUs that are close to the memory where that process's data lives.
- Lesson 1268 — NUMA-Aware Scheduling
O
- object
- An object is a specific instance of a class—a concrete entity in memory with its own:
- Lesson 2122 — Classes and Objects
- Object-Relational Mapper
- An Object-Relational Mapper is a library that translates between your programming language's objects and database tables.
- Lesson 2481 — ORM and SQL Injection Protection
- objective function
- The objective function is what your learning algorithm tries to optimize—usually minimizing the total loss across all training data.
- Lesson 2779 — Loss Functions and Objective Functions
- octets
- These 32 bits are typically divided into four groups of 8 bits each (called octets or bytes).
- Lesson 1461 — IPv4 Address Structure and Notation
- one-bit branch predictor
- A one-bit branch predictor is the most basic form of dynamic branch prediction.
- Lesson 1178 — One-Bit Branch Predictor
- one-to-one
- An injective function (also called one-to-one) is a function where different inputs always produce different outputs.
- Lesson 77 — Function Properties: Injective (One-to-One)
- One-vs-Rest
- One-vs-Rest is simpler to implement (reuse binary classifiers) but treats classes independently.
- Lesson 2834 — Multiclass Logistic Regression
- One's complement
- One's complement is a method for representing signed integers where a negative number is formed by inverting every bit (changing 0s to 1s and 1s to 0s) of its positive counterpart.
- Lesson 1058 — One's Complement Representation
- opcode
- The opcode (operation code) is the field that tells the CPU which operation to execute.
- Lesson 1085 — Instruction Formats and Opcodes
- Operands
- Operands are the data or locations the instruction acts upon—typically one or two values separated by commas:
- Lesson 1093 — Assembly Language Syntax and Structure
- Operation Types
- The plan shows operations like Seq Scan (reading entire table), Index Scan (using an index), Hash Join, or Nested Loop. Sequential scans on large tables often signal missing indexes.
- Lesson 1705 — Reading and Analyzing EXPLAIN Output
- optimal solution
- An optimal solution is one with the lowest path cost among all possible solutions that reach a goal state.
- Lesson 2730 — Path Cost and Optimality
- Optimal substructure
- Optimal substructure means that the best solution to a big problem is made up of the best solutions to smaller pieces of that same problem.
- Lesson 905 — Optimal Substructure in Greedy AlgorithmsLesson 914 — Optimal Substructure PropertyLesson 940 — Unique Paths in Grid
- Optimization becomes simpler
- Once code is in IR form, the compiler can apply powerful optimizations (eliminating redundant calculations, reordering instructions, etc.) without worrying about the quirks of either the source language or the target machine.
- Lesson 2037 — What is an Intermediate Representation (IR)?
- Optimization-Friendly
- Because each instruction is simple and independent, optimizers can easily analyze data flow, eliminate dead code, or rearrange instructions for better performance.
- Lesson 2040 — Three-Address Code (TAC)
- Ordering
- Items at the top are more refined, detailed, and urgent. Lower items can remain vague until they move up in priority. The team typically works on top items first during sprints.
- Lesson 2377 — Scrum Artifacts: Product Backlog
- Ostrich Algorithm
- The Ostrich Algorithm is the decision to do nothing about deadlock—essentially pretending it doesn't exist, like an ostrich burying its head in the sand.
- Lesson 1328 — Ostrich Algorithm and Practical Approaches
- outcome
- An outcome is a single element from the sample space—one specific result.
- Lesson 108 — Sample Spaces and Events
- Outdated information
- Comments that contradict the code are worse than no comments
- Lesson 2312 — Comments: When and How to Use Them
- Over-regularization
- Constraints are so strict the model can't learn
- Lesson 2809 — What is Underfitting?
- overfitting
- The model could simply memorize training examples rather than learning generalizable patterns—a problem called overfitting.
- Lesson 2796 — Training Set vs Test Set
- Overflow
- Attempting enqueue when capacity is full (bounded queues)
- Lesson 377 — Queue Interface and Specification
- overhead
- In networking, this extra information is called overhead.
- Lesson 1498 — Overhead and Header Size Comparison
- Overlapping subproblems
- Overlapping subproblems means that your recursive solution ends up solving the exact same subproblems multiple times.
- Lesson 915 — Overlapping Subproblems
- Owner tracking
- The mutex remembers which thread holds it
- Lesson 1288 — Recursive Locks (Reentrant Mutexes)
- Ownership
- The Product Owner maintains and prioritizes the backlog. They decide what goes in, what comes out, and—critically—what order items appear in.
- Lesson 2377 — Scrum Artifacts: Product Backlog
P
- P ∧ Q
- The conjunction P ∧ Q is true only when both P and Q are true.
- Lesson 33 — Logical Conjunction (AND)
- P ⊆ coNP
- Every polynomial-time problem is also in coNP (if you can decide it efficiently, you can decide its complement efficiently)
- Lesson 1909 — Complementary Classes: coNP
- P ⊆ NP
- Every polynomial-time problem is in NP
- Lesson 1908 — Why P ≠ NP is BelievedLesson 1909 — Complementary Classes: coNP
- P ⊆ NP ⊆ PSPACE
- Everything solvable in polynomial time (P) is also solvable in polynomial space. Everything verifiable in polynomial time (NP) can also be solved in polynomial space by simply checking all possible certificates.
- Lesson 1895 — The Class PSPACE
- P ⊆ PSPACE ⊆ EXP
- If you can solve a problem in polynomial space, you can solve it in exponential time (because you can only visit finitely many configurations with polynomial space). Since P is contained in EXP, PSPACE sits somewhere in between.
- Lesson 1895 — The Class PSPACE
- page table
- A page table is a data structure maintained by the operating system that stores the mapping between virtual page numbers and physical frame numbers.
- Lesson 1344 — Page Tables IntroductionLesson 1353 — Page Tables
- page table entry
- Each entry in the table (called a page table entry or PTE) contains the physical frame number along with additional metadata like permission bits and validity flags.
- Lesson 1344 — Page Tables Introduction
- Paging
- Paging is a memory management scheme that eliminates external fragmentation by breaking both physical memory and virtual address spaces into fixed-size blocks:
- Lesson 1351 — Introduction to Paging
- palindromic subsequence
- A palindromic subsequence is a sequence of characters that reads the same forwards and backwards, but doesn't need to be contiguous.
- Lesson 935 — Longest Palindromic Subsequence
- Parallelism
- Parallelism means literally running multiple computations at the exact same time—not just switching between them quickly, but truly simultaneously.
- Lesson 1429 — Disk Scheduling in Modern SystemsLesson 2545 — Parallelism Defined: Simultaneous ExecutionLesson 2553 — Choosing Between Concurrency and Parallelism
- parameter
- A parameter is a variable listed in the function declaration that acts as a placeholder for data you'll provide when calling the function.
- Lesson 195 — Function Parameters: Passing Data to Functions
- parameter object
- A parameter object is a simple data structure that bundles related parameters into a single, cohesive unit.
- Lesson 2328 — Simplify Method Signatures: Parameter Objects
- Parameter validation
- Parameter validation means checking inputs before using them, so your function can respond gracefully to bad data.
- Lesson 205 — Parameter Type Checking and Validation
- parameters
- These parameters are passed from your user-mode program to the kernel.
- Lesson 1208 — System Call Parameters and Return ValuesLesson 1980 — AST Representation of Function Definitions
- parent
- A parent is any node that has one or more nodes directly connected below it.
- Lesson 451 — Root, Parent, Child, and Sibling NodesLesson 462 — Array Index Formulas
- Parent and child
- A parent node splits into child nodes via edges. The root has no parent; leaves have no children.
- Lesson 2840 — Tree Terminology: Nodes, Edges, and Leaves
- parse tree
- A parse tree is a graphical representation of this derivation.
- Lesson 1814 — Derivations and Parse Trees
- Parser generators
- Parser generators are tools that do this work for you automatically.
- Lesson 1973 — Parser Generators and YACC/Bison
- Parsing complexity
- The CYK (Cocke-Younger-Kasami) algorithm relies on CNF to run in O(n³) time
- Lesson 1843 — Chomsky Normal Form
- Partial application
- Partial application is simpler—it fixes some arguments upfront and returns a function waiting for the rest.
- Lesson 2138 — Currying and Partial Application
- partial order
- A partial order is a special type of relation that lets us compare some (but not necessarily all) elements in a set according to a consistent ordering.
- Lesson 74 — Partial Orders
- partition
- The Law of Total Probability lets you split the entire sample space into separate, non-overlapping scenarios (called a partition), calculate the probability within each scenario, then add them up.
- Lesson 117 — Law of Total Probability
- partition tolerance
- Now we'll understand why partition tolerance is non-negotiable in real-world distributed systems.
- Lesson 2603 — Partition Tolerance ExplainedLesson 2697 — Eventual Consistency Definition and Motivation
- partitioning
- Instead of splitting the array into equal halves and doing work after recursion (during merging), quicksort does its main work before recursion through a process called partitioning.
- Lesson 762 — Quicksort: The Divide-and-Conquer Sorting Strategy
- partitions
- Data partitioning divides a dataset into smaller, independent subsets called partitions or shards, each stored on different nodes.
- Lesson 2682 — Introduction to Data Partitioning
- password manager
- A password manager is an encrypted vault that stores all your passwords behind a single master password.
- Lesson 2515 — Password Managers and Best Practices
- path
- Key Takeaway: A path is a sequence of distinct vertices connected by edges (no repeats), while a walk allows revisiting vertices and edges — all paths are walks, but not all walks are paths.
- Lesson 490 — Path Length PropertiesLesson 657 — What is a Graph? Vertices and EdgesLesson 662 — Paths and Walks
- path sum
- A path sum is the total of node values along some route through the tree.
- Lesson 949 — Path Sums and Tree DP
- Patterns
- Patterns are the rules that define what strings belong to each token category
- Lesson 1939 — Tokens, Lexemes, and Patterns
- payload
- A payload is the actual malicious JavaScript code injected into a vulnerable application.
- Lesson 2458 — XSS Attack Vectors and Payloads
- PDAs
- PDAs are like recognition machines — they read strings and decide membership using a stack.
- Lesson 1835 — Equivalence of PDAs and Context-Free Grammars
- Peek
- The cashier looks to see which car is next without serving them yet
- Lesson 376 — Essential Queue Operations
- pepper
- A pepper is different: it's a secret key stored separately from your database—typically in your application's configuration or a hardware security module (HSM).
- Lesson 2510 — Pepper: Additional Secret Layer
- Perfect
- The ideal case—fully balanced and completely filled
- Lesson 459 — Full, Complete, and Perfect Binary Trees
- perfect binary tree
- A perfect binary tree is a special type of binary tree where:
- Lesson 486 — Perfect Binary Trees
- Performance
- Operations on integers are faster than text comparisons
- Lesson 270 — What is Runtime Analysis?Lesson 1554 — Domains and Data Types
- permutation
- A permutation is a specific arrangement of items.
- Lesson 858 — Generating All Permutations
- Personal information
- Names, birthdays, pet names are in attacker dictionaries
- Lesson 2511 — Password Strength and Entropy
- physical address space
- The physical address space is the actual hardware memory—the real RAM installed in your computer.
- Lesson 1342 — Virtual vs Physical Address Spaces
- Physical connectors
- The shape and pin layout of network jacks (like RJ-45 Ethernet ports)
- Lesson 1441 — Physical Layer Overview
- Physical Layer
- The Physical Layer is the bottom-most layer of the OSI model—the literal physical foundation that makes all network communication possible.
- Lesson 1433 — OSI Layer 1: Physical Layer
- Physical operations
- Physical operations are involved (imagine sorting physical packages on a conveyor belt—minimizing movements saves time and energy)
- Lesson 746 — Selection Sort: Minimizing Swaps
- Pigeonhole Principle
- The Pigeonhole Principle is delightfully simple: if you have n+1 objects to place into n boxes (pigeonholes), at least one box must contain two or more objects.
- Lesson 103 — The Pigeonhole Principle
- pipeline bubble
- A pipeline stall (also called a pipeline bubble) is an intentional delay inserted into the pipeline.
- Lesson 1168 — Pipeline Stalls and Bubbles
- pipeline fill
- These transitional periods are called pipeline fill (startup) and pipeline drain (shutdown).
- Lesson 1153 — Pipeline Fill and Drain
- Pipeline hazards
- Pipeline hazards are conditions that prevent the next instruction from executing in its designated clock cycle.
- Lesson 1160 — Introduction to Pipeline Hazards
- pipeline latches
- Pipeline registers (also called pipeline latches) are small, fast storage units placed between consecutive stages that hold intermediate values from one clock cycle to the next.
- Lesson 1150 — Pipeline Registers and Latches
- Plaintext storage
- Plaintext storage means saving passwords exactly as users type them, unprotected in your database.
- Lesson 2504 — Password Storage Fundamentals
- planar graph
- A planar graph is a graph that can be drawn on a flat surface (like a piece of paper) without any edges crossing each other.
- Lesson 692 — Planar Graphs
- Playwright
- Playwright is Microsoft's modern contender, offering cross-browser testing (Chrome, Firefox, Safari) with one API.
- Lesson 2249 — E2E Testing Tools and Frameworks
- ply depth
- The ply depth is how many individual moves deep we search in the tree.
- Lesson 2765 — Game Trees and Ply Depth
- Pointers to data blocks
- the disk addresses where the file's actual content lives
- Lesson 1397 — File Control Blocks and Inodes
- Policies
- Policies are written in a declarative language (like XACML or Rego)
- Lesson 2529 — Policy-Based Access Control
- Polling
- The CI system periodically checks the repository for changes, like checking your mailbox every few minutes.
- Lesson 2385 — Version Control Integration
- polynomial complexities
- These are called polynomial complexities of degree 3 or higher.
- Lesson 288 — O(n³) and Higher Polynomial Time
- Poor key choice
- Using sequential IDs as hash keys when most writes are recent records
- Lesson 2690 — Handling Data Skew and Hotspots
- Port
- The specific door to knock on (e.g., 5432 for PostgreSQL, 3306 for MySQL)
- Lesson 1562 — Database Connection and Basic Structure
- port number
- A port number is a 16-bit value (0–65535) that identifies a specific application or service on a host.
- Lesson 1483 — TCP Port Numbers and Multiplexing
- possession factor
- A possession factor is the second type of authentication factor in multi-factor authentication (MFA).
- Lesson 2518 — Possession Factors (Something You Have)
- POST
- POST is used to submit data to the server, typically to create or update a resource.
- Lesson 1516 — HTTP Methods: GET and POSTLesson 1517 — HTTP Methods: PUT, DELETE, and Others
- Post-pruning
- Post-pruning is more computationally expensive but often produces better results because it makes decisions with full information about the tree's structure.
- Lesson 2850 — Pruning: Pre-pruning vs Post-pruning
- post-receive
- runs after refs are updated (useful for deployment or notifications)
- Lesson 2210 — Git Hooks
- Postfix
- Postfix is like receiving your current number, then the machine increments for the next person.
- Lesson 161 — Increment and Decrement Operators
- Postfix evaluation
- Postfix evaluation is beautifully suited for stacks:
- Lesson 365 — Expression Evaluation: Infix, Prefix, Postfix
- Power consumption
- More circuitry means more energy used per access
- Lesson 1136 — Associativity Impact on Conflict Misses
- Pragmas
- Pragmas are special directives embedded in source code that give the compiler hints or commands about specific sections.
- Lesson 2073 — Optimization Levels and Pragmas
- pre-commit
- runs before a commit is finalized (perfect for linting or running tests)
- Lesson 2210 — Git Hooks
- Pre-pruning
- Pre-pruning is computationally efficient (less tree to build) but risks underfitting—you might stop too early and miss important patterns deeper in the tree.
- Lesson 2850 — Pruning: Pre-pruning vs Post-pruning
- pre-receive
- runs before any refs are updated (can reject pushes that violate policies)
- Lesson 2210 — Git Hooks
- Preemptive priority scheduling
- Preemptive priority scheduling is more aggressive.
- Lesson 1257 — Priority Scheduling: Preemptive vs Non-Preemptive
- Preemptive scheduling
- Preemptive scheduling means the OS can forcibly interrupt a running process and assign the CPU to another process, even if the current one isn't finished and hasn't blocked.
- Lesson 1243 — Preemptive vs Non-Preemptive Scheduling
- Prefix
- Prefix is like the machine incrementing before printing your number—you see the new number.
- Lesson 161 — Increment and Decrement Operators
- primary key
- A primary key is a special column (or combination of columns) in a database table that uniquely identifies every single row.
- Lesson 1555 — Primary KeysLesson 1614 — Key Attributes and Identifiers
- Principal
- The user or group (e.g., "user123" or "admins_group")
- Lesson 2525 — Access Control Lists (ACLs)
- Priority inversion
- Priority inversion is a related but different problem: a high-priority process waits for a resource held by a low-priority process, while a medium-priority process runs, delaying everyone.
- Lesson 1258 — Priority Inversion and Aging
- priority queue
- A priority queue is an abstract data type (ADT) that stores elements with associated priorities and always gives you access to the element with the highest (or lowest) priority first.
- Lesson 389 — Priority Queues IntroductionLesson 609 — Priority Queue ADT OverviewLesson 610 — Heap as Priority Queue Implementation
- private
- The member is visible only within the defining class. No outside code—not even subclasses—can access it directly. Use this for internal implementation details you want to hide completely.
- Lesson 2124 — Access Modifiers and Visibility
- Probabilistic guarantee
- The chance of repeatedly picking terrible pivots becomes vanishingly small (like flipping heads 20 times in a row)
- Lesson 771 — Randomized Quicksort: Avoiding Worst Case
- process
- A process is a program in execution—it's your code brought to life with its own memory space, execution state, and resources.
- Lesson 1199 — Core OS Services: Process ManagementLesson 1215 — What is a Process?
- Process state
- Whether the process is running, ready, waiting, etc.
- Lesson 1217 — Process Control Block (PCB)
- Processor affinity
- Processor affinity is the tendency (or requirement) for a process or thread to run on the same CPU core it previously ran on.
- Lesson 1265 — Processor Affinity
- Producer
- Lock mutex → check if buffer is full → if full, wait on notFull condition → add item → signal notEmpty → unlock
- Lesson 1310 — Producer-Consumer with Condition Variables
- product backlog
- The product backlog is an ordered list of everything that might be needed in the product—features, enhancements, bug fixes, technical improvements, and more.
- Lesson 2377 — Scrum Artifacts: Product Backlog
- Product Owner
- In Scrum, the Product Owner is the single person responsible for maximizing the value of the product resulting from the team's work.
- Lesson 2374 — Scrum Roles: Product Owner
- Product types
- Product types are the simplest composite types: they combine two or more values into one unit, creating a Cartesian product of their component types.
- Lesson 1987 — Composite Types: Products
- profile
- The profile is a compact representation—often a bitmask—encoding just the relevant information about the boundary (e.g., which cells in the previous row are "occupied" or "available").
- Lesson 963 — Profile/Broken Profile Optimization
- Program Counter
- The Program Counter (PC) is a special register in the CPU that holds the memory address of the next instruction to be fetched from memory.
- Lesson 1083 — Program Counter and Instruction AddressLesson 1217 — Process Control Block (PCB)
- Progress
- If no process is executing in the critical section, the selection of the next process cannot be postponed indefinitely
- Lesson 1276 — Progress and No DeadlockLesson 1277 — Bounded Waiting Property
- proof by contradiction
- We'll use a powerful technique called proof by contradiction, where we assume the opposite of what we want to prove and show this leads to an impossible situation.
- Lesson 1880 — Proof by Contradiction Setup
- proper subset
- A proper subset is stricter: A is a proper subset of B if A is a subset of B and B contains at least one element not in A.
- Lesson 60 — Subsets and Proper Subsets
- proposition
- A proposition is a declarative statement that is either true or false, but not both.
- Lesson 31 — Propositions and Truth Values
- Pros
- Consistency is guaranteed at the database level, regardless of which application touches the data.
- Lesson 1651 — Using Triggers and Application Logic
- protected
- The member is visible within the defining class and its subclasses, but not to unrelated code. This creates a middle ground for inheritance hierarchies.
- Lesson 2124 — Access Modifiers and Visibility
- Protection
- The OS can control who reads or writes each file
- Lesson 1340 — Address Translation OverviewLesson 1386 — File Abstraction and Basic Operations
- Proxy
- A Proxy is a structural design pattern that provides a surrogate or placeholder object to control access to the real object.
- Lesson 2280 — Proxy Pattern: Controlling Access to Objects
- Pruning
- Pruning means cutting off these dead-end branches before you fully explore them.
- Lesson 865 — Pruning and OptimizationLesson 2850 — Pruning: Pre-pruning vs Post-pruning
- public
- The member is visible everywhere—inside the class, outside the class, in subclasses, anywhere in your program. Use this for the intentional interface you want others to use.
- Lesson 2124 — Access Modifiers and Visibility
- Public Key
- The server's public key for asymmetric encryption
- Lesson 1532 — Digital Certificates Fundamentals
- Pull migration
- An idle processor pulls a waiting process from a busy processor's queue.
- Lesson 1263 — Load Balancing Concepts
- pull request
- A pull request (PR) is a formal proposal to merge changes from one branch (usually your feature branch) into another (typically main or develop).
- Lesson 2196 — Pull Requests and Code Review
- Puppeteer
- Puppeteer is Google's Node.js library for controlling Chrome/Chromium.
- Lesson 2249 — E2E Testing Tools and Frameworks
- pure function
- A pure function is like a mathematical function: given the same input, it always returns the same output, with no side effects.
- Lesson 2132 — Pure Functions and Immutability
- Push migration
- The OS periodically checks processor loads and actively pushes processes from overloaded cores to idle ones.
- Lesson 1263 — Load Balancing Concepts
- PUT
- PUT is idempotent: updating user 42 ten times leaves the same final state
- Lesson 1517 — HTTP Methods: PUT, DELETE, and Others
Q
- queue
- The queue is the data structure that makes this work: it processes nodes in first-in-first-out (FIFO) order, ensuring we explore level by level.
- Lesson 375 — Queue ADT Definition and FIFO PrincipleLesson 2741 — BFS Implementation and Complexity
- queue invariant
- A queue invariant is a condition that must always remain true throughout the lifetime of your queue, no matter what operations you perform.
- Lesson 386 — Queue Invariants and Correctness
- Quicksort
- Quicksort is lightning-fast on average but can degrade with poor pivot choices
- Lesson 607 — Heapsort vs Quicksort vs MergesortLesson 800 — Hybrid Sorting Strategies
- quorum
- A quorum is the minimum number of nodes that must agree before an operation succeeds.
- Lesson 2620 — Quorum-Based ConsistencyLesson 2656 — Quorums and Majority Voting
R
- radix tree
- A compressed trie (also called a radix tree or Patricia trie) merges these single-child chains into a single edge labeled with multiple characters.
- Lesson 631 — Compressed Tries (Radix Trees)
- Random
- Random is the simplest but unpredictable, though it avoids worst-case scenarios that can trap other policies.
- Lesson 1123 — Cache Replacement Policies Overview
- Random access
- Random access means jumping directly to any position in the file using seek operations—like flipping to page 237 of a book.
- Lesson 1391 — Sequential vs Random Access
- random variable
- A random variable is a function that assigns a numerical value to each possible outcome of a random experiment.
- Lesson 120 — Random Variables: Definition and Types
- Range
- The set of all second elements that actually appear in the relation's pairs (subset of codomain)
- Lesson 67 — Relations as Sets of Ordered Pairs
- Reachability
- Reachability is the key concept: if your program cannot possibly access an object anymore (no variables, no pointers, no references lead to it), that object is garbage.
- Lesson 2094 — What is Garbage Collection?
- Read
- Retrieving documents by their identifier or by matching specific fields within the document structure. This is how you query your nested JSON data.
- Lesson 1721 — CRUD Operations in Document Databases
- Read ports
- Allow the CPU to fetch data from two (or more) registers at once. This is crucial when executing instructions like ADD R1, R2, R3 (add contents of R2 and R3, store in R1)—you need to read R2 and R3 simultaneously.
- Lesson 1080 — Register File Architecture
- reader-writer lock
- A reader-writer lock (or rwlock) is a synchronization primitive that distinguishes between two types of access:
- Lesson 1289 — Reader-Writer Locks Introduction
- Real-time predictions needed
- Even with KD-trees or Ball trees, KNN is slower than parametric models like logistic regression
- Lesson 2872 — KNN in Practice: Applications and Limitations
- rear
- Using an array, we can implement this by keeping track of two positions: where the front of the queue is (where we remove items) and where the rear is (where we add new items).
- Lesson 378 — Array-Based Queue Implementation
- recurrence relation
- A recurrence relation is a formula that defines each term of a sequence based on one or more previous terms.
- Lesson 84 — Recurrence Relations
- Recursion
- Recursion is when a function calls itself during its own execution.
- Lesson 217 — What is Recursion?
- recursive partitioning algorithm
- The recursive partitioning algorithm is the engine that constructs a decision tree.
- Lesson 2847 — Recursive Partitioning Algorithm
- recursive queries
- The beauty of recursive queries is that the client makes only one request and waits for a complete answer.
- Lesson 1507 — DNS Resolution Process: Recursive Queries
- Reduced Risk
- Smaller releases mean smaller failures. A bad two-week sprint is easier to recover from than discovering six months of work missed the mark.
- Lesson 2369 — Continuous Delivery of Value
- Reduced throughput
- The whole pipeline stalls waiting for the slowest stage
- Lesson 1155 — Balancing Pipeline Stages
- reduction
- A reduction is a transformation that converts one problem into another.
- Lesson 1928 — Introduction to Reductions
- reduction chain
- A reduction chain is when you string these together: if problem A reduces to B, and B reduces to C, then A automatically reduces to C.
- Lesson 1936 — Reduction Chains
- Redundancy elimination
- Redundancy elimination is normalization's core benefit—it prevents update anomalies and saves storage.
- Lesson 1645 — Normal Form Trade-offs
- reentrant mutex
- A recursive lock (also called a reentrant mutex) keeps track of which thread owns it and how many times that thread has locked it.
- Lesson 1288 — Recursive Locks (Reentrant Mutexes)
- reference
- A reference is essentially a nickname or alternate name for an existing variable.
- Lesson 320 — References as Aliases
- reflog
- Git's reflog (reference log) is your safety net—a local history of where your HEAD and branch references have pointed over time.
- Lesson 2207 — Reflog and Recovery
- Refresh tokens
- Refresh tokens are long-lived credentials (days to months) used exclusively to request new access tokens from the authorization server.
- Lesson 2539 — OAuth 2.0 Tokens: Access Tokens and Refresh Tokens
- Register allocation
- Register allocation is the compiler's job of deciding which program variables should live in these precious registers at each point in execution.
- Lesson 2070 — Register Allocation
- register transfer
- This movement is called register transfer.
- Lesson 1079 — Register Transfer and Data Paths
- Registers
- Registers are tiny, ultra-fast storage locations built directly into the CPU.
- Lesson 1071 — CPU Components Overview
- Rehashing frequency
- The amortized O(1) cost hides occasional expensive O(n) pauses
- Lesson 441 — Benchmarking and Practical Performance
- reject state
- The reject state is the "Failure Exit" — reaching it means the input failed the test
- Lesson 1856 — Accepting and Rejecting States
- Related data co-location
- Items that are queried together should share the same key to avoid distributed joins.
- Lesson 2685 — Partition Keys and Shard Keys
- Relational integrity constraints
- Relational integrity constraints are the rules that databases enforce automatically to maintain data quality.
- Lesson 1557 — Relational Integrity Constraints
- relational model
- The relational model is a mathematical framework for organizing data as tables (called relations), where each table consists of rows and columns.
- Lesson 1551 — What is the Relational Model?
- relationship
- A relationship is a meaningful association between two or more entity sets.
- Lesson 1615 — Relationships and Relationship Sets
- relationship set
- A relationship set is the collection of all relationship instances of the same type.
- Lesson 1615 — Relationships and Relationship Sets
- Relatively fast
- Neighbor lookup is O(degree) with good locality
- Lesson 683 — Hybrid and Compressed Representations
- Relaxation
- Relaxation is the process of checking whether traveling through an intermediate vertex gives you a shorter path to a destination than your current best estimate.
- Lesson 967 — The Relaxation Operation
- Release
- Release means unlocking and leaving—the next person waiting can now enter and lock it behind them.
- Lesson 1281 — Lock Semantics and Acquire/Release
- Reliability
- With distributed systems, every clone is a full backup. If the "central" server fails, any developer can restore it.
- Lesson 2168 — Git vs Other Version Control Systems
- Relocation
- Relocation is the mechanism that makes this flexibility possible.
- Lesson 1334 — Relocation and Dynamic Loading
- replicated state machine
- A replicated state machine is a design pattern where multiple servers maintain identical copies of state by executing the same sequence of deterministic commands in the same order.
- Lesson 2658 — The Replicated State Machine Model
- Replication
- Replication means making complete copies of the same data on multiple nodes.
- Lesson 2637 — Introduction to ReplicationLesson 2638 — Replication vs. Partitioning
- Reporting needs
- Aggregated data is calculated repeatedly instead of pre-computed
- Lesson 1646 — Introduction to Denormalization
- Repository
- Repository is the bound album itself — once photos are glued in, they're permanently recorded
- Lesson 2171 — The Three States of Git
- Request edge
- An arrow from a process to a resource means that process is requesting that resource (process → resource)
- Lesson 1316 — Resource Allocation Graphs
- Requirements change frequently
- going back to an earlier phase is expensive and disruptive
- Lesson 2354 — Waterfall Strengths and Limitations
- residual capacity of the entire path
- The residual capacity of the entire path is the smallest (minimum) residual capacity among all edges on that path.
- Lesson 1029 — Residual Capacity of a Path
- residual network
- A residual network is a transformed version of your original flow network that shows how much more flow you can push along each edge.
- Lesson 1027 — Residual NetworksLesson 1036 — Residual Networks
- Resource Manager role
- The building manager schedules conference rooms, allocates office space, and ensures the elevator system serves all floors fairly.
- Lesson 1193 — What is an Operating System?
- resource owner
- The resource owner is typically the end user who owns the data.
- Lesson 2535 — OAuth 2.0 Roles: Resource Owner, Client, Authorization Server
- Resource planning
- If your sorting operation is Θ(n log n), you can accurately estimate server capacity, memory needs, and processing time for production workloads. Loose bounds like "at most O(n²)" lead to over-provisioning or surprises.
- Lesson 301 — Practical Applications of Tight Bounds
- Retransmission
- Lost segments are sent again, preserving the same sequence numbers
- Lesson 1476 — TCP Reliability: Retransmission
- return statement
- The return statement is how a function sends a value back to its caller.
- Lesson 189 — Return StatementsLesson 199 — Return Statements and Values
- Reusability
- The function works with any compatible type
- Lesson 2012 — Principal Types and Most General Unifiers
- Rich context
- Shows when/where/what device is trying to authenticate
- Lesson 2522 — Push Notification-Based MFA
- Ridge regression
- L2 regularization, also known as Ridge regression, adds a penalty term to your loss function that punishes large weights.
- Lesson 2812 — L2 Regularization (Ridge)
- Right child
- stores strings where the current character is greater than this node's character (alphabetically later)
- Lesson 637 — Ternary Search Trees
- right rotation
- A right rotation is like grabbing the left child and promoting it upward, making the original parent "rotate" down to become the right child.
- Lesson 535 — Single Right Rotation
- ROLLBACK
- ROLLBACK is the opposite—it tells the database: "Something went wrong.
- Lesson 1656 — Commit and Rollback Operations
- Rollback and recovery mechanisms
- Rollback and recovery mechanisms are your safety net—automated procedures that quickly revert to the last known good state when something goes wrong.
- Lesson 2393 — Rollback and Recovery Mechanisms
- root
- The root is the topmost node in the tree — it has no parent.
- Lesson 451 — Root, Parent, Child, and Sibling NodesLesson 1797 — Computation Trees in NFAs
- root node
- The root node is special—it's your entry point to the entire tree.
- Lesson 460 — Node-Based Tree StructureLesson 2838 — Decision Tree Intuition and StructureLesson 2840 — Tree Terminology: Nodes, Edges, and Leaves
- root set
- The root set is the starting point for reachability analysis.
- Lesson 2095 — Reachability and the Root Set
- Rotating left
- Rotating left means taking books from the left end and moving them to the right end.
- Lesson 254 — Array Rotation: Shifting Elements Circularly
- routing table
- A routing table is like a GPS lookup table inside every router.
- Lesson 1468 — Routing Table Fundamentals
- Row key
- A unique identifier (like a primary key)
- Lesson 1738 — Introduction to Column-Family Databases
- Rows Estimates
- The rows=1000 value shows expected row counts at each step. If actual counts (from EXPLAIN ANALYZE) differ wildly from estimates, your statistics may be stale—affecting the optimizer's join order and index selection decisions.
- Lesson 1705 — Reading and Analyzing EXPLAIN Output
- Rules
- Logical implications (grandparent(X, Z) :- parent(X, Y), parent(Y, Z) means X is Z's grandparent if X is Y's parent and Y is Z's parent)
- Lesson 2157 — What is Logic Programming?
- Runtime Analysis
- Runtime Analysis is the study of how long an algorithm takes to run as the input size grows.
- Lesson 270 — What is Runtime Analysis?
S
- Safe state
- A sequence exists where all processes can finish (even if we must carefully schedule them).
- Lesson 1323 — Deadlock Avoidance: Safe States
- Safety
- Think of a traffic light: safety means "cars from perpendicular directions never both have green lights" (no crashes), while liveness means "eventually every direction gets a green light" (traffic flows).
- Lesson 2649 — Safety and Liveness PropertiesLesson 2680 — Paxos Safety and Liveness Properties
- salt
- A salt is a random string added to each password before hashing: hash(password + salt).
- Lesson 2430 — Hash Function Applications: Password StorageLesson 2506 — Salt: Defending Against Rainbow Tables
- Same logic
- The traversal order matches recursive DFS
- Lesson 373 — Depth-First Search with Explicit Stack
- sample space
- A sample space is the set of all possible outcomes of a random experiment or process.
- Lesson 108 — Sample Spaces and EventsLesson 119 — Probability in Algorithm Analysis
- Sanitization
- Sanitization (or escaping) means transforming potentially dangerous input into a safe form.
- Lesson 2459 — Input Validation and Sanitization
- Scalability
- Less coordination overhead means systems can grow more easily
- Lesson 1236 — Multithreading Models: Many-to-ManyLesson 2697 — Eventual Consistency Definition and Motivation
- scalar subquery
- A scalar subquery is a SELECT statement nested inside another query that returns exactly one value (one row, one column).
- Lesson 1602 — Scalar Subqueries in SELECT
- Scope
- Scope is the region of your program where a variable name is visible and can be accessed.
- Lesson 207 — What is Scope?
- Search problem formulation
- Search problem formulation is the art of taking an informal problem ("get from A to B cheaply") and defining it formally using four key ingredients:
- Lesson 2734 — Search Problem Formulation
- Searching
- Searching is checking each mailbox until you find what you need.
- Lesson 239 — Common Array Operations
- Second preimage resistance
- Second preimage resistance is a related but distinct property: given a specific input and its hash, an attacker shouldn't be able to find a different input that produces the same hash.
- Lesson 2423 — Second Preimage ResistanceLesson 2424 — Collision Resistance
- second-chance algorithm
- The second-chance algorithm is essentially the same concept, sometimes with additional state (like a dirty bit to prefer clean pages).
- Lesson 1372 — LRU Approximation Algorithms
- Seeding
- Seeding means populating your test database with known data before tests run.
- Lesson 2253 — Test Data Management
- Seek time optimization becomes irrelevant
- the core problem traditional algorithms solved simply doesn't exist
- Lesson 1429 — Disk Scheduling in Modern Systems
- Segmentation
- Segmentation is a memory management scheme that divides the address space according to the program's logical structure.
- Lesson 1378 — Segmentation Basics and Motivation
- Selenium
- Selenium is the veteran of browser automation, supporting multiple programming languages (Java, Python, JavaScript, C#) and all major browsers.
- Lesson 2249 — E2E Testing Tools and Frameworks
- self join
- A self join is when you join a table to itself — essentially treating the same table as if it were two separate tables.
- Lesson 1583 — Self Join
- self-loop
- A self-loop is an edge that connects a vertex to itself.
- Lesson 687 — Self-Loops and Their Implications
- Self-Signed Certificate
- The certificate wasn't issued by a recognized CA—the server signed it itself. While the cryptography works, there's no independent verification of identity.
- Lesson 2450 — Certificate Validation and Common Errors
- semaphore
- A semaphore is a synchronization primitive built around an integer counter.
- Lesson 1292 — Semaphore Definition and Purpose
- Semaphores
- Semaphores are more flexible counters that support both mutual exclusion (binary semaphores) and resource counting (counting semaphores).
- Lesson 1303 — Semaphores vs Mutexes vs Condition Variables
- Separate chaining
- Separate chaining is one of the most straightforward solutions.
- Lesson 419 — Separate Chaining: Concept
- sequence
- In the last lesson, you learned that a sequence is an ordered list of numbers.
- Lesson 82 — Sequence Fundamentals and NotationLesson 83 — Arithmetic and Geometric Sequences
- Sequential access
- Sequential access means reading or writing data in order, from beginning to end—like reading a book page by page.
- Lesson 1391 — Sequential vs Random Access
- Sequential consistency
- Sequential consistency is a memory model that guarantees operations from each individual process appear to execute in the order that process issued them, but the interleaving of operations across different processes can vary.
- Lesson 2612 — Sequential Consistency
- sequential control flow
- In imperative programming, sequential control flow means the computer executes statements from top to bottom, line by line, just like reading a recipe.
- Lesson 2116 — Sequential Control Flow
- Sequential execution mirrors instruction flow
- The program counter in the CPU moves through memory addresses, executing instructions one after another—just like your sequential control flow
- Lesson 2120 — Memory Model in Imperative Languages
- Serialization differences
- The same data might encode differently across platforms
- Lesson 2596 — Heterogeneity of Hardware and Software
- Server
- A program that listens on a specific port, waiting for incoming connection requests. It creates a socket, binds it to an IP address and port number, then waits (listens) for clients.
- Lesson 1541 — Socket Fundamentals and Client-Server Model
- session
- A session is typically tied to a single client's connection or authenticated user.
- Lesson 2619 — Session Consistency Models
- set
- A set is simply a collection of distinct objects, called elements (or members).
- Lesson 58 — Set Fundamentals and Notation
- shard
- Sharding is a specific implementation of horizontal partitioning where data is split across multiple physically separate databases, each called a shard.
- Lesson 2684 — Sharding Fundamentals
- shard key
- The partition key (also called shard key) is the attribute you choose to make this determination.
- Lesson 2685 — Partition Keys and Shard Keys
- sharding
- Horizontal partitioning (also called sharding) scales well when you need to distribute load across many records—ideal for high-traffic applications.
- Lesson 2683 — Horizontal vs Vertical Partitioning
- Shopping cart contents
- Lost carts are annoying but not catastrophic. Relaxing Durability during browsing (before checkout) improves performance.
- Lesson 1665 — ACID Tradeoffs and Real-World Implications
- Short critical sections
- The work protected is minimal anyway
- Lesson 2574 — Performance Characteristics of Lock-Free Algorithms
- Short-circuit evaluation
- Short-circuit evaluation means the program stops evaluating as soon as it can determine the final result.
- Lesson 159 — Short-Circuit EvaluationLesson 173 — Short-Circuit Evaluation
- Shortest Paths in Unweighted Graphs
- Because BFS explores level by level, the first time it reaches any vertex is guaranteed to be via the shortest path (fewest edges) from the source. This makes it ideal for navigation problems where all moves have equal cost.
- Lesson 694 — BFS Overview and Applications
- Shrinking range
- Shrinking range means in pass 1 you compare n-1 pairs, in pass 2 you compare n-2 pairs, and so on.
- Lesson 743 — Bubble Sort: Optimization
- Siblings
- Siblings are nodes that share the same parent.
- Lesson 451 — Root, Parent, Child, and Sibling Nodes
- side effect
- This change to the program's state is called a side effect.
- Lesson 2115 — Assignment and Side Effects
- Signal encoding
- Signal encoding is the process of representing digital data as a signal suitable for transmission, and modulation is how we impress that data onto a carrier wave (especially for analog channels).
- Lesson 1443 — Signal Encoding and Modulation
- Similar train and test performance
- Both are bad (unlike overfitting where train is good, test is bad)
- Lesson 2809 — What is Underfitting?
- simple graph
- A map showing whether two cities are connected by any road. Either there's a connection or there isn't.
- Lesson 660 — Simple Graphs and Multigraphs
- Simple graphs
- Simple graphs are cleaner mathematically and more memory-efficient.
- Lesson 686 — Simple Graphs and Multigraphs
- Simple implementation
- The thread library runs entirely in user space with no kernel support needed.
- Lesson 1234 — Multithreading Models: Many-to-One
- Single node
- If tail->prev is NULL, you're deleting the only node. Both head and tail should become NULL.
- Lesson 345 — Deleting from the Tail of a Doubly Linked List
- single producer
- Messages from a single producer are delivered to consumers in the exact order sent.
- Lesson 2709 — Message Ordering Guarantees
- Single-pass array traversals
- Single-pass array traversals are the classic example:
- Lesson 285 — O(n): Linear Time
- size
- State space size is the total number of distinct states.
- Lesson 397 — Array-Based Deque ImplementationLesson 1388 — File Attributes and MetadataLesson 2735 — State Space Size and Complexity
- Small tables
- Reading the whole table is faster than index overhead
- Lesson 1702 — Index Selection for Queries
- Smaller initial size
- Uses less memory upfront, but may require frequent resizing and rehashing as items are added. Better when you expect few entries.
- Lesson 440 — Space-Time Tradeoffs in Hash Tables
- Social media feeds
- Show you posts even if some recent ones are delayed
- Lesson 1734 — Eventual Consistency Trade-offsLesson 2606 — AP Systems: Availability and Partition Tolerance
- socket
- A socket is a software endpoint that allows two programs (often on different machines) to communicate over a network.
- Lesson 1541 — Socket Fundamentals and Client-Server Model
- Soft affinity
- The scheduler tries to keep a process on the same CPU when possible, but may migrate it for load balancing. This is the default in most systems—a preference, not a rule.
- Lesson 1265 — Processor Affinity
- Soft State
- The counter might show different values to different users temporarily as updates spread
- Lesson 2699 — The BASE Model: Basically Available, Soft State, Eventual
- Softmax
- Softmax is more elegant mathematically, directly models class probabilities, and often performs better when classes are mutually exclusive.
- Lesson 2834 — Multiclass Logistic Regression
- Sorted array
- Extract is O(1), but insert requires finding position and shifting—O(n)
- Lesson 610 — Heap as Priority Queue Implementation
- Sorting
- Sorting is the process of rearranging a collection of elements so they appear in a specific order—usually ascending (smallest to largest) or descending (largest to smallest).
- Lesson 737 — What is Sorting?
- Space complexity
- Space complexity is how much counter space and how many pots you need.
- Lesson 302 — What is Space Complexity?
- spatial locality
- Spatial locality means "nearby in space." When a program accesses one memory location, it's likely to access adjacent locations soon after.
- Lesson 682 — Memory Layout and Cache PerformanceLesson 1118 — Principle of Locality
- Speed
- Lookup is O(1) once the database is built
- Lesson 1195 — Monolithic Kernel ArchitectureLesson 2168 — Git vs Other Version Control SystemsLesson 2758 — Pattern Database Heuristics
- Speed vs Size
- Inlining a function called 100 times improves speed but copies that function's code 100 times.
- Lesson 2059 — Optimization Goals and Tradeoffs
- Speedup
- Speedup refers to how much faster a task completes when parallelized.
- Lesson 2552 — Parallelism Benefits: Speed and Throughput
- splaying operation
- The splaying operation is the heart of splay trees.
- Lesson 569 — The Splaying Operation
- Sprint Backlog
- The Sprint Backlog is a subset of items selected from the Product Backlog that the Development Team commits to completing during a single sprint.
- Lesson 2378 — Scrum Artifacts: Sprint Backlog and Increment
- SSA Form
- LLVM IR uses Static Single Assignment form by default—each variable is assigned exactly once. This makes data flow analysis and optimization much simpler, as you've already learned from SSA concepts.
- Lesson 2045 — LLVM IR Overview
- Stability risk
- A bug in any kernel component (even a device driver) can crash the entire system, since everything runs with full privileges in the same space.
- Lesson 1195 — Monolithic Kernel Architecture
- stack
- The stack is a special region of memory that operates like a stack of plates: you can only add or remove items from the top.
- Lesson 356 — The Stack ADT DefinitionLesson 1102 — The Stack: PUSH and POP Operations
- Staging Area
- Staging Area is the selection tray where you place photos you've decided to include in the album
- Lesson 2171 — The Three States of Git
- starvation
- Starvation means a process waits indefinitely because other processes keep getting priority.
- Lesson 1249 — Scheduling Criteria Trade-offsLesson 1258 — Priority Inversion and AgingLesson 1318 — Deadlock vs Livelock vs Starvation
- state
- In dynamic programming, a state is a snapshot of the problem at a specific point.
- Lesson 920 — State Definition and TransitionsLesson 954 — Tree DP with Multiple States per NodeLesson 2295 — State Pattern
- state space
- A state space is the complete set of all possible configurations (states) a problem can be in, along with the actions that move you from one state to another.
- Lesson 2727 — State Space Definition and Components
- Stateless
- Server doesn't need to store session data; everything needed is in the token itself
- Lesson 2500 — Token-Based Authentication
- Statement Sequences
- A BlockNode or SequenceNode contains an ordered list of child statement nodes, representing sequential execution.
- Lesson 1979 — AST Representation of Statements
- States
- Pairs (q₁, q₂) where q₁ is a state from M₁ and q₂ is from M₂
- Lesson 1779 — DFA State DiagramsLesson 1805 — Closure Properties: Intersection
- Static typing
- Static typing means types are checked before the program runs — typically during compilation.
- Lesson 1997 — Static vs Dynamic Typing Overview
- Stop at 3NF for most applications
- BCNF and higher are often overkill unless you face specific anomalies
- Lesson 1644 — Practical Normalization Process
- Storage costs
- Less memory means cheaper cloud hosting and faster load times
- Lesson 152 — Memory and Variable Storage
- string
- A string is a data type that represents text as a sequence of characters.
- Lesson 144 — String BasicsLesson 1756 — Alphabets and Strings
- strongly typed
- This enforcement is called type safety, and languages that strictly enforce it are called strongly typed.
- Lesson 146 — Type Safety and Strong Typing
- STUDENT
- STUDENT is an entity set containing all student entities (Alice, Bob, Carol, etc.)
- Lesson 1612 — Entities and Entity Sets
- subclass
- The new class (called a subclass or child class) automatically receives all the properties and behaviors from the original class (the superclass or parent class), and can add or modify functionality without rewriting shared code.
- Lesson 2126 — Inheritance Fundamentals
- subgraph
- A subgraph is simply a graph formed by taking some vertices and edges from a larger graph.
- Lesson 667 — Subgraphs, Induced Subgraphs, and Spanning Subgraphs
- subnet mask
- A subnet mask is a 32-bit number that divides an IPv4 address into two components: the network portion (which identifies the network itself) and the host portion (which identifies individual devices on that network).
- Lesson 1463 — Subnet Masks and Network/Host Portions
- subsequence
- A subsequence is a sequence derived from another by deleting some (or zero) characters without changing the order of remaining elements.
- Lesson 925 — Longest Common Subsequence (LCS)
- subtree
- A subtree is simply a tree formed by taking any node and considering it as the root, along with all its descendants.
- Lesson 456 — Subtrees and Their Properties
- Subtyping with polymorphism
- The interaction between type hierarchies and generic types creates exponentially complex inference problems
- Lesson 2014 — Type Inference Limitations
- suffix tree
- A suffix tree is a specialized tree structure that stores all suffixes of a given string.
- Lesson 634 — Suffix Trees: Motivation and Structure
- Suffix Trees
- Suffix Trees are memory-heavy but lightning-fast for advanced string operations.
- Lesson 640 — Trie Variant Performance Comparison
- sum type
- A sum type represents a choice between alternatives—one value OR another, but not both.
- Lesson 2140 — Algebraic Data Types
- Swapping
- Swapping is the process of moving pages from RAM to disk storage (called the backing store or swap space) and bringing them back when needed.
- Lesson 1340 — Address Translation OverviewLesson 1347 — Swapping and Backing Store
- symbol table
- A symbol table is a data structure that stores information about these identifiers so the compiler can look them up quickly throughout the compilation process.
- Lesson 444 — Symbol Tables in CompilersLesson 1946 — Symbol Tables and Identifiers
- symbolic link
- A symbolic link (symlink) is a special file that contains a pathname string pointing to another file.
- Lesson 1419 — Hard Links vs Symbolic Links
- symmetric cryptography
- Meanwhile, symmetric cryptography (like AES) is blazingly fast and efficient, but requires both parties to somehow share a secret key securely beforehand.
- Lesson 2416 — Hybrid Cryptosystems
- Symmetry
- Symmetry means if a is in [b], then b is in [a] — they share the same class
- Lesson 73 — Equivalence Classes and Partitions
- system call
- Think of a restaurant: A system call is you pressing the call button for your waiter—you initiate it when ready.
- Lesson 1214 — System Calls vs Interrupts: Comparison
- System calls
- System calls are the official requests your program makes to the kernel.
- Lesson 1203 — What Are System Calls?Lesson 1214 — System Calls vs Interrupts: Comparison
- System utilities
- System utilities are small, specialized programs that perform common tasks:
- Lesson 1202 — System Utilities and User Interface
T
- Tabular Data
- Spreadsheets, datasets, and matrices are naturally 2D. If you're tracking student grades across multiple tests, grades[student][test] organizes the information intuitively.
- Lesson 249 — Practical Applications of Multidimensional Arrays
- tail call optimization
- This optimization (called tail call optimization) prevents stack overflow and makes recursion as efficient as loops.
- Lesson 227 — Tail Recursion
- tail recursion
- In the previous lesson, you learned that tail recursion is when the recursive call is the very last operation in a function—no additional work happens after the call returns.
- Lesson 228 — Converting Tail Recursion to Iteration
- tape
- The tape is an unbounded sequence of cells extending infinitely in both directions.
- Lesson 1851 — Components of a Turing Machine
- Target leakage
- A feature wouldn't actually be available at prediction time (e.g., using "total_purchase_amount" to predict "will_make_purchase")
- Lesson 2805 — Data Leakage Prevention
- tautology
- A tautology is a proposition that is always true, no matter what truth values its variables have.
- Lesson 43 — Tautologies and Contradictions
- TCP segment
- A TCP segment is the fundamental unit of data transmission in TCP.
- Lesson 1472 — TCP Segment Structure
- TCP state machine
- The TCP state machine is a formal model with approximately 11 states that govern every TCP connection.
- Lesson 1482 — TCP States and State Machine
- Temporal locality
- Temporal locality means "nearby in time." When a program accesses a memory location, it's likely to access that same location again soon.
- Lesson 1118 — Principle of Locality
- Temporary inconsistencies
- Temporary inconsistencies are tolerated—different replicas may return different values for a short period
- Lesson 2614 — Eventual Consistency Overview
- terminal state
- In adversarial search (like chess or tic-tac-toe), a terminal state is a game position where no more moves are possible—the game is over.
- Lesson 2767 — Terminal States and Utility Functions
- test case
- A test case is a single, specific scenario designed to verify a piece of software behavior.
- Lesson 2219 — Test Cases and Test Suites
- Test data
- A completely separate dataset held back during training. After the model is trained, we evaluate it on this unseen data to measure how well it generalizes.
- Lesson 2777 — Training Data vs Test Data
- Test doubles
- Test doubles are stand-ins that replace these dependencies during tests—like stunt doubles in movies.
- Lesson 2230 — Mocking and Test Doubles
- test fixture
- A test fixture is the fixed state and resources that exist before your test runs.
- Lesson 2229 — Test Fixtures and Setup
- test scenario
- A test scenario is a specific instance of that journey you'll verify works correctly.
- Lesson 2248 — Test Scenarios and User Journeys
- test suite
- A test suite is an organized collection of related test cases grouped together for execution.
- Lesson 2219 — Test Cases and Test Suites
- Testability
- Smaller methods are easier to unit test in isolation.
- Lesson 2319 — Extract Method: Breaking Down Complex Functions
- Testing
- Testing is the systematic process of executing your software to reveal defects—you're actively searching for problems by running the code under various conditions.
- Lesson 2216 — Testing vs Debugging
- Testing bottleneck
- You can't test until everything is complete
- Lesson 2236 — Big Bang Integration Strategy
- Testing difficulty
- Long methods are harder to test thoroughly because they have more execution paths and dependencies.
- Lesson 2330 — Long Method Smell
- Think of it like this
- Dijkstra's is like following the shortest routes on a map systematically. Bellman-Ford is like trying every possible route V-1 times until you're sure you've found the shortest ones.
- Lesson 986 — Bellman-Ford Time Complexity
- thrashing
- However, excessive swapping (called thrashing) can grind the system to a halt when the disk becomes the bottleneck.
- Lesson 1347 — Swapping and Backing Store
- thread
- Creating a new thread is much cheaper because it reuses the existing process's resources—only a small stack and thread-specific data structures need allocation.
- Lesson 1230 — What is a Thread?Lesson 1231 — Threads vs Processes
- Thread safety
- Thread safety means that your code behaves correctly when multiple threads access the same data or resources at the same time.
- Lesson 2554 — What is Thread Safety?
- three-valued logic
- This is called three-valued logic: comparisons can be TRUE, FALSE, or UNKNOWN (NULL).
- Lesson 1558 — NULL Values and Their Semantics
- throughput
- Think of a restaurant kitchen: CPU utilization is how much of the day your chef is actually cooking (not standing idle), while throughput is how many meals get served to customers per hour.
- Lesson 1245 — CPU Utilization and ThroughputLesson 1444 — Bandwidth and Throughput
- Time complexity
- O(n log k) where n is the total elements—much better than O(n log n) for full sorting when k is small.
- Lesson 618 — Top-K Elements Problem
- time quantum
- Round Robin (RR) is a preemptive scheduling algorithm that gives each process a small, fixed amount of CPU time called a time quantum or time slice (typically 10-100 milliseconds).
- Lesson 1255 — Round Robin (RR) Scheduling
- Time-to-market matters
- waiting for complete delivery means competitors may ship first
- Lesson 2354 — Waterfall Strengths and Limitations
- Timeout
- Operations taking too long (if timeouts are configured)
- Lesson 1550 — Error Handling and Socket Shutdown
- TLB hit
- A TLB hit means translation happens in hardware at CPU speed.
- Lesson 1350 — Virtual Memory Performance Considerations
- Tokens
- Tokens are the categories or types of elements (like "identifier," "number," or "operator")
- Lesson 1939 — Tokens, Lexemes, and Patterns
- tombstone
- A tombstone is a special marker that says "this key was deleted at timestamp X." Instead of erasing data on DELETE, the system writes a tombstone value.
- Lesson 1731 — DELETE and Tombstones
- top
- The peek operation (also called top) lets you look at the element on top of the stack without removing it.
- Lesson 359 — Peek (or Top) Operation
- Top-down parsers
- Top-down parsers are simpler to implement manually.
- Lesson 1974 — Bottom-Up vs Top-Down Tradeoffs
- topological ordering
- A topological ordering is a linear arrangement of all vertices in a directed graph such that for every directed edge from vertex u to vertex v, u comes before v in the ordering.
- Lesson 719 — What is Topological Sorting?
- total disk access time
- The total disk access time is the sum of three distinct mechanical delays:
- Lesson 1422 — Disk Access Time Components
- total node count
- The total node count is straightforward: count yourself (1), plus all nodes in your left subtree, plus all nodes in your right subtree.
- Lesson 492 — Calculating Tree Metrics
- Total Space
- Total Space is the sum of all memory your algorithm uses—both the input data and any extra memory needed during execution.
- Lesson 303 — Auxiliary Space vs Total Space
- Training data
- The dataset the model learns from. The algorithm examines these examples, identifies patterns, and adjusts its internal parameters to minimize errors on this data.
- Lesson 2777 — Training Data vs Test Data
- Training Set
- The data used to teach the model patterns, adjust weights, and optimize the objective function
- Lesson 2796 — Training Set vs Test Set
- transaction
- A transaction is a single, logical unit of work that consists of one or more database operations (like reads, updates, inserts, or deletes) that must be completed together or not at all.
- Lesson 1654 — Introduction to Database Transactions
- transition
- A transition is the rule for moving from one state to another.
- Lesson 920 — State Definition and Transitions
- transition function
- The transition function is the rulebook that determines what happens next.
- Lesson 1853 — States and Transition Functions
- transition rule
- A transition rule is like one line in that recipe: "If you're in state A and see symbol X, then write symbol Y, move your position (left or right or stay), and switch to state B."
- Lesson 1855 — Transition Rules and Execution
- transition table
- A transition table is a 2D data structure that encodes all the state transitions of your DFA in a format a program can efficiently traverse.
- Lesson 1943 — Building a Transition Table
- transitive closure
- This yes/no reachability question is called transitive closure.
- Lesson 998 — Transitive Closure with Floyd-Warshall
- trapdoor function
- A trapdoor function is like a door that's easy to walk through in one direction but nearly impossible to go back through—unless you know the secret mechanism (the "trapdoor") that opens it from the other side.
- Lesson 2407 — Trapdoor Functions
- Traversing
- Traversing means visiting each node in a structured way and performing operations on it.
- Lesson 1981 — Traversing Abstract Syntax Trees
- tree
- A tree is a hierarchical data structure made up of nodes connected by edges, with one special node called the root at the top.
- Lesson 450 — What is a Tree? Definition and Motivation
- Tree edges
- Edges that connect a parent to its child in the BFS tree. These are edges we use to discover new vertices.
- Lesson 700 — BFS Tree and Parent Tracking
- Tree height
- Tree height is the height of the root node — equivalently, it's the maximum depth of any node in the tree.
- Lesson 455 — Tree Height and Level
- Tree traversal
- Tree traversal is the process of visiting each node in a tree exactly once, in a specific, systematic order.
- Lesson 468 — What is Tree Traversal?
- trees
- Undirected acyclic graphs are called trees or forests (multiple disconnected trees).
- Lesson 663 — Cycles and Acyclic Graphs
- Tri-color marking
- Tri-color marking is an incremental algorithm that breaks this work into smaller steps, allowing the collector to run alongside your program with minimal pauses.
- Lesson 2099 — Tri-Color Marking
- Trivial dependencies
- Trivial dependencies are always true but useless for design.
- Lesson 1622 — Functional Dependency Notation and Terminology
- Trust over legal protection
- The relationship is built on mutual trust and transparency
- Lesson 2364 — Customer Collaboration Over Contract Negotiation
- truth table
- A truth table is a chart that shows all possible combinations of Boolean inputs and their resulting outputs for a logical operation.
- Lesson 13 — Boolean Values and Truth Tables
- Tuples
- Many languages let you bundle values into a lightweight container called a tuple. The function packs values together, and the caller unpacks them.
- Lesson 200 — Multiple Return ValuesLesson 1987 — Composite Types: Products
- Turing Machine
- A Turing Machine is a theoretical computing device that manipulates symbols on an infinite tape according to a set of rules.
- Lesson 1850 — What is a Turing Machine?
- Turnaround Time
- Turnaround Time is the total elapsed time between when a process is submitted (arrives) to the system and when it finishes execution completely.
- Lesson 1246 — Turnaround Time
- Two disjoint sets
- The vertices are partitioned into two groups with no overlap
- Lesson 689 — Bipartite Graphs
- Two zeros
- Unlike what you might expect, one's complement has both +0 (all zeros: 0000 0000) and -0 (all ones: 1111 1111), which is awkward for hardware
- Lesson 1058 — One's Complement Representation
- Type annotations
- In statically typed languages, type annotations are explicit declarations where you tell the compiler exactly what type a variable, parameter, or return value should be.
- Lesson 1995 — Type Annotations and SignaturesLesson 2000 — Type Annotations in Static Languages
- Type constraints
- Enforce that age is a number, not a string
- Lesson 1725 — Schema Validation and Flexibility
- Type errors in dynamic languages
- Caught when the operation is attempted
- Lesson 2032 — Error Detection: Compile-Time vs Runtime
- Type inference
- Type inference is a compiler feature that lets you skip writing the type name — the compiler analyzes the value you assign and infers (deduces) the correct type automatically.
- Lesson 149 — Type InferenceLesson 2007 — What is Type Inference?
- Type information in ASTs
- Type information in ASTs means augmenting each AST node with metadata that records what type that node represents or produces.
- Lesson 1983 — Type Information in ASTs
- type safety
- Type safety means that a program is free from type errors—situations where operations are applied to values of incompatible types.
- Lesson 146 — Type Safety and Strong TypingLesson 1989 — Type Safety and Type Soundness
- Type soundness
- Type soundness is the guarantee: the inspection process is rigorous enough that it actually achieves that goal
- Lesson 1989 — Type Safety and Type Soundness
- type system
- A type system is a set of rules that assigns a type (a classification) to every value and expression in a program.
- Lesson 1985 — What is a Type System?
U
- undecidable language
- An undecidable language is one where no such TM exists.
- Lesson 1869 — Decidable vs. Undecidable Languages
- underflow
- Unlike insertion, which may cause nodes to grow and split, deletion can make nodes shrink below their minimum capacity—creating what's called underflow.
- Lesson 1683 — Deletion from Leaf Nodes
- Unification
- Unification is the algorithm that solves these puzzles.
- Lesson 2010 — Type Variables and Unification
- Uniform input size
- The signature algorithm always receives predictable-length input
- Lesson 2436 — Hash-then-Sign Paradigm
- Union
- If L₁ and L₂ are CFLs, then L₁ ∪ L₂ is also a CFL. You can build a new grammar with a new start symbol S that derives either grammar: S → S₁ | S₂, where S₁ and S₂ are the original start symbols.
- Lesson 1803 — Closure Properties: Union and ConcatenationLesson 1848 — Closure Properties of CFLs
- Uniqueness
- The principal type is essentially unique (up to renaming)
- Lesson 2012 — Principal Types and Most General Unifiers
- unit production
- A unit production is a grammar rule where one nonterminal produces exactly one other nonterminal, like A → B.
- Lesson 1824 — Eliminating Unit Productions
- Unit testing
- Unit testing is the practice of testing the smallest, most isolated pieces of your code—typically individual functions, methods, or classes—in complete isolation from the rest of the system.
- Lesson 2224 — What is Unit Testing?
- Unit tests
- Unit tests are cheap, run in milliseconds, and pinpoint exact failures.
- Lesson 2217 — The Testing Pyramid
- universal gates
- These gates are called universal gates because each one can create every other gate you've learned.
- Lesson 18 — NAND and NOR Gates
- Unreachable branches
- Code after a return statement, or inside an if (false) block when constant propagation has determined the condition is always false
- Lesson 2063 — Dead Code Elimination
- Unsorted array
- Insert is O(1), but extract requires scanning all elements—O(n)
- Lesson 610 — Heap as Priority Queue Implementation
- Untracked files
- Untracked files are files in your working directory that Git isn't monitoring at all—you've never added them, so Git ignores them unless you explicitly stage them.
- Lesson 2174 — Checking Repository Status
- Untrusted Root
- The certificate chain doesn't lead back to any CA your browser recognizes.
- Lesson 2450 — Certificate Validation and Common Errors
- Unweighted graph
- A map showing which cities have direct flights between them. Either a flight exists or it doesn't.
- Lesson 659 — Weighted vs Unweighted Graphs
- URI
- Imagine ordering at a restaurant: the method is whether you're ordering, paying, or canceling; the URI is the menu item number; headers are dietary preferences or instructions; the body is any customization details.
- Lesson 1515 — HTTP Request Structure
- user journey
- A user journey is a complete path a user takes through your application to accomplish a goal—from logging in, to browsing products, to checking out.
- Lesson 2248 — Test Scenarios and User Journeys
- User mode
- User mode is the standard employee badge—you can access your office and common areas, but trying to enter the server room triggers an alarm.
- Lesson 1194 — OS Kernel and User Space
- User Threads
- User threads are lightweight and fast to create/switch between (no kernel involvement), but cannot take advantage of multiple CPU cores, and if one blocks on I/O, the whole process blocks.
- Lesson 1233 — User Threads vs Kernel Threads
V
- Valgrind
- A powerful tool that tracks every allocation and reports leaks when your program exits.
- Lesson 2087 — Memory Leaks: Causes and Detection
- Validation
- Validation means checking that input matches your expectations.
- Lesson 2459 — Input Validation and Sanitization
- Value ranges
- Validate that quantity is positive or status is one of a few allowed values
- Lesson 1725 — Schema Validation and Flexibility
- Values
- Values are opaque blobs of data (strings, JSON, binary data)
- Lesson 1711 — Key-Value Store Fundamentals
- variable
- A variable is a named storage location in a computer's memory that holds a value while your program runs.
- Lesson 138 — What is a Variable?
- vector clock
- A vector clock is an array of counters, one for each process in the system.
- Lesson 1735 — Vector Clocks and Conflict ResolutionLesson 2631 — Vector Clocks Fundamentals
- Venn diagram
- A Venn diagram is a visual tool that uses overlapping circles (or other shapes) to show how sets relate to each other.
- Lesson 64 — Venn Diagrams
- Version control systems
- Version control systems (VCS) are tools that track every change made to files over time.
- Lesson 2167 — What is Version Control?
- viable prefix
- A viable prefix is any prefix of a right-sentential form that doesn't extend past the end of its handle.
- Lesson 1961 — Handles and Viable Prefixes
- Vigenère Cipher
- The Vigenère Cipher is the most famous polyalphabetic cipher.
- Lesson 2398 — Polyalphabetic Ciphers and the Vigenère Cipher
- virtual address space
- The virtual address space is the range of addresses a program can potentially use—often starting at 0 and extending to some large number (like 2³² or 2⁶⁴).
- Lesson 1342 — Virtual vs Physical Address Spaces
- Volatile variables
- A write to a volatile field happens-before every subsequent read of that field
- Lesson 2564 — Happens-Before Relationship
- vs. Document Stores
- Instead of storing complete documents, column-family stores optimize for reading/writing specific column groups. Documents are self-contained units; column families are distributed across the cluster for scalability.
- Lesson 1738 — Introduction to Column-Family Databases
W
- wait-signal pattern
- The wait-signal pattern is the standard recipe for using condition variables correctly.
- Lesson 1306 — The Wait-Signal Pattern
- walk
- A walk is any sequence of vertices where each consecutive pair is connected by an edge.
- Lesson 662 — Paths and Walks
- weak entity
- In ER modeling, a weak entity is an entity that cannot be uniquely identified by its own attributes alone.
- Lesson 1619 — Weak Entities and Identifying Relationships
- weak reference
- A weak reference is like a regular pointer, but with a crucial difference: it observes an object without claiming ownership.
- Lesson 2108 — Weak References
- Webhooks
- The Git hosting service (GitHub, GitLab, Bitbucket) sends an HTTP notification to your CI system immediately when an event occurs. Think of it like a doorbell—the repository actively alerts the CI server: "Hey, someone just pushed code!"
- Lesson 2385 — Version Control Integration
- weight
- Each edge carries a numeric value called a weight that represents some meaningful quantity.
- Lesson 659 — Weighted vs Unweighted Graphs
- Weighted graph
- The same map, but now each flight edge shows the distance in miles, ticket price, or flight duration. The connection exists and has a meaningful number attached.
- Lesson 659 — Weighted vs Unweighted Graphs
- Well-ordering
- Well-ordering is a special total order where every non-empty subset has a smallest element (like natural numbers: 0, 1, 2, ...).
- Lesson 75 — Total Orders and Chains
- wᵢ
- Each wᵢ is a weight (like the slope m, but one per feature)
- Lesson 2817 — The Linear Model Equation
- Within your session
- The system honors guarantees like "you'll always see your own writes" or "you won't see data go backward in time."
- Lesson 2619 — Session Consistency Models
- Working Directory
- Working Directory is your desk where you arrange and edit photos
- Lesson 2171 — The Three States of Git
- working set
- The working set is the collection of memory locations your program accesses frequently during a particular time window.
- Lesson 1143 — Types of Cache Misses: CapacityLesson 1350 — Virtual Memory Performance Considerations
- worst-case AVL tree
- The worst-case AVL tree is one that's just barely balanced—every node has a balance factor of ±1.
- Lesson 543 — AVL Tree Height Analysis
- write-back stage
- The write-back stage is the final step of the instruction cycle where the CPU takes the result produced during the execute or memory access stages and stores it in its proper destination—typically a register in the register file, or sometimes a memory location.
- Lesson 1088 — Write-Back Stage
- Write-through
- Every change you make gets immediately saved to the main document on disk. Safer (your work is always backed up), but slower because each write waits for disk I/O.
- Lesson 1409 — Buffer Cache and Write Policies
- Writers
- A writer requires exclusive access—no other readers or writers can hold the lock at the same time.
- Lesson 1289 — Reader-Writer Locks Introduction
- Wrong
- ab|c+ → means "ab OR one-or-more cs"
- Lesson 1774 — Precedence and Parentheses in Regular Expressions
X
- xᵢ
- Each xᵢ is a different feature (square footage, bedrooms, etc.)
- Lesson 2817 — The Linear Model Equation
Y
- YAML
- Languages like JSON and YAML are Domain-Specific Languages (DSLs) designed specifically for configuration.
- Lesson 2152 — Configuration Files and DSLs