← Back to Computer Science

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
ACLs are fast—check if user ID is in the list.
Lesson 2533 — Authorization Model Tradeoffs
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
Act
Act is the single action you're testing.
Lesson 2225 — Anatomy of a Unit Test
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
alphabet
An alphabet is simply a finite set of symbols.
Lesson 1756 — Alphabets and Strings
Amortization
Occasional rehashing costs are spread across many operations
Lesson 433 — Average-Case Time Complexity Analysis
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
Arithmetic operations
a + b or x * 2 are single operations
Lesson 283 — O(1): Constant Time
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
Author
The name and email of the person who made the commit.
Lesson 2175 — Viewing Commit History
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)
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
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
BOOK
BOOK is an entity set containing all book entities
Lesson 1612 — Entities and Entity Sets
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
Bug multiplication
A single defect exists in multiple places
Lesson 2332 — Duplicate Code Smell
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
Caching layers
Temporary inconsistency is expected
Lesson 1734 — Eventual Consistency Trade-offs
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
The function being called
Lesson 188 — Calling Functions
Callee-saved
The called function must preserve these and restore them before returning
Lesson 2056 — Function Call Code Generation
Caller
The code that invokes the function
Lesson 188 — Calling Functions
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
capacity constraints
These rules are called capacity constraints.
Lesson 1024 — Capacity Constraints
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
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
Comparison
Quickly check if two values are different
Lesson 35 — Exclusive OR (XOR)
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
Yes, if all step costs are positive
Lesson 2746 — Uniform-Cost Search
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
The object whose behavior changes (e.g., VendingMachine)
Lesson 2295 — State Pattern
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
Current page
The paper on top of your "back stack"
Lesson 372 — Browser History Navigation
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
Deadlock
Deadlock is a permanent blocking situation.
Lesson 1318 — Deadlock vs Livelock vs Starvation
Debugging
Debugging is what happens after a test fails.
Lesson 2216 — Testing vs Debugging
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
degenerate
This is called a degenerate or skewed BST.
Lesson 523 — Worst-Case BST Analysis
Degree
The number of edges connected to a vertex
Lesson 657 — What is a Graph? Vertices and Edges
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
derived table
This is called a derived table or inline view.
Lesson 1608 — Subqueries in FROM Clause
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
Deterministic
The same input always produces the same hash
Lesson 2420 — What is a Hash Function?
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
Enqueue
A new car joins the back of the line
Lesson 376 — Essential Queue Operations
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 Class
Extract Class is your primary refactoring tool.
Lesson 2338 — Divergent Change Smell
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?
Failures happen
The current leader might crash mid-coordination
Lesson 2655 — Leader Election Basics
Fast allocation
the free space is contiguous; just bump a pointer
Lesson 2097 — Copying Collection
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 to review
less cognitive load means quicker turnaround
Lesson 2342 — Preparing Code for Review
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?
Fixed capacity
The table has a maximum size
Lesson 422 — Open Addressing: Concept
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
game tree
A game tree is a state-space representation where:
Lesson 2765 — Game Trees and Ply Depth
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
GET
GET is used to retrieve data from a server.
Lesson 1516 — HTTP Methods: GET and POST
Gini
Gini is computationally cheaper (no logarithms)
Lesson 2844 — Impurity Measures: Gini Index
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
Hasse diagram
A Hasse diagram is a visual way to represent partial orders.
Lesson 74 — Partial Orders
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
hub
A hub is a simple, unintelligent repeater.
Lesson 1454 — Network Switches vs Hubs
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
Identity
Keys are already 0 to N-1
Lesson 410 — Hashing Integers
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-degree
The number of edges coming into the vertex
Lesson 661 — Degree of a Vertex
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
Inserting
Inserting means adding a new mailbox and renumbering.
Lesson 239 — Common Array Operations
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
The data cannot be modified without detection
Lesson 1524 — Introduction to HTTPS
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
Invalid
Has a gap (node 6 exists but node 5 is missing)
Lesson 576 — Complete Binary Tree Property
inversion
This operation is also called inversion or negation.
Lesson 14 — The NOT Gate (Inverter)
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
K₃
A triangle (3 vertices, 3 edges)
Lesson 688 — Complete 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
Keys are unique identifiers (strings, numbers, UUIDs)
Lesson 1711 — Key-Value Store Fundamentals
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
Labels
Labels are what you're trying to predict.
Lesson 2776 — Features and Labels
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
Less prone to overfitting
Complexity is naturally constrained
Lesson 2811 — L1 Regularization (Lasso)
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
LISTEN
Server is waiting for incoming connection requests
Lesson 1482 — TCP States and State Machine
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
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
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
Minimize data movement
Transferring terabytes is expensive
Lesson 2691 — Rebalancing Partitions
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

n₀
n₀ is the point beyond which the relationship holds
Lesson 297 — Formal Definition of Big-Omega
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
NAND
NAND means "NOT AND" — it's an AND gate followed by a NOT gate.
Lesson 18 — NAND and NOR Gates
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 duplicate work
Each node is expanded at most once
Lesson 1004 — Consistent (Monotonic) Heuristics
No fault tolerance
If a thread holding a lock crashes, all waiting threads are stuck
Lesson 2566 — Introduction to Lock-Free Programming
No fragmentation
objects are compacted as they're copied
Lesson 2097 — Copying Collection
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?
NOR
NOR means "NOT OR" — it's an OR gate followed by a NOT gate.
Lesson 18 — NAND and NOR Gates
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
not isRaining
True if isRaining is false
Lesson 172 — Logical Operators: AND, OR, NOT
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
Observers
Observers are subscribers who want updates
Lesson 2289 — Observer Pattern Fundamentals
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
Older systems
sometimes called a "file descriptor block"
Lesson 1397 — File Control Blocks and Inodes
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)
ORDER
ORDER is an entity set containing all order entities
Lesson 1612 — Entities and Entity Sets
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
Originator
The object whose state you want to save (e.g., a TextEditor)
Lesson 2298 — Memento Pattern
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
Out-degree
The number of edges going out from the vertex
Lesson 661 — Degree of a Vertex
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 ⊆ 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
P vs. NP
the million-dollar question!
Lesson 1897 — Complexity Class Hierarchy
p^k
p^k is the probability all k successes occur
Lesson 125 — Binomial Distribution
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
Pages
Pages are fixed-size blocks of logical (virtual) memory
Lesson 1352 — Pages and Frames
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
Position-sensitive
The string's order matters naturally
Lesson 411 — Hashing Strings: Basic Approach
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
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
Readability
The code's structure mirrors the data's structure
Lesson 2141 — Pattern Matching
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
Resource pooling
Resource pooling is the classic use case.
Lesson 394 — Queue Variant Applications
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
RISC-V
An open-source ISA gaining popularity
Lesson 1092 — Instruction Set Architecture (ISA)
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 exception
The root can have as few as one key.
Lesson 1677 — B-Tree Structure and Properties
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
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
Schema
Schema is the structure definition of your database.
Lesson 1553 — Schemas and Instances
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
Shotgun Surgery
Shotgun Surgery is exactly this problem in code.
Lesson 2337 — Shotgun Surgery Smell
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
Small datasets
Small datasets are especially vulnerable.
Lesson 2801 — Holdout Method Limitations
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
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
Sorted portion
the leftmost part, grows one element at a time
Lesson 744 — Selection Sort: Algorithm
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 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
subject
The subject is the publisher that holds the data
Lesson 2289 — Observer Pattern Fundamentals
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
TLB miss
This is called a TLB miss, and it requires special handling.
Lesson 1363 — TLB Miss Handling
TLS handshake
The TLS handshake is this negotiation process.
Lesson 1525 — HTTPS Handshake Process
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
Too many fields
The class tracks dozens of instance variables
Lesson 2331 — Large Class Smell
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 more stable
The model sees representative data
Lesson 2799 — Stratified Sampling
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
Transitions
Transitions are arrows connecting states.
Lesson 1779 — DFA State Diagrams
transitive closure
This yes/no reachability question is called transitive closure.
Lesson 998 — Transitive Closure with Floyd-Warshall
transitivity
This is called transitivity of reductions.
Lesson 1936 — Reduction Chains
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?
TypeScript
TypeScript is the most prominent example.
Lesson 2005 — Gradual Typing Systems

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
Unused computations
Variables that are assigned but never read
Lesson 2063 — Dead Code Elimination
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
O(degree) if B is last or absent
Lesson 674 — Adjacency List: Operations and Complexity
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

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