Computer Science Glossary

Key terms from the Computer Science course, linked to the lesson that introduces each one.

6,287 terms.

#

-1, 0, or +1: .; Lesson 531 — AVL Tree Definition and Balance Property Lesson 533 — Calculating Balance Factors
`git fetch`: Downloads new data from the remote and updates your remote-tracking branches (`origin/main` etc.; Lesson 2192 — Remote Branches Lesson 2203 — Synchronizing with Remotes
`git pull`: Fetches *and* merges the remote branch into your current local branch (essentially `fetch` + `merge`); Lesson 2192 — Remote Branches Lesson 2203 — Synchronizing with Remotes
`git push`: Uploads your local branch commits to the remote repository; Lesson 2192 — Remote Branches Lesson 2203 — Synchronizing with Remotes
`signal()`: (also called V operation); Lesson 1296 — Mutual Exclusion with Binary Semaphores Lesson 1309 — Signal vs Broadcast
0/1 Knapsack Problem: (where you can't take fractions of items): *"Always pick the item with highest value first.; Lesson 911 — Counterexamples: When Greedy Fails Lesson 931 — Unbounded Knapsack Problem
1 sign bit: Determines if the number is positive (0) or negative (1); Lesson 1065 — IEEE 754 Standard: Single Precision Lesson 1066 — IEEE 754 Standard: Double Precision
2n: space—still O(n), but with a notable constant multiplier.; Lesson 310 — Space Complexity of Common Data Structures Lesson 597 — Build Heap Time Complexity: O(n) Proof
3n/2 comparisons: instead of 2n (if you found max and min separately), saving about 25% of comparisons—valuable when working with massive datasets.; Lesson 252 — Finding Maximum and Minimum Elements Lesson 829 — Simultaneous Min and Max
8 bits: 0 to 255 (2⁸ = 256 values); Lesson 1062 — Integer Width and Range Tradeoffs Lesson 1462 — Network Classes and CIDR Notation

A

AAAA record: (pronounced "quad-A") does the exact same job, but for **IPv6 addresses**.; Lesson 1504 — DNS Record Types: A and AAAA
AAAA records: these are the core mappings that make the web browsable.; Lesson 1504 — DNS Record Types: A and AAAA
ABAC: offers maximum flexibility—you can express complex policies based on any attribute (time, location, resource sensitivity, user clearance).; Lesson 2533 — Authorization Model Tradeoffs
Abort all deadlocked processes: – Simple but wasteful; all progress is lost; Lesson 1327 — Deadlock Recovery Strategies
Above upper threshold: Allocate more frames to this process; Lesson 1376 — Page Fault Frequency
Absolute: start from root (`/home/alice/documents`); Lesson 1414 — Tree-Structured Directories
Absolute Error: Treats all miss distances more uniformly; Lesson 2779 — Loss Functions and Objective Functions
absolute path: specifies the complete location from the **root** of the file system.; Lesson 1390 — File Paths: Absolute vs Relative Lesson 1415 — Absolute vs Relative Paths
Absorbing phase: The input message is broken into blocks and XORed into part of the internal state, with each block processed through a permutation function; Lesson 2428 — SHA-3 and Keccak
Abstract classes: let you create partially implemented blueprints—they can have some complete methods and some incomplete ones (called abstract methods) that subclasses must implement.; Lesson 2128 — Abstract Classes and Interfaces
Abstract Data Type (ADT): is like a blueprint or contract that describes *what* a data structure can do, without specifying *how* it does it.; Lesson 355 — What is an Abstract Data Type (ADT)?
Abstract Factory: Select when you need to create families of related objects that must work together (UI components for different platforms).; Lesson 2273 — Choosing the Right Creational Pattern
Abstract Factory Pattern: provides an interface for creating these related object families without specifying their exact classes.; Lesson 2269 — Abstract Factory Pattern
Abstract Syntax Tree: that becomes your compiler's first IR.; Lesson 2039 — Abstract Syntax Trees (ASTs) as IR
abstract syntax tree (AST): , on the other hand, strips away the syntactic "scaffolding" and keeps only the semantically meaningful structure.; Lesson 1847 — Parse Tree vs. Abstract Syntax Tree Lesson 1975 — What is an Abstract Syntax Tree (AST)?Lesson 1977 — From Parse Tree to AST Lesson 1978 — AST Representation of Expressions
Abstraction: Same operations work across different storage devices; Lesson 1386 — File Abstraction and Basic Operations
Abstraction benefits: CSS separates styling from structure.; Lesson 2156 — Benefits and Trade-offs of Declarative Style
Abstraction hierarchy: High-level logic (e.; Lesson 2275 — Bridge Pattern: Separating Abstraction from Implementation
Abstraction Layer: – The OS hides the complex, messy details of hardware from application programmers.; Lesson 1193 — What is an Operating System?
Abstraction layer role: Tenants don't need to understand the electrical wiring, HVAC systems, or plumbing blueprints— they just flip switches, adjust thermostats, and turn on faucets.; Lesson 1193 — What is an Operating System?
Abstraction leaks: Implementation details exposed through interfaces; Lesson 2347 — Evaluating Design and Architecture
ACCEPT: Lesson 1780 — DFA Computation and Acceptance Lesson 1833 — Designing PDAs for Simple Languages Lesson 1836 — Converting CFGs to PDAs Lesson 1859 — Languages Recognized by Turing Machines Lesson 1962 — Shift-Reduce Parsing Actions Lesson 1966 — LR(0) Parsing Tables
Accept if: You've read the entire string AND the stack is empty; Lesson 1834 — PDAs for Balanced Parentheses
Accept input: (called parameters or arguments) — like numbers to average; Lesson 185 — What is a Function?
Accept Request: to acceptors, asking them to accept a specific value with the proposal number that was promised.; Lesson 2677 — Phase 2a: Accept Request
accept state: (also called a final state); Lesson 1780 — DFA Computation and Acceptance Lesson 1856 — Accepting and Rejecting States
Accept states: (also called final states) are drawn as **double circles** — two concentric circles instead of one.; Lesson 1779 — DFA State Diagrams Lesson 1784 — Combining Conditions with Product Construction Lesson 1786 — DFAs for Union of Languages Lesson 1805 — Closure Properties: Intersection
Accept the job: if there's a free time slot; otherwise skip it; Lesson 891 — Job Sequencing with Deadlines
Acceptance Testing: Lesson 2355 — The V-Model: Verification and Validation
Accepted notification: to all learners.; Lesson 2678 — Phase 2b: Accepted Notification
Accepting states: Any DFA state containing at least one NFA accepting state becomes an accepting state.; Lesson 1800 — Subset Construction: NFA to DFA Conversion Lesson 1810 — Minimizing DFAs Using Equivalence Classes Lesson 1828 — Introduction to Pushdown Automata Lesson 1943 — Building a Transition Table
Acceptors: form the voting body that decides which value becomes consensus.; Lesson 2673 — Paxos Roles: Proposers, Acceptors, and Learners
accepts: a string if and only if:; Lesson 1780 — DFA Computation and Acceptance Lesson 1797 — Computation Trees in NFAs Lesson 1856 — Accepting and Rejecting States Lesson 1875 — Recognizable vs. Decidable
Access control: Determining which device can transmit on a shared medium (like WiFi); Lesson 1434 — OSI Layer 2: Data Link Layer
Access Control Lists (ACLs): , which allow fine-grained control beyond the simple user/group/other model, specifying permissions for individual users or groups.; Lesson 1392 — File Permissions and Access Control
Access front/rear: O(1) — direct index access; Lesson 400 — Deque Time Complexity Analysis
Access permissions: for the segment, such as read, write, and execute.; Lesson 1379 — Segment Table Structure
Access safely: The thread can now read the node knowing no one will free it; Lesson 2573 — Hazard Pointers for Memory Reclamation
Access the slot: O(1) array lookup; Lesson 433 — Average-Case Time Complexity Analysis
Access time: (or **latency**) is the delay between requesting data from a storage device and receiving it.; Lesson 1110 — Access Time and Latency
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
Accessibility: Works on any device that can receive SMS or email, including basic phones.; Lesson 2521 — SMS and Email-Based MFA
Accounting data: CPU time consumed, time limits, process numbers; Lesson 1217 — Process Control Block (PCB)
accumulator: is an extra parameter you add to your recursive function that carries partial results *downward* through the recursion.; Lesson 871 — Accumulator Pattern in Recursion Lesson 1077 — Accumulator and Status Registers
accumulators: ) to carry partial results forward, eliminating the need for work after the call.; Lesson 229 — Helper Functions in Recursion Lesson 872 — Tail Recursion Optimization
Accuracy: is critical (corruption is unacceptable); Lesson 1499 — When to Use TCP: Application Scenarios Lesson 2758 — Pattern Database Heuristics Lesson 2760 — Weighted A* and Speed-Accuracy Tradeoffs Lesson 2794 — Label Quality and Acquisition Lesson 2804 — Performance Metrics Selection Lesson 2835 — Evaluating Logistic Regression Models
Accuracy on training data: (lower error); Lesson 2851 — Cost-Complexity Pruning
ACK: (acknowledgment), confirming "I heard you want to close.; Lesson 1474 — TCP Connection Termination
ACK flag: set, acknowledging the server's sequence number (server's ISN + 1).; Lesson 1473 — TCP Three-Way Handshake
Acknowledge good work: "Nice use of the Extract Method refactoring here—this really clarifies the intent.; Lesson 2344 — Providing Constructive Feedback
Acknowledgment Number: (32 bits): Tells the sender "I've received everything up to byte X; send byte X next"; Lesson 1472 — TCP Segment Structure
Acknowledgments: (ACKs) to detect loss; Lesson 2592 — Message Loss and Ordering
ACLs: (which list "who can do what to this resource") or **RBAC** (which assigns permissions based on roles), capabilities are:; Lesson 2532 — Capability-Based Security Lesson 2533 — Authorization Model Tradeoffs
ACLs and DAC: are simple but inflexible—they tie permissions directly to resources.; Lesson 2533 — Authorization Model Tradeoffs
Acquire: means trying to lock the door—if it's already locked, you wait outside.; Lesson 1281 — Lock Semantics and Acquire/Release Lesson 1283 — Pthread Mutex Basics
Acquisition strategies: balance cost and quality:; Lesson 2794 — Label Quality and Acquisition
Across sessions: No such guarantees—other users might see stale data or different orderings.; Lesson 2619 — Session Consistency Models
Act: is the single action you're testing.; Lesson 2225 — Anatomy of a Unit Test Lesson 2226 — Writing Your First Unit Test
Action: Write `1`, move Right, enter state `q₂`; Lesson 1855 — Transition Rules and Execution Lesson 2738 — Solution Extraction and Path Reconstruction Lesson 2792 — Reinforcement Learning Overview
Action to take: move to a new state and **push zero or more symbols** onto the stack; Lesson 1830 — PDA Transition Functions
Actions: – What moves are available from each state?; Lesson 2734 — Search Problem Formulation
activation record: (also called a stack frame) onto this stack.; Lesson 374 — Stack-Based Memory Management Lesson 2076 — Stack Frames and Activation Records
Active learning: Strategically choosing which examples to label for maximum impact; Lesson 2794 — Label Quality and Acquisition
Active point tracking: Maintain state about where you're currently working in the tree; Lesson 635 — Suffix Tree Construction Overview
ActiveMQ: , **NATS**, and **Google Cloud Pub/Sub** each occupy specific niches—traditional enterprise messaging, ultra-low-latency scenarios, and GCP integration respectively.; Lesson 2716 — Popular Message Queue Systems
Activity family: last_login, post_count, friend_count; Lesson 1712 — Column Family Store Fundamentals
Activity Selection: Sort by end time O(n log n), then scan once O(n); Lesson 887 — Greedy Algorithm Complexity Lesson 896 — Minimum Platforms Problem
Activity Selection Problem: , a classic greedy algorithm challenge.; Lesson 882 — Activity Selection Problem Lesson 883 — Exchange Arguments for Correctness Lesson 888 — Activity Selection Problem
Actual cost so far: (like Dijkstra's distance from start); Lesson 1000 — Introduction to A* Search
Actual Output: What the code *actually* returns (compared against expected); Lesson 2219 — Test Cases and Test Suites
Actual result: Lesson 1271 — Demonstrating Race Conditions with Shared Counters
Acyclic: There are no cycles (you can't start at a vertex and loop back to it); Lesson 691 — Trees as Special Graphs Lesson 719 — What is Topological Sorting?Lesson 721 — DAG Detection and Prerequisites
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 Lesson 690 — Cyclic and Acyclic Graphs
Acyclic graphs: are simpler to work with for many algorithms.; Lesson 690 — Cyclic and Acyclic Graphs
AD is minimal: → candidate key; Lesson 1630 — Using FDs to Identify Candidate Keys
Ad-hoc queries: with JOINs across multiple tables; Lesson 1717 — NoSQL vs SQL: Complementary Approaches
Adapt to change: Requirements often evolve—short iterations make pivoting easier; Lesson 2366 — Iterative and Incremental Development
Adaptation: The team can adjust their daily plan based on progress; Lesson 2380 — Daily Scrum (Stand-up)Lesson 2857 — Boosting: Sequential Learning
Adaptee: The existing class with an incompatible interface; Lesson 2274 — Adapter Pattern: Converting Interfaces
Adapter: The wrapper that implements the target interface and delegates to the adaptee; Lesson 2274 — Adapter Pattern: Converting Interfaces Lesson 2281 — Adapter vs Bridge: When to Use Which Lesson 2283 — Structural Pattern Trade-offs Lesson 2284 — Combining Structural Patterns Lesson 2294 — Iterator Pattern
Adapter is about compatibility: while **Bridge is about flexibility**.; Lesson 2281 — Adapter vs Bridge: When to Use Which
Adapter Pattern: solves a problem *after the fact*.; Lesson 2281 — Adapter vs Bridge: When to Use Which
adaptive: it detects and exploits existing order in your data.; Lesson 802 — Timsort: Python's Default Sorting Algorithm Lesson 2772 — Iterative Deepening in Games
Add: the "rest of the tree" (the part that was above `p`) as a new subtree under `c`; Lesson 947 — Rerooting Technique Lesson 1271 — Demonstrating Race Conditions with Shared Counters Lesson 2126 — Inheritance Fundamentals
Add a cache/memo: (usually a dictionary or array); Lesson 916 — Memoization (Top-Down DP)
Add a sink vertex: `t` that every vertex in the right set connects to (e.; Lesson 1046 — Bipartite Matching via Max Flow Lesson 1047 — Maximum Bipartite Matching Algorithm
Add a source vertex: `s` that connects to every vertex in the left set (e.; Lesson 1046 — Bipartite Matching via Max Flow Lesson 1047 — Maximum Bipartite Matching Algorithm
Add edges: Lesson 1051 — Image Segmentation with Min-Cut
Add new lines: while preserving convexity (remove dominated lines); Lesson 958 — Convex Hull Trick for DP
Add random prefixes/suffixes: to hot keys, spreading them across multiple partitions (e.; Lesson 2690 — Handling Data Skew and Hotspots
Add registers strategically: Place pipeline registers to create natural breakpoints; Lesson 1155 — Balancing Pipeline Stages
Add security: Private networks are isolated from direct internet access by default; Lesson 1465 — Private and Public IP Address Ranges
AddBack (push_back): Create a new node, set its `prev` to current `tail`, update the old tail's `next`, then move `tail` to the new node.; Lesson 398 — Linked List Deque Implementation
AddFront (push_front): Create a new node, set its `next` to current `head`, update the old head's `prev`, then move `head` to the new node.; Lesson 398 — Linked List Deque Implementation
Adding a node: Only keys in the range *between the new node and its predecessor* need to move—just one node's worth of data.; Lesson 1732 — Consistent Hashing
Addition (`+`): Adds two numbers together; Lesson 154 — Arithmetic Operators
Addition Just Works: Here's the magic—you can add signed numbers using the *exact same circuit* as unsigned addition, ignoring any overflow bit.; Lesson 1059 — Two's Complement: The Standard for Signed Integers
Addition mod n: `(a + b) mod n` wraps around at n; Lesson 2406 — Mathematical Foundations: Modular Arithmetic
Addition Rule: gives us the correct formula:; Lesson 113 — Addition Rule for Probabilities
Additional data types: (ObjectId, Date, binary data—types JSON lacks); Lesson 1719 — JSON and BSON Data Formats
Address already in use: Trying to bind to a port already bound; Lesson 1550 — Error Handling and Socket Shutdown
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
Address rewriting: The router replaces the source IP:port in the UDP header with its own public IP:port before forwarding to the destination.; Lesson 1491 — UDP and Network Address Translation (NAT)
address translation: .; Lesson 1340 — Address Translation Overview Lesson 1342 — Virtual vs Physical Address Spaces
Addressing modes: (how to specify where data lives); Lesson 1092 — Instruction Set Architecture (ISA)
Adequate bucket space: The hash table shouldn't be overcrowded (typically keeping load factor below 0.; Lesson 1692 — O(1) Lookup with Hash Indexes
Adjacency list: Each student carries a list with only their actual friends' names (efficient!; Lesson 675 — Adjacency List: Memory Efficiency Lesson 680 — Choosing Representation by Graph Density Lesson 681 — Representation Trade-offs for Common Operations Lesson 682 — Memory Layout and Cache Performance
Adjacency matrices: may work fine here, as the `O(V²)` space matches the number of edges anyway.; Lesson 693 — Graph Density and Sparsity
adjacency matrix: is one of the most straightforward ways to store a graph in memory.; Lesson 669 — Adjacency Matrix: Structure and Memory Lesson 670 — Adjacency Matrix: Operations and Complexity Lesson 675 — Adjacency List: Memory Efficiency Lesson 680 — Choosing Representation by Graph Density Lesson 681 — Representation Trade-offs for Common Operations Lesson 682 — Memory Layout and Cache Performance Lesson 1020 — Comparing Kruskal's and Prim's Algorithms
Adjacent vertices: Two vertices connected by an edge; Lesson 657 — What is a Graph? Vertices and Edges
Adjusts: all internal pointers within the relocated memory; Lesson 1337 — Memory Compaction
Admissibility: h(n) ≤ true_cost(n → goal) for all nodes; Lesson 2753 — A* Optimality and Admissibility
admissible: (never overestimate) to guarantee finding the optimal path—but that's a topic for later.; Lesson 1001 — Heuristic Functions in A*Lesson 2750 — Heuristic Functions: Definition and Properties Lesson 2752 — A* Search Algorithm Lesson 2753 — A* Optimality and Admissibility Lesson 2757 — Euclidean Distance Heuristic Lesson 2758 — Pattern Database Heuristics
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 Lesson 1008 — A* Correctness and Optimality Lesson 2756 — Manhattan Distance Heuristic
Advantages: Lesson 676 — Edge List Representation Lesson 1122 — Write-Through vs Write-Back Policies Lesson 1130 — Fully Associative Caches Lesson 1368 — FIFO Page Replacement Lesson 1724 — Embedding vs Referencing Lesson 2223 — When to Write Tests Lesson 2522 — Push Notification-Based MFA Lesson 2686 — Range-Based Partitioning
Adversarial search: introduces a fundamentally different challenge: *an opponent actively trying to stop you from winning*.; Lesson 2764 — Adversarial Search Overview
Advisory locking: is cooperative: processes *voluntarily* check and respect locks before accessing a file.; Lesson 1393 — File Locking Mechanisms
AES (Advanced Encryption Standard): as the official successor—a symmetric block cipher designed to encrypt 128-bit blocks with keys of 128, 192, or 256 bits.; Lesson 2401 — AES: The Advanced Encryption Standard
After (1NF): Lesson 1633 — Achieving First Normal Form
After (guard clauses): Lesson 2325 — Replace Nested Conditionals with Guard Clauses
After borrowing: Lesson 565 — Borrowing Keys from Siblings
After computing: Store the result in the cache before returning; Lesson 916 — Memoization (Top-Down DP)
After consolidation: Lesson 2324 — Consolidate Conditional Expressions
After Inline Method: Lesson 2320 — Inline Method: Removing Unnecessary Indirection
After inlining: Lesson 2069 — Inlining Functions
After pre-commit acknowledgments: Participants know everyone agreed, so they can safely commit even without the coordinator; Lesson 2654 — Three-Phase Commit Improvements
After reading: Thread clears its hazard pointer; Lesson 2573 — Hazard Pointers for Memory Reclamation
After scanning everything: pop any remaining operators to output; Lesson 366 — Infix to Postfix Conversion Lesson 368 — Balanced Parentheses Checking
After the loop: attach the new node to the parent in the correct position; Lesson 507 — BST Insertion: Iterative Approach
Against CSRF: Lesson 2466 — CSRF vs XSS
Against XSS: Lesson 2466 — CSRF vs XSS
age: Lesson 2098 — Generational Garbage Collection Lesson 2626 — Clock Skew and Clock Drift
Aggregation operators: Compute sums, counts, averages; Lesson 1698 — Query Execution Plans and Operators
Aggregations: (COUNT, SUM, AVG, etc.; Lesson 1590 — Using Joins with Aggregations
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
Agreement: Both sides now know exactly which algorithms to use for the rest of the connection; Lesson 2448 — Cipher Suites: Negotiating Encryption Algorithms Lesson 2655 — Leader Election Basics
Ahead-of-Time compilation: translates your entire source code into machine code *before* the program ever runs.; Lesson 2028 — Ahead-of-Time vs Just-in-Time Execution Lesson 2036 — Real-World Examples: C, Python, and JavaScript
Aho-Corasick: Builds a trie structure—significant memory for multiple patterns; Lesson 840 — String Searching Applications and Tradeoffs
Aim for 0–3 parameters: More than that signals your function might be doing too much or that related data should be grouped together.; Lesson 2311 — Function Parameters and Argument Lists
Airline scheduling: Matching crews to flights; Lesson 1032 — Applications of Maximum Flow
Algebraic laws: help transform expressions:; Lesson 1776 — Regular Expression Equivalence
Algebraic Simplifications: Lesson 2058 — Peephole Optimization in Code Generation Lesson 2071 — Peephole Optimization
Algorithm: Lesson 897 — Maximum Length Chain of Pairs Lesson 1870 — Examples of Decidable Problems
Algorithm Analysis: When studying sorting algorithms, counting comparisons or swaps often involves summing sequences (Σ notation) or understanding worst-case arrangements—permutations where data is in reverse order.; Lesson 107 — Counting Problems in Computer Science
Algorithm complexity: (analyzing how runtime grows); Lesson 84 — Recurrence Relations
Algorithm steps: Lesson 2746 — Uniform-Cost Search
Algorithms and behavior: How can you make behaviors interchangeable or extensible?; Lesson 2286 — Introduction to Behavioral Patterns
all: inputs are FALSE.; Lesson 16 — The OR Gate Lesson 49 — Negating Quantified Statements Lesson 86 — The Principle of Mathematical Induction Lesson 1309 — Signal vs Broadcast Lesson 1320 — Deadlock Prevention: Breaking Hold and Wait Lesson 1548 — Handling Multiple Clients with Select Lesson 1578 — Inner Join with Multiple Conditions Lesson 1607 — ANY, ALL, and SOME Operators (+3 more)
All other nodes: Must contain at least `t-1` keys; Lesson 558 — B-Tree Invariants
All positive case: Return the smallest single number; Lesson 898 — Minimum Product Subset
All-or-nothing: Philosophers only pick up both forks if both are available (using a critical section to check); Lesson 1300 — Dining Philosophers Problem
Allocate correctly: Request the right amount of memory for your data; Lesson 2084 — Manual Memory Management Overview
Allocate minimal space: Instead of `dp[n][m]`, use `dp[2][m]` or just `dp[m]`.; Lesson 956 — Space Optimization with Rolling Arrays
Allocate temporary storage: (registers or memory) for intermediate results; Lesson 2054 — Code Generation for Expressions
Allocation: resources currently held by each process; Lesson 1324 — The Banker's Algorithm
Allocation failures: happen even when sufficient total memory exists; Lesson 1382 — External Fragmentation in Segmentation
Allowing only symbolic links: to create potential cycles (they don't affect reference counts); Lesson 1420 — General Graph Directories and Cycle Issues
Alpha (α): The best score the maximizer can guarantee so far; Lesson 2768 — Alpha-Beta Pruning
Alphabet symbols: lowercase letters like `a`, `b`, or digits; Lesson 1765 — Language Specifications and Notation
Alphabetical order: Every pair of words has a dictionary ordering; Lesson 75 — Total Orders and Chains
already sorted: or nearly sorted; Lesson 822 — Naive Selection via Sorting Lesson 830 — Selection in Specialized Contexts
Alternating moves: Players take turns, each choosing actions that change the state; Lesson 2764 — Adversarial Search Overview
Alternation `a|b`: Create parallel paths with ε-transitions; Lesson 1942 — From Regular Expressions to Finite Automata
ALU: is the CPU's calculator.; Lesson 1071 — CPU Components Overview
ALU (Arithmetic Logic Unit): or other specialized functional units perform the operation identified by the instruction's **opcode**.; Lesson 1086 — The Execute Stage
always: wrap `wait()` inside a `while` loop that re-checks your condition:; Lesson 1308 — Spurious Wakeups Lesson 2650 — The FLP Impossibility Result
Always halts: no infinite loops allowed; Lesson 1875 — Recognizable vs. Decidable
Always scale features: using standardization or normalization; Lesson 2872 — KNN in Practice: Applications and Limitations
Always use exact-match validation: , not just domain or prefix matching.; Lesson 2543 — OAuth 2.0 Security: Common Vulnerabilities and Best Practices
Always use UTF-8: for new projects—it's the universal standard; Lesson 30 — Common Encoding Issues
Always-Not-Taken: The predictor assumes every branch will fall through.; Lesson 1176 — Static Branch Prediction
Always-Taken: The predictor assumes every branch will be taken.; Lesson 1176 — Static Branch Prediction
Amazon DynamoDB: defaults to eventual consistency for faster reads, but offers a "strongly consistent read" option when applications need it.; Lesson 2622 — Consistency in Practice: Examples
Amdahl's Law: tells us the maximum speedup possible when only a fraction of the program benefits from the improvement.; Lesson 1188 — Speedup and Amdahl's Law
Amortization: Occasional rehashing costs are spread across many operations; Lesson 433 — Average-Case Time Complexity Analysis
amortized: over many operations.; Lesson 429 — Rehashing Process Lesson 568 — Splay Trees: Self-Adjusting BSTs
amortized O(1): .; Lesson 438 — Dynamic Resizing and Rehashing Cost Lesson 974 — Dijkstra's with Fibonacci Heap
Amplitude Modulation (AM): Vary signal strength to encode data.; Lesson 1443 — Signal Encoding and Modulation
Analogy: Think of two safety switches on dangerous machinery.; Lesson 18 — NAND and NOR Gates Lesson 36 — Conditional Statements (Implication)Lesson 39 — Compound Propositions and Precedence Lesson 63 — Set Difference and Complement Lesson 78 — Function Properties: Surjective (Onto)Lesson 213 — Stack-Based Lifetime for Local Variables Lesson 214 — Static Lifetime Variables Lesson 310 — Space Complexity of Common Data Structures (+126 more)
Analysis: Normalize code into canonical forms for easier comparison; Lesson 1982 — AST Manipulation and Transformation
Analysis Ease: Lesson 2047 — IR Design Tradeoffs
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
Angular: , interpolation with `{{userInput}}` does the same.; Lesson 2462 — XSS Prevention in Modern Frameworks
Annihilator: `L · ∅ = ∅ · L = ∅` — concatenating with the empty language yields nothing; Lesson 1769 — Union and Concatenation Properties
Anomaly detection: Identifying unusual data points that don't fit patterns; Lesson 2788 — Unsupervised Learning: Finding Patterns Without Labels Lesson 2872 — KNN in Practice: Applications and Limitations
Another example: The brute-force solution to the **Traveling Salesman Problem**.; Lesson 290 — O(n!): Factorial Time
Another example: Generating combinations: Lesson 870 — Multiple Recursive Calls
Anti-Entropy: is a background process that continuously compares replicas and synchronizes differences.; Lesson 2643 — Read Repair and Anti-Entropy Lesson 2704 — Anti-Entropy and Gossip Protocols Lesson 2705 — Read Repair and Hinted Handoff Lesson 2706 — Eventual Consistency in Practice: Dynamo and Cassandra
Anti-patterns: document *ineffective* solutions that degrade these qualities—they're warnings, not recommendations; Lesson 2301 — Introduction to Anti-Patterns
Antisymmetric: A relation R is **antisymmetric** if whenever both (a, b) and (b, a) are in R, then a must equal b.; Lesson 70 — Properties of Relations: Symmetry Lesson 74 — Partial Orders Lesson 75 — Total Orders and Chains
any: of those inputs is TRUE.; Lesson 16 — The OR Gate Lesson 1135 — Cache Placement Example Calculations Lesson 1227 — Process Waiting: wait() and waitpid()Lesson 1234 — Multithreading Models: Many-to-One Lesson 1578 — Inner Join with Multiple Conditions Lesson 1607 — ANY, ALL, and SOME Operators Lesson 1722 — Querying Nested Fields Lesson 1796 — NFA Acceptance: Existence of Accepting Path (+2 more)
Any state → Follower: When a server receives a message with a higher term number; Lesson 2659 — Raft Server States: Follower, Candidate, Leader
Anytime algorithm: You have a best move at every moment; Lesson 2772 — Iterative Deepening in Games
AP: (availability + partition tolerance).; Lesson 1714 — CAP Theorem Trade-offs Across Categories
AP system: chooses to remain **Available** rather than shut down or refuse requests.; Lesson 2606 — AP Systems: Availability and Partition Tolerance
AP systems: (e.; Lesson 2604 — The CAP Trade-off: Pick Two Lesson 2607 — CA Systems and the Real World
AP-leaning: .; Lesson 1714 — CAP Theorem Trade-offs Across Categories
AP-tunable: .; Lesson 1714 — CAP Theorem Trade-offs Across Categories
Apache Cassandra: uses tunable consistency via quorum reads/writes.; Lesson 2622 — Consistency in Practice: Examples
Apache ZooKeeper: guarantees linearizable writes and sequential consistency for reads from a single client.; Lesson 2622 — Consistency in Practice: Examples
API Configuration: If your application consumes external APIs, you'll need test versions.; Lesson 2250 — Setting Up the Test Environment
API contracts: between services; Lesson 2234 — What is Integration Testing?
API documentation: Public interfaces benefit from structured documentation; Lesson 2312 — Comments: When and How to Use Them
API integrations: calendar apps accessing your email to auto-add events; Lesson 2534 — OAuth 2.0 Overview and Use Cases
API parameter tampering: Modifying JSON payloads like `{"userId": 999}` to access different accounts; Lesson 2484 — Insecure Direct Object References (IDOR)
API/function documentation: Are parameters, return values, and expected exceptions documented?; Lesson 2348 — Reviewing Tests and Documentation
Apologizing for bad code: Comments like "// hack" or "// fix this later" mean you should fix it now; Lesson 2312 — Comments: When and How to Use Them
Appear thread-safe superficially: Individual operations may look safe in isolation; Lesson 2555 — Race Conditions
Append zeros: Add *n* zeros to your data (where *n* is the degree of the generator polynomial).; Lesson 1448 — Cyclic Redundancy Check (CRC)
Appends: all entries from the leader's log; Lesson 2667 — Handling Log Inconsistencies
Application: creates the message; Lesson 1440 — Encapsulation and Layer Communication
Application Layer: – Where user applications interact with the network (e.; Lesson 1432 — The OSI Model: Seven-Layer Overview Lesson 1437 — OSI Upper Layers: Session, Presentation, Application Lesson 1438 — The TCP/IP Model Lesson 1440 — Encapsulation and Layer Communication
Application Layer (TCP/IP): = OSI Layers 5, 6, 7; Lesson 1439 — Mapping OSI to TCP/IP
Application-level caching: to absorb read spikes before they hit the database; Lesson 2690 — Handling Data Skew and Hotspots
Application-level resolution: (letting your code decide); Lesson 2641 — Multi-Leader Replication
Apply: the Pumping Lemma: there exists a pumping length p; Lesson 1807 — Using the Pumping Lemma to Prove Non-Regularity
Apply De Morgan's: `(NOT Door) OR (NOT Armed)`; Lesson 20 — De Morgan's Laws
Apply dimensionality reduction: (e.; Lesson 2872 — KNN in Practice: Applications and Limitations
Apply index formulas: For node at index `i`, its left child is at `2i+1`, right at `2i+2`; Lesson 467 — Converting Between Representations
Apply parent-child formulas: For any element at index `i`, its children are at `2i+1` (left) and `2i+2` (right); Lesson 583 — Visualizing Heap Structure
Approach 1: Counter Variable: Lesson 361 — Size Operation
Approval and merge: happen once reviewers are satisfied; Lesson 2196 — Pull Requests and Code Review
Approval Workflows: You can configure repositories to require one or more approvals before merging.; Lesson 2350 — Code Review Tools and Workflow
Approximate physical time: for monitoring, debugging, and TTL decisions; Lesson 2636 — Hybrid Logical Clocks
Approximation Algorithms: The famous Traveling Salesman Problem is hard, but an MST gives a quick 2-approximation.; Lesson 1021 — MST Applications and Variations Lesson 1911 — Practical Impact of P vs NP
Architectural boundaries: Does domain logic stay separate from infrastructure concerns?; Lesson 2347 — Evaluating Design and Architecture
Architecture choices: The structure you design determines what functions are reachable; Lesson 2778 — The Hypothesis Space
Argon2: and proper salting, the weakest link is often the password itself.; Lesson 2515 — Password Managers and Best Practices
Argon2d: Maximizes resistance to GPU attacks (data-dependent); Lesson 2508 — Password Hashing with Argon2
Argon2i: Optimized for resistance to side-channel attacks (data-independent); Lesson 2508 — Password Hashing with Argon2
Argon2id: Hybrid approach, recommended for password hashing; Lesson 2508 — Password Hashing with Argon2
Arithmetic: Array indices (0, 1, 2, 3, .; Lesson 83 — Arithmetic and Geometric Sequences
Arithmetic Instructions: (like `ADD`, `SUB`); Lesson 1090 — Instruction Cycle Variations Lesson 1101 — Implementing Loops in Assembly
Arithmetic Logic Unit (ALU): is the computational workhorse of the CPU.; Lesson 1072 — The Arithmetic Logic Unit (ALU)
Arithmetic operations: `a + b`, `x * y`, `n - 1`; Lesson 271 — Counting Primitive Operations Lesson 283 — O(1): Constant Time Lesson 1072 — The Arithmetic Logic Unit (ALU)
Arithmetic sequences: grow by adding the same amount each time.; Lesson 83 — Arithmetic and Geometric Sequences
Arithmetic/Logic operations: The ALU receives two operands (e.; Lesson 1086 — The Execute Stage
ARM: Dominant in smartphones, tablets, and increasingly in laptops; Lesson 1092 — Instruction Set Architecture (ISA)
Arrange: is where you set up everything needed for the test.; Lesson 2225 — Anatomy of a Unit Test Lesson 2226 — Writing Your First Unit Test
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?Lesson 362 — Array-Based Stack Implementation Lesson 526 — Comparing BST to Array and Linked List
Array access: `arr[i]`; Lesson 271 — Counting Primitive Operations Lesson 273 — Input Size as a Variable
Array access by index: `array[5]` jumps directly to position 5, no matter how long the array is; Lesson 283 — O(1): Constant Time
array indexing: .; Lesson 236 — Iterating Through Arrays Lesson 2067 — Strength Reduction
Array representation: Because there are no gaps, we can store a heap in a simple array without wasting space; Lesson 576 — Complete Binary Tree Property
Array reversal: visiting each element once to swap positions; Lesson 285 — O(n): Linear Time
Array reversal in-place: Uses two index variables (`left` and `right`) and one `temp` variable—always 3 variables, regardless of array size; Lesson 305 — Constant Space: O(1)
Array wins: O(V²) < O(V² log V); Lesson 976 — Dijkstra's on Dense vs Sparse Graphs
Array-based: Best for nearly-complete trees (heaps, complete binary trees) where few slots go unused; Lesson 465 — Space Efficiency Comparison Lesson 467 — Converting Between Representations
Array-based (simple priority queue): O(V²) time complexity; Lesson 976 — Dijkstra's on Dense vs Sparse Graphs
Array-based circular queue: Lesson 384 — Queue Size and IsEmpty Operations
Array-based queues: allocate a fixed or resizable block of memory.; Lesson 385 — Queue Implementation Tradeoffs
Array-based stacks: store elements in contiguous memory with minimal overhead—just the array itself plus a size counter.; Lesson 364 — Stack Implementation Tradeoffs
arrays: when you know approximate size limits, want fast access, and can tolerate occasional resize hiccups.; Lesson 364 — Stack Implementation Tradeoffs Lesson 385 — Queue Implementation Tradeoffs Lesson 2057 — Code Generation for Arrays and Records
Arrays/Lists: Simple puzzles (8-puzzle, Rubik's cube positions); Lesson 2731 — State Representation Strategies
Arrive at the conclusion: Show the statement holds for k+1; Lesson 89 — Inductive Step: The Core Argument
Artifact storage: (build outputs between stages); Lesson 2394 — CI/CD Tools and Infrastructure
Artificial intelligence: Learning and planning algorithms; Lesson 1912 — The Million Dollar Question
ASC: (ascending): smallest to largest, A to Z; Lesson 1568 — ORDER BY and Sorting Results
Ask: What does my data naturally look like?; Lesson 1715 — Choosing the Right NoSQL Category Lesson 2349 — Responding to Review Feedback
Ask questions: "Could we simplify this conditional expression?; Lesson 2344 — Providing Constructive Feedback
ASN.1: (Abstract Syntax Notation One) and **DER encoding** to serialize data into binary form— ensuring every byte is interpreted identically across platforms.; Lesson 2440 — Digital Signature Standards and Formats
ASP.NET Core: `[ValidateAntiForgeryToken]` attributes protect actions; Lesson 2473 — Implementing CSRF Protection
Assembly/Machine Code: The final representation understood by hardware.; Lesson 2048 — Lowering Through Multiple IR Levels
Assert: is where you verify the outcome.; Lesson 2225 — Anatomy of a Unit Test Lesson 2226 — Writing Your First Unit Test
Assign potential: to each node based on its subtree size; Lesson 574 — Amortized Analysis of Splay Trees
Assign registers: Variables like `a`, `b`, and `t1` need physical CPU registers or memory locations; Lesson 2051 — Three-Address Code Translation
Assign task: Add the task's workload to that server's load; Lesson 617 — Load Balancing Systems
Assignment: `x = 5` stores a new value in `x`; Lesson 164 — Expression Evaluation and Side Effects Lesson 1939 — Tokens, Lexemes, and Patterns 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
Assignment modifies memory: `x = 5` means "write the value 5 to the memory location named x"; Lesson 2120 — Memory Model in Imperative Languages
Assignment statements: that change variable values; Lesson 2112 — What is Imperative Programming?
Assignments: `x = 5`; Lesson 271 — Counting Primitive Operations
Association rules: Discovering relationships between variables; Lesson 2788 — Unsupervised Learning: Finding Patterns Without Labels
associative: (grouping doesn't matter: `(a ⊕ b) ⊕ c = a ⊕ (b ⊕ c)`), which makes segment trees work perfectly.; Lesson 647 — Segment Tree Variants and Functions Lesson 1769 — Union and Concatenation Properties
Associativity: determines the order when operators have the **same precedence**.; Lesson 155 — Operator Precedence and Associativity Lesson 1758 — String Operations: Concatenation Lesson 1776 — Regular Expression Equivalence
Assume: there exists an optimal solution that differs from your greedy solution; Lesson 906 — Proof by Exchange Argument Lesson 1807 — Using the Pumping Lemma to Prove Non- Regularity Lesson 1880 — Proof by Contradiction Setup Lesson 1885 — Reductions from the Halting Problem
AST manipulation: lets compilers, optimizers, and refactoring tools reshape code at the structural level before generating output.; Lesson 1982 — AST Manipulation and Transformation
Asymmetric: A relation R is **asymmetric** if whenever (a, b) is in R, then (b, a) is definitely NOT in R (unless a = b isn't even allowed).; Lesson 70 — Properties of Relations: Symmetry
asymmetric cryptography: (like RSA or ECDH) solves the key distribution problem beautifully—no need to share secret keys in advance.; Lesson 2416 — Hybrid Cryptosystems Lesson 2442 — TLS: The Security Layer Behind HTTPS
Asymmetric encryption: (public-key cryptography) uses a pair of keys: one public, one private.; Lesson 1530 — Symmetric vs Asymmetric Encryption in TLS Lesson 1531 — The TLS Handshake Process
Asymmetric solution: Odd-numbered philosophers pick up left fork first; even-numbered pick up right fork first; Lesson 1300 — Dining Philosophers Problem
Asynchronous: You drop it in the teacher's inbox and immediately leave.; Lesson 2640 — Synchronous vs. Asynchronous Replication
Asynchronous operation: No timing assumptions required for correctness (though some are needed for liveness); Lesson 2672 — Introduction to Paxos: The Consensus Problem
Asynchronous systems: make deterministic consensus impossible with even one crash failure (remember the FLP impossibility result from lesson 2650).; Lesson 2652 — Synchronous vs Asynchronous Models
At each ancestor: , check if it's now imbalanced (balance factor > 1 or < -1); Lesson 542 — Rebalancing After Deletion
At each step: compare the new value with the current node's value; Lesson 507 — BST Insertion: Iterative Approach
at least one: of them is true.; Lesson 34 — Logical Disjunction (OR)Lesson 48 — Existential Quantifier (∃)Lesson 1548 — Handling Multiple Clients with Select Lesson 1565 — Logical Operators: AND, OR, NOT Lesson 1762 — Kleene Star and Plus on Languages Lesson 1794 — Nondeterminism: Multiple Transitions and Choices
At runtime: , randomly select one function from this family when creating your hash table; Lesson 414 — Universal Hashing Lesson 1999 — Type Checking at Runtime
At the sink: Sum all flow entering the sink minus any flow leaving the sink; Lesson 1025 — Valid Flows and Flow Value
At the source: Sum all flow leaving the source minus any flow entering the source; Lesson 1025 — Valid Flows and Flow Value
atomic: (all-or-nothing) and preventing interference.; Lesson 1241 — Threading Challenges: Synchronization Needs Lesson 1295 — Semaphore Implementation and Atomicity Lesson 2109 — Reference Counting Performance Lesson 2611 — Strong Consistency (Linearizability)
Atomic commits: Should all replicas commit or abort a transaction?; Lesson 2647 — The Consensus Problem Definition
atomic operations: sequences of instructions that must complete without interruption (like updating shared data structures).; Lesson 1213 — Interrupt Priority and Masking Lesson 1278 — Atomicity and Indivisible Operations Lesson 1724 — Embedding vs Referencing Lesson 2110 — Reference Counting in Practice Lesson 2561 — Synchronized Blocks and Methods Lesson 2566 — Introduction to Lock-Free Programming Lesson 2567 — Atomic Operations and Compare-and-Swap Lesson 2578 — Concurrent Queue: Array-Based Implementation
Atomic values only: – Each cell must contain a single, indivisible value; Lesson 1632 — First Normal Form (1NF) Definition
atomicity: ).; Lesson 1657 — Transaction Logs and Write-Ahead Logging Lesson 1658 — Consistency: Maintaining Database Invariants Lesson 2717 — What Are Distributed Transactions?
Attach remainder: The remainder becomes your CRC checksum, replacing those zeros.; Lesson 1448 — Cyclic Redundancy Check (CRC)
Attach the signature: – Send both the message and this encrypted hash; Lesson 2432 — What are Digital Signatures?
Attempting requests without tokens: (should fail); Lesson 2473 — Implementing CSRF Protection
Attempts unification: by comparing the query structure with each candidate; Lesson 2159 — Queries and Unification
Attributes: (columns) → Column definitions with data types; Lesson 1560 — From Relational Model to SQL Lesson 1611 — Introduction to Entity-Relationship (ER) Modeling Lesson 1612 — Entities and Entity Sets Lesson 1613 — Attributes and Domains Lesson 1615 — Relationships and Relationship Sets Lesson 2528 — Attribute-Based Access Control (ABAC)
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 Paths Lesson 1037 — Augmenting Paths
Authentication: You're actually talking to the legitimate server, not an imposter; Lesson 1524 — Introduction to HTTPS Lesson 1529 — TLS Overview and Purpose Lesson 2432 — What are Digital Signatures?Lesson 2442 — TLS: The Security Layer Behind HTTPS Lesson 2494 — What is Authentication?Lesson 2524 — Authorization vs Authentication
Authentication Method: – How the server proves its identity (e.; Lesson 1536 — TLS Cipher Suites Lesson 2448 — Cipher Suites: Negotiating Encryption Algorithms
Authenticity: Lesson 2434 — Digital Signature Properties
Author: The name and email of the person who made the commit.; Lesson 2175 — Viewing Commit History
authorization: determines *what they're allowed to access*.; Lesson 2488 — Broken Access Control Lesson 2494 — What is Authentication?Lesson 2524 — Authorization vs Authentication Lesson 2525 — Access Control Lists (ACLs)Lesson 2541 — OpenID Connect: Adding Identity to OAuth 2.0
Authorization Server: (issues tokens after consent); Lesson 2534 — OAuth 2.0 Overview and Use Cases Lesson 2535 — OAuth 2.0 Roles: Resource Owner, Client, Authorization Server
Auto-complete systems: that suggest words in sorted order; Lesson 502 — BST Advantages and Use Cases
Autocomplete systems: Type "ho" and instantly see "home," "hotel," "house"; Lesson 619 — What is a Trie? Motivation and Use Cases
Automated testing in CI: works the same way for code: every time someone commits changes, the CI server immediately runs your full test suite—unit tests, integration tests, and any other automated checks—before declaring the build successful or failed.; Lesson 2386 — Automated Testing in CI
Automated triggers: (commits, branches, schedules); Lesson 2394 — CI/CD Tools and Infrastructure
Automatic: Languages like Java, Python, and JavaScript use *garbage collection* to reclaim unused heap memory automatically.; Lesson 2078 — Heap Memory Fundamentals
Autonomy: The team decides task assignments, technical approaches, and daily workflows; Lesson 2367 — Self-Organizing Teams
Auxiliary Space: is only the *extra* memory your algorithm allocates beyond the input itself.; Lesson 303 — Auxiliary Space vs Total Space Lesson 757 — Mergesort Space Complexity
Availability: (A): Every request receives a response (success or failure); Lesson 1714 — CAP Theorem Trade-offs Across Categories Lesson 1733 — Replication in Key-Value Stores Lesson 1734 — Eventual Consistency Trade-offs Lesson 2602 — Availability in Distributed Systems Lesson 2604 — The CAP Trade-off: Pick Two Lesson 2607 — CA Systems and the Real World Lesson 2637 — Introduction to Replication Lesson 2638 — Replication vs. Partitioning (+2 more)
availability and partition tolerance: .; Lesson 2608 — CAP Theorem in Practice: Database Examples Lesson 2614 — Eventual Consistency Overview
Available: resources currently free; Lesson 1324 — The Banker's Algorithm Lesson 2604 — The CAP Trade-off: Pick Two Lesson 2606 — AP Systems: Availability and Partition Tolerance
Available instructions: (add, subtract, load, store, jump, etc.; Lesson 1092 — Instruction Set Architecture (ISA)
Avalanche effect: Changing even one bit in the input completely changes the hash output; Lesson 2420 — What is a Hash Function?
Average case: O(1 + α) — we hash to a bucket (O(1)), then traverse its linked list (O(α) on average); Lesson 421 — Separate Chaining: Analysis Lesson 674 — Adjacency List: Operations and Complexity
Average Case: O(n²): Lesson 748 — Insertion Sort: Analysis
Average deletion cost: O(log n); Lesson 524 — Average-Case BST Performance
Average insertion cost: O(log n); Lesson 524 — Average-Case BST Performance
Average row/column size: Lesson 1704 — Statistics and Histograms
Average search cost: ~1.; Lesson 524 — Average-Case BST Performance
Average-Case: On average, you'll find the person somewhere in the middle of the room, after checking about half the seats.; Lesson 272 — Best-Case, Worst-Case, and Average-Case Lesson 277 — Analyzing Conditional Statements Lesson 300 — Best-Case, Worst-Case, and Average-Case Analysis Lesson 781 — Heapsort Time Complexity Analysis
Averaging metrics: Average order value per customer?; Lesson 1590 — Using Joins with Aggregations
AVG: divides that sum by the count of non-NULL values, giving you the average (mean).; Lesson 1593 — SUM and AVG Functions
AVL tree: is a self-balancing binary search tree.; Lesson 531 — AVL Tree Definition and Balance Property Lesson 545 — AVL Trees vs Unbalanced BSTs
AVL trees: maintain a balance factor of -1, 0, or +1 at every node.; Lesson 555 — Red-Black vs AVL Trees: Tradeoffs Lesson 575 — Splay Trees vs Other Balanced Trees
Avoid: requiring "at least one uppercase, one number, one symbol" — this creates predictable patterns; Lesson 2512 — Password Policies and Requirements
Avoid aliasing: Don't create multiple pointers to the same dynamically allocated memory unless you carefully track which one "owns" it.; Lesson 2089 — Double-Free Errors
Avoid exposing sensitive data: While being helpful, don't leak passwords, API keys, or internal system paths that could create security vulnerabilities.; Lesson 2317 — Error Handling and Exception Messages
Avoid global variables: unless absolutely necessary.; Lesson 216 — Best Practices for Variable Scope
Avoid hotspots: Don't accidentally concentrate traffic on one node; Lesson 2691 — Rebalancing Partitions
Avoid mental mapping: Don't make readers translate `i`, `j`, `k` into actual meanings outside simple loop counters; Lesson 2309 — Meaningful Names for Variables and Functions
Avoid powers of 2: (like 8, 16, 32): `k mod 16` only looks at the last 4 bits of `k`, ignoring most of your key's information; Lesson 408 — The Division Method
Avoid stack overflow: Deeply nested recursion can crash; iterative DFS won't; Lesson 373 — Depth-First Search with Explicit Stack
Avoid use-after-free: Never access memory after deallocating it (this creates dangling pointers); Lesson 2084 — Manual Memory Management Overview
Avoidance: (Banker's Algorithm): requires advance knowledge and runtime checks, adding overhead; Lesson 1328 — Ostrich Algorithm and Practical Approaches
Avoiding hotspots: If you stored all recent orders on one shard (like in range partitioning by date), that shard would handle all write traffic.; Lesson 2687 — Hash-Based Partitioning
Avoids duplication: Shared data exists once; Lesson 1724 — Embedding vs Referencing

B

B caused A: if every element `VB[i] ≤ VA[i]` and at least one is strictly less; Lesson 2702 — Vector Clocks for Causality Tracking
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: is a self-balancing tree structure that databases use to organize and quickly locate data on disk.; Lesson 1676 — B-Tree Index Overview
B-tree indexes: remain the default because they support both equality and range operations, while hash indexes are specialized tools for specific use cases.; Lesson 1688 — What Are Hash Indexes?Lesson 1697 — Choosing Between B-Tree and Hash Indexes
B-trees: require:; Lesson 1697 — Choosing Between B-Tree and Hash Indexes
back: (or rear) of the queue.; Lesson 376 — Essential Queue Operations Lesson 706 — 0-1 BFS
Back button: Pop from the back stack, push the current page onto the forward stack; Lesson 372 — Browser History Navigation
back edge: Lesson 712 — DFS Tree Edges and Classification Lesson 713 — Cycle Detection with DFS
Back off and retry: Each device waits a random time before trying again; Lesson 1450 — Medium Access Control (MAC)
Backpressure: is the mechanism by which a slow consumer signals upstream components to slow down.; Lesson 2714 — Backpressure and Flow Control Lesson 2715 — Message Queue Performance Considerations
backtrack: to the last decision point; Lesson 856 — What is Backtracking?Lesson 859 — Generating All Subsets Lesson 860 — N-Queens Problem Lesson 861 — Sudoku Solver Lesson 862 — Combination Sum Problems
backtracking: , **constraint propagation**, and **arc consistency** to prune impossible values and search efficiently through the solution space.; Lesson 2155 — Constraint Programming Basics Lesson 2162 — Recursive Rules in Prolog
Backtracking in general: Make one choice, recursively explore remaining choices; Lesson 866 — Problem Decomposition in Recursion
Backtracks: or reports errors when matches fail; Lesson 1952 — Implementing Recursive Descent Functions Lesson 2159 — Queries and Unification
Backup systems: Verify backed-up data matches the original; Lesson 2429 — Hash Function Applications: Data Integrity
Backward edge: It also adds a *reverse* edge from v to u with capacity 4 (you can "cancel" up to 4 units of flow).; Lesson 1027 — Residual Networks
Backward edges: Allow you to "undo" flow by redirecting it elsewhere; Lesson 1036 — Residual Networks
Backward search: relaxes edges in reverse (target ← predecessors); Lesson 978 — Bidirectional Dijkstra's Algorithm
Backward-Taken-Forward-Not-Taken (BTFNT): This clever strategy examines the branch direction in memory:; Lesson 1176 — Static Branch Prediction
Bad: `hash(x) = x % 10` when all your keys end in 5; Lesson 1690 — Hash Function Selection for Indexes
bad character rule: tells us how far we can safely shift the pattern forward without missing any potential matches.; Lesson 836 — Boyer-Moore: Bad Character Rule Lesson 838 — Boyer-Moore: Combined Algorithm
Bad naming: Lesson 2309 — Meaningful Names for Variables and Functions
Bad replacement: Evict a page your active program needs immediately → thrashing (constant paging); Lesson 1366 — Page Replacement Problem
Bad state definitions: include redundant information or miss crucial details.; Lesson 920 — State Definition and Transitions
bagging: builds many trees, each trained on a slightly different random sample of your data.; Lesson 2854 — Bagging: Bootstrap Aggregating Lesson 2855 — Random Forests: Bagging with Decision Trees Lesson 2862 — Ensemble Selection and Hyperparameters
Balance carefully: Sometimes load balancing still requires moving processes, but the scheduler weighs the memory penalty; Lesson 1268 — NUMA-Aware Scheduling
balance factor: of a node measures how balanced its subtrees are: `height(left) - height(right)`.; Lesson 492 — Calculating Tree Metrics Lesson 531 — AVL Tree Definition and Balance Property Lesson 532 — Height-Balance Invariant Lesson 533 — Calculating Balance Factors
Balance Factor = -1: Right subtree is one level taller (slightly right-heavy); Lesson 533 — Calculating Balance Factors
Balance Factor = 0: Both subtrees have equal height (perfectly balanced); Lesson 533 — Calculating Balance Factors
Balance Factor = 1: Left subtree is one level taller (slightly left-heavy); Lesson 533 — Calculating Balance Factors
Balanced approach: Use moderate values (0.; Lesson 440 — Space-Time Tradeoffs in Hash Tables Lesson 2620 — Quorum-Based Consistency
Balanced tree: Operations typically take **O(log n)** time because the height stays proportional to log₂(n).; Lesson 488 — Balanced vs Unbalanced Trees
Balanced trees: have low IPL because nodes are spread evenly across fewer levels.; Lesson 490 — Path Length Properties
bandwidth: , which is the amount of data that can flow through the memory system per second, typically measured in gigabytes per second (GB/s).; Lesson 1113 — Memory Bandwidth Considerations Lesson 1444 — Bandwidth and Throughput Lesson 2590 — Network Latency and Bandwidth Constraints
Banking: Alice transfers $100 from savings to checking.; Lesson 2610 — What is Consistency in Distributed Systems?
Base: Show P(1) is true; Lesson 86 — The Principle of Mathematical Induction Lesson 94 — Structural Induction Lesson 97 — Induction in Algorithm Analysis Lesson 1381 — Segmentation with Protection and Sharing
Base (widest): Unit tests — many small, fast tests for individual functions or classes; Lesson 2217 — The Testing Pyramid
base address: (the starting location); Lesson 237 — Array Memory Layout Lesson 1380 — Logical Address Translation in Segmentation
base case: is your starting point—the first domino you need to prove falls.; Lesson 87 — Base Case: Starting the Proof Lesson 88 — Inductive Hypothesis Lesson 91 — Divisibility Proofs by Induction Lesson 92 — Inequality Proofs by Induction Lesson 93 — Strong Induction Lesson 95 — Common Induction Mistakes Lesson 97 — Induction in Algorithm Analysis Lesson 217 — What is Recursion? (+34 more)
Base Case (n=1): Does the formula work when n=1?; Lesson 90 — Summing Series by Induction Lesson 91 — Divisibility Proofs by Induction
Base case(s): Starting values that don't depend on others; Lesson 84 — Recurrence Relations Lesson 94 — Structural Induction
Base cases: Lesson 924 — Climbing Stairs Problem Lesson 927 — Edit Distance (Levenshtein Distance)Lesson 935 — Longest Palindromic Subsequence Lesson 938 — Egg Dropping Problem Lesson 940 — Unique Paths in Grid
Base decorator: holds a reference to a component and forwards requests to it; Lesson 2277 — Decorator Pattern: Adding Responsibilities Dynamically
Base register: Holds the starting physical address of the process's memory; Lesson 1332 — Base and Limit Registers
Baseball elimination: Determining which teams can still win a division; Lesson 1032 — Applications of Maximum Flow
baseline model: is an intentionally simple approach that establishes minimum acceptable performance.; Lesson 2784 — Baseline Models and Evaluation Lesson 2816 — What is Linear Regression?
basic block: is a maximal sequence of consecutive instructions where:; Lesson 2042 — Control Flow Graphs (CFGs)Lesson 2043 — Basic Blocks and Leaders
Basic family: username, email, created_date; Lesson 1712 — Column Family Store Fundamentals
Basic syntax: Lesson 176 — The While Loop Lesson 1610 — Common Table Expressions (CTEs)
Basically Available: The system guarantees availability—it will respond to requests even if some parts fail or data isn't perfectly synchronized yet; Lesson 2699 — The BASE Model: Basically Available, Soft State, Eventual
Batch: Survey everyone in the city before taking a step.; Lesson 2822 — Batch vs Stochastic Gradient Descent
Batch gradient descent: uses *all* training examples to compute one gradient update, while **stochastic gradient descent (SGD)** uses just *one* example at a time.; Lesson 2822 — Batch vs Stochastic Gradient Descent
Batch processes: (background tasks); Lesson 1259 — Multilevel Queue Scheduling
Bayes' Theorem: states:; Lesson 118 — Bayes' Theorem
BCNF (Boyce-Codd Normal Form): Stricter version of 3NF; Lesson 1631 — Introduction to Normal Forms Lesson 1641 — Achieving BCNF
Be computationally efficient: You'll call it thousands of times per move; Lesson 2770 — Evaluation Functions for Non-Terminal States
Be descriptive but concise: .; Lesson 191 — Function Naming Conventions
Be specific: Instead of catching a generic `Exception`, catch specific types (`FileNotFoundException`, `ValueError`) so you can provide targeted guidance.; Lesson 2317 — Error Handling and Exception Messages
Be specific, not generic: Use `customer_email_list` instead of `data` or `list1`; Lesson 2309 — Meaningful Names for Variables and Functions
Before (nested): Lesson 2325 — Replace Nested Conditionals with Guard Clauses
Before (Unnormalized): Lesson 1633 — Achieving First Normal Form
Before an event: increment your counter; Lesson 2628 — Lamport Timestamps
Before commit: The database can check the log during recovery, see the transaction never completed, and safely ignore those changes (supporting **rollback**).; Lesson 1657 — Transaction Logs and Write-Ahead Logging
Before computing: Check if the answer is already in the cache; Lesson 916 — Memoization (Top-Down DP)
Before consolidation: Lesson 2324 — Consolidate Conditional Expressions
Before Inline Method: Lesson 2320 — Inline Method: Removing Unnecessary Indirection
Before inlining: Lesson 2069 — Inlining Functions
Before pre-commit acknowledgments: Participants can safely abort (no one has committed yet); Lesson 2654 — Three-Phase Commit Improvements
Before reading: Thread announces the pointer it's about to access by storing it in a hazard pointer (a shared location); Lesson 2573 — Hazard Pointers for Memory Reclamation
BEGIN TRANSACTION: Start writing your draft; Lesson 1656 — Commit and Rollback Operations Lesson 1673 — Snapshot Isolation
Behavior: Related operations scatter across the codebase instead of living with the data; Lesson 2335 — Primitive Obsession Smell
Belady's Anomaly: adding more page frames can sometimes *increase* page faults rather than decrease them.; Lesson 1368 — FIFO Page Replacement Lesson 1369 — Belady's Anomaly
Bellman-Ford: "Let me check all E edges, V-1 times, just in case.; Lesson 988 — SPFA: Shortest Path Faster Algorithm
Bellman-Ford algorithm: comes to the rescue.; Lesson 980 — Bellman-Ford Overview and Motivation
Below lower threshold: Remove frames from this process; Lesson 1376 — Page Fault Frequency
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
Benchmarking: measures actual runtime on real hardware with real data.; Lesson 441 — Benchmarking and Practical Performance
Benefit: Fetch and memory-access stages can proceed simultaneously without conflict.; Lesson 1164 — Resolving Structural Hazards
Benefits: Better isolation, improved security, easier to maintain and debug individual services.; Lesson 1196 — Microkernel Architecture Lesson 1198 — Layered Operating System Structure Lesson 1454 — Network Switches vs Hubs Lesson 1998 — Type Checking at Compile Time Lesson 2028 — Ahead-of- Time vs Just-in-Time Execution Lesson 2584 — Concurrent Lists: Hand-Over-Hand Locking
Benefits you get: Lesson 2772 — Iterative Deepening in Games
Bernoulli distribution: models the simplest random experiment: a single trial with exactly two possible outcomes.; Lesson 124 — Bernoulli Distribution
Bernoulli trial: (success probability *p*, failure probability *1-p*).; Lesson 125 — Binomial Distribution
Best approach: Maintain a `size` counter variable that:; Lesson 384 — Queue Size and IsEmpty Operations
Best case: O(1) — the bucket is empty or has just one element; Lesson 421 — Separate Chaining: Analysis Lesson 674 — Adjacency List: Operations and Complexity
Best case (balanced): O(log n) stack space; Lesson 525 — Space Complexity of BSTs
Best Case: O(n): Lesson 748 — Insertion Sort: Analysis
Best for: Frequent insertions, rare removals; Lesson 390 — Priority Queue Array Implementation Lesson 798 — Linear-Time Sorting: Practical Considerations Lesson 1007 — Common Heuristics for Grid Graphs Lesson 1019 — Prim's Algorithm: Time Complexity Analysis Lesson 1737 — Popular Key-Value Stores: Redis and DynamoDB Lesson 2509 — PBKDF2 and Key Derivation Lesson 2716 — Popular Message Queue Systems Lesson 2761 — IDA* (Iterative Deepening A*)
Best of both worlds: Strong security where needed, speed where it matters; Lesson 1530 — Symmetric vs Asymmetric Encryption in TLS Lesson 2745 — Iterative Deepening DFS
Best practice: Avoid shadowing by using distinct names.; Lesson 211 — Shadowing: When Names Collide Lesson 1572 — DELETE Statement for Removing Data
Best-Case: The person you're looking for is sitting in the very first seat.; Lesson 272 — Best-Case, Worst-Case, and Average-Case Lesson 277 — Analyzing Conditional Statements Lesson 300 — Best-Case, Worst-Case, and Average-Case Analysis Lesson 781 — Heapsort Time Complexity Analysis
Beta (β): The best score the minimizer can guarantee so far; Lesson 2768 — Alpha-Beta Pruning
Better: A function that considers all bits of the input evenly; Lesson 1690 — Hash Function Selection for Indexes
Better approach (consistent abstraction): Lesson 2310 — Function Length and Single Responsibility
Better blocking behavior: When one user thread blocks, others can continue executing; Lesson 1236 — Multithreading Models: Many-to-Many
Better cache behavior: Keeps processes on the same CPU (processor affinity); Lesson 1266 — Per-CPU Run Queues
Better cache performance: Less memory access improves real-world speed; Lesson 631 — Compressed Tries (Radix Trees)
Better Design: TDD naturally leads to modular, loosely-coupled code.; Lesson 2263 — TDD Benefits and Common Pitfalls
Better error detection: Syntax errors caught at compile-to-bytecode stage; Lesson 2033 — Bytecode Compilation: The Hybrid Approach
Better height preservation: Tree height depends on *unique* values, not total elements; Lesson 528 — BST with Duplicate Keys
Better move ordering: Earlier shallow searches inform alpha-beta pruning in deeper searches, making pruning more effective; Lesson 2772 — Iterative Deepening in Games
Better Multiprocessor Utilization: On multi-core systems, your threads can genuinely run in parallel, taking full advantage of available hardware.; Lesson 1235 — Multithreading Models: One-to-One
Better throughput: Reduces wild back-and-forth seeking; Lesson 1425 — SCAN (Elevator) Algorithm
BFS: from the source to assign levels.; Lesson 1042 — Dinic's Algorithm Implementation
BFS tree: a subset of the graph's edges that form a tree rooted at the source.; Lesson 700 — BFS Tree and Parent Tracking
BGP: (Border Gateway Protocol): Used between autonomous systems on the Internet; Lesson 1470 — Static vs Dynamic Routing Protocols
Bias: measures how far off your model's average predictions are from the true values.; Lesson 2782 — The Bias-Variance Tradeoff Lesson 2808 — The Bias-Variance Tradeoff Lesson 2816 — What is Linear Regression?Lesson 2817 — The Linear Model Equation
Bias Reduction: Combining diverse models that make different types of errors can capture patterns that individual models miss.; Lesson 2853 — Introduction to Ensemble Learning
bias-variance tradeoff: describes how these errors decompose into two competing sources:; Lesson 2782 — The Bias-Variance Tradeoff Lesson 2784 — Baseline Models and Evaluation Lesson 2853 — Introduction to Ensemble Learning
Bidirectional BFS: launches two simultaneous searches—one from the start vertex and one from the goal vertex— expanding both frontiers until they collide.; Lesson 707 — Bidirectional BFS
Bidirectional processing: scenarios benefit from deques.; Lesson 394 — Queue Variant Applications
Bidirectional search: runs *two* searches at once: one forward from the start state and one backward from the goal state.; Lesson 2747 — Bidirectional Search Lesson 2762 — Bidirectional Heuristic Search
Bidirectional type checking: combines both approaches strategically: some language constructs *infer* their types upward, while others *check* against types pushed downward from context.; Lesson 2015 — Bidirectional Type Checking Lesson 2016 — Type Inference in Modern Languages
Big Ball of Mud: is a system that has grown organically without any guiding architectural vision.; Lesson 2308 — Big Ball of Mud Anti-Pattern
Big-endian: Most significant byte first (like reading left-to-right); Lesson 29 — Byte Order Marks and Endianness
Big-O: "It will take *at most* this long" (upper bound); Lesson 296 — Introduction to Big-Omega Notation Lesson 304 — Space Complexity Notation
Big-O (O): "grows at most this fast" (upper bound only); Lesson 292 — Introduction to Big-Theta Notation Lesson 299 — Relationship Between Big-O, Big-Omega, and Big-Theta Lesson 300 — Best-Case, Worst-Case, and Average-Case Analysis
Big-O notation: formalizes this intuition into precise mathematical language.; Lesson 280 — What is Big-O Notation?
Big-Omega: "It will take *at least* this long" (lower bound); Lesson 296 — Introduction to Big-Omega Notation Lesson 304 — Space Complexity Notation
Big-Omega (Ω): is like saying "you scored *at least* 85%" — a lower bound; Lesson 299 — Relationship Between Big-O, Big-Omega, and Big-Theta Lesson 300 — Best-Case, Worst- Case, and Average-Case Analysis
Big-step: "The expression `3 + 4 × 2` evaluates to `11`.; Lesson 2018 — Small-Step vs Big-Step Semantics
Big-step semantics: (also called *natural semantics* or *evaluation semantics*) models computation by relating an initial expression directly to its final result.; Lesson 2018 — Small-Step vs Big-Step Semantics
Big-Theta: "It will take *exactly* this rate" (tight bound—both upper and lower match); Lesson 296 — Introduction to Big-Omega Notation Lesson 304 — Space Complexity Notation
Big-Theta (Θ): "grows exactly this fast" (tight bound, both upper and lower); Lesson 292 — Introduction to Big-Theta Notation Lesson 299 — Relationship Between Big-O, Big-Omega, and Big-Theta
Big-Theta notation: describes a **tight bound** on an algorithm's growth rate.; Lesson 292 — Introduction to Big-Theta Notation
binary: (base-2)—a number system with just two digits: **0** (off) and **1** (on).; Lesson 1 — What is Binary and Why It Matters Lesson 1461 — IPv4 Address Structure and Notation
Binary alphabet: {0, 1}; Lesson 1756 — Alphabets and Strings
Binary heap-based: O((V + E) log V) time complexity; Lesson 976 — Dijkstra's on Dense vs Sparse Graphs
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 Operations: An expression with an operator evaluates by first evaluating its left operand, then its right operand, then applying the operation.; Lesson 2020 — Operational Semantics of Arithmetic Expressions
binary search: to find the correct insertion position faster, reducing the number of comparisons from O(n) to O(log n) per element.; Lesson 749 — Insertion Sort: Binary Search Optimization Lesson 841 — Divide and Conquer Paradigm Overview Lesson 842 — Recurrence Relations for Divide and Conquer Lesson 851 — Median of Two Sorted Arrays Lesson 2208 — Git Bisect for Bug Hunting
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 Search Tree (BST): , on the other hand, enforces the **BST invariant**: for every node, all values in its left subtree are smaller, and all values in its right subtree are larger.; Lesson 495 — BST vs General Binary Trees
binary semaphore: can only hold the values **0 or 1**.; Lesson 1293 — Binary Semaphores vs Counting Semaphores Lesson 1296 — Mutual Exclusion with Binary Semaphores
Binary strings: of length 5: 2⁵ = 32 strings (each position: 0 or 1); Lesson 101 — Permutations with Repetition
binary tree: is a specialized tree structure where every node has *at most two children*.; Lesson 457 — Binary Tree Definition Lesson 614 — Huffman Coding Tree Construction Lesson 890 — Huffman Coding for Data Compression
Binary tree specificity: Unlike general trees, each node has at most two children, simplifying your state transitions—you only combine left and right results.; Lesson 948 — DP on Binary Trees
bind: it to a specific IP address and port number so that other computers know exactly where to reach you.; Lesson 1542 — TCP Socket Creation and Binding Lesson 2479 — Parameterized Queries and Prepared Statements
Binding: associates your socket with a specific port number on your machine.; Lesson 1495 — UDP Socket Programming Basics
Binding step: extend environment with `{a ↦ 3, b ↦ 5}`; Lesson 2025 — Function Call Semantics
binds: a variable—meaning it takes ownership of that variable within a specific region called its **scope**.; Lesson 53 — Quantifier Scope and Binding Lesson 1488 — UDP Port Numbers and Multiplexing
Binds variables: to concrete values that make the match work; Lesson 2159 — Queries and Unification
binomial coefficient: Lesson 100 — Combinations: Selections Without Order Lesson 105 — The Binomial Theorem
Binomial Distribution: tells you the probability of getting *exactly* k heads out of those n = 10 flips.; Lesson 125 — Binomial Distribution
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: splits vertices into two independent sets where edges *only* connect vertices from different sets— never within the same set.; Lesson 666 — Complete, Bipartite, and Regular Graphs Lesson 689 — Bipartite Graphs Lesson 703 — BFS for Bipartiteness Testing Lesson 1046 — Bipartite Matching via Max Flow Lesson 1047 — Maximum Bipartite Matching Algorithm
Bison: is its modern, open-source successor and is largely compatible.; Lesson 1973 — Parser Generators and YACC/Bison
bit: the smallest unit of data in computing.; Lesson 1 — What is Binary and Why It Matters Lesson 649 — Fenwick Tree (Binary Indexed Tree) Introduction
Bit = 0: Last time, branch was not taken → predict **not taken**; Lesson 1178 — One-Bit Branch Predictor
Bit = 1: Last time, branch was taken → predict **taken**; Lesson 1178 — One-Bit Branch Predictor
Bit flipping: XORing a bit with 1 toggles it (0 → 1, 1→ 0); Lesson 35 — Exclusive OR (XOR)
Bit masking: Maximum speed, requires power-of-2 table sizes; Lesson 410 — Hashing Integers
Bit rate: How fast bits travel (e.; Lesson 1433 — OSI Layer 1: Physical Layer
Bit Strings: How many 8-bit strings have exactly three 1s?; Lesson 107 — Counting Problems in Computer Science
Bit-Stuffing: Lesson 1446 — Framing Techniques
Bitcoin and blockchain: ECDSA (secp256k1 curve) secures cryptocurrency transactions; Lesson 2438 — ECDSA (Elliptic Curve Digital Signature Algorithm)
bitmasks: to pack multiple boolean flags into a single integer.; Lesson 952 — State Compression for Tree DP Lesson 962 — Bitmasking for Subset DP
Bitsets: Compact representation when state is binary flags; Lesson 2731 — State Representation Strategies
black: Lesson 551 — Insertion Case 3: Uncle is Black, Line Configuration Lesson 554 — Deletion Cases: Black Sibling with Red Children Lesson 2099 — Tri-Color Marking Lesson 2102 — Write Barriers
black box: to the one above—only the interface matters, not the internal implementation.; Lesson 1198 — Layered Operating System Structure Lesson 2218 — Black Box vs White Box Testing
Black box testing: treats the system like a sealed box.; Lesson 2218 — Black Box vs White Box Testing Lesson 2221 — Equivalence Partitioning
blank symbol: (often written as or ⊔) to mark empty cells, plus any symbols your computation needs (like 0, 1, or letters).; Lesson 1851 — Components of a Turing Machine Lesson 1852 — Turing Machine Tape and Symbols
Blind: attacks occur when the application doesn't display database errors or query results directly.; Lesson 2476 — Types of SQL Injection Attacks
Blind SQL injection: solves this by turning the database into a yes/no answering machine—extracting data one bit at a time through observable differences in application behavior.; Lesson 2478 — Blind SQL Injection Techniques
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 Lesson 1146 — Impact of Block Size on Performance
Block 1: A simple loop that runs `n` times → roughly `n` operations; Lesson 276 — Analyzing Sequential Statements
Block 2: Another loop that runs `n²` times → roughly `n²` operations; Lesson 276 — Analyzing Sequential Statements
Block 3: A single assignment → `1` operation; Lesson 276 — Analyzing Sequential Statements
Block offset: Last 3 bits (log₂(8) = 3): `0x2C & 0x7 = 4`; Lesson 1135 — Cache Placement Example Calculations
Block offset bits: – locate the byte within the cache line; Lesson 1133 — Set-Associative Address Mapping
Block Redundant Ports: Any port that would create a loop is placed in a **blocking state**—it won't forward frames but stays ready as backup; Lesson 1458 — Spanning Tree Protocol (STP)
Block vs character devices: Different device access patterns; Lesson 1389 — File Types and Classification
Blocked: ) state.; Lesson 1219 — Process States: Running and Waiting Lesson 1557 — Relational Integrity Constraints Lesson 2719 — 2PC Failure Modes and Blocking
Blocked progress: Authors can't merge working code because of minor formatting debates; Lesson 2345 — Distinguishing Critical vs Stylistic Issues
blocking: by default—it waits until a client attempts to connect.; Lesson 1543 — TCP Server: Listen and Accept Lesson 1544 — TCP Client: Connect to Server Lesson 1549 — Non-Blocking Sockets and I/O Multiplexing Lesson 2653 — Two-Phase Commit Protocol
Blocking dictionary words entirely: Prevents strong passphrases like `Blue-Mountain-Coffee-Morning`; Lesson 2512 — Password Policies and Requirements
Blocking lock: Ask the OS to put the thread to sleep and wake it later; Lesson 1287 — Spin Locks vs Blocking Locks
Blocking locks: Higher initial overhead, but efficient use of CPU during wait; Lesson 1287 — Spin Locks vs Blocking Locks
Blocking/Tiling: Lesson 805 — Cache-Friendly Sorting Techniques
Blocking/waking: (sleep when empty, wake when available); Lesson 1301 — Resource Counting with Counting Semaphores
blocks: (waits) until the lock becomes available.; Lesson 1281 — Lock Semantics and Acquire/Release Lesson 1285 — Trylock and Nonblocking Lock Attempts Lesson 1294 — Wait (P) and Signal (V) Operations Lesson 2119 — Statement-Oriented Syntax
Blue: (current live version) and **Green** (new version).; Lesson 2392 — Deployment Strategies: Blue-Green and Canary
Blue-Green: Best when you need all-or-nothing deployment with instant rollback.; Lesson 2392 — Deployment Strategies: Blue-Green and Canary
body: contains data being sent to the server, typically with `POST` or `PUT` requests.; Lesson 1515 — HTTP Request Structure Lesson 1518 — HTTP Response Structure and Status Codes Lesson 1980 — AST Representation of Function Definitions
Body evaluation: executing the function's code; Lesson 2025 — Function Call Semantics
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: is an entity set containing all book entities; Lesson 1612 — Entities and Entity Sets
Boolean: is the simplest data type—it can only be one of two values: **TRUE** or **FALSE**.; Lesson 13 — Boolean Values and Truth Tables Lesson 142 — Boolean Data Type Lesson 157 — Comparison Operators
Boolean expressions: using comparison and logical operators?; Lesson 165 — What Are Conditionals?Lesson 166 — Boolean Expressions in Conditionals
Boolean inputs: (remember: TRUE or FALSE, 1 or 0) and produces a single output.; Lesson 15 — The AND Gate
Boolean-based: Observes differences in page content (success vs.; Lesson 2476 — Types of SQL Injection Attacks
Booleans: (`bool`): Truth values `true` or `false`; Lesson 1986 — Primitive Types
Boosting: (like AdaBoost, Gradient Boosting, XGBoost) excels when you have:; Lesson 2862 — Ensemble Selection and Hyperparameters
borrow: keys.; Lesson 1677 — B-Tree Structure and Properties Lesson 1682 — B-Tree Deletion Overview
Borrow 2 host bits: Now you have 26 network bits, 6 host bits; Lesson 1464 — Subnetting Fundamentals
both: conditions simultaneously.; Lesson 55 — Quantifiers Over Restricted Domains Lesson 113 — Addition Rule for Probabilities Lesson 167 — The if Statement Lesson 299 — Relationship Between Big-O, Big-Omega, and Big-Theta Lesson 392 — Deque Array Implementation Lesson 1565 — Logical Operators: AND, OR, NOT Lesson 1577 — Inner Join Basics Lesson 1578 — Inner Join with Multiple Conditions (+9 more)
both directions: Lesson 346 — Deleting from the Middle of a Doubly Linked List Lesson 347 — Bidirectional Traversal in Doubly Linked Lists
Both parties verify identities: using digital certificates; Lesson 1524 — Introduction to HTTPS
bottleneck: of an augmenting path is the smallest residual capacity among all edges in the path.; Lesson 1028 — Augmenting Paths Lesson 1029 — Residual Capacity of a Path Lesson 1286 — Lock Granularity and Performance Lesson 2577 — Lock-Based vs Lock-Free Approaches
bottom-up: even though the code is written recursively—you must know the children's values before computing the parent's.; Lesson 643 — Building a Segment Tree Lesson 913 — What is Dynamic Programming?Lesson 943 — Tree DP Fundamentals Lesson 1974 — Bottom-Up vs Top-Down Tradeoffs Lesson 2237 — Incremental Integration Approach
Bottom-Up (Post-order): Start at the leaves and work toward the root.; Lesson 943 — Tree DP Fundamentals
Bottom-up approach: Lesson 924 — Climbing Stairs Problem
Bottom-Up Mergesort: flips the traditional top-down approach on its head.; Lesson 760 — Bottom-Up Mergesort
Bottom-up order: you solve small problems first, then combine them; Lesson 917 — Tabulation (Bottom-Up DP)
Bottom-up parsers: handle a broader class of grammars.; Lesson 1974 — Bottom-Up vs Top-Down Tradeoffs
Bottom-up parsing: starts with the input tokens and gradually reduces them into higher-level grammar constructs until reaching the start symbol.; Lesson 1960 — Bottom-Up Parsing Overview
Bottom-up team: starts at the database layer, using drivers to call upward, testing the data access components; Lesson 2240 — Sandwich Integration Testing
Boundaries: minimum/maximum values (e.; Lesson 2260 — Handling Edge Cases and Boundaries
Boundary checking: The system inserts runtime checks where typed and untyped code meet; Lesson 2005 — Gradual Typing Systems
Boundary clocks: in switches relay timing while maintaining accuracy; Lesson 2635 — Precision Time Protocol (PTP)
Boundary Value Analysis (BVA): is a black-box testing technique that focuses on values at the boundaries between valid and invalid input partitions.; Lesson 2222 — Boundary Value Analysis
Boundary values: Test exactly at the limit, just inside, and just outside.; Lesson 2228 — Testing Edge Cases and Boundaries
Bounded drift: between logical and physical time; Lesson 2636 — Hybrid Logical Clocks
Bounded Waiting Property: prevents this from happening to processes competing for access to critical sections.; Lesson 1277 — Bounded Waiting Property
Bounds checking: means verifying that an index is within the valid range before accessing it.; Lesson 264 — String Length and Bounds Checking Lesson 1381 — Segmentation with Protection and Sharing
Boyer-Moore: More complex preprocessing, but often fastest in practice for natural text; Lesson 840 — String Searching Applications and Tradeoffs
Branch History Table (BHT): Lesson 1177 — Dynamic Branch Prediction Basics Lesson 1178 — One-Bit Branch Predictor
Branch Instructions: (like `JUMP`, `BRANCH`); Lesson 1090 — Instruction Cycle Variations Lesson 1172 — Control Hazards: Branch Impact
Branch mispredictions: Wrong predictions require flushing the pipeline and restarting with the correct path; Lesson 1186 — Cycles Per Instruction (CPI)
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: is expressed as a percentage:; Lesson 1184 — Branch Prediction Performance Impact
Branch Target Buffer (BTB): is a small, fast cache that stores the *target addresses* of recently executed branch instructions.; Lesson 1180 — Branch Target Buffer (BTB)
Branches: Each possible transition choice (including epsilon transitions); Lesson 1797 — Computation Trees in NFAs Lesson 2838 — Decision Tree Intuition and Structure
Branching: Centralized systems often make branching expensive (copying directories on the server).; Lesson 2168 — Git vs Other Version Control Systems
Branching factor (b): average number of actions available per state; Lesson 2735 — State Space Size and Complexity
Breach isolation: If one service is compromised, your other accounts remain safe; Lesson 2515 — Password Managers and Best Practices
Breadth-First Search: , which treats all edges equally, **Uniform-Cost Search** recognizes that edges can have different *costs* (weights).; Lesson 2746 — Uniform-Cost Search
Bridge: You're designing a universal remote control system.; Lesson 2281 — Adapter vs Bridge: When to Use Which Lesson 2283 — Structural Pattern Trade-offs Lesson 2284 — Combining Structural Patterns
Bridge is about flexibility: .; Lesson 2281 — Adapter vs Bridge: When to Use Which
Bridge Pattern: is *proactive design*.; Lesson 2281 — Adapter vs Bridge: When to Use Which
Brittle system: Easy to introduce inconsistencies; Lesson 2337 — Shotgun Surgery Smell
Brittleness: Small UI changes (a renamed button class, a reordered form field) can break dozens of tests.; Lesson 2254 — E2E Testing Challenges and Best Practices
Broken pipe: Writing to a socket after the other end has closed; Lesson 1550 — Error Handling and Socket Shutdown
Browser developer tools: help trace how data flows through your application.; Lesson 2463 — Testing and Detecting XSS Vulnerabilities
Browser sends it back: On every subsequent request to that domain, the browser automatically includes:; Lesson 1522 — HTTP Cookies and State Management
Browser stores it: Your browser saves `session_id=abc123` associated with that domain.; Lesson 1522 — HTTP Cookies and State Management
Browser-based clients: When your API serves a single-page application (SPA) that stores tokens in cookies for convenience, you've reintroduced CSRF risk.; Lesson 2471 — CSRF in REST APIs
Browsers automatically send credentials: (cookies, HTTP authentication) with every request to a domain; Lesson 2464 — What is CSRF?
BST (balanced): O(log n) - eliminates half the tree at each step.; Lesson 526 — Comparing BST to Array and Linked List
BST (worst-case): O(n) - degenerates to a linked list shape.; Lesson 526 — Comparing BST to Array and Linked List
BST Insert: Start at the root and traverse down comparing keys, just like ordinary BST insertion, until you find the appropriate spot for the new node; Lesson 572 — Splay Tree Insertion
BST invariant: (also called the BST property) is the fundamental rule that every Binary Search Tree must satisfy at all times:; Lesson 494 — The BST Invariant Lesson 495 — BST vs General Binary Trees
BSTs excel at: Search, finding min/max, range queries, sorted traversal; Lesson 584 — Comparing Heaps to BSTs
BTB hit: The BTB contains an entry → the processor immediately knows this is a branch and where it goes, so it can fetch from the predicted target address right away; Lesson 1180 — Branch Target Buffer (BTB)
BTB miss: No entry found → proceed normally through fetch and decode; Lesson 1180 — Branch Target Buffer (BTB)
Bubble down: the new root to restore heap order; Lesson 591 — Implementing Extract Operation
Bubble Sort: Stable (equal elements maintain their original order); Lesson 751 — Comparing Elementary Sorts
Bucket Overflow: occurs when a bucket becomes full.; Lesson 1694 — Hash Index Insertion and Deletion
Bucket Sort: can be very efficient.; Lesson 799 — When to Use Which Sorting Algorithm
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 Lesson 1689 — Hash Index Structure
Buffering: .; Lesson 1395 — Standard I/O and Buffering
Buffering Strategies: Lesson 1949 — Optimizing Lexical Analyzers
Bug fixes: `bugfix/login-crash` or `fix/null-pointer-error`; Lesson 2193 — Branch Management Best Practices
Bug multiplication: A single defect exists in multiple places; Lesson 2332 — Duplicate Code Smell
Build a graph: Each pixel becomes a node.; Lesson 1051 — Image Segmentation with Min-Cut
Build a heap: from the unsorted array (organizing elements so the maximum is on top); Lesson 777 — Heapsort Overview and Motivation
Build a level graph: using BFS to assign each node a "distance" (level) from the source; Lesson 1042 — Dinic's Algorithm Implementation
Build a max-heap: from the unsorted array (takes O(n) time using bottom-up construction); Lesson 601 — Heapsort Overview and Basic Idea
Build complexity: Compose simple procedures into more sophisticated ones; Lesson 2118 — Procedural Abstraction
Build expression objects: – Each part (number, addition, subtraction) becomes an object; Lesson 2300 — Interpreter Pattern
Build Heap: operation you learned earlier:; Lesson 598 — Merge Two Heaps Lesson 599 — Heap Operation Trade-offs
Build level by level: Index 0 → children at 1,2 → their children at 3,4,5,6, and so on; Lesson 583 — Visualizing Heap Structure
Build method: Validates and returns the final constructed object; Lesson 2270 — Builder Pattern for Complex Objects
Build systems: File dependencies must form a DAG, or compilation becomes impossible; Lesson 663 — Cycles and Acyclic Graphs
Build-up from simpler cases: Generating all subsets?; Lesson 867 — Identifying Recursive Structure
Builder: Perfect for constructing complex objects with many optional parameters or configuration steps.; Lesson 2273 — Choosing the Right Creational Pattern Lesson 2303 — Spaghetti Code Anti-Pattern
Builder class: Holds temporary state and provides step methods; Lesson 2270 — Builder Pattern for Complex Objects
Building the heap: When converting the array into a max-heap, elements are rearranged based on heap property rules, not their original positions.; Lesson 783 — Heapsort Stability
Builds the entire application: to ensure everything compiles; Lesson 2383 — What is Continuous Integration?
Built-in strength: Most managers automatically generate passwords meeting high entropy requirements; Lesson 2515 — Password Managers and Best Practices
Business impact: Does this flow directly affect revenue or core functionality?; Lesson 2248 — Test Scenarios and User Journeys
Business metrics: How many active customers?; Lesson 1592 — COUNT Function
Business rule violations: (duplicate username, insufficient permissions); Lesson 2231 — Testing Exception Handling
Business rules: Account balances can't be negative, order totals must match line items; Lesson 1658 — Consistency: Maintaining Database Invariants Lesson 2312 — Comments: When and How to Use Them
Busy (EBUSY): The lock is currently held by another thread.; Lesson 1285 — Trylock and Nonblocking Lock Attempts
Byte-Stuffing (Character Stuffing): Lesson 1446 — Framing Techniques
Bytecode: Virtual machine instructions (like Java bytecode or Python bytecode); Lesson 2049 — Introduction to Code Generation
Bytecode systems: like Java's JVM split the difference: compile to an intermediate bytecode once, then run on any platform with a JVM.; Lesson 2035 — Platform Dependency and Portability
bytes: , which can represent 256 values (0–255).; Lesson 25 — Extended ASCII and Code Pages Lesson 152 — Memory and Variable Storage Lesson 1461 — IPv4 Address Structure and Notation
Byzantine failure: when it behaves arbitrarily—sending contradictory messages, lying, colluding with other faulty nodes, or acting maliciously.; Lesson 2651 — Failure Models: Crash vs Byzantine
Byzantine failures: are far more challenging.; Lesson 2593 — Node Failures: Crash and Byzantine

C

c = 3: and **n₀ = 0**, then for all n ≥ 0:; Lesson 297 — Formal Definition of Big-Omega Lesson 298 — Proving Big-Omega Bounds
C-LOOK: (Circular LOOK): Like C-SCAN, but instead of traveling to the disk end before jumping back to the beginning, it reverses at the last request in the forward direction, jumps to the lowest pending request, and continues servicing in one direction only.; Lesson 1427 — LOOK and C-LOOK Variants
C-SCAN (Circular SCAN): treats the disk as if it were circular, always scanning in **one direction only**.; Lesson 1426 — C-SCAN (Circular SCAN)
C(n, k): or **"n choose k"**, tell you how many ways you can select k items from n items (combinations).; Lesson 104 — Binomial Coefficients and Pascal's Triangle Lesson 125 — Binomial Distribution
C(n, r): or `nCr`, also called the **binomial coefficient**:; Lesson 100 — Combinations: Selections Without Order
C(n,k): are the binomial coefficients from Pascal's Triangle you just learned.; Lesson 105 — The Binomial Theorem
C++ `std::sort()`: Typically implements Introsort (quicksort that switches to heapsort if recursion depth exceeds a threshold), guaranteeing O(n log n) worst-case but **not stable**; Lesson 808 — Standard Library Sort Functions
C++ `std::stable_sort()`: Guarantees stability using a mergesort-based approach; Lesson 808 — Standard Library Sort Functions
CA: (Consistency + Availability) in a truly distributed system because network partitions are inevitable —you can't ignore partition tolerance.; Lesson 2600 — Introduction to the CAP Theorem
CA-leaning: in single-node setups, but shift to **CP** when distributed.; Lesson 1714 — CAP Theorem Trade-offs Across Categories
Cache: Very fast memory right next to CPU cores; kilobytes to megabytes; Lesson 1106 — The Memory Hierarchy Concept Lesson 1119 — Cache Hit vs Cache Miss
Cache (L1, L2, L3): Very expensive—measured in kilobytes to megabytes; Lesson 1111 — Cost Per Byte Analysis
Cache (L1/L2/L3): High bandwidth (tens to hundreds of GB/s), but decreases as you move to outer cache levels; Lesson 1113 — Memory Bandwidth Considerations
Cache effects: Lock operations themselves are expensive, involving memory barriers and context switches; Lesson 2576 — Why Thread-Safe Data Structures?
Cache efficiency: makes quicksort faster in practice.; Lesson 774 — Quicksort vs Mergesort: Practical Comparison Lesson 2109 — Reference Counting Performance
Cache friendly: Contiguous memory improves performance; Lesson 683 — Hybrid and Compressed Representations
cache hit: (fast).; Lesson 439 — Cache Performance and Memory Locality Lesson 1119 — Cache Hit vs Cache Miss Lesson 1128 — Direct-Mapped Cache Lookup Lesson 1130 — Fully Associative Caches Lesson 1133 — Set- Associative Address Mapping Lesson 1138 — Cache Hit and Miss Definitions
Cache Levels: (L1, L2, L3); Lesson 1107 — Storage Pyramid Levels
cache lines: (typically 64 bytes) from memory.; Lesson 529 — Cache Performance and BSTs Lesson 682 — Memory Layout and Cache Performance
cache locality: the CPU pre-loads nearby data automatically.; Lesson 385 — Queue Implementation Tradeoffs Lesson 804 — In-Place vs Out-of-Place Tradeoffs
Cache memory: (L1, L2, L3); Lesson 1112 — Volatile vs Non-Volatile Memory
cache miss: (slow—up to 100x slower).; Lesson 439 — Cache Performance and Memory Locality Lesson 529 — Cache Performance and BSTs Lesson 682 — Memory Layout and Cache Performance Lesson 1119 — Cache Hit vs Cache Miss Lesson 1120 — Cache Lines and Blocks Lesson 1128 — Direct-Mapped Cache Lookup Lesson 1130 — Fully Associative Caches Lesson 1138 — Cache Hit and Miss Definitions
Cache Miss Detection: Lesson 1141 — Miss Penalty Components
cache misses: as the CPU jumps between distant memory locations.; Lesson 385 — Queue Implementation Tradeoffs Lesson 1186 — Cycles Per Instruction (CPI)
Cacheable: Responses can be cached by browsers or proxies; Lesson 1516 — HTTP Methods: GET and POST
Caching: is storing computed results so you can retrieve them instantly later.; Lesson 443 — Caching and Memoization Lesson 1116 — The Memory Gap Problem Lesson 2388 — CI Best Practices: Fast Feedback
Caching layers: Temporary inconsistency is expected; Lesson 1734 — Eventual Consistency Trade-offs
Caesar cipher: is the most famous example: shift every letter by a fixed number of positions in the alphabet.; Lesson 2396 — The Substitution Cipher Lesson 2398 — Polyalphabetic Ciphers and the Vigenère Cipher
Calculate: aggregate values (like sum or count); Lesson 468 — What is Tree Traversal?Lesson 1380 — Logical Address Translation in Segmentation
Calculate balance factor: `balance = left_child_height - right_child_height`; Lesson 540 — Updating Heights After Insertion
Calculate Best Paths: Each switch determines its shortest path to the root bridge; Lesson 1458 — Spanning Tree Protocol (STP)
Calculate child entropies: Measure impurity in each resulting subset; Lesson 2843 — Information Gain
Calculate expected value: using probability distributions: E[X] = sum of (outcome × probability); Lesson 137 — Expected Value and Variance in Algorithm Analysis
Calculate parent entropy: Measure the impurity of the dataset before splitting; Lesson 2843 — Information Gain
Calculate parent index: `parent = (i - 1) // 2` (integer division); Lesson 587 — Implementing Heap Insert
Calculate the cache index: `index = (block_address) % N`; Lesson 1126 — Direct-Mapped Caches
Calculate value-to-weight ratio: for each item; Lesson 889 — Fractional Knapsack Problem
Calculate variance: to understand consistency: Var(X) = E[X²] - (E[X])²; Lesson 137 — Expected Value and Variance in Algorithm Analysis
Calculation (sender side): Lesson 1489 — UDP Checksum Calculation and Verification
call: (or "invoke") them.; Lesson 188 — Calling Functions Lesson 221 — Computing Factorials Recursively
Call an evaluation function: to estimate how favorable the position is; Lesson 2771 — Depth-Limited Minimax
Call other functions: for non-terminals; Lesson 1952 — Implementing Recursive Descent Functions
Call signal() or broadcast(): to wake waiting threads; Lesson 1306 — The Wait-Signal Pattern
call stack: , a special region of memory that works like a stack of plates.; Lesson 224 — Call Stack and Stack Overflow Lesson 308 — Recursion and Call Stack Space Lesson 369 — Function Call Stack and Recursion Lesson 374 — Stack-Based Memory Management Lesson 711 — DFS Iterative Implementation with Stack
Call stack (DFS): Depth at most V in worst case; Lesson 727 — Time and Space Complexity
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 Lesson 206 — Function Signatures and Contracts
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: is a standard agreement about:; Lesson 1104 — Function Parameters and Calling Conventions Lesson 2056 — Function Call Code Generation
Calls: other parsing functions for non-terminals in the rule; Lesson 1952 — Implementing Recursive Descent Functions
CAM: solves this with special hardware that performs *parallel comparison*.; Lesson 1131 — Associative Cache Lookup and CAM
camelCase: `firstName`, `totalScore` (common in many languages); Lesson 147 — Variable Naming Conventions Lesson 191 — Function Naming Conventions
Can't allocate more frames: Suspend or swap out a process to free memory; Lesson 1376 — Page Fault Frequency
Canary: Best when you want gradual risk mitigation and real-world validation.; Lesson 2392 — Deployment Strategies: Blue-Green and Canary
Candidate: wants to become a **Leader**, it sends `RequestVote` RPCs to all other servers asking for their vote.; Lesson 2661 — Raft RPCs: RequestVote and AppendEntries Lesson 2663 — Leader Election: Voting Process
Candidate → Follower: When a candidate discovers a leader with an equal or higher term; Lesson 2659 — Raft Server States: Follower, Candidate, Leader
Candidate → Leader: When a candidate receives votes from a majority of servers (quorum); Lesson 2659 — Raft Server States: Follower, Candidate, Leader
Candidate keys: are *all* possible attributes (or combinations) that could serve as primary keys.; Lesson 1614 — Key Attributes and Identifiers
cannot: express:; Lesson 1777 — Limitations of Regular Expressions Lesson 2630 — Limitations of Lamport Timestamps
Cannot be null: References always refer to a valid object; Lesson 320 — References as Aliases
Cannot be reached: during execution (unreachable code); Lesson 2063 — Dead Code Elimination
Cannot be reassigned: Once bound, always bound to that variable; Lesson 320 — References as Aliases
Capability-based: systems elegantly handle delegation but require careful revocation mechanisms.; Lesson 2533 — Authorization Model Tradeoffs
Capacities: Lane counts on roads (2-lane road = capacity 2000 cars/hour); Lesson 1022 — Flow Networks and Definitions Lesson 1049 — Assignment Problem
Capacity: Pipelines where weights represent maximum flow; Lesson 659 — Weighted vs Unweighted Graphs Lesson 685 — Weighted and Unweighted Graphs Lesson 1030 — Cuts in Flow Networks Lesson 1031 — The Max-Flow Min-Cut Theorem Lesson 2428 — SHA-3 and Keccak
Capacity constraint: For every edge (u, v), the flow cannot exceed capacity: `0 ≤ f(u, v) ≤ c(u, v)`; Lesson 1022 — Flow Networks and Definitions
capacity constraints: .; Lesson 1024 — Capacity Constraints Lesson 1025 — Valid Flows and Flow Value Lesson 1035 — Flow Conservation and Capacity Constraints Lesson 1054 — Circulation with Demands
CAPTCHA: challenges after failed attempts; Lesson 2514 — Credential Stuffing and Breach Detection
Captures before quiet moves: (taking pieces is often strong); Lesson 2769 — Move Ordering in Alpha-Beta
Capturing outputs: from one stage at the clock edge; Lesson 1150 — Pipeline Registers and Latches
cardinality: defines how many instances of one entity can be associated with instances of another entity.; Lesson 1616 — Relationship Cardinality: One-to-One and One-to-Many Lesson 1700 — Cardinality Estimation Lesson 1764 — The Empty Language vs Empty String
Careful merge operations: Mergesort stays stable by always taking from the left subarray first when elements are equal; Lesson 803 — Stability in Production Sorting
Caretaker: Manages when to save and restore states (e.; Lesson 2298 — Memento Pattern
Carry flag (C): Set if an addition produced a carry-out or subtraction needed a borrow; Lesson 1077 — Accumulator and Status Registers
Carry Flag (CF): might be set.; Lesson 1098 — Comparison and Test Instructions
Cartesian product: of two sets creates a new set containing every possible ordered pair where the first element comes from the first set and the second element comes from the second set.; Lesson 66 — Cartesian Products
Cartesian products: , which create all possible ordered pairs between two sets.; Lesson 67 — Relations as Sets of Ordered Pairs
Case 1: Leaf node (no children) → Simply remove it; Lesson 513 — BST Deletion: Complete Implementation Lesson 1882 — The Contradiction Emerges
Case 2: One child → Replace node with its child; Lesson 513 — BST Deletion: Complete Implementation Lesson 1882 — The Contradiction Emerges
Case 3: Two children → Replace with inorder successor (or predecessor), then delete that successor; Lesson 513 — BST Deletion: Complete Implementation
Case conversion: changing lowercase letters to uppercase or vice versa; Lesson 265 — Character-Level String Operations
Categorical encoding: Converting categories like "red," "blue," "green" into numerical representations the model can process.; Lesson 2783 — Feature Engineering Basics
Categorical Variables: Convert categories to numbers using one-hot encoding.; Lesson 2836 — Feature Engineering for Logistic Regression
Causal consistency: is weaker than sequential consistency but respects the natural flow of cause and effect.; Lesson 2613 — Causal Consistency Lesson 2617 — Monotonic Write Consistency Lesson 2621 — Consistency vs Availability Tradeoffs Lesson 2624 — Choosing the Right Consistency Model
Causal violations: Can effects appear before their causes?; Lesson 2623 — Measuring and Testing Consistency
Causality tracking: like Lamport timestamps (the logical counter catches ordering violations); Lesson 2636 — Hybrid Logical Clocks
Caveat: Finding the "kth smallest element" becomes trickier—you must account for counts when traversing; Lesson 528 — BST with Duplicate Keys
CDNs: delivering content for many customers through shared infrastructure; Lesson 2449 — Server Name Indication (SNI)
Celebrity users: A social media post from a famous account generates millions of interactions hitting one partition; Lesson 2690 — Handling Data Skew and Hotspots
Cells: contain the destination state when reading that symbol from that state; Lesson 1783 — DFA Transition Tables Lesson 1852 — Turing Machine Tape and Symbols Lesson 1943 — Building a Transition Table
Central Processing Unit (CPU): is like the brain of a computer, but instead of neurons, it contains specialized components that work in harmony to perform calculations and control operations.; Lesson 1071 — CPU Components Overview
Certificate: An assignment like `x=true, y=false, z=true`; Lesson 1893 — Examples of Problems in NP Lesson 1901 — Verifiers and Certificates Lesson 1902 — The Class NP: Nondeterministic Polynomial Time Lesson 1904 — Examples of Problems in NP Lesson 1914 — Verification vs Solution Lesson 1918 — The Clique Problem
Certificate Authorities (CAs): come in.; Lesson 1533 — Certificate Authorities and Trust Chains Lesson 1535 — Public Key Infrastructure (PKI)Lesson 2417 — Key Distribution and Management Lesson 2445 — Digital Certificates and Certificate Authorities
Certificate Authority: is a trusted third-party organization that issues digital certificates.; Lesson 1533 — Certificate Authorities and Trust Chains Lesson 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)
Certificate Revocation Lists (CRLs): Downloadable lists of revoked certificate serial numbers; Lesson 1534 — Certificate Validation Process
Certificate Verification: Your browser verifies the server's certificate is legitimate and issued by a trusted Certificate Authority.; Lesson 1525 — HTTPS Handshake Process Lesson 2443 — The TLS Handshake: Establishing Secure Connections
CFG → PDA: Given any CFG, we can construct a PDA that recognizes the same language; Lesson 1835 — Equivalence of PDAs and Context-Free Grammars
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: is any subset where all elements *are* comparable.; Lesson 75 — Total Orders and Chains Lesson 523 — Worst-Case BST Analysis
Chain of Responsibility: pattern lets you pass a request along a chain of potential handlers until one of them handles it—or the request reaches the end unhandled.; Lesson 2296 — Chain of Responsibility Pattern
Chain of Trust Verification: The browser traces the certificate chain back to a trusted root Certificate Authority (CA) stored in its certificate store, exactly as we learned with the certificate chain of trust.; Lesson 2450 — Certificate Validation and Common Errors
Chain Pattern: Tables link sequentially, each joining to the next.; Lesson 1587 — Multi-Table Join Patterns
chaining: , each slot in the hash table holds a collection (often a linked list) of all elements that hash to that location.; Lesson 418 — Collision Resolution Overview Lesson 430 — Comparing Collision Strategies Lesson 439 — Cache Performance and Memory Locality Lesson 1691 — Collision Handling in Hash Indexes Lesson 1694 — Hash Index Insertion and Deletion Lesson 2143 — Monads and Effect Management
Challenges: Lesson 2686 — Range-Based Partitioning
Challenges include: Lesson 806 — Parallel Sorting Algorithms
CHANCE nodes: – represent random events with probabilistic outcomes; Lesson 2773 — Stochastic Games and Expectiminimax
Change the shared state: to make the condition true; Lesson 1306 — The Wait-Signal Pattern
Changes persist: Modifications to the parameter inside the function *actually modify* the original variable outside the function; Lesson 203 — Pass-by-Reference Semantics
Character frequency: for compression algorithms or cryptanalysis; Lesson 447 — Frequency Counting and Histograms
Character Links (Children): An array or map that points to child nodes, one for each possible next character; Lesson 620 — Trie Node Structure and Components
Character match or `?`: `dp[i][j] = dp[i-1][j-1]` if characters match or pattern has `?; Lesson 942 — Wildcard Pattern Matching
Character replacement: swapping specific characters for others; Lesson 265 — Character-Level String Operations
Characteristics: Lesson 1264 — Push vs Pull Migration Lesson 2038 — High-Level vs Low-Level IR Lesson 2651 — Failure Models: Crash vs Byzantine Lesson 2708 — Point-to-Point vs Publish-Subscribe Models
Characters: (`char`): Single letters or symbols like `'a'`, `'Z'`, `'$'`; Lesson 1986 — Primitive Types
Chattiness hurts: If your system requires 10 sequential network calls to complete one operation, you've multiplied latency by 10.; Lesson 2590 — Network Latency and Bandwidth Constraints
Cheap: to write and maintain; Lesson 2224 — What is Unit Testing?
Cheaper than fully associative: You only search within one set (a few ways) instead of the entire cache; Lesson 1132 — Set-Associative Caches
Check: the variable in the loop's condition; Lesson 177 — Loop Control Variables Lesson 864 — Constraint Satisfaction Problems Lesson 873 — Recursion with Memoization Integration Lesson 1871 — The Acceptance Problem for DFAs
Check balance: Compute the balance factor at each node; Lesson 541 — AVL Deletion Overview
Check Constraints: enforce business rules directly: `age >= 0`, `salary > 0`, `status IN ('active', 'pending', 'closed')`.; Lesson 1659 — Integrity Constraints and Consistency
Check final position: When the string is exhausted, see where you ended up; Lesson 1780 — DFA Computation and Acceptance
Check for imbalance: If `|balance| > 1`, a rotation is needed at this node; Lesson 540 — Updating Heights After Insertion
Check for zero: If present and no negatives exist, return 0; Lesson 898 — Minimum Product Subset
Check if it's imbalanced: (balance factor is -2 or +2); Lesson 539 — AVL Insertion Algorithm
Check if it's null: If `current` is `null`, the list is empty—you're done.; Lesson 327 — Traversing a Linked List
Check the `Origin` header: matches your expected domain; Lesson 2470 — Origin and Referer Header Validation
Check the condition: in a while loop (not if!; Lesson 1306 — The Wait-Signal Pattern Lesson 1307 — Condition Variables with Mutexes
Check the memtable first: most recent writes live here; Lesson 1741 — Read and Write Operations in Column Families
Check the valid bit: Is there actually data in this line?; Lesson 1128 — Direct-Mapped Cache Lookup
Check validity: If the edge leads to an already-visited node, discard it (it would create a cycle).; Lesson 1018 — Prim's Algorithm: Priority Queue Implementation
Check your primary key: Does it have multiple columns?; Lesson 1635 — Partial Dependencies Explained
Checking all state-changing endpoints: (none should be unprotected); Lesson 2473 — Implementing CSRF Protection
Checking before popping: Test if the stack is empty before attempting the operation; Lesson 358 — Pop Operation
Checking mode ( ↓): Expressions that need context (lambda abstractions, conditionals) *check* against an expected type pushed down.; Lesson 2015 — Bidirectional Type Checking
Checking palindromes: – verify if a string reads the same forwards and backwards; Lesson 268 — Common String Algorithms
Checkpoint: Actually perform the file system updates; Lesson 1406 — File System Consistency and Journaling Lesson 1664 — Recovery Mechanisms and Durability
Checks: what the current token is (using lookahead); Lesson 1952 — Implementing Recursive Descent Functions
Checks and threats: (forcing moves constrain opponents); Lesson 2769 — Move Ordering in Alpha-Beta
Checks permissions: (read, write, execute) to enforce memory protection; Lesson 1343 — Memory Management Unit (MMU)
checksum: is a numeric summary computed over all the data bits in a frame.; Lesson 1447 — Error Detection with Parity and Checksums Lesson 1472 — TCP Segment Structure
Chef's hands: (registers): Instantly accessible, but can only hold a few items; Lesson 1108 — Speed vs Capacity Tradeoff
child: is a node directly connected to and below another node.; Lesson 451 — Root, Parent, Child, and Sibling Nodes Lesson 1223 — Process Creation: Parent-Child Relationships
Child pointers: References to subtrees; a node with `n` keys has `n+1` child pointers; Lesson 1677 — B-Tree Structure and Properties
Children: = all states reachable by one legal move; Lesson 2765 — Game Trees and Ply Depth
Choices at Each Step: Lesson 919 — Identifying DP Problems
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 Lesson 1845 — CYK Parsing Algorithm
Choose: Select an option and add it to your current path; Lesson 857 — Backtracking Template Pattern Lesson 858 — Generating All Permutations Lesson 864 — Constraint Satisfaction Problems Lesson 1807 — Using the Pumping Lemma to Prove Non-Regularity
Choose a default action: (shift usually wins over reduce in many tools); Lesson 1971 — Conflict Resolution in LR Parsing
Choose a generator polynomial: A standardized polynomial like CRC-32 acts as the divisor.; Lesson 1448 — Cyclic Redundancy Check (CRC)
Choose a hash table: when you only need exact-match lookups and want predictable, minimal memory usage; Lesson 630 — Tries vs Hash Tables for String Storage
Choose a pivot: Select an element from the array (often the last element, first element, or a random one); Lesson 762 — Quicksort: The Divide-and-Conquer Sorting Strategy
Choose a starting vertex: in the component you want to explore; Lesson 730 — Component Finding with DFS
Choose a trie: when you need prefix queries, autocomplete, or sorted iteration through strings; Lesson 630 — Tries vs Hash Tables for String Storage
Choose an appropriate cost: Aim for 250ms-500ms hashing time on your server.; Lesson 2507 — Password Hashing with bcrypt
Choose availability: Accept operations and resolve conflicts later; Lesson 2589 — Network Partitions and Split-Brain
Choose better partition keys: avoid keys with inherently skewed distributions; Lesson 2690 — Handling Data Skew and Hotspots
Choose consistency: Refuse operations during partitions to prevent conflicts; Lesson 2589 — Network Partitions and Split-Brain
Choose greedily: Lesson 898 — Minimum Product Subset
Choose Kruskal's when: Lesson 1020 — Comparing Kruskal's and Prim's Algorithms
Choose middle (7): as root; Lesson 520 — BST from Sorted Array
Choose predicates: Define functions that describe properties or relationships; Lesson 51 — Translating English to Predicate Logic
Choose Prim's when: Lesson 1020 — Comparing Kruskal's and Prim's Algorithms
Choose your constants: c₁ and c₂; Lesson 294 — Proving Big-Theta Bounds
Choose your threshold: n₀; Lesson 294 — Proving Big-Theta Bounds
Chunks with clear purpose: A 5-10 line block that validates user input or formats data?; Lesson 2319 — Extract Method: Breaking Down Complex Functions
Church-Turing thesis: these different formalisms all define the same boundary between what can and cannot be algorithmically computed.; Lesson 1864 — Equivalence of Computational Models Lesson 1865 — Statement of the Church-Turing Thesis
CI triggers: the automated build and test suite; Lesson 2389 — What is Continuous Deployment?
cipher suite: is a bundle of cryptographic algorithms that work together to establish a secure TLS connection.; Lesson 1536 — TLS Cipher Suites Lesson 2448 — Cipher Suites: Negotiating Encryption Algorithms
Circuit board layouts: Components connected by wires that can't overlap; Lesson 692 — Planar Graphs
Circuit Complexity: Lesson 1070 — Hardware Trade-offs in Number Representation
Circular array logic: using modulo (`%`): when `rear` reaches the end, wrap it back to index 0 if there's space.; Lesson 378 — Array-Based Queue Implementation
circular doubly linked list: , the tail's `next` points to the head *and* the head's `prev` points back to the tail, forming a complete cycle in both directions.; Lesson 349 — Circular Linked List Concept and Structure Lesson 353 — Circular Doubly Linked Lists
circular queue: treats the array as if it wraps around: when you reach the last index, the next position loops back to index 0.; Lesson 379 — Circular Queue Concept Lesson 383 — Queue Operation Complexity Analysis Lesson 387 — Circular Queues
Circular queue logic: (with front and rear pointers wrapping around); Lesson 381 — Dynamic Array-Based Queue
Circular Wait: A circular chain of processes exists, where each process holds a resource needed by the next process in the chain; Lesson 1314 — What is Deadlock?
Circulation with demands: extends flow networks by assigning each node a **demand** value:; Lesson 1054 — Circulation with Demands
City planning: Streets that intersect only at designated crossings; Lesson 692 — Planar Graphs
Claim: Some property P(n) holds for all n ≥ 1; Lesson 86 — The Principle of Mathematical Induction Lesson 827 — Median of Medians: Complexity Proof
Clarifies Requirements: Lesson 2257 — Writing Tests Before Implementation
Clarity: They communicate to other programmers (and your future self) that this value is intentional and shouldn't be modified; Lesson 148 — Constants and Immutability Lesson 204 — Const Parameters and Immutability Lesson 355 — What is an Abstract Data Type (ADT)?Lesson 1554 — Domains and Data Types Lesson 2335 — Primitive Obsession Smell Lesson 2526 — Role-Based Access Control (RBAC)
Clarity over cleverness: means:; Lesson 2316 — Clear Control Flow and Avoiding Clever Code
Class A: (0.; Lesson 1462 — Network Classes and CIDR Notation
Class B: (128.; Lesson 1462 — Network Classes and CIDR Notation
Class C: (192.; Lesson 1462 — Network Classes and CIDR Notation
Class imbalance: Ensure rare classes appear sufficiently in both sets (use stratified sampling); Lesson 2800 — Train-Test Split Ratios
classes: based on their first few bits:; Lesson 1462 — Network Classes and CIDR Notation Lesson 2122 — Classes and Objects
Classic example: The Fibonacci sequence you've seen makes two recursive calls:; Lesson 226 — Multiple Recursive Calls
Classic example: Tree traversal: Lesson 870 — Multiple Recursive Calls
Classification: problems predict **discrete categories** or labels.; Lesson 2781 — Classification vs Regression Problems Lesson 2786 — Supervised Learning: Learning from Labeled Examples Lesson 2787 — Classification vs Regression Tasks Lesson 2839 — Classification vs Regression Trees Lesson 2846 — Choosing the Best Split
Classification outputs: Lesson 2787 — Classification vs Regression Tasks
Classification Trees: predict discrete categories (like "spam/not spam" or "species A/B/C").; Lesson 2839 — Classification vs Regression Trees
Classify: which case it falls into:; Lesson 513 — BST Deletion: Complete Implementation Lesson 1940 — Token Classification
Classify edges: (tree, forward, back, cross edges—which we've already covered); Lesson 715 — DFS Discovery and Finish Times
Classify trees: Binary trees have degree ≤ 2, ternary trees have degree ≤ 3; Lesson 458 — Degree of a Node and Tree Degree
Classless Inter-Domain Routing (CIDR): introduced flexible subnet masks using **slash notation**:; Lesson 1462 — Network Classes and CIDR Notation
Cleaner code: Avoid passing context through every function call; Lesson 1239 — Thread-Local Storage
Cleaner design: IR provides a clean separation of concerns.; Lesson 2037 — What is an Intermediate Representation (IR)?
Cleaner implementation: You can skip the "reopen" logic where nodes get re-added to the priority queue with better paths; Lesson 1004 — Consistent (Monotonic) Heuristics
Cleaner syntax: No dereferencing (`*`) needed; Lesson 321 — Reference Parameters in Functions
Clear boundaries: define what belongs where.; Lesson 2318 — Code Organization and Module Structure
Clear journal: Mark the journal entry as processed; Lesson 1406 — File System Consistency and Journaling
Clear mental model: The code reads like step-by-step instructions; Lesson 2121 — Imperative Style Tradeoffs
Clear module ownership: Assign different features or files to different developers when possible; Lesson 2200 — Handling Merge Conflicts in Teams
Clear ownership: Design your code so only one part is responsible for freeing a particular allocation.; Lesson 2089 — Double-Free Errors
Clear ownership rules: Know exactly which part of your code is responsible for freeing each allocation.; Lesson 2088 — Dangling Pointers and Use-After-Free
Clear patterns or curves: Your model is missing something (maybe non-linear relationships); Lesson 2825 — Evaluating Linear Regression Models
Clearer to understand: at a glance; Lesson 57 — Prenex Normal Form
Client: (usually a web browser) initiates communication by sending an HTTP request; Lesson 1514 — HTTP Overview and Client-Server Model Lesson 1541 — Socket Fundamentals and Client- Server Model Lesson 2534 — OAuth 2.0 Overview and Use Cases Lesson 2535 — OAuth 2.0 Roles: Resource Owner, Client, Authorization Server
Client commands arrive: at the leader; Lesson 2658 — The Replicated State Machine Model
Client Hello: Your browser sends a message listing supported TLS versions and cipher suites (encryption algorithms).; Lesson 1525 — HTTPS Handshake Process Lesson 2448 — Cipher Suites: Negotiating Encryption Algorithms
Client-side enforcement only: Hiding a button in the UI doesn't stop someone from crafting the HTTP request directly; Lesson 2488 — Broken Access Control
Client-side hooks: run on your local machine during operations like committing or merging.; Lesson 2210 — Git Hooks
ClientHello: Lesson 2443 — The TLS Handshake: Establishing Secure Connections
Climbing Stairs: problem, you only need the last two values, not the entire history.; Lesson 956 — Space Optimization with Rolling Arrays
clique: in an undirected graph is a subset of vertices where *every* pair of vertices is connected by an edge.; Lesson 1918 — The Clique Problem Lesson 1935 — Vertex Cover and Clique Reductions
Clique Problem: asks: Given a graph G and a number k, does G contain a clique of size at least k?; Lesson 1918 — The Clique Problem Lesson 1919 — The Independent Set Problem Lesson 1920 — The Vertex Cover Problem
Clock algorithm: treats pages as sitting in a circular list (like hours on a clock).; Lesson 1372 — LRU Approximation Algorithms
clock cycle time: must accommodate the slowest stage.; Lesson 1155 — Balancing Pipeline Stages Lesson 1185 — CPU Performance Equation Fundamentals
Clock skew: Machines tick at slightly different rates (remember our earlier lessons on timing!; Lesson 2596 — Heterogeneity of Hardware and Software Lesson 2626 — Clock Skew and Clock Drift
Clone their fork: They clone *their fork* to their local machine.; Lesson 2198 — Forking Workflow
CLOSE_WAIT: Passive side received FIN but hasn't closed yet; Lesson 1482 — TCP States and State Machine
CLOSED: Connection fully terminated; Lesson 1482 — TCP States and State Machine
CLOSING: Both sides closing simultaneously (rare); Lesson 1482 — TCP States and State Machine
closure: (expanding item sets to include all possible parsing paths) and **goto** (transitioning between states based on grammar symbols).; Lesson 1965 — Building the LR(0) Automaton Lesson 2137 — Closures and Lexical Scope
Closure under intersection: means: if L₁ and L₂ are regular languages, then L₁ ∩ L₂ (the set of strings in *both* languages) is also regular.; Lesson 1805 — Closure Properties: Intersection
Cloud metadata services: `http://169.; Lesson 2485 — Server-Side Request Forgery (SSRF)
Cloud platforms: maximizing resource efficiency; Lesson 2449 — Server Name Indication (SNI)
Cluster 1: High spenders, frequent purchases; Lesson 2789 — Clustering Fundamentals
Cluster 2: Budget shoppers, infrequent visits; Lesson 2789 — Clustering Fundamentals
Cluster 3: Window shoppers, many visits but few purchases; Lesson 2789 — Clustering Fundamentals
Cluster assumptions: Assume decision boundaries should pass through low-density regions, not cluster centers; Lesson 2791 — Semi-Supervised Learning
Clustered Index: The B-Tree structure *determines the actual storage order* of the table rows themselves.; Lesson 1686 — Clustered vs Non-Clustered B-Tree 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 Lesson 1687 — B-Tree Index Performance Characteristics
clustering: happens: occupied slots group together, making future insertions slower because they must probe through longer chains of filled slots.; Lesson 437 — Primary and Secondary Clustering Effects Lesson 1021 — MST Applications and Variations Lesson 2788 — Unsupervised Learning: Finding Patterns Without Labels
Clustering columns: Define the sort order *within* a partition.; Lesson 1744 — Apache Cassandra: Architecture and Use Cases
CMP: (compare) and **TEST** instructions come in.; Lesson 1098 — Comparison and Test Instructions
CMS: is the modern successor to PKCS#7, standardized as RFC 5652.; Lesson 2440 — Digital Signature Standards and Formats
CNAME: (Canonical Name) record creates an alias for another domain name.; Lesson 1505 — DNS Record Types: CNAME and MX
Co-training: Use multiple "views" of data (e.; Lesson 2791 — Semi-Supervised Learning
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
Coarse-grained locks: protect large sections of data or code with a single mutex.; Lesson 1286 — Lock Granularity and Performance
Code Clarity: Memoization typically feels more intuitive because it follows the problem's recursive definition directly.; Lesson 918 — Top-Down vs Bottom-Up Tradeoffs
Code generation: Adapt the tree to target-specific machine instructions; Lesson 1982 — AST Manipulation and Transformation Lesson 2029 — The Translation Pipeline: Source to Machine Code Lesson 2040 — Three-Address Code (TAC)
Code Generation Simplicity: Lesson 2047 — IR Design Tradeoffs
Code Issuance: After the user grants permission, the authorization server redirects back to the client with a short- lived **authorization code** (not a token!; Lesson 2536 — OAuth 2.0 Grant Types: Authorization Code Grant
Code Page 1252: Windows Western European; Lesson 25 — Extended ASCII and Code Pages
Code Page 437: Original IBM PC (American English); Lesson 25 — Extended ASCII and Code Pages
Code Page 850: Western European languages; Lesson 25 — Extended ASCII and Code Pages
Code Page 866: Russian Cyrillic; Lesson 25 — Extended ASCII and Code Pages
Code review: involves examining source code for missing output encoding, especially where user data flows into HTML, JavaScript, or URLs.; Lesson 2463 — Testing and Detecting XSS Vulnerabilities
Code review happens faster: on smaller changesets; Lesson 2199 — Trunk-Based Development
Code segment: (instructions); Lesson 1378 — Segmentation Basics and Motivation
Code sharing: Multiple processes running the same program can share a single read-only code segment (saves memory).; Lesson 1381 — Segmentation with Protection and Sharing
Code signing: Apple, Android, and other platforms use ECDSA for app verification; Lesson 2438 — ECDSA (Elliptic Curve Digital Signature Algorithm)
Code size: Fewer, compact instructions reduce memory footprint; Lesson 2053 — Instruction Selection Lesson 2059 — Optimization Goals and Tradeoffs Lesson 2061 — Constant Folding
Codomain: The entire target set B (what the relation *could* map to); Lesson 67 — Relations as Sets of Ordered Pairs Lesson 76 — Definition and Notation of Functions Lesson 1992 — Function Types
Cognitive load: Developers must remember where all the copies live; Lesson 2332 — Duplicate Code Smell
Cognitive overhead: Developers waste time trying to understand whether old code is still relevant.; Lesson 2307 — Lava Flow Anti-Pattern
Cognitive overload: Developers must hold too much context in their heads to understand what the method does.; Lesson 2330 — Long Method Smell
Coin Change problem: , and it's a classic application of dynamic programming that builds on the unbounded knapsack pattern.; Lesson 928 — Coin Change: Minimum Coins
Collaboration: Distributed systems enable flexible workflows—you can pull from any peer, not just a central authority.; Lesson 2168 — Git vs Other Version Control Systems
Colleague objects: interact through the mediator, not directly with each other; Lesson 2297 — Mediator Pattern
Collecting All Words: Lesson 627 — Trie Traversal Patterns
Collision resistance: prevents digital signature attacks—can't create two contracts with the same signature; Lesson 2421 — Properties of Cryptographic Hash Functions Lesson 2424 — Collision Resistance Lesson 2427 — SHA-2 Family
Collision resistant: It should be extremely difficult to find two different inputs that produce the same hash; Lesson 2420 — What is a Hash Function?
Color the grandparent red: (compensates for adding two black nodes); Lesson 549 — Insertion Case 1: Uncle is Red
Color the parent black: (removes the red-red violation); Lesson 549 — Insertion Case 1: Uncle is Red
Color the uncle black: (maintains balance on that side); Lesson 549 — Insertion Case 1: Uncle is Red
Colors: (every pixel on your screen); Lesson 1 — What is Binary and Why It Matters
column: , fix the second index and iterate through the first:; Lesson 245 — Common 2D Array Operations Lesson 1552 — Tables, Rows, and Columns
Column cardinality: How many distinct values exist in each column; Lesson 1699 — Cost-Based Query Optimization
Column count must match: Both SELECT statements need the same number of columns; Lesson 2477 — Union-Based SQL Injection
column families: rather than traditional rows.; Lesson 1738 — Introduction to Column-Family Databases Lesson 1739 — Column-Family Data Model: Rows and Column Families
Column family: A grouping of related columns (like folders inside that drawer); Lesson 1739 — Column-Family Data Model: Rows and Column Families
Column family stores: Lesson 1715 — Choosing the Right NoSQL Category
Column histograms: Distribution of values (how many rows have each value); Lesson 1700 — Cardinality Estimation
Column qualifier: The actual column name within a family (like documents inside a folder); Lesson 1739 — Column-Family Data Model: Rows and Column Families
Column-family stores: (also called wide-column stores) organize data into rows and columns, but unlike relational tables, columns can vary per row and are grouped into families.; Lesson 1709 — The Four Main NoSQL Categories
columns: .; Lesson 1551 — What is the Relational Model?Lesson 1559 — Relational Algebra Basics Lesson 1738 — Introduction to Column-Family Databases Lesson 1783 — DFA Transition Tables Lesson 1943 — Building a Transition Table Lesson 2683 — Horizontal vs Vertical Partitioning
Combinatorial problems: finding all possible combinations or arrangements; Lesson 226 — Multiple Recursive Calls Lesson 2155 — Constraint Programming Basics
Combine: Merge the subresults using addition, max, subtraction, etc.; Lesson 492 — Calculating Tree Metrics Lesson 644 — Range Query Operations Lesson 753 — The Divide- and-Conquer Strategy Lesson 841 — Divide and Conquer Paradigm Overview Lesson 844 — Binary Search as Divide and Conquer Lesson 853 — Divide and Conquer on Trees Lesson 854 — Fast Fourier Transform (FFT) Overview
Combine both structures: Lesson 449 — Implementing LRU Cache
Combine results: How do solutions to subproblems build the final answer?; Lesson 866 — Problem Decomposition in Recursion
Combine the groups: Lesson 8 — Converting Between Binary and Hexadecimal
Combined: O(V²), since the V² dominates even when we add O(E).; Lesson 1019 — Prim's Algorithm: Time Complexity Analysis
command: that changes the **program state**—the current values of variables, memory, and other runtime data.; Lesson 2113 — Command-Based Execution Model Lesson 2296 — Chain of Responsibility Pattern Lesson 2303 — Spaghetti Code Anti-Pattern
Command side: Validates and appends events to the log; Lesson 2725 — Alternatives: Event Sourcing and CQRS
Command-Line Interface (Shell): A text-based interpreter where you type commands.; Lesson 1202 — System Utilities and User Interface
comments: placed directly above or inside the function.; Lesson 192 — Function Documentation Lesson 1093 — Assembly Language Syntax and Structure
Comments explaining sections: If you wrote `// calculate discount` above a code block, that block probably wants to be `calculateDiscount()`.; Lesson 2319 — Extract Method: Breaking Down Complex Functions
COMMIT: is the command that tells the database: "I'm done with this transaction, and everything worked correctly.; Lesson 1656 — Commit and Rollback Operations Lesson 1673 — Snapshot Isolation Lesson 2188 — Resolving Merge Conflicts
Commit and push: Changes go to the contributor's fork, not the original repository.; Lesson 2198 — Forking Workflow
Commit directly to trunk: (or use extremely short-lived branches lasting hours, not days); Lesson 2199 — Trunk-Based Development
Commit hash: A long hexadecimal string (like `a3f8b21c4d.; Lesson 2175 — Viewing Commit History
Commit message: The description you wrote explaining what changed.; Lesson 2175 — Viewing Commit History
Commitment: Implements "if-then-else" logic—once a condition matches, commit to that path.; Lesson 2163 — The Cut Operator (!)
Commitment rules: An entry becomes committed only when stored on a majority of servers in the current term; Lesson 2670 — Raft Safety Proof: State Machine Safety Property
committed: by other transactions.; Lesson 1668 — Read Committed Isolation Level Lesson 2172 — Tracking Files with 'git add'Lesson 2665 — Log Replication: AppendEntries Basics Lesson 2668 — Commitment Rules and Safety
Common convention: Lesson 2767 — Terminal States and Utility Functions
Common forwarding paths: Lesson 1170 — Forwarding Paths and Limitations
Common mistake: Forgetting to verify the base case at all, or checking only `n = 1` when your claim actually starts at `n = 0` or `n = 3`.; Lesson 95 — Common Induction Mistakes Lesson 1774 — Precedence and Parentheses in Regular Expressions
Common patterns: Lesson 1208 — System Call Parameters and Return Values Lesson 2511 — Password Strength and Entropy
Common protocols: Lesson 1470 — Static vs Dynamic Routing Protocols
Common sharing scenarios: Lesson 1381 — Segmentation with Protection and Sharing
Common sources: Lesson 1211 — Interrupt Types and Sources Lesson 2457 — DOM-Based XSS Attacks
Common Subexpression Elimination (CSE): is an optimization that identifies expressions computed more than once with the same operand values, then replaces subsequent computations with a reference to the first result.; Lesson 2064 — Common Subexpression Elimination
Common syntax patterns: Lesson 198 — Variable Number of Arguments
Common trade-off scenarios: Lesson 1645 — Normal Form Trade-offs
Common Use Case: Preserving register values before using them for other operations, then restoring them afterward:; Lesson 1102 — The Stack: PUSH and POP Operations
Communicating early: Let teammates know which files you're working on; Lesson 2200 — Handling Merge Conflicts in Teams
Communication: Lesson 1206 — System Call Categories Lesson 1431 — Introduction to Computer Networks
Commutative: `L₁ ∪ L₂ = L₂ ∪ L₁` — order doesn't matter; Lesson 1769 — Union and Concatenation Properties Lesson 2703 — Conflict-Free Replicated Data Types (CRDTs)
Commutativity of union: `r|s = s|r`; Lesson 1776 — Regular Expression Equivalence
Compact representation: One bit per block means minimal storage overhead; Lesson 1403 — Free Space Management: Bitmaps
compaction: (rearranging files to consolidate free space) are expensive and cause downtime.; Lesson 1399 — File Allocation Methods: Contiguous Lesson 1740 — Physical Storage: SSTables and Log- Structured Merge Trees
Compactness: Lesson 2047 — IR Design Tradeoffs Lesson 2731 — State Representation Strategies
Compare: your search value with the current node; Lesson 503 — BST Search: Finding a Node Lesson 587 — Implementing Heap Insert Lesson 1679 — B-Tree Search Operation
Compare and copy: Look at the current element in each subarray, copy the smaller one to the output, and advance that subarray's pointer; Lesson 754 — The Merge Operation
Compare state: Exchange summaries (hashes, Merkle trees, version vectors); Lesson 2704 — Anti-Entropy and Gossip Protocols
Compare tags: If the line is valid, compare the tag stored in that cache line with the tag from the requested address; Lesson 1128 — Direct-Mapped Cache Lookup
Compare the characters: at the current position; Lesson 267 — String Comparison: Character-by-Character
Compare your target: with each key in the current node from left to right; Lesson 559 — B-Tree Search Operation
compare-and-swap: , or **fetch-and-add**.; Lesson 1295 — Semaphore Implementation and Atomicity Lesson 2557 — Atomic Operations
Comparing algorithms: Suppose Algorithm A is O(n²) and Algorithm B is O(n²).; Lesson 301 — Practical Applications of Tight Bounds
Comparing rows: Finding pairs of products in the same price range; Lesson 1583 — Self Join
Comparison: Quickly check if two values are different; Lesson 35 — Exclusive OR (XOR)
Comparison instructions: (CMP) to test a condition; Lesson 1101 — Implementing Loops in Assembly
Comparison operations: `if (x > y)` evaluates in constant time; Lesson 283 — O(1): Constant Time
comparison operators: like `>` and `==` give you boolean results (`true` or `false`).; Lesson 158 — Logical Operators Lesson 165 — What Are Conditionals?Lesson 1564 — WHERE Clause and Filtering
Comparisons: `i < n`, `x == y`; Lesson 271 — Counting Primitive Operations Lesson 2021 — Semantics of Boolean Expressions
Compilation Time: Lesson 2059 — Optimization Goals and Tradeoffs
Compile to bytecode: Source code is translated into an intermediate representation called *bytecode*—a low-level, platform-independent instruction set that's easier to execute than source code but not yet native machine code.; Lesson 2033 — Bytecode Compilation: The Hybrid Approach
Compile-time checking: A statically typed language like Java or C++ analyzes your code before execution and rejects programs that misuse types (e.; Lesson 1985 — What is a Type System?
Compiled executables: Lesson 2034 — Memory Requirements and Resource Usage
compiler: reads your entire source program and translates it into machine code (or another lower-level representation) *before* execution begins.; Lesson 2027 — Compilation and Interpretation: Two Execution Models Lesson 2032 — Error Detection: Compile-Time vs Runtime
Compiler correctness: How do we prove a compiler translates code correctly?; Lesson 2017 — Introduction to Operational Semantics
Compiler verification: – The compiler checks that you never accidentally put a string where an integer belongs; Lesson 2000 — Type Annotations in Static Languages
complement: of a set A, written as `A'` or `A ᶜ`, contains everything that is *not* in A, but within some universal set U.; Lesson 63 — Set Difference and Complement Lesson 448 — Two-Sum and Complement Problems Lesson 1763 — Language Complement and Intersection Lesson 1804 — Closure Properties: Star and Complement Lesson 1848 — Closure Properties of CFLs
Complement (A'): Shade everything in the rectangle *except* A's circle; Lesson 64 — Venn Diagrams
Complement Rule: lets you flip between these two perspectives.; Lesson 112 — Complement Rule
complements: as you go.; Lesson 448 — Two-Sum and Complement Problems Lesson 1935 — Vertex Cover and Clique Reductions
Complete: Focuses on filling levels top-to-bottom, left-to-right; Lesson 459 — Full, Complete, and Perfect Binary Trees Lesson 464 — Advantages of Array-Based Representation Lesson 486 — Perfect Binary Trees Lesson 585 — Heap Structure Invariants Lesson 1785 — Complementing DFAs Lesson 1886 — Practical Approximations Lesson 2740 — Breadth-First Search (BFS)Lesson 2746 — Uniform-Cost Search
complete binary tree: directly in an array.; Lesson 461 — Array-Based Complete Binary Trees Lesson 485 — Complete Binary Trees Lesson 576 — Complete Binary Tree Property Lesson 582 — Heap Shape vs Heap Order Lesson 592 — Extract Time Complexity Lesson 642 — Segment Tree Structure and Representation
complete binary trees: where the array has no gaps, which is why complete trees are ideal for array representation.; Lesson 462 — Array Index Formulas Lesson 579 — Array Representation of Binary Heaps
complete graph: is one where *every* vertex connects directly to *every other* vertex.; Lesson 666 — Complete, Bipartite, and Regular Graphs Lesson 688 — Complete Graphs
Complete like BFS: If a solution exists at finite depth, IDDFS will find it; Lesson 2745 — Iterative Deepening DFS
Complete signatures: `function map(f: int -> int, list: [int]) -> [int]`; Lesson 1995 — Type Annotations and Signatures
Completeness: is mandatory (all data must arrive); Lesson 1499 — When to Use TCP: Application Scenarios Lesson 2744 — Depth-Limited Search Lesson 2748 — Comparing Uninformed Strategies
Completion: When the dot reaches the end of a rule, update all items waiting for that nonterminal; Lesson 1846 — Earley Parsing Algorithm
Complex boolean logic: `if (user.; Lesson 2322 — Extract Variable: Explaining Complex Expressions
Complex Conditionals: Nested if-statements that are hard to follow; Lesson 2329 — Introduction to Code Smells
Complex predicates: Functions or expressions on indexed columns (e.; Lesson 1702 — Index Selection for Queries
Complex queries: What was a simple `SELECT * FROM Orders` becomes a multi-table join puzzle; Lesson 1645 — Normal Form Trade-offs
Complex relationships: between entities; Lesson 1717 — NoSQL vs SQL: Complementary Approaches
Complex stateful logic: Managing game state, handling network protocols, or coordinating system resources often requires explicit sequencing.; Lesson 2156 — Benefits and Trade-offs of Declarative Style
Complexity: O(E × max_flow) – depends on flow value, not just graph size; Lesson 1045 — Maximum Flow Algorithm Comparison Lesson 1195 — Monolithic Kernel Architecture Lesson 2248 — Test Scenarios and User Journeys Lesson 2696 — Trade-offs in Partitioning Strategies Lesson 2735 — State Space Size and Complexity
Component 1: Alice ↔ Bob ↔ Carol; Lesson 664 — Connected Graphs and Components
Component 2: Dave ↔ Eve; Lesson 664 — Connected Graphs and Components
Component 3: Frank (alone, still a component of one vertex); Lesson 664 — Connected Graphs and Components
Component interface: defines operations both base objects and decorators implement; Lesson 2277 — Decorator Pattern: Adding Responsibilities Dynamically
Composability: You can combine multiple pattern databases (e.; Lesson 2758 — Pattern Database Heuristics
Composes naturally: chain `filter().; Lesson 2151 — Declarative Data Transformation
Composite: nodes represent containers that hold leaves *or* other composites (like a folder); Lesson 2276 — Composite Pattern: Tree Structures of Objects Lesson 2283 — Structural Pattern Trade-offs Lesson 2284 — Combining Structural Patterns
composite keys: keys built from multiple components.; Lesson 413 — Hashing Composite Keys Lesson 1634 — Second Normal Form (2NF) Definition
Composite Pattern: (tree structures) and often uses **Visitor** to add operations without modifying expression classes.; Lesson 2300 — Interpreter Pattern
Composition: Chain functions together (output of one becomes input of another); Lesson 1863 — Alternative Models: Recursive Functions Lesson 2129 — Composition vs Inheritance Lesson 2142 — Functors and Mappable Types
Compound: Queries using multiple fields together, or range queries on the second field after equality on the first; Lesson 1723 — Indexing Document Fields
Compound Assignment: `x += 3` both computes and updates `x`; Lesson 164 — Expression Evaluation and Side Effects
Compression: (reducing data size for efficient transfer); Lesson 1437 — OSI Upper Layers: Session, Presentation, Application
Compromised email accounts: If your email is hacked, attackers bypass MFA entirely; Lesson 2521 — SMS and Email-Based MFA
Computation has inherent limits: Some problems are *fundamentally* unsolvable, not just "hard"; Lesson 1887 — Philosophical and Practical Impact
Computational budget: Larger training sets take longer to train; Lesson 2800 — Train-Test Split Ratios
Computational difficulty: Use slow hashing algorithms that resist brute-force attacks; Lesson 2504 — Password Storage Fundamentals
Computational efficiency: Fewer features mean faster training for other algorithms; Lesson 2790 — Dimensionality Reduction Concepts
Computational geometry: problems; Lesson 641 — Segment Tree Motivation and Use Cases
Compute: recursively if not cached; Lesson 873 — Recursion with Memoization Integration
Compute closure: by adding items for all non-terminals after the dot, calculating their specific lookahead using FIRST sets; Lesson 1969 — Canonical LR(1) Parsing
Compute goto: transitions by advancing the dot and taking closure again; Lesson 1969 — Canonical LR(1) Parsing
Compute the closure: – For each combination, calculate its closure using the given FDs (as you learned with closure of attribute sets).; Lesson 1630 — Using FDs to Identify Candidate Keys
Compute the difference: Subtract the weighted average from the parent entropy; Lesson 2843 — Information Gain
Compute topological order: of the DAG; Lesson 950 — DP on DAGs: Longest Path
Computed values: used repeatedly (total order amounts, aggregated scores); Lesson 1653 — Hybrid Normalization Strategies
Concatenate: Merge all buckets back together in order; Lesson 795 — Bucket Sort: Partitioning the Range Lesson 796 — Bucket Sort: Implementation
concatenation: is written as:; Lesson 1758 — String Operations: Concatenation Lesson 1761 — Language Operations: Union and Concatenation Lesson 1764 — The Empty Language vs Empty String Lesson 1774 — Precedence and Parentheses in Regular Expressions Lesson 1803 — Closure Properties: Union and Concatenation Lesson 1812 — Regular Language Identities and Algebraic Laws Lesson 1826 — CFG Closure Properties Lesson 1848 — Closure Properties of CFLs
Concatenation `ab`: Chain the NFA for `a` to the NFA for `b`; Lesson 1942 — From Regular Expressions to Finite Automata
Conclude: If you're never behind at any step, you must reach an optimal solution; Lesson 884 — Greedy Stays Ahead Proofs Lesson 906 — Proof by Exchange Argument Lesson 1807 — Using the Pumping Lemma to Prove Non-Regularity Lesson 1885 — Reductions from the Halting Problem
conclusion: (or consequent).; Lesson 36 — Conditional Statements (Implication)Lesson 294 — Proving Big-Theta Bounds Lesson 907 — Proving Activity Selection Correctness
Concrete component: the original object being decorated; Lesson 2277 — Decorator Pattern: Adding Responsibilities Dynamically
Concrete Creators: implement the method, returning specific product types; Lesson 2267 — Factory Method Pattern Basics
Concrete decorators: extend the base decorator, adding behavior before/after forwarding; Lesson 2277 — Decorator Pattern: Adding Responsibilities Dynamically
Concrete Mediator: implements coordination logic; Lesson 2297 — Mediator Pattern
Concrete Observers: Implement the update interface, maintain reference to subject (if needed); Lesson 2289 — Observer Pattern Fundamentals
Concrete Products: actual implementations; Lesson 2267 — Factory Method Pattern Basics
Concrete States: Classes implementing different behaviors (IdleState, HasMoneyState, OutOfStockState); Lesson 2295 — State Pattern
Concrete Subject: Stores state, sends notifications when state changes; Lesson 2289 — Observer Pattern Fundamentals
Concurrency: means dealing with multiple tasks that can make progress without necessarily executing at the exact same instant.; Lesson 2544 — Concurrency Defined: Multiple Tasks in Progress Lesson 2545 — Parallelism Defined: Simultaneous Execution Lesson 2546 — The Key Distinction: Dealing vs Doing Lesson 2547 — Single-Core Concurrency Through Time-Slicing Lesson 2553 — Choosing Between Concurrency and Parallelism
Concurrency is treacherous: Multiple threads modifying shared state lead to race conditions; Lesson 2121 — Imperative Style Tradeoffs
concurrent: and **parallel** garbage collection aim to reduce the dreaded stop-the-world pauses you learned about earlier, but they use different strategies:; Lesson 2101 — Concurrent and Parallel GC Lesson 2627 — Happens-Before Relation Lesson 2632 — Vector Clock Operations Lesson 2702 — Vector Clocks for Causality Tracking
Concurrent (A || B): Neither vector is less than or equal to the other.; Lesson 2633 — Detecting Causality with Vector Clocks
Concurrent access: Multiple users can work simultaneously without corrupting each other's data; Lesson 1654 — Introduction to Database Transactions
concurrent conflicts: that need resolution; Lesson 1735 — Vector Clocks and Conflict Resolution Lesson 2702 — Vector Clocks for Causality Tracking
Concurrent GC: runs *alongside* your application threads.; Lesson 2101 — Concurrent and Parallel GC
Concurrent operations: don't corrupt data; Lesson 2243 — Database Integration Testing Lesson 2613 — Causal Consistency
Concurrent writes: happen to different replicas before they've synchronized; Lesson 2700 — Conflict Detection in Eventual Consistency
Condition: Keep looping while this is true (e.; Lesson 179 — The For Loop Lesson 180 — Loop Initialization, Condition, and Update
Condition Variable: Waiting for complex conditions; avoiding busy-waiting; coordinating state changes; Lesson 1303 — Semaphores vs Mutexes vs Condition Variables Lesson 1304 — Condition Variable Basics
Condition variables: Allow threads to wait for specific conditions; Lesson 1241 — Threading Challenges: Synchronization Needs Lesson 1303 — Semaphores vs Mutexes vs Condition Variables Lesson 1311 — Reader-Writer Problem with CVs
Conditional jumps: (JE, JNE, JL, etc.; Lesson 1101 — Implementing Loops in Assembly
Conditional jumps combine both: they check the CPU's flag registers (like zero, carry, sign, or overflow flags) and jump *only if* a specific condition is true.; Lesson 1100 — Conditional Jumps and Branches
Conditional logic: "If the top is an operator, do one thing; if it's a number, do another.; Lesson 359 — Peek (or Top) Operation
conditional probability: the likelihood of event A when event B has already happened.; Lesson 114 — Conditional Probability Lesson 119 — Probability in Algorithm Analysis
Conditionals: (`if-else`) become:; Lesson 2055 — Control Flow Code Generation
Confidence to Refactor: Remember lesson 2261?; Lesson 2263 — TDD Benefits and Common Pitfalls
Confidential: Lesson 2530 — Mandatory Access Control (MAC)
Confidentiality: No one can read the data in transit; Lesson 1524 — Introduction to HTTPS
configuration: or **instantaneous description (ID)**.; Lesson 1829 — PDA Configurations and Instantaneous Descriptions Lesson 1854 — Turing Machine Configuration
Configuration changes: What's the current cluster membership?; Lesson 2647 — The Consensus Problem Definition
Configuration values: like timeouts, limits, or thresholds; Lesson 2323 — Replace Magic Numbers with Named Constants
Conflict detected: Two replicas have different values for key `user:123:email`; Lesson 2701 — Last-Write-Wins (LWW) Conflict Resolution
Conflict detection: The tool warns about shift-reduce or reduce-reduce conflicts; Lesson 1973 — Parser Generators and YACC/Bison
conflict miss: even if the rest of the cache is empty.; Lesson 1129 — Conflict Misses in Direct Mapping Lesson 1144 — Types of Cache Misses: Conflict
conflict misses: even when other cache lines sit empty.; Lesson 1126 — Direct-Mapped Caches Lesson 1130 — Fully Associative Caches
Congestion Avoidance: comes in.; Lesson 1479 — TCP Congestion Control: Congestion Avoidance
Connect contradictory literals: Add edges between vertices representing a variable and its negation across different triangles.; Lesson 1934 — 3-SAT to Independent Set Reduction
Connect with logical operators: AND ( ∧), OR (∨), implication (→ ); Lesson 51 — Translating English to Predicate Logic
connected: if you can reach any vertex from any other vertex by following edges.; Lesson 664 — Connected Graphs and Components Lesson 691 — Trees as Special Graphs
connected component: is a maximal subgraph where every vertex can reach every other vertex through some path.; Lesson 729 — Connected Components in Undirected Graphs Lesson 731 — Component Finding with BFS Lesson 732 — Counting Connected Components
Connection refused: The server isn't listening on that port; Lesson 1550 — Error Handling and Socket Shutdown
Connection to DFAs: Each equivalence class corresponds to a state in the minimal DFA!; Lesson 1808 — Myhill-Nerode Theorem: Equivalence Classes
Connection-Oriented Communication: Lesson 1471 — TCP Overview and Key Features
Connectivity: Harder to define in directed graphs (requires "strong" vs "weak" connectivity concepts); Lesson 684 — Directed vs Undirected Graphs
Conquer: Recursively sort each half (keep splitting until you have single elements); Lesson 752 — Introduction to Mergesort Lesson 753 — The Divide-and-Conquer Strategy Lesson 841 — Divide and Conquer Paradigm Overview Lesson 844 — Binary Search as Divide and Conquer Lesson 848 — Closest Pair of Points
Cons: Lesson 1398 — Directory Implementation Strategies Lesson 1470 — Static vs Dynamic Routing Protocols Lesson 1538 — Certificate Revocation: CRL and OCSP Lesson 1651 — Using Triggers and Application Logic Lesson 2581 — Concurrent Stack Implementations Lesson 2646 — Replication Topologies Lesson 2695 — Routing Requests to Shards Lesson 2721 — Saga Pattern for Long-Running Transactions
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
Consequences: Lesson 1454 — Network Switches vs Hubs
Conserve public IPs: A company with 500 devices might only need one or two public addresses; Lesson 1465 — Private and Public IP Address Ranges
Consider: all possible ways to split s = xyz (where |xy| ≤ p and |y| > 0); Lesson 1807 — Using the Pumping Lemma to Prove Non-Regularity Lesson 2674 — Proposal Numbers and Ordering
Consider alternatives when: Lesson 2509 — PBKDF2 and Key Derivation
Consider approximate nearest neighbors: algorithms for large datasets; Lesson 2872 — KNN in Practice: Applications and Limitations
Consider multiple factors: Material, position, mobility, king safety, etc.; Lesson 2770 — Evaluation Functions for Non-Terminal States
Considerations: Lesson 2522 — Push Notification-Based MFA
Consistency: Ensures data moves from one valid state to another without violating rules (like your total balance remaining constant); Lesson 1654 — Introduction to Database Transactions Lesson 1658 — Consistency: Maintaining Database Invariants Lesson 1659 — Integrity Constraints and Consistency Lesson 1667 — Dirty Reads Problem Lesson 1714 — CAP Theorem Trade-offs Across Categories Lesson 1734 — Eventual Consistency Trade-offs Lesson 2229 — Test Fixtures and Setup Lesson 2529 — Policy-Based Access Control (+9 more)
consistent: (or **monotonic**) heuristic goes beyond being merely admissible—it satisfies a triangle inequality-like property.; Lesson 1004 — Consistent (Monotonic) Heuristics Lesson 2637 — Introduction to Replication Lesson 2750 — Heuristic Functions: Definition and Properties Lesson 2752 — A* Search Algorithm Lesson 2754 — Consistency and Monotonicity
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: means combining multiple conditional checks into a single boolean expression or extracting them into a well-named method.; Lesson 2324 — Consolidate Conditional Expressions
Consolidate Similar Logic: Lesson 2327 — Remove Duplicate Code: DRY Principle in Practice
constant: is a variable whose value is set once and can never be changed afterward.; Lesson 148 — Constants and Immutability Lesson 278 — Growth Rates and Dominant Terms
constant folding: , **dead code elimination**, and better **instruction selection**.; Lesson 2068 — Loop Unrolling Lesson 2069 — Inlining Functions
Constant propagation: takes what constant folding discovered—that certain variables hold constant values—and spreads that knowledge throughout your code.; Lesson 2062 — Constant Propagation Lesson 2066 — Loop-Invariant Code Motion
constant time: operations.; Lesson 283 — O(1): Constant Time Lesson 383 — Queue Operation Complexity Analysis
Constants: A number evaluates to itself immediately.; Lesson 2020 — Operational Semantics of Arithmetic Expressions
Constraint generation: As it analyzes your code, it builds equations based on how values are used.; Lesson 2009 — Hindley-Milner Type System
Constraint Satisfaction Problem (CSP): is a problem where you must assign values to variables while satisfying a set of constraints—rules that limit which combinations are valid.; Lesson 864 — Constraint Satisfaction Problems
Constraints: Primary keys, foreign keys, unique constraints, NOT NULL requirements; Lesson 1658 — Consistency: Maintaining Database Invariants Lesson 2155 — Constraint Programming Basics
Constructive view (max-flow): How much can we send?; Lesson 1031 — The Max-Flow Min-Cut Theorem
Consul: explicitly choose CP behavior because they coordinate critical cluster state—consistency matters more than temporary unavailability.; Lesson 2605 — CP Systems: Consistency and Partition Tolerance
Consults internal structures: (like page tables, which we'll cover later) to find the corresponding physical address; Lesson 1343 — Memory Management Unit (MMU)
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
Consumers: remove data from that buffer and process it; Lesson 1298 — Producer-Consumer Problem with Semaphores
Consumes: tokens when they match (advances the input pointer); Lesson 1952 — Implementing Recursive Descent Functions
Contact that specific shard: to perform the operation; Lesson 2689 — Directory-Based Partitioning
Containerization: Tools like Docker help create consistent, reproducible environments that any team member can spin up instantly, eliminating "works on my machine" problems.; Lesson 2250 — Setting Up the Test Environment
Contention: measures how often threads compete for the same resource.; Lesson 2587 — Performance Trade-offs and Selection
context: .; Lesson 1210 — Interrupt Handling Process Lesson 1996 — Type Errors and Error Messages Lesson 2295 — State Pattern
Context matters: Sanitize differently for HTML content, HTML attributes, JavaScript strings, and URLs.; Lesson 2459 — Input Validation and Sanitization
context switch: .; Lesson 1229 — Context Switching Between Processes Lesson 2547 — Single-Core Concurrency Through Time-Slicing
Context-dependent structures: like matching variable declarations to usage; Lesson 1777 — Limitations of Regular Expressions
Contiguous Memory: The characters sit right next to each other in memory, making it efficient to read through them sequentially (like iterating through an array).; Lesson 260 — Strings as Arrays of Characters
Continue: until the heap is empty (all lists exhausted).; Lesson 616 — Merging K Sorted Lists Lesson 722 — Kahn's Algorithm: Basic Idea
Continue similar matching: Lesson 1858 — Computing with a Turing Machine
Continue to the end: of the array—the largest element is now in its final position; Lesson 741 — Bubble Sort: Algorithm
Continue upward: Keep checking and rotating until you reach the root; Lesson 541 — AVL Deletion Overview Lesson 645 — Point Update Operations
continuous: if it can take on any value within an interval.; Lesson 120 — Random Variables: Definition and Types Lesson 128 — Uniform Distribution
Continuous adaptation: The team adjusts their process based on what they learn; Lesson 2367 — Self-Organizing Teams
Continuous Delivery: (CD) and **Continuous Deployment** share the same foundation: automated building and testing from Continuous Integration.; Lesson 2390 — Continuous Delivery vs Deployment
Continuous Delivery of Value: flips this: deliver small, functional increments regularly—every two weeks, monthly, or at most every few months.; Lesson 2369 — Continuous Delivery of Value
Continuous Deployment: share the same foundation: automated building and testing from Continuous Integration.; Lesson 2390 — Continuous Delivery vs Deployment
Continuous Deployment (CD): is the practice of automatically releasing every code change that passes all automated tests directly to production—no human gatekeeper required.; Lesson 2389 — What is Continuous Deployment?
Contract Testing: Lesson 2244 — Testing External Dependencies
contradiction: is a proposition that is *always false*, no matter what.; Lesson 43 — Tautologies and Contradictions Lesson 1807 — Using the Pumping Lemma to Prove Non- Regularity Lesson 1885 — Reductions from the Halting Problem Lesson 2753 — A* Optimality and Admissibility
Contradiction example: `p AND NOT p`; Lesson 43 — Tautologies and Contradictions
Contradictions: help identify impossible conditions or logical errors in arguments; Lesson 43 — Tautologies and Contradictions
Contrapositive: Swap *and* negate both parts: **¬q → ¬p** ("if not q, then not p"); Lesson 37 — Converse, Inverse, and Contrapositive
Control: Unbuffered system calls give you precise timing, but at a performance cost; Lesson 1395 — Standard I/O and Buffering Lesson 2163 — The Cut Operator (!)
Control flow constructs: (conditionals, loops) that direct execution order; Lesson 2112 — What is Imperative Programming?
Control Flow Graph (CFG): is a graphical representation of all possible execution paths through a program.; Lesson 2042 — Control Flow Graphs (CFGs)
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
control unit: acts as the conductor of an orchestra.; Lesson 1071 — CPU Components Overview Lesson 1075 — Instruction Register (IR)
Control Unit (CU): is its conductor—coordinating all the other components to work in harmony.; Lesson 1073 — The Control Unit
Convenience: Use simple pointer operations instead of system calls; Lesson 1394 — Memory-Mapped Files Lesson 2519 — Inherence Factors (Something You Are)Lesson 2521 — SMS and Email-Based MFA
convergence: all replicas eventually reach the same state — by ensuring operations are:; Lesson 2703 — Conflict-Free Replicated Data Types (CRDTs)Lesson 2821 — Learning Rate and Convergence
Convergence happens over time: as updates spread through the system; Lesson 2614 — Eventual Consistency Overview
Conversation Threads: Each inline comment becomes a discussion thread that can be marked "resolved" once addressed, providing clear tracking of outstanding issues versus completed feedback.; Lesson 2350 — Code Review Tools and Workflow
Converse: Swap the hypothesis and conclusion: **q → p** ("if q, then p"); Lesson 37 — Converse, Inverse, and Contrapositive
Convert between NAND/NOR gates: and other logic gates; Lesson 41 — De Morgan's Laws
Convert each group: to its hex digit (0-9, A-F); Lesson 8 — Converting Between Binary and Hexadecimal
Convoying: Threads pile up waiting for a slow lock holder; Lesson 2566 — Introduction to Lock-Free Programming
Cookie theft: Lesson 2458 — XSS Attack Vectors and Payloads
Cookie values: When cookies are read and displayed client-side; Lesson 2458 — XSS Attack Vectors and Payloads
Cookie-based authentication: If your "REST" API still uses session cookies for authentication (not truly stateless), CSRF attacks work exactly as with traditional web apps.; Lesson 2471 — CSRF in REST APIs
Cookies: are small pieces of data that the server sends to your browser in an HTTP response header.; Lesson 1522 — HTTP Cookies and State Management Lesson 2497 — Session Management Basics
Coordinate transformation: Rotate or shift your perspective (e.; Lesson 955 — State Space Reduction
Coordinating actions: Agreeing when to start a distributed transaction; Lesson 2598 — Lack of Global Clock
Coordination overhead: Multiple developers touching many files for one feature; Lesson 2337 — Shotgun Surgery Smell Lesson 2692 — Cross-Shard Queries and Joins
coordinator: and multiple **participants**:; Lesson 2653 — Two-Phase Commit Protocol Lesson 2718 — Two-Phase Commit (2PC) Protocol
Copies: the memory contents of each process to new locations; Lesson 1337 — Memory Compaction
Copper: balances cost and performance for short distances.; Lesson 1442 — Transmission Media Types
Copy: the entire tree structure; Lesson 468 — What is Tree Traversal?
Copy all live objects: from the from-space to the to-space; Lesson 2097 — Copying Collection
Copy the value: Replace the target node's value with the successor/predecessor's value; Lesson 510 — BST Deletion: Two Children Case
Copy-on-Write (CoW): file system never overwrites existing data blocks.; Lesson 1408 — Copy-on-Write File Systems
Copy-paste programming: that duplicates logic everywhere; Lesson 2303 — Spaghetti Code Anti-Pattern
Copying arrays: is the classic example.; Lesson 306 — Linear Space: O(n)
Core principles: Lesson 2504 — Password Storage Fundamentals
CoreMark: Embedded systems performance; Lesson 1191 — Benchmark Programs and Performance Testing
correct: under all valid usage.; Lesson 386 — Queue Invariants and Correctness Lesson 1175 — Introduction to Branch Prediction Lesson 1184 — Branch Prediction Performance Impact
Correct interpretation: the character `a` followed by zero or more `b`s (matches: `a`, `ab`, `abb`, etc.; Lesson 1774 — Precedence and Parentheses in Regular Expressions
Corrected to 1NF: Lesson 1632 — First Normal Form (1NF) Definition
Correctness: means your program produces the right answer.; Lesson 270 — What is Runtime Analysis?Lesson 1280 — Mutual Exclusion Problem Lesson 1973 — Parser Generators and YACC/Bison Lesson 2343 — The Review Checklist Approach Lesson 2610 — What is Consistency in Distributed Systems?
Correlate with winning probability: Higher scores should mean better positions; Lesson 2770 — Evaluation Functions for Non-Terminal States
Correlated subqueries: can be performance killers.; Lesson 1609 — Subquery Performance Considerations
Cost: Networks where weights represent monetary expense; Lesson 659 — Weighted vs Unweighted Graphs Lesson 685 — Weighted and Unweighted Graphs Lesson 1052 — Project Selection Problem Lesson 1107 — Storage Pyramid Levels Lesson 1164 — Resolving Structural Hazards Lesson 1701 — Join Order Selection Lesson 2682 — Introduction to Data Partitioning Lesson 2730 — Path Cost and Optimality (+1 more)
Cost Estimates: Numbers like `cost=0.; Lesson 1705 — Reading and Analyzing EXPLAIN Output
Cost per bit: Fast memory (like CPU registers or cache) uses expensive materials and complex circuitry; Lesson 1108 — Speed vs Capacity Tradeoff
Cost-Complexity Pruning: (also called "weakest link pruning") uses a complexity parameter **α (alpha)** to balance two competing goals:; Lesson 2851 — Cost-Complexity Pruning
Cost-effective: Free to implement and use; Lesson 2517 — Knowledge Factors (Something You Know)
Costs: Each agent → task edge has cost equal to the assignment cost; all other edges have cost 0; Lesson 1049 — Assignment Problem Lesson 1998 — Type Checking at Compile Time Lesson 2584 — Concurrent Lists: Hand-Over-Hand Locking Lesson 2734 — Search Problem Formulation
Count: Most space-efficient for high-duplicate datasets (word frequency counters); Lesson 499 — Handling Duplicate Keys Lesson 647 — Segment Tree Variants and Functions Lesson 2715 — Message Queue Performance Considerations
Count in-degrees: Calculate how many incoming edges each vertex has; Lesson 722 — Kahn's Algorithm: Basic Idea
Count negative numbers: Lesson 898 — Minimum Product Subset
Count negatives: An odd number of negatives gives a negative product; an even number gives positive; Lesson 898 — Minimum Product Subset
Count occurrences: Create a count array where each index represents a possible value, and store how many times that value appears in the input; Lesson 788 — Counting Sort: Basic Concept
Counter Method: Lesson 701 — Level-Order Traversal
Counterexample: Lesson 911 — Counterexamples: When Greedy Fails
Counters: track `active_readers`, `active_writers`, and `waiting_writers`; Lesson 1311 — Reader-Writer Problem with CVs
Counting character frequencies: – track how many times each character appears; Lesson 268 — Common String Algorithms
Counting related records: How many items per category?; Lesson 1590 — Using Joins with Aggregations
Counting resources: Managing a pool of identical resources (like database connections or buffer slots); Lesson 1292 — Semaphore Definition and Purpose
counting semaphore: can hold any **non-negative integer** value.; Lesson 1293 — Binary Semaphores vs Counting Semaphores Lesson 1299 — Readers-Writers Problem with Semaphores Lesson 1301 — Resource Counting with Counting Semaphores
Counting Sort: or **Radix Sort** achieve O(n) time.; Lesson 799 — When to Use Which Sorting Algorithm
Counting total edges: Lesson 676 — Edge List Representation
Counting/Radix sort: are linear-time but only work with specific data types; Lesson 800 — Hybrid Sorting Strategies
Course: Lesson 1615 — Relationships and Relationship Sets
Course prerequisites: CS101 before CS201 before CS301—no loops allowed; Lesson 663 — Cycles and Acyclic Graphs
Course scheduling: Students in one set, courses in the other, edges show enrollment; Lesson 689 — Bipartite Graphs
Coverage: Do labels represent all important cases?; Lesson 2794 — Label Quality and Acquisition
Coverage gaps: Are new functions/branches tested, or only the happy path?; Lesson 2348 — Reviewing Tests and Documentation
CP: (consistency + partition tolerance) or **AP** (availability + partition tolerance).; Lesson 1714 — CAP Theorem Trade-offs Across Categories
CP system: , when a network partition splits your distributed system into isolated groups, the system chooses to maintain **consistency** across all nodes rather than remain available for writes.; Lesson 2605 — CP Systems: Consistency and Partition Tolerance
CP systems: (e.; Lesson 2604 — The CAP Trade-off: Pick Two Lesson 2607 — CA Systems and the Real World
CP-leaning: .; Lesson 1714 — CAP Theorem Trade-offs Across Categories
CPI: tells you how many clock cycles it takes, on average, to complete one instruction.; Lesson 1159 — Pipeline Performance Metrics Lesson 1185 — CPU Performance Equation Fundamentals Lesson 1186 — Cycles Per Instruction (CPI)
CPI (Cycles Per Instruction): The average number of clock cycles needed to complete one instruction; Lesson 1185 — CPU Performance Equation Fundamentals
CPU Burst: A period when the process actively uses the CPU to perform computations (adding numbers, comparing values, executing logic); Lesson 1242 — CPU Burst and I/O Burst Cycles
CPU cycles: , and **cache efficiency**.; Lesson 2109 — Reference Counting Performance
CPU flags: tiny status indicators that other instructions can read to make decisions.; Lesson 1098 — Comparison and Test Instructions
CPU jumps: to the handler address stored in that entry; Lesson 1212 — Interrupt Vector Table
CPU reads IVT entry: at position *n* (often calculated as: `IVT_base_address + n × entry_size`); Lesson 1212 — Interrupt Vector Table
CPU Registers: ~0.; Lesson 1110 — Access Time and Latency Lesson 1113 — Memory Bandwidth Considerations Lesson 1217 — Process Control Block (PCB)Lesson 2095 — Reachability and the Root Set
CPU returns: to interrupted program; Lesson 1212 — Interrupt Vector Table
CPU Utilization: and **Throughput**.; Lesson 1245 — CPU Utilization and Throughput Lesson 1249 — Scheduling Criteria Trade-offs
CPU-bound processes: are computation-heavy—think video encoding, scientific simulations, or cryptographic operations.; Lesson 1250 — CPU-Bound vs I/O-Bound Processes Lesson 1260 — Multilevel Feedback Queue Scheduling
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
CRDTs: (data structures designed to merge automatically); Lesson 2641 — Multi-Leader Replication
Create: and modify database structures (tables, schemas); Lesson 1561 — SQL Introduction and Purpose Lesson 1721 — CRUD Operations in Document Databases Lesson 2193 — Branch Management Best Practices
Create a cache: (usually a dictionary or array) before your recursion starts.; Lesson 873 — Recursion with Memoization Integration
Create a feature branch: Work happens on a branch in their fork.; Lesson 2198 — Forking Workflow
Create a flow network: source → agents → tasks → sink; Lesson 1049 — Assignment Problem
Create a new commit: `HEAD` moves forward to point to the new commit; Lesson 2184 — The HEAD Pointer
Create a new node: with your data; Lesson 328 — Inserting at the Head
Create a new table: (typically 2× the old size); Lesson 429 — Rehashing Process
Create a source node: `s` and a **sink node** `t`; Lesson 1052 — Project Selection Problem
Create buckets: Divide this range into equal-sized intervals (buckets); Lesson 795 — Bucket Sort: Partitioning the Range
Create conflicts: Design inputs where the greedy choice blocks a better combination; Lesson 911 — Counterexamples: When Greedy Fails
Create leaf nodes: For each character and its frequency, insert a node into a min-heap (prioritized by frequency); Lesson 614 — Huffman Coding Tree Construction
Create parent node: Make a new internal node with frequency = sum of the two children; Lesson 614 — Huffman Coding Tree Construction
Create states: for each distinct "memory" situation; Lesson 1781 — Designing Simple DFAs
Create the new node: with your data; Lesson 341 — Inserting at the Head of a Doubly Linked List Lesson 342 — Inserting at the Tail of a Doubly Linked List
Create two new nodes: left gets keys smaller than median, right gets keys greater; Lesson 561 — Node Splitting During Insertion Lesson 1681 — Node Splitting During Insertion
Create your new node: (just like inserting at the head); Lesson 329 — Inserting at the Tail
Create, Read, Update, Delete: the four fundamental operations for managing data in any database.; Lesson 1721 — CRUD Operations in Document Databases
Creating a new array: Declare a new array of the same length, then copy elements one by one; Lesson 240 — Array Copying and Cloning
Creating new tables: – Move the transitively dependent attributes into their own table; Lesson 1639 — Achieving Third Normal Form
Creating temporary arrays: during processing also exhibits O(n) space:; Lesson 306 — Linear Space: O(n)
Creational patterns: are design solutions that abstract and manage the object instantiation process.; Lesson 2264 — Introduction to Creational Patterns
Creator (abstract): declares the factory method; Lesson 2267 — Factory Method Pattern Basics
Credentials: Username and password for authentication; Lesson 1562 — Database Connection and Basic Structure
Critical issues: threaten functionality, security, or correctness—they're bugs waiting to happen, vulnerabilities that could be exploited, or logic errors that produce wrong results.; Lesson 2345 — Distinguishing Critical vs Stylistic Issues
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 Defined Lesson 2556 — Critical Sections
critical sections: .; Lesson 1213 — Interrupt Priority and Masking Lesson 1273 — Critical Sections Defined Lesson 1280 — Mutual Exclusion Problem Lesson 2561 — Synchronized Blocks and Methods
Critical state changes: Design for idempotency and conflict resolution; Lesson 1734 — Eventual Consistency Trade-offs
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.; Lesson 700 — BFS Tree and Parent Tracking Lesson 714 — DFS on Directed vs Undirected Graphs
Cross-Domain: Tokens work seamlessly across different domains and APIs; Lesson 2500 — Token-Based Authentication
Cross-Entropy Loss: Measures how well predicted probabilities match true class labels; Lesson 2779 — Loss Functions and Objective Functions Lesson 2832 — Maximum Likelihood Estimation
Cross-functional collaboration: Members with different skills work together fluidly; Lesson 2367 — Self-Organizing Teams
Cross-set edges only: All edges go between the two sets; no edges exist within a set; Lesson 689 — Bipartite Graphs
Crossing the midpoint: (starts in left, ends in right); Lesson 847 — Maximum Subarray Problem
Crowdsourcing: Cheaper but noisier (Amazon Mechanical Turk); Lesson 2794 — Label Quality and Acquisition
Cryptographic (for security): Lesson 415 — Cryptographic vs Non-Cryptographic Hash Functions
Cryptographic hash functions: prioritize **security**.; Lesson 415 — Cryptographic vs Non-Cryptographic Hash Functions
Cryptographically random: Use secure random generators, not predictable sequences; Lesson 2506 — Salt: Defending Against Rainbow Tables
Cryptography: Most internet security assumes P ≠ NP; Lesson 1912 — The Million Dollar Question
CS: (Code Segment): points to executable code; Lesson 1385 — Segmentation in x86 Architecture
CSRF: Hidden forms, image tags, or links that trigger state-changing requests on victim sites; Lesson 2466 — CSRF vs XSS
CSRF (Cross-Site Request Forgery): exploits a website's trust in an authenticated user.; Lesson 2466 — CSRF vs XSS
CSRF targets: Missing anti-CSRF tokens, predictable request patterns, reliance on cookies alone for authentication; Lesson 2466 — CSRF vs XSS
CSRF tokens: for all state-changing requests (POST, PUT, DELETE); Lesson 2473 — Implementing CSRF Protection
CSS backgrounds: , iframes, or any resource reference; Lesson 2472 — State-Changing Operations and Safe Methods
CSS context: Has its own escaping rules; Lesson 2460 — Output Encoding and Escaping
CTEs: (Common Table Expressions) make complex logic readable and are calculated once, improving both clarity and performance; Lesson 1609 — Subquery Performance Considerations
Cubic: `n³` — grows even faster; Lesson 278 — Growth Rates and Dominant Terms
Cumulative Distribution Function (CDF): tells you the probability that the variable is *at most* that value.; Lesson 123 — Cumulative Distribution Functions (CDF)
Current data focus: (today's orders, this week's inventory); Lesson 1650 — OLTP vs OLAP Database Design
Current page: The paper on top of your "back stack"; Lesson 372 — Browser History Navigation
Current state: – which control state the PDA is in; Lesson 1829 — PDA Configurations and Instantaneous Descriptions Lesson 1853 — States and Transition Functions Lesson 1854 — Turing Machine Configuration Lesson 1855 — Transition Rules and Execution
current working directory: .; Lesson 1390 — File Paths: Absolute vs Relative Lesson 1414 — Tree-Structured Directories Lesson 1417 — Current Working Directory
Currying: transforms this into a chain where each step takes one argument and returns a new function: `add(a)(b)(c)`.; Lesson 2138 — Currying and Partial Application
Customer collaboration: over contract negotiation; Lesson 2361 — The Agile Manifesto
Customer service line: First caller waits the shortest time; Lesson 375 — Queue ADT Definition and FIFO Principle
Customers: table: `customer_id`, `name`, `email`; Lesson 1576 — What is a Join?
cut: of a graph is simply a partition of vertices into two disjoint sets.; Lesson 1013 — Cut Property and MST Correctness Lesson 1031 — The Max-Flow Min-Cut Theorem Lesson 1050 — Min-Cut and Max-Flow Duality
cut property: provides that guarantee.; Lesson 1013 — Cut Property and MST Correctness Lesson 1014 — Kruskal's Algorithm: Overview Lesson 1017 — Prim's Algorithm: Overview
Cut-through latency: Forwarding begins after reading destination MAC; Lesson 1459 — Switch Performance Metrics
Cutoff to Insertion Sort: Instead of recursing all the way down to single elements, switch to Insertion Sort when a subarray reaches a small threshold (e.; Lesson 759 — Optimizing Mergesort
Cutting board: (cache): Very quick to reach, limited workspace; Lesson 1108 — Speed vs Capacity Tradeoff
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 Lesson 690 — Cyclic and Acyclic Graphs Lesson 1316 — Resource Allocation Graphs Lesson 1317 — Detecting Cycles in Resource Allocation Graphs Lesson 1326 — Deadlock Detection Algorithms
Cycle 1: Only stage 1 is active (1 instruction in flight); Lesson 1153 — Pipeline Fill and Drain Lesson 1165 — Data Hazards: Read-After-Write (RAW)
Cycle 2: Stages 1-2 active (2 instructions); Lesson 1153 — Pipeline Fill and Drain Lesson 1165 — Data Hazards: Read-After-Write (RAW)
Cycle 3: Stages 1-3 active (3 instructions); Lesson 1153 — Pipeline Fill and Drain Lesson 1165 — Data Hazards: Read-After-Write (RAW)
Cycle 4: Stages 1-4 active (4 instructions); Lesson 1153 — Pipeline Fill and Drain Lesson 1165 — Data Hazards: Read-After-Write (RAW)
Cycle 5: All stages active—pipeline is **full**!; Lesson 1153 — Pipeline Fill and Drain Lesson 1165 — Data Hazards: Read-After-Write (RAW)
Cycle detection: A self-loop is technically a cycle of length 1; Lesson 687 — Self-Loops and Their Implications Lesson 718 — DFS Applications and Use Cases
Cycle detection differs: Lesson 714 — DFS on Directed vs Undirected Graphs
cycles per instruction (CPI): .; Lesson 1151 — Pipeline Throughput and Latency Lesson 1187 — Instructions Per Cycle (IPC) and Throughput
Cyclic graphs: model real-world scenarios like social networks, road maps, and circular dependencies.; Lesson 690 — Cyclic and Acyclic Graphs
Cyclic Redundancy Check (CRC): provides industrial-strength error detection by treating your data as a giant polynomial and performing division.; Lesson 1448 — Cyclic Redundancy Check (CRC)
CYK: (which requires Chomsky Normal Form), you might wonder: *Is there a way to parse any CFG directly, without preprocessing?; Lesson 1846 — Earley Parsing Algorithm
CYK (Cocke-Younger-Kasami) algorithm: is a parsing method that determines whether a string belongs to the language generated by a context-free grammar.; Lesson 1845 — CYK Parsing Algorithm Lesson 1873 — Decidability of CFG Membership
CYK parsing algorithm: Uses CNF to efficiently parse strings in O(n³) time; Lesson 1820 — Chomsky Normal Form (CNF)
Cypress: runs directly in the browser alongside your application, making tests fast and debugging easier with time-travel snapshots.; Lesson 2249 — E2E Testing Tools and Frameworks

D

D6: Lesson 8 — Converting Between Binary and Hexadecimal
DAC: distributes control but risks inconsistency—resource owners may grant access unwisely.; Lesson 2533 — Authorization Model Tradeoffs
Dangerous sinks: Lesson 2457 — DOM-Based XSS Attacks
dangling pointer: occurs when you hold a reference to stack memory that has already been deallocated.; Lesson 2083 — Common Pitfalls: Dangling Pointers and Leaks Lesson 2088 — Dangling Pointers and Use- After-Free
Data: The actual value you want to store (an integer, character, etc.; Lesson 324 — Introduction to Linked Lists Lesson 339 — Doubly Linked List Structure and Node Design Lesson 460 — Node-Based Tree Structure Lesson 1078 — Memory Address and Data Registers Lesson 1215 — What is a Process?Lesson 1472 — TCP Segment Structure
Data analysis: Time-series data across multiple locations; Lesson 247 — 3D Arrays and Higher Dimensions
Data Characteristics: Lesson 799 — When to Use Which Sorting Algorithm
Data distribution: Histograms showing value frequency; Lesson 1699 — Cost-Based Query Optimization Lesson 2684 — Sharding Fundamentals
Data encoding/decoding: (ASCII, Unicode, etc.; Lesson 1437 — OSI Upper Layers: Session, Presentation, Application
Data exchange: between modules (correct format, completeness); Lesson 2234 — What is Integration Testing?
Data field: – the actual value you want to store (an integer, string, etc.; Lesson 325 — Node Structure
Data flows automatically: Changes propagate without explicit commands; Lesson 2153 — Reactive Programming Fundamentals
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)
Data in body: Parameters are sent in the HTTP request body, not visible in the URL; Lesson 1516 — HTTP Methods: GET and POST
Data in URL: Any parameters are visible in the URL query string (e.; Lesson 1516 — HTTP Methods: GET and POST
data integrity: using cryptographic checksums, detecting any alterations.; Lesson 1529 — TLS Overview and Purpose Lesson 1556 — Foreign Keys and References Lesson 1613 — Attributes and Domains Lesson 1650 — OLTP vs OLAP Database Design Lesson 2422 — Preimage Resistance (One-Wayness)
Data integrity constraints: (foreign keys, uniqueness) work as expected; Lesson 2243 — Database Integration Testing
Data Link Layer: – Transfers data between adjacent network nodes, handles physical addressing; Lesson 1432 — The OSI Model: Seven-Layer Overview Lesson 1440 — Encapsulation and Layer Communication
Data locality: Everything lives together on disk; Lesson 1724 — Embedding vs Referencing
Data loss is inevitable: with LWW.; Lesson 2701 — Last-Write-Wins (LWW) Conflict Resolution
Data members: (also called fields or attributes): variables that hold state; Lesson 2122 — Classes and Objects
Data NULLs: NULLs that exist in your actual table data; Lesson 1589 — Handling NULLs in Joins
Data presentation: Users expect sorted results (search results, leaderboards, file listings); Lesson 737 — What is Sorting?
Data profiling: understanding distributions in datasets (most common values, outliers); Lesson 447 — Frequency Counting and Histograms
Data rate and timing: How fast bits are sent and how sender/receiver synchronize their clocks; Lesson 1441 — Physical Layer Overview
data redundancy: the same information stored multiple times.; Lesson 1631 — Introduction to Normal Forms Lesson 1648 — Data Redundancy and Consistency Risks
Data segment: (global variables); Lesson 1378 — Segmentation Basics and Motivation
Data sharing: Cooperating processes can share a data segment for inter-process communication.; Lesson 1381 — Segmentation with Protection and Sharing
Data Size Matters: Lesson 799 — When to Use Which Sorting Algorithm Lesson 2590 — Network Latency and Bandwidth Constraints
data skew: when values aren't evenly distributed.; Lesson 1704 — Statistics and Histograms Lesson 2690 — Handling Data Skew and Hotspots
Data Transfer: Lesson 1141 — Miss Penalty Components
Data type: `INTEGER` or `SMALLINT`; Lesson 1554 — Domains and Data Types
Data types: and their sizes (integers, floats); Lesson 1092 — Instruction Set Architecture (ISA)Lesson 1554 — Domains and Data Types Lesson 1658 — Consistency: Maintaining Database Invariants
Data validation: How many records exist?; Lesson 1592 — COUNT Function
Database breaches happen constantly: no system is perfectly secure; Lesson 2504 — Password Storage Fundamentals
Database connections: (one connection per thread avoids locking); Lesson 2559 — Thread-Local Storage
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
Database indexing: where you need both fast lookups and range scans; Lesson 502 — BST Advantages and Use Cases
Database interactions: between business logic and data layers; Lesson 2234 — What is Integration Testing?
Database name: Which specific database you want to access; Lesson 1562 — Database Connection and Basic Structure
Database ORMs: Entity Framework and SQLAlchemy provide simple object interfaces that hide SQL complexity and connection management.; Lesson 2285 — Real-World Structural Pattern Examples
Database query optimizers: order operations; Lesson 720 — Topological Sort Applications
Database Setup: Use a separate test database instance (often in-memory or containerized) with the same schema as production.; Lesson 2250 — Setting Up the Test Environment
Databases: MySQL, PostgreSQL, and Oracle use B-tree variants (B+ trees) for indexing.; Lesson 567 — B-Tree Performance and Applications
Dataflow programming: works the same way: you define how data flows between operations, and the system automatically executes operations whenever their input data becomes available.; Lesson 2154 — Dataflow Programming
Dataset is large: Prediction requires computing distances to *all* training points (remember: O(n) complexity per prediction); Lesson 2872 — KNN in Practice: Applications and Limitations
Date/Timestamp: When the commit was created.; Lesson 2175 — Viewing Commit History
Dating apps: Two groups of users, edges represent mutual interest; Lesson 689 — Bipartite Graphs
Dead Code Elimination: Lesson 2058 — Peephole Optimization in Code Generation Lesson 2068 — Loop Unrolling Lesson 2069 — Inlining Functions
Dead Letter Queue: is a special holding area for problematic messages.; Lesson 2712 — Dead Letter Queues and Poison Messages
Dead node: Crashed entirely, will never respond; Lesson 2591 — Partial Failures and Fault Detection
deadlock: .; Lesson 1290 — Lock Ordering and Deadlock Prevention Lesson 1300 — Dining Philosophers Problem Lesson 1314 — What is Deadlock?Lesson 1318 — Deadlock vs Livelock vs Starvation
deadlock avoidance: allows the system to make smart decisions at runtime.; Lesson 1323 — Deadlock Avoidance: Safe States Lesson 1324 — The Banker's Algorithm
Deadlock risk: Two threads can block each other forever; Lesson 2566 — Introduction to Lock-Free Programming
Deadlocks: Different nodes lock resources in conflicting orders; Lesson 2717 — What Are Distributed Transactions?
Deallocate: Free the memory of the old tail node; Lesson 333 — Deleting from the Tail
Deallocate exactly once: Free each allocation when no longer needed, but never free the same memory twice; Lesson 2084 — Manual Memory Management Overview
Deallocate the removed node: to prevent memory leaks; Lesson 346 — Deleting from the Middle of a Doubly Linked List
Debug builds: Use `-O0` (no optimization) so code matches source line-by-line for easier debugging; Lesson 2073 — Optimization Levels and Pragmas
Debug logical errors: when conditions seem backwards; Lesson 41 — De Morgan's Laws
Debuggable: Easier to reason about cause and effect; Lesson 2132 — Pure Functions and Immutability
Debugging: Stack traces in recursive solutions can be harder to follow when many levels deep.; Lesson 868 — Recursive vs Iterative Tradeoffs Lesson 2216 — Testing vs Debugging
Debugging mindset: Analytical and constructive.; Lesson 2216 — Testing vs Debugging
Decades of evidence: No one has found a counterexample despite countless attempts; Lesson 1867 — Implications and Universal Acceptance
decidable: (always answerable):; Lesson 1811 — Decision Properties of Regular Languages Lesson 1868 — What is Decidability?Lesson 1870 — Examples of Decidable Problems Lesson 1871 — The Acceptance Problem for DFAs Lesson 1872 — The Emptiness Problem for DFAs Lesson 1875 — Recognizable vs. Decidable Lesson 1877 — Decidability as a Fundamental Limit
decidable language: ) is one where a Turing Machine exists that will always halt and correctly answer "yes" or "no" for every possible input.; Lesson 1868 — What is Decidability?Lesson 1869 — Decidable vs. Undecidable Languages
Decision point: Lesson 1656 — Commit and Rollback Operations
decision problem: is any yes/no question about an input.; Lesson 1868 — What is Decidability?Lesson 1898 — Decision Problems and Languages Lesson 1900 — Examples of Problems in P
Declaration: `int& num` creates a reference parameter; Lesson 321 — Reference Parameters in Functions
Declarations: – token definitions and precedence rules; Lesson 1973 — Parser Generators and YACC/Bison
declarative: approach is simply saying: "I want the pasta carbonara.; Lesson 2147 — Declarative vs Imperative: Philosophy and Examples Lesson 2154 — Dataflow Programming
Declarative code: expresses logic and desired results without dictating control flow.; Lesson 2147 — Declarative vs Imperative: Philosophy and Examples
Declarative dependencies: You describe *what* depends on *what*, not *how* to update; Lesson 2153 — Reactive Programming Fundamentals
Declarative example concept: (from functional lessons):; Lesson 2147 — Declarative vs Imperative: Philosophy and Examples
declare: one so the computer understands what you're creating.; Lesson 186 — Function Declaration Syntax Lesson 2149 — HTML and Markup Languages
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
Decode: Interpret the instruction's binary pattern to determine what operation is needed (e.; Lesson 1073 — The Control Unit Lesson 1075 — Instruction Register (IR)Lesson 1081 — What is the Instruction Cycle?Lesson 1089 — Instruction Cycle Timing Lesson 1148 — Introduction to Instruction Pipelining Lesson 1169 — Data Forwarding (Bypassing)
decode stage: .; Lesson 1084 — The Decode Stage Lesson 1085 — Instruction Formats and Opcodes
Decompose: Lesson 1641 — Achieving BCNF
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
Decompose into: Lesson 1636 — Achieving Second Normal Form Lesson 1639 — Achieving Third Normal Form
Decompose the relation: Split the original table into two:; Lesson 1641 — Achieving BCNF
Decorator: Lesson 2282 — Decorator vs Inheritance: Flexible Extension Lesson 2283 — Structural Pattern Trade-offs Lesson 2284 — Combining Structural Patterns Lesson 2294 — Iterator Pattern
Decoupling: Client code doesn't depend on concrete classes; Lesson 2267 — Factory Method Pattern Basics Lesson 2296 — Chain of Responsibility Pattern
decrease: in a min-heap), you're making it "stronger" relative to its parent—it might now violate the heap order property *upward*.; Lesson 594 — Increase/Decrease Key Operations Lesson 2858 — AdaBoost Algorithm
Decrease the tallest towers: by `k` to pull them down; Lesson 901 — Minimize Maximum Difference in Heights
Decrease-key: Update a node's priority when we relax an edge in O(log V) time; Lesson 973 — Dijkstra's with Binary Heap Priority Queue Lesson 974 — Dijkstra's with Fibonacci Heap
Decrease-key (relaxation): Called up to E times (once per edge), each O(log V) → O(E log V) total; Lesson 973 — Dijkstra's with Binary Heap Priority Queue
Decrement: The old target's count goes down (you removed a pointer from it); Lesson 2105 — Reference Count Operations
Decryption: Alice uses her private key `x` to compute `c₁^x`, then recovers the message by calculating `c₂ / c₁^x mod p`.; Lesson 2413 — ElGamal Encryption System
Deduplication: extends this idea: instead of just detecting duplicates, you actively remove them to create a clean dataset.; Lesson 446 — Duplicate Detection and Deduplication
Deduplication identifiers: (tracking message IDs); Lesson 2710 — At-Most-Once, At-Least-Once, Exactly-Once Delivery
deep copy: matters when arrays contain references to other objects or nested arrays.; Lesson 240 — Array Copying and Cloning Lesson 2272 — Prototype Pattern and Cloning
Deep nesting: If you're indented 3-4 levels deep, inner blocks often make great extracted methods.; Lesson 2319 — Extract Method: Breaking Down Complex Functions
Deep recursion: Each recursive call adds a frame.; Lesson 2077 — Stack Growth and Limitations
Deep traversals: "Find all suppliers three hops away from this manufacturer"; Lesson 1746 — Graph Database Model and Use Cases
Defect detection: Finding errors before they reach production; Lesson 2214 — What is Software Testing?
Defense against adversarial input: If your system might face deliberately crafted worst-case inputs (security contexts, public APIs), heapsort's consistent behavior prevents algorithmic complexity attacks that exploit quicksort's weaknesses.; Lesson 608 — Practical Considerations for Heapsort
Defensive programming: Never assume the stack has elements; Lesson 358 — Pop Operation
Deferred deletion: When removing a node, threads don't immediately free it—they add it to a "retire list"; Lesson 2573 — Hazard Pointers for Memory Reclamation
Deferring decrements: in some cases to batch operations; Lesson 2110 — Reference Counting in Practice
Define a measure: Identify how to compare your greedy solution to alternatives (e.; Lesson 884 — Greedy Stays Ahead Proofs
Define state: What's the best sum ending/starting at this node?; Lesson 949 — Path Sums and Tree DP
Define the grammar: – What are valid expressions?; Lesson 2300 — Interpreter Pattern
Define the reduction: What parameter(s) shrink with each recursive call?; Lesson 866 — Problem Decomposition in Recursion
Definitive answer: CYK either finds a parse (the string is in the language) or exhaustively proves no parse exists (the string is not in the language).; Lesson 1873 — Decidability of CFG Membership
Degree: The number of edges connected to a vertex; Lesson 657 — What is a Graph? Vertices and Edges Lesson 661 — Degree of a Vertex Lesson 684 — Directed vs Undirected Graphs Lesson 1615 — Relationships and Relationship Sets
Degree calculation: In undirected graphs, a self-loop traditionally adds 2 to a vertex's degree (the edge touches the vertex twice); Lesson 687 — Self-Loops and Their Implications
Degree-Constrained MST: Add constraints like "no node can have more than k connections.; Lesson 1021 — MST Applications and Variations
Delay_Request: ; master responds with **Delay_Response**; Lesson 2635 — Precision Time Protocol (PTP)
Delay_Response: Lesson 2635 — Precision Time Protocol (PTP)
Delaying node creation: until necessary; Lesson 639 — Burst Tries
Delete: Replace the target element with a tombstone marker.; Lesson 427 — Deletion in Open Addressing Lesson 442 — Dictionary and Set Implementations Lesson 522 — Best-Case BST Analysis Lesson 927 — Edit Distance (Levenshtein Distance)Lesson 1517 — HTTP Methods: PUT, DELETE, and Others Lesson 1528 — RESTful API Design with HTTP Lesson 1687 — B-Tree Index Performance Characteristics Lesson 1721 — CRUD Operations in Document Databases (+1 more)
Delete a specific user: Lesson 1572 — DELETE Statement for Removing Data
Delete all unit productions: Remove every rule of the form `A → B`.; Lesson 1824 — Eliminating Unit Productions
Delete anomalies: Removing data might leave orphaned redundant copies elsewhere.; Lesson 1648 — Data Redundancy and Consistency Risks
Delete Arbitrary Element: O(log n) — combines swap and bubble operations; Lesson 599 — Heap Operation Trade-offs
Delete by position: Traverse to the nth node and remove it.; Lesson 334 — Deleting a Specific Node
Delete by value: Traverse the list comparing each node's data.; Lesson 334 — Deleting a Specific Node
Delete from front: Remove the element at `front`, then move `front` *forward*.; Lesson 397 — Array-Based Deque Implementation
Delete from rear: Move `rear` *backward* (with wrap-around), then remove that element.; Lesson 397 — Array-Based Deque Implementation
Delete normally: Use BST deletion rules (remove leaf, bypass single-child node, or replace with inorder successor/predecessor); Lesson 541 — AVL Deletion Overview
Delete old records: Lesson 1572 — DELETE Statement for Removing Data
Delete the replacement node: The successor/predecessor will have at most one child, making it an easier deletion case you've already learned; Lesson 510 — BST Deletion: Two Children Case
Delete-front: Remove the element at `front`, then move `front` forward; Lesson 392 — Deque Array Implementation
Delete-rear: Move `rear` backward, then remove the element there; Lesson 392 — Deque Array Implementation
DeleteBack: Save the tail's data, move `tail` to `tail->prev`, update the new tail's `next` to `NULL` (if it exists).; Lesson 393 — Deque Linked List Implementation
Deleted branch: The commits still exist.; Lesson 2207 — Reflog and Recovery
DeleteFront: Save the head's data, move `head` to `head->next`, update the new head's `prev` to `NULL` (if it exists).; Lesson 393 — Deque Linked List Implementation
Deleting: removes one and shifts the rest.; Lesson 239 — Common Array Operations
Deleting the head: Use your existing "delete from head" logic (no predecessor exists); Lesson 334 — Deleting a Specific Node
Deletion: O(n) — you must search through the chain first; Lesson 523 — Worst-Case BST Analysis Lesson 544 — AVL Operation Complexity Lesson 545 — AVL Trees vs Unbalanced BSTs Lesson 626 — Time Complexity of Trie Operations Lesson 1685 — B-Tree Height and Disk I/O
Deletion anomalies: Removing the last student in a major loses the building information; Lesson 1637 — Third Normal Form (3NF) Definition Lesson 1638 — Transitive Dependencies Explained
Deletion anomaly: Removing a row accidentally erases unrelated information; Lesson 1631 — Introduction to Normal Forms
Deletion complexity: You might need to remove only *one* duplicate, requiring you to traverse duplicates; Lesson 528 — BST with Duplicate Keys
Deletion total: O(log n) search + O(log n) rotations × O(1) each = **O(log n)**; Lesson 544 — AVL Operation Complexity
Deliver value early: Users get working features sooner; Lesson 2366 — Iterative and Incremental Development
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 Lesson 1394 — Memory-Mapped Files
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
denormalization: related data lives together in nested structures.; Lesson 1718 — Document Database Model Lesson 1742 — Schema Design in Column-Family Stores Lesson 2690 — Handling Data Skew and Hotspots Lesson 2692 — Cross-Shard Queries and Joins
Denormalized or star/snowflake schemas: for query performance; Lesson 1650 — OLTP vs OLAP Database Design
dense: (edges approach V² in number); Lesson 671 — Adjacency Matrix: Space-Time Tradeoffs Lesson 693 — Graph Density and Sparsity Lesson 999 — Floyd-Warshall vs Repeated Dijkstra Lesson 1020 — Comparing Kruskal's and Prim's Algorithms
Dense Graph: `E ≈ V²` (edges approach the theoretical maximum); Lesson 680 — Choosing Representation by Graph Density Lesson 976 — Dijkstra's on Dense vs Sparse Graphs
dense graphs: (where most possible edges exist) make this tradeoff favorable.; Lesson 671 — Adjacency Matrix: Space-Time Tradeoffs Lesson 693 — Graph Density and Sparsity Lesson 697 — BFS with Adjacency Matrix
Density formula: Lesson 693 — Graph Density and Sparsity
Departments: table:; Lesson 1556 — Foreign Keys and References
Dependency conflicts: Library versions, language runtimes; Lesson 2596 — Heterogeneity of Hardware and Software
Dependency management: means:; Lesson 2387 — Build Artifacts and Dependencies
Deployment: Release the software to production; Lesson 2353 — The Waterfall Model: Sequential Phases
depth: tells you how far down a node sits from the root, while **height** tells you how far up from the deepest leaf below.; Lesson 454 — Node Depth and Height Lesson 455 — Tree Height and Level Lesson 456 — Subtrees and Their Properties Lesson 483 — Tree Height and Depth
Depth (d): number of steps from initial to goal state; Lesson 2735 — State Space Size and Complexity
Depth of recursion: Each level cuts the problem size in half, so you need **log₂ n** levels to reduce n elements down to size 1 (just like our card deck: 8 → 4 → 2 → 1 took log₂ 8 = 3 steps).; Lesson 768 — Best-Case Analysis: Balanced Partitions
Depth-limited minimax: solves this by setting a maximum search depth (say, 6 ply).; Lesson 2771 — Depth-Limited Minimax
Depth-Limited Search: from the previous lesson?; Lesson 2745 — Iterative Deepening DFS
Depth-Limited Search (DLS): solves this by adding a hard depth limit `l` — the search will not explore any node deeper than `l` levels from the start state.; Lesson 2744 — Depth-Limited Search
deque: (double-ended queue) needs efficient operations at both the front and back.; Lesson 393 — Deque Linked List Implementation Lesson 395 — Deque: Double-Ended Queue Fundamentals Lesson 399 — Deque vs Stack vs Queue Lesson 401 — Sliding Window Problems with Deques Lesson 706 — 0-1 BFS
Dequeue: The car at the window gets their order and drives away; Lesson 376 — Essential Queue Operations Lesson 379 — Circular Queue Concept Lesson 383 — Queue Operation Complexity Analysis Lesson 2571 — Lock-Free Queue: The Michael-Scott Algorithm Lesson 2578 — Concurrent Queue: Array-Based Implementation Lesson 2579 — Concurrent Queue: Linked List Implementation Lesson 2580 — Lock-Free Queue with CAS
Dequeue (remove from front): Lesson 378 — Array-Based Queue Implementation Lesson 382 — Linked List-Based Queue Implementation
Dequeue (Remove): Lesson 376 — Essential Queue Operations
DER encoding: to serialize data into binary form—ensuring every byte is interpreted identically across platforms.; Lesson 2440 — Digital Signature Standards and Formats
Derivation length: For a string of length *n*, you need exactly *2n - 1* steps; Lesson 1843 — Chomsky Normal Form
DESC: (descending): largest to smallest, Z to A; Lesson 1568 — ORDER BY and Sorting Results
Design: Lesson 2343 — The Review Checklist Approach Lesson 2353 — The Waterfall Model: Sequential Phases
Design data structures: The degree constraint affects how you implement tree nodes in code; Lesson 458 — Degree of a Node and Tree Degree
Design feedback: – Hard-to-test code often signals design problems; Lesson 2224 — What is Unit Testing?
Design phase: Sketch your pattern recognition as an NFA—small, intuitive, elegant; Lesson 1802 — Why Use NFAs: Design vs Implementation
Destination IP: (where to route the packet across networks); Lesson 1452 — MAC Addresses
Destination MAC: (which physical device on *this* network segment to hand it to); Lesson 1452 — MAC Addresses
destination port number: in the TCP header and delivers the data to the correct application.; Lesson 1483 — TCP Port Numbers and Multiplexing Lesson 1488 — UDP Port Numbers and Multiplexing
Destination registers: of instructions in later stages (Execute, Memory, Write-Back); Lesson 1174 — Hazard Detection Unit Design
Destructive view (min-cut): What's the weakest point to block everything?; Lesson 1031 — The Max-Flow Min-Cut Theorem
Destructuring: Extract nested data in one step instead of multiple accessor calls; Lesson 2141 — Pattern Matching
Detailed Design: → paired with **Integration Testing**; Lesson 2355 — The V-Model: Verification and Validation
Detect back edges: If you encounter a vertex marked "visiting" during DFS, you've found a cycle; Lesson 721 — DAG Detection and Prerequisites
Detect collisions: If two devices transmit simultaneously, both detect the collision; Lesson 1450 — Medium Access Control (MAC)
detect negative cycles: loops where the total weight is negative.; Lesson 980 — Bellman-Ford Overview and Motivation Lesson 989 — Bellman-Ford Applications
Detect outliers: (points that don't fit any cluster well); Lesson 2789 — Clustering Fundamentals
Detect redundancy: – Repeated data often signals problematic dependencies; Lesson 1621 — Introduction to Functional Dependencies
Detect relationships: between vertices (is one an ancestor of another?; Lesson 715 — DFS Discovery and Finish Times
Detecting differences: Comparing two binary values bit-by-bit (if XOR outputs 1, those bits differ); Lesson 17 — The XOR Gate (Exclusive OR)
Detecting failures: Deciding if a node is slow or crashed (the partial failure problem you've seen); Lesson 2598 — Lack of Global Clock
Detection + Recovery: periodically scans for cycles and kills processes, which is disruptive; Lesson 1328 — Ostrich Algorithm and Practical Approaches
Detection mechanism: After processing, if the number of vertices added to the topological order is less than the total number of vertices, a cycle exists.; Lesson 726 — Detecting Cycles During Topological Sort
Determine direction: Lesson 594 — Increase/Decrease Key Operations
Determine the range: Find the minimum and maximum values in your data; Lesson 795 — Bucket Sort: Partitioning the Range
Determinism: A program's execution has exactly one possible outcome.; Lesson 2026 — Proving Semantic Properties
deterministic: every string has exactly one path, so flipping acceptance perfectly inverts the language.; Lesson 1804 — Closure Properties: Star and Complement Lesson 1853 — States and Transition Functions Lesson 1956 — Predictive Parsing and FIRST Sets Lesson 2109 — Reference Counting Performance Lesson 2132 — Pure Functions and Immutability Lesson 2420 — What is a Hash Function?
Deterministic Finite Automaton (DFA): is a mathematical model of computation defined as a 5-tuple: `(Q, Σ, δ, q₀, F)`.; Lesson 1778 — DFA Definition and Components Lesson 1796 — NFA Acceptance: Existence of Accepting Path
Deterministic PDA (DPDA): , from any configuration (state, input symbol, stack top), there is *at most one* possible transition.; Lesson 1832 — Deterministic vs Nondeterministic PDAs
Development: "Does it compile?; Lesson 2391 — Deployment Pipelines and Stages
Development Team: isn't just a group of people assigned tasks by a manager.; Lesson 2376 — Scrum Roles: Development Team Lesson 2381 — Sprint Review
Device Management: Lesson 1206 — System Call Categories
DFA (Deterministic Finite Automaton): is like a machine that reads input one symbol at a time, following a strict set of rules.; Lesson 1780 — DFA Computation and Acceptance
DFA → NFA: Trivial.; Lesson 1801 — NFA-DFA Equivalence Theorem
DFA Minimization: Lesson 1949 — Optimizing Lexical Analyzers
DFA transition function: δ: Q × Σ → Q; Lesson 1793 — NFA Definition and Components
DFAs excel at implementation: A DFA has exactly one transition per symbol from each state—no choices, no guessing.; Lesson 1802 — Why Use NFAs: Design vs Implementation
DFS: on the level graph to push flow.; Lesson 1042 — Dinic's Algorithm Implementation
DFS-based sorting: visit every vertex and every edge exactly once.; Lesson 727 — Time and Space Complexity
Dialog control: (managing who can transmit when—like taking turns in conversation); Lesson 1437 — OSI Upper Layers: Session, Presentation, Application
Diameter candidate: longest path *through* that node (sum of two largest subtree heights); Lesson 946 — Tree Diameter via DP
Dictionary implementations: where alphabetical ordering matters; Lesson 502 — BST Advantages and Use Cases Lesson 619 — What is a Trie? Motivation and Use Cases
Dictionary words: "password" isn't 47 bits (8 random characters × 6 bits each)—it's one item from ~170,000 English words ≈ 17 bits; Lesson 2511 — Password Strength and Entropy
Difference (A − B): Shade A's circle, but exclude the overlap; Lesson 64 — Venn Diagrams
Different data models: Not everything fits in tables—social networks need graph databases, session storage needs key- value stores, and JSON documents need document databases.; Lesson 1708 — What is NoSQL and Why It Exists
Different structure: Not vulnerable to length-extension attacks that affect SHA-2; Lesson 2428 — SHA-3 and Keccak
Difficult fault isolation: When something breaks, it's hard to pinpoint which module is the culprit among many; Lesson 2236 — Big Bang Integration Strategy
Difficult maintenance: Understanding a 3,000-line class with dozens of methods is mentally exhausting; Lesson 2302 — God Object Anti-Pattern
Difficult naming: You can't give the class a clear, specific name without using "and" or "Manager" or "Helper"; Lesson 2331 — Large Class Smell
Difficult to reuse: You can't extract just the piece you need; Lesson 2338 — Divergent Change Smell
Diffie-Hellman: or **ECDH** to generate fresh session keys for each communication.; Lesson 2418 — Forward Secrecy
Diffie-Hellman is vulnerable: Key exchange security also relies on the discrete log problem; Lesson 2419 — Quantum Threats to Asymmetric Crypto
Diffie-Hellman solves this: by letting Alice and Bob each contribute their own private information, perform mathematical operations using public information, and arrive at the same shared secret—without ever sending that secret over the channel.; Lesson 2411 — Diffie-Hellman Key Exchange
Digit structure: Sort numbers digit-by-digit (Radix Sort); Lesson 787 — Breaking the O(n log n) Barrier
Digital: Mathematically bound to every byte of the document.; Lesson 2433 — Digital Signatures vs. Handwritten Signatures
digital certificate: (containing its public key).; Lesson 1525 — HTTPS Handshake Process Lesson 2445 — Digital Certificates and Certificate Authorities Lesson 2502 — Certificate-Based Authentication
digital certificates: (containing public keys).; Lesson 2442 — TLS: The Security Layer Behind HTTPS Lesson 2445 — Digital Certificates and Certificate Authorities
Digital forensics: Prove evidence files haven't been altered; Lesson 2429 — Hash Function Applications: Data Integrity
Digital Signature: The CA's cryptographic signature proving authenticity; Lesson 1532 — Digital Certificates Fundamentals Lesson 2432 — What are Digital Signatures?Lesson 2445 — Digital Certificates and Certificate Authorities
Digital signatures: Attackers could forge messages that produce the same hash; Lesson 2422 — Preimage Resistance (One-Wayness)
Digits: "0" is 48, "1" is 49.; Lesson 24 — ASCII: The Foundation
Dijkstra's: Explores nodes based purely on distance from source (`g(n)`); Lesson 1006 — A* vs Dijkstra's Algorithm
Dijkstra's with a compass: .; Lesson 1006 — A* vs Dijkstra's Algorithm
Dimension elimination: If one variable can be computed from others, don't store it; Lesson 955 — State Space Reduction
Dimensionality reduction: Finding simpler representations of complex data; Lesson 2788 — Unsupervised Learning: Finding Patterns Without Labels Lesson 2790 — Dimensionality Reduction Concepts Lesson 2871 — Handling High-Dimensional Data
Diminishing returns: Eventually, register overhead limits how fast you can actually clock; Lesson 1156 — Deeper Pipelines: Benefits and Costs
Direct access: Finding the status of block *n* is just a matter of checking bit *n*; Lesson 1403 — Free Space Management: Bitmaps
Direct all original edges: from left to right (capacity 1 each); Lesson 1047 — Maximum Bipartite Matching Algorithm
Direct Coding Methods: Lesson 1949 — Optimizing Lexical Analyzers
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
Direct modification: Changes to `num` affect `value` in `main()`; Lesson 321 — Reference Parameters in Functions
Direct-mapped: (1-way associative) is the simplest: fast lookup, cheap hardware, but suffers from conflict misses when multiple addresses map to the same slot.; Lesson 1134 — Comparing Associativity Tradeoffs Lesson 1144 — Types of Cache Misses: Conflict
direct-mapped caches: ?; Lesson 1130 — Fully Associative Caches Lesson 1132 — Set-Associative Caches
Directed: No symmetry required.; Lesson 678 — Directed vs Undirected Graph Storage Lesson 684 — Directed vs Undirected Graphs Lesson 719 — What is Topological Sorting?Lesson 721 — DAG Detection and Prerequisites Lesson 1749 — Relationships and Edge Properties
Directed Acyclic Graph (DAG): .; Lesson 663 — Cycles and Acyclic Graphs Lesson 1418 — Acyclic Graph Directories
Directed Acyclic Graphs (DAGs): are especially important—they represent dependencies, task scheduling, and compilation order where circular dependencies would be problematic.; Lesson 690 — Cyclic and Acyclic Graphs
directed graph: (also called a **digraph**), edges have a specific direction, shown with arrows.; Lesson 658 — Directed vs Undirected Graphs Lesson 661 — Degree of a Vertex Lesson 663 — Cycles and Acyclic Graphs Lesson 669 — Adjacency Matrix: Structure and Memory Lesson 678 — Directed vs Undirected Graph Storage Lesson 679 — Incidence Matrix Representation Lesson 684 — Directed vs Undirected Graphs Lesson 1022 — Flow Networks and Definitions (+1 more)
directed graphs: (where edges have arrows showing direction), we split degree into two types:; Lesson 661 — Degree of a Vertex Lesson 713 — Cycle Detection with DFS Lesson 714 — DFS on Directed vs Undirected Graphs
direction: of those connections matters tremendously.; Lesson 658 — Directed vs Undirected Graphs Lesson 684 — Directed vs Undirected Graphs Lesson 2077 — Stack Growth and Limitations
Director (optional): Orchestrates common construction sequences; Lesson 2270 — Builder Pattern for Complex Objects
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 Lesson 1695 — Dynamic Hash Indexes
Directory-based partitioning: takes a different approach: it maintains a separate **lookup table** (the "directory") that explicitly stores which partition holds each key or key range.; Lesson 2689 — Directory-Based Partitioning
dirty read: occurs when Transaction A reads data that Transaction B has modified but *not yet committed*.; Lesson 1661 — Read and Write Conflicts Lesson 1667 — Dirty Reads Problem
Dirty reads: Transaction A reads data that Transaction B modified but hasn't committed yet (and might rollback); Lesson 1660 — Isolation: Concurrent Transaction Independence Lesson 1666 — Read Uncommitted Isolation Level Lesson 1668 — Read Committed Isolation Level Lesson 1672 — Serializable Isolation Level
Disable directory listings: and use absolute paths internally; Lesson 2489 — Path Traversal and File Inclusion
Disadvantages: Lesson 1122 — Write-Through vs Write-Back Policies Lesson 1130 — Fully Associative Caches
Disallow: Best when keys represent unique identifiers (employee IDs, usernames); Lesson 499 — Handling Duplicate Keys
Disconnect the old tail: – Set the new tail's `next` pointer to `NULL`; Lesson 345 — Deleting from the Tail of a Doubly Linked List
Discover hidden structure: in unlabeled data; Lesson 2789 — Clustering Fundamentals
Discrete Logarithm Problem (DLP): is the *reverse*: given `g`, `p`, and the result `y = g^x mod p`, find the unknown exponent `x`.; Lesson 2412 — Discrete Logarithm Problem
discrete random variable: is a numerical outcome of a random process that can only take on **countable values**.; Lesson 121 — Discrete Random Variables Lesson 130 — Definition of Expected Value
Disk I/O optimization: Sequential reads and writes are much faster than random access; Lesson 807 — External Sorting for Large Datasets
Disk Storage: (bottom) — Huge capacity (terabytes) but millions of times slower; Lesson 1106 — The Memory Hierarchy Concept
Disk Storage (SSD/HDD): Lesson 1107 — Storage Pyramid Levels
Distance: Road networks where weights represent miles/kilometers; Lesson 659 — Weighted vs Unweighted Graphs Lesson 685 — Weighted and Unweighted Graphs
Distance from multiple sources: Multi-source BFS to find nearest exit/resource; Lesson 704 — BFS in Grid Graphs
Distance from source: to each vertex; Lesson 699 — Shortest Path in Unweighted Graphs
distance metrics: quantify similarity in different ways, and your choice fundamentally changes which neighbors get selected—and thus what predictions your model makes.; Lesson 2864 — Distance Metrics for KNN Lesson 2868 — Feature Scaling in KNN
Distance metrics become meaningless: Euclidean distance loses discriminative power when all pairwise distances converge to similar values; Lesson 2871 — Handling High-Dimensional Data
Distance to nearest exit: Given a grid with multiple exits, find each cell's distance to its closest exit; Lesson 702 — Multi-Source BFS
Distinct value counts: (how many unique values exist in a column); Lesson 1704 — Statistics and Histograms
distinguishable: (different).; Lesson 1788 — Distinguishable and Indistinguishable States Lesson 1789 — The Table-Filling Algorithm
Distribute: Place each element into the appropriate bucket based on its value; Lesson 795 — Bucket Sort: Partitioning the Range Lesson 796 — Bucket Sort: Implementation
Distributed Computing: Lesson 987 — Bellman-Ford vs Dijkstra Comparison
Distributed systems: Geographic replication makes full ACID extremely expensive.; Lesson 1665 — ACID Tradeoffs and Real-World Implications
Distribution: Place elements into buckets based on value ranges (Bucket Sort); Lesson 787 — Breaking the O(n log n) Barrier
Divergent Change: occurs when a single class frequently needs modification for different, unrelated reasons.; Lesson 2338 — Divergent Change Smell
Diverse workloads: Mix of integer math, floating-point calculations, memory access patterns, and branches; Lesson 1191 — Benchmark Programs and Performance Testing
Divide: Split your array into two roughly equal halves; Lesson 752 — Introduction to Mergesort Lesson 753 — The Divide-and-Conquer Strategy Lesson 825 — Median of Medians: Deterministic Selection Lesson 841 — Divide and Conquer Paradigm Overview Lesson 844 — Binary Search as Divide and Conquer Lesson 848 — Closest Pair of Points Lesson 1448 — Cyclic Redundancy Check (CRC)
Divide into chunks: Read as much data as fits in memory, sort it using any fast in-memory algorithm (like Quicksort), and write the sorted chunk back to disk.; Lesson 807 — External Sorting for Large Datasets
divide-and-conquer: break a big problem into smaller pieces, solve the smaller piece, and ignore the rest.; Lesson 251 — Binary Search: Efficient Searching in Sorted Arrays Lesson 643 — Building a Segment Tree
Divide-and-conquer algorithms: splitting data into multiple parts; Lesson 226 — Multiple Recursive Calls
Divide-and-conquer structure: (the log n part): They split the problem into smaller subproblems recursively, creating log n "levels" of division; Lesson 286 — O(n log n): Linearithmic Time
Dividing: O(1) — just finding the midpoint; Lesson 756 — Mergesort Time Complexity Analysis
Division (`/`): Divides the first number by the second; Lesson 154 — Arithmetic Operators
Division by zero: Only detected when that specific line executes; Lesson 2032 — Error Detection: Compile-Time vs Runtime
Django: Uses middleware that injects tokens and validates them automatically; Lesson 2473 — Implementing CSRF Protection
DNA alphabet: {A, C, G, T}; Lesson 1756 — Alphabets and Strings
DNS: Always returns *some* IP address, even if it's cached and slightly stale; Lesson 2606 — AP Systems: Availability and Partition Tolerance
DNS Security Extensions (DNSSEC): solves this by adding digital signatures to DNS records.; Lesson 1513 — DNS Security Concerns and DNSSEC Introduction
Do not: generate a token; Lesson 1945 — Handling Whitespace and Comments
Do work: perform calculations, make decisions, use loops; Lesson 185 — What is a Function?
Document assumptions: clearly so callers know their responsibilities; Lesson 205 — Parameter Type Checking and Validation
Document complex resolutions: Leave comments explaining non-obvious merge decisions; Lesson 2200 — Handling Merge Conflicts in Teams
Document FDs first: Write down all functional dependencies you discover before splitting tables; Lesson 1644 — Practical Normalization Process
Document stores: organize data as self-contained documents (typically JSON or XML).; Lesson 1709 — The Four Main NoSQL Categories Lesson 1715 — Choosing the Right NoSQL Category
Document your workflow: Team conventions only work if everyone follows them; Lesson 2193 — Branch Management Best Practices
Documentation: – Anyone reading your code immediately knows what types are expected; Lesson 2000 — Type Annotations in Static Languages Lesson 2224 — What is Unit Testing?
Does `DIAG(DIAG)` halt: Lesson 1881 — Constructing the Diagonal Argument
Does P = NP: Lesson 1892 — NP vs P: The Relationship
Doesn't prevent direct access: Advanced users can still interact with subsystem classes if needed; Lesson 2278 — Facade Pattern: Simplifying Complex Subsystems
DOM-Based XSS: occurs purely in the browser.; Lesson 2457 — DOM-Based XSS Attacks
domain: (the set of things x can be).; Lesson 47 — Universal Quantifier (∀)Lesson 51 — Translating English to Predicate Logic Lesson 67 — Relations as Sets of Ordered Pairs Lesson 76 — Definition and Notation of Functions Lesson 1552 — Tables, Rows, and Columns Lesson 1554 — Domains and Data Types Lesson 1613 — Attributes and Domains Lesson 1992 — Function Types
Domain Match: The certificate's Common Name (CN) or Subject Alternative Name (SAN) must match the domain you're visiting.; Lesson 2450 — Certificate Validation and Common Errors
Domain parameters: (p, q, g): shared public values where p is a large prime, q is a smaller prime divisor of p-1, and g is a generator; Lesson 2437 — DSA (Digital Signature Algorithm)
Domain-Appropriate: A chess board might use a bitboard (64-bit integers for piece positions) for speed, while a pathfinding grid could use coordinate tuples `(x, y)`.; Lesson 2731 — State Representation Strategies
Domain-specific features: Using your knowledge of the problem.; Lesson 2783 — Feature Engineering Basics Lesson 2836 — Feature Engineering for Logistic Regression
Domains: → SQL data types (`INTEGER`, `VARCHAR`, `DATE`); Lesson 1560 — From Relational Model to SQL
Don't: extract truly obvious values like `0` for array initialization or `1` for simple increments.; Lesson 2323 — Replace Magic Numbers with Named Constants
Don't need every packet: (streaming video—one dropped frame won't ruin your movie); Lesson 1486 — UDP Protocol Overview and Design Philosophy
Don't panic or force-push: Communicate with affected team members first; Lesson 2200 — Handling Merge Conflicts in Teams
Don't reuse variable names: in different scopes (avoid shadowing) unless you have a very good reason—it confuses readers.; Lesson 216 — Best Practices for Variable Scope
Done: No merge step needed—the array is sorted once recursion completes!; Lesson 762 — Quicksort: The Divide-and-Conquer Sorting Strategy Lesson 1628 — Closure of Attribute Sets
Dotted-decimal: is how humans configure and read them; Lesson 1461 — IPv4 Address Structure and Notation
double hashing: , when a collision occurs, instead of stepping forward by a fixed amount (like linear probing's +1, +2, +3.; Lesson 426 — Double Hashing Lesson 436 — Open Addressing Performance Characteristics Lesson 437 — Primary and Secondary Clustering Effects Lesson 1691 — Collision Handling in Hash Indexes
Double Submit Cookie Pattern: is a stateless CSRF protection technique that doesn't require server-side session storage.; Lesson 2469 — Double Submit Cookie Pattern Lesson 2473 — Implementing CSRF Protection
Doubling the data: only adds **one level** to the height; Lesson 581 — Height of a Binary Heap
doubly linked list: allows two-way traffic: each node has **two pointers**, one pointing to the next node and another pointing to the previous node.; Lesson 339 — Doubly Linked List Structure and Node Design Lesson 345 — Deleting from the Tail of a Doubly Linked List Lesson 449 — Implementing LRU Cache
Doubly Linked Lists: Lesson 348 — Doubly vs Singly Linked Lists: Tradeoffs
down: toward the leaves, just like extract.; Lesson 594 — Increase/Decrease Key Operations Lesson 595 — Delete Arbitrary Element Lesson 1294 — Wait (P) and Signal (V) Operations Lesson 1432 — The OSI Model: Seven-Layer Overview Lesson 1950 — Introduction to Top-Down Parsing
Downtown: All intersections connect to each other through one-way routes (one SCC); Lesson 734 — Strongly Connected Components in Directed Graphs
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)Lesson 592 — Extract Time Complexity
DPDA: You have a map with one clear route marked.; Lesson 1832 — Deterministic vs Nondeterministic PDAs
Draw: Lesson 2767 — Terminal States and Utility Functions
Draw transitions: based on how each new symbol updates that memory; Lesson 1781 — Designing Simple DFAs
Drawback: Wastes CPU time if the wait is long.; Lesson 1287 — Spin Locks vs Blocking Locks Lesson 1371 — LRU Implementation Techniques
Drawbacks: More message-passing overhead means performance can suffer compared to monolithic designs.; Lesson 1196 — Microkernel Architecture Lesson 1198 — Layered Operating System Structure Lesson 1368 — FIFO Page Replacement Lesson 2028 — Ahead-of-Time vs Just-in-Time Execution
Drug design: Protein folding simulations; Lesson 1912 — The Million Dollar Question
DRY: (Don't Repeat Yourself), ensure **consistency** across tests, and make **cleanup automatic**— preventing resource leaks or contaminated test environments.; Lesson 2229 — Test Fixtures and Setup
DS: (Data Segment): points to data; Lesson 1385 — Segmentation in x86 Architecture
dummy node: , so the actual data is in `head->next`.; Lesson 2571 — Lock-Free Queue: The Michael-Scott Algorithm Lesson 2579 — Concurrent Queue: Linked List Implementation
Duplicate Code: Repeated logic scattered across multiple places; Lesson 2329 — Introduction to Code Smells
Duplicate detection: finding the most duplicated records; Lesson 447 — Frequency Counting and Histograms Lesson 1476 — TCP Reliability: Retransmission
Duplicate operations: Payment processed twice because two nodes didn't know about each other's action; Lesson 2597 — Concurrency and Race Conditions
Duplicate Waits: Lesson 1302 — Semaphore Pitfalls and Common Errors
Duplication: Used for frequently-contested, small resources; Lesson 1164 — Resolving Structural Hazards Lesson 1490 — UDP Datagram Delivery and No Guarantees Lesson 2323 — Replace Magic Numbers with Named Constants Lesson 2592 — Message Loss and Ordering Lesson 2805 — Data Leakage Prevention
durability: guarantees committed changes persist even after crashes.; Lesson 1664 — Recovery Mechanisms and Durability Lesson 1733 — Replication in Key-Value Stores Lesson 2713 — Queue Persistence and Durability Lesson 2717 — What Are Distributed Transactions?
During a read: Memory places the data from the requested address into the MDR, and the CPU retrieves it from there; Lesson 1078 — Memory Address and Data Registers
During a write: The CPU places data into the MDR, which then gets written to the address specified in the MAR; Lesson 1078 — Memory Address and Data Registers
During BFS traversal: Lesson 699 — Shortest Path in Unweighted Graphs
During insertion: "This slot is available for reuse.; Lesson 427 — Deletion in Open Addressing
During search: "Keep probing—don't stop here.; Lesson 427 — Deletion in Open Addressing
During the algorithm: Lesson 997 — Path Reconstruction in Floyd-Warshall
Dynamic branch prediction: tracks the *history* of what each branch instruction actually did in the past and uses that history to predict what it will do next time.; Lesson 1177 — Dynamic Branch Prediction Basics
Dynamic hash indexes: solve this by allowing the hash table to grow incrementally.; Lesson 1695 — Dynamic Hash Indexes
Dynamic languages: must:; Lesson 2004 — Performance Implications of Type Systems
Dynamic loading: takes this further: not all code needs to be in memory from the start.; Lesson 1334 — Relocation and Dynamic Loading
Dynamic matrix: (e.; Lesson 311 — Analyzing Multi-Dimensional Space
Dynamic memory allocation: lets you request memory from the **heap** — a large, flexible pool — *while your program runs*.; Lesson 322 — Dynamic Memory Allocation Basics Lesson 1216 — Process Components: Memory Layout
Dynamic MST: Handle edge insertions/deletions efficiently.; Lesson 1021 — MST Applications and Variations
Dynamic programming: problems; Lesson 84 — Recurrence Relations Lesson 881 — Greedy vs Dynamic Programming Lesson 912 — Greedy vs Dynamic Programming Decision Lesson 940 — Unique Paths in Grid
Dynamic query construction: Building queries with unvalidated input (like sorting columns or table names) can introduce vulnerabilities, since these aren't always parameterizable.; Lesson 2481 — ORM and SQL Injection Protection
Dynamic relocation: happens continuously during execution using hardware support (like base registers you learned about).; Lesson 1334 — Relocation and Dynamic Loading
Dynamic resizing: (allocating a new, larger array when full); Lesson 381 — Dynamic Array-Based Queue
Dynamic routing protocols: allow routers to automatically discover network topology, share routing information with neighbors, and adapt to changes.; Lesson 1470 — Static vs Dynamic Routing Protocols
Dynamic Size: BSTs grow and shrink as needed.; Lesson 502 — BST Advantages and Use Cases
dynamic sorted data: .; Lesson 502 — BST Advantages and Use Cases Lesson 530 — When to Use BSTs
Dynamic typing: means types are checked **while the program runs** — at execution time.; Lesson 1997 — Static vs Dynamic Typing Overview Lesson 2006 — Choosing Between Static and Dynamic Typing
Dynamic updates: Change rules without redeploying applications; Lesson 2529 — Policy-Based Access Control
Dynamically: (during execution): The interpreter checks types as operations execute.; Lesson 1990 — Type Checking
DynamoDB: is Amazon's fully managed key-value and document store.; Lesson 1737 — Popular Key-Value Stores: Redis and DynamoDB

E

E ≈ V: (sparse).; Lesson 976 — Dijkstra's on Dense vs Sparse Graphs
E ≈ V²: (dense), and heap-based when **E ≈ V** (sparse).; Lesson 976 — Dijkstra's on Dense vs Sparse Graphs
E edges: , the algorithm visits every vertex once and explores every edge once.; Lesson 698 — BFS Time and Space Complexity
E[g(X)]: directly using the original distribution of **X**.; Lesson 131 — Expected Value of Functions
E[X²]: How far values are from zero on average (squared); Lesson 134 — Computing Variance from Moments
E2E tests: cover complete user journeys, from clicking "Sign Up" through receiving a welcome email.; Lesson 2247 — E2E Testing vs Integration Testing
Each iteration: Lesson 972 — Dijkstra's with Array-Based Priority Queue
Each server applies: committed entries to its state machine in log order; Lesson 2658 — The Replicated State Machine Model
Eager: Simple, always thread-safe, but potentially wasteful; Lesson 2266 — Singleton Thread Safety and Lazy Initialization
Eager Initialization: creates the instance when the class loads:; Lesson 2266 — Singleton Thread Safety and Lazy Initialization
Earley items: (also called states) that represent partially matched production rules at specific positions in the input string.; Lesson 1846 — Earley Parsing Algorithm
Earley parsing algorithm: is that solution.; Lesson 1846 — Earley Parsing Algorithm
early: .; Lesson 865 — Pruning and Optimization Lesson 1985 — What is a Type System?
Early bug detection: – Catch errors immediately when you write new code; Lesson 2224 — What is Unit Testing?
Early error detection: – Type mismatches are caught before the program runs; Lesson 2000 — Type Annotations in Static Languages
Early optimizations: work on high-level IR or ASTs (constant folding, dead code elimination); Lesson 2060 — Optimization Phases and Safety
Early problem detection: Impediments surface immediately, not days later; Lesson 2380 — Daily Scrum (Stand-up)
Early returns: exit a function as soon as you know the answer.; Lesson 174 — Common Conditional Patterns Lesson 2087 — Memory Leaks: Causes and Detection
Early Termination: If a complete pass happens without any swaps, the list is already sorted—stop immediately.; Lesson 743 — Bubble Sort: Optimization
Early value delivery: Stakeholders see progress immediately, not just promises; Lesson 2363 — Working Software Over Comprehensive Documentation
Ease maintenance: Fix a bug once in the procedure, not in every copy; Lesson 2118 — Procedural Abstraction
Easier auditing: Security teams can review all policies without reading application code; Lesson 2529 — Policy-Based Access Control
Easier optimization: The VM can optimize bytecode execution; Lesson 2033 — Bytecode Compilation: The Hybrid Approach
Easier to analyze: for logical equivalence; Lesson 57 — Prenex Normal Form
Easier to debug: If something breaks, you know exactly where to look; Lesson 193 — Single Responsibility Principle
Easier to name: A function doing one task has a clear, descriptive name; Lesson 193 — Single Responsibility Principle
Easier to reuse: Small, focused functions can be used in multiple places; Lesson 193 — Single Responsibility Principle
Easier to revert: if something breaks, you know exactly what caused it; Lesson 2342 — Preparing Code for Review
Easier to test: You only need to verify one behavior per function; Lesson 193 — Single Responsibility Principle
Easier to understand: reviewers grasp the context immediately; Lesson 2342 — Preparing Code for Review
Easy evolution: Add new fields to new documents without altering existing ones; Lesson 1718 — Document Database Model
Easy to compute: in one direction (given input x, computing f(x) is fast); Lesson 2407 — Trapdoor Functions
Easy to verify: Given a proposed selection, you can quickly check if it fits and reaches the target value; Lesson 1924 — The Knapsack Problem
EAT: = 0.; Lesson 1364 — Effective Access Time with Paging
ECC is vulnerable: Elliptic curve discrete logs fall just as quickly; Lesson 2419 — Quantum Threats to Asymmetric Crypto
ECDH: (Elliptic Curve Diffie-Hellman) and **ECDSA** (Elliptic Curve Digital Signature Algorithm) are simply elliptic curve variants of classic cryptographic protocols.; Lesson 2415 — ECDH and ECDSA Lesson 2418 — Forward Secrecy
ECDSA: (Elliptic Curve Digital Signature Algorithm) are simply elliptic curve variants of classic cryptographic protocols.; Lesson 2415 — ECDH and ECDSA
edge: is the link or connection between a parent node and one of its children.; Lesson 452 — Leaves, Internal Nodes, and Edges Lesson 657 — What is a Graph? Vertices and Edges Lesson 717 — DFS Time Complexity Analysis
Edge cases: are unusual inputs that might break your code: empty values, zero, negative numbers, or boundary values.; Lesson 174 — Common Conditional Patterns
Edge classification: Lesson 714 — DFS on Directed vs Undirected Graphs
edge list: is the most straightforward way to represent a graph: you literally just list out every edge.; Lesson 676 — Edge List Representation Lesson 681 — Representation Trade-offs for Common Operations
Edge updates: After adding a vertex, update its neighbors → O(E) total across all iterations; Lesson 1019 — Prim's Algorithm: Time Complexity Analysis
Edge updates (decrease-key): Each of E edges might trigger an update at O(log V) = O(E log V); Lesson 1019 — Prim's Algorithm: Time Complexity Analysis
Edge-centric operations: like filtering connections by weight; Lesson 676 — Edge List Representation
Edges: A→ B, A→ C, B→ D (three connections total); Lesson 452 — Leaves, Internal Nodes, and Edges Lesson 657 — What is a Graph? Vertices and Edges Lesson 683 — Hybrid and Compressed Representations Lesson 979 — Practical Applications of Dijkstra's Algorithm Lesson 1713 — Graph Database Fundamentals Lesson 1746 — Graph Database Model and Use Cases Lesson 1749 — Relationships and Edge Properties Lesson 1754 — Social Network and Recommendation Queries (+3 more)
Edges (E): Each edge is examined exactly once to check adjacency or reduce in-degrees.; Lesson 727 — Time and Space Complexity
Edges array: Stores all destination vertices in order; Lesson 683 — Hybrid and Compressed Representations
Edges with capacities: (maximum flow each edge can carry); Lesson 1034 — Maximum Flow Problem Definition
Edit the content: to keep what you want—delete one version, keep both, or write something new; Lesson 2188 — Resolving Merge Conflicts
Effect: Keys with *different* hash values end up competing for the same probe sequence, exponentially degrading performance as load factor increases.; Lesson 437 — Primary and Secondary Clustering Effects
effective access time: the average time it takes to retrieve data:; Lesson 1138 — Cache Hit and Miss Definitions Lesson 1364 — Effective Access Time with Paging
Effective Access Time (EAT): , and it combines the best-case scenario (cache hit) with the worst-case (cache miss) weighted by how often each occurs.; Lesson 1115 — Effective Access Time Calculation Lesson 1364 — Effective Access Time with Paging
Efficiency: For large data structures, passing a reference avoids copying huge amounts of data; Lesson 203 — Pass-by-Reference Semantics Lesson 228 — Converting Tail Recursion to Iteration Lesson 1195 — Monolithic Kernel Architecture Lesson 1251 — Context Switch Overhead Lesson 1280 — Mutual Exclusion Problem Lesson 1349 — Shared Memory via Virtual Memory Lesson 1530 — Symmetric vs Asymmetric Encryption in TLS Lesson 2163 — The Cut Operator (!)
Efficiency through avoidance: If you compute a value but never use it, you've wasted CPU cycles.; Lesson 2139 — Lazy Evaluation
Efficient: Enqueue and dequeue remain O(1).; Lesson 379 — Circular Queue Concept Lesson 2811 — L1 Regularization (Lasso)
Efficient cloning: Creating a copy of a file just means duplicating metadata pointers — no actual data copying until modifications occur.; Lesson 1408 — Copy-on-Write File Systems
Efficient combine step: After solving subproblems, you must be able to merge their solutions into the final answer relatively quickly (ideally in linear time or better).; Lesson 855 — When to Use Divide and Conquer
Efficient execution: Direct manipulation of state without abstraction overhead; Lesson 2121 — Imperative Style Tradeoffs
Efficient navigation: Parent and child relationships follow simple arithmetic formulas (parent at index i, children at 2i+1 and 2i+2); Lesson 576 — Complete Binary Tree Property
Efficient Operations: When balanced, BSTs provide O(log n) time for search, insert, and delete.; Lesson 502 — BST Advantages and Use Cases
Efficient Random Access: Unlike linked allocation (lesson 1400) where you had to traverse a chain of pointers, indexed allocation lets you access any part of the file immediately—just consult the index.; Lesson 1401 — File Allocation Methods: Indexed
Efficient search: Navigate directly via paths instead of scanning flat lists; Lesson 1414 — Tree-Structured Directories
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
either: line in set 1.; Lesson 1135 — Cache Placement Example Calculations Lesson 1786 — DFAs for Union of Languages
Elect a Root Bridge: All switches exchange Bridge Protocol Data Units (BPDUs) to elect one switch as the "root" (typically the one with the lowest Bridge ID); Lesson 1458 — Spanning Tree Protocol (STP)
Electrical/optical signals: Converting bits into voltage changes, light pulses, or radio frequencies; Lesson 1433 — OSI Layer 1: Physical Layer
Electrical/optical specifications: What voltage represents a "1" vs.; Lesson 1441 — Physical Layer Overview
Eliminate extraneous attributes: Check if removing an attribute from the left side still allows the FD to hold (using closure); Lesson 1629 — Minimal Cover and Canonical Cover
Eliminate implications: using logical equivalences (A → B becomes ¬A ∨ B); Lesson 57 — Prenex Normal Form
Eliminates Conditionals: No sprawling `if-else` or `switch` statements; Lesson 2287 — Strategy Pattern Fundamentals
Eliminates loop boilerplate: no index variables or mutation; Lesson 2151 — Declarative Data Transformation
Elliptic Curve Cryptography (ECC): uses a different mathematical structure: equations of the form `y² = x³ + ax + b` evaluated over finite fields (like modulo arithmetic you've already seen).; Lesson 2414 — Elliptic Curve Cryptography Basics
Embed documents when: Lesson 1720 — Document Structure and Nesting
Embedded in the page: (usually as a hidden form field or custom HTTP header); Lesson 2467 — CSRF Token Defense
Employees: table:; Lesson 1556 — Foreign Keys and References
Emptiness: Does the language contain any strings at all?; Lesson 1811 — Decision Properties of Regular Languages
empty: , both `head` and `tail` are `NULL`; Lesson 330 — Maintaining a Tail Pointer Lesson 380 — Circular Queue Implementation Details Lesson 392 — Deque Array Implementation Lesson 1298 — Producer-Consumer Problem with Semaphores
Empty heap operations: What happens when someone calls `extract_max()` on an empty heap?; Lesson 600 — Practical Heap Implementation Considerations
Empty inputs: Empty strings, empty arrays, or null values.; Lesson 2228 — Testing Edge Cases and Boundaries
Empty language: `∅` (not the same as `{ε}`!; Lesson 1765 — Language Specifications and Notation
Empty list: Nothing to delete; Lesson 334 — Deleting a Specific Node Lesson 337 — Finding the Middle Node Lesson 345 — Deleting from the Tail of a Doubly Linked List
empty string: is a string containing zero characters.; Lesson 1757 — The Empty String and String Length Lesson 1765 — Language Specifications and Notation
Empty, specifying only size: Lesson 233 — Array Declaration and Initialization
Enable two-factor authentication: on your password manager itself; Lesson 2515 — Password Managers and Best Practices
Enables: Constant propagation and dead code elimination.; Lesson 2072 — Dataflow Analysis for Optimization
Enables further optimizations: simplifying expressions can reveal dead code or invariant conditions; Lesson 2061 — Constant Folding
Enables optimization: the runtime can parallelize or optimize under the hood; Lesson 2151 — Declarative Data Transformation
Encapsulation: Hide complexity behind a clean interface; Lesson 355 — What is an Abstract Data Type (ADT)?Lesson 1440 — Encapsulation and Layer Communication Lesson 2125 — Constructors and Initialization
Encoding mismatches: typically occur when:; Lesson 30 — Common Encoding Issues
Encoding schemes: How to represent binary 0 and 1 as physical signals; Lesson 1433 — OSI Layer 1: Physical Layer
Encouraging simpler patterns: Models learn only the strongest, most generalizable relationships; Lesson 2810 — Introduction to Regularization
Encryption: Simple XOR ciphers use this operator to scramble data; Lesson 35 — Exclusive OR (XOR)Lesson 2413 — ElGamal Encryption System Lesson 2442 — TLS: The Security Layer Behind HTTPS
Encryption Algorithm: – What symmetric cipher encrypts the data (e.; Lesson 1536 — TLS Cipher Suites
Encryption and decryption: (securing data before transmission); Lesson 1437 — OSI Upper Layers: Session, Presentation, Application
End position: (or length): Where it stops or how many characters to take; Lesson 266 — Substring Extraction
End-entity certificate: The actual website's certificate (e.; Lesson 1533 — Certificate Authorities and Trust Chains
End-of-Word Marker: A boolean flag indicating whether a complete word ends at this node; Lesson 620 — Trie Node Structure and Components
End-to-end tests: simulate real workflows through the entire system.; Lesson 2217 — The Testing Pyramid
Endianness: describes the order in which bytes are arranged in memory:; Lesson 29 — Byte Order Marks and Endianness
Enforce: integrity constraints you learned about; Lesson 1561 — SQL Introduction and Purpose
Enforce associativity: For left-associative operators, make the recursive production place the non-terminal on the *left* side of the operator.; Lesson 1839 — Resolving Ambiguity: Grammar Rewriting
Enforce linear history: Require rebase or squash merges to keep history clean—no messy merge commits cluttering `main`.; Lesson 2201 — Branch Protection and Policies
Enforce the protocol: A process holding resource `i` may only request resource `j` where `j > i`; Lesson 1322 — Deadlock Prevention: Breaking Circular Wait
English lowercase: {a, b, c, .; Lesson 1756 — Alphabets and Strings
Enqueue: A new car joins the back of the line; Lesson 376 — Essential Queue Operations Lesson 379 — Circular Queue Concept Lesson 383 — Queue Operation Complexity Analysis Lesson 2571 — Lock-Free Queue: The Michael-Scott Algorithm Lesson 2578 — Concurrent Queue: Array-Based Implementation Lesson 2579 — Concurrent Queue: Linked List Implementation Lesson 2580 — Lock-Free Queue with CAS
Enqueue (add to rear): Lesson 378 — Array-Based Queue Implementation Lesson 382 — Linked List-Based Queue Implementation
Enqueue (Add): Lesson 376 — Essential Queue Operations
Enrolls: Lesson 1615 — Relationships and Relationship Sets
Ensemble learning: applies this same principle to machine learning models.; Lesson 2853 — Introduction to Ensemble Learning
Ensure quality control: through a single process; Lesson 2264 — Introduction to Creational Patterns
Ensures Testability: Lesson 2257 — Writing Tests Before Implementation
Ensuring consistency: Merging concurrent updates to replicated data; Lesson 2598 — Lack of Global Clock
Entities: Things you want to store data about (like `Customer`, `Order`, `Product`); Lesson 1611 — Introduction to Entity-Relationship (ER) Modeling
Entities with many relationships: (social networks, recommendation engines) → **Graph databases**; Lesson 1715 — Choosing the Right NoSQL Category
Entity integrity: means that every row in a table must be uniquely identifiable and actually exist.; Lesson 1557 — Relational Integrity Constraints
entropy: measures unpredictability in bits.; Lesson 2511 — Password Strength and Entropy Lesson 2839 — Classification vs Regression Trees Lesson 2842 — Impurity Measures: Entropy Lesson 2844 — Impurity Measures: Gini Index Lesson 2845 — Splitting Criteria for Regression Trees
Entry point: The very first instruction of the program or procedure; Lesson 2043 — Basic Blocks and Leaders
Enums: or **algebraic data types** (Rust, Haskell, ML); Lesson 1988 — Composite Types: Sums
environment: a mapping from variable names to their current values.; Lesson 2023 — Semantics of Variable Assignment and State Lesson 2792 — Reinforcement Learning Overview
Environment attributes: time of day, location, network security level, threat level; Lesson 2528 — Attribute-Based Access Control (ABAC)
Environment extension: creating a new scope with those bindings; Lesson 2025 — Function Call Semantics
Environment management: (dev/staging/prod); Lesson 2394 — CI/CD Tools and Infrastructure
Environment Variables: Configure connection strings, API keys, and feature flags to point to test resources, not production ones.; Lesson 2250 — Setting Up the Test Environment
Ephemeral keys: are temporary, generated fresh for each TLS session and then discarded; Lesson 1537 — Perfect Forward Secrecy Lesson 2418 — Forward Secrecy
ephemeral ports: (49152–65535) as source ports for outgoing connections.; Lesson 1483 — TCP Port Numbers and Multiplexing Lesson 1488 — UDP Port Numbers and Multiplexing
equal: if and only if they contain exactly the same elements.; Lesson 59 — Special Sets and Set Equality Lesson 171 — Comparison Operators in Conditions
Equal counts: strings with the same number of `a`s and `b`s; Lesson 1777 — Limitations of Regular Expressions
Equal terms: Normal processing continues.; Lesson 2660 — Terms and the Logical Clock in Raft
Equal to: `==` — "Are these two values the same?; Lesson 157 — Comparison Operators
Equal to pivot: (elements == pivot); Lesson 772 — Three-Way Partitioning for Duplicate Keys
Equivalence classes never overlap: (if two classes share any element, they're actually the same class); Lesson 73 — Equivalence Classes and Partitions
equivalent: if they describe the same set of strings—that is, if they define the same language.; Lesson 1776 — Regular Expression Equivalence Lesson 1787 — Minimizing States in DFAs
Error: Lesson 1962 — Shift-Reduce Parsing Actions Lesson 1966 — LR(0) Parsing Tables
Error checking: Spotting when transmitted data has changed; Lesson 17 — The XOR Gate (Exclusive OR)
Error detection: XOR helps identify corrupted bits in data transmission; Lesson 35 — Exclusive OR (XOR)Lesson 1445 — Data Link Layer Responsibilities
Error handling: when one module fails; Lesson 2234 — What is Integration Testing?
Error Productions: Lesson 1972 — LR Parser Error Recovery
Error recovery: If something goes wrong, changes can be undone automatically; Lesson 1654 — Introduction to Database Transactions
Error signaling: Throw an exception, return an error code, or use a special sentinel value; Lesson 358 — Pop Operation
Error-based: Forces the database to produce error messages that reveal data; Lesson 2476 — Types of SQL Injection Attacks
ES, FS, GS: extra segments for additional data; Lesson 1385 — Segmentation in x86 Architecture
Establish the base case: When is the problem so small it's trivial to solve?; Lesson 866 — Problem Decomposition in Recursion
established: ready to transfer data reliably.; Lesson 1473 — TCP Three-Way Handshake Lesson 1482 — TCP States and State Machine Lesson 1544 — TCP Client: Connect to Server
Establishing foreign keys: – Keep the determining attribute in the original table as a foreign key reference; Lesson 1639 — Achieving Third Normal Form
Estimate each plan's cost: using formulas like:; Lesson 1699 — Cost-Based Query Optimization
Estimated cost to goal: (a heuristic guess about remaining distance); Lesson 1000 — Introduction to A* Search
etcd: , and **Consul** explicitly choose CP behavior because they coordinate critical cluster state— consistency matters more than temporary unavailability.; Lesson 2605 — CP Systems: Consistency and Partition Tolerance Lesson 2622 — Consistency in Practice: Examples
Euclidean: works well when all features are equally scaled and contribute smoothly; Lesson 2864 — Distance Metrics for KNN
Euclidean distance: for grid pathfinding (straight-line distance is never longer than any actual path); Lesson 1003 — Admissible Heuristics Lesson 2863 — KNN: Distance-Based Classification and Regression
Euclidean distance heuristic: measures the straight-line distance between two points in continuous space, just like measuring the "as-the-crow-flies" distance on a map.; Lesson 2757 — Euclidean Distance Heuristic
Evaluate performance: Calculate how many examples were misclassified; Lesson 2858 — AdaBoost Algorithm
Evaluation metrics: Classification uses accuracy, precision, recall; regression uses RMSE, MAE, R²; Lesson 2781 — Classification vs Regression Problems
Evaluation metrics differ: Accuracy, precision for classification; MSE, R² for regression; Lesson 2839 — Classification vs Regression Trees
Evaluation step: evaluate body in extended environment; Lesson 2025 — Function Call Semantics
Even count: Exclude the negative with smallest absolute value to flip sign; Lesson 898 — Minimum Product Subset
Even length: two-character center (like "abba" centers between 'b' and 'b'); Lesson 936 — Longest Palindromic Substring
Even-length lists: Convention typically returns the second middle node; Lesson 337 — Finding the Middle Node
Even/Odd Checking: One classic example determines if a number is even or odd:; Lesson 875 — Mutual Recursion
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 Lesson 119 — Probability in Algorithm Analysis
Event Sourcing: treats every state change as an immutable event appended to a log.; Lesson 2725 — Alternatives: Event Sourcing and CQRS
Event-driven by nature: UI clicks, sensor readings, or data updates trigger cascades; Lesson 2153 — Reactive Programming Fundamentals
Events are concurrent: if neither vector is less-than-or-equal to the other; Lesson 2631 — Vector Clocks Fundamentals
Eventual consistency: trade-offs (CAP theorem choices); Lesson 1717 — NoSQL vs SQL: Complementary Approaches Lesson 1734 — Eventual Consistency Trade-offs Lesson 1736 — Key-Value Store Use Cases Lesson 2615 — Read-Your-Writes Consistency Lesson 2617 — Monotonic Write Consistency Lesson 2621 — Consistency vs Availability Tradeoffs Lesson 2624 — Choosing the Right Consistency Model Lesson 2697 — Eventual Consistency Definition and Motivation (+2 more)
every: student passed.; Lesson 49 — Negating Quantified Statements Lesson 1618 — Participation Constraints: Total vs Partial
Every computational model discovered: (lambda calculus, recursive functions, quantum computers, neural networks) has proven equivalent to Turing Machines in what they can compute; Lesson 1867 — Implications and Universal Acceptance
Every future request: repeats step 4; Lesson 2499 — Authentication Protocols: Basic Auth
Every process: suffers internal fragmentation in its last page (on average, half a page wasted); Lesson 1356 — Internal Fragmentation in Paging
Evolution: The backlog never stops changing.; Lesson 2377 — Scrum Artifacts: Product Backlog
EX → EX: The ALU result from one instruction's Execute stage forwards directly to the next instruction's Execute stage (most common); Lesson 1170 — Forwarding Paths and Limitations
exact-match lookups: .; Lesson 1693 — Range Query Limitations Lesson 1696 — Hash Indexes in Practice
Exact-match queries only: Hash indexes excel at `WHERE id = 42`, but fail at range queries like `WHERE id > 42`; Lesson 1692 — O(1) Lookup with Hash Indexes
exactly one: starting point will work, and our greedy elimination finds it.; Lesson 893 — Gas Station Circuit Problem Lesson 2091 — Ownership and Lifetime Management
Examine non-key attributes: Can any be determined by knowing *just one part* of the key?; Lesson 1635 — Partial Dependencies Explained
Example (Counter Method): Lesson 701 — Level-Order Traversal
Example (using 4-bit numbers): Lesson 11 — Two's Complement Arithmetic
Example 1: "It is NOT true that (I'm hungry AND tired)" means "I'm NOT hungry OR I'm NOT tired" (at least one condition fails).; Lesson 41 — De Morgan's Laws Lesson 71 — Properties of Relations: Transitivity
Example 1 (Injective): Consider the function `f: {1, 2, 3} → {a, b, c, d}` where:; Lesson 77 — Function Properties: Injective (One-to-One)
Example 2: "It is NOT true that (the door is open OR the window is open)" means "the door is NOT open AND the window is NOT open" (both must be closed).; Lesson 41 — De Morgan's Laws Lesson 71 — Properties of Relations: Transitivity
Example 2 (Not Injective): Consider `g: {1, 2, 3} → {x, y}` where:; Lesson 77 — Function Properties: Injective (One-to-One)
Example 3: R = {(1,1), (2,2), (3,3)} (reflexive relation); Lesson 71 — Properties of Relations: Transitivity
Example analogy: Finding a route through a small town (hundreds of intersections) versus navigating the entire global road network (billions of segments).; Lesson 2735 — State Space Size and Complexity
Example concepts: Lesson 2133 — First-Class and Higher-Order Functions
Example cycle: Lesson 1317 — Detecting Cycles in Resource Allocation Graphs
Example flow: Lesson 162 — Type Conversion in Expressions Lesson 1208 — System Call Parameters and Return Values Lesson 2725 — Alternatives: Event Sourcing and CQRS
Example hierarchy: Lesson 2527 — RBAC Hierarchies
Example of violations: Lesson 1632 — First Normal Form (1NF) Definition
Example pattern: Lesson 182 — The Break Statement
Example pitfall: Forgetting to check if `n == 0` when computing a factorial, so it keeps calling itself with negative numbers indefinitely.; Lesson 231 — Common Recursion Pitfalls
Example scenario: Lesson 1170 — Forwarding Paths and Limitations Lesson 1227 — Process Waiting: wait() and waitpid()Lesson 1586 — Three-Table Joins Lesson 1634 — Second Normal Form (2NF) Definition Lesson 1971 — Conflict Resolution in LR Parsing Lesson 2182 — Understanding Git Branches Lesson 2589 — Network Partitions and Split-Brain
Example simplification: Lesson 1776 — Regular Expression Equivalence
Example skeleton: Lesson 89 — Inductive Step: The Core Argument
Example structure: Lesson 86 — The Principle of Mathematical Induction Lesson 1720 — Document Structure and Nesting
Example thinking: "I want to add the number 42 at index 2, so I need to move everything from index 2 onward one spot to the right first.; Lesson 239 — Common Array Operations
Example tree: Lesson 578 — Heap Order Property: Max-Heap
Example use: Java bytecode retains classes and methods, making it portable across platforms.; Lesson 2038 — High-Level vs Low-Level IR
Example walkthrough: Lesson 277 — Analyzing Conditional Statements Lesson 747 — Insertion Sort: Algorithm
Example with even parity: Lesson 1447 — Error Detection with Parity and Checksums
Example: Binary Search (Recursive): Lesson 308 — Recursion and Call Stack Space
Example: Factorial: Lesson 308 — Recursion and Call Stack Space
Examples of propositions: Lesson 31 — Propositions and Truth Values
Exception behavior: Errors occur at the same program points; Lesson 2060 — Optimization Phases and Safety
Exception/error paths: Forgetting to free on all code paths through a function.; Lesson 2087 — Memory Leaks: Causes and Detection
Exchange: the optimal solution's choice with the greedy choice at that position; Lesson 906 — Proof by Exchange Argument Lesson 2557 — Atomic Operations
exchange argument: is a proof technique that validates greedy algorithms.; Lesson 883 — Exchange Arguments for Correctness Lesson 906 — Proof by Exchange Argument Lesson 907 — Proving Activity Selection Correctness
Exchange Arguments: Show that if an optimal solution differs from the greedy choice, you can "exchange" elements to make it more like the greedy solution without losing optimality.; Lesson 903 — Introduction to Greedy Correctness Proofs
Exchange property: If you have two independent sets where one is larger, you can add an element from the larger set to the smaller one while maintaining independence; Lesson 910 — Matroid Theory and Greedy Algorithms
Exclude: the element → recurse to the next element without adding it; Lesson 859 — Generating All Subsets Lesson 945 — Maximum Independent Set on Trees
Exclude it: Keep current capacity for other items; Lesson 930 — 0/1 Knapsack Problem Lesson 945 — Maximum Independent Set on Trees
excluding: `node`; Lesson 945 — Maximum Independent Set on Trees Lesson 948 — DP on Binary Trees
Exclusive + Exclusive: Incompatible (writers block each other); Lesson 1662 — Locking Mechanisms for Isolation
Exclusive locks: (write locks) grant one process sole access to modify a file.; Lesson 1393 — File Locking Mechanisms
Exclusive Locks (Write Locks): Lesson 1662 — Locking Mechanisms for Isolation
Exclusive OR (XOR): is more selective: it returns true only when *exactly one* operand is true, but *not both*.; Lesson 35 — Exclusive OR (XOR)
Execute: Generate control signals that coordinate other components—telling the ALU which operation to perform, directing the memory unit to read or write data, or updating registers; Lesson 1073 — The Control Unit Lesson 1074 — Program Counter (PC)Lesson 1075 — Instruction Register (IR)Lesson 1081 — What is the Instruction Cycle?Lesson 1089 — Instruction Cycle Timing Lesson 1148 — Introduction to Instruction Pipelining Lesson 1172 — Control Hazards: Branch Impact Lesson 2030 — Interpreter Execution Cycle: Parse and Execute (+1 more)
Execute (EX): Lesson 1149 — The Classic Five-Stage Pipeline
Execute (x): Run a file as a program, or enter a directory; Lesson 1392 — File Permissions and Access Control
Execute and Store: When a command executes, push it onto the undo stack; Lesson 2292 — Command Pattern for Undo/Redo
Execute bit: Can the CPU treat bytes here as instructions?; Lesson 1348 — Memory Protection with Virtual Memory
Execute operations: Write your changes (INSERT, UPDATE, DELETE); Lesson 1656 — Commit and Rollback Operations
execute stage: where the actual work happens.; Lesson 1086 — The Execute Stage Lesson 1169 — Data Forwarding (Bypassing)
Execution: When a victim views the compromised page, their browser executes the injected script; Lesson 2454 — What is Cross-Site Scripting (XSS)?
Execution Order: Operations nest or sequence.; Lesson 1705 — Reading and Analyzing EXPLAIN Output
Execution speed: Some instructions execute faster than others; Lesson 2053 — Instruction Selection Lesson 2059 — Optimization Goals and Tradeoffs
Execution state: which instruction is running, register values, program counter; Lesson 1215 — What is a Process?
Exhaustive search won't scale: beyond small inputs; Lesson 1937 — Practical Applications of Reductions
Exhaustiveness checking: The compiler ensures you've handled all possible cases; Lesson 2141 — Pattern Matching
Existential forgery attacks: exploit weaknesses in implementation.; Lesson 2441 — Digital Signature Security Considerations
Exists in every alphabet: No matter which alphabet you define, ε is always a valid string over that alphabet; Lesson 1757 — The Empty String and String Length
EXP: , the class of problems solvable in *exponential time*.; Lesson 1894 — The Class EXP (Exponential Time)
Expand: Mark the new node as visited and push *all its edges* into the heap.; Lesson 1018 — Prim's Algorithm: Priority Queue Implementation
Expand nonterminals: In `q_loop`, for each production `A → w`, pop `A` and push `w` in reverse order (ε-transition, no input consumed); Lesson 1836 — Converting CFGs to PDAs
Expected height: ~1.; Lesson 524 — Average-Case BST Performance
Expected Output: What correct behavior should produce; Lesson 2219 — Test Cases and Test Suites
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
Expected result: Lesson 1271 — Demonstrating Race Conditions with Shared Counters
Expected space complexity: O(log n); Lesson 773 — Space Complexity and Tail Recursion
Expected value: tells you the *average* performance across all possible random outcomes.; Lesson 137 — Expected Value and Variance in Algorithm Analysis Lesson 2773 — Stochastic Games and Expectiminimax
Expectiminimax: extends minimax by adding a third type of node to your game tree:; Lesson 2773 — Stochastic Games and Expectiminimax
expensive: Lesson 1337 — Memory Compaction Lesson 2611 — Strong Consistency (Linearizability)
Expensive reads: If reads take significant time, allowing concurrency among readers improves throughput; Lesson 2563 — Read-Write Locks
Expert labeling: Expensive but accurate (doctors, lawyers, specialists); Lesson 2794 — Label Quality and Acquisition
Expiration Check: Certificates have validity periods (not-before and not-after dates).; Lesson 2450 — Certificate Validation and Common Errors
Expired Certificate: The certificate's validity period has passed.; Lesson 2450 — Certificate Validation and Common Errors
Explaining confusing logic: If you need comments to clarify what code does, refactor it with better names instead; Lesson 2312 — Comments: When and How to Use Them
Explaining intent: When the *why* matters more than the *how*; Lesson 2322 — Extract Variable: Explaining Complex Expressions
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 state spaces: have all their states pre-enumerated and stored.; Lesson 2736 — Explicit vs Implicit State Spaces
Explicit step-by-step instructions: describing the computation process; Lesson 2112 — What is Imperative Programming?
Explicit waits: are targeted: "Wait for *this specific condition* to be true.; Lesson 2252 — Handling Asynchronous Operations
Explicitly: Using an actual stack data structure (iterative DFS); Lesson 709 — DFS Overview and Intuition
Explicitly declare encoding: in files, HTML headers, and database connections; Lesson 30 — Common Encoding Issues
Exploitation: The script can steal cookies (including session tokens), redirect users to phishing sites, or modify page content; Lesson 2454 — What is Cross-Site Scripting (XSS)?
Exploratory work or spikes: Test-after lets you experiment freely.; Lesson 2223 — When to Write Tests
Explore: Recursively continue building from this choice; Lesson 857 — Backtracking Template Pattern Lesson 858 — Generating All Permutations
explored sets: only tell you which states you've visited, not the exact sequence from initial state to goal.; Lesson 2738 — Solution Extraction and Path Reconstruction Lesson 2739 — Uninformed Search Overview
Exponent field: Several bits storing the power of 2 (not 10); Lesson 1064 — Floating-Point Representation Overview
Exponential: `2ⁿ` — explodes rapidly; Lesson 278 — Growth Rates and Dominant Terms
Exponential algorithms: (not in P): O(2ⁿ), O(n!; Lesson 1899 — The Class P: Polynomial Time
Exponential growth: For each ACK received, increase cwnd by one segment; Lesson 1478 — TCP Congestion Control: Slow Start
Exponential search for bounds: Start at index 0 and keep doubling your position (1, 2, 4, 8, 16.; Lesson 818 — Binary Search on Infinite Arrays
Exponentiation → Multiplication: `x ** 2` becomes `x * x`; Lesson 2067 — Strength Reduction
Express the larger problem: in terms of one or more smaller instances of the same problem; Lesson 225 — Recursive Problem Decomposition
Express.js: Libraries like `csurf` middleware handle token generation; Lesson 2473 — Implementing CSRF Protection
Extend short runs: If a run is too small (below a minimum threshold called `minrun`, typically 32-64 elements), extend it using **insertion sort**—which is fast on small, nearly-sorted data.; Lesson 802 — Timsort: Python's Default Sorting Algorithm
Extendable Output Functions (XOFs): Variants like SHAKE128 and SHAKE256 can produce arbitrarily long outputs; Lesson 2428 — SHA-3 and Keccak
Extended ASCII: takes advantage of all 8 bits, adding characters numbered 128–255.; Lesson 25 — Extended ASCII and Code Pages
Extensibility: Add new product types without modifying existing code; Lesson 2267 — Factory Method Pattern Basics
Extensions: Additional information like allowed domain names; Lesson 1532 — Digital Certificates Fundamentals
external fragmentation: as processes start and terminate, memory becomes a patchwork of occupied and free regions.; Lesson 1335 — Contiguous Memory Allocation Lesson 1336 — Fragmentation in Contiguous Allocation Lesson 1351 — Introduction to Paging Lesson 1382 — External Fragmentation in Segmentation Lesson 1383 — Segmentation vs Paging Trade-offs Lesson 1399 — File Allocation Methods: Contiguous Lesson 2079 — Allocation and Deallocation on the Heap
External nodes: (also called leaves) have zero children.; Lesson 489 — Internal vs External Nodes
External Services: Dependencies like payment processors, email services, or authentication providers should be stubbed or use dedicated test accounts.; Lesson 2250 — Setting Up the Test Environment
External Sorting: Lesson 761 — Mergesort Applications and Tradeoffs Lesson 807 — External Sorting for Large Datasets
Extract: the highest/lowest priority element; Lesson 610 — Heap as Priority Queue Implementation Lesson 1380 — Logical Address Translation in Segmentation
Extract Class: refactorings to consolidate scattered logic.; Lesson 2337 — Shotgun Surgery Smell Lesson 2338 — Divergent Change Smell
Extract Method: is the same principle for code.; Lesson 2319 — Extract Method: Breaking Down Complex Functions Lesson 2327 — Remove Duplicate Code: DRY Principle in Practice Lesson 2330 — Long Method Smell Lesson 2333 — Feature Envy Smell
Extract minimum: Use extract-min to get the unvisited vertex with smallest known distance; Lesson 613 — Dijkstra's Algorithm with Priority Queue Lesson 1018 — Prim's Algorithm: Priority Queue Implementation Lesson 1019 — Prim's Algorithm: Time Complexity Analysis
Extract the index: The CPU uses the index bits to go directly to one specific cache line; Lesson 1128 — Direct-Mapped Cache Lookup
Extract two minimum nodes: Remove the two nodes with lowest frequencies; Lesson 614 — Huffman Coding Tree Construction
Extract Variable: means capturing a sub-expression's result in a well-named local variable.; Lesson 2322 — Extract Variable: Explaining Complex Expressions Lesson 2327 — Remove Duplicate Code: DRY Principle in Practice
extract-max: (for max-heaps) or **extract-min** (for min-heaps) removes and returns the root element.; Lesson 589 — Extract-Max/Min: Core Priority Queue Operation Lesson 611 — Job Scheduling with Priority Queues
Extract-Max (or Extract-Min): Remove and return the element with the highest (or lowest) priority; Lesson 609 — Priority Queue ADT Overview
Extract-Max/Min: removes the root and uses downward bubbling to fix the structure; Lesson 610 — Heap as Priority Queue Implementation
extract-min: (for min-heaps) removes and returns the root element.; Lesson 589 — Extract-Max/Min: Core Priority Queue Operation Lesson 612 — Event-Driven Simulation Lesson 973 — Dijkstra's with Binary Heap Priority Queue Lesson 974 — Dijkstra's with Fibonacci Heap
Extract-Min/Max: O(log n) — requires bubbling down to restore heap order; Lesson 599 — Heap Operation Trade-offs
extracting elements: .; Lesson 601 — Heapsort Overview and Basic Idea Lesson 783 — Heapsort Stability
Extraneous attributes: Extra attributes on the left or right side that aren't needed; Lesson 1629 — Minimal Cover and Canonical Cover
Extrinsic state: unique, context-dependent data (e.; Lesson 2279 — Flyweight Pattern: Sharing to Support Many Objects

F

F: The Accept States: Lesson 1778 — DFA Definition and Components
f(n): is the function we're analyzing (like your algorithm's runtime); Lesson 297 — Formal Definition of Big-Omega Lesson 842 — Recurrence Relations for Divide and Conquer Lesson 843 — Master Theorem Introduction Lesson 1002 — The f(n) Evaluation Function Lesson 1005 — A* Algorithm Implementation Lesson 2752 — A* Search Algorithm
F(x) = Σ p(k): for all k where k ≤ x; Lesson 123 — Cumulative Distribution Functions (CDF)
F1: when you need balance.; Lesson 2835 — Evaluating Logistic Regression Models
F1 Score: The harmonic mean of precision and recall.; Lesson 2804 — Performance Metrics Selection
F1-score: combines precision and recall into one number using their harmonic mean.; Lesson 2835 — Evaluating Logistic Regression Models
Facade: add minimal runtime overhead—they're thin wrappers that delegate calls.; Lesson 2283 — Structural Pattern Trade-offs Lesson 2284 — Combining Structural Patterns
Facade pattern: creates a single, simplified interface that sits in front of a complex subsystem of classes.; Lesson 2278 — Facade Pattern: Simplifying Complex Subsystems
Face-to-face conversation: beats lengthy email chains or documentation for resolving ambiguity.; Lesson 2362 — Individuals and Interactions Over Processes and Tools
Factory: or **Builder** patterns to organize creation logic.; Lesson 2303 — Spaghetti Code Anti-Pattern
factory method: an interface or abstract method that returns objects.; Lesson 2267 — Factory Method Pattern Basics Lesson 2273 — Choosing the Right Creational Pattern
facts: , **rules**, and **queries** based on formal logic.; Lesson 2157 — What is Logic Programming?Lesson 2158 — Prolog Syntax: Facts and Rules
fails: , revealing a defect.; Lesson 2219 — Test Cases and Test Suites Lesson 2722 — Compensating Transactions
Failure: Return `-1` (or similar sentinel) to signal an error; Lesson 1208 — System Call Parameters and Return Values
Failure links: that jump to the longest proper suffix when a mismatch occurs; Lesson 839 — Multiple Pattern Matching: Aho-Corasick
Failure rates: Older hardware fails more often; Lesson 2596 — Heterogeneity of Hardware and Software
Failures happen: The current leader might crash mid-coordination; Lesson 2655 — Leader Election Basics
Fair feature treatment: Algorithms using distance metrics (like k-nearest neighbors) or regularization (L1/L2) treat all features equitably when scaled.; Lesson 2824 — Feature Scaling and Normalization
Fairer service distribution: no area of the disk gets preferential treatment; Lesson 1426 — C-SCAN (Circular SCAN)
fairness: every process eventually gets CPU time, preventing indefinite starvation.; Lesson 1258 — Priority Inversion and Aging Lesson 1280 — Mutual Exclusion Problem Lesson 1423 — First-Come, First-Served (FCFS) Scheduling Lesson 1428 — Comparing Disk Scheduling Algorithms
FALSE: .; Lesson 13 — Boolean Values and Truth Tables Lesson 38 — Biconditional Statements Lesson 46 — Predicates and Propositional Functions Lesson 1565 — Logical Operators: AND, OR, NOT
False case: If `e ⇓ false` and `s₂ ⇓ v`, then `if e then s₁ else s₂ ⇓ v`; Lesson 2022 — Operational Semantics of Conditionals
False dependencies: Other code may appear to rely on dead functions, blocking refactoring efforts.; Lesson 2307 — Lava Flow Anti-Pattern
False negatives: Waiting too long before detecting actual crashes (degrading availability); Lesson 2594 — Impossibility of Perfect Failure Detection
False positives: Declaring a slow node dead (leading to unnecessary failovers); Lesson 2594 — Impossibility of Perfect Failure Detection
Familiar model: Matches how many traditional databases work; Lesson 2639 — Leader-Based Replication
Far red child: (same side as sibling): Perform a single rotation toward the double-black node, recolor appropriately; Lesson 554 — Deletion Cases: Black Sibling with Red Children
Fast: (usually linear or O(n log n) time); Lesson 878 — What Makes an Algorithm Greedy?Lesson 1391 — Sequential vs Random Access Lesson 1729 — Hash-Based Key Distribution Lesson 2224 — What is Unit Testing?
Fast allocation: the free space is contiguous; just bump a pointer; Lesson 2097 — Copying Collection
Fast contiguous allocation: You can quickly scan for consecutive `0` bits to allocate adjacent blocks; Lesson 1403 — Free Space Management: Bitmaps
Fast INSERT, UPDATE, DELETE: operations; Lesson 1650 — OLTP vs OLAP Database Design
Fast lookups: Getting the value at any position takes the same constant amount of time.; Lesson 232 — What is an Array?Lesson 444 — Symbol Tables in Compilers
Fast Operations: Your representation must support quick state transitions (generating successors) and comparisons (checking if you've reached a goal).; Lesson 2731 — State Representation Strategies
Fast pointer: moves two nodes at a time; Lesson 338 — Detecting Cycles in a List
Fast Recovery: cuts the congestion window in half and continues with Congestion Avoidance.; Lesson 1480 — TCP Congestion Control: Fast Retransmit and Fast Recovery
Fast Retransmit: works this way: if the sender receives **three duplicate ACKs** for the same sequence number, it immediately assumes that packet is lost and retransmits it—without waiting for the timeout.; Lesson 1480 — TCP Congestion Control: Fast Retransmit and Fast Recovery
Fast SELECT and aggregation: operations across large datasets; Lesson 1650 — OLTP vs OLAP Database Design
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
Fast to compute: Generating the hash should be quick; Lesson 2420 — What is a Hash Function?
faster: (fewer checks) and **safer** (avoids errors like dividing by zero or accessing invalid data).; Lesson 173 — Short-Circuit Evaluation Lesson 2522 — Push Notification-Based MFA
Faster connection establishment: QUIC combines the handshake and encryption setup (like HTTPS does with TLS) into a single round-trip, or even zero round-trips for repeat connections; Lesson 1527 — HTTP/3 and QUIC
Faster convergence: When all features live in similar ranges (like 0–1 or standard deviations from the mean), gradient descent takes more direct paths toward the minimum.; Lesson 2824 — Feature Scaling and Normalization
Faster debugging: errors caught at compile time don't require time-consuming test runs; Lesson 2002 — Early Error Detection in Static Typing
Faster Feedback: Customers use real software early and tell you what works and what doesn't.; Lesson 2369 — Continuous Delivery of Value
Faster reads: Queries become simpler—fewer or no joins mean less work for the database engine.; Lesson 1647 — Read Performance vs Write Complexity Lesson 1724 — Embedding vs Referencing
Faster searching: Binary search only works on sorted data, cutting search time dramatically; Lesson 737 — What is Sorting?
Faster than pure interpretation: Parsing and translation happen once, not every execution; Lesson 2033 — Bytecode Compilation: The Hybrid Approach
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)
Fastest access time: (1-4 CPU cycles); Lesson 1121 — Cache Levels: L1, L2, L3
Fault occurs: Program accesses a page not in RAM; Lesson 1346 — Page Faults and Demand Paging
Fault tolerance: If one node fails, other replicas continue serving requests.; Lesson 2637 — Introduction to Replication Lesson 2638 — Replication vs. Partitioning Lesson 2672 — Introduction to Paxos: The Consensus Problem
Favorable outcomes: 10 (the numbers 10, 20, 30, .; Lesson 110 — Computing Basic Probabilities
FCFS: since they don't need quick responses; Lesson 1259 — Multilevel Queue Scheduling Lesson 1261 — Comparing Scheduling Algorithm Performance
Feature branches: `feature/user-authentication` or `feature/add-search`; Lesson 2193 — Branch Management Best Practices Lesson 2197 — Gitflow Workflow
Feature creep: without restructuring existing code; Lesson 2303 — Spaghetti Code Anti-Pattern
Feature independence: Logistic regression assumes features aren't highly correlated with each other (no multicollinearity).; Lesson 2837 — Assumptions and Limitations of Logistic Regression
Feature Scaling: Normalize or standardize numerical features so they're on similar scales.; Lesson 2836 — Feature Engineering for Logistic Regression Lesson 2868 — Feature Scaling in KNN Lesson 2871 — Handling High-Dimensional Data
Features: (also called input variables or attributes) are the measurable properties or characteristics we use to describe each example; Lesson 2776 — Features and Labels
Feedback comes late: – stakeholders don't see working software until near the end, when changes are most costly; Lesson 2354 — Waterfall Strengths and Limitations
Feistel network structure: (splitting data into left and right halves, mixing them iteratively); Lesson 2400 — DES: The Data Encryption Standard
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
Fenwick trees: are remarkably simpler to code.; Lesson 655 — Fenwick Tree vs Segment Tree Trade-offs
Fetch: Retrieve the next instruction from memory using the address in the program counter; Lesson 1073 — The Control Unit Lesson 1074 — Program Counter (PC)Lesson 1081 — What is the Instruction Cycle?Lesson 1089 — Instruction Cycle Timing Lesson 1148 — Introduction to Instruction Pipelining Lesson 1162 — Structural Hazards: Definition Lesson 1172 — Control Hazards: Branch Impact
fetch stage: is the first step of the instruction cycle where the CPU grabs the next instruction from memory.; Lesson 1082 — The Fetch Stage Lesson 1084 — The Decode Stage
Fewer conflicts: than direct-mapped: Multiple addresses mapping to the same set won't always collide—they can coexist in different ways; Lesson 1132 — Set-Associative Caches
Fewer total blocks: With fixed cache size, larger blocks mean fewer blocks fit in cache.; Lesson 1146 — Impact of Block Size on Performance
Fiber: excels for high-speed, long-haul connections.; Lesson 1442 — Transmission Media Types
Fibonacci heaps: for better asymptotic performance.; Lesson 999 — Floyd-Warshall vs Repeated Dijkstra
FIFO: is simpler but can evict frequently-used blocks just because they're old.; Lesson 1123 — Cache Replacement Policies Overview
FIFO (First-In-First-Out): principle, just like a line of people waiting for a bus.; Lesson 376 — Essential Queue Operations
FIFO (First-In-First-Out) page replacement: , increasing the number of available frames can paradoxically *increase* the number of page faults.; Lesson 1369 — Belady's Anomaly
FIFO ordering: the element that's been waiting longest must always be the next one to leave.; Lesson 386 — Queue Invariants and Correctness
File and Disk Encryption: Tools like BitLocker and FileVault use AES to encrypt entire hard drives.; Lesson 2404 — Symmetric Crypto in Practice: Performance and Use Cases
File Control Block (FCB): is the generic term for a data structure that stores all metadata about a single file.; Lesson 1397 — File Control Blocks and Inodes
File deduplication: Quickly identify identical files by comparing hashes; Lesson 2429 — Hash Function Applications: Data Integrity
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
File Inclusion attacks: take this further by actually executing files:; Lesson 2489 — Path Traversal and File Inclusion
File Management: Lesson 1206 — System Call Categories
File size: in bytes; Lesson 1397 — File Control Blocks and Inodes
File Systems: NTFS, HFS+, and ext4 use B-trees to organize directory structures and file metadata efficiently.; Lesson 567 — B-Tree Performance and Applications Lesson 1201 — Core OS Services: File Systems and I/O Lesson 2285 — Real-World Structural Pattern Examples
File type: Regular file, directory, symbolic link, etc.; Lesson 1388 — File Attributes and Metadata Lesson 1397 — File Control Blocks and Inodes
File uploads: Especially filenames or metadata displayed to users; Lesson 2458 — XSS Attack Vectors and Payloads
Fill base cases: (the "smallest" problems you know the answer to); Lesson 917 — Tabulation (Bottom-Up DP)
Fill the knapsack: greedily:; Lesson 889 — Fractional Knapsack Problem
Filter: Keep only elements that satisfy a condition; Lesson 2136 — Map, Filter, and Reduce
Filter operators: Apply WHERE conditions to eliminate unwanted rows; Lesson 1698 — Query Execution Plans and Operators
Filtering: keeping only certain characters (like removing spaces or digits); Lesson 265 — Character-Level String Operations
Filtering unreachable states: Don't allocate memory for impossible combinations; Lesson 955 — State Space Reduction
FIN: (finish) segment, saying "I'm done sending data.; Lesson 1474 — TCP Connection Termination
FIN_WAIT_1: , **FIN_WAIT_2**: Active closer is shutting down; Lesson 1482 — TCP States and State Machine
FIN_WAIT_2: Active closer is shutting down; Lesson 1482 — TCP States and State Machine
Final cleanup: Once acknowledged, the PCB is deleted and all traces of the process disappear from the system.; Lesson 1220 — Process States: Terminated
Final predictions: For new data, pass it through all base models, then feed those predictions to the meta-model for the final output; Lesson 2861 — Stacking: Meta-Learning
Financial transactions: where accuracy is non-negotiable; Lesson 1717 — NoSQL vs SQL: Complementary Approaches Lesson 1734 — Eventual Consistency Trade-offs
Financial transactions requiring ACID: Use a relational database for consistency; Lesson 1716 — Polyglot Persistence Strategy
Find: the first position where they differ; Lesson 906 — Proof by Exchange Argument Lesson 1015 — Kruskal's Algorithm: Union-Find Data Structure
Find all unit pairs: For each nonterminal `A`, determine which nonterminals `B` are reachable through chains of unit productions (e.; Lesson 1824 — Eliminating Unit Productions
Find an empty cell: in the grid; Lesson 861 — Sudoku Solver
Find an unfinished process: whose maximum remaining need can be satisfied with current available resources (`work`).; Lesson 1325 — Banker's Algorithm: Safety Check
Find any pattern: in the original string in O(m) time, where m is the pattern length (not dependent on text size!; Lesson 634 — Suffix Trees: Motivation and Structure
Find augmenting paths: in the residual network, but only using edges with residual capacity ≥ Δ; Lesson 1040 — Capacity Scaling
Find blocking flows: using DFS, exploring only edges that move forward one level at a time; Lesson 1042 — Dinic's Algorithm Implementation
Find each group's median: Sort each small group and pick its middle element — this takes constant time per group since groups have fixed size; Lesson 826 — Median of Medians: Partitioning Strategy
Find median: Lesson 615 — Median Maintenance with Two Heaps
Find nullable non-terminals: identify all non-terminals that can derive ε (directly or through a chain); Lesson 1823 — Eliminating ε-Productions
Find recursive structure: How can larger strings be built from smaller ones?; Lesson 1818 — Designing CFGs for Simple Languages
Find the best split: using your chosen criterion (Information Gain, Gini Index, or variance reduction); Lesson 2847 — Recursive Partitioning Algorithm
Find the conflict markers: (`<<<<<<<`, `=======`, `>>>>>>>`); Lesson 2188 — Resolving Merge Conflicts
Find the median: of each group (just 5 elements, so it's fast); Lesson 825 — Median of Medians: Deterministic Selection
Find the median key: – Select the middle key from the sorted keys in the node; Lesson 1681 — Node Splitting During Insertion
Find the min-cut: Run a max-flow algorithm.; Lesson 1051 — Image Segmentation with Min-Cut
Find the new tail: – Use `tail->prev` to instantly jump to the second-to-last node; Lesson 345 — Deleting from the Tail of a Doubly Linked List
Find the node: you want to delete (using BST search); Lesson 508 — BST Deletion: Leaf Node Case
Find the page: OS locates the page on disk (usually in swap space); Lesson 1346 — Page Faults and Demand Paging
Find the replacement: Navigate to the right subtree's minimum (successor) or left subtree's maximum (predecessor); Lesson 510 — BST Deletion: Two Children Case
Finding: a subset: potentially requires trying many combinations; Lesson 1891 — The Class NP (Nondeterministic Polynomial)Lesson 1901 — Verifiers and Certificates
Finding Ceiling: Lesson 519 — Floor and Ceiling Operations
Finding extremes: Maximum price in each department?; Lesson 1590 — Using Joins with Aggregations
Finding Floor: Lesson 519 — Floor and Ceiling Operations
Finding max/min: scanning through all elements once to track the largest or smallest; Lesson 285 — O(n): Linear Time
Finding maximum element: Uses one variable to track the current maximum as you scan through; Lesson 305 — Constant Space: O(1)
Finding minimum: Scan all V vertices each iteration → O(V) per iteration; Lesson 1019 — Prim's Algorithm: Time Complexity Analysis
Finding patterns: Spotting duplicates, medians, or extremes becomes trivial when data is ordered; Lesson 737 — What is Sorting?
Finding the median: for statistical analysis (k = n/2); Lesson 821 — The Selection Problem Definition
Fine-grained: Each capability grants precisely scoped rights; Lesson 2532 — Capability-Based Security
Fine-grained control: You decide precisely how memory is used and modified; Lesson 2121 — Imperative Style Tradeoffs
Fine-grained control flow: Error recovery, retry logic, or multi-step transactions with specific rollback behavior often demand imperative clarity.; Lesson 2156 — Benefits and Trade-offs of Declarative Style
Fine-grained locking: allows much higher concurrency—multiple threads can work simultaneously on different parts of the data structure.; Lesson 1286 — Lock Granularity and Performance Lesson 2579 — Concurrent Queue: Linked List Implementation
Fine-grained locks: protect smaller, more specific pieces.; Lesson 1286 — Lock Granularity and Performance
Fine-grained memory management: Unused portions of segments don't waste frames; Lesson 1384 — Segmentation with Paging (Hybrid Approach)
Finish with insertion sort: – When subarrays become small (≤16 elements), use insertion sort's cache-friendly efficiency; Lesson 801 — Introsort: The Best of Both Worlds
Finished Messages: Both exchange encrypted "finished" messages to confirm the handshake succeeded.; Lesson 1525 — HTTPS Handshake Process Lesson 2443 — The TLS Handshake: Establishing Secure Connections
Finite input: The grammar is finite, and the string has finite length *n*.; Lesson 1873 — Decidability of CFG Membership
Finiteness: Does the language contain infinitely many strings?; Lesson 1811 — Decision Properties of Regular Languages
Fire spread simulation: Multiple fire sources spreading simultaneously; Lesson 702 — Multi-Source BFS
first: occurrence, we adjust the strategy:; Lesson 812 — Finding First Occurrence Lesson 1603 — Subqueries in WHERE Clause Lesson 2524 — Authorization vs Authentication Lesson 2805 — Data Leakage Prevention
First Normal Form (1NF): .; Lesson 1632 — First Normal Form (1NF) Definition
First pass: Treat each element as a sorted subarray of size 1.; Lesson 760 — Bottom-Up Mergesort
FIRST set: of a grammar symbol (terminal, non-terminal, or production right-hand side) contains all the terminals that can appear as the *first* symbol when that grammar element is expanded.; Lesson 1956 — Predictive Parsing and FIRST Sets
FIRST sets don't overlap: For any two productions of the same non-terminal (like `A → α` and `A → β`), the FIRST sets of α and β must be disjoint.; Lesson 1958 — LL(1) Grammars
First-In-First-Out (FIFO): .; Lesson 375 — Queue ADT Definition and FIFO Principle Lesson 1368 — FIFO Page Replacement
Fix the code: Modify your implementation to make the test pass.; Lesson 2262 — TDD for Bug Fixes
Fixed Access Time: Whether accessing the first byte or the millionth, you always: read index block → find pointer → read data block.; Lesson 1401 — File Allocation Methods: Indexed
Fixed capacity: The table has a maximum size; Lesson 422 — Open Addressing: Concept
Fixed memory: The array size stays constant.; Lesson 379 — Circular Queue Concept
Fixed size: When you declare an array, you specify how many elements it holds.; Lesson 232 — What is an Array?
Fixed-scope projects: with clear, unchanging requirements; Lesson 2354 — Waterfall Strengths and Limitations
Fixed-size 2D array: (e.; Lesson 311 — Analyzing Multi-Dimensional Space
Fixtures: are pre-defined data sets you can reuse across tests.; Lesson 2253 — Test Data Management
Flags: (9 bits): Control bits including:; Lesson 1472 — TCP Segment Structure
Flex: ) are the most famous examples.; Lesson 1948 — Lexer Generator Tools
Flexibility: Swap implementations without changing code that *uses* the ADT; Lesson 355 — What is an Abstract Data Type (ADT)?Lesson 647 — Segment Tree Variants and Functions Lesson 1331 — The Address Space Abstraction Lesson 1340 — Address Translation Overview Lesson 1349 — Shared Memory via Virtual Memory Lesson 1724 — Embedding vs Referencing Lesson 1999 — Type Checking at Runtime Lesson 2003 — Runtime Type Errors in Dynamic Systems (+7 more)
Flexibility to pivot: When priorities shift or new insights emerge, the team adapts; Lesson 2364 — Customer Collaboration Over Contract Negotiation
Flexible: Can be changed if compromised; Lesson 2517 — Knowledge Factors (Something You Know)
Flexible Schema: Documents don't require a predefined structure.; Lesson 1710 — Document Store Fundamentals
Flexible schema evolution: → Document stores; Lesson 1715 — Choosing the Right NoSQL Category
Flexible schemas: Store documents, key-value pairs, or graphs without predefined tables.; Lesson 1708 — What is NoSQL and Why It Exists Lesson 1717 — NoSQL vs SQL: Complementary Approaches
Flexible segment sizes: Segments can grow by allocating more pages without worrying about finding contiguous space; Lesson 1384 — Segmentation with Paging (Hybrid Approach)
Floating-point: `[0-9]+\.; Lesson 1941 — Lexical Specification with Regular Expressions
Floating-point division: divides numbers and preserves the decimal portion of the result.; Lesson 156 — Integer vs Floating-Point Division
floating-point numbers: , and computers store them using special data types.; Lesson 141 — Floating-Point Data Types Lesson 1986 — Primitive Types
Floating-point values uniformly distributed: **Bucket Sort** can be very efficient.; Lesson 799 — When to Use Which Sorting Algorithm
Flood fill: Paint connected regions (like paint bucket tool); Lesson 704 — BFS in Grid Graphs
FLOPS: (Floating-Point Operations Per Second).; Lesson 1190 — MIPS and FLOPS Metrics
Flow and Error Control: Lesson 1471 — TCP Overview and Key Features
Flow conservation: For every vertex except s and t, flow in equals flow out: ∑(flow in) = ∑(flow out); Lesson 1022 — Flow Networks and Definitions Lesson 1025 — Valid Flows and Flow Value Lesson 1034 — Maximum Flow Problem Definition Lesson 1035 — Flow Conservation and Capacity Constraints
Flow conservation with demands: for every node `v`, the incoming flow minus outgoing flow must equal `d(v)`; Lesson 1054 — Circulation with Demands
Flow control: Preventing a fast sender from overwhelming a slow receiver; Lesson 1434 — OSI Layer 2: Data Link Layer Lesson 1436 — OSI Layer 4: Transport Layer Lesson 1445 — Data Link Layer Responsibilities Lesson 2714 — Backpressure and Flow Control
Flow requirement: Push flow of *n* from source to sink; Lesson 1049 — Assignment Problem
Floyd-Warshall: computes all-pairs paths in one pass with O(V³) time and O(V²) space.; Lesson 999 — Floyd-Warshall vs Repeated Dijkstra
FLP impossibility result: (Fischer, Lynch, Paterson, 1985), which shows that in an asynchronous system where even one process *might* fail, no algorithm can guarantee consensus while also guaranteeing termination.; Lesson 2594 — Impossibility of Perfect Failure Detection
Flyweight: trades initial object-creation cost for memory savings but adds complexity in managing shared state.; Lesson 2283 — Structural Pattern Trade-offs
Follow consistent casing conventions: Lesson 191 — Function Naming Conventions
FOLLOW handled correctly: If a production can derive the empty string (ε), its FIRST set must not overlap with the FOLLOW set of its left-hand non-terminal.; Lesson 1958 — LL(1) Grammars
Follow predecessors backward: repeatedly jump to `pred[dest]`, then `pred[pred[dest]]`, and so on; Lesson 975 — Path Reconstruction from Predecessor Array
FOLLOW sets: to determine what tokens can legally appear *after* a non-terminal, enabling your parser to handle epsilon productions correctly.; Lesson 1957 — FOLLOW Sets
Follow the path: For each character, check if a child link exists; Lesson 622 — Trie Search: Exact Match Queries
Follow the transition: Move to the next state according to the transition function for that symbol; Lesson 1780 — DFA Computation and Acceptance
Follow_Up: with exact timestamp; Lesson 2635 — Precision Time Protocol (PTP)
FOLLOW(A): is the set of all terminals that can legally appear immediately after non-terminal A in *any* valid derivation.; Lesson 1957 — FOLLOW Sets Lesson 1967 — SLR(1) Parsing
Follower: Any instruction that immediately follows a jump, branch, conditional, or return statement; Lesson 2043 — Basic Blocks and Leaders
Follower → Candidate: When a follower's election timeout expires without hearing from the leader, it starts an election; Lesson 2659 — Raft Server States: Follower, Candidate, Leader
Followers: start new blocks because the previous instruction could have transferred control away (forcing a new hallway); Lesson 2043 — Basic Blocks and Leaders Lesson 2661 — Raft RPCs: RequestVote and AppendEntries
Followers apply: the change to their local copies; Lesson 2639 — Leader-Based Replication
Following instructions: get stuck waiting in earlier stages; Lesson 1158 — Multi-Cycle Instructions in Pipelines
For arrays: append to the end (amortized O(1)); Lesson 674 — Adjacency List: Operations and Complexity
For classification: assign the most common label among those k neighbors (majority vote); Lesson 2863 — KNN: Distance-Based Classification and Regression
For CPU-bound processes: Longer time slices reduce context switching overhead since these processes will use their entire quantum anyway.; Lesson 1250 — CPU-Bound vs I/O-Bound Processes
For dependent events: (when the first affects the second):; Lesson 115 — Multiplication Rule
For each character: in the word:; Lesson 621 — Trie Insertion: Adding Words Lesson 623 — Prefix Search and StartsWith Operations
For each job: , try to schedule it as late as possible before its deadline; Lesson 891 — Job Sequencing with Deadlines
For every language L: Lesson 1801 — NFA-DFA Equivalence Theorem
For I/O-bound processes: Shorter time slices and prioritized scheduling improve responsiveness.; Lesson 1250 — CPU-Bound vs I/O-Bound Processes
For independent events: (when one doesn't affect the other):; Lesson 115 — Multiplication Rule
For k largest elements: Use a **min-heap** of size k.; Lesson 618 — Top-K Elements Problem
For k smallest elements: Use a **max-heap** of size k.; Lesson 618 — Top-K Elements Problem
For linked lists: add a new node at the head or tail (O(1)); Lesson 674 — Adjacency List: Operations and Complexity
For multicores: Lesson 1269 — Multicore vs Multiprocessor Scheduling
For multiprocessors: Lesson 1269 — Multicore vs Multiprocessor Scheduling
For regression: predict the average value of those k neighbors; Lesson 2863 — KNN: Distance-Based Classification and Regression
For that node n: f(n) = g(n) + h(n) ≤ g(n) + true_cost(n → goal) = C₁ (because h is admissible).; Lesson 2753 — A* Optimality and Admissibility
Force B to wait: Lesson 1168 — Pipeline Stalls and Bubbles
Force-push carefully: `git push --force-with-lease`; Lesson 2213 — Rewriting History Safely
Forced termination: Another thread cancels it (though this is risky); Lesson 1238 — Thread Creation and Termination
Ford-Fulkerson method: for solving maximum flow problems.; Lesson 1037 — Augmenting Paths
Foreign keys: → `FOREIGN KEY` constraint with `REFERENCES`; Lesson 1560 — From Relational Model to SQL Lesson 1576 — What is a Join?Lesson 1659 — Integrity Constraints and Consistency
Forgettable: Strong passwords are hard to remember, leading to weak choices or password reuse; Lesson 2517 — Knowledge Factors (Something You Know)
Forgetting to Signal: Lesson 1302 — Semaphore Pitfalls and Common Errors
Fork the repository: A contributor copies the main project repository to their own GitHub (or GitLab, etc.; Lesson 2198 — Forking Workflow
Forking Workflow: , contributors don't work directly in the project's main repository.; Lesson 2198 — Forking Workflow
formal language: is simply a set of strings built from a particular alphabet.; Lesson 1760 — Languages as Sets of Strings Lesson 1898 — Decision Problems and Languages
Formal mathematical definition: Turing Machine (precisely defined mathematical object); Lesson 1866 — Why the Thesis Cannot Be Proven
Formal verification: Can we mathematically prove our program does what we claim?; Lesson 2017 — Introduction to Operational Semantics
Formally: L* = {ε} ∪ L ∪ LL ∪ LLL ∪ .; Lesson 1762 — Kleene Star and Plus on Languages
Formatting buffers: (temporary storage that doesn't need sharing); Lesson 2559 — Thread-Local Storage
Formula: `h(k) = floor(m * (k * A mod 1))`; Lesson 409 — The Multiplication Method Lesson 1029 — Residual Capacity of a Path Lesson 1159 — Pipeline Performance Metrics Lesson 1190 — MIPS and FLOPS Metrics
Forward button: Pop from the forward stack, push it back onto the back stack; Lesson 372 — Browser History Navigation
forward edge: Lesson 712 — DFS Tree Edges and Classification Lesson 1027 — Residual Networks
forward edges: (shortcuts to descendants), **cross edges** (between separate subtrees), and **back edges** (to ancestors, proving cycles).; Lesson 714 — DFS on Directed vs Undirected Graphs Lesson 1036 — Residual Networks
Forward search: relaxes edges normally (source → neighbors); Lesson 978 — Bidirectional Dijkstra's Algorithm
Forward secrecy: (also called *perfect forward secrecy* or PFS) is a cryptographic property that ensures each session uses ephemeral (temporary) keys.; Lesson 2418 — Forward Secrecy Lesson 2442 — TLS: The Security Layer Behind HTTPS
Forwarding Decision: Lesson 1455 — Switch Learning and Forwarding
Found the node: Splay it to the root using the appropriate rotation sequence (Zig-Zig, Zig-Zag, or Zig depending on configuration).; Lesson 571 — Splay Tree Search
Foundation: Other control structures (loops, conditionals) redirect this flow but don't eliminate it; Lesson 2116 — Sequential Control Flow Lesson 2224 — What is Unit Testing?
Fourth column: 1 + 0 + 1(carry) = 0, carry 1; Lesson 5 — Binary Addition
Fourth Normal Form: if:; Lesson 1642 — Fourth Normal Form (4NF) Overview
Fractional Knapsack: Sort by ratio O(n log n), then fill greedily O(n); Lesson 887 — Greedy Algorithm Complexity
Fragile: Changes in one area risk breaking unrelated functionality; Lesson 2338 — Divergent Change Smell
fragmentation: scattered small holes of free space that are individually too small to satisfy allocation requests, even though their total size might be sufficient.; Lesson 1337 — Memory Compaction Lesson 2079 — Allocation and Deallocation on the Heap
Frame pointer: Reference to the caller's frame (optional but common); Lesson 2076 — Stack Frames and Activation Records
Frames: Fixed-size blocks of physical memory (typically 4KB each); Lesson 1351 — Introduction to Paging Lesson 1352 — Pages and Frames Lesson 1356 — Internal Fragmentation in Paging Lesson 1434 — OSI Layer 2: Data Link Layer Lesson 1445 — Data Link Layer Responsibilities
Framing: Wrapping data into structured frames with headers and trailers; Lesson 1434 — OSI Layer 2: Data Link Layer Lesson 1445 — Data Link Layer Responsibilities
Framing techniques: solve this delimitation problem by marking frame boundaries in the bit stream.; Lesson 1446 — Framing Techniques
Free the memory: – Deallocate the removed node; Lesson 345 — Deleting from the Tail of a Doubly Linked List
Free the old head: Deallocate the memory of the node you removed; Lesson 344 — Deleting from the Head of a Doubly Linked List
Freeze: those layers; Lesson 2795 — Transfer Learning and Self-Supervised Learning
Freezes: the instruction that needs data (keeps it in the same stage); Lesson 1168 — Pipeline Stalls and Bubbles
frequency analysis: .; Lesson 2396 — The Substitution Cipher Lesson 2397 — The Caesar Cipher Lesson 2398 — Polyalphabetic Ciphers and the Vigenère Cipher
Frequency assignment: in wireless networks (towers are vertices, interference creates edges); Lesson 1925 — Graph Coloring Problem
Frequency Modulation (FM): Vary the frequency.; Lesson 1443 — Signal Encoding and Modulation
Frequent checks: (e.; Lesson 1326 — Deadlock Detection Algorithms
Frequent feedback loops: Customers see working software regularly (weekly or bi-weekly); Lesson 2364 — Customer Collaboration Over Contract Negotiation
Frequently joined dimensions: in OLTP systems serving web traffic; Lesson 1653 — Hybrid Normalization Strategies
Frequently updated information: where consistency is critical; Lesson 1653 — Hybrid Normalization Strategies
Frictionless: No typing codes, no copying/pasting; Lesson 2522 — Push Notification-Based MFA
From function signatures: if a function returns `bool`, any variable assigned that result is also `bool`; Lesson 2007 — What is Type Inference?
FROM keyword: → **where** it lives → **optional filter**; Lesson 1562 — Database Connection and Basic Structure
From literals: `y = "hello"` — clearly a string; Lesson 2007 — What is Type Inference?
From operations: `z = x + y` — if `x` and `y` are integers, `z` must be too; Lesson 2007 — What is Type Inference?
front: of the queue.; Lesson 376 — Essential Queue Operations Lesson 378 — Array-Based Queue Implementation Lesson 382 — Linked List-Based Queue Implementation Lesson 706 — 0-1 BFS
Front (or Head): Where elements are removed; Lesson 375 — Queue ADT Definition and FIFO Principle
Front and Rear Consistency: Lesson 386 — Queue Invariants and Correctness
Front pointer: Points to the node at the head of the queue (where we dequeue from); Lesson 382 — Linked List-Based Queue Implementation
frontier: and **explored sets** only tell you which states you've visited, not the exact sequence from initial state to goal.; Lesson 2738 — Solution Extraction and Path Reconstruction Lesson 2739 — Uninformed Search Overview Lesson 2746 — Uniform-Cost Search
Full: when `(rear + 1) % capacity == front`; Lesson 380 — Circular Queue Implementation Details Lesson 392 — Deque Array Implementation Lesson 459 — Full, Complete, and Perfect Binary Trees Lesson 486 — Perfect Binary Trees Lesson 1153 — Pipeline Fill and Drain Lesson 1298 — Producer-Consumer Problem with Semaphores
full binary tree: (also called a *strictly binary tree* or *2-tree*) is a special type of binary tree where every node has **exactly 0 or 2 children** — never just one child.; Lesson 484 — Full Binary Trees Lesson 487 — Node Count Formulas
Full dependency: .; Lesson 1624 — Full vs Partial Functional Dependencies
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
Full transition: After C-new commits, servers in C-old but not C-new can safely shut down; Lesson 2671 — Cluster Membership Changes in Raft
Fully associative: eliminates conflict misses entirely since any block can go anywhere.; Lesson 1134 — Comparing Associativity Tradeoffs
fully associative cache: takes the opposite approach: *any* memory block can be placed in *any* cache line.; Lesson 1130 — Fully Associative Caches Lesson 1131 — Associative Cache Lookup and CAM
function: is a special kind of relation that assigns *exactly one* output to each input.; Lesson 76 — Definition and Notation of Functions Lesson 185 — What is a Function?
Function abstraction: defining anonymous functions (think "lambda x, return x+1"); Lesson 1862 — Alternative Models: Lambda Calculus
Function application: calling functions with arguments; Lesson 1862 — Alternative Models: Lambda Calculus
Function call semantics: specify the exact rules for:; Lesson 2025 — Function Call Semantics
Function call sequences: across boundaries; Lesson 2234 — What is Integration Testing?
Function calls/returns: (excluding the work *inside* the function); Lesson 271 — Counting Primitive Operations
Function Declaration: (also called a *prototype*): This announces that a function exists, specifying its name, return type, and parameters—but *not* the actual code inside.; Lesson 187 — Function Definition vs Declaration
Function Definition: (also called an *implementation*): This provides the complete function, including the declaration information *plus* the actual body of code that executes when the function is called.; Lesson 187 — Function Definition vs Declaration
Function inlining: is an optimization where the compiler replaces a function call with the actual body of the function.; Lesson 2069 — Inlining Functions
Function parameters: Specify what types inputs must be; Lesson 2000 — Type Annotations in Static Languages
function signature: is like a contract or promise.; Lesson 206 — Function Signatures and Contracts Lesson 1995 — Type Annotations and Signatures
Functional: trades some performance for safety.; Lesson 2146 — Functional vs Imperative Tradeoffs
Functional software provides: Lesson 2363 — Working Software Over Comprehensive Documentation
Functional unit availability: Is the ALU or multiplier free when needed?; Lesson 1163 — Detecting Structural Hazards
Functional units: Two instructions needing the same ALU or multiplier; Lesson 1162 — Structural Hazards: Definition
Funnel shapes: Indicates heteroscedasticity (variance isn't constant); Lesson 2825 — Evaluating Linear Regression Models
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(n): is the simpler function we're comparing it to (like n, n², etc.; Lesson 297 — Formal Definition of Big-Omega Lesson 1001 — Heuristic Functions in A*Lesson 1002 — The f(n) Evaluation Function Lesson 2752 — A* Search Algorithm
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
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 AI: Pathfinding for characters moving through a map; Lesson 965 — Introduction to Single-Source Shortest Path Problems Lesson 1011 — A* Applications and Variants
Game Boards: Think of a chess board or tic-tac-toe grid.; Lesson 249 — Practical Applications of Multidimensional Arrays
Game development: Voxel-based worlds (like Minecraft); Lesson 247 — 3D Arrays and Higher Dimensions
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
Gates feed into gates: The output wire from one gate plugs into the input of another; Lesson 21 — Building Complex Circuits from Basic Gates
GCD: Each node stores the greatest common divisor.; Lesson 647 — Segment Tree Variants and Functions
Geekbench: Cross-platform consumer devices; Lesson 1191 — Benchmark Programs and Performance Testing
General formula: P(A ∪ B) = P(A) + P(B) - P(A ∩ B); Lesson 111 — Union and Intersection of Events
Generalizes: it to `∀α.; Lesson 2013 — Let-Polymorphism
Generate alternate rules: for each production containing nullable non-terminals, create new versions with those symbols present and absent; Lesson 1823 — Eliminating ε-Productions
Generate candidate plans: (from lesson 1698's execution plan operators); Lesson 1699 — Cost-Based Query Optimization
Generate constraints: When analyzing `f x`, if `f` has type `α → β` and `x` has type `Int`, you get the constraint: `α = Int`; Lesson 2010 — Type Variables and Unification
Generate instructions: for each operation in sequence; Lesson 2054 — Code Generation for Expressions
Generate meta-features: Use these base models to make predictions on a validation set; Lesson 2861 — Stacking: Meta-Learning
Generate neighbors dynamically: For each state you dequeue, compute all valid next states using problem rules; Lesson 705 — BFS with State Space Representation
Generating Permutations: Fix one element, recursively permute the rest; Lesson 866 — Problem Decomposition in Recursion
Generational barriers: Track pointers from old generations to young ones (remember, generational GC assumes old objects rarely reference new ones); Lesson 2102 — Write Barriers
Genomics/DNA sequencing: KMP or specialized algorithms shine here because DNA has small alphabets (A, C, G, T) and patterns repeat frequently.; Lesson 840 — String Searching Applications and Tradeoffs
Geographically distributed datacenters: Each datacenter has its own leader, reducing latency for local users; Lesson 2641 — Multi-Leader Replication
Geometric: Binary search divides a problem in half each time (geometric with r = 0.; Lesson 83 — Arithmetic and Geometric Sequences
Geometric sequences: grow by multiplying by the same amount each time.; Lesson 83 — Arithmetic and Geometric Sequences
GET: is used to *retrieve* data from a server.; Lesson 1516 — HTTP Methods: GET and POST Lesson 1528 — RESTful API Design with HTTP
Get a thread identifier: Receive a handle to reference this thread later; Lesson 1238 — Thread Creation and Termination
GET, HEAD, OPTIONS: are idempotent (reading doesn't change state); Lesson 1517 — HTTP Methods: PUT, DELETE, and Others
Gini: is computationally cheaper (no logarithms); Lesson 2844 — Impurity Measures: Gini Index
Gini impurity: or **entropy** — metrics that quantify how "mixed" the classes are in a node.; Lesson 2839 — Classification vs Regression Trees
Gini index: (or Gini impurity) measures how often a randomly chosen element from a set would be incorrectly classified if it were randomly labeled according to the distribution of labels in that set.; Lesson 2844 — Impurity Measures: Gini Index Lesson 2845 — Splitting Criteria for Regression Trees
Git submodules: let you include one Git repository inside another while keeping them separate and independently versioned.; Lesson 2209 — Submodules
GitHub Actions: uses YAML workflow files stored in `.; Lesson 2394 — CI/CD Tools and Infrastructure
GitLab CI: uses `.; Lesson 2394 — CI/CD Tools and Infrastructure
Global Descriptor Table (GDT): and **Local Descriptor Table (LDT)** store segment descriptors containing:; Lesson 1385 — Segmentation in x86 Architecture
Global History Predictor: maintains a single shift register that records the outcomes (taken/not-taken) of the last N branches executed—*regardless of which branch instructions they were*.; Lesson 1181 — Global History Predictors
Global variables: live for the entire program execution; Lesson 212 — Variable Lifetime Basics Lesson 2095 — Reachability and the Root Set
Go back: Move current page from back stack to forward stack; Lesson 372 — Browser History Navigation
Go forward: Move page from forward stack back to back stack; Lesson 372 — Browser History Navigation
Goal: Create a decider that always answers correctly; Lesson 1878 — What is the Halting Problem?Lesson 2734 — Search Problem Formulation Lesson 2782 — The Bias-Variance Tradeoff
goal state: (solution you're looking for); Lesson 705 — BFS with State Space Representation Lesson 2728 — Initial State and Goal States
Goal States: The target node(s) you're trying to reach; sometimes it's one specific state, other times any state satisfying certain conditions (e.; Lesson 2728 — Initial State and Goal States
Goals: – optionally, criteria to optimize; Lesson 2155 — Constraint Programming Basics Lesson 2734 — Search Problem Formulation
God Object: (sometimes called a "God Class") is a class that has grown to know too much or do too much.; Lesson 2302 — God Object Anti-Pattern Lesson 2303 — Spaghetti Code Anti-Pattern Lesson 2337 — Shotgun Surgery Smell
Good distribution: Keys should spread data evenly across partitions.; Lesson 2685 — Partition Keys and Shard Keys
Good for small systems: When you have only a few tightly-coupled components, the overhead of incremental testing may not be worth it; Lesson 2236 — Big Bang Integration Strategy
Good hash function: Must distribute keys uniformly across buckets to avoid clustering; Lesson 1692 — O(1) Lookup with Hash Indexes
Good naming: Lesson 2309 — Meaningful Names for Variables and Functions
Good replacement: Evict a page from an idle background process → few subsequent faults; Lesson 1366 — Page Replacement Problem
Good state definitions: are minimal yet complete.; Lesson 920 — State Definition and Transitions
good suffix rule: tells you: "I know this suffix matched—where else could it appear in my pattern?; Lesson 837 — Boyer-Moore: Good Suffix Rule Lesson 838 — Boyer-Moore: Combined Algorithm
Good uses: Lesson 2312 — Comments: When and How to Use Them
Google Cloud Pub/Sub: each occupy specific niches—traditional enterprise messaging, ultra-low-latency scenarios, and GCP integration respectively.; Lesson 2716 — Popular Message Queue Systems
Google Spanner: provides strong consistency (linearizability) across globally distributed data centers.; Lesson 2622 — Consistency in Practice: Examples
Gossip: provides fast, probabilistic propagation for new writes; Lesson 2704 — Anti-Entropy and Gossip Protocols
Gossip protocols: spread updates like rumors in a social network:; Lesson 2704 — Anti-Entropy and Gossip Protocols
GPS navigation: Finding routes when all roads have equal weight; Lesson 694 — BFS Overview and Applications Lesson 965 — Introduction to Single-Source Shortest Path Problems
Gradient descent: and its variants iteratively:; Lesson 2780 — Optimization in Machine Learning Lesson 2859 — Gradient Boosting Fundamentals
Gradual typing systems: allow parts of your codebase to be statically typed (checked at compile time) while other parts remain dynamically typed (checked at runtime).; Lesson 2005 — Gradual Typing Systems
Grammar rules: – production rules in BNF-like notation, each with semantic actions (code executed when the rule is reduced); Lesson 1973 — Parser Generators and YACC/Bison
graph: is a data structure consisting of two components:; Lesson 657 — What is a Graph? Vertices and Edges Lesson 1747 — Graph Database vs Relational Joins
Graph approach: Lesson 1747 — Graph Database vs Relational Joins
Graph connectivity: (is the graph connected?; Lesson 1890 — Examples of Problems in P
graph database: stores data as a network of entities (nodes) and their relationships (edges).; Lesson 1713 — Graph Database Fundamentals Lesson 1747 — Graph Database vs Relational Joins
Graph databases: store data as nodes (entities) and edges (relationships), optimized for traversing connections.; Lesson 1709 — The Four Main NoSQL Categories Lesson 1715 — Choosing the Right NoSQL Category
graph search: (which recognizes when you've visited a state before).; Lesson 2737 — Redundant Paths and Graph Search Lesson 2738 — Solution Extraction and Path Reconstruction Lesson 2753 — A* Optimality and Admissibility
Graphical User Interface (GUI): Windows, icons, menus—visual elements you click.; Lesson 1202 — System Utilities and User Interface
Graphs: make patterns visually obvious; Lesson 68 — Representing Relations Lesson 2731 — State Representation Strategies
Gray: Visited, but references from this object haven't been scanned yet; *work queue*; Lesson 2099 — Tri-Color Marking
Greater branch misprediction penalty: A wrong guess wastes more in-progress work; Lesson 1156 — Deeper Pipelines: Benefits and Costs
Greater than: `>` — "Is the left value larger?; Lesson 157 — Comparison Operators Lesson 171 — Comparison Operators in Conditions Lesson 257 — Partitioning Arrays Around a Pivot Lesson 493 — What is a Binary Search Tree?Lesson 514 — Range Query in BST
Greater than pivot: (elements > pivot); Lesson 772 — Three-Way Partitioning for Duplicate Keys
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 Lesson 1424 — Shortest Seek Time First (SSTF)Lesson 2847 — Recursive Partitioning Algorithm Lesson 2852 — Advantages and Limitations of Decision Trees
greedy algorithm: makes the locally optimal choice at each step, hoping that these local decisions will lead to a globally optimal solution.; Lesson 878 — What Makes an Algorithm Greedy?Lesson 895 — Egyptian Fraction Representation
Greedy algorithms: make a series of **irreversible choices**.; Lesson 881 — Greedy vs Dynamic Programming
Greedy Best-First Search: (which you learned earlier).; Lesson 2760 — Weighted A* and Speed-Accuracy Tradeoffs
greedy choice: at each step, you make the locally optimal decision without worrying about future consequences.; Lesson 892 — Minimum Number of Coins Problem Lesson 902 — Buy Maximum Stocks with K Transactions Lesson 911 — Counterexamples: When Greedy Fails Lesson 971 — Why Negative Edges Break Dijkstra's Algorithm
greedy choice property: is the key trait that tells you a problem *can* be solved greedily.; Lesson 879 — The Greedy Choice Property Lesson 880 — Optimal Substructure in Greedy Problems Lesson 881 — Greedy vs Dynamic Programming Lesson 885 — When Greedy Fails Lesson 891 — Job Sequencing with Deadlines Lesson 895 — Egyptian Fraction Representation Lesson 900 — Policemen Catch Thieves Problem Lesson 904 — The Greedy Choice Property (+3 more)
Greedy result: 3 coins (4 + 1 + 1); Lesson 885 — When Greedy Fails
Greedy Stays Ahead: Prove that after each step, the greedy solution is "at least as good" as any other solution in a measurable way.; Lesson 903 — Introduction to Greedy Correctness Proofs
Greedy step: repeatedly take the two nodes with the smallest frequencies and merge them into a parent node (frequency = sum of children); Lesson 890 — Huffman Coding for Data Compression
Green: (new version).; Lesson 2392 — Deployment Strategies: Blue-Green and Canary
Grid with obstacles: → BFS on grid graph; Lesson 708 — BFS Applications and Problem Patterns
Grids and Maps: From minesweeper to geographic terrain elevation data, any grid-based representation benefits from 2D arrays.; Lesson 249 — Practical Applications of Multidimensional Arrays
Group: A set of users who share access (e.; Lesson 1392 — File Permissions and Access Control
Group related modules: into clusters; Lesson 2239 — Bottom-Up Integration Testing
Grouping: and **counting** are optimization strategies that batch information for efficiency.; Lesson 1405 — Free Space Management: Grouping and Counting
Grow: when the array is full and you attempt an enqueue; Lesson 381 — Dynamic Array-Based Queue
Grow-Only Set: (G-Set) allows only additions.; Lesson 2703 — Conflict-Free Replicated Data Types (CRDTs)
Growth simpler: Segments can grow independently (stack grows down, heap grows up); Lesson 1383 — Segmentation vs Paging Trade-offs
Guaranteed O(n log n): time in *all cases*—even worst-case.; Lesson 774 — Quicksort vs Mergesort: Practical Comparison Lesson 802 — Timsort: Python's Default Sorting Algorithm
Guaranteed termination: CYK runs in O(n³) time—it always finishes in a predictable number of steps.; Lesson 1873 — Decidability of CFG Membership
Guaranteed worst-case matters: Basic BSTs degrade to O(n) with poor insertion order.; Lesson 530 — When to Use BSTs
Guaranteed worst-case performance: **Heapsort** or **Mergesort**—never degrades beyond O(n log n).; Lesson 799 — When to Use Which Sorting Algorithm
Guarantees termination: even in infinite state spaces (unlike vanilla DFS); Lesson 2744 — Depth-Limited Search
guard: that checks every assignment and operation.; Lesson 146 — Type Safety and Strong Typing Lesson 2022 — Operational Semantics of Conditionals Lesson 2225 — Anatomy of a Unit Test
guard clause: checks for invalid or special conditions *first* and handles them immediately.; Lesson 174 — Common Conditional Patterns Lesson 2315 — Reducing Nesting and Complexity Lesson 2325 — Replace Nested Conditionals with Guard Clauses
guess: when the substring starts and follow that path.; Lesson 1799 — NFA Example: Substring Recognition Lesson 1837 — DPDA Limitations and Language Classes
Guessable: Humans choose predictable patterns; attackers use dictionaries and common passwords; Lesson 2517 — Knowledge Factors (Something You Know)
GUI Frameworks: Swing, JavaFX, and React all use composites—containers hold components or other containers, forming tree structures with uniform interfaces.; Lesson 2285 — Real-World Structural Pattern Examples
Guide normalization: – They're the foundation for organizing tables efficiently (you'll learn normalization soon!; Lesson 1621 — Introduction to Functional Dependencies

H

h(n): guides A* search by estimating the remaining cost from any node to the goal.; Lesson 1001 — Heuristic Functions in A*Lesson 1002 — The f(n) Evaluation Function Lesson 2752 — A* Search Algorithm
Hall's condition: .; Lesson 1048 — Hall's Marriage Theorem
halt: (stop executing):; Lesson 1856 — Accepting and Rejecting States Lesson 1871 — The Acceptance Problem for DFAs
Hamiltonian Cycle Problem: you learned previously—if you can solve TSP, you can solve Hamiltonian Cycle (just set all edge weights to 1).; Lesson 1922 — The Traveling Salesman Problem (TSP)
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
Handle addressing modes: Different architectures access memory differently; Lesson 2051 — Three-Address Code Translation
Handle alternatives: (the `|` choices in grammar rules); Lesson 1952 — Implementing Recursive Descent Functions
Handle asynchronous operations properly: Wait for specific conditions (element visible, API response complete) rather than arbitrary timeouts.; Lesson 2254 — E2E Testing Challenges and Best Practices
Handle complexity: behind a simple interface; Lesson 2264 — Introduction to Creational Patterns
Handle fragmentation: decide whether to split a large block or keep searching for a better fit; Lesson 2080 — Stack vs Heap: Allocation Speed
Handle leftovers: When one subarray runs out, copy all remaining elements from the other subarray; Lesson 754 — The Merge Operation
Handle retries themselves: (DNS queries—the application can resend if needed); Lesson 1486 — UDP Protocol Overview and Design Philosophy
Handle special cases: If the list is empty or has only one node, handle those separately; Lesson 333 — Deleting from the Tail
Handler executes: and services the interrupt; Lesson 1212 — Interrupt Vector Table
Handles cycles: Unlike reference counting, mark-and-sweep correctly identifies circular references as garbage if the cycle itself is unreachable; Lesson 2096 — Mark-and-Sweep Collection
Handles large relationships: No document size limits; Lesson 1724 — Embedding vs Referencing
Handshake Phase: Client and server authenticate using **digital certificates** (containing public keys).; Lesson 2442 — TLS: The Security Layer Behind HTTPS
Handwritten: Physical attachment only.; Lesson 2433 — Digital Signatures vs. Handwritten Signatures
Happens-Before (A → B): Vector clock VC(A) ≤ VC(B) *and* VC(A) ≠ VC(B).; Lesson 2633 — Detecting Causality with Vector Clocks
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 Lesson 2569 — Memory Ordering and Happens-Before
Hard affinity: The process is *locked* to specific CPUs and will never run elsewhere.; Lesson 1265 — Processor Affinity
Hard Disk Drive (HDD): ~5-10 milliseconds; Lesson 1110 — Access Time and Latency
Hard Disk Drives: Least expensive—multiple terabytes; Lesson 1111 — Cost Per Byte Analysis
Hard disk drives (HDD): magnetic storage; Lesson 1112 — Volatile vs Non-Volatile Memory
Hard links: Lesson 1419 — Hard Links vs Symbolic Links
Hard problem identified: Switch to approximate solutions, randomized algorithms, or special-case optimizations; Lesson 1937 — Practical Applications of Reductions
Hard to reverse: without special knowledge (given f(x), finding x is computationally infeasible); Lesson 2407 — Trapdoor Functions
Hard to solve: Finding the optimal selection requires examining many combinations—no known polynomial- time algorithm exists for the general case; Lesson 1924 — The Knapsack Problem
Hard to test: Mocking or isolating this class becomes nearly impossible because it touches everything; Lesson 2302 — God Object Anti-Pattern
Hard to understand: Mixed responsibilities create cognitive overload; Lesson 2338 — Divergent Change Smell
Harder to balance: More stages means more potential bottlenecks; Lesson 1156 — Deeper Pipelines: Benefits and Costs
hardware: the MMU automatically walks the page table without OS intervention.; Lesson 1363 — TLB Miss Handling Lesson 1396 — File System Layers and Architecture
Hardware complexity: More comparators needed to check all ways in parallel; Lesson 1136 — Associativity Impact on Conflict Misses
Hardware cost: ↑ (more comparators and multiplexers); Lesson 1134 — Comparing Associativity Tradeoffs
Hardware interaction: Operating system kernels, device drivers, and embedded systems often require direct hardware control that only assembly provides.; Lesson 1091 — Assembly Language Overview and Purpose
Hardware sets an: overflow flag** to signal this.; Lesson 1061 — Overflow Detection in Integer Arithmetic
Hardware Simplicity: Subtraction becomes addition with a negated operand.; Lesson 1059 — Two's Complement: The Standard for Signed Integers
Hardware-software integration: where changing course mid-development is costly; Lesson 2354 — Waterfall Strengths and Limitations
Harvard architecture: with physically separate instruction and data memories (or separate caches).; Lesson 1164 — Resolving Structural Hazards
hash: or **digest**.; Lesson 2420 — What is a Hash Function?Lesson 2438 — ECDSA (Elliptic Curve Digital Signature Algorithm)
Hash collisions: Independent hash operations have multiplicative collision probabilities; Lesson 116 — Independent Events Lesson 833 — Rabin-Karp: Collision Handling
hash function: is a mathematical function that takes a key (like a name, number, or word) and converts it into an **array index**.; Lesson 405 — What is a Hash Function?Lesson 832 — Rabin-Karp Algorithm: Rolling Hash Lesson 1689 — Hash Index Structure Lesson 2420 — What is a Hash Function?Lesson 2448 — Cipher Suites: Negotiating Encryption Algorithms
Hash function output range: Can be huge (potentially billions of values); Lesson 407 — Hash Function Output Range and Table Size
Hash function overhead: A complex hash that reduces collisions might actually slow things down; Lesson 441 — Benchmarking and Practical Performance
Hash indexes: shine for:; Lesson 1697 — Choosing Between B-Tree and Hash Indexes
Hash indexes cannot: Lesson 1688 — What Are Hash Indexes?
Hash indexes excel at: Lesson 1688 — What Are Hash Indexes?
Hash Join: Build a hash table from one input, probe with the other; Lesson 1698 — Query Execution Plans and Operators
hash table: gives O(1) lookups but can't efficiently track access order.; Lesson 449 — Implementing LRU Cache Lesson 630 — Tries vs Hash Tables for String Storage Lesson 1398 — Directory Implementation Strategies
Hash the key: O(1) to compute the hash; Lesson 433 — Average-Case Time Complexity Analysis Lesson 1729 — Hash-Based Key Distribution
Hash the message: – Create a fixed-size digest of your data; Lesson 2432 — What are Digital Signatures?
hashed: version of your password—never the plaintext.; Lesson 2496 — Username and Password Authentication Lesson 2513 — Password Reset Security
Hasse diagram: is a visual way to represent partial orders.; Lesson 74 — Partial Orders
HAVING: Filter groups based on aggregate calculations; Lesson 1597 — HAVING Clause for Filtering Groups Lesson 1598 — WHERE vs HAVING
Hazard Pointers: Threads announce which nodes they're using.; Lesson 2586 — ABA Problem in Lock-Free Structures
HBase: relies heavily on Hadoop's ecosystem.; Lesson 1745 — HBase and Other Column-Family Systems
HDDs with mixed workload: CFQ (fairness matters); Lesson 1430 — I/O Schedulers in Operating Systems
head: , and the last node points to `NULL` to signal the end of the list.; Lesson 324 — Introduction to Linked Lists Lesson 328 — Inserting at the Head Lesson 353 — Circular Doubly Linked Lists Lesson 673 — Adjacency List: Structure with Linked Lists Lesson 1517 — HTTP Methods: PUT, DELETE, and Others Lesson 1851 — Components of a Turing Machine Lesson 2170 — Creating a Git Repository Lesson 2571 — Lock-Free Queue: The Michael-Scott Algorithm
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 Lesson 327 — Traversing a Linked List Lesson 330 — Maintaining a Tail Pointer
Head position: – Where the read/write head is currently located on the tape; Lesson 1854 — Turing Machine Configuration
header: information before passing it down.; Lesson 1440 — Encapsulation and Layer Communication Lesson 1472 — TCP Segment Structure
Headers: provide metadata about the request—like extra instructions or context.; Lesson 1515 — HTTP Request Structure Lesson 1518 — HTTP Response Structure and Status Codes Lesson 2497 — Session Management Basics
heap: a large, flexible pool — *while your program runs*.; Lesson 322 — Dynamic Memory Allocation Basics Lesson 610 — Heap as Priority Queue Implementation Lesson 2078 — Heap Memory Fundamentals Lesson 2079 — Allocation and Deallocation on the Heap Lesson 2081 — Stack vs Heap: Lifetime and Scope
Heap Order (Value-based): The values must satisfy the min-heap or max-heap ordering property.; Lesson 582 — Heap Shape vs Heap Order
heap order property: relative to its children:; Lesson 585 — Heap Structure Invariants Lesson 586 — Heap Insert: Upward Bubbling Concept
Heap segment: Lesson 1378 — Segmentation Basics and Motivation
Heap Shape (Structural): The tree must be a **complete binary tree**.; Lesson 582 — Heap Shape vs Heap Order
Heap wins: O(V log V) < O(V²); Lesson 976 — Dijkstra's on Dense vs Sparse Graphs
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)Lesson 603 — The Sorting Phase: Extract-Max Repeatedly
Heaps excel at: Quickly accessing the maximum (or minimum) element, priority-based processing; Lesson 584 — Comparing Heaps to BSTs
Heapsort: guarantees O(n log n) in *all* cases—best, average, and worst.; Lesson 607 — Heapsort vs Quicksort vs Mergesort Lesson 777 — Heapsort Overview and Motivation Lesson 784 — Heapsort vs Quicksort Comparison Lesson 785 — Heapsort vs Mergesort Comparison Lesson 799 — When to Use Which Sorting Algorithm Lesson 800 — Hybrid Sorting Strategies
Heartbeats: Empty messages sent regularly to maintain authority and prevent new elections; Lesson 2661 — Raft RPCs: RequestVote and AppendEntries
height: tells you how far up from the deepest leaf below.; Lesson 454 — Node Depth and Height Lesson 455 — Tree Height and Level Lesson 456 — Subtrees and Their Properties Lesson 483 — Tree Height and Depth Lesson 492 — Calculating Tree Metrics Lesson 521 — BST Height and Balance Lesson 545 — AVL Trees vs Unbalanced BSTs Lesson 946 — Tree Diameter via DP (+1 more)
Heisenbug nature: Adding debugging code can change timing enough to hide the bug; Lesson 2555 — Race Conditions
Here's how it works: Lesson 350 — Traversing Circular Linked Lists
Hereditary property: If a set is independent, all its subsets are also independent (like how a subset of compatible activities is also compatible); Lesson 910 — Matroid Theory and Greedy Algorithms
heuristic function: (often denoted `h(n)`) to estimate how far each node is from the goal.; Lesson 1000 — Introduction to A* Search Lesson 2749 — Introduction to Informed Search Lesson 2750 — Heuristic Functions: Definition and Properties
heuristics: educated guesses based on patterns:; Lesson 1886 — Practical Approximations Lesson 1911 — Practical Impact of P vs NP
Hibernate/JPA: Lazy-loading proxies delay database queries until you actually access related entities.; Lesson 2285 — Real-World Structural Pattern Examples
Hidden bugs: Copied code may contain assumptions or edge cases you don't understand; Lesson 2306 — Cargo Cult Programming Anti-Pattern
Hidden dependencies: Classes that know too much about each other's internals; Lesson 2347 — Evaluating Design and Architecture
Hidden intent: The method's true purpose becomes obscured by implementation details.; Lesson 2330 — Long Method Smell
Hierarchical (or multi-level) paging: solves this by organizing page tables as a *tree* rather than a flat array.; Lesson 1358 — Hierarchical Page Tables
Hierarchical relationships: Employees and managers, categories and parent categories; Lesson 1583 — Self Join
Hierarchical/nested objects: (user profiles, product catalogs) → **Document stores**; Lesson 1715 — Choosing the Right NoSQL Category
Hierarchy tracking: PPIDs help the OS maintain the parent-child process tree; Lesson 1228 — Process IDs and Identification
high availability: , even during network issues.; Lesson 1734 — Eventual Consistency Trade-offs Lesson 2620 — Quorum-Based Consistency Lesson 2697 — Eventual Consistency Definition and Motivation
High bias: The model makes systematic errors due to wrong assumptions; Lesson 2809 — What is Underfitting?
High bias, low variance: Your arrows cluster tightly but consistently left of the bullseye (systematic error, but consistent).; Lesson 2782 — The Bias-Variance Tradeoff
High cohesion: means each module focuses on a single, well-defined responsibility.; Lesson 2318 — Code Organization and Module Structure
High consistency: = wait for all replicas to acknowledge → slower responses; Lesson 2609 — Beyond CAP: PACELC and Modern Perspectives
High contention: A waiting queue is more efficient than spinning retries; Lesson 2574 — Performance Characteristics of Lock-Free Algorithms
High load factor: As the table fills up (especially with open addressing), collisions multiply.; Lesson 434 — Worst-Case Time Complexity Scenarios
High selectivity: Your `WHERE` clause filters out most rows (e.; Lesson 1702 — Index Selection for Queries
High threshold (e.g., 0.9): Maximizes memory efficiency by keeping the table fuller.; Lesson 440 — Space-Time Tradeoffs in Hash Tables
High training error: Poor performance even on data the model has seen; Lesson 2809 — What is Underfitting?
high variance: in your performance estimate.; Lesson 2801 — Holdout Method Limitations Lesson 2802 — Leave-One-Out Cross-Validation
High write throughput: for massive data volumes; Lesson 1717 — NoSQL vs SQL: Complementary Approaches Lesson 2641 — Multi-Leader Replication
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-level IR: early for source-level optimizations and portability; Lesson 2038 — High-Level vs Low-Level IR Lesson 2048 — Lowering Through Multiple IR Levels
High-variance models: (like deep neural networks or complex trees) can appear to perform very differently depending on the split, making it hard to know their true capability.; Lesson 2801 — Holdout Method Limitations
High-volume social media feeds: If a "like" count is briefly inconsistent between users, that's often acceptable.; Lesson 1665 — ACID Tradeoffs and Real-World Implications
Higher risk: Critical defects may emerge very late in the development cycle; Lesson 2236 — Big Bang Integration Strategy
Higher term wins: If a node receives a message with a higher term, it immediately updates its own term and reverts to follower state.; Lesson 2660 — Terms and the Logical Clock in Raft
Higher threshold (e.g., 0.7): More conservative, reduces false positives but may miss true positives; Lesson 2829 — Interpreting Probabilities and Decision Boundaries
Higher-rank polymorphism: When polymorphic functions are passed as arguments or returned from functions, determining where to instantiate type variables becomes ambiguous; Lesson 2014 — Type Inference Limitations
Highly normalized schemas: (3NF or BCNF) to minimize data redundancy; Lesson 1650 — OLTP vs OLAP Database Design
Highway: Connects downtown to suburbs, but you can't return (not part of any SCC with others); Lesson 734 — Strongly Connected Components in Directed Graphs
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
hinted handoff: (returning data to the correct nodes when they recover).; Lesson 2644 — Quorums and Sloppy Quorums Lesson 2705 — Read Repair and Hinted Handoff Lesson 2706 — Eventual Consistency in Practice: Dynamo and Cassandra
Historical data: spanning months or years; Lesson 1650 — OLTP vs OLAP Database Design
History heuristic: (moves that historically performed well); Lesson 2769 — Move Ordering in Alpha-Beta
Hit null: The value doesn't exist in the tree; Lesson 503 — BST Search: Finding a Node
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 Penalty Lesson 1115 — Effective Access Time Calculation Lesson 1125 — Measuring Cache Effectiveness Lesson 1138 — Cache Hit and Miss Definitions Lesson 1139 — Cache Hit Rate and Miss Rate
Hit Time: How fast you access data when it's in the cache (e.; Lesson 1115 — Effective Access Time Calculation Lesson 1125 — Measuring Cache Effectiveness Lesson 1140 — Average Memory Access Time (AMAT)
HMaster: Coordinates the cluster, assigns regions, handles schema changes; Lesson 1745 — HBase and Other Column-Family Systems
Hoare: You hand the baton directly to the next runner, who starts immediately; Lesson 1312 — Condition Variable Mesa vs Hoare Semantics
Hoare Partition Scheme: is an alternative to Lomuto's approach.; Lesson 766 — Hoare Partition Scheme
Hoare semantics: (signal-and-wait).; Lesson 1312 — Condition Variable Mesa vs Hoare Semantics
Hoare semantics (signal-and-wait): The signaling thread **immediately** blocks and transfers execution directly to the waiting thread.; Lesson 1312 — Condition Variable Mesa vs Hoare Semantics
Hold and Wait: A process holding at least one resource is waiting to acquire additional resources held by other processes; Lesson 1314 — What is Deadlock?
Holding values stable: during the next clock cycle; Lesson 1150 — Pipeline Registers and Latches
Horizontal Partitioning: splits data by **rows**.; Lesson 2683 — Horizontal vs Vertical Partitioning Lesson 2684 — Sharding Fundamentals
Horizontal privilege escalation: Regular users accessing other regular users' resources; Lesson 2488 — Broken Access Control
Horizontal scalability: NoSQL databases distribute data across many commodity servers easily, handling growth by adding more machines rather than upgrading expensive hardware.; Lesson 1708 — What is NoSQL and Why It Exists Lesson 1717 — NoSQL vs SQL: Complementary Approaches
Horizontal scaling: with simple sharding → Key-Value or Column family stores; Lesson 1715 — Choosing the Right NoSQL Category
Horizontal scaling limits: Traditional databases struggled to distribute across thousands of machines; Lesson 1708 — What is NoSQL and Why It Exists
host: is any device on the network that can send or receive data.; Lesson 1431 — Introduction to Computer Networks Lesson 1463 — Subnet Masks and Network/Host Portions
host portion: (which identifies individual devices on that network).; Lesson 1463 — Subnet Masks and Network/Host Portions Lesson 1464 — Subnetting Fundamentals
Hostname/address: Where the database server lives (e.; Lesson 1562 — Database Connection and Basic Structure
Hot spots: If new data clusters in one range (e.; Lesson 2686 — Range-Based Partitioning
Hotfix branches: branch from `main` for urgent production bugs; merge back to both `main` and `develop`; Lesson 2197 — Gitflow Workflow
Hotfixes: `hotfix/security-patch`; Lesson 2193 — Branch Management Best Practices
Hotspots: arise when some partitions receive far more read or write requests than their peers, overwhelming them while leaving other nodes idle.; Lesson 2690 — Handling Data Skew and Hotspots
how: they compute and store results.; Lesson 918 — Top-Down vs Bottom-Up Tradeoffs Lesson 1038 — Ford-Fulkerson Method Lesson 2011 — Algorithm W Lesson 2112 — What is Imperative Programming?Lesson 2321 — Rename Variable/Method: Improving Semantic Clarity Lesson 2342 — Preparing Code for Review
How are they passed: Lesson 1208 — System Call Parameters and Return Values
How it works: Lesson 550 — Insertion Case 2: Uncle is Black, Triangle Configuration Lesson 1406 — File System Consistency and Journaling Lesson 1449 — Flow Control Mechanisms Lesson 2392 — Deployment Strategies: Blue-Green and Canary Lesson 2538 — OAuth 2.0 Grant Types: Client Credentials and Resource Owner Password Lesson 2582 — Concurrent Hash Map: Basics
How many levels: Starting with n elements, we divide by 2 each time until reaching size 1.; Lesson 756 — Mergesort Time Complexity Analysis
How to use it: Without reading the implementation; Lesson 206 — Function Signatures and Contracts
How we get there: (actions); Lesson 2727 — State Space Definition and Components
HSTS preload lists: hardcoded databases of domains that should *always* use HTTPS, even on the very first visit.; Lesson 2453 — HTTPS Best Practices and HSTS
HTML context: Encode `<`, `>`, `&`, `"`, `'` to their HTML entity equivalents; Lesson 2460 — Output Encoding and Escaping
HTTP headers: Referer, User-Agent (when displayed on pages); Lesson 2458 — XSS Attack Vectors and Payloads
HTTP request: to a server.; Lesson 1515 — HTTP Request Structure
HTTP Secure: .; Lesson 1524 — Introduction to HTTPS
HTTP/3: is simply HTTP running on top of QUIC instead of TCP.; Lesson 1527 — HTTP/3 and QUIC
HTTPS-to-HTTP transitions: often drop the Referer header; Lesson 2470 — Origin and Referer Header Validation
hubs: and **switches** physically connect multiple devices, but they handle incoming frames very differently.; Lesson 1454 — Network Switches vs Hubs Lesson 1456 — Broadcast and Collision Domains
Huffman Coding: Build heap O(n), then extract min repeatedly O(n log n); Lesson 887 — Greedy Algorithm Complexity
Human limits are real: Tired developers write buggy code, make poor design decisions, and skip tests.; Lesson 2368 — Sustainable Development Pace
hybrid approach: , the logical address space is first divided into segments (code, stack, heap), but then *each segment* is divided into fixed-size pages.; Lesson 1384 — Segmentation with Paging (Hybrid Approach)Lesson 2036 — Real-World Examples: C, Python, and JavaScript Lesson 2111 — Hybrid Approaches
hybrid approaches: Quicksort for general cases, switching to Insertion Sort for small subarrays, and sometimes incorporating Heapsort as a fallback.; Lesson 799 — When to Use Which Sorting Algorithm Lesson 1398 — Directory Implementation Strategies
Hybrid kernels: attempt exactly that.; Lesson 1197 — Hybrid Kernel Designs
Hybrid Logical Clocks (HLC): marry these two worlds.; Lesson 2636 — Hybrid Logical Clocks
Hybrid normalization strategies: involve keeping your critical, frequently-updated data fully normalized (often in 3NF or BCNF) while strategically denormalizing specific tables or columns that serve high-traffic read queries.; Lesson 1653 — Hybrid Normalization Strategies
Hybrid Pattern: Combines both approaches—some tables form chains while others branch from a central point.; Lesson 1587 — Multi-Table Join Patterns
Hybrid predictors: extend this by potentially combining predictor outputs or using more than two base predictors.; Lesson 1183 — Tournament and Hybrid Predictors
hybrid sorting algorithm: that combines the strengths of quicksort, heapsort, and insertion sort while avoiding their individual weaknesses.; Lesson 801 — Introsort: The Best of Both Worlds Lesson 802 — Timsort: Python's Default Sorting Algorithm

I

I/O Burst: A period when the process waits for input/output operations to complete (reading a file, waiting for user input, sending network data); Lesson 1242 — CPU Burst and I/O Burst Cycles
I/O management: as core services.; Lesson 1201 — Core OS Services: File Systems and I/O
I/O multiplexing: mechanisms like `poll()` and `epoll()` solve this elegantly:; Lesson 1549 — Non-Blocking Sockets and I/O Multiplexing
I/O schedulers: that translate those ideas into production code with practical tradeoffs.; Lesson 1430 — I/O Schedulers in Operating Systems
I/O status: Open files, allocated devices, pending I/O operations; Lesson 1217 — Process Control Block (PCB)
I/O-bound processes: spend most of their time waiting for input/output operations to complete—like text editors waiting for keystrokes, databases fetching from disk, or web servers handling network requests.; Lesson 1250 — CPU-Bound vs I/O-Bound Processes Lesson 1260 — Multilevel Feedback Queue Scheduling
ID Token: alongside OAuth's access token.; Lesson 2541 — OpenID Connect: Adding Identity to OAuth 2.0 Lesson 2542 — ID Tokens and JWT Structure in OpenID Connect
ID/EX register: holds decoded operation codes and register values.; Lesson 1150 — Pipeline Registers and Latches
IDA: * (Iterative Deepening A*) merges two concepts you already know: **Iterative Deepening DFS** and **A* Search**.; Lesson 2761 — IDA* (Iterative Deepening A*)
Idempotence: `r|r = r` (union with itself); Lesson 1776 — Regular Expression Equivalence
Idempotency: so duplicate messages don't cause incorrect state changes; Lesson 2592 — Message Loss and Ordering
Idempotent: Multiple identical GET requests should have the same effect—just retrieving data, never modifying it; Lesson 1516 — HTTP Methods: GET and POST Lesson 1517 — HTTP Methods: PUT, DELETE, and Others Lesson 2703 — Conflict-Free Replicated Data Types (CRDTs)Lesson 2726 — Best Practices for Distributed Transactions
Idempotent and read-only GET: Your `GET` endpoints should be safe to call multiple times with identical results and zero side effects.; Lesson 2472 — State-Changing Operations and Safe Methods
Idempotent processing: (handling duplicates gracefully); Lesson 2710 — At-Most-Once, At-Least-Once, Exactly-Once Delivery
IDENTIFIER: (pattern: letter followed by letters/digits); Lesson 1939 — Tokens, Lexemes, and Patterns Lesson 1940 — Token Classification Lesson 1941 — Lexical Specification with Regular Expressions
Identify a sibling: with more than the minimum number of keys (it has extras to share); Lesson 565 — Borrowing Keys from Siblings
Identify base cases: What are the simplest strings in your language?; Lesson 1818 — Designing CFGs for Simple Languages
Identify its parent node: Lesson 508 — BST Deletion: Leaf Node Case
Identify real bottlenecks: based on data, not guesses; Lesson 2305 — Premature Optimization Anti-Pattern
Identify runs: Scan the array for naturally occurring sorted subsequences (called "runs").; Lesson 802 — Timsort: Python's Default Sorting Algorithm
Identify the child: Determine whether the node has a left child or right child; Lesson 509 — BST Deletion: One Child Case
Identify the dependency: Does row `i` only depend on row `i-1`?; Lesson 956 — Space Optimization with Rolling Arrays
Identify the full node: – The node has reached its maximum key capacity; Lesson 1681 — Node Splitting During Insertion
Identify the median key: in the full node; Lesson 561 — Node Splitting During Insertion
Identify the random variable: (e.; Lesson 137 — Expected Value and Variance in Algorithm Analysis
Identify the self-similarity: How does a smaller version of the problem relate to the larger one?; Lesson 866 — Problem Decomposition in Recursion
Identify the simplest case: (base case) that requires no further breakdown; Lesson 225 — Recursive Problem Decomposition
Identify the starting value: Determine whether your statement begins at `n = 0`, `n = 1`, or some other initial value.; Lesson 87 — Base Case: Starting the Proof
Identify the subject(s): Who or what are we discussing?; Lesson 51 — Translating English to Predicate Logic
Identify the unbalanced node: (let's call it `A`) with balance factor -2; Lesson 536 — Single Left Rotation
Identify the violating FD: Find a functional dependency `X → Y` where `X` is not a candidate key; Lesson 1641 — Achieving BCNF
Identifying transitive dependencies: – Find non-key attributes that determine other non-key attributes; Lesson 1639 — Achieving Third Normal Form
Identity: Keys are already 0 to N-1; Lesson 410 — Hashing Integers Lesson 1776 — Regular Expression Equivalence Lesson 2142 — Functors and Mappable Types
Identity Element: The empty string `ε` acts as the identity: `xε = εx = x`.; Lesson 1758 — String Operations: Concatenation Lesson 1769 — Union and Concatenation Properties
Identity for concatenation: For any string `w`, concatenating with ε doesn't change it:; Lesson 1757 — The Empty String and String Length Lesson 1764 — The Empty Language vs Empty String
IEEE 754 Single Precision: format is the most common way computers store floating-point numbers.; Lesson 1065 — IEEE 754 Standard: Single Precision
If: something has property P, **then** Q must hold.; Lesson 55 — Quantifiers Over Restricted Domains Lesson 167 — The if Statement
If all voted "yes": Coordinator sends "commit" to everyone.; Lesson 2718 — Two-Phase Commit (2PC) Protocol
if and only if: you score 60% or higher.; Lesson 38 — Biconditional Statements Lesson 1801 — NFA-DFA Equivalence Theorem Lesson 1916 — Cook-Levin Theorem
If any voted "no": (or timeout): Coordinator sends "abort" to everyone.; Lesson 2718 — Two-Phase Commit (2PC) Protocol
If characters match: (`X[i-1] == Y[j-1]`): the LCS grows by 1; Lesson 925 — Longest Common Subsequence (LCS)
If combining dominates: The answer is driven by the combining work; Lesson 843 — Master Theorem Introduction
If false, call wait(): this atomically releases the mutex and sleeps; Lesson 1306 — The Wait-Signal Pattern
If guard is false: `if false then s₁ else s₂ → s₂`; Lesson 2022 — Operational Semantics of Conditionals
If guard is true: `if true then s₁ else s₂ → s₁`; Lesson 2022 — Operational Semantics of Conditionals
If heap order violated: (e.; Lesson 587 — Implementing Heap Insert
If no: Make the problem smaller and call yourself again (recursive case); Lesson 218 — Base Case and Recursive Case
If no goal found: , repeat with the new threshold set to that minimum value; Lesson 2761 — IDA* (Iterative Deepening A*)
If no overlap: , ignore that subtree entirely; Lesson 644 — Range Query Operations
If not empty: Lesson 342 — Inserting at the Tail of a Doubly Linked List
If one string ends: while the other continues, the shorter string comes first; Lesson 267 — String Comparison: Character-by-Character
If P = NP: Breaking encryption would become as easy as creating it.; Lesson 1907 — Implications if P = NP
If recursion dominates: The answer is driven by how many leaves your recursion tree has; Lesson 843 — Master Theorem Introduction
If tests fail: , you know instantly what broke—revert or fix it; Lesson 2261 — Refactoring with Confidence
If tests pass: , you've successfully improved the code without regression; Lesson 2261 — Refactoring with Confidence
If the check fails: , the follower rejects the RPC.; Lesson 2667 — Handling Log Inconsistencies
If there's a zero: Including it gives a product of 0, which is often minimal (unless all numbers are positive and you can pick none); Lesson 898 — Minimum Product Subset
If they differ: , the string with the "smaller" character (earlier in alphabetical order) comes first; Lesson 267 — String Comparison: Character-by-Character
If they don't match: take the best result from either ignoring one character from X or one from Y; Lesson 925 — Longest Common Subsequence (LCS)
If they match: , move to the next index and repeat; Lesson 267 — String Comparison: Character-by-Character
If they're balanced: You get an extra log factor; Lesson 843 — Master Theorem Introduction
If yes: Return the answer directly (stop recursing); Lesson 218 — Base Case and Recursive Case
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
IF/ID register: (between Fetch and Decode) might store the fetched instruction bits and updated program counter.; Lesson 1150 — Pipeline Registers and Latches
Ignore it: The answer automatically wraps around correctly.; Lesson 1060 — Two's Complement Arithmetic Operations
Illegal state transitions: (withdrawing from empty account); Lesson 2231 — Testing Exception Handling
Image processing: Video frames (width, height, time); Lesson 247 — 3D Arrays and Higher Dimensions
Image segmentation: Separating foreground from background in computer vision; Lesson 1032 — Applications of Maximum Flow
Image tags: `<img src="https://bank.; Lesson 2472 — State-Changing Operations and Safe Methods
Images and Graphics: Digital images are grids of pixels.; Lesson 249 — Practical Applications of Multidimensional Arrays
Imbalanced classes: amplify the problem.; Lesson 2801 — Holdout Method Limitations
Immediacy: Data might not appear immediately—it sits in the buffer until flushed (manually, when the buffer fills, or at program exit); Lesson 1395 — Standard I/O and Buffering
Immediate to Register: Lesson 1095 — MOV and Data Transfer Instructions
immediately: blocks and transfers execution directly to the waiting thread.; Lesson 1312 — Condition Variable Mesa vs Hoare Semantics Lesson 2104 — Reference Counting Fundamentals
Immediately exits the function: – no code after the return runs; Lesson 189 — Return Statements
Immutability: is the broader idea that once something is created, it cannot be altered.; Lesson 148 — Constants and Immutability Lesson 2132 — Pure Functions and Immutability Lesson 2270 — Builder Pattern for Complex Objects Lesson 2565 — Thread Safety Strategies
immutable: once created, they cannot be changed.; Lesson 262 — String Immutability Lesson 269 — String Building and Concatenation Efficiency
Impact: Automated attacks can compromise thousands of accounts quickly.; Lesson 2503 — Authentication Security Considerations
Imperative: often wins on raw speed.; Lesson 2146 — Functional vs Imperative Tradeoffs Lesson 2147 — Declarative vs Imperative: Philosophy and Examples
Imperative approach: "Walk to aisle 5, turn left, go to the third shelf, scan titles from left to right until you find *The Great Gatsby*.; Lesson 2166 — Logic vs Imperative Programming
Imperative example concept: (building on previous lessons):; Lesson 2147 — Declarative vs Imperative: Philosophy and Examples
Imperfect Distribution: Lesson 417 — Collision Definition and Causes
Implement proper access controls: at the OS and application level; Lesson 2489 — Path Traversal and File Inclusion
implementation: Lesson 355 — What is an Abstract Data Type (ADT)?Lesson 1045 — Maximum Flow Algorithm Comparison Lesson 2353 — The Waterfall Model: Sequential Phases
Implementation (coding): → paired with **Unit Testing**; Lesson 2355 — The V-Model: Verification and Validation
Implementation A: 10 operations per lookup; Lesson 441 — Benchmarking and Practical Performance
Implementation B: 1000 operations per lookup; Lesson 441 — Benchmarking and Practical Performance
Implementation hierarchy: Platform-specific details (e.; Lesson 2275 — Bridge Pattern: Separating Abstraction from Implementation
Implementation phase: Convert to a DFA using subset construction for efficient execution; Lesson 1802 — Why Use NFAs: Design vs Implementation
Implementing: correct insertion and search operations; Lesson 500 — BST Range Property
implication: (or conditional statement) has the form "if P, then Q," written as `P → Q`.; Lesson 36 — Conditional Statements (Implication)Lesson 55 — Quantifiers Over Restricted Domains
implicit: in the index positions.; Lesson 464 — Advantages of Array-Based Representation Lesson 2728 — Initial State and Goal States
Implicit casting: (also called automatic conversion) happens when the compiler safely converts a value for you.; Lesson 151 — Type Casting Fundamentals
Implicit Grant: was designed for JavaScript apps running in browsers where keeping client secrets secure is impossible.; Lesson 2537 — OAuth 2.0 Grant Types: Implicit and PKCE
Implicit state spaces: generate states dynamically as needed during search.; Lesson 2736 — Explicit vs Implicit State Spaces
Implicit suffixes: Delay creating certain nodes until absolutely necessary; Lesson 635 — Suffix Tree Construction Overview
Implicit waits: set a global timeout: "Wait up to X seconds for *any* element to appear before failing.; Lesson 2252 — Handling Asynchronous Operations
Implicitly: Using the function call stack (recursive DFS); Lesson 709 — DFS Overview and Intuition
Important limitation: A CNAME cannot coexist with other record types for the same name (like A or MX records).; Lesson 1505 — DNS Record Types: CNAME and MX
Impractical: processes often don't know all needed resources in advance; Lesson 1320 — Deadlock Prevention: Breaking Hold and Wait
Improve readability: Named procedures communicate intent better than raw commands; Lesson 2118 — Procedural Abstraction
Improves Design: Lesson 2257 — Writing Tests Before Implementation
Improves readability: One clear entry point instead of many scattered calls; Lesson 2278 — Facade Pattern: Simplifying Complex Subsystems
Improves runtime performance: (fewer instructions to execute); Lesson 2063 — Dead Code Elimination
In a BST: You could find any value efficiently by comparing at each node and going left or right.; Lesson 584 — Comparing Heaps to BSTs
In a heap: The only guarantee is that 50 is at the root (max-heap), and each parent is larger than its children.; Lesson 584 — Comparing Heaps to BSTs
In directed graphs: The direction matters.; Lesson 690 — Cyclic and Acyclic Graphs
In Open Addressing: Lesson 432 — Load Factor and Its Impact on Performance
in parallel: in a single clock cycle; Lesson 1131 — Associative Cache Lookup and CAM Lesson 2255 — CI/CD Integration for E2E Tests
In Separate Chaining: Lesson 432 — Load Factor and Its Impact on Performance
In the child process: `fork()` returns `0`; Lesson 1222 — Process Creation: fork() System Call
In the FROM clause: treating the subquery result as a temporary table; Lesson 1601 — Introduction to Subqueries
In the parent process: `fork()` returns the child's process ID (PID), a positive integer; Lesson 1222 — Process Creation: fork() System Call
In the SELECT clause: to compute a value for each row; Lesson 1601 — Introduction to Subqueries
In the WHERE clause: (most common) - for filtering based on calculated values; Lesson 1601 — Introduction to Subqueries
In undirected graphs: A cycle requires at least three vertices forming a loop (A → B→ C→ A).; Lesson 690 — Cyclic and Acyclic Graphs
In-band: attacks are the most straightforward: the attacker uses the *same communication channel* to both launch the attack and gather results.; Lesson 2476 — Types of SQL Injection Attacks
In-degree: The number of edges *coming into* the vertex; Lesson 661 — Degree of a Vertex
in-place: using the same array that holds your data—no extra memory needed beyond a few variables.; Lesson 601 — Heapsort Overview and Basic Idea Lesson 606 — Heapsort Space Complexity and Stability Lesson 739 — In-Place vs Out-of-Place Sorting Lesson 745 — Selection Sort: Analysis Lesson 748 — Insertion Sort: Analysis Lesson 750 — When to Use Elementary Sorts Lesson 763 — The Partition Operation: Core of Quicksort Lesson 782 — Heapsort Space Complexity (+1 more)
In-place sorting: algorithms rearrange elements within the original data structure, using only a constant amount of extra memory — O(1) space.; Lesson 739 — In-Place vs Out-of-Place Sorting Lesson 774 — Quicksort vs Mergesort: Practical Comparison Lesson 777 — Heapsort Overview and Motivation Lesson 804 — In-Place vs Out-of-Place Tradeoffs
In-place updates: Sometimes you can reuse the same array by carefully ordering your computations.; Lesson 922 — Space Optimization Techniques
Inbound translation: When a reply arrives at `203.; Lesson 1491 — UDP and Network Address Translation (NAT)
Include: the element → add it to your current subset → recurse to the next element; Lesson 859 — Generating All Subsets Lesson 945 — Maximum Independent Set on Trees
Include context: Don't just say "Invalid input.; Lesson 2317 — Error Handling and Exception Messages
Include it: Get its value, but reduce remaining capacity; Lesson 930 — 0/1 Knapsack Problem Lesson 945 — Maximum Independent Set on Trees
including: `node`; Lesson 945 — Maximum Independent Set on Trees Lesson 948 — DP on Binary Trees
Inclusion-Exclusion Principle: fixes this by systematically correcting for overlaps.; Lesson 106 — Inclusion-Exclusion Principle
Incoming packet: Source = `93.; Lesson 1466 — Network Address Translation (NAT)
Inconsistency risk: Easy to miss one instance, creating behavior discrepancies; Lesson 2332 — Duplicate Code Smell
inconsistent state: .; Lesson 2589 — Network Partitions and Split-Brain Lesson 2597 — Concurrency and Race Conditions
Incorporate feedback quickly: Each iteration can adjust based on what you learned; Lesson 2366 — Iterative and Incremental Development
Incorrect Initialization: Lesson 1302 — Semaphore Pitfalls and Common Errors
increase: in a min-heap), you're making it "weaker"—it might now be out of order with its *children*.; Lesson 594 — Increase/Decrease Key Operations Lesson 2858 — AdaBoost Algorithm
Increase periodically: Review and increment the cost factor every few years as hardware advances.; Lesson 2507 — Password Hashing with bcrypt
Increase the shortest towers: by `k` to pull them up; Lesson 901 — Minimize Maximum Difference in Heights
Increase/Decrease Key: O(log n) — may require bubbling up or down; Lesson 599 — Heap Operation Trade-offs
Increased bandwidth: Traffic is distributed across all member links, multiplying your effective throughput.; Lesson 1460 — Link Aggregation
Increased computational cost: More dimensions mean more calculations per distance computation; Lesson 2871 — Handling High-Dimensional Data
Increased hazard complexity: More opportunities for data, control, and structural hazards; Lesson 1156 — Deeper Pipelines: Benefits and Costs
Increased miss penalty: Fetching a 128-byte block takes longer than fetching 16 bytes.; Lesson 1146 — Impact of Block Size on Performance
Increased storage: You're storing the same data (like customer names) repeatedly across many rows instead of once.; Lesson 1647 — Read Performance vs Write Complexity
Increment: After fetching, the PC automatically updates to point to the next instruction (typically PC = PC + instruction_size); Lesson 1074 — Program Counter (PC)Lesson 2105 — Reference Count Operations Lesson 2356 — Iterative and Incremental Development Lesson 2378 — Scrum Artifacts: Sprint Backlog and Increment
Increment/Decrement: `x++`, `--y` modify the variable; Lesson 164 — Expression Evaluation and Side Effects Lesson 2557 — Atomic Operations
Incremental Builds: Only rebuild what changed.; Lesson 2388 — CI Best Practices: Fast Feedback
Incremental collection: interleaves garbage collection work with normal program execution.; Lesson 2100 — Stop-the-World vs Incremental Collection
Incremental construction: Build the tree character by character from left to right; Lesson 635 — Suffix Tree Construction Overview
Incremental update barriers: Record the *new* reference being created; Lesson 2102 — Write Barriers
Independence: In SVN, you need network access to commit your work.; Lesson 2168 — Git vs Other Version Control Systems Lesson 2684 — Sharding Fundamentals
independent: if knowing that one occurred doesn't change the probability of the other occurring.; Lesson 116 — Independent Events Lesson 219 — Anatomy of a Recursive Call
independent set: in a graph is a collection of vertices where *no two vertices are connected by an edge*.; Lesson 1919 — The Independent Set Problem Lesson 1935 — Vertex Cover and Clique Reductions
Independent Set Problem: asks: "Given a graph *G* and an integer *k*, does there exist an independent set of at least *k* vertices?; Lesson 1919 — The Independent Set Problem Lesson 1920 — The Vertex Cover Problem
Independent subproblems: Breaking the problem into smaller pieces creates subproblems that can be solved *separately* without needing information from each other.; Lesson 855 — When to Use Divide and Conquer
Independent/Equal: VC(A) = VC(B) only when they're literally the same event.; Lesson 2633 — Detecting Causality with Vector Clocks
index: , 1 is the **lower bound**, and 5 is the **upper bound**.; Lesson 85 — Summation Notation and Series Lesson 1127 — Cache Address Breakdown Lesson 1128 — Direct-Mapped Cache Lookup Lesson 1135 — Cache Placement Example Calculations Lesson 1380 — Logical Address Translation in Segmentation Lesson 2667 — Handling Log Inconsistencies
Index boundary checks: Since parent-child relationships use formulas like `parent = (i-1)//2`, verify you never access negative indices or go beyond array bounds during bubble operations.; Lesson 600 — Practical Heap Implementation Considerations
Index covers the query: All needed columns exist in the index itself; Lesson 1702 — Index Selection for Queries
Index Scan: Use an index (B-tree or hash) to find specific rows quickly; Lesson 1698 — Query Execution Plans and Operators
Index selectivity: What percentage of rows match typical conditions; Lesson 1699 — Cost-Based Query Optimization
Index statistics: Unique value counts, min/max values; Lesson 1700 — Cardinality Estimation
Index tracking: When sorting by a key that might have duplicates, include the original position as a tie-breaker; Lesson 803 — Stability in Production Sorting
Indexed access: Each element has a numeric position, typically starting at index 0.; Lesson 232 — What is an Array?Lesson 526 — Comparing BST to Array and Linked List
indexing: comes in—think of it like apartment numbers in a building.; Lesson 234 — Array Indexing and Access Lesson 260 — Strings as Arrays of Characters
Indirect left recursion: is trickier:; Lesson 1953 — Left Recursion Problem
Individuals and interactions: over processes and tools; Lesson 2361 — The Agile Manifesto
Inductive: Assume P(k) is true; prove P(k+1) follows; Lesson 86 — The Principle of Mathematical Induction
inductive hypothesis: ).; Lesson 86 — The Principle of Mathematical Induction Lesson 88 — Inductive Hypothesis Lesson 89 — Inductive Step: The Core Argument Lesson 90 — Summing Series by Induction Lesson 91 — Divisibility Proofs by Induction Lesson 92 — Inequality Proofs by Induction Lesson 93 — Strong Induction Lesson 94 — Structural Induction (+1 more)
Inductive Step: , you assume your statement is true for some arbitrary value n=k (this is your **Inductive Hypothesis** from the previous lesson), and then use that assumption to *prove* it must also be true for n=k+1.; Lesson 89 — Inductive Step: The Core Argument Lesson 90 — Summing Series by Induction Lesson 91 — Divisibility Proofs by Induction Lesson 92 — Inequality Proofs by Induction Lesson 93 — Strong Induction Lesson 94 — Structural Induction Lesson 95 — Common Induction Mistakes Lesson 97 — Induction in Algorithm Analysis (+3 more)
Industry standard: Used in graph databases and scientific computing libraries; Lesson 683 — Hybrid and Compressed Representations
Inefficiency: – Many parts of a program sit idle (initialization code, error handlers, rarely-used features); Lesson 1338 — Motivation for Virtual Memory
Infer overly general types: The principal type might be correct but not what the programmer intended; Lesson 2014 — Type Inference Limitations
Inference mode ( ↑): Expressions with clear structure (variables, function applications) *synthesize* their type and push it up.; Lesson 2015 — Bidirectional Type Checking
Infers: `id` has type `α → α` (using a type variable); Lesson 2013 — Let-Polymorphism
Infinite data structures: You can define conceptually infinite sequences (like all natural numbers) and only compute the elements you actually access.; Lesson 2139 — Lazy Evaluation
Infinite recursion: Bugs that never hit a base case will eventually overflow.; Lesson 2077 — Stack Growth and Limitations
Infinite Virtual Registers: Instead of worrying about a CPU's limited physical registers, LLVM IR assumes you have as many virtual registers as needed (like `%1`, `%2`, `%result`).; Lesson 2045 — LLVM IR Overview
infinity: (∞), meaning "unreachable so far.; Lesson 968 — Algorithm Initialization and Data Structures Lesson 1068 — Special Floating-Point Values: Infinity and NaN
Infix evaluation: is trickier because of precedence (multiplication before addition) and parentheses.; Lesson 365 — Expression Evaluation: Infix, Prefix, Postfix
Inflexibility: – Programs must fit entirely in memory to run; Lesson 1338 — Motivation for Virtual Memory
Informal, intuitive concept: "algorithm" or "effective procedure" (something a human could carry out mechanically with paper and pencil); Lesson 1866 — Why the Thesis Cannot Be Proven
Information Maintenance: Lesson 1206 — System Call Categories
Informed search: (also called *heuristic search*) uses a **heuristic function**—a problem-specific estimate of how far a state is from the goal.; Lesson 2749 — Introduction to Informed Search
Infrequent checks: (e.; Lesson 1326 — Deadlock Detection Algorithms
Inheritance: If `A → αB` or `A → αBβ` where β derives ε, add FOLLOW(A) to FOLLOW(B); Lesson 1957 — FOLLOW Sets Lesson 2126 — Inheritance Fundamentals Lesson 2129 — Composition vs Inheritance Lesson 2282 — Decorator vs Inheritance: Flexible Extension
Inherits: all accessible fields and methods from the parent; Lesson 2126 — Inheritance Fundamentals
Initial and final permutations: (shuffling bit positions); Lesson 2400 — DES: The Data Encryption Standard
Initial Configuration: Lesson 1858 — Computing with a Turing Machine
Initial congestion window: Larger values speed up slow start; Lesson 1485 — TCP Performance Considerations
Initial Sequence Number (ISN): .; Lesson 1475 — Sequence Numbers and Acknowledgments
Initial values: `a(0) = 0`, `a(1) = 1`; Lesson 84 — Recurrence Relations
Initial window: Start with a small cwnd (typically 1-10 segments); Lesson 1478 — TCP Congestion Control: Slow Start
Initialization: The invariant is true before the loop starts; Lesson 97 — Induction in Algorithm Analysis Lesson 145 — Variable Initialization Lesson 178 — Infinite Loops and Termination Lesson 179 — The For Loop Lesson 180 — Loop Initialization, Condition, and Update Lesson 973 — Dijkstra's with Binary Heap Priority Queue Lesson 997 — Path Reconstruction in Floyd-Warshall
Initialization Phase: Lesson 984 — Bellman-Ford Implementation
Initialize: the variable before the loop starts; Lesson 177 — Loop Control Variables Lesson 429 — Rehashing Process Lesson 447 — Frequency Counting and Histograms Lesson 613 — Dijkstra's Algorithm with Priority Queue Lesson 616 — Merging K Sorted Lists Lesson 617 — Load Balancing Systems Lesson 723 — Kahn's Algorithm: Implementation Lesson 873 — Recursion with Memoization Integration (+7 more)
Initialize a table: (array) to store solutions to subproblems; Lesson 917 — Tabulation (Bottom-Up DP)
Initialize the queue: with all source vertices (not just one); Lesson 702 — Multi-Source BFS
Initialize weights: Every training example starts with equal weight (typically `1/n` where `n` is dataset size); Lesson 2858 — AdaBoost Algorithm
Initialized data: variables with initial values; Lesson 1216 — Process Components: Memory Layout
Injection: The attacker finds a way to insert malicious script into the website (through a comment form, URL parameter, profile field, etc.; Lesson 2454 — What is Cross-Site Scripting (XSS)?
Injective (one-to-one): Every output comes from exactly one input.; Lesson 81 — Inverse Functions
Injective test: Different inputs always produce different outputs; Lesson 79 — Function Properties: Bijective
Inline comments: Do they explain non-obvious *why* decisions rather than redundantly describing *what* the code does?; Lesson 2348 — Reviewing Tests and Documentation Lesson 2350 — Code Review Tools and Workflow
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 Lesson 2340 — Speculative Generality Smell
Inner (second-level) page tables: Contain the actual page-to-frame mappings; Lesson 1359 — Two-Level Page Tables
Inner index: Selects the specific page table entry within that table; Lesson 1359 — Two-Level Page Tables
Inner Join: only shows rows where matches exist in *both* tables.; Lesson 1579 — Left Outer Join Lesson 1589 — Handling NULLs in Joins
Inner loop: Examines all E edges (where E is the total number of edges); Lesson 986 — Bellman-Ford Time Complexity
Innovation is needed: – you can't experiment when you've committed to detailed specifications months ago; Lesson 2354 — Waterfall Strengths and Limitations
inode: or similar structure on disk.; Lesson 1388 — File Attributes and Metadata Lesson 1397 — File Control Blocks and Inodes
inorder predecessor: of a node is the node that would appear directly before it if you performed an inorder traversal (left-root-right).; Lesson 512 — Finding Inorder Predecessor Lesson 564 — B-Tree Deletion: Internal Node Cases
inorder successor: of a node is the node that would come immediately after it if you performed an inorder traversal (left-root-right).; Lesson 511 — Finding Inorder Successor Lesson 564 — B-Tree Deletion: Internal Node Cases
Input: Two binary values are fetched from registers and sent to the ALU; Lesson 1072 — The Arithmetic Logic Unit (ALU)Lesson 1871 — The Acceptance Problem for DFAs Lesson 1878 — What is the Halting Problem?Lesson 1918 — The Clique Problem Lesson 2219 — Test Cases and Test Suites Lesson 2268 — Factory Method: Parameterized Creation
Input alphabet: The symbols the PDA reads from input; Lesson 1828 — Introduction to Pushdown Automata
Input features: (the data you observe); Lesson 2786 — Supervised Learning: Learning from Labeled Examples
Input symbol to read: (or ε to read nothing); Lesson 1830 — PDA Transition Functions
Inputs: The data or conditions fed to the code; Lesson 2219 — Test Cases and Test Suites
Insert: O(1) — just append to the end; Lesson 390 — Priority Queue Array Implementation Lesson 427 — Deletion in Open Addressing Lesson 442 — Dictionary and Set Implementations Lesson 522 — Best-Case BST Analysis Lesson 599 — Heap Operation Trade-offs Lesson 610 — Heap as Priority Queue Implementation Lesson 611 — Job Scheduling with Priority Queues Lesson 612 — Event-Driven Simulation (+3 more)
Insert (or Enqueue): Add a new element with its priority to the collection; Lesson 609 — Priority Queue ADT Overview
Insert 1, 2, 3: Creates a right-leaning chain, height = 2, search time O(n); Lesson 527 — Impact of Insertion Order
Insert 2, 1, 3: Creates a balanced tree with 2 at root, height = 1, search time O(log n); Lesson 527 — Impact of Insertion Order
Insert 3, 2, 1: Creates a left-leaning chain, height = 2, search time O(n); Lesson 527 — Impact of Insertion Order
Insert all elements: into the new table; Lesson 428 — Load Factor and Rehashing
Insert anomalies: Adding new data requires correctly populating all redundant locations.; Lesson 1648 — Data Redundancy and Consistency Risks
Insert at front: (`push_front` or `addFirst`); Lesson 395 — Deque: Double-Ended Queue Fundamentals Lesson 397 — Array-Based Deque Implementation
Insert at rear: (`push_back` or `addLast`); Lesson 395 — Deque: Double-Ended Queue Fundamentals Lesson 397 — Array-Based Deque Implementation
Insert back: Put this new node back into the min-heap; Lesson 614 — Huffman Coding Tree Construction
Insert each element: into its new position; Lesson 429 — Rehashing Process
Insert new numbers: Add to one heap based on comparison with current median; Lesson 615 — Median Maintenance with Two Heaps
Insert-front: Move `front` backward (wrapping around if necessary), then place the element there; Lesson 392 — Deque Array Implementation
Insert-rear: Place the element at `rear`, then move `rear` forward; Lesson 392 — Deque Array Implementation
Insert, update, and delete: data (manipulation); Lesson 1561 — SQL Introduction and Purpose
Insert/delete at front: O(1) — just move the front index and place/remove the element; Lesson 400 — Deque Time Complexity Analysis
Insert/delete at rear: O(1) — just move the rear index and place/remove the element; Lesson 400 — Deque Time Complexity Analysis
InsertBack: Create a new node, set its `prev` to the current tail, update the old tail's `next` (if it exists), then update `tail`.; Lesson 393 — Deque Linked List Implementation
InsertFront: Create a new node, set its `next` to the current head, update the old head's `prev` (if it exists), then update `head`.; Lesson 393 — Deque Linked List Implementation
Inserting: means adding a new mailbox and renumbering.; Lesson 239 — Common Array Operations
Inserting at position 0: Use your head-insertion logic instead.; Lesson 331 — Inserting at a Specific Position
Insertion: O(n) — you must find the insertion point at the end of the chain; Lesson 523 — Worst-Case BST Analysis Lesson 544 — AVL Operation Complexity Lesson 545 — AVL Trees vs Unbalanced BSTs Lesson 626 — Time Complexity of Trie Operations Lesson 1685 — B-Tree Height and Disk I/O
Insertion and Deletion: Red-black trees typically perform better.; Lesson 555 — Red-Black vs AVL Trees: Tradeoffs
Insertion anomalies: You can't store a major's building without having a student in that major; Lesson 1625 — Transitive Functional Dependencies Lesson 1634 — Second Normal Form (2NF) Definition Lesson 1637 — Third Normal Form (3NF) Definition Lesson 1638 — Transitive Dependencies Explained
Insertion anomaly: Can't add certain facts without unrelated data; Lesson 1631 — Introduction to Normal Forms
Insertion Sort: Stable (elements are inserted carefully, preserving order); Lesson 751 — Comparing Elementary Sorts Lesson 759 — Optimizing Mergesort Lesson 799 — When to Use Which Sorting Algorithm Lesson 800 — Hybrid Sorting Strategies Lesson 802 — Timsort: Python's Default Sorting Algorithm Lesson 805 — Cache-Friendly Sorting Techniques Lesson 830 — Selection in Specialized Contexts
Insertion total: O(log n) search + O(1) rotation = **O(log n)**; Lesson 544 — AVL Operation Complexity
Insertion/deletion problems: Can't record a customer without an order detail; Lesson 1635 — Partial Dependencies Explained
Inserts a bubble: (NOP) into the next stage; Lesson 1168 — Pipeline Stalls and Bubbles
Inside alone: = mutual exclusion guaranteed; Lesson 1275 — Mutual Exclusion Explained
Insider threats: even trusted employees shouldn't see user passwords; Lesson 2504 — Password Storage Fundamentals
Instance: is the **actual data** stored in the database at a specific point in time.; Lesson 1553 — Schemas and Instances Lesson 1623 — Identifying Functional Dependencies from Data
instance variables: .; Lesson 2130 — Static Members and Class Methods Lesson 2334 — Data Clumps Smell
Instantiates: it with fresh type variables at each use:; Lesson 2013 — Let-Polymorphism
Instruction Count: The total number of instructions your program executes; Lesson 1185 — CPU Performance Equation Fundamentals
Instruction Decode (ID): Lesson 1149 — The Classic Five-Stage Pipeline
Instruction Fetch (IF): Lesson 1149 — The Classic Five-Stage Pipeline
instruction formats: come in—they divide each instruction into distinct **fields**.; Lesson 1085 — Instruction Formats and Opcodes Lesson 1092 — Instruction Set Architecture (ISA)
Instruction formatting: The assembler combines the opcode and operands according to the instruction format (the blueprint for where each bit goes).; Lesson 1105 — Assembly to Machine Code Translation
Instruction ordering: Arranging operations to follow target platform rules; Lesson 2049 — Introduction to Code Generation
Instruction pipelining: changes this approach.; Lesson 1148 — Introduction to Instruction Pipelining
Instruction Register (IR): is a special storage location inside the CPU that holds the instruction currently being processed.; Lesson 1075 — Instruction Register (IR)Lesson 1082 — The Fetch Stage Lesson 1084 — The Decode Stage
Instruction selection: Choosing which target instructions implement each IR operation; Lesson 2049 — Introduction to Code Generation Lesson 2053 — Instruction Selection Lesson 2068 — Loop Unrolling
Instruction Set Architecture (ISA): is essentially the contract between hardware and software.; Lesson 1092 — Instruction Set Architecture (ISA)
instructions per cycle (IPC): .; Lesson 1151 — Pipeline Throughput and Latency Lesson 1187 — Instructions Per Cycle (IPC) and Throughput
Insufficient features: Missing important variables that explain the pattern; Lesson 2809 — What is Underfitting?
Integer: `[0-9]+`; Lesson 1941 — Lexical Specification with Regular Expressions
Integer division: divides whole numbers and produces a whole number result by *truncating* (chopping off) any fractional part.; Lesson 156 — Integer vs Floating-Point Division
Integer range: If you're sorting integers from 0 to k, you can count occurrences (Counting Sort); Lesson 787 — Breaking the O(n log n) Barrier
Integers: (`int`): Whole numbers like `-3`, `0`, `42`; Lesson 1986 — Primitive Types
Integrate continuously: to catch conflicts and integration issues immediately; Lesson 2199 — Trunk-Based Development
Integrate incrementally: Replace one stub at a time with the actual module implementation; Lesson 2238 — Top-Down Integration Testing
Integrate the next layer: up, using the tested clusters below; Lesson 2239 — Bottom-Up Integration Testing
Integration: Multiple components working together; Lesson 2235 — Integration Testing vs Unit Testing
Integration becomes routine: , not a dreaded event; Lesson 2199 — Trunk-Based Development
integration testing: examines how those components interact with each other.; Lesson 2234 — What is Integration Testing?Lesson 2355 — The V-Model: Verification and Validation
Integration tests: verify boundaries between components (database calls, API interactions).; Lesson 2217 — The Testing Pyramid Lesson 2235 — Integration Testing vs Unit Testing Lesson 2247 — E2E Testing vs Integration Testing Lesson 2386 — Automated Testing in CI
Integration with CI/CD: Automated tests run on each PR/MR, giving reviewers immediate feedback about test failures before they even start their manual review.; Lesson 2350 — Code Review Tools and Workflow
Integrity: The data cannot be modified without detection; Lesson 1524 — Introduction to HTTPS Lesson 1554 — Domains and Data Types Lesson 2432 — What are Digital Signatures?Lesson 2434 — Digital Signature Properties Lesson 2442 — TLS: The Security Layer Behind HTTPS
Integrity binding: The hash cryptographically binds the signature to the exact message content; Lesson 2436 — Hash-then-Sign Paradigm
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
Inter-process communication (IPC): via message passing; Lesson 1196 — Microkernel Architecture Lesson 1349 — Shared Memory via Virtual Memory
Interactive processes: (user-facing applications); Lesson 1259 — Multilevel Queue Scheduling
interface: from **implementation**:; Lesson 355 — What is an Abstract Data Type (ADT)?Lesson 377 — Queue Interface and Specification
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
Intermediate Certificate Authority: Issued by the root CA.; Lesson 2446 — The Certificate Chain of Trust
Intermediate certificate(s): Issued by a CA to sign end-entity certificates; Lesson 1533 — Certificate Authorities and Trust Chains
Intermediate Representation (IR) Generation: Lesson 2029 — The Translation Pipeline: Source to Machine Code
internal fragmentation: unused bytes within a page when a process doesn't need the full page size.; Lesson 1351 — Introduction to Paging Lesson 1356 — Internal Fragmentation in Paging Lesson 1383 — Segmentation vs Paging Trade-offs Lesson 2079 — Allocation and Deallocation on the Heap
Internal network resources: Services hidden behind firewalls; Lesson 2485 — Server-Side Request Forgery (SSRF)
Internal nodes: (also called **non-leaf nodes**) are any nodes that have at least one child.; Lesson 452 — Leaves, Internal Nodes, and Edges Lesson 484 — Full Binary Trees Lesson 489 — Internal vs External Nodes Lesson 1978 — AST Representation of Expressions Lesson 2838 — Decision Tree Intuition and Structure Lesson 2840 — Tree Terminology: Nodes, Edges, and Leaves
Internal systems: `http://localhost:8080/admin` or `http://192.; Lesson 2485 — Server-Side Request Forgery (SSRF)
Internet Layer: Lesson 1438 — The TCP/IP Model
Internet Layer (TCP/IP): = OSI Layer 3; Lesson 1439 — Mapping OSI to TCP/IP
Internet Protocol (IP): .; Lesson 1438 — The TCP/IP Model
Interpret the bytecode: A virtual machine (VM) reads and executes the bytecode instructions one by one (or uses JIT compilation for hot code paths).; Lesson 2033 — Bytecode Compilation: The Hybrid Approach
Interpret/evaluate: – Walk through these objects to compute the result; Lesson 2300 — Interpreter Pattern
Interpretable: Fewer active features means easier understanding; Lesson 2811 — L1 Regularization (Lasso)
Interpreted code: , on the other hand, remains in a form closer to source code (or bytecode).; Lesson 2035 — Platform Dependency and Portability
Interpreted programs: Lesson 2034 — Memory Requirements and Resource Usage
interpreter: reads your source code and executes it directly, typically one statement or expression at a time.; Lesson 2027 — Compilation and Interpretation: Two Execution Models Lesson 2032 — Error Detection: Compile-Time vs Runtime
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 1210 — Interrupt Handling Process Lesson 1214 — System Calls vs Interrupts: Comparison
Interrupt arrives: with number *n* (e.; Lesson 1212 — Interrupt Vector Table
interrupt handler: (also called interrupt service routine); Lesson 1209 — What Are Interrupts?Lesson 1210 — Interrupt Handling Process
Interrupt Vector Table (IVT): is a data structure stored in memory that maps each possible interrupt number (or interrupt ID) to the memory address of its corresponding handler routine.; Lesson 1212 — Interrupt Vector Table
Interrupts: are *asynchronous* and often *external*.; Lesson 1214 — System Calls vs Interrupts: Comparison
Intersection: `A ∩ B = B ∩ A`; Lesson 65 — Set Identities and Laws Lesson 111 — Union and Intersection of Events Lesson 1577 — Inner Join Basics Lesson 1763 — Language Complement and Intersection Lesson 1848 — Closure Properties of CFLs
Intersection ( ∩): finds *common ground*.; Lesson 62 — Set Union and Intersection
Intersection (A ∩ B): Shade only where the circles overlap; Lesson 64 — Venn Diagrams
Intrinsic state: shared, immutable data (e.; Lesson 2279 — Flyweight Pattern: Sharing to Support Many Objects
Introduce precedence levels: For arithmetic expressions, create separate non-terminals for each precedence tier.; Lesson 1839 — Resolving Ambiguity: Grammar Rewriting
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 Lesson 577 — Heap Order Property: Min-Heap
Invalid arguments: (null, negative where positive required, out of range); Lesson 2231 — Testing Exception Handling
Invalid data: negative numbers where only positives make sense, malformed input; Lesson 2260 — Handling Edge Cases and Boundaries
Invalid Example: Lesson 496 — Valid vs Invalid BSTs
Invalidate old tokens: When a new reset is requested, invalidate all previous tokens for that account; Lesson 2513 — Password Reset Security
Invalidate on use: Once a token resets a password, destroy it immediately; Lesson 2513 — Password Reset Security
Inventory: Two customers simultaneously buy the last item in stock from different data centers.; Lesson 2610 — What is Consistency in Distributed Systems?
Inventory counts: May need additional coordination; Lesson 1734 — Eventual Consistency Trade-offs
Inverse: Negate both parts: **¬p → ¬q** ("if not p, then not q"); Lesson 37 — Converse, Inverse, and Contrapositive
inversion: or **negation**.; Lesson 14 — The NOT Gate (Inverter)Lesson 656 — Fenwick Tree Applications Lesson 852 — Count Inversions in Array
IP: Lesson 1438 — The TCP/IP Model
IP fragmentation: occurs.; Lesson 1492 — UDP Maximum Datagram Size and Fragmentation
IP routing tables: Network routers use tries to match IP prefixes; Lesson 619 — What is a Trie? Motivation and Use Cases
IPC: is simply the inverse of CPI.; Lesson 1159 — Pipeline Performance Metrics
IPv4 address: .; Lesson 1504 — DNS Record Types: A and AAAA
IPv6 addresses: .; Lesson 1504 — DNS Record Types: A and AAAA
IR: Lesson 1075 — Instruction Register (IR)
Irrelevant features dominate: Unlike tree-based models, KNN can't ignore noisy features—they pollute distance calculations equally; Lesson 2872 — KNN in Practice: Applications and Limitations
isEmpty: Check if the stack contains any elements; Lesson 356 — The Stack ADT Definition Lesson 362 — Array-Based Stack Implementation
Island counting: Though typically DFS, BFS works too; Lesson 704 — BFS in Grid Graphs
Isolate your work: Make all commits related to one feature or task on this branch; Lesson 2195 — Feature Branch Workflow
Isolated: Does each test focus on one specific behavior?; Lesson 2348 — Reviewing Tests and Documentation
Isolating stages: so each can work on different instructions simultaneously; Lesson 1150 — Pipeline Registers and Latches
isolation: between functions.; Lesson 202 — Pass-by-Value Semantics Lesson 1333 — Memory Protection with Address Spaces Lesson 1339 — What is Virtual Memory?Lesson 1340 — Address Translation Overview Lesson 1660 — Isolation: Concurrent Transaction Independence Lesson 2712 — Dead Letter Queues and Poison Messages Lesson 2717 — What Are Distributed Transactions?
Issuer: Which Certificate Authority (CA) verified and signed it; Lesson 1532 — Digital Certificates Fundamentals
It breaks: You lose one egg and must check the `x-1` floors below; Lesson 938 — Egg Dropping Problem
It doesn't: 3-SAT is also NP-complete!; Lesson 1917 — 3-SAT Problem
It survives: You keep the egg and must check the `n-x` floors above; Lesson 938 — Egg Dropping Problem
It's simpler structurally: than general SAT; Lesson 1917 — 3-SAT Problem
It's universal: Every other NP problem can be transformed into Subset Sum; Lesson 1923 — Subset Sum Problem
Iterate: through your dataset; Lesson 447 — Frequency Counting and Histograms Lesson 917 — Tabulation (Bottom-Up DP)Lesson 1628 — Closure of Attribute Sets
Iterate through every element: in the old table; Lesson 429 — Rehashing Process
Iteration: uses loops (`while`, `for`) to repeat code blocks.; Lesson 223 — Recursion vs Iteration Lesson 236 — Iterating Through Arrays Lesson 260 — Strings as Arrays of Characters Lesson 1954 — Eliminating Left Recursion Lesson 2356 — Iterative and Incremental Development
Iteration is preferable when: Lesson 868 — Recursive vs Iterative Tradeoffs
Iterative and Incremental Development: to maintain structure.; Lesson 2367 — Self-Organizing Teams
Iterative approach: Start at 1, multiply by 2, then 3, then 4, then 5.; Lesson 223 — Recursion vs Iteration
Iterative control: Easier to manage memory in graphs that might cause deep recursion; Lesson 731 — Component Finding with BFS
Iterative deepening: solves this by running depth-limited minimax searches repeatedly, increasing the depth limit each iteration (depth 1, then 2, then 3.; Lesson 2772 — Iterative Deepening in Games
Iterative Deepening DFS: and **A* Search**.; Lesson 2761 — IDA* (Iterative Deepening A*)
Iterative Deepening DFS (IDDFS): solves this problem elegantly: it runs depth-limited DFS repeatedly with limits of 0, 1, 2, 3, .; Lesson 2745 — Iterative Deepening DFS

J

Java: Lesson 233 — Array Declaration and Initialization Lesson 2033 — Bytecode Compilation: The Hybrid Approach
Java bytecode: a platform-independent intermediate representation designed to run on the Java Virtual Machine (JVM).; Lesson 2046 — Java Bytecode as IR
Java I/O (again!): Stack decorators like `BufferedReader(new FileReader(file))` add buffering behavior dynamically.; Lesson 2285 — Real-World Structural Pattern Examples
Java I/O Streams: `InputStreamReader` adapts a byte-oriented `InputStream` into a character-oriented `Reader`.; Lesson 2285 — Real-World Structural Pattern Examples
Java's `Arrays.sort()`: Uses dual-pivot quicksort for primitives (O(n log n) average, unstable) and Timsort for objects (stable); Lesson 808 — Standard Library Sort Functions
JavaScript context: Escape quotes, backslashes, and control characters differently; Lesson 2460 — Output Encoding and Escaping
JavaScript Frameworks: Vue.; Lesson 2285 — Real-World Structural Pattern Examples
Jenkins: is an open-source automation server that runs on your own infrastructure.; Lesson 2394 — CI/CD Tools and Infrastructure
JIT compilation: to optimize performance.; Lesson 2046 — Java Bytecode as IR
Job matching: Workers on one side, jobs on the other, edges represent who can do which job; Lesson 689 — Bipartite Graphs
Job Sequencing with Deadlines: solves this optimization problem using a greedy approach:; Lesson 891 — Job Sequencing with Deadlines
Join NULLs: NULLs added by SQL because no matching row was found; Lesson 1589 — Handling NULLs in Joins
JOIN operations: that scan multiple tables, match keys, and potentially build temporary result sets.; Lesson 1747 — Graph Database vs Relational Joins
Join operators: Combine rows from multiple tables; Lesson 1698 — Query Execution Plans and Operators Lesson 1701 — Join Order Selection
Join order matters: for your specific data distribution; Lesson 1706 — Query Hints and Plan Forcing
Join the subtrees: Lesson 573 — Splay Tree Deletion
JOINs: connect related tables; Lesson 1590 — Using Joins with Aggregations Lesson 1609 — Subquery Performance Considerations Lesson 1647 — Read Performance vs Write Complexity
Joins are usually faster: for combining data from multiple tables.; Lesson 1588 — Join vs Subquery Trade-offs
Joint consensus phase: While in C-old,new, decisions (elections, commits) require majorities from *both* C-old AND C- new.; Lesson 2671 — Cluster Membership Changes in Raft
Journaling: (or **write-ahead logging**) solves this by adding a special log area on disk.; Lesson 1406 — File System Consistency and Journaling
JSON: and **YAML** are Domain-Specific Languages (DSLs) designed specifically for configuration.; Lesson 2152 — Configuration Files and DSLs
JSON Web Tokens (JWTs): a standardized way to securely transmit information between parties as a JSON object.; Lesson 2542 — ID Tokens and JWT Structure in OpenID Connect
Jump target: Any instruction that is the target of a jump, branch, or goto statement; Lesson 2043 — Basic Blocks and Leaders
Jump targets: start new blocks because control can arrive from elsewhere (a new entrance); Lesson 2043 — Basic Blocks and Leaders
Jump-to-Jump Elimination: Lesson 2058 — Peephole Optimization in Code Generation
Jumps back: to that address, resuming execution right after the original `CALL`; Lesson 1103 — Function Calls and the CALL Instruction
Jumps to the subroutine: It transfers control to the target label, just like an unconditional jump; Lesson 1103 — Function Calls and the CALL Instruction
Just right: You make steady progress toward the minimum in a reasonable number of iterations, balancing speed with stability.; Lesson 2821 — Learning Rate and Convergence
Just-in-Time compilation: delays translation until the program is actually running.; Lesson 2028 — Ahead-of-Time vs Just-in-Time Execution Lesson 2036 — Real-World Examples: C, Python, and JavaScript

K

K_n: , where *n* is the number of vertices:; Lesson 688 — Complete Graphs
K-Fold Cross-Validation: divides your entire training dataset into *k* equal-sized "folds" (commonly k=5 or k=10).; Lesson 2798 — K-Fold Cross-Validation Lesson 2799 — Stratified Sampling Lesson 2801 — Holdout Method Limitations
K₃: A triangle (3 vertices, 3 edges); Lesson 688 — Complete Graphs
K₃,₃: Complete bipartite graph with 3 vertices on each side; Lesson 692 — Planar Graphs
K₄: Four vertices where each connects to the other three (6 edges); Lesson 688 — Complete Graphs
K₅: Five vertices, all interconnected (10 edges); Lesson 688 — Complete Graphs Lesson 692 — Planar Graphs
Kahn's algorithm: and **DFS-based sorting**—visit every vertex and every edge exactly once.; Lesson 727 — Time and Space Complexity
KD-tree: splits space recursively along different dimensions, creating a binary tree.; Lesson 2870 — Accelerating KNN with Data Structures
Keccak: (pronounced "catch-ack"), which became **SHA-3** in 2015.; Lesson 2428 — SHA-3 and Keccak
Keep `main` stable: Only merge thoroughly tested, production-ready code; Lesson 2193 — Branch Management Best Practices
Keep a count field: in each node - One node per unique value, with a counter; Lesson 528 — BST with Duplicate Keys
Keep a parent pointer: to remember the last node visited; Lesson 507 — BST Insertion: Iterative Approach
Keep changes small: so each commit is independently reviewable and releasable; Lesson 2199 — Trunk-Based Development
Keep focused: Each branch represents one logical unit of work; Lesson 2195 — Feature Branch Workflow
Keep going up: don't stop after one rotation; Lesson 542 — Rebalancing After Deletion
Keep serving requests: Rebalancing shouldn't cause downtime; Lesson 2691 — Rebalancing Partitions
Keep the test: This test now lives in your suite permanently, preventing regression.; Lesson 2262 — TDD for Bug Fixes
Keeping the tree shallow: , so you traverse fewer levels; Lesson 1676 — B-Tree Index Overview
Kept (semantic information): Lesson 1977 — From Parse Tree to AST
Kernel mode: (also called *supervisor mode* or *privileged mode*) grants unrestricted access to all system resources.; Lesson 1194 — OS Kernel and User Space Lesson 1204 — User Mode vs Kernel Mode
Kernel Threads: are created, scheduled, and managed directly by the operating system kernel.; Lesson 1233 — User Threads vs Kernel Threads
key: and store the computed result as the **value**.; Lesson 443 — Caching and Memoization Lesson 444 — Symbol Tables in Compilers Lesson 447 — Frequency Counting and Histograms Lesson 1728 — Key-Value Store Data Model
Key Addition (AddRoundKey): XOR the block with a portion of the expanded key; Lesson 2401 — AES: The Advanced Encryption Standard
Key attributes: are special attributes whose values uniquely identify each entity.; Lesson 1614 — Key Attributes and Identifiers
Key benefit: Keeps the channel busy while acknowledgments travel back, dramatically improving throughput compared to stop-and-wait.; Lesson 1449 — Flow Control Mechanisms
Key benefits: Lesson 2583 — Striped Locking for Hash Maps
Key characteristics: Lesson 1516 — HTTP Methods: GET and POST
Key compromise: remains the ultimate threat.; Lesson 2441 — Digital Signature Security Considerations
Key difference: `wait()` is simpler but less flexible; `waitpid()` gives you precise control over which child to wait for and how to wait.; Lesson 1227 — Process Waiting: wait() and waitpid()Lesson 2431 — Hash Function Applications: Digital Signatures and MACs
Key difference from paging: Segmentation respects program semantics.; Lesson 1378 — Segmentation Basics and Motivation
Key Exchange: The client generates a "pre-master secret," encrypts it using the server's public key, and sends it.; Lesson 1525 — HTTPS Handshake Process Lesson 2442 — TLS: The Security Layer Behind HTTPS Lesson 2443 — The TLS Handshake: Establishing Secure Connections
Key Exchange Algorithm: – How the client and server will agree on shared secret keys (e.; Lesson 1536 — TLS Cipher Suites Lesson 2448 — Cipher Suites: Negotiating Encryption Algorithms
Key features: Lesson 1737 — Popular Key-Value Stores: Redis and DynamoDB
Key Generation: Alice picks a prime `p`, generator `g`, and private key `x`.; Lesson 2413 — ElGamal Encryption System
Key insight: You're mapping the tree's logical structure (which index *would* this node occupy?; Lesson 467 — Converting Between Representations Lesson 933 — Partition Equal Subset Sum
Key limitation: Space proportional to the range, not the number of elements.; Lesson 798 — Linear-Time Sorting: Practical Considerations
Key properties: Lesson 2746 — Uniform-Cost Search
Key rotation: Periodically replacing keys to limit damage from compromise; Lesson 2417 — Key Distribution and Management Lesson 2441 — Digital Signature Security Considerations
Key scheduling: that derives 16 different round keys from your original 56-bit key; Lesson 2400 — DES: The Data Encryption Standard
Key steps: Lesson 1548 — Handling Multiple Clients with Select
Key stretching: (or key derivation functions like PBKDF2, bcrypt, or Argon2) intentionally slow down hashing by applying it thousands of times.; Lesson 2430 — Hash Function Applications: Password Storage
Key-to-Location Mapping: Lesson 1689 — Hash Index Structure
key-value store: is the simplest type of NoSQL database.; Lesson 1711 — Key-Value Store Fundamentals Lesson 1728 — Key-Value Store Data Model
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 Lesson 1715 — Choosing the Right NoSQL Category
Key/Value: The data stored in the node.; Lesson 497 — BST Node Structure
Keyboard symbols: {a, b, .; Lesson 1756 — Alphabets and Strings
Keylogging: Lesson 2458 — XSS Attack Vectors and Payloads
Keys: Sorted values (e.; Lesson 1677 — B-Tree Structure and Properties Lesson 1711 — Key-Value Store Fundamentals Lesson 1732 — Consistent Hashing
Keyword: → **what** to retrieve → **FROM keyword** → **where** it lives → **optional filter**; Lesson 1562 — Database Connection and Basic Structure Lesson 1939 — Tokens, Lexemes, and Patterns Lesson 1940 — Token Classification Lesson 2398 — Polyalphabetic Ciphers and the Vigenère Cipher
Keyword `if`: `if`; Lesson 1941 — Lexical Specification with Regular Expressions
Keyword Checking First: When the lexer sees a potential identifier, it checks if the lexeme matches a reserved keyword (like `if`, `while`, `return`).; Lesson 1946 — Symbol Tables and Identifiers
Killer moves: (moves that caused cutoffs at the same depth elsewhere); Lesson 2769 — Move Ordering in Alpha-Beta
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: operation, written as `Σ*`, generates **every possible string** you can make from an alphabet Σ, including the empty string.; Lesson 1759 — Powers of Strings and Kleene Star Lesson 1770 — Kleene Star and Repetition Lesson 1826 — CFG Closure Properties Lesson 1848 — Closure Properties of CFLs
Kleene star L: * produces a new language containing:; Lesson 1762 — Kleene Star and Plus on Languages
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 where n is the number of vertices Lesson 666 — Complete, Bipartite, and Regular Graphs
Knapsack Problem: given items with weights and values, and a capacity limit, select a subset that maximizes value while staying within the weight constraint.; Lesson 1924 — The Knapsack Problem
Knuth-Morris-Pratt (KMP) algorithm: does something smarter: it uses knowledge about the pattern itself to skip unnecessary comparisons.; Lesson 834 — Knuth-Morris-Pratt: Prefix Function
Knuth's Optimization: notices that when your cost function satisfies the **quadrangle inequality**, the optimal split point moves monotonically—meaning if the best `k` for `dp[i][j]` is 5, then the best `k` for `dp[i] [j+1]` won't be 2 or 3; it'll be ≥ 5.; Lesson 960 — Knuth's Optimization
Kosaraju's Algorithm: finds strongly connected components (SCCs) by performing two separate depth-first searches: one on the original graph to determine a special ordering, and another on the transpose graph (where all edges are reversed) using that ordering.; Lesson 735 — Kosaraju's Algorithm for SCCs
Kruskal's: Each new edge connects two separate tree components (a natural cut); Lesson 1013 — Cut Property and MST Correctness
Kruskal's algorithm: sorts all edges globally and builds the MST by repeatedly adding the smallest edge that doesn't create a cycle.; Lesson 1020 — Comparing Kruskal's and Prim's Algorithms
Kruskal's simpler implementation: often makes it the practical choice.; Lesson 1020 — Comparing Kruskal's and Prim's Algorithms

L

L - 1: internal nodes; Lesson 484 — Full Binary Trees
L NP: .; Lesson 1905 — P Subset of NP
L(G): , is the set of all strings that:; Lesson 1816 — Language Generated by a Grammar
L(M): , is the complete set of all strings that the DFA M accepts.; Lesson 1782 — The Language of a DFA
L₁: = `{a, ab, aab}` — exactly three strings over alphabet `{a, b}`; Lesson 1760 — Languages as Sets of Strings
L1 (Lasso) Regularization: Lesson 2833 — Regularization in Logistic Regression
L1 Cache: ~1 nanosecond; Lesson 1110 — Access Time and Latency
L1 caches: 2-way to 8-way (fast access critical, smaller size); Lesson 1137 — Choosing Associativity in Practice
L₂: = `{00, 11}` — two binary strings; Lesson 1760 — Languages as Sets of Strings
L2 (Ridge) Regularization: Lesson 2833 — Regularization in Logistic Regression
L2 Cache: ~4 nanoseconds; Lesson 1110 — Access Time and Latency
L2 caches: 4-way to 16-way (larger, can afford more complexity); Lesson 1137 — Choosing Associativity in Practice
L₃: = `{}` — the empty language (contains no strings at all); Lesson 1760 — Languages as Sets of Strings
L3 Cache: ~10-20 nanoseconds; Lesson 1110 — Access Time and Latency
L3 caches: 8-way to 16-way (very large, still limited by cost); Lesson 1137 — Choosing Associativity in Practice
L₄: = `{0, 00, 000, 0000, .; Lesson 1760 — Languages as Sets of Strings
L₅: = `{a, ab, abb, abbb, .; Lesson 1760 — Languages as Sets of Strings
L₆: = all valid Python programs (yes, that's an infinite language!; Lesson 1760 — Languages as Sets of Strings
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 Lesson 1748 — Nodes and Properties Lesson 2787 — Classification vs Regression Tasks
Label quality: encompasses:; Lesson 2794 — Label Quality and Acquisition
Label resolution: The assembler tracks all labels and calculates their actual memory addresses.; Lesson 1105 — Assembly to Machine Code Translation
Labeled examples: (input-output pairs)?; Lesson 2793 — Choosing the Right Learning Paradigm
labels: human-readable names that mark specific locations in your code.; Lesson 1099 — Unconditional Jumps and Labels Lesson 1105 — Assembly to Machine Code Translation Lesson 1748 — Nodes and Properties Lesson 2055 — Control Flow Code Generation Lesson 2776 — Features and Labels
Lack of experience: Not knowing better solutions exist; Lesson 2301 — Introduction to Anti-Patterns
Lack of planning: or architectural design; Lesson 2303 — Spaghetti Code Anti-Pattern
LACP: Link Aggregation Control Protocol), they:; Lesson 1460 — Link Aggregation
LALR(1): (Look-Ahead LR) solves this problem elegantly.; Lesson 1970 — LALR(1) Parsing
lambda calculus: Lesson 1860 — The Quest for a Formal Definition of Algorithm Lesson 1864 — Equivalence of Computational Models
Lamport timestamps: and **Vector clocks** handle causality purely logically, but they lose real-world time information.; Lesson 2636 — Hybrid Logical Clocks
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 Lesson 1898 — Decision Problems and Languages
Language design: What *should* happen when unusual cases arise?; Lesson 2017 — Introduction to Operational Semantics
Language-specific copy functions: Many languages provide built-in ways to duplicate arrays efficiently; Lesson 240 — Array Copying and Cloning
languages: sets of strings.; Lesson 1762 — Kleene Star and Plus on Languages Lesson 1765 — Language Specifications and Notation Lesson 1898 — Decision Problems and Languages
Large arrays: Use **Quicksort**, **Mergesort**, or **Heapsort** for O(n log n) performance.; Lesson 799 — When to Use Which Sorting Algorithm
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
Large datasets (100,000+ examples): You can afford smaller test percentages like 90-10 or even 95-5.; Lesson 2800 — Train-Test Split Ratios
Large k (e.g., k=100): Lesson 2865 — Choosing the Value of K
Large local variables: Allocating big arrays on the stack consumes space quickly.; Lesson 2077 — Stack Growth and Limitations
Large working sets: that don't fit in cache; Lesson 805 — Cache-Friendly Sorting Techniques
Large α: Penalizes complexity strongly → aggressive pruning; Lesson 2851 — Cost-Complexity Pruning
Larger: Recursively search the right subtree; Lesson 503 — BST Search: Finding a Node Lesson 558 — B-Tree Invariants Lesson 595 — Delete Arbitrary Element
Larger address spaces: Processes can use addresses beyond available RAM (we'll see how later); Lesson 1339 — What is Virtual Memory?
Larger capacity: (typically 256 KB - 1 MB per core); Lesson 1121 — Cache Levels: L1, L2, L3
Larger initial size: Wastes memory if you don't fill it, but prevents costly rehashing operations early on.; Lesson 440 — Space-Time Tradeoffs in Hash Tables
Larger numbers: multiple bytes work together to represent one character; Lesson 27 — UTF-8 Encoding
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)
Last level fills left-to-right: Nodes on the bottom level must be as far left as possible, with no gaps; Lesson 485 — Complete Binary Trees
Last-In-First-Out (LIFO): principle.; Lesson 356 — The Stack ADT Definition Lesson 375 — Queue ADT Definition and FIFO Principle
Last-write-wins: (using timestamps—but remember clock skew!; Lesson 2641 — Multi-Leader Replication Lesson 2706 — Eventual Consistency in Practice: Dynamo and Cassandra
Last-Write-Wins (LWW): is the simplest conflict resolution strategy: attach a timestamp to every write, and when a conflict is detected, keep the write with the highest (most recent) timestamp and discard all others.; Lesson 2701 — Last-Write-Wins (LWW) Conflict Resolution
Last-write-wins timestamps: Compare timestamps to identify concurrent writes, though this doesn't fully detect semantic conflicts.; Lesson 2700 — Conflict Detection in Eventual Consistency
Late defect discovery: Integration bugs only surface after everything is built; Lesson 2236 — Big Bang Integration Strategy
Late failure: Bugs hide until execution reaches them—a rarely-used code path might contain type errors that won't appear until months later in production.; Lesson 1999 — Type Checking at Runtime
Late optimizations: happen during or after code generation (peephole optimization, register allocation improvements); Lesson 2060 — Optimization Phases and Safety
latency: ) is the delay between requesting data from a storage device and receiving it.; Lesson 1110 — Access Time and Latency Lesson 1151 — Pipeline Throughput and Latency Lesson 1444 — Bandwidth and Throughput Lesson 2590 — Network Latency and Bandwidth Constraints Lesson 2698 — Strong vs Eventual Consistency Tradeoffs Lesson 2715 — Message Queue Performance Considerations
Lava Flow: anti-pattern (where obsolete code remains frozen in place), this is an entire system lacking structure—code written without thought to modularity, separation of concerns, or long-term maintainability.; Lesson 2308 — Big Ball of Mud Anti-Pattern
Lava Flow Anti-Pattern: occurs when obsolete, unused, or poorly understood code remains in your codebase because developers are afraid to remove it.; Lesson 2307 — Lava Flow Anti-Pattern
Law of Demeter violation: (also known as the "principle of least knowledge").; Lesson 2339 — Message Chains Smell
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 Lesson 119 — Probability in Algorithm Analysis
Layer 0: Hardware interface (direct CPU, memory, device control); Lesson 1198 — Layered Operating System Structure
Layer 1: Basic scheduling and low-level memory management; Lesson 1198 — Layered Operating System Structure
Layer 2: Inter-process communication; Lesson 1198 — Layered Operating System Structure
Layer 3: I/O device drivers; Lesson 1198 — Layered Operating System Structure
Layer 4: File systems; Lesson 1198 — Layered Operating System Structure
Layer 5: User programs and shell; Lesson 1198 — Layered Operating System Structure
Layer-by-layer expansion: → BFS; Lesson 708 — BFS Applications and Problem Patterns
Lazy: Resource-efficient, but requires synchronization complexity; Lesson 2266 — Singleton Thread Safety and Lazy Initialization
Lazy Array: Maintain a parallel array storing pending updates for each node; Lesson 646 — Range Update with Lazy Propagation
Lazy Initialization: delays creation until first access:; Lesson 2266 — Singleton Thread Safety and Lazy Initialization
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: if it satisfies any of these conditions:; Lesson 2043 — Basic Blocks and Leaders Lesson 2661 — Raft RPCs: RequestVote and AppendEntries Lesson 2663 — Leader Election: Voting Process
Leader → Follower: When the leader discovers another server with a higher term number; Lesson 2659 — Raft Server States: Follower, Candidate, Leader
Leader appends: the command to its log; Lesson 2658 — The Replicated State Machine Model
Leader election: Which node coordinates the system?; Lesson 2647 — The Consensus Problem Definition Lesson 2655 — Leader Election Basics Lesson 2657 — Introduction to Raft: Motivation and Overview Lesson 2681 — Multi-Paxos: Optimizing for Multiple Decisions
Leader election restriction: A candidate can only become leader if its log contains all committed entries (it must receive votes from a majority, which overlaps with the commit majority); Lesson 2670 — Raft Safety Proof: State Machine Safety Property
Leader replicates: the log entry to followers; Lesson 2658 — The Replicated State Machine Model
leaf: node.; Lesson 451 — Root, Parent, Child, and Sibling Nodes Lesson 2276 — Composite Pattern: Tree Structures of Objects
leaf node: a node with no left or right children.; Lesson 508 — BST Deletion: Leaf Node Case Lesson 560 — B-Tree Insertion: Simple Cases Lesson 1680 — B-Tree Insertion Basics Lesson 1683 — Deletion from Leaf Nodes
leaf nodes: ) are nodes with *no children at all*.; Lesson 452 — Leaves, Internal Nodes, and Edges Lesson 484 — Full Binary Trees Lesson 558 — B-Tree Invariants Lesson 1978 — AST Representation of Expressions Lesson 2838 — Decision Tree Intuition and Structure Lesson 2840 — Tree Terminology: Nodes, Edges, and Leaves
Leaf predictions differ: Mode (most frequent) vs mean (average); Lesson 2839 — Classification vs Regression Trees
Learners: discover what value was chosen without participating in voting.; Lesson 2673 — Paxos Roles: Proposers, Acceptors, and Learners
Learning Phase: Lesson 1455 — Switch Learning and Forwarding
learning rate: , a small positive number that prevents overshooting the minimum.; Lesson 2819 — Gradient Descent Basics Lesson 2821 — Learning Rate and Convergence Lesson 2862 — Ensemble Selection and Hyperparameters
Least Privilege: Users automatically get only the permissions their role needs, reducing attack surface when credentials are compromised.; Lesson 2526 — Role-Based Access Control (RBAC)
Least Recently Used (LRU): makes this decision by tracking when each page was last accessed and replacing the one with the oldest "last used" timestamp.; Lesson 1370 — Least Recently Used (LRU)
Leave-One-Out Cross-Validation (LOOCV): is k-fold cross-validation pushed to its logical limit: where k equals the total number of examples in your dataset.; Lesson 2802 — Leave-One-Out Cross-Validation
Leaves: (or **leaf nodes**) are nodes with *no children at all*.; Lesson 452 — Leaves, Internal Nodes, and Edges Lesson 1797 — Computation Trees in NFAs Lesson 2840 — Tree Terminology: Nodes, Edges, and Leaves
left: subtree; Lesson 476 — Implementing Postorder Recursively Lesson 519 — Floor and Ceiling Operations Lesson 535 — Single Right Rotation Lesson 638 — Ternary Search Tree Operations Lesson 812 — Finding First Occurrence Lesson 1812 — Regular Language Identities and Algebraic Laws
Left associativity: Notice `E → E + T` puts the recursive `E` on the *left*.; Lesson 1819 — CFGs for Arithmetic Expressions
left child: and the **right child**, establishing a clear distinction between the two positions.; Lesson 457 — Binary Tree Definition Lesson 461 — Array-Based Complete Binary Trees Lesson 462 — Array Index Formulas Lesson 517 — Validating BST Property Lesson 534 — Identifying Imbalance Cases Lesson 579 — Array Representation of Binary Heaps Lesson 580 — Parent-Child Index Formulas Lesson 637 — Ternary Search Trees
Left child index: `2 * i`; Lesson 580 — Parent-Child Index Formulas
Left Child Pointer: A reference to the left subtree's root node.; Lesson 497 — BST Node Structure
Left factoring: extracts the common prefix (`a b` in our example) into a single production, then delegates the decision about what comes *after* to a new nonterminal:; Lesson 1842 — Left Factoring Lesson 1955 — Left Factoring
LEFT JOIN: (also called LEFT OUTER JOIN) comes in.; Lesson 1579 — Left Outer Join
Left recursion: happens when a grammar rule's first symbol refers back to itself—directly or indirectly.; Lesson 1953 — Left Recursion Problem Lesson 1954 — Eliminating Left Recursion
Left rotation: on the left child (straightening the zigzag into a straight left-left line); Lesson 537 — Left-Right Double Rotation Lesson 551 — Insertion Case 3: Uncle is Black, Line Configuration Lesson 553 — Deletion Cases: Red Sibling
Left Shift (`<<`): Moves all bits left, filling with 0s.; Lesson 163 — Bitwise Operators
Left side (descending): Each specification phase defines both *what* to build and *how it will be tested*.; Lesson 2355 — The V-Model: Verification and Validation
Left subtree: contains all smaller values; Lesson 493 — What is a Binary Search Tree?Lesson 515 — Counting Nodes in a BST Lesson 534 — Identifying Imbalance Cases
Left-half inversions: Count recursively in the left half; Lesson 852 — Count Inversions in Array
Left-Right case: the imbalance "zigzags" down.; Lesson 537 — Left-Right Double Rotation
Left-Right Double Rotation: performs:; Lesson 537 — Left-Right Double Rotation
Left-Right-Root: pattern.; Lesson 475 — Postorder Traversal: Left-Right-Root Lesson 482 — Iterative Postorder with Stack
Left-Root-Right: .; Lesson 472 — Inorder Traversal: Left-Root-Right Lesson 474 — Inorder and Binary Search Trees
Left/Right: Simple to implement, but can unbalance the tree with many duplicates; Lesson 499 — Handling Duplicate Keys
leftmost: (first) occurrence of a target value when duplicates exist in a sorted array.; Lesson 812 — Finding First Occurrence Lesson 1950 — Introduction to Top-Down Parsing
leftmost derivation: always replaces the leftmost non-terminal at each step, while a **rightmost derivation** always replaces the rightmost non-terminal first.; Lesson 1815 — Leftmost and Rightmost Derivations Lesson 1950 — Introduction to Top-Down Parsing
Legacy approach (`git checkout`): Lesson 2178 — Undoing Changes in Working Directory
Legacy constraints: Working around old decisions compounds problems; Lesson 2301 — Introduction to Anti-Patterns
Legal and ethical obligations: you're responsible for protecting user data; Lesson 2504 — Password Storage Fundamentals
Legitimate users: may be blocked if headers are missing; Lesson 2470 — Origin and Referer Header Validation
length: or **size**.; Lesson 235 — Array Length and Bounds Lesson 260 — Strings as Arrays of Characters Lesson 264 — String Length and Bounds Checking Lesson 453 — Path, Ancestor, and Descendant Concepts Lesson 1399 — File Allocation Methods: Contiguous Lesson 1757 — The Empty String and String Length
Length Field: Lesson 1446 — Framing Techniques
Length prefixes: (faster field skipping without parsing); Lesson 1719 — JSON and BSON Data Formats
Length zero: `|ε| = 0` — it contains no symbols; Lesson 1757 — The Empty String and String Length
Less prone to overfitting: Complexity is naturally constrained; Lesson 2811 — L1 Regularization (Lasso)
Less than: `<` — "Is the left value smaller?; Lesson 157 — Comparison Operators Lesson 171 — Comparison Operators in Conditions Lesson 257 — Partitioning Arrays Around a Pivot Lesson 493 — What is a Binary Search Tree?Lesson 514 — Range Query in BST Lesson 897 — Maximum Length Chain of Pairs
Less than pivot: (elements < pivot); Lesson 772 — Three-Way Partitioning for Duplicate Keys
Letters: (like 'A' or 'z'); Lesson 1 — What is Binary and Why It Matters
level: tells you which management tier someone belongs to.; Lesson 455 — Tree Height and Level Lesson 1547 — Socket Options and Configuration
level by level: , like ripples spreading outward in a pond.; Lesson 694 — BFS Overview and Applications Lesson 699 — Shortest Path in Unweighted Graphs
Level structure: You get vertices organized by distance from the start; Lesson 731 — Component Finding with BFS
Level-order traversal: Visit nodes level by level (use a queue); Lesson 467 — Converting Between Representations Lesson 478 — Level-Order Traversal Concept Lesson 583 — Visualizing Heap Structure Lesson 701 — Level-Order Traversal
Leverages known algorithms: Uses in-memory sorting for chunks and merge logic you already understand; Lesson 807 — External Sorting for Large Datasets
Lex: (and its modern successor **Flex**) are the most famous examples.; Lesson 1948 — Lexer Generator Tools
Lexeme: = the actual item in your hand; Lesson 1939 — Tokens, Lexemes, and Patterns
Lexemes: are the *actual strings* found in the source code (like `count`, `42`, or `+`); Lesson 1939 — Tokens, Lexemes, and Patterns
Lexer generator tools: automate this process.; Lesson 1948 — Lexer Generator Tools
Lexical analysis: (also called *scanning*) is the very first phase of this multi-stage process.; Lesson 1938 — Role of Lexical Analysis in Compilation Lesson 2029 — The Translation Pipeline: Source to Machine Code
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
LFU: replaces the page with the smallest counter value—the one that's been accessed the fewest times.; Lesson 1374 — Counting-Based Algorithms
License plates: with 3 letters (A–Z): 26³ = 17,576 combinations; Lesson 101 — Permutations with Repetition
Lifetime: is the period during program execution when a variable occupies space in memory.; Lesson 212 — Variable Lifetime Basics Lesson 215 — Scope and Lifetime: The Key Difference Lesson 2091 — Ownership and Lifetime Management
LIFO (Last-In, First-Out): principle is fundamental to how programs manage temporary data during execution.; Lesson 2075 — Stack Memory Fundamentals
Lightweight: Minimal overhead since the kernel manages only one thread.; Lesson 1234 — Multithreading Models: Many-to-One Lesson 1447 — Error Detection with Parity and Checksums
limit: (or bound) on the number of times other processes can enter their critical sections before this process gets its turn.; Lesson 1277 — Bounded Waiting Property Lesson 1380 — Logical Address Translation in Segmentation Lesson 1381 — Segmentation with Protection and Sharing
Limit branch lifespan: Long-lived branches accumulate merge conflicts; aim for days, not weeks; Lesson 2193 — Branch Management Best Practices
Limit diners: Use a counting semaphore initialized to 4, allowing only four philosophers to attempt eating simultaneously; Lesson 1300 — Dining Philosophers Problem
Limit production: when needed (like creating only one manager object); Lesson 2264 — Introduction to Creational Patterns
Limit register: Holds the size (length) of the process's memory region; Lesson 1332 — Base and Limit Registers
Limitation: A line might run, but not all its logic paths get tested.; Lesson 2232 — Code Coverage Metrics Lesson 2452 — HTTPS Performance: Session Resumption Lesson 2643 — Read Repair and Anti-Entropy
Limitations: Lesson 676 — Edge List Representation
limited memory: .; Lesson 777 — Heapsort Overview and Motivation Lesson 799 — When to Use Which Sorting Algorithm
Limited physical memory: – Processes can't exceed available RAM; Lesson 1338 — Motivation for Virtual Memory
Line queries: (finding min `mx + b` for varying `x`): Convex hull trick fits perfectly.; Lesson 964 — Choosing the Right Optimization
Linear: `n` — doubles when input doubles; Lesson 278 — Growth Rates and Dominant Terms
Linear decision boundaries: Without feature engineering (polynomial features, interactions), logistic regression can only draw straight lines (or hyperplanes) between classes.; Lesson 2837 — Assumptions and Limitations of Logistic Regression
linear probing: creates clusters—long runs of occupied slots that slow down future insertions and lookups.; Lesson 425 — Quadratic Probing Lesson 436 — Open Addressing Performance Characteristics Lesson 437 — Primary and Secondary Clustering Effects Lesson 1691 — Collision Handling in Hash Indexes Lesson 1694 — Hash Index Insertion and Deletion
Linear programming: (surprisingly!; Lesson 1890 — Examples of Problems in P
Linear scalability: (add nodes, get proportional performance); Lesson 1744 — Apache Cassandra: Architecture and Use Cases
Linear scan: through all vertices to find the unvisited one with minimum `dist` value (O(V)); Lesson 972 — Dijkstra's with Array-Based Priority Queue
Linear Search: Lesson 272 — Best-Case, Worst-Case, and Average-Case Lesson 273 — Input Size as a Variable Lesson 285 — O(n): Linear Time
Linear stage: Compute `z = w ᵀx + b` (just like linear regression); Lesson 2828 — Logistic Regression Model and Hypothesis
linear time: .; Lesson 648 — Segment Tree Time and Space Complexity Lesson 824 — QuickSelect Analysis and Performance
Linearithmic time: combines two growth rates you've already seen: **linear (O(n))** and **logarithmic (O(log n))**.; Lesson 286 — O(n log n): Linearithmic Time
Linearity of Expectation: states that the expected value of a sum equals the sum of the expected values:; Lesson 132 — Linearity of Expectation
Linearizability: Operations appear to happen instantaneously at some point between their start and completion; Lesson 2601 — Consistency in Distributed Systems Lesson 2611 — Strong Consistency (Linearizability)Lesson 2621 — Consistency vs Availability Tradeoffs Lesson 2624 — Choosing the Right Consistency Model
linearly: with `n`.; Lesson 274 — Analyzing Simple Loops Lesson 279 — Constant Factors and Why They're Dropped Lesson 1479 — TCP Congestion Control: Congestion Avoidance
link: from the parent.; Lesson 620 — Trie Node Structure and Components Lesson 1431 — Introduction to Computer Networks
Link count: How many directory entries point to this file; Lesson 1388 — File Attributes and Metadata Lesson 1397 — File Control Blocks and Inodes
Link Layer (TCP/IP): = OSI Layers 1 & 2; Lesson 1439 — Mapping OSI to TCP/IP
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 Lesson 420 — Separate Chaining: Implementation Lesson 526 — Comparing BST to Array and Linked List Lesson 1361 — Hashed Page Tables
Linked list nodes: scatter across memory wherever allocation happens, causing frequent **cache misses** as the CPU jumps between distant memory locations.; Lesson 385 — Queue Implementation Tradeoffs
Linked list stacks: require extra memory for each node's pointer(s).; Lesson 364 — Stack Implementation Tradeoffs
linked list-based queue: grows and shrinks dynamically.; Lesson 382 — Linked List-Based Queue Implementation Lesson 384 — Queue Size and IsEmpty Operations
Linked list-based queues: use exactly the memory needed for current elements, but *each node* carries overhead: one or two pointers (8–16 bytes on modern systems) plus the data itself.; Lesson 385 — Queue Implementation Tradeoffs
linked lists: when size is unpredictable, predictable timing matters more than raw speed, or elements are large (making pointer overhead negligible).; Lesson 364 — Stack Implementation Tradeoffs Lesson 385 — Queue Implementation Tradeoffs
Linkers: resolve symbol dependencies in executable files; Lesson 720 — Topological Sort Applications
Linters: flag code that "smells" wrong; Lesson 1886 — Practical Approximations
Linux: Use your package manager (`sudo apt install git` on Ubuntu/Debian, `sudo yum install git` on Fedora/CentOS); Lesson 2169 — Installing and Configuring Git
Linux and Windows: primarily use the one-to-one model because the concurrency benefits outweigh the overhead for typical applications.; Lesson 1235 — Multithreading Models: One-to-One
Liskov Substitution Principle: a subtype must be usable wherever its supertype is expected without breaking program correctness.; Lesson 1994 — Subtyping and Type Hierarchies
LISTEN: Server is waiting for incoming connection requests; Lesson 1482 — TCP States and State Machine
Listen before speaking: A device checks if the channel is idle; Lesson 1450 — Medium Access Control (MAC)
Lists in Prolog: and leveraging **Backtracking** to explore alternatives.; Lesson 2162 — Recursive Rules in Prolog
Literal: (integer constant); Lesson 1940 — Token Classification
Literal values: `true ⇓ true` and `false ⇓ false` (base cases); Lesson 2021 — Semantics of Boolean Expressions
Little-endian: Least significant byte first (like reading right-to-left); Lesson 29 — Byte Order Marks and Endianness
Livelock: looks active but makes no progress.; Lesson 1318 — Deadlock vs Livelock vs Starvation
Liveness: means that something good eventually happens.; Lesson 2649 — Safety and Liveness Properties Lesson 2650 — The FLP Impossibility Result Lesson 2655 — Leader Election Basics Lesson 2680 — Paxos Safety and Liveness Properties
Living Documentation: Your test suite becomes executable documentation.; Lesson 2263 — TDD Benefits and Common Pitfalls
Living specification: The code itself (when clean and well-structured) demonstrates what the system actually does; Lesson 2363 — Working Software Over Comprehensive Documentation
LL(1): friendly, meaning deterministic with one-token lookahead.; Lesson 1955 — Left Factoring
LL(1) grammar: is a context-free grammar that can be parsed from **L**eft-to-right, building a **L**eftmost derivation, with just **1** token of lookahead.; Lesson 1958 — LL(1) Grammars
LL(1) parsing table: is a two-dimensional lookup table that tells a predictive parser exactly which production to apply based on the current non-terminal and the next input token (lookahead).; Lesson 1959 — LL(1) Parsing Tables
load balancing: problem.; Lesson 1263 — Load Balancing Concepts Lesson 1266 — Per-CPU Run Queues Lesson 2596 — Heterogeneity of Hardware and Software
Load distribution: Multiple replicas can share read traffic, reducing bottlenecks and improving throughput.; Lesson 2637 — Introduction to Replication Lesson 2696 — Trade-offs in Partitioning Strategies
load factor: (α), which is the average number of keys per bucket:; Lesson 421 — Separate Chaining: Analysis Lesson 424 — Linear Probing: Clustering Problem Lesson 428 — Load Factor and Rehashing Lesson 429 — Rehashing Process Lesson 432 — Load Factor and Its Impact on Performance Lesson 435 — Chaining Performance with Load Factor Lesson 2582 — Concurrent Hash Map: Basics
Load factor matters more: As the table fills up, finding empty slots becomes harder; Lesson 422 — Open Addressing: Concept
Load factor tuning: α = 0.; Lesson 441 — Benchmarking and Practical Performance
Load instructions: Copying data from a memory address into a register; Lesson 1087 — Memory Access Stage Lesson 1090 — Instruction Cycle Variations
Load into RAM: OS reads the page from disk into a free physical frame; Lesson 1346 — Page Faults and Demand Paging
Load state: Restore Task B's previously saved state; Lesson 2547 — Single-Core Concurrency Through Time-Slicing
load-use hazard: .; Lesson 1170 — Forwarding Paths and Limitations Lesson 1171 — Load-Use Hazards
local: to that function.; Lesson 208 — Local Variables and Function Scope Lesson 2016 — Type Inference in Modern Languages
Local Descriptor Table (LDT): store segment descriptors containing:; Lesson 1385 — Segmentation in x86 Architecture
Local event: Increment your own counter; Lesson 2631 — Vector Clocks Fundamentals
Local File Inclusion (LFI): Including local files that may contain code; Lesson 2489 — Path Traversal and File Inclusion
Local order: Operations on the same process are causally ordered; Lesson 2613 — Causal Consistency
Local variables: come to life when their declaration is executed and die when their block/function exits; Lesson 212 — Variable Lifetime Basics Lesson 214 — Static Lifetime Variables Lesson 374 — Stack-Based Memory Management Lesson 2076 — Stack Frames and Activation Records Lesson 2334 — Data Clumps Smell Lesson 2556 — Critical Sections
locality of reference: .; Lesson 784 — Heapsort vs Quicksort Comparison Lesson 1109 — Locality of Reference Lesson 1117 — Cache as Fast Temporary Storage Lesson 1119 — Cache Hit vs Cache Miss Lesson 1345 — Translation Lookaside Buffer (TLB)Lesson 1362 — Translation Lookaside Buffer (TLB)
Locate all occurrences: of a pattern quickly; Lesson 634 — Suffix Trees: Motivation and Structure
Locate the element: (typically you'll have its index); Lesson 594 — Increase/Decrease Key Operations
Location: File, line, and column numbers; Lesson 1996 — Type Errors and Error Messages
lock contention: .; Lesson 1266 — Per-CPU Run Queues Lesson 2576 — Why Thread-Safe Data Structures?
Lock count: Increments on each lock, decrements on each unlock; Lesson 1288 — Recursive Locks (Reentrant Mutexes)
Lock granularity: More buckets = more parallelism but more memory overhead for locks.; Lesson 2582 — Concurrent Hash Map: Basics
Lock the door: = entering the critical section; Lesson 1275 — Mutual Exclusion Explained
Lock the mutex: protecting shared state; Lesson 1306 — The Wait-Signal Pattern Lesson 1307 — Condition Variables with Mutexes
lock-free: and **wait-free** approaches rely on special atomic operations provided by hardware.; Lesson 1291 — Lock-Free vs Wait-Free Alternatives Lesson 2575 — Lock-Free vs Wait-Free Guarantees
Locking: Transactions acquire locks on data they're reading or writing, blocking others from interfering; Lesson 1660 — Isolation: Concurrent Transaction Independence
Locks (mutexes): Only one thread can hold the lock at a time; Lesson 1241 — Threading Challenges: Synchronization Needs
log matching property: ensures consistency across servers with a simple guarantee:; Lesson 2666 — Log Consistency and the Matching Property Lesson 2670 — Raft Safety Proof: State Machine Safety Property
Log replication: – distributing commands to followers; Lesson 2657 — Introduction to Raft: Motivation and Overview Lesson 2661 — Raft RPCs: RequestVote and AppendEntries
Log the change: Before modifying any file system structure (inode, data block, free space bitmap), write a descriptive log entry to a dedicated log area on disk; Lesson 1407 — Write-Ahead Logging and Recovery
Log-Structured Merge (LSM) trees: to turn random writes into sequential writes.; Lesson 1740 — Physical Storage: SSTables and Log-Structured Merge Trees
Logarithmic: `log n` — grows very slowly; Lesson 278 — Growth Rates and Dominant Terms Lesson 488 — Balanced vs Unbalanced Trees
Logged and marked complete: Skip it; already done; Lesson 1407 — Write-Ahead Logging and Recovery
Logged but not completed: Replay the operation (redo); Lesson 1407 — Write-Ahead Logging and Recovery
Logging and transactions: By storing command objects, you can replay actions, audit what happened, or roll back a series of operations if something fails.; Lesson 2291 — Command Pattern Fundamentals
Logic approach: "I need *The Great Gatsby*.; Lesson 2166 — Logic vs Imperative Programming
Logic errors: Using the wrong comparison operator or flawed conditions.; Lesson 178 — Infinite Loops and Termination
logical address: consists of two parts:; Lesson 1380 — Logical Address Translation in Segmentation Lesson 1384 — Segmentation with Paging (Hybrid Approach)
logical addresses: (also called *virtual addresses*)—these are the addresses your code "thinks" it's using.; Lesson 1329 — Physical vs Logical Addresses Lesson 1435 — OSI Layer 3: Network Layer
Logical component: A counter that increments when causality demands it; Lesson 2636 — Hybrid Logical Clocks
Logical conjunction: is the formal name for the AND operation you've already seen with logic gates.; Lesson 33 — Logical Conjunction (AND)
Logical division: Programs still see meaningful segments with separate protection and sharing per segment; Lesson 1384 — Segmentation with Paging (Hybrid Approach)
Logical operations: Lesson 1072 — The Arithmetic Logic Unit (ALU)
logical operators: come in.; Lesson 158 — Logical Operators Lesson 165 — What Are Conditionals?
Logical organization: Group related files naturally; Lesson 1414 — Tree-Structured Directories Lesson 1457 — VLANs (Virtual LANs)
Logical time: abandons trying to measure "real" time and instead focuses on **event ordering**.; Lesson 2625 — Physical Time vs Logical Time in Distributed Systems
logically equivalent: .; Lesson 38 — Biconditional Statements Lesson 40 — Logical Equivalence
Login Request: You send username and password to the server; Lesson 2500 — Token-Based Authentication
Lomuto partition scheme: is a straightforward way to perform the partition operation in Quicksort.; Lesson 765 — Lomuto Partition Scheme
Long critical sections: One thread completing complex work beats many retrying simple CAS operations; Lesson 2574 — Performance Characteristics of Lock-Free Algorithms
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
Long Methods: Functions doing too many things at once; Lesson 2329 — Introduction to Code Smells
Long timeouts: Slow to detect real failures, poor user experience; Lesson 2591 — Partial Failures and Fault Detection
Long-Lived Data: Heap memory persists until explicitly freed or garbage-collected.; Lesson 2078 — Heap Memory Fundamentals
Long-term keys: for authentication (proving who you are); Lesson 2418 — Forward Secrecy
Longer pipeline fill/drain times: More stages to fill before reaching peak throughput; Lesson 1156 — Deeper Pipelines: Benefits and Costs
Longest Common Subsequence: , each row depends only on the row above it, so two 1D arrays suffice.; Lesson 956 — Space Optimization with Rolling Arrays
Longest Increasing Subsequence: is the longest such subsequence you can find.; Lesson 926 — Longest Increasing Subsequence (LIS)
Longest path: Alternating red-black nodes (the maximum reds you can insert); Lesson 547 — Red-Black Tree Height Guarantees
Longest prefix matching: solves this by choosing the route with the **longest matching prefix** (the most specific subnet mask).; Lesson 1469 — Longest Prefix Match Routing
LOOK: Services requests while moving in one direction.; Lesson 1427 — LOOK and C-LOOK Variants
Look for "close calls": Make the greedy option *almost* as good, but slightly worse than alternatives combined; Lesson 911 — Counterexamples: When Greedy Fails
Lookahead: means examining the next character(s) without consuming them.; Lesson 1944 — Longest Match and Lookahead
Lookup time: ↑ (checking more ways in parallel takes slightly longer); Lesson 1134 — Comparing Associativity Tradeoffs Lesson 1136 — Associativity Impact on Conflict Misses
loop: is a control structure that repeats a block of code multiple times based on a condition.; Lesson 175 — What is a Loop?Lesson 760 — Bottom-Up Mergesort Lesson 1806 — The Pumping Lemma for Regular Languages
Loop forever: on a string → string is not in L(M); Lesson 1859 — Languages Recognized by Turing Machines
loop invariants: statements that remain true before and after each iteration.; Lesson 97 — Induction in Algorithm Analysis Lesson 2066 — Loop-Invariant Code Motion
loops: and **correlated branches** where the same instruction behaves predictably but differently from other branches.; Lesson 1182 — Local History Predictors Lesson 1979 — AST Representation of Statements Lesson 2055 — Control Flow Code Generation
Loops (`while`, `for`): repeat blocks of code:; Lesson 2117 — Explicit Control Structures
loose coupling: colleagues don't need to know about each other, only about the mediator.; Lesson 2297 — Mediator Pattern Lesson 2318 — Code Organization and Module Structure
Loss: A message might never arrive due to network failures, buffer overflows, or crashed intermediate routers; Lesson 2592 — Message Loss and Ordering Lesson 2767 — Terminal States and Utility Functions
loss function: and evaluation metrics.; Lesson 2784 — Baseline Models and Evaluation Lesson 2816 — What is Linear Regression?
Lost commits after reset: If you ran `git reset --hard` and lost work, find the commit in the reflog and restore it:; Lesson 2207 — Reflog and Recovery
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
Lost message: Your request never arrived, or the response got dropped; Lesson 2591 — Partial Failures and Fault Detection
Lost pointers: Reassigning a pointer before freeing what it pointed to:; Lesson 2087 — Memory Leaks: Causes and Detection
Lost updates: Two nodes read the same value, modify it, and both write back—one overwrites the other; Lesson 2597 — Concurrency and Race Conditions Lesson 2717 — What Are Distributed Transactions?
Low bias, high variance: Your arrows scatter all around the bullseye (no systematic error, but wildly inconsistent).; Lesson 2782 — The Bias-Variance Tradeoff
Low cardinality estimation: The optimizer estimates few rows will match; Lesson 1702 — Index Selection for Queries
Low collision rate: Few keys should hash to the same bucket (handled by techniques from your previous lesson); Lesson 1692 — O(1) Lookup with Hash Indexes
Low latency: = respond after one replica → faster, but readers might see old data; Lesson 2609 — Beyond CAP: PACELC and Modern Perspectives
Low resource utilization: resources sit idle while processes wait; Lesson 1320 — Deadlock Prevention: Breaking Hold and Wait
Low selectivity: Your query returns a large percentage of rows anyway; Lesson 1702 — Index Selection for Queries
Low threshold (e.g., 0.5): Keeps the table spacious, minimizing collisions and maintaining fast O(1) operations.; Lesson 440 — Space-Time Tradeoffs in Hash Tables
Low to moderate contention: Fewer retries mean the overhead stays manageable; Lesson 2574 — Performance Characteristics of Lock-Free Algorithms
Low-dimensional problems: (typically <20 features) where distance metrics remain meaningful; Lesson 2872 — KNN in Practice: Applications and Limitations
Low-level IR: close to code generation for machine-specific tuning; Lesson 2038 — High-Level vs Low-Level IR Lesson 2048 — Lowering Through Multiple IR Levels
Low-level memory management: (address spaces); Lesson 1196 — Microkernel Architecture
lower bound: , and 5 is the **upper bound**.; Lesson 85 — Summation Notation and Series Lesson 294 — Proving Big-Theta Bounds Lesson 297 — Formal Definition of Big-Omega Lesson 298 — Proving Big-Omega Bounds Lesson 304 — Space Complexity Notation Lesson 500 — BST Range Property Lesson 811 — Upper Bound Search
Lower instruction completion rate: You could be processing faster if stages were balanced; Lesson 1155 — Balancing Pipeline Stages
Lower latency: Operations complete quickly without synchronous replication; Lesson 2697 — Eventual Consistency Definition and Motivation
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.; Lesson 1376 — Page Fault Frequency
Lower threshold (e.g., 0.3): More sensitive, catches more positive cases but may include false positives; Lesson 2829 — Interpreting Probabilities and Decision Boundaries
Lowercase: "a" is 97, "b" is 98.; Lesson 24 — ASCII: The Foundation
Lowering: is the process of translating IR from a higher abstraction level to a lower one.; Lesson 2048 — Lowering Through Multiple IR Levels
Lowest Common Ancestor (LCA): of two nodes in a tree is the deepest node that has both nodes as descendants (where a node can be its own descendant).; Lesson 518 — Lowest Common Ancestor in BST
LR: stands for:; Lesson 1963 — LR Parsing Introduction
LR(0) item: is simply a grammar production with a special dot (•) inserted somewhere on the right-hand side.; Lesson 1964 — LR(0) Items and Item Sets
LR(1) item: extends the LR(0) item by adding a **lookahead symbol**—a terminal that could legally follow this production.; Lesson 1968 — LR(1) Items and Lookahead
LR(1) items: of the form `[A → α·β, a]`, where `a` is a lookahead token.; Lesson 1969 — Canonical LR(1) Parsing
LRU: typically achieves the best hit rates but requires extra hardware to track access order for every block.; Lesson 1123 — Cache Replacement Policies Overview
LSB: least significant bit).; Lesson 650 — Binary Representation and Index Manipulation
LSD: is simpler: sort all elements at each digit position, always processing the complete array.; Lesson 793 — Radix Sort: LSD vs MSD
LSH: uses special hash functions that map similar points to the same bucket with high probability.; Lesson 2870 — Accelerating KNN with Data Structures

M

MAC: minimizes insider risk but creates bottlenecks—only administrators can modify classifications.; Lesson 2533 — Authorization Model Tradeoffs
MAC Address: `AA:BB:CC:DD:EE:01`; Lesson 1455 — Switch Learning and Forwarding
MAC address table: that maps addresses to physical ports.; Lesson 1454 — Network Switches vs Hubs Lesson 1455 — Switch Learning and Forwarding
machine code: .; Lesson 1105 — Assembly to Machine Code Translation Lesson 2035 — Platform Dependency and Portability Lesson 2049 — Introduction to Code Generation
Magic Numbers: Unexplained literal values throughout code; Lesson 2329 — Introduction to Code Smells
Main Memory (RAM): Fast but larger; gigabytes in size; Lesson 1106 — The Memory Hierarchy Concept Lesson 1107 — Storage Pyramid Levels Lesson 1110 — Access Time and Latency Lesson 1111 — Cost Per Byte Analysis Lesson 1113 — Memory Bandwidth Considerations
Main Relaxation Loop: Lesson 984 — Bellman-Ford Implementation
Maintain: Technical debt accumulates, slowing down development; Lesson 2329 — Introduction to Code Smells
Maintain a convex hull: of these lines (lower or upper envelope depending on min/max); Lesson 958 — Convex Hull Trick for DP
Maintain Active Topology: Only one active path exists between any two switches; Lesson 1458 — Spanning Tree Protocol (STP)
Maintain BST property: Since the child was already in the correct BST position (smaller than ancestors if on the left, larger if on the right), the invariant is preserved; Lesson 509 — BST Deletion: One Child Case
Maintain consistency: Use techniques from earlier lessons (quorums, consistent hashing) to ensure data integrity during moves; Lesson 2691 — Rebalancing Partitions
Maintain test hygiene: Remove redundant tests.; Lesson 2245 — Integration Test Maintenance and CI
Maintainability: Change grammar, regenerate parser—no tedious table updates; Lesson 1973 — Parser Generators and YACC/Bison Lesson 2156 — Benefits and Trade-offs of Declarative Style Lesson 2319 — Extract Method: Breaking Down Complex Functions Lesson 2326 — Decompose Conditional: Simplifying Complex If Statements Lesson 2526 — Role-Based Access Control (RBAC)
Maintainability boost: SQL's `SELECT * FROM users WHERE age > 18` is clearer than loops with conditions.; Lesson 2156 — Benefits and Trade-offs of Declarative Style
maintainable: .; Lesson 192 — Function Documentation Lesson 2348 — Reviewing Tests and Documentation
Maintains Sorted Order: Unlike hash tables, BSTs keep elements sorted.; Lesson 502 — BST Advantages and Use Cases
Maintenance: If true before an iteration, it stays true after (the inductive step!; Lesson 97 — Induction in Algorithm Analysis Lesson 2353 — The Waterfall Model: Sequential Phases
Maintenance becomes chaotic: because nobody planned for it; Lesson 2351 — What is a Software Development Lifecycle (SDLC)?
Maintenance burden: Because they touch so much code, E2E tests require constant updates as your application evolves.; Lesson 2254 — E2E Testing Challenges and Best Practices Lesson 2307 — Lava Flow Anti-Pattern Lesson 2332 — Duplicate Code Smell
Maintenance nightmare: Every feature change becomes a scavenger hunt; Lesson 2337 — Shotgun Surgery Smell
Maintenance nightmares: Future developers (including you) struggle to modify code whose purpose is unclear; Lesson 2306 — Cargo Cult Programming Anti-Pattern
MAJOR: Increment when you make breaking changes; Lesson 2202 — Release Tagging and Versioning
MAJOR.MINOR.PATCH: (e.; Lesson 2202 — Release Tagging and Versioning
majority: (quorum) refuse write operations; Lesson 2605 — CP Systems: Consistency and Partition Tolerance Lesson 2678 — Phase 2b: Accepted Notification
Make a backup: `git clone --mirror original-repo backup-repo`; Lesson 2213 — Rewriting History Safely
Make distinctions meaningful: If you have both `get_active_account()` and `get_active_accounts()`, the singular/plural distinction matters; Lesson 2309 — Meaningful Names for Variables and Functions
Make tests independent: Each test should set up its own data and clean up afterward.; Lesson 2254 — E2E Testing Challenges and Best Practices
Make your refactoring changes: (extract functions, simplify logic, improve structure); Lesson 2261 — Refactoring with Confidence
Making locally optimal choices: (nearest pairing) leads to the globally optimal solution; Lesson 900 — Policemen Catch Thieves Problem
Management: Administrators and programs use PIDs to monitor, signal, or terminate specific processes; Lesson 1228 — Process IDs and Identification
Manchester Encoding: Each bit period has a transition—`0` transitions low-to-high, `1` high-to-low.; Lesson 1443 — Signal Encoding and Modulation
Mandatory locking: is enforced by the operating system itself.; Lesson 1393 — File Locking Mechanisms
Mandatory password rotation: (changing every 60-90 days): Research shows this encourages weak, incremental changes; Lesson 2512 — Password Policies and Requirements
Manhattan: is more robust to outliers and works better in high-dimensional spaces; Lesson 2864 — Distance Metrics for KNN
Manhattan distance: for grid-restricted movement (minimum steps ignoring obstacles); Lesson 1003 — Admissible Heuristics Lesson 2755 — Designing Admissible Heuristics
Manual: Languages like C require you to explicitly free memory (`free()`) when done, or it leaks.; Lesson 2078 — Heap Memory Fundamentals
Manual code review: Trace each `malloc()` to ensure a matching `free()` on every execution path.; Lesson 2087 — Memory Leaks: Causes and Detection
Manual iteration: Loop through the original array and assign each element to a new array at the same index; Lesson 240 — Array Copying and Cloning
Manual or Automatic Management: Lesson 2078 — Heap Memory Fundamentals
Manual verification required: Developers must use testing, code review, and careful reasoning—but even then, some bugs may slip through.; Lesson 1883 — Implications for Program Verification
Manufacturing variations: No two quartz crystals oscillate identically; Lesson 2626 — Clock Skew and Clock Drift
Many duplicates: **Three-way Quicksort** avoids redundant comparisons.; Lesson 799 — When to Use Which Sorting Algorithm
Many small, concurrent transactions: happening simultaneously; Lesson 1650 — OLTP vs OLAP Database Design
Map: Transform each element using a function; Lesson 2136 — Map, Filter, and Reduce
Map coloring: (regions are vertices, borders create edges); Lesson 1925 — Graph Coloring Problem
Map to a node: – Use the hash output to select a node, often with modulo: `node_id = hash(key) % num_nodes`; Lesson 1729 — Hash-Based Key Distribution
Mark A as finalized: this is the mistake!; Lesson 971 — Why Negative Edges Break Dijkstra's Algorithm
Mark accept states: where the pattern is satisfied; Lesson 1781 — Designing Simple DFAs
Mark complete: Optionally note in the log that the operation finished; Lesson 1407 — Write-Ahead Logging and Recovery
Mark completion: Set the `isEndOfWord` flag to `true` at the final node; Lesson 621 — Trie Insertion: Adding Words
Mark each visited vertex: as you explore; Lesson 730 — Component Finding with DFS
Mark journal entry complete: Once all changes are logged, write a commit marker; Lesson 1406 — File System Consistency and Journaling
Mark new accepting states: (any class containing at least one original accepting state); Lesson 1790 — Constructing the Minimal DFA
Mark null children: When a node is missing, store a sentinel value (like `null` or `-1`); Lesson 467 — Converting Between Representations
Mark visited: Track the current node to avoid cycles; Lesson 710 — DFS Recursive Implementation
Marker/Sentinel Method: Lesson 701 — Level-Order Traversal
Market Responsiveness: When competitors launch a feature or customer needs shift, you can adapt in weeks instead of waiting for next year's release.; Lesson 2369 — Continuous Delivery of Value
Marking visited cells: prevents infinite loops (walking in circles); Lesson 863 — Maze and Path Finding
Masking: temporarily disables certain (or all) interrupts during these **critical sections**.; Lesson 1213 — Interrupt Priority and Masking
Massive scale: Billions of users generating petabytes of data; Lesson 1708 — What is NoSQL and Why It Exists
Master data: that must remain the single source of truth; Lesson 1653 — Hybrid Normalization Strategies
Match: Return the node (found!; Lesson 503 — BST Search: Finding a Node Lesson 1128 — Direct-Mapped Cache Lookup
Match operations to instructions: A TAC operation like `t1 = a + b` becomes an ADD instruction in the target architecture; Lesson 2051 — Three-Address Code Translation
Match terminals: In `q_loop`, for each terminal `a`, pop `a` when reading `a` from input; Lesson 1836 — Converting CFGs to PDAs Lesson 1952 — Implementing Recursive Descent Functions
matching: assigns edges so no vertex appears twice—like pairing each job to at most one applicant.; Lesson 1046 — Bipartite Matching via Max Flow Lesson 1047 — Maximum Bipartite Matching Algorithm
Mathematics itself: Automated theorem proving; Lesson 1912 — The Million Dollar Question
Matrices: are perfect for computation and finding properties; Lesson 68 — Representing Relations Lesson 2731 — State Representation Strategies
Matrix Chain Multiplication: can use Knuth's Optimization because its cost structure satisfies this property.; Lesson 960 — Knuth's Optimization
Matroids: provide the answer.; Lesson 910 — Matroid Theory and Greedy Algorithms
Max: maximum resources each process might need; Lesson 1324 — The Banker's Algorithm Lesson 2759 — Combining Heuristics: Max and Sum
Max depth/complexity: of base models:; Lesson 2862 — Ensemble Selection and Hyperparameters
MAX nodes: – your player maximizes utility (unchanged); Lesson 2773 — Stochastic Games and Expectiminimax
max-heap: is a complete binary tree where every parent node contains a value *greater than or equal to* the values of its children.; Lesson 578 — Heap Order Property: Max-Heap Lesson 585 — Heap Structure Invariants Lesson 615 — Median Maintenance with Two Heaps Lesson 618 — Top-K Elements Problem
Maximizing player: (you) picks the move leading to the highest score; Lesson 2766 — Minimax Algorithm
maximum: of steps 2 and 3 to step 1 for worst-case; Lesson 277 — Analyzing Conditional Statements Lesson 820 — Ternary Search for Unimodal Functions Lesson 837 — Boyer-Moore: Good Suffix Rule Lesson 919 — Identifying DP Problems Lesson 2759 — Combining Heuristics: Max and Sum
Maximum boundary: Test 119 (valid), 120 (valid), 121 (invalid); Lesson 2222 — Boundary Value Analysis
Maximum Flow: The most water you can push from source to sink; Lesson 1050 — Min-Cut and Max-Flow Duality
Maximum height: n - 1 (degenerate/skewed tree); Lesson 491 — Binary Tree Theorems
Maximum impurity: 5 samples class A, 5 samples class B → `p_A = p_B = 0.; Lesson 2842 — Impurity Measures: Entropy
Maximum Independent Set: problem: selecting the most nodes from a tree such that no two selected nodes share an edge.; Lesson 945 — Maximum Independent Set on Trees
Maximum keys: No node may exceed `2t-1` keys; Lesson 558 — B-Tree Invariants
Maximum nodes: = 2^(h+1) - 1 (when perfect); Lesson 487 — Node Count Formulas
Maximum path length (m): longest possible path; Lesson 2735 — State Space Size and Complexity
Maximum segment size (MSS): Affects efficiency and overhead; Lesson 1485 — TCP Performance Considerations
Maximum Spanning Tree: Instead of minimizing total weight, maximize it.; Lesson 1021 — MST Applications and Variations
Maximum Transmission Unit (MTU): the largest packet size it can handle in one piece.; Lesson 1492 — UDP Maximum Datagram Size and Fragmentation
Maze solving: States are (row, column) positions; Lesson 705 — BFS with State Space Representation
MD5: Collision attacks became practical in 2004.; Lesson 2426 — Common Hash Functions: MD5 and SHA-1
Mean predictor: Always predict the average label value; Lesson 2784 — Baseline Models and Evaluation
Mean Squared Error (MSE): Heavily penalizes large mistakes (like being way off the bullseye); Lesson 2779 — Loss Functions and Objective Functions Lesson 2804 — Performance Metrics Selection Lesson 2818 — Loss Functions: Mean Squared Error Lesson 2845 — Splitting Criteria for Regression Trees
meaning: of the data, not just current table contents; Lesson 1621 — Introduction to Functional Dependencies Lesson 1817 — Ambiguous Grammars
Meaningful Names: and **Reducing Complexity**—consolidation eliminates repetitive structure and communicates intent through naming.; Lesson 2324 — Consolidate Conditional Expressions
Measure actual performance: using profiling tools; Lesson 2305 — Premature Optimization Anti-Pattern
Median predictor: Always predict the median (robust to outliers); Lesson 2784 — Baseline Models and Evaluation
Median-first input: → best balance → O(log n) operations; Lesson 527 — Impact of Insertion Order
Mediator interface: defines how colleagues communicate; Lesson 2297 — Mediator Pattern
Medium Access Control (MAC): Lesson 1445 — Data Link Layer Responsibilities
Medium datasets (1,000-100,000): Stick with the 80-20 or 70-30 standards.; Lesson 2800 — Train-Test Split Ratios
Meeting Room: problems you've seen, but here we're counting maximum overlaps rather than selecting non- overlapping intervals.; Lesson 896 — Minimum Platforms Problem
MEM → EX: Data from the Memory Access stage forwards to an Execute stage operation; Lesson 1170 — Forwarding Paths and Limitations
MEM → MEM: Memory data forwards to another memory operation; Lesson 1170 — Forwarding Paths and Limitations
Membership: Is a specific string *w* in the language?; Lesson 1811 — Decision Properties of Regular Languages
Memcached: offers no consistency guarantees between replicas—each cache node operates independently.; Lesson 2622 — Consistency in Practice: Examples
Memento: A snapshot that stores the originator's state (opaque to outsiders); Lesson 2298 — Memento Pattern
Memento Pattern: solves this by letting you capture and store an object's state in a separate "memento" object, which can later restore the original object—all without revealing internal details.; Lesson 2298 — Memento Pattern
Memoization: is a specific caching technique where a function remembers its previous outputs for given inputs, avoiding redundant calculations.; Lesson 443 — Caching and Memoization Lesson 873 — Recursion with Memoization Integration Lesson 913 — What is Dynamic Programming?
Memoization (Top-Down): Lesson 918 — Top-Down vs Bottom-Up Tradeoffs
memorizing: the training examples rather than learning generalizable patterns.; Lesson 2777 — Training Data vs Test Data Lesson 2849 — Overfitting in Decision Trees
memory: .; Lesson 302 — What is Space Complexity?Lesson 868 — Recursive vs Iterative Tradeoffs Lesson 2109 — Reference Counting Performance Lesson 2761 — IDA* (Iterative Deepening A*)
Memory Access: stage is where that happens.; Lesson 1087 — Memory Access Stage Lesson 1089 — Instruction Cycle Timing Lesson 1141 — Miss Penalty Components Lesson 1148 — Introduction to Instruction Pipelining Lesson 1162 — Structural Hazards: Definition
Memory Access (MEM): Lesson 1149 — The Classic Five-Stage Pipeline
Memory access conflicts: One instruction trying to fetch the next instruction while another reads/writes data from the same memory unit; Lesson 1162 — Structural Hazards: Definition Lesson 1163 — Detecting Structural Hazards
Memory access patterns: Chaining with linked lists causes cache misses; open addressing can be faster due to better locality; Lesson 441 — Benchmarking and Practical Performance
Memory access time: (slower, maybe 100 ns); Lesson 1364 — Effective Access Time with Paging
memory address: a number that identifies exactly where in RAM that variable lives.; Lesson 312 — Memory Addresses and the Address-of Operator Lesson 1083 — Program Counter and Instruction Address
Memory Address Register (MAR): and the **Memory Data Register (MDR)**.; Lesson 1078 — Memory Address and Data Registers Lesson 1082 — The Fetch Stage Lesson 1087 — Memory Access Stage
Memory available: **Mergesort** is stable and predictable, worth the O(n) space.; Lesson 799 — When to Use Which Sorting Algorithm
Memory compaction: (moving segments to consolidate free space) is expensive and requires updating segment tables; Lesson 1382 — External Fragmentation in Segmentation
Memory Constraints: Lesson 799 — When to Use Which Sorting Algorithm Lesson 2692 — Cross-Shard Queries and Joins
Memory consumption: Smaller types = more data fits in memory; Lesson 152 — Memory and Variable Storage
Memory cost: (measured in kibibytes): How much RAM each hash requires; Lesson 2508 — Password Hashing with Argon2
Memory Data Register (MDR): .; Lesson 1078 — Memory Address and Data Registers Lesson 1082 — The Fetch Stage Lesson 1087 — Memory Access Stage
Memory efficiency: In arrays storing millions of numbers, using `short` instead of `long` saves significant space; Lesson 140 — Integer Data Types Lesson 422 — Open Addressing: Concept Lesson 807 — External Sorting for Large Datasets
Memory efficient: No pointer overhead, no wasted zeros; Lesson 683 — Hybrid and Compressed Representations Lesson 2772 — Iterative Deepening in Games
Memory follows process: Some systems can migrate memory pages to follow frequently-scheduled processes; Lesson 1268 — NUMA-Aware Scheduling
Memory hardness: .; Lesson 2508 — Password Hashing with Argon2
Memory Hierarchy Interaction: Lesson 1365 — Paging Performance Considerations
Memory is wasted: despite being technically "free"; Lesson 1336 — Fragmentation in Contiguous Allocation
memory leak: lost memory that your program can never use again.; Lesson 332 — Deleting from the Head Lesson 2083 — Common Pitfalls: Dangling Pointers and Leaks
memory management: service acts like a careful librarian, allocating memory to each program, ensuring they don't interfere with each other, and creating the illusion that each has more memory than physically exists.; Lesson 1200 — Core OS Services: Memory Management Lesson 2715 — Message Queue Performance Considerations
Memory management information: Base/limit registers, page tables, or segment tables; Lesson 1217 — Process Control Block (PCB)
Memory Management Unit (MMU): is the hardware component that translates logical addresses to physical addresses on-the-fly, transparently to your program.; Lesson 1329 — Physical vs Logical Addresses Lesson 1340 — Address Translation Overview Lesson 1343 — Memory Management Unit (MMU)
Memory operations: For load/store instructions, the ALU might calculate a memory address (base address + offset), then the memory unit reads from or writes to that location.; Lesson 1086 — The Execute Stage
Memory overhead: Requires a mark bit per object; Lesson 2096 — Mark-and-Sweep Collection
Memory requirements: Explicit spaces store all states; implicit spaces generate successors on-demand; Lesson 2736 — Explicit vs Implicit State Spaces
Memory stall cycles: = (Instructions × Miss rate × Miss penalty); Lesson 1145 — Cache Performance Metrics and Benchmarking
Memory to Register (Load): Lesson 1095 — MOV and Data Transfer Instructions
Memory Usage During Execution: Lesson 2059 — Optimization Goals and Tradeoffs
Memory-constrained environments: Heapsort sorts in-place with only O(1) extra space.; Lesson 608 — Practical Considerations for Heapsort
Memory-constrained systems: Accept higher load factors and slower operations; Lesson 440 — Space-Time Tradeoffs in Hash Tables Lesson 821 — The Selection Problem Definition
memory-efficient: for simple storage.; Lesson 630 — Tries vs Hash Tables for String Storage Lesson 878 — What Makes an Algorithm Greedy?
Memory-efficient like DFS: Only stores one path from root to current node, plus siblings at each level — O(bd) space for branching factor b and depth d; Lesson 2745 — Iterative Deepening DFS
MemTable (Memory): New writes go into an in-memory sorted structure first—fast!; Lesson 1740 — Physical Storage: SSTables and Log-Structured Merge Trees
merge: nodes together.; Lesson 566 — Merging Nodes in B-Trees Lesson 752 — Introduction to Mergesort Lesson 1677 — B-Tree Structure and Properties Lesson 1682 — B-Tree Deletion Overview Lesson 2193 — Branch Management Best Practices
Merge conflicts: When multiple developers modify the same bloated class, version control becomes a nightmare; Lesson 2302 — God Object Anti-Pattern
Merge conflicts shrink: because changes don't diverge for long; Lesson 2199 — Trunk-Based Development
Merge intelligently: Once runs are identified and extended, merge them using an optimized mergesort approach, carefully maintaining a stack of runs and merging in a way that minimizes comparisons.; Lesson 802 — Timsort: Python's Default Sorting Algorithm
Merge Join: Sort both inputs, then merge them together; Lesson 1698 — Query Execution Plans and Operators
Merge results: combine data from all sources, with newer entries overriding older ones; Lesson 1741 — Read and Write Operations in Column Families
Merge the runs: Use a multi-way merge (similar to the merge operation in Mergesort) to combine these sorted chunks.; Lesson 807 — External Sorting for Large Datasets
Merge to main branch: Run all tests, build artifacts, and potentially deploy; Lesson 2385 — Version Control Integration
Merge when ready: Once tested and approved, merge back into `main`; Lesson 2195 — Feature Branch Workflow
mergesort: and **quicksort** achieve O(n log n) time by cleverly combining:; Lesson 286 — O(n log n): Linearithmic Time Lesson 607 — Heapsort vs Quicksort vs Mergesort Lesson 777 — Heapsort Overview and Motivation Lesson 785 — Heapsort vs Mergesort Comparison Lesson 799 — When to Use Which Sorting Algorithm Lesson 800 — Hybrid Sorting Strategies Lesson 806 — Parallel Sorting Algorithms Lesson 841 — Divide and Conquer Paradigm Overview (+2 more)
Merging: O(n) — combining sorted halves; Lesson 756 — Mergesort Time Complexity Analysis Lesson 1683 — Deletion from Leaf Nodes Lesson 2632 — Vector Clock Operations
Mesa: You drop the baton in a box and keep running; the next runner picks it up whenever they get scheduled; Lesson 1312 — Condition Variable Mesa vs Hoare Semantics
Mesa semantics: (signal-and-continue) and **Hoare semantics** (signal-and-wait).; Lesson 1312 — Condition Variable Mesa vs Hoare Semantics
Mesa semantics (signal-and-continue): The signaling thread **continues running**.; Lesson 1312 — Condition Variable Mesa vs Hoare Semantics
Message Authentication Code (MAC): – How to verify data integrity (e.; Lesson 1536 — TLS Cipher Suites
message passing: rather than direct function calls.; Lesson 1196 — Microkernel Architecture Lesson 2627 — Happens-Before Relation
metadata: (data about the data).; Lesson 1388 — File Attributes and Metadata Lesson 1677 — B-Tree Structure and Properties Lesson 2090 — Memory Corruption and Buffer Overflows
Method overriding: means a subclass provides its own implementation of a method already defined in its parent class.; Lesson 2127 — Method Overriding and Polymorphism
Method signatures: that repeatedly take the same 3-4 parameters together; Lesson 2334 — Data Clumps Smell
Methods: (also called member functions): functions that operate on that state; Lesson 2122 — Classes and Objects
MFU: does the opposite—it replaces the page with the *highest* counter.; Lesson 1374 — Counting-Based Algorithms
Michael-Scott algorithm: achieves this by using atomic compare-and-swap operations to safely modify shared pointers at the head and tail of a linked list.; Lesson 2580 — Lock-Free Queue with CAS
Mid-level IR: for architecture-neutral optimizations; Lesson 2038 — High-Level vs Low-Level IR Lesson 2048 — Lowering Through Multiple IR Levels
middle: (for the next character in the word), and **right** (for characters that come after).; Lesson 638 — Ternary Search Tree Operations Lesson 1426 — C-SCAN (Circular SCAN)Lesson 2217 — The Testing Pyramid
Middle child: stores strings where the current character *matches* this node's character — this continues the same word; Lesson 637 — Ternary Search Trees
Middle-end optimizations: operate on lower-level IR like SSA form (common subexpression elimination, loop transformations); Lesson 2060 — Optimization Phases and Safety
MIN nodes: – opponent minimizes utility (unchanged); Lesson 2773 — Stochastic Games and Expectiminimax
min-heap: is a complete binary tree with one special invariant: **every parent node contains a value that is less than or equal to the values of both its children**.; Lesson 577 — Heap Order Property: Min-Heap Lesson 585 — Heap Structure Invariants Lesson 614 — Huffman Coding Tree Construction Lesson 615 — Median Maintenance with Two Heaps Lesson 617 — Load Balancing Systems Lesson 618 — Top-K Elements Problem Lesson 899 — Connect N Ropes with Minimum Cost
min-heap priority queue: to store future events sorted by their scheduled time.; Lesson 612 — Event-Driven Simulation Lesson 613 — Dijkstra's Algorithm with Priority Queue
Min-Max Normalization: (rescales to [0,1]):; Lesson 2824 — Feature Scaling and Normalization Lesson 2868 — Feature Scaling in KNN
Min/Max: Each node stores the minimum or maximum in its range.; Lesson 647 — Segment Tree Variants and Functions
Min/max values: for a column; Lesson 1704 — Statistics and Histograms
Mini-batch: Ask a small group, then step.; Lesson 2822 — Batch vs Stochastic Gradient Descent
Minimal Overhead: Lesson 1493 — UDP Performance Characteristics
Minimization: (the μ operator): Find the smallest number that makes a function equal zero; Lesson 1863 — Alternative Models: Recursive Functions
Minimize data movement: Transferring terabytes is expensive; Lesson 2691 — Rebalancing Partitions
Minimizing player: (opponent) picks the move leading to the lowest score for you; Lesson 2766 — Minimax Algorithm
Minimum 8-12 characters: (ideally longer); Lesson 2512 — Password Policies and Requirements
Minimum boundary: Test -1 (invalid), 0 (valid), 1 (valid); Lesson 2222 — Boundary Value Analysis
Minimum Cut: The smallest total capacity of edges you'd need to remove to completely disconnect the source from the sink; Lesson 1050 — Min-Cut and Max-Flow Duality
Minimum height: ⌈log₂(n+1) ⌉ - 1 (perfect/complete tree); Lesson 491 — Binary Tree Theorems
Minimum nodes: = h + 1 (when each node has only one child—a skewed tree); Lesson 487 — Node Count Formulas
Minimum per node: data + 2 pointers (typically 12-24 bytes for simple integer keys); Lesson 525 — Space Complexity of BSTs
Minkowski: lets you tune sensitivity to coordinate differences; Lesson 2864 — Distance Metrics for KNN
MINOR: Increment when you add backwards-compatible features; Lesson 2202 — Release Tagging and Versioning
MIPS: Historically used in embedded systems and education; Lesson 1092 — Instruction Set Architecture (ISA)Lesson 1190 — MIPS and FLOPS Metrics
Misapplied patterns: Using the right tool in the wrong context; Lesson 2301 — Introduction to Anti-Patterns
Misplaced tiles: Relax even further—assume any tile can jump to its goal in one move.; Lesson 2755 — Designing Admissible Heuristics
Mispredict twice per loop: once when entering (predicts not-taken but takes), and once when exiting (predicts taken but doesn't); Lesson 1178 — One-Bit Branch Predictor
miss penalty: the extra time required to fetch that data from the next, slower level.; Lesson 1114 — Hit Rate and Miss Penalty Lesson 1115 — Effective Access Time Calculation Lesson 1125 — Measuring Cache Effectiveness Lesson 1140 — Average Memory Access Time (AMAT)Lesson 1141 — Miss Penalty Components
miss rate: is simply the opposite: `miss rate = 1 - hit rate`.; Lesson 1114 — Hit Rate and Miss Penalty Lesson 1125 — Measuring Cache Effectiveness Lesson 1134 — Comparing Associativity Tradeoffs Lesson 1139 — Cache Hit Rate and Miss Rate Lesson 1140 — Average Memory Access Time (AMAT)
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
Missing test cases: Are edge cases tested?; Lesson 2348 — Reviewing Tests and Documentation
Mitigation: TLS 1.; Lesson 1540 — Common TLS Attacks and Mitigations
Mix: (opcode) ingredients from **bowl 2** and **bowl 5** (operands), put result in **bowl 2**.; Lesson 1085 — Instruction Formats and Opcodes
Mixed code: Typed and untyped code coexist in the same program; Lesson 2005 — Gradual Typing Systems
Mixed operation workload: When you're doing lots of searches, insertions, and deletions together, BSTs balance all three reasonably well in average cases.; Lesson 530 — When to Use BSTs
Mixing (MixColumns): Mathematically combine columns to spread changes throughout the block; Lesson 2401 — AES: The Advanced Encryption Standard
Mobile apps: fitness trackers syncing data to health platforms; Lesson 2534 — OAuth 2.0 Overview and Use Cases
Model checkers: explore a *bounded* state space instead of infinite possibilities; Lesson 1886 — Practical Approximations
Model the problem: Define what a "state" is (e.; Lesson 705 — BFS with State Space Representation
Model too simple: Using linear regression when the relationship is polynomial; Lesson 2809 — What is Underfitting?
Model type: Linear models have simpler hypothesis spaces than decision trees or neural networks; Lesson 2778 — The Hypothesis Space
Models organizational structure: Mirrors real-world hierarchies naturally; Lesson 2527 — RBAC Hierarchies
Modern Git (`git restore`): Lesson 2178 — Undoing Changes in Working Directory
Modes of operation: solve this by defining how to apply a block cipher to multi-block messages.; Lesson 2402 — Block Cipher Modes of Operation
modified: to **staged** to **committed**.; Lesson 2172 — Tracking Files with 'git add'Lesson 2187 — Merge Conflicts: Basics
Modified files: are files you've changed since your last commit but haven't staged yet.; Lesson 2174 — Checking Repository Status
Modify: Simple changes become risky and time-consuming; Lesson 2329 — Introduction to Code Smells Lesson 2558 — Immutability for Thread Safety
Modify its value: Lesson 594 — Increase/Decrease Key Operations
modular arithmetic: using the `%` operator:; Lesson 387 — Circular Queues Lesson 2406 — Mathematical Foundations: Modular Arithmetic
Modular exponentiation: `(base^exponent) mod n` raises to a power, then takes the remainder; Lesson 2406 — Mathematical Foundations: Modular Arithmetic Lesson 2409 — RSA Algorithm: Encryption and Decryption
modularity: you can upgrade one layer's implementation without breaking others, as long as the interface stays consistent.; Lesson 1440 — Encapsulation and Layer Communication Lesson 2123 — Encapsulation and Information Hiding
Modulo: General-purpose, works with any table size; Lesson 410 — Hashing Integers
Modulo (`%`): Returns the *remainder* after division; Lesson 154 — Arithmetic Operators
Modulo operation: The bridge that maps the large range down to valid indices; Lesson 407 — Hash Function Output Range and Table Size Lesson 408 — The Division Method
modulo operator: (`%`).; Lesson 379 — Circular Queue Concept Lesson 407 — Hash Function Output Range and Table Size
Monitor recursion depth: – Track how deep the recursion goes; Lesson 801 — Introsort: The Best of Both Worlds
Monitoring: for impossible travel (logins from distant locations within minutes); Lesson 2514 — Credential Stuffing and Breach Detection
Monitoring and dynamic rebalancing: detect hot partitions and split or migrate them; Lesson 2690 — Handling Data Skew and Hotspots
Monotonic Read Consistency: (successive reads never go backward in time) and **Read-Your-Writes** (seeing your own writes).; Lesson 2617 — Monotonic Write Consistency
Monotonic reads: Does a client ever see older data after seeing newer data?; Lesson 2623 — Measuring and Testing Consistency Lesson 2624 — Choosing the Right Consistency Model
Monotonicity condition: If `opt[i]` is the best `j` for state `i`, then:; Lesson 959 — Divide and Conquer Optimization
More compact: One node stores many occurrences; Lesson 528 — BST with Duplicate Keys
More control: You manage the stack directly; Lesson 373 — Depth-First Search with Explicit Stack Lesson 760 — Bottom-Up Mergesort
More hits: = faster program execution, better performance; Lesson 1138 — Cache Hit and Miss Definitions
More joins: A query needing data from five normalized tables performs multiple joins, which is computationally expensive; Lesson 1645 — Normal Form Trade-offs
More misses: = slower execution due to frequent main memory access (the "miss penalty"); Lesson 1138 — Cache Hit and Miss Definitions
More pipeline registers: Each boundary between stages needs storage, adding hardware overhead; Lesson 1156 — Deeper Pipelines: Benefits and Costs
More predictable: Response time is more uniform than FCFS or SSTF; Lesson 1425 — SCAN (Elevator) Algorithm
More secure than SMS: Not vulnerable to SIM-swapping attacks; Lesson 2522 — Push Notification-Based MFA
More uniform wait times: all requests wait roughly the same amount of time; Lesson 1426 — C-SCAN (Circular SCAN)
Most frequent class: Always predict the majority label; Lesson 2784 — Baseline Models and Evaluation
Motivation 1: Natural protection: You can set different permissions per segment (execute-only for code, read-write for stack).; Lesson 1378 — Segmentation Basics and Motivation
Motivation 2: Easy sharing: Two processes can share a code segment without sharing their data—just point both to the same segment.; Lesson 1378 — Segmentation Basics and Motivation
Motivation 3: Logical growth: The heap can grow independently from the stack, each in its own segment with room to expand.; Lesson 1378 — Segmentation Basics and Motivation
Move downward: Continue until all stubs are replaced with real implementations; Lesson 2238 — Top-Down Integration Testing
Move Method: and **Extract Class** refactorings to consolidate scattered logic.; Lesson 2337 — Shotgun Surgery Smell
Move one position forward: and compare the next pair; Lesson 741 — Bubble Sort: Algorithm
Movement is unrestricted: in continuous space (not confined to grid moves); Lesson 2757 — Euclidean Distance Heuristic
MSD: is more complex but potentially faster: it creates partitions and recurses into each bucket.; Lesson 793 — Radix Sort: LSD vs MSD
Much larger: (several MB, sometimes 16-32 MB); Lesson 1121 — Cache Levels: L1, L2, L3
Multi-commodity flow: extends the maximum flow problem to scenarios where *k* different commodities (each with its own source and sink) must share the same network edges.; Lesson 1055 — Multi-Commodity Flow Introduction
multi-cycle instructions: or **out-of-order execution**, `I1` might take longer (maybe a slow multiply) and finish *after* `I2`.; Lesson 1167 — Data Hazards: Write-After-Write (WAW)Lesson 1186 — Cycles Per Instruction (CPI)
Multi-datacenter replication: with tunable consistency; Lesson 1744 — Apache Cassandra: Architecture and Use Cases
Multi-Factor Authentication (MFA): requires evidence from *two or more* different factor categories.; Lesson 2516 — What Is Multi-Factor Authentication (MFA)?
Multi-line comments: (e.; Lesson 1945 — Handling Whitespace and Comments
Multi-step calculations: Breaking `totalPrice = basePrice * (1 - discountRate) * (1 + taxRate)` into `discountedPrice` then `finalPrice`; Lesson 2322 — Extract Variable: Explaining Complex Expressions
Multi-version concurrency control (MVCC): The database maintains multiple versions of data so transactions can see consistent snapshots; Lesson 1660 — Isolation: Concurrent Transaction Independence Lesson 1673 — Snapshot Isolation
multigraph: relaxes these restrictions: it allows *multiple edges* between the same pair of vertices, and some variants permit **self-loops** (edges from a vertex back to itself).; Lesson 660 — Simple Graphs and Multigraphs Lesson 686 — Simple Graphs and Multigraphs
Multigraphs: capture real-world complexity like transportation networks (multiple flights between cities), communication channels (several cables between nodes), or weighted alternatives (different cost paths between locations).; Lesson 686 — Simple Graphs and Multigraphs
Multilevel (Feedback) Queues: balance CPU-bound and I/O-bound processes well but are complex to configure.; Lesson 1261 — Comparing Scheduling Algorithm Performance
Multilevel Feedback Queue Scheduling: allows processes to **move between queues** based on how they actually behave.; Lesson 1260 — Multilevel Feedback Queue Scheduling
Multilevel Queue Scheduling: works the same way.; Lesson 1259 — Multilevel Queue Scheduling Lesson 1260 — Multilevel Feedback Queue Scheduling
multiple: k-th elements (e.; Lesson 822 — Naive Selection via Sorting Lesson 1686 — Clustered vs Non-Clustered B-Tree Indexes
Multiple agents: Typically two players (you and an opponent), though the concepts extend to more; Lesson 2764 — Adversarial Search Overview
Multiple base predictors: (e.; Lesson 1183 — Tournament and Hybrid Predictors
Multiple children: A node with k keys has k + 1 children; Lesson 556 — B-Tree Definition and Properties
Multiple columns: Group by genre, *then* by author within each genre; Lesson 1599 — Grouping by Multiple Columns
Multiple concerns: The class handles user input *and* database logic *and* business rules *and* formatting; Lesson 2331 — Large Class Smell
Multiple consumers: Another thread might grab the resource first after you wake; Lesson 1306 — The Wait-Signal Pattern
Multiple keys per node: Each internal node contains between ⌈m/2 ⌉ - 1 and m - 1 keys (except the root); Lesson 556 — B-Tree Definition and Properties
multiple levels: as you walk back up to the root.; Lesson 541 — AVL Deletion Overview Lesson 1509 — DNS Caching and Time-to-Live (TTL)Lesson 1740 — Physical Storage: SSTables and Log-Structured Merge Trees
Multiple outputs: A function can "return" multiple values by modifying several reference parameters; Lesson 203 — Pass-by-Reference Semantics
Multiple physical cores: (or processors) in the hardware; Lesson 2548 — Multi-Core Parallelism: True Simultaneity
Multiple readers: can access the data simultaneously (no mutual exclusion among readers); Lesson 1299 — Readers-Writers Problem with Semaphores
multiple recursive calls: in one execution.; Lesson 226 — Multiple Recursive Calls Lesson 289 — O(2ⁿ): Exponential Time Lesson 870 — Multiple Recursive Calls
Multiplexers (MUXes): solve this by acting like traffic directors or railroad switches.; Lesson 1079 — Register Transfer and Data Paths
Multiplexing: is the process of combining multiple data streams into one channel.; Lesson 1483 — TCP Port Numbers and Multiplexing Lesson 1488 — UDP Port Numbers and Multiplexing
Multiplication → Addition: `i * c` becomes repeated addition when `i` increments predictably; Lesson 2067 — Strength Reduction
Multiplication Method: takes a completely different approach: it multiplies your key `k` by a constant decimal number `A` (where `0 < A < 1`), then extracts the fractional part and scales it.; Lesson 409 — The Multiplication Method
Multiplication mod n: `(a × b) mod n` also wraps around; Lesson 2406 — Mathematical Foundations: Modular Arithmetic
Multiplication Rule: tells us how to find the probability that two events occur together.; Lesson 115 — Multiplication Rule
must: include two components:; Lesson 218 — Base Case and Recursive Case Lesson 721 — DAG Detection and Prerequisites Lesson 1061 — Overflow Detection in Integer Arithmetic Lesson 1135 — Cache Placement Example Calculations Lesson 1244 — Scheduling Decision Points Lesson 1306 — The Wait-Signal Pattern Lesson 1307 — Condition Variables with Mutexes Lesson 1312 — Condition Variable Mesa vs Hoare Semantics (+7 more)
Must be initialized: References can't exist without binding to something; Lesson 320 — References as Aliases
mutex: semaphores together to safely coordinate producers and consumers sharing a bounded buffer.; Lesson 1298 — Producer-Consumer Problem with Semaphores Lesson 1299 — Readers-Writers Problem with Semaphores Lesson 1303 — Semaphores vs Mutexes vs Condition Variables Lesson 1311 — Reader- Writer Problem with CVs Lesson 2581 — Concurrent Stack Implementations
Mutexes: are designed specifically for **mutual exclusion** — protecting critical sections.; Lesson 1303 — Semaphores vs Mutexes vs Condition Variables
Mutual authentication: Servers can also present certificates, allowing clients to verify server identity — exactly what happens in TLS/HTTPS connections you've already learned.; Lesson 2502 — Certificate-Based Authentication
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 Lesson 1277 — Bounded Waiting Property Lesson 1296 — Mutual Exclusion with Binary Semaphores Lesson 1301 — Resource Counting with Counting Semaphores Lesson 1303 — Semaphores vs Mutexes vs Condition Variables Lesson 1314 — What is Deadlock?Lesson 1319 — Deadlock Prevention: Breaking Mutual Exclusion Lesson 2561 — Synchronized Blocks and Methods
MX: (Mail Exchange) record specifies which mail servers handle email for a domain.; Lesson 1505 — DNS Record Types: CNAME and MX
MySQL: uses hash indexes internally for its MEMORY (HEAP) storage engine but not for InnoDB tables.; Lesson 1696 — Hash Indexes in Practice

N

n ≥ n₀: Lesson 293 — Formal Definition of Big-Theta Lesson 297 — Formal Definition of Big-Omega Lesson 298 — Proving Big-Omega Bounds
n elements: has a height of **floor(log₂ n)**.; Lesson 581 — Height of a Binary Heap Lesson 757 — Mergesort Space Complexity
N-Queens: Place one queen, then recursively solve N-1 Queens on the remaining rows; Lesson 866 — Problem Decomposition in Recursion
n(n-1)/2: edges (undirected); Lesson 666 — Complete, Bipartite, and Regular Graphs Lesson 742 — Bubble Sort: Analysis Lesson 745 — Selection Sort: Analysis
n₀: (a threshold input size); Lesson 293 — Formal Definition of Big-Theta Lesson 297 — Formal Definition of Big-Omega Lesson 298 — Proving Big-Omega Bounds
Naive approach: Zero preprocessing, but slow searches—good for one-time searches; Lesson 840 — String Searching Applications and Tradeoffs
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
Naive, Rabin-Karp, KMP: O(m) extra space—minimal memory footprint; Lesson 840 — String Searching Applications and Tradeoffs
Name: A label you choose (like `score` or `userName`); Lesson 138 — What is a Variable?Lesson 188 — Calling Functions Lesson 1552 — Tables, Rows, and Columns Lesson 1980 — AST Representation of Function Definitions
Name accurately: – Clear purpose leads to clear names; Lesson 2310 — Function Length and Single Responsibility
Name Mismatch: Visiting `https://example.; Lesson 2450 — Certificate Validation and Common Errors
Name variables descriptively: so their purpose is obvious at their point of use.; Lesson 216 — Best Practices for Variable Scope
Named pipes (FIFOs): Enable inter-process communication; Lesson 1389 — File Types and Classification
Namespace isolation: Different paths can have identically named files; Lesson 1414 — Tree-Structured Directories
Naming: Human-readable identifiers instead of raw disk addresses; Lesson 1386 — File Abstraction and Basic Operations
Naming conflicts: With all users sharing one namespace, "report.; Lesson 1412 — Single-Level Directory Structure
NaN: (Not-a-Number).; Lesson 1068 — Special Floating-Point Values: Infinity and NaN
NaN ≠ NaN: .; Lesson 1068 — Special Floating-Point Values: Infinity and NaN
NAND: and **NOR**.; Lesson 18 — NAND and NOR Gates
Narrower integers: = save resources but risk **overflow** if values exceed the range.; Lesson 1062 — Integer Width and Range Tradeoffs
NAT router looks up: the mapping and rewrites: Destination = `192.; Lesson 1466 — Network Address Translation (NAT)
NAT router rewrites it: Source = `203.; Lesson 1466 — Network Address Translation (NAT)
NAT translation table: mapping `192.; Lesson 1466 — Network Address Translation (NAT)
NATS: , and **Google Cloud Pub/Sub** each occupy specific niches—traditional enterprise messaging, ultra-low-latency scenarios, and GCP integration respectively.; Lesson 2716 — Popular Message Queue Systems
Natural completion: The thread function finishes and returns; Lesson 1238 — Thread Creation and Termination
Natural skew: In a name-based partition, more last names start with 'S' than 'X'; Lesson 2690 — Handling Data Skew and Hotspots
Natural subdivisions: Searching a sorted array?; Lesson 867 — Identifying Recursive Structure
Near red child: (opposite side from sibling): First rotate the sibling to convert it to case 1, then apply case 1's solution; Lesson 554 — Deletion Cases: Black Sibling with Red Children
Nearly sorted data: **Insertion Sort** runs in nearly O(n) time.; Lesson 799 — When to Use Which Sorting Algorithm
Need: Max - Allocation (what each process still requires); Lesson 1324 — The Banker's Algorithm
Need minimal latency: (online gaming—outdated position data is useless anyway); Lesson 1486 — UDP Protocol Overview and Design Philosophy
Negate complex conditions: correctly; Lesson 41 — De Morgan's Laws
Negated: ∃x ¬(x > 0) or ∃x (x ≤ 0); Lesson 49 — Negating Quantified Statements
negation: .; Lesson 14 — The NOT Gate (Inverter)Lesson 2021 — Semantics of Boolean Expressions
negative: , it means there's a way to start at vertex `i`, follow some edges, return to `i`, and end up with a *negative total cost*.; Lesson 996 — Detecting Negative Cycles Lesson 1061 — Overflow Detection in Integer Arithmetic
Negative Cycle Detection: Lesson 987 — Bellman-Ford vs Dijkstra Comparison
Negative Cycle Detection (Optional): Lesson 984 — Bellman-Ford Implementation
Negative demand: (`d(v) < 0`): the node *supplies* that much flow (it's a source of resources); Lesson 1054 — Circulation with Demands
negative edge weights: exist.; Lesson 981 — Bellman-Ford Algorithm Structure Lesson 986 — Bellman-Ford Time Complexity Lesson 989 — Bellman-Ford Applications Lesson 999 — Floyd-Warshall vs Repeated Dijkstra
Negative flag (N): Set if the result is negative (in two's complement); Lesson 1077 — Accumulator and Status Registers
Negative infinity: (`-∞`): Results from operations like `-1.; Lesson 1068 — Special Floating-Point Values: Infinity and NaN
Negative Weight Edges: Lesson 987 — Bellman-Ford vs Dijkstra Comparison
Nested: Queries targeting embedded objects; Lesson 1723 — Indexing Document Fields
Nested Data: Instead of splitting information across multiple tables with foreign keys, you can embed related data directly:; Lesson 1710 — Document Store Fundamentals
Nested document rules: Check structures within embedded documents; Lesson 1725 — Schema Validation and Flexibility
Nested HTML/XML tags: with proper matching; Lesson 1777 — Limitations of Regular Expressions
nested loop: is simply a loop placed inside the body of another loop.; Lesson 181 — Nested Loops Lesson 244 — Iterating Through 2D Arrays Lesson 273 — Input Size as a Variable
Nested Loop Join: For each row in one table, scan matching rows in another; Lesson 1698 — Query Execution Plans and Operators
Nested or self-similar data: Trees are recursively structured: each subtree is itself a tree.; Lesson 867 — Identifying Recursive Structure
Nested structures: `(open(close)*)*` allows arbitrary nesting; Lesson 1770 — Kleene Star and Repetition
Network: `192.; Lesson 1463 — Subnet Masks and Network/Host Portions
Network Access Layer: (or Link Layer); Lesson 1438 — The TCP/IP Model
Network Address Translation: sits at your gateway router (the boundary between your private network and the Internet) and translates addresses in both directions:; Lesson 1466 — Network Address Translation (NAT)
Network Address Translation (NAT): at the router to communicate with the internet, translating their private address to a public one.; Lesson 1465 — Private and Public IP Address Ranges
Network broadcasting: Efficient message propagation; Lesson 694 — BFS Overview and Applications
Network Communication: Once two parties establish a shared key (solving the key distribution problem you learned about), they use symmetric encryption for the actual data transfer.; Lesson 2404 — Symmetric Crypto in Practice: Performance and Use Cases
Network Infrastructure: When building telecommunications, electrical grids, or water distribution systems, you want to connect all locations using the minimum total cable/pipe length.; Lesson 1021 — MST Applications and Variations
Network latency: Data must be fetched from multiple nodes across the network; Lesson 2692 — Cross-Shard Queries and Joins
Network Layer: – Routes data packets across networks using logical addresses; Lesson 1432 — The OSI Model: Seven-Layer Overview Lesson 1435 — OSI Layer 3: Network Layer Lesson 1440 — Encapsulation and Layer Communication
network partition: occurs when nodes in a distributed system lose the ability to communicate with each other, typically due to network failures, router crashes, or firewall misconfigurations.; Lesson 2589 — Network Partitions and Split-Brain Lesson 2591 — Partial Failures and Fault Detection Lesson 2604 — The CAP Trade-off: Pick Two Lesson 2694 — Partition Tolerance and Fault Handling
network partitions: and **lack of global clock** from previous lessons?; Lesson 2601 — Consistency in Distributed Systems Lesson 2655 — Leader Election Basics Lesson 2717 — What Are Distributed Transactions?
Network performance: Different network cards, connection speeds; Lesson 2596 — Heterogeneity of Hardware and Software
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 Lesson 1464 — Subnetting Fundamentals
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: Computers in one set, routers in the other; Lesson 689 — Bipartite Graphs Lesson 965 — Introduction to Single-Source Shortest Path Problems Lesson 1011 — A* Applications and Variants
Network topology: Physical cable layouts that avoid crossings; Lesson 692 — Planar Graphs
Network unreachable: Routing problems prevent connection; Lesson 1550 — Error Handling and Socket Shutdown
NetworkTopologyStrategy: Distributes across data centers for disaster recovery; Lesson 1743 — Consistency and Replication in Column Stores
never: get CPU time if high-priority processes keep arriving.; Lesson 1256 — Priority Scheduling Fundamentals Lesson 1313 — Common Condition Variable Pitfalls Lesson 1424 — Shortest Seek Time First (SSTF)Lesson 2468 — SameSite Cookie Attribute Lesson 2616 — Monotonic Read Consistency
Never assume: the default encoding—always specify it; Lesson 30 — Common Encoding Issues
Never deserialize untrusted data: from users or external sources; Lesson 2490 — Insecure Deserialization
Never reorder equal elements: Comparison-based stable sorts (Mergesort, Insertion Sort) naturally preserve relative order when keys match; Lesson 803 — Stability in Production Sorting
Never share passwords: through insecure channels; Lesson 2515 — Password Managers and Best Practices
new: stack frame with its **own** local variables, even though it's the same function name.; Lesson 369 — Function Call Stack and Recursion Lesson 1218 — Process States: New and Ready Lesson 1221 — Process State Transitions
New → Ready: happens automatically once the OS finishes setup.; Lesson 1218 — Process States: New and Ready Lesson 1221 — Process State Transitions
New column: carry becomes 1; Lesson 5 — Binary Addition
New Command: When a fresh command executes, clear the redo stack (you can't redo after taking a new path); Lesson 2292 — Command Pattern for Undo/Redo
Next level: Merge two groups of n/2 → 2 × O(n/2) = O(n) work; Lesson 756 — Mergesort Time Complexity Analysis
Next pointer: – the memory address of the next node in the chain; Lesson 325 — Node Structure Lesson 339 — Doubly Linked List Structure and Node Design
Next recognizable token: Discard characters until the automaton can successfully transition again; Lesson 1947 — Error Detection and Recovery in Lexing
NFA: (Nondeterministic Finite Automaton) is different: it can have multiple transitions from the same state on the same symbol, and it can even take epsilon transitions without reading input.; Lesson 1796 — NFA Acceptance: Existence of Accepting Path
NFA → DFA: Use the Subset Construction algorithm to convert any NFA into an equivalent DFA.; Lesson 1801 — NFA-DFA Equivalence Theorem
NFA transition function: δ: Q × (Σ ∪ {ε}) → P(Q); Lesson 1793 — NFA Definition and Components
NFAs excel at design: When you're solving a problem like "recognize strings containing '101' somewhere inside," an NFA lets you write what you're thinking directly: "Guess where '101' starts, then verify it.; Lesson 1802 — Why Use NFAs: Design vs Implementation
No: The element `z` in the codomain is never reached by any input.; Lesson 78 — Function Properties: Surjective (Onto)Lesson 443 — Caching and Memoization Lesson 563 — B-Tree Deletion: Leaf Node Cases Lesson 1624 — Full vs Partial Functional Dependencies
No backtracking needed: the choice is irrevocable; Lesson 880 — Optimal Substructure in Greedy Problems
No complete bug detector: We cannot build a tool that catches all possible infinite loops across all programs.; Lesson 1883 — Implications for Program Verification
No complete static analyzer: Tools that check program properties (security vulnerabilities, memory leaks) must either be incomplete or report false positives; Lesson 1879 — Why the Halting Problem Matters
No complex queries: You can't search by value content or filter across multiple keys.; Lesson 1728 — Key-Value Store Data Model
No conflict misses: blocks never fight for the same spot; Lesson 1130 — Fully Associative Caches
No Congestion Control: Lesson 1493 — UDP Performance Characteristics
No Cross-Shard Operations (Ideally): Queries that need data from multiple shards become complex and slow, requiring coordination across independent systems.; Lesson 2684 — Sharding Fundamentals
No deadlock: ensures that if multiple processes are trying to enter their critical sections simultaneously, at least one will eventually succeed.; Lesson 1276 — Progress and No Deadlock
No duplicate work: Each node is expanded at most once; Lesson 1004 — Consistent (Monotonic) Heuristics
No efficient traversal: There's no way to "walk" from one value to the next in sorted order; Lesson 1693 — Range Query Limitations
No encryption: SMS travels in plaintext through cellular networks; Lesson 2521 — SMS and Email-Based MFA
No external fragmentation: Each segment is paged, so memory is allocated in fixed-size frames; Lesson 1384 — Segmentation with Paging (Hybrid Approach)Lesson 1401 — File Allocation Methods: Indexed
No extra data structures: Everything lives in the hash table array; Lesson 422 — Open Addressing: Concept
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 global view: Nodes can't see everyone's status simultaneously; Lesson 2655 — Leader Election Basics
No head-of-line blocking: Multiple streams are truly independent at the transport layer; Lesson 1527 — HTTP/3 and QUIC
No information disclosure: Never reveal whether an email exists in your system ("If that email exists, we sent a reset link"); Lesson 2513 — Password Reset Security
No information loss: Constraints are applied *only* when necessary; Lesson 2012 — Principal Types and Most General Unifiers
No input is special: There's no "adversarial" arrangement that guarantees worst-case behavior; Lesson 771 — Randomized Quicksort: Avoiding Worst Case
No isolation: Users can't have private workspaces; everyone sees everyone's files; Lesson 1412 — Single-Level Directory Structure
No match: → **Cache miss** — different data occupies this line; Lesson 1128 — Direct-Mapped Cache Lookup
No maximum length: (within reason, like 128 characters); Lesson 2512 — Password Policies and Requirements
No memorization burden: You only remember one strong master password; Lesson 2515 — Password Managers and Best Practices
No need to reconsider: You never need to undo or revisit a greedy choice.; Lesson 879 — The Greedy Choice Property
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 organization: You can't group related files (like all photos together, or all project files); Lesson 1412 — Single-Level Directory Structure
No passwords transmitted: There's nothing to intercept or steal in transit.; Lesson 2502 — Certificate-Based Authentication
No perfect debugger: You cannot build a tool that automatically detects all infinite loops in arbitrary code; Lesson 1879 — Why the Halting Problem Matters
No pointer syntax: Inside `increment`, you use `num` like a normal variable; Lesson 321 — Reference Parameters in Functions
No predefined structure required: You don't declare columns before inserting data; Lesson 1718 — Document Database Model
No Preemption: Resources cannot be forcibly taken away; they must be voluntarily released by the holding process; Lesson 1314 — What is Deadlock?Lesson 1321 — Deadlock Prevention: Allowing Preemption
No reader parallelism: Multiple threads can't even read simultaneously, despite reads not conflicting; Lesson 2576 — Why Thread-Safe Data Structures?
No recursion: purely iterative loops; Lesson 917 — Tabulation (Bottom-Up DP)
No recursion overhead: Avoids function call stack depth; Lesson 760 — Bottom-Up Mergesort
No reduction found: Continue searching for an efficient algorithm—there may be hope!; Lesson 1937 — Practical Applications of Reductions
No relationships: There are no foreign keys or joins.; Lesson 1728 — Key-Value Store Data Model
No repeating groups: – No columns should repeat (like Phone1, Phone2, Phone3); Lesson 1632 — First Normal Form (1NF) Definition
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
No side effects: Doesn't modify external state or interact with the outside world; Lesson 2132 — Pure Functions and Immutability
No stack overhead: no risk of stack overflow; Lesson 917 — Tabulation (Bottom-Up DP)
No stale reads: You never read outdated data after a successful write; Lesson 2601 — Consistency in Distributed Systems
No starvation: Unlike SSTF, every request gets serviced in bounded time; Lesson 1425 — SCAN (Elevator) Algorithm
No synchronization overhead: Since each thread owns its copy, no locks needed; Lesson 1239 — Thread-Local Storage
No type safety: `3` could mean "approved status" in one place and "retry count" in another; Lesson 2323 — Replace Magic Numbers with Named Constants
No universal optimizer: Compilers cannot always determine the optimal version of your code; Lesson 1879 — Why the Halting Problem Matters
No wasted space: Empty slots at the front become available again.; Lesson 379 — Circular Queue Concept
No, here's why: Lesson 970 — Correctness of Dijkstra's Algorithm
node: is a self-contained package that holds two essential pieces:; Lesson 325 — Node Structure Lesson 493 — What is a Binary Search Tree?Lesson 1431 — Introduction to Computer Networks Lesson 1677 — B-Tree Structure and Properties Lesson 1748 — Nodes and Properties Lesson 1754 — Social Network and Recommendation Queries
Node < range minimum: Only explore the right subtree; Lesson 514 — Range Query in BST
Node > range maximum: Only explore the left subtree; Lesson 514 — Range Query in BST
Node in range: Add it to results, then explore both left and right subtrees; Lesson 514 — Range Query in BST
Node not found: Traverse completes without finding the target; Lesson 334 — Deleting a Specific Node Lesson 571 — Splay Tree Search
Node-based: Essential for sparse, unbalanced, or dynamically-shaped trees; Lesson 465 — Space Efficiency Comparison Lesson 467 — Converting Between Representations
Node-based representation: (using pointers/references) shines in exactly these scenarios.; Lesson 463 — Advantages of Node-Based Representation
nodes: ) are scattered in memory, each pointing to the next one through pointers.; Lesson 324 — Introduction to Linked Lists Lesson 497 — BST Node Structure Lesson 979 — Practical Applications of Dijkstra's Algorithm Lesson 1713 — Graph Database Fundamentals Lesson 1732 — Consistent Hashing Lesson 1746 — Graph Database Model and Use Cases Lesson 1750 — Cypher Query Language Basics Lesson 1797 — Computation Trees in NFAs (+1 more)
Noise reduction: Removing redundant dimensions can filter out noise; Lesson 2790 — Dimensionality Reduction Concepts
Noise tolerance: How many errors can your training process handle?; Lesson 2794 — Label Quality and Acquisition
Nominal equivalence: says two types are the same only if they have the same *name* or were declared to be related explicitly.; Lesson 1991 — Type Equivalence: Structural vs Nominal
Nominal typing: provides stronger guarantees and prevents accidental mixing of semantically different types (like mixing `Money` and `Weight` even if both are numbers), common in Java and C++; Lesson 1991 — Type Equivalence: Structural vs Nominal
Non-accepting states: (all in another class); Lesson 1810 — Minimizing DFAs Using Equivalence Classes
Non-clustered index: A card catalog organized by author name.; Lesson 1686 — Clustered vs Non-Clustered B-Tree Indexes
Non-Clustered Index (Secondary Index): The B-Tree structure is separate from the table data.; Lesson 1686 — Clustered vs Non-Clustered B-Tree Indexes
Non-clustered indexes: require an extra lookup step: first navigate the B-Tree, then follow the pointer to fetch the actual row data.; Lesson 1686 — Clustered vs Non-Clustered B-Tree Indexes Lesson 1687 — B-Tree Index Performance Characteristics
Non-cryptographic (for hash tables): Lesson 415 — Cryptographic vs Non-Cryptographic Hash Functions
Non-cryptographic hash functions: (what we use for hash tables) prioritize **speed**.; Lesson 415 — Cryptographic vs Non-Cryptographic Hash Functions
Non-destructive inspection: You want to examine the stack's state without altering it during debugging or algorithm execution.; Lesson 359 — Peek (or Top) Operation
non-determinism: .; Lesson 1272 — Interleaving and Non-Determinism Lesson 2599 — Testing and Debugging Difficulties
Non-deterministic: They don't happen every time; Lesson 2555 — Race Conditions
Non-generating: A nonterminal that cannot derive any string of terminals (no matter how many steps you take, you never reach a complete word); Lesson 1825 — Removing Useless Symbols
Non-linear decision boundaries: that would be difficult to capture with linear models; Lesson 2872 — KNN in Practice: Applications and Limitations
Non-linear transformation: Apply `σ(z) = 1 / (1 + e ᶻ)` to squeeze the output between 0 and 1; Lesson 2828 — Logistic Regression Model and Hypothesis
Non-null: The primary key cannot be empty (NULL) — every row must have a value; Lesson 1555 — Primary Keys
Non-preemptive: A student sits down and uses the computer until they're done with their task or voluntarily step away.; Lesson 1243 — Preemptive vs Non-Preemptive Scheduling Lesson 1244 — Scheduling Decision Points Lesson 1253 — Shortest Job First (SJF) Scheduling Lesson 1256 — Priority Scheduling Fundamentals Lesson 1257 — Priority Scheduling: Preemptive vs Non-Preemptive
Non-preemptive priority scheduling: waits politely.; Lesson 1257 — Priority Scheduling: Preemptive vs Non-Preemptive
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-regular: and require more powerful computational models.; Lesson 1791 — DFA Limitations and Non-Regular Languages Lesson 1807 — Using the Pumping Lemma to Prove Non-Regularity
Non-repeatable reads: Transaction A reads the same row twice but gets different values because Transaction B modified it in between; Lesson 1660 — Isolation: Concurrent Transaction Independence
Non-repudiation: You cannot deny signing it later (your private key is uniquely yours); Lesson 2432 — What are Digital Signatures?Lesson 2434 — Digital Signature Properties
Non-Return-to-Zero (NRZ): `1` = high voltage, `0` = low voltage.; Lesson 1443 — Signal Encoding and Modulation
Non-saturating push: sends all the excess flow from the source node (less than edge capacity); Lesson 1044 — Push-Relabel Operations
Non-tail-recursive version: Lesson 227 — Tail Recursion
Non-trivial: if it's true for *some* programs but not others; Lesson 1884 — Rice's Theorem Introduction
Non-trivial dependencies: provide real design information:; Lesson 1622 — Functional Dependency Notation and Terminology
Non-volatile storage: includes:; Lesson 1112 — Volatile vs Non-Volatile Memory
Non-zero values: indicate some kind of error or abnormal condition; Lesson 1225 — Process Termination: exit() and Return Codes
Nondeterministic Finite Automaton (NFA): is a computational model similar to a DFA, but with a crucial superpower: it can have *multiple possible next states* for a given input symbol, or even transition without consuming any input at all.; Lesson 1793 — NFA Definition and Components
Nondeterministic PDA (NPDA): , from the same configuration, there may be *multiple* valid transitions.; Lesson 1832 — Deterministic vs Nondeterministic PDAs
Nondeterministic TM → Verifier: The sequence of nondeterministic choices forms the certificate; the accepting computation path is the verification process.; Lesson 1903 — Alternative NP Definition: Nondeterministic TMs
Nonrepeatable Reads: If you read the same row twice, another transaction might have modified and committed it between your reads, giving you different values.; Lesson 1666 — Read Uncommitted Isolation Level Lesson 1670 — Repeatable Read Isolation Level Lesson 1672 — Serializable Isolation Level
NOR: .; Lesson 18 — NAND and NOR Gates
Normal Equation: .; Lesson 2823 — Normal Equation: Closed-Form Solution
Normal feature development: Test-during often provides the best balance.; Lesson 2223 — When to Write Tests
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
Normalize: by the total number of trees; Lesson 2856 — Random Forest Feature Importance
Normalize and validate paths: before use; Lesson 2489 — Path Traversal and File Inclusion
NOT: Flips the value (TRUE becomes FALSE, FALSE becomes TRUE); Lesson 13 — Boolean Values and Truth Tables Lesson 16 — The OR Gate Lesson 56 — Logical Equivalences with Quantifiers Lesson 63 — Set Difference and Complement Lesson 77 — Function Properties: Injective (One-to-One)Lesson 158 — Logical Operators Lesson 658 — Directed vs Undirected Graphs Lesson 1097 — Logical and Bitwise Instructions (+12 more)
NOT (`~`): Flips every bit (0 becomes 1, 1 becomes 0).; Lesson 163 — Bitwise Operators
Not Always Fastest: Lesson 761 — Mergesort Applications and Tradeoffs
Not cacheable: Responses typically aren't cached; Lesson 1516 — HTTP Methods: GET and POST
Not Commutative: Unlike addition, order matters!; Lesson 1758 — String Operations: Concatenation Lesson 1769 — Union and Concatenation Properties
Not equal to: `!; Lesson 157 — Comparison Operators
Not idempotent: Submitting the same POST twice might create two orders or two accounts; Lesson 1516 — HTTP Methods: GET and POST
Not logged: The operation never started; nothing to fix; Lesson 1407 — Write-Ahead Logging and Recovery
Not optimal: returns the first solution found within the limit, which may not be the shallowest; Lesson 2744 — Depth-Limited Search Lesson 2751 — Greedy Best-First Search
Not propositions: Lesson 31 — Propositions and Truth Values
not stable: because heap operations (building the heap and repeated swaps during extraction) reorder equal elements based on tree structure rather than preserving their original relative positions.; Lesson 783 — Heapsort Stability Lesson 785 — Heapsort vs Mergesort Comparison Lesson 808 — Standard Library Sort Functions
Not tail-recursive: (work happens after the call):; Lesson 872 — Tail Recursion Optimization
not taken: forward branches are often for error handling or special cases; Lesson 1176 — Static Branch Prediction Lesson 1178 — One-Bit Branch Predictor
Not used: The shortest path from `i` to `j` using vertices `{1, 2, .; Lesson 992 — Floyd-Warshall Dynamic Programming Formulation
nothing: can determine other attributes unless it uniquely identifies the whole row.; Lesson 1640 — Boyce-Codd Normal Form (BCNF) Definition Lesson 2179 — Unstaging Files
Notify your team: everyone will need to re-clone; Lesson 2213 — Rewriting History Safely
NP: if there exists a polynomial-time *verifier* algorithm V such that:; Lesson 1891 — The Class NP (Nondeterministic Polynomial)Lesson 1894 — The Class EXP (Exponential Time)Lesson 1905 — P Subset of NP Lesson 1926 — Partition Problem
NP vs. PSPACE: Lesson 1897 — Complexity Class Hierarchy
NP-complete: (we'll explore this soon).; Lesson 1915 — The Satisfiability Problem (SAT)Lesson 1916 — Cook-Levin Theorem Lesson 1918 — The Clique Problem Lesson 1919 — The Independent Set Problem Lesson 1920 — The Vertex Cover Problem Lesson 1921 — The Hamiltonian Cycle Problem Lesson 1922 — The Traveling Salesman Problem (TSP)Lesson 1923 — Subset Sum Problem (+3 more)
NP-hard: because every other NP problem can be reduced to it in polynomial time; Lesson 1926 — Partition Problem
NPDA: You have multiple possible routes at each intersection.; Lesson 1832 — Deterministic vs Nondeterministic PDAs
NS records delegate responsibility: for a domain to specific nameservers.; Lesson 1506 — DNS Record Types: NS, SOA, and TXT
NSPACE(f(n)) DSPACE(f(n)²): , where NSPACE is nondeterministic space and DSPACE is deterministic space.; Lesson 1896 — Savitch's Theorem
NTP: and **PTP** provide physical time, but they can't guarantee causal ordering when clock skew exists.; Lesson 2636 — Hybrid Logical Clocks
Null counts: How many rows contain NULL in each column; Lesson 1700 — Cardinality Estimation Lesson 1704 — Statistics and Histograms
NULL never equals NULL: not even to itself.; Lesson 1589 — Handling NULLs in Joins
Null pointer dereferencing: Found when accessing that memory location; Lesson 2032 — Error Detection: Compile-Time vs Runtime
Null/default values: Decide how to handle uninitialized array slots after resizing—though only indices `0` to `size-1` matter.; Lesson 600 — Practical Heap Implementation Considerations
Null/empty inputs: `null` references, empty strings, empty collections; Lesson 2260 — Handling Edge Cases and Boundaries
NUMA (Non-Uniform Memory Access): system, multiple processors each have their own local memory.; Lesson 1268 — 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
number: , push it onto the stack; Lesson 367 — Evaluating Postfix Expressions Lesson 1939 — Tokens, Lexemes, and Patterns
Number all resources: (locks, files, devices) from 1 to N; Lesson 1322 — Deadlock Prevention: Breaking Circular Wait
Number of bedrooms: ranges from 1 to 5 (small numbers); Lesson 2868 — Feature Scaling in KNN
Number of estimators: (`n_estimators`): How many base models to train; Lesson 2862 — Ensemble Selection and Hyperparameters
Numbers: (like 5, 1000, or 3.; Lesson 1 — What is Binary and Why It Matters
Numbers with ≤: Every pair of real numbers can be compared (5 ≤ 7, 3.; Lesson 75 — Total Orders and Chains
Numeric literals: that aren't self-evident (`86400` is seconds-per-day, not obvious); Lesson 2323 — Replace Magic Numbers with Named Constants
Numerical stability: Extreme value differences can cause floating-point overflow or underflow, especially in deep models with many layers of computation.; Lesson 2824 — Feature Scaling and Normalization
Numerical transformations: Scaling values to similar ranges, taking logarithms to handle skewed distributions, or creating polynomial features to capture non-linear relationships.; Lesson 2783 — Feature Engineering Basics

O

O(...): when describing the maximum memory you might need; Lesson 304 — Space Complexity Notation
O(1): means constant time—runtime doesn't grow with input size; Lesson 280 — What is Big-O Notation?Lesson 283 — O(1): Constant Time Lesson 291 — Comparing Growth Rates Lesson 302 — What is Space Complexity?Lesson 304 — Space Complexity Notation Lesson 305 — Constant Space: O(1)Lesson 328 — Inserting at the Head Lesson 330 — Maintaining a Tail Pointer (+12 more)
O(1) auxiliary space: .; Lesson 309 — In-Place Algorithms
O(1) average-case lookup: for exact-match queries.; Lesson 445 — Database Indexing with Hash Tables Lesson 1689 — Hash Index Structure
O(1) average-case lookup time: , meaning they can find a record in roughly constant time regardless of how many records exist in the table.; Lesson 1692 — O(1) Lookup with Hash Indexes
O(1) average-case time: for:; Lesson 442 — Dictionary and Set Implementations
O(1) constant time: performance.; Lesson 361 — Size Operation
O(1) extra space: .; Lesson 258 — Kadane's Algorithm: Maximum Subarray Sum Lesson 786 — Practical Applications of Heapsort
O(1) on average: .; Lesson 433 — Average-Case Time Complexity Analysis
O(1) space complexity: it uses only a constant amount of extra memory (just the two index variables and one temporary variable for swapping).; Lesson 253 — Array Reversal In-Place
O(1) time: Lesson 398 — Linked List Deque Implementation
O(1) total: Lesson 1692 — O(1) Lookup with Hash Indexes
O(2ⁿ): Exponential: Each additional input doubles the work; Lesson 291 — Comparing Growth Rates
O(b^(d/2)): nodes.; Lesson 2747 — Bidirectional Search
O(b^d): where *d* is the solution depth.; Lesson 2742 — Depth-First Search (DFS)Lesson 2747 — Bidirectional Search
O(b×m): memory versus BFS's **O(b^d)** where *d* is the solution depth.; Lesson 2742 — Depth-First Search (DFS)
O(d(n+k)): where:; Lesson 794 — Radix Sort: Implementation and Analysis
O(E log E): or equivalently O(E log V), since E ≤ V²; Lesson 1016 — Kruskal's Algorithm: Implementation and Analysis
O(E log V): total time, much faster for sparse graphs.; Lesson 1018 — Prim's Algorithm: Priority Queue Implementation
O(E): total across all vertices; Lesson 698 — BFS Time and Space Complexity
O(E² log U): time—much better when *U* is reasonable.; Lesson 1040 — Capacity Scaling
O(h): where h is tree height.; Lesson 518 — Lowest Common Ancestor in BST
O(k): extra space for the counting array.; Lesson 791 — Counting Sort: Space-Time Tradeoffs
O(k³ log n): .; Lesson 961 — Matrix Exponentiation for Linear Recurrences
O(log k): time.; Lesson 616 — Merging K Sorted Lists
O(log n): time when it repeatedly cuts the problem size in half (or into some constant fraction) with each step.; Lesson 284 — O(log n): Logarithmic Time Lesson 291 — Comparing Growth Rates Lesson 488 — Balanced vs Unbalanced Trees Lesson 495 — BST vs General Binary Trees Lesson 521 — BST Height and Balance Lesson 524 — Average-Case BST Performance Lesson 544 — AVL Operation Complexity Lesson 567 — B- Tree Performance and Applications (+11 more)
O(log n) amortized: .; Lesson 574 — Amortized Analysis of Splay Trees
O(log n) height: , you examine at most a constant number of nodes per level, giving logarithmic query time.; Lesson 648 — Segment Tree Time and Space Complexity
O(log n) rotations: for deletion in the absolute worst case—but typically far fewer.; Lesson 544 — AVL Operation Complexity
O(log n) space complexity: .; Lesson 308 — Recursion and Call Stack Space
O(log n) time: .; Lesson 543 — AVL Tree Height Analysis Lesson 581 — Height of a Binary Heap Lesson 592 — Extract Time Complexity Lesson 610 — Heap as Priority Queue Implementation
O(log n) time complexity: the time grows *logarithmically* with the array size, not linearly.; Lesson 251 — Binary Search: Efficient Searching in Sorted Arrays
O(m log n): .; Lesson 574 — Amortized Analysis of Splay Trees
O(m): time where `m` is the length of the word (one operation per character).; Lesson 621 — Trie Insertion: Adding Words Lesson 622 — Trie Search: Exact Match Queries Lesson 626 — Time Complexity of Trie Operations
O(n + k): time, where **n** is the number of elements and **k** is the range of values.; Lesson 788 — Counting Sort: Basic Concept Lesson 791 — Counting Sort: Space-Time Tradeoffs Lesson 797 — Bucket Sort: When It Works Best
O(n + m): time — much better than repeatedly inserting!; Lesson 598 — Merge Two Heaps Lesson 835 — KMP: Pattern Matching Algorithm
O(n + m) time: , where n and m are the lengths of the two arrays.; Lesson 256 — Merging Two Sorted Arrays
O(n × m): Lesson 311 — Analyzing Multi-Dimensional Space
O(n log n): , it means for input size *n*, the algorithm performs roughly *n × log n* operations.; Lesson 286 — O(n log n): Linearithmic Time Lesson 291 — Comparing Growth Rates Lesson 605 — Heapsort Time Complexity Analysis Lesson 768 — Best-Case Analysis: Balanced Partitions Lesson 781 — Heapsort Time Complexity Analysis Lesson 788 — Counting Sort: Basic Concept Lesson 821 — The Selection Problem Definition Lesson 822 — Naive Selection via Sorting (+1 more)
O(n!): Factorial: Catastrophically slow, explodes instantly; Lesson 291 — Comparing Growth Rates
O(n!) complexity: when its number of operations grows as fast as the factorial of the input size.; Lesson 290 — O(n!): Factorial Time
O(n): complexity, meaning in the worst case, you'll check every element.; Lesson 250 — Linear Search: Sequential Element Finding Lesson 280 — What is Big-O Notation?Lesson 281 — Ignoring Constants in Big-O Lesson 291 — Comparing Growth Rates Lesson 302 — What is Space Complexity?Lesson 304 — Space Complexity Notation Lesson 310 — Space Complexity of Common Data Structures Lesson 330 — Maintaining a Tail Pointer (+22 more)
O(n) best-case: when data is already sorted; Lesson 802 — Timsort: Python's Default Sorting Algorithm
O(n) linear time: but doesn't require extra memory for a counter.; Lesson 361 — Size Operation Lesson 635 — Suffix Tree Construction Overview
O(n) linear time complexity: .; Lesson 335 — Searching in a Linked List
O(n) space: just enough room for the elements themselves.; Lesson 310 — Space Complexity of Common Data Structures Lesson 926 — Longest Increasing Subsequence (LIS)
O(n) space complexity: when the amount of extra memory it needs grows linearly with the input size.; Lesson 306 — Linear Space: O(n)Lesson 308 — Recursion and Call Stack Space
O(n) time: using just **O(1) extra space**.; Lesson 258 — Kadane's Algorithm: Maximum Subarray Sum Lesson 285 — O(n): Linear Time Lesson 329 — Inserting at the Tail Lesson 597 — Build Heap Time Complexity: O(n) Proof Lesson 602 — Building a Max Heap for Sorting Lesson 787 — Breaking the O(n log n) Barrier Lesson 824 — QuickSelect Analysis and Performance
O(n) time complexity: Lesson 252 — Finding Maximum and Minimum Elements
O(n/m) average-case time: on random text, where `n` is text length and `m` is pattern length.; Lesson 838 — Boyer-Moore: Combined Algorithm
O(n^2.807): instead of O(n³)—a genuine improvement for large matrices!; Lesson 849 — Strassen's Matrix Multiplication
O(n²): means quadratic time—runtime grows with the square of input size; Lesson 280 — What is Big-O Notation?Lesson 291 — Comparing Growth Rates Lesson 302 — What is Space Complexity?Lesson 311 — Analyzing Multi-Dimensional Space Lesson 670 — Adjacency Matrix: Operations and Complexity Lesson 742 — Bubble Sort: Analysis Lesson 745 — Selection Sort: Analysis
O(n²) performance: .; Lesson 824 — QuickSelect Analysis and Performance
O(n²) space: , regardless of how many edges actually exist.; Lesson 669 — Adjacency Matrix: Structure and Memory
O(n²) time complexity: and **O(n) space** for the dp array.; Lesson 926 — Longest Increasing Subsequence (LIS)
O(n³): cubic time complexity.; Lesson 288 — O(n³) and Higher Polynomial Time Lesson 291 — Comparing Growth Rates
O(n³|G|): time complexity, where n is string length and |G| is grammar size.; Lesson 1845 — CYK Parsing Algorithm
O(V + E): space complexity:; Lesson 675 — Adjacency List: Memory Efficiency Lesson 696 — BFS with Adjacency List Lesson 698 — BFS Time and Space Complexity Lesson 706 — 0-1 BFS Lesson 717 — DFS Time Complexity Analysis Lesson 951 — DP on DAGs: Counting Paths
O(V): Lesson 698 — BFS Time and Space Complexity
O(V) auxiliary space: for three main structures:; Lesson 698 — BFS Time and Space Complexity
O(V²): for adjacency matrices.; Lesson 717 — DFS Time Complexity Analysis Lesson 972 — Dijkstra's with Array-Based Priority Queue Lesson 994 — Floyd-Warshall Time and Space Complexity
O(V²E): total complexity—much better than basic Ford-Fulkerson.; Lesson 1042 — Dinic's Algorithm Implementation
O(V³): .; Lesson 994 — Floyd-Warshall Time and Space Complexity
O(VE): Lesson 986 — Bellman-Ford Time Complexity Lesson 1039 — Edmonds-Karp Algorithm
object: is an actual house built from that blueprint.; Lesson 2122 — Classes and Objects Lesson 2530 — Mandatory Access Control (MAC)
Object communication: How should objects talk to each other without tight coupling?; Lesson 2286 — Introduction to Behavioral Patterns
Object-Relational Mapper: is a library that translates between your programming language's objects and database tables.; Lesson 2481 — ORM and SQL Injection Protection
Observer: Defines an update interface that subjects use for notification; Lesson 2289 — Observer Pattern Fundamentals
Observer Pattern: solves this by establishing a one-to-many dependency between objects.; Lesson 2289 — Observer Pattern Fundamentals
Observer pattern on steroids: Multiple dependents react to one source; Lesson 2153 — Reactive Programming Fundamentals
observers: ) and notifies them automatically when its state changes.; Lesson 2289 — Observer Pattern Fundamentals Lesson 2290 — Observer Pattern Implementation
Obvious statements: `// increment counter` above `counter++` adds noise, not value; Lesson 2312 — Comments: When and How to Use Them
OCSP: lets clients query a CA's server in real-time: "Is certificate X still valid?; Lesson 1538 — Certificate Revocation: CRL and OCSP
OCSP stapling: (servers pre-fetch their own OCSP response and include it in the TLS handshake) to improve performance and privacy.; Lesson 1538 — Certificate Revocation: CRL and OCSP
Odd count: Include all negatives and all positives for maximum negative magnitude (most negative = minimum); Lesson 898 — Minimum Product Subset
Odd length: single-character center (like "racecar" centers on 'e'); Lesson 936 — Longest Palindromic Substring
Off-by-one errors: fence-post problems at array boundaries; Lesson 2260 — Handling Edge Cases and Boundaries
Offline-capable applications: Your laptop acts as a leader while disconnected, syncing when reconnected; Lesson 2641 — Multi-Leader Replication
offset: .; Lesson 1127 — Cache Address Breakdown Lesson 1128 — Direct-Mapped Cache Lookup Lesson 1133 — Set- Associative Address Mapping Lesson 1353 — Page Tables Lesson 1354 — Address Translation in Paging Lesson 1359 — Two-Level Page Tables
Offset (d): The distance from the beginning of that segment; Lesson 1380 — Logical Address Translation in Segmentation
Offsets: `[0, 2, 3, 3]`; Lesson 683 — Hybrid and Compressed Representations
Offsets array: Marks where each vertex's neighbors start; Lesson 683 — Hybrid and Compressed Representations
Often enables further optimizations: by cleaning up after other optimization passes; Lesson 2063 — Dead Code Elimination
OLAP: (Online Analytical Processing) databases—systems designed for fundamentally different purposes.; Lesson 1650 — OLTP vs OLAP Database Design
Old generation (tenured space): Objects that have survived multiple collections graduate here; Lesson 2098 — Generational Garbage Collection
Older systems: sometimes called a "file descriptor block"; Lesson 1397 — File Control Blocks and Inodes
OLTP: (Online Transaction Processing) and **OLAP** (Online Analytical Processing) databases— systems designed for fundamentally different purposes.; Lesson 1650 — OLTP vs OLAP Database Design
On entry: Increment the count (the parameter now references it); Lesson 2105 — Reference Count Operations
On failure: `fork()` returns `-1` (no child created); Lesson 1222 — Process Creation: fork() System Call
On mismatch: use `prefix[j-1]` to reset `j` (never backtrack `i`!; Lesson 835 — KMP: Pattern Matching Algorithm
On return: Decrement the count (the parameter goes out of scope); Lesson 2105 — Reference Count Operations
Once a majority confirms: , the entry is considered "committed"; Lesson 2658 — The Replicated State Machine Model
one: student who failed.; Lesson 49 — Negating Quantified Statements Lesson 169 — The elif (else if) Statement Lesson 1309 — Signal vs Broadcast Lesson 1467 — IPv6 Addressing Basics Lesson 1566 — LIKE Operator and Pattern Matching Lesson 1686 — Clustered vs Non-Clustered B-Tree Indexes Lesson 1743 — Consistency and Replication in Column Stores Lesson 1787 — Minimizing States in DFAs
one at a time: (left-to-right, top-to-bottom) rather than entire rows, updating the profile incrementally.; Lesson 963 — Profile/Broken Profile Optimization Lesson 991 — Floyd-Warshall Core Idea
one-to-one: ) is a function where different inputs always produce different outputs.; Lesson 77 — Function Properties: Injective (One-to-One)Lesson 1616 — Relationship Cardinality: One-to- One and One-to-Many
one-to-one correspondence: between sets.; Lesson 79 — Function Properties: Bijective Lesson 1951 — Recursive Descent Parsing Concept
One-vs-Rest: is simpler to implement (reuse binary classifiers) but treats classes independently.; Lesson 2834 — Multiclass Logistic Regression
One-way transformation: Store a hash, not the password itself; Lesson 2504 — Password Storage Fundamentals
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
only: `(x > 0)`, not the whole statement.; Lesson 53 — Quantifier Scope and Binding Lesson 562 — Splitting Root Nodes
Opcode: (operation code): Specifies *what* to do (add, subtract, load, store, etc.; Lesson 1084 — The Decode Stage Lesson 1085 — Instruction Formats and Opcodes Lesson 1086 — The Execute Stage
Opcode lookup: Each mnemonic maps to a specific binary opcode.; Lesson 1105 — Assembly to Machine Code Translation
Open a pull request: through the web interface, describing what changed and why; Lesson 2196 — Pull Requests and Code Review
open addressing: , every slot holds at most one element.; Lesson 418 — Collision Resolution Overview Lesson 422 — Open Addressing: Concept Lesson 428 — Load Factor and Rehashing Lesson 430 — Comparing Collision Strategies Lesson 431 — Collision Resolution in Practice Lesson 439 — Cache Performance and Memory Locality Lesson 1691 — Collision Handling in Hash Indexes
Open the conflicted file: in your text editor; Lesson 2188 — Resolving Merge Conflicts
Open/Closed Principle: Add new strategies without touching existing ones; Lesson 2287 — Strategy Pattern Fundamentals
Operand encoding: Register names and immediate values get converted to binary fields.; Lesson 1105 — Assembly to Machine Code Translation
Operand fields: Specify *which* registers or memory addresses hold the data; Lesson 1084 — The Decode Stage Lesson 1085 — Instruction Formats and Opcodes
operands: the locations of data the operation needs.; Lesson 1085 — Instruction Formats and Opcodes Lesson 1093 — Assembly Language Syntax and Structure Lesson 1978 — AST Representation of Expressions
Operation Selection: A control signal tells the ALU which operation to perform (add, subtract, compare, etc.; Lesson 1072 — The Arithmetic Logic Unit (ALU)
Operation Types: The plan shows operations like `Seq Scan` (reading entire table), `Index Scan` (using an index), `Hash Join`, or `Nested Loop`.; Lesson 1705 — Reading and Analyzing EXPLAIN Output
Operation-based CRDTs (CmRDTs): Replicas broadcast operations that commute.; Lesson 2703 — Conflict-Free Replicated Data Types (CRDTs)
Operational Overhead: Rebalancing partitions is easier with consistent hashing than with range partitioning.; Lesson 2696 — Trade-offs in Partitioning Strategies
operator: , pop two operands, apply the operator, and push the result back; Lesson 367 — Evaluating Postfix Expressions Lesson 1940 — Token Classification
operators: that actually fetch, filter, join, and aggregate your data.; Lesson 1698 — Query Execution Plans and Operators Lesson 1978 — AST Representation of Expressions
Opposing goals: One player's victory is the other's defeat (zero-sum games); Lesson 2764 — Adversarial Search Overview
opposite: output.; Lesson 14 — The NOT Gate (Inverter)Lesson 1935 — Vertex Cover and Clique Reductions
optimal: uninformed search algorithm that explores all nodes at depth *d* before moving to any node at depth *d+1*.; Lesson 2740 — Breadth-First Search (BFS)Lesson 2746 — Uniform-Cost Search
Optimal like BFS: Finds the shallowest goal first (assuming uniform path cost); Lesson 2745 — Iterative Deepening DFS
Optimal Page Replacement (OPT): algorithm, also called Bélády's algorithm, always replaces the page that **will not be used for the longest time in the future**.; Lesson 1367 — Optimal Page Replacement (OPT)
Optimal result: 2 coins (3 + 3); Lesson 885 — When Greedy Fails
Optimal solution: Take Items B and C (value = 120); Lesson 911 — Counterexamples: When Greedy Fails Lesson 2730 — Path Cost and Optimality
Optimal Substructure: (subproblems solve independently).; Lesson 880 — Optimal Substructure in Greedy Problems Lesson 881 — Greedy vs Dynamic Programming Lesson 900 — Policemen Catch Thieves Problem Lesson 905 — Optimal Substructure in Greedy Algorithms Lesson 907 — Proving Activity Selection Correctness Lesson 908 — Proving Huffman Coding Correctness Lesson 914 — Optimal Substructure Property Lesson 915 — Overlapping Subproblems (+12 more)
Optimality: Here's the key proof: When A* selects the goal node for expansion, it has the lowest `f` value among all nodes in the open set.; Lesson 1008 — A* Correctness and Optimality Lesson 2748 — Comparing Uninformed Strategies
Optimality preserved: Consistency implies admissibility, so solutions remain optimal; Lesson 1004 — Consistent (Monotonic) Heuristics
Optimization: Scheduling, routing, resource allocation; Lesson 1912 — The Million Dollar Question Lesson 1982 — AST Manipulation and Transformation Lesson 2029 — The Translation Pipeline: Source to Machine Code Lesson 2144 — Referential Transparency
Optimization becomes simpler: Once code is in IR form, the compiler can apply powerful optimizations (eliminating redundant calculations, reordering instructions, etc.; Lesson 2037 — What is an Intermediate Representation (IR)?
Optimization freedom: The engine can reorder operations, parallelize work, or cache results without breaking your code —because you never specified *how* to execute.; Lesson 2156 — Benefits and Trade-offs of Declarative Style
Optimization Opportunities: Lesson 2047 — IR Design Tradeoffs
Optimization Required: Lesson 919 — Identifying DP Problems
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)
Optimize: pattern matching in compilers and text processors; Lesson 1776 — Regular Expression Equivalence
Optimize only what matters: with measurable impact; Lesson 2305 — Premature Optimization Anti-Pattern
Optimizes away redundant operations: when it proves an object lives long enough; Lesson 2110 — Reference Counting in Practice
Option A: Memorize all the answers beforehand (uses lots of mental space, but answering is instant); Lesson 307 — Space-Time Tradeoffs
Option B: Bring the textbook and look up each answer (uses minimal space, but takes more time per answer); Lesson 307 — Space-Time Tradeoffs
Optional annotations: You can add type annotations where you want compile-time safety; Lesson 2005 — Gradual Typing Systems
Optional metadata: (parent pointer, balance factors, color bits for self-balancing variants); Lesson 525 — Space Complexity of BSTs
Optional weights array: For weighted graphs; Lesson 683 — Hybrid and Compressed Representations
OPTIONS: Asks the server which HTTP methods are supported for a given resource.; Lesson 1517 — HTTP Methods: PUT, DELETE, and Others
Oracle: provides hash clusters for similar functionality.; Lesson 1696 — Hash Indexes in Practice
Order: Does every parent-child pair satisfy the heap property?; Lesson 582 — Heap Shape vs Heap Order Lesson 647 — Segment Tree Variants and Functions Lesson 937 — Matrix Chain Multiplication Lesson 1499 — When to Use TCP: Application Scenarios Lesson 1612 — Entities and Entity Sets
Order matters: If you change the anchor's pointer first, you lose track of the rest of the list.; Lesson 331 — Inserting at a Specific Position Lesson 1825 — Removing Useless Symbols
Order matters critically: Swap two statements and behavior may break unpredictably; Lesson 2121 — Imperative Style Tradeoffs
Order matters for readability: , but the query optimizer may rearrange internally; Lesson 1586 — Three-Table Joins
Order Preservation: Lesson 386 — Queue Invariants and Correctness
Order rule: "Parent books must be alphabetically before child books.; Lesson 582 — Heap Shape vs Heap Order
Order vertices: by when they were discovered or completed; Lesson 715 — DFS Discovery and Finish Times
OrderDetails: (OrderID, ProductID, ProductName, Quantity); Lesson 1636 — Achieving Second Normal Form
Ordered Delivery: Lesson 1471 — TCP Overview and Key Features
Ordering: Items at the top are more refined, detailed, and urgent.; Lesson 2377 — Scrum Artifacts: Product Backlog
Ordering events: Determining causality (did A cause B?; Lesson 2598 — Lack of Global Clock
Orders: table: `order_id`, `customer_id`, `product`, `price`; Lesson 1576 — What is a Join?
Origin/Referer header validation: as a backup check; Lesson 2473 — Implementing CSRF Protection
Original: ∀x (x > 0); Lesson 49 — Negating Quantified Statements Lesson 1464 — Subnetting Fundamentals
Original packet: Source = `192.; Lesson 1466 — Network Address Translation (NAT)
Originator: The object whose state you want to save (e.; Lesson 2298 — Memento Pattern
OS takes control: The page fault handler is invoked; Lesson 1346 — Page Faults and Demand Paging
OSPF: (Open Shortest Path First): More sophisticated, uses link state and cost metrics; Lesson 1470 — Static vs Dynamic Routing Protocols
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
Other automated checks: might include linting, security scans, or performance benchmarks; Lesson 2386 — Automated Testing in CI
Other systems like Cassandra: handle replication and distribution internally without depending on external file systems.; Lesson 1745 — HBase and Other Column-Family Systems
Other/World: Everyone else on the system; Lesson 1392 — File Permissions and Access Control
Others waiting outside: = blocked processes; Lesson 1275 — Mutual Exclusion Explained
ours: strategy resolves conflicts by keeping *your current branch's* version of conflicting files, completely ignoring changes from the branch being merged in.; Lesson 2191 — Merge Strategies Lesson 2211 — Advanced Merge Strategies
Out-degree: The number of edges *going out from* the vertex; Lesson 661 — Degree of a Vertex
Out-of-band: attacks use a *different channel* to exfiltrate data, typically when the application is too locked down for in-band methods.; Lesson 2476 — Types of SQL Injection Attacks
out-of-bounds error: .; Lesson 235 — Array Length and Bounds Lesson 264 — String Length and Bounds Checking
Out-of-Order Delivery: If you send datagrams A, B, and C in that order, they might arrive as B, C, A.; Lesson 1490 — UDP Datagram Delivery and No Guarantees
out-of-order execution: , if Instruction 2 somehow completes its write to `R1` *before* Instruction 1 reads it, Instruction 1 gets the wrong value.; Lesson 1166 — Data Hazards: Write-After-Read (WAR)Lesson 1167 — Data Hazards: Write-After-Write (WAW)
Out-of-place: You take all the books off, sort them on a separate table (requiring a second table-sized space), then put them back on the shelf in order.; Lesson 739 — In-Place vs Out-of-Place Sorting
Out-of-place sorting: algorithms create additional data structures to hold intermediate or final results, requiring O(n) extra space where n is the number of elements being sorted.; Lesson 739 — In-Place vs Out-of-Place Sorting Lesson 804 — In-Place vs Out-of-Place Tradeoffs
Outbound mapping creation: The NAT router records the internal IP and port (e.; Lesson 1491 — UDP and Network Address Translation (NAT)
Outdated information: Comments that contradict the code are worse than no comments; Lesson 2312 — Comments: When and How to Use Them
Outer (first-level) page table: Points to second-level page tables; Lesson 1359 — Two-Level Page Tables
Outer index: Selects which second-level page table to use; Lesson 1359 — Two-Level Page Tables
Outer loop: Runs V-1 times (one iteration per possible edge in the shortest path); Lesson 986 — Bellman-Ford Time Complexity
Output: The result is sent back to a register, and status flags (like overflow or zero) are set; Lesson 1072 — The Arithmetic Logic Unit (ALU)Lesson 2268 — Factory Method: Parameterized Creation
Output format: Classification outputs probabilities or class labels; regression outputs a single number or vector of numbers; Lesson 2781 — Classification vs Regression Problems
Output Parameters: Some languages allow "output" or "reference" parameters — variables passed to the function that it modifies directly, effectively "returning" values through them.; Lesson 200 — Multiple Return Values
Outputs the physical address: to the memory bus, allowing the access to proceed; Lesson 1343 — Memory Management Unit (MMU)
Over-Mocking: Excessive mocking can hide integration problems and create tests that pass but don't validate real behavior.; Lesson 2263 — TDD Benefits and Common Pitfalls
Over-regularization: Constraints are so strict the model can't learn; Lesson 2809 — What is Underfitting?
Overall complexity: still O(n²): because shifts dominate; Lesson 749 — Insertion Sort: Binary Search Optimization
overfitting: .; Lesson 2777 — Training Data vs Test Data Lesson 2796 — Training Set vs Test Set
Overfitting risk: Sparse data in high dimensions means your K nearest neighbors might not actually be representative; Lesson 2871 — Handling High-Dimensional Data
Overflow: Attempting `enqueue` when capacity is full (bounded queues); Lesson 377 — Queue Interface and Specification Lesson 1061 — Overflow Detection in Integer Arithmetic Lesson 1062 — Integer Width and Range Tradeoffs
Overflow flag (V): Set if signed arithmetic overflowed; Lesson 1077 — Accumulator and Status Registers
Overlap between circles: Elements in the intersection of those sets; Lesson 64 — Venn Diagrams
overlapping subproblems: where the same smaller problem appears multiple times.; Lesson 881 — Greedy vs Dynamic Programming Lesson 913 — What is Dynamic Programming?Lesson 915 — Overlapping Subproblems Lesson 919 — Identifying DP Problems Lesson 924 — Climbing Stairs Problem Lesson 926 — Longest Increasing Subsequence (LIS)Lesson 927 — Edit Distance (Levenshtein Distance)Lesson 928 — Coin Change: Minimum Coins (+7 more)
Overly restrictive character rules: Reduces possible password space; Lesson 2512 — Password Policies and Requirements
Overwrites: all follower entries *after* that point; Lesson 2667 — Handling Log Inconsistencies
owner: or **parent**) for identification.; Lesson 1619 — Weak Entities and Identifying Relationships Lesson 2531 — Discretionary Access Control (DAC)
Owner and group IDs: Lesson 1397 — File Control Blocks and Inodes
Owner tracking: The mutex remembers which thread holds it; Lesson 1288 — Recursive Locks (Reentrant Mutexes)
Owner/User: The file's creator or designated owner; Lesson 1392 — File Permissions and Access Control
Ownership: User ID and group ID of the file's owner; Lesson 1388 — File Attributes and Metadata Lesson 2377 — Scrum Artifacts: Product Backlog

P

P = coP: P is closed under complementation; Lesson 1909 — Complementary Classes: coNP
P ≠ EXP: (proven!; Lesson 1894 — The Class EXP (Exponential Time)
P = NP: , then every NP problem (like the Traveling Salesman, Boolean satisfiability, or graph coloring) would have efficient algorithms waiting to be discovered.; Lesson 1906 — The P vs NP Question
P ≠ NP: (what most computer scientists believe), then some problems are *inherently* harder to solve than to verify—there's a fundamental asymmetry in computation.; Lesson 1906 — The P vs NP Question Lesson 1908 — Why P ≠ NP is Believed
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 EXP: (strictly, proven via time hierarchy theorem); Lesson 1897 — Complexity Class Hierarchy
P NP: .; Lesson 1892 — NP vs P: The Relationship Lesson 1905 — P Subset of NP Lesson 1908 — Why P ≠ NP is Believed Lesson 1909 — Complementary Classes: coNP
P PSPACE: (proven to be strict by Savitch's Theorem and other results); Lesson 1897 — Complexity Class Hierarchy
P Q: is true **only when both P and Q are true**.; Lesson 33 — Logical Conjunction (AND)
P vs NP question: asks: Does P = NP?; Lesson 1906 — The P vs NP Question
P vs. NP: the million-dollar question!; Lesson 1897 — Complexity Class Hierarchy
P(A ∩ B): removes that double-count; Lesson 113 — Addition Rule for Probabilities
P(A): counts all outcomes where A happens; Lesson 113 — Addition Rule for Probabilities
P(A) ≥ 0: for any event A.; Lesson 109 — Probability Axioms
P(A|B): (read as "probability of A given B") and calculated as:; Lesson 114 — Conditional Probability Lesson 118 — Bayes' Theorem
P(B): counts all outcomes where B happens; Lesson 113 — Addition Rule for Probabilities
P(B|A): and need **P(A|B)** instead?; Lesson 118 — Bayes' Theorem
P(S) = 1: Lesson 109 — Probability Axioms
P(spam): Overall rate of spam emails (prior probability); Lesson 118 — Bayes' Theorem
P(spam|word): the probability an email is spam *given* it contains a certain word.; Lesson 118 — Bayes' Theorem
P(word): Overall rate of the word appearing; Lesson 118 — Bayes' Theorem
P(word|spam): how often that word appears in known spam.; Lesson 118 — Bayes' Theorem
P(X = x): Lesson 121 — Discrete Random Variables Lesson 131 — Expected Value of Functions
P(x): , where:; Lesson 46 — Predicates and Propositional Functions
PA/EL: (available during partitions, prioritize latency otherwise), while systems like HBase are **PC/EC** (consistent during partitions, consistent even at the cost of latency during normal operation).; Lesson 2609 — Beyond CAP: PACELC and Modern Perspectives
PACELC theorem: fills this gap.; Lesson 2609 — Beyond CAP: PACELC and Modern Perspectives
Package managers: (npm, pip, apt) resolve installation order; Lesson 720 — Topological Sort Applications
Packet Loss: UDP datagrams can simply vanish in transit.; Lesson 1490 — UDP Datagram Delivery and No Guarantees
Packet loss detected: (timeout or duplicate ACKs) — signals congestion; Lesson 1478 — TCP Congestion Control: Slow Start
Page defacement: Lesson 2458 — XSS Attack Vectors and Payloads
page fault: occurs when a program tries to access a virtual memory page that isn't currently mapped to physical memory.; Lesson 1346 — Page Faults and Demand Paging Lesson 1350 — Virtual Memory Performance Considerations Lesson 1366 — Page Replacement Problem
Page Fault Frequency (PFF): takes a more practical, feedback-driven approach: instead of predicting memory needs, we *measure* how a process is actually performing and adjust accordingly.; Lesson 1376 — Page Fault Frequency
Page number (p): – identifies which page the address belongs to; Lesson 1354 — Address Translation in Paging
Page offset (d): – specifies the exact byte within that page; Lesson 1354 — Address Translation in Paging
Page Size: Lesson 1365 — Paging Performance Considerations
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 Introduction Lesson 1352 — Pages and Frames Lesson 1353 — Page Tables Lesson 1384 — Segmentation with Paging (Hybrid Approach)
Page Table Structure: Lesson 1365 — Paging Performance Considerations
Pages: Fixed-size blocks of a process's virtual address space (same size as frames); Lesson 1351 — Introduction to Paging Lesson 1352 — Pages and Frames Lesson 1356 — Internal Fragmentation in 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
Pairing nearby: ensures we don't "waste" a policeman on a distant thief when a closer one exists; Lesson 900 — Policemen Catch Thieves Problem
Palindrome checking: also benefits: push characters onto a deque, then compare by popping from both ends simultaneously until you meet in the middle.; Lesson 404 — Deque Applications and Use Cases
Palindromes of arbitrary length: `aba`, `abba`, `abcba`, etc.; Lesson 1777 — Limitations of Regular Expressions
Panic Mode Recovery: Lesson 1972 — LR Parser Error Recovery
parallel: it uses the index to jump straight to one location while simultaneously comparing the tag.; Lesson 1127 — Cache Address Breakdown Lesson 2101 — Concurrent and Parallel GC
Parallel execution: (multiple jobs simultaneously); Lesson 2394 — CI/CD Tools and Infrastructure
Parallel GC: uses *multiple threads* during the collection itself.; Lesson 2101 — Concurrent and Parallel GC
Parallel scheduling: All CPUs can schedule processes at the same time; Lesson 1266 — Per-CPU Run Queues
Parallel sorting: splits the sorting work across these processors so they can work simultaneously, potentially sorting data much faster.; Lesson 806 — Parallel Sorting Algorithms
Parallelism: is key — modern SSDs have multiple channels and can handle concurrent operations efficiently; Lesson 1429 — Disk Scheduling in Modern Systems Lesson 2508 — Password Hashing with Argon2 Lesson 2545 — Parallelism Defined: Simultaneous Execution Lesson 2546 — The Key Distinction: Dealing vs Doing Lesson 2547 — Single-Core Concurrency Through Time-Slicing Lesson 2553 — Choosing Between Concurrency and Parallelism
Parallelizable: Safe to run concurrently without race conditions; Lesson 2132 — Pure Functions and Immutability
Parallelization: Run independent tests or build steps simultaneously across multiple machines or CPU cores.; Lesson 2388 — CI Best Practices: Fast Feedback
Parallelize when possible: Many CI systems let you run tests concurrently across multiple machines, cutting total time dramatically.; Lesson 2245 — Integration Test Maintenance and CI Lesson 2254 — E2E Testing Challenges and Best Practices
Parameter binding: matching arguments to parameters; Lesson 2025 — Function Call Semantics
Parameter validation: means checking inputs *before* using them, so your function can respond gracefully to bad data.; Lesson 205 — Parameter Type Checking and Validation
Parameterization: Lesson 2327 — Remove Duplicate Code: DRY Principle in Practice
Parameterize clients: Different objects can hold different commands and execute them without knowing the details.; Lesson 2291 — Command Pattern Fundamentals
Parameterized algorithms: exploiting special structure; Lesson 1911 — Practical Impact of P vs NP
parameters: Lesson 125 — Binomial Distribution Lesson 192 — Function Documentation Lesson 212 — Variable Lifetime Basics Lesson 374 — Stack-Based Memory Management Lesson 1208 — System Call Parameters and Return Values Lesson 1980 — AST Representation of Function Definitions Lesson 1995 — Type Annotations and Signatures Lesson 2076 — Stack Frames and Activation Records
Parameters and capacity: More parameters mean a larger, more flexible hypothesis space; Lesson 2778 — The Hypothesis Space
parent: is any node that has one or more nodes directly connected below it.; Lesson 451 — Root, Parent, Child, and Sibling Nodes Lesson 461 — Array-Based Complete Binary Trees Lesson 462 — Array Index Formulas Lesson 566 — Merging Nodes in B-Trees Lesson 579 — Array Representation of Binary Heaps Lesson 580 — Parent-Child Index Formulas Lesson 586 — Heap Insert: Upward Bubbling Concept Lesson 650 — Binary Representation and Index Manipulation (+3 more)
Parent and child: A parent node splits into child nodes via edges.; Lesson 2840 — Tree Terminology: Nodes, Edges, and Leaves
Parent index: `i / 2` (using integer division); Lesson 580 — Parent-Child Index Formulas
Parent Pointer (Optional): Some implementations include a pointer back to the parent node.; Lesson 497 — BST Node Structure
Parent pointers: which vertex led us to each node; Lesson 699 — Shortest Path in Unweighted Graphs Lesson 2738 — Solution Extraction and Path Reconstruction
Parent Process ID (PPID): the PID of the process that created it.; Lesson 1228 — Process IDs and Identification
Parent/distance arrays: (optional): If you're tracking shortest paths or reconstructing routes, these also take O(V).; Lesson 698 — BFS Time and Space Complexity
parentheses: to make your meaning crystal clear: `(p ∧ q) ∨ r` versus `p ∧ (q ∨ r)` can yield different truth values!; Lesson 39 — Compound Propositions and Precedence Lesson 188 — Calling Functions
Parity: adds a single bit to a frame to make the total number of 1s either even (even parity) or odd (odd parity).; Lesson 1447 — Error Detection with Parity and Checksums
Parse: Use lexical analysis (tokens) and parsing (building an AST fragment) to understand the statement's structure; Lesson 2030 — Interpreter Execution Cycle: Parse and Execute
parse tree: is a graphical representation of this derivation.; Lesson 1814 — Derivations and Parse Trees Lesson 1847 — Parse Tree vs. Abstract Syntax Tree Lesson 1977 — From Parse Tree to AST
Parse tree shape: All internal nodes have exactly 2 children or 1 terminal child; Lesson 1843 — Chomsky Normal Form
Parser generators: are tools that do this work for you automatically.; Lesson 1973 — Parser Generators and YACC/Bison
Parsing: When parsing nested structures (like expressions or grammar rules), different parsing functions handle different syntax elements and call each other as they encounter nested patterns.; Lesson 875 — Mutual Recursion
Parsing complexity: The CYK (Cocke-Younger-Kasami) algorithm relies on CNF to run in O(n³) time; Lesson 1843 — Chomsky Normal Form
Partial application: is simpler—it fixes some arguments upfront and returns a function waiting for the rest.; Lesson 2138 — Currying and Partial Application
Partial dependency: .; Lesson 1624 — Full vs Partial Functional Dependencies Lesson 1635 — Partial Dependencies Explained
Partial failures: One shard might be down or slow, affecting the entire query; Lesson 2692 — Cross-Shard Queries and Joins Lesson 2717 — What Are Distributed Transactions?
Partial key: The weak entity has a **discriminator** (or partial key)—an attribute that distinguishes it among entities related to the same owner, but not globally.; Lesson 1619 — Weak Entities and Identifying Relationships
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 Lesson 2628 — Lamport Timestamps
Partial participation: (optional): Some entities may participate in the relationship, but it's not required—entities can exist independently.; Lesson 1618 — Participation Constraints: Total vs Partial
Partial participation example: Lesson 1618 — Participation Constraints: Total vs Partial
participants: Lesson 2653 — Two-Phase Commit Protocol Lesson 2718 — Two-Phase Commit (2PC) Protocol
partition: ), calculate the probability within each scenario, then add them up.; Lesson 117 — Law of Total Probability Lesson 762 — Quicksort: The Divide-and-Conquer Sorting Strategy Lesson 767 — Quicksort Recursive Implementation Lesson 1790 — Constructing the Minimal DFA
Partition and recurse: Partition around this pivot and recurse on the appropriate side; Lesson 826 — Median of Medians: Partitioning Strategy
Partition key: Determines which nodes store your data using consistent hashing (remember that from key-value stores?; Lesson 1744 — Apache Cassandra: Architecture and Use Cases Lesson 2685 — Partition Keys and Shard Keys
Partition Problem: given a set of integers, can you divide them into two disjoint subsets with equal sums?; Lesson 1926 — Partition Problem
Partition the data: into subsets based on that split; Lesson 2847 — Recursive Partitioning Algorithm
Partition tolerance: (P): The system continues operating despite network splits; Lesson 1714 — CAP Theorem Trade-offs Across Categories Lesson 1734 — Eventual Consistency Trade-offs Lesson 2603 — Partition Tolerance Explained Lesson 2697 — Eventual Consistency Definition and Motivation Lesson 2698 — Strong vs Eventual Consistency Tradeoffs
partitioning: .; Lesson 762 — Quicksort: The Divide-and-Conquer Sorting Strategy Lesson 2638 — Replication vs. Partitioning Lesson 2683 — Horizontal vs Vertical Partitioning
Partitioning answers: "How do I handle datasets larger than one machine and distribute write load?; Lesson 2638 — Replication vs. Partitioning
Partitions: .; Lesson 2607 — CA Systems and the Real World Lesson 2682 — Introduction to Data Partitioning Lesson 2720 — Three-Phase Commit (3PC)
PascalCase: usually reserved for type names, not variables; Lesson 147 — Variable Naming Conventions
Pass 1: Run DFS on the original graph and record the **finish times** (when each vertex completes).; Lesson 735 — Kosaraju's Algorithm for SCCs Lesson 742 — Bubble Sort: Analysis Lesson 744 — Selection Sort: Algorithm Lesson 792 — Radix Sort: Digit-by-Digit Sorting
Pass 2: Transpose the graph (reverse every edge).; Lesson 735 — Kosaraju's Algorithm for SCCs Lesson 742 — Bubble Sort: Analysis Lesson 744 — Selection Sort: Algorithm Lesson 792 — Radix Sort: Digit-by-Digit Sorting
Pass 3: (n - 3) comparisons; Lesson 742 — Bubble Sort: Analysis Lesson 744 — Selection Sort: Algorithm Lesson 792 — Radix Sort: Digit-by-Digit Sorting
Pass 4: Find minimum in remaining (25), already in place; Lesson 744 — Selection Sort: Algorithm
Pass arguments: Give the thread any data it needs to start; Lesson 1238 — Thread Creation and Termination
Pass n-1: 1 comparison; Lesson 742 — Bubble Sort: Analysis
Pass-by-reference: works differently: instead of copying the data, the function receives a *reference* (think: address or pointer) to the original data's location in memory.; Lesson 203 — Pass-by-Reference Semantics Lesson 318 — Pass-by-Value vs Pass-by-Reference
pass-by-value: semantics.; Lesson 202 — Pass-by-Value Semantics Lesson 203 — Pass-by-Reference Semantics Lesson 318 — Pass-by- Value vs Pass-by-Reference
Password hash prefix matching: Send only the first 5 characters of a password's SHA-1 hash to avoid exposing the full password; Lesson 2514 — Credential Stuffing and Breach Detection
Password reuse: one breach cascades across the internet; Lesson 2504 — Password Storage Fundamentals
Password storage: If you could reverse a password hash, attackers who breach a database could instantly recover all passwords; Lesson 2422 — Preimage Resistance (One-Wayness)
Password Strength: A password with 8 characters from 62 options (a-z, A-Z, 0-9) has 62^8 possible values (permutations with repetition).; Lesson 107 — Counting Problems in Computer Science
Passwords: with 8 characters from 62 options (a-z, A-Z, 0-9): 62⁸ ≈ 218 trillion possibilities; Lesson 101 — Permutations with Repetition Lesson 2517 — Knowledge Factors (Something You Know)
PATCH: Partially updates a resource.; Lesson 1517 — HTTP Methods: PUT, DELETE, and Others Lesson 2202 — Release Tagging and Versioning
path: in a tree is a sequence of nodes connected by edges, where you move from one node to another without revisiting any node.; Lesson 453 — Path, Ancestor, and Descendant Concepts Lesson 490 — Path Length Properties Lesson 657 — What is a Graph? Vertices and Edges Lesson 662 — Paths and Walks
Path cost: assigns a numerical value to each route through the state space, letting us compare solutions objectively.; Lesson 2730 — Path Cost and Optimality
Path existence: checking between two nodes; Lesson 718 — DFS Applications and Use Cases
Path reconstruction: follow parent pointers backward; Lesson 699 — Shortest Path in Unweighted Graphs Lesson 700 — BFS Tree and Parent Tracking
Path Traversal Example: Lesson 2489 — Path Traversal and File Inclusion
Pathological input: An attacker or unlucky data set might exploit your hash function's weaknesses, causing massive clustering.; Lesson 434 — Worst-Case Time Complexity Scenarios
Patricia trie: ) merges these single-child chains into a single edge labeled with multiple characters.; Lesson 631 — Compressed Tries (Radix Trees)
Pattern: = the rules to classify it ("if it's thin and rectangular with a stamp, it's a letter"); Lesson 1939 — Tokens, Lexemes, and Patterns
Pattern History Table (PHT): of 2-bit saturating counters; Lesson 1182 — Local History Predictors
Pattern matching: "Detect circular payment chains"; Lesson 1746 — Graph Database Model and Use Cases Lesson 1750 — Cypher Query Language Basics
Pattern violations: New code using Factory Method when existing code uses Abstract Factory for similar purposes; Lesson 2347 — Evaluating Design and Architecture
patterns: that make code easier to read and less error-prone.; Lesson 174 — Common Conditional Patterns Lesson 1750 — Cypher Query Language Basics Lesson 1939 — Tokens, Lexemes, and Patterns Lesson 2301 — Introduction to Anti-Patterns
Pauses: running processes; Lesson 1337 — Memory Compaction
Paxos: was the dominant consensus algorithm taught in academia and used in distributed systems.; Lesson 2657 — Introduction to Raft: Motivation and Overview Lesson 2672 — Introduction to Paxos: The Consensus Problem
Payload: The actual data being transmitted.; Lesson 1489 — UDP Checksum Calculation and Verification Lesson 2458 — XSS Attack Vectors and Payloads
PC/EC: (consistent during partitions, consistent even at the cost of latency during normal operation).; Lesson 2609 — Beyond CAP: PACELC and Modern Perspectives
PCB retention: The Process Control Block remains temporarily in memory so the parent process can retrieve the exit status and other final information.; Lesson 1220 — Process States: Terminated
PDA → CFG: Given any PDA, we can construct a CFG that generates the same language; Lesson 1835 — Equivalence of PDAs and Context-Free Grammars
PDAs: are like *recognition machines* — they read strings and decide membership using a stack.; Lesson 1835 — Equivalence of PDAs and Context-Free Grammars
peek: (or **top**): View the top element without removing it; Lesson 356 — The Stack ADT Definition Lesson 359 — Peek (or Top) Operation Lesson 360 — IsEmpty Operation Lesson 362 — Array-Based Stack Implementation Lesson 363 — Linked List-Based Stack Implementation Lesson 370 — Backtracking with Stacks Lesson 376 — Essential Queue Operations Lesson 382 — Linked List-Based Queue Implementation (+4 more)
Peek (or Find-Max/Min): View the highest/lowest priority element without removing it; Lesson 609 — Priority Queue ADT Overview
Peek (View Front): Lesson 376 — Essential Queue Operations
Peek at front: (view front element without removing); Lesson 395 — Deque: Double-Ended Queue Fundamentals
Peek at rear: (view rear element without removing); Lesson 395 — Deque: Double-Ended Queue Fundamentals
Penalizing large parameter values: Keeps weights small and reasonable; Lesson 2810 — Introduction to Regularization
Per-thread request context: (user ID, transaction ID in web servers); Lesson 2559 — Thread-Local Storage
Percentile calculations: (e.; Lesson 821 — The Selection Problem Definition
Perfect: The ideal case—fully balanced and completely filled; Lesson 459 — Full, Complete, and Perfect Binary Trees Lesson 486 — Perfect Binary Trees
perfect binary tree: is a special type of binary tree where:; Lesson 486 — Perfect Binary Trees Lesson 487 — Node Count Formulas
Perfect verification is impossible: We cannot build a tool that guarantees all programs are bug-free; Lesson 1887 — Philosophical and Practical Impact
Perform depth-first search: , but prune any path where `f(n) = g(n) + h(n)` exceeds the current threshold; Lesson 2761 — IDA* (Iterative Deepening A*)
Perform standard BST search: Start at the root and navigate left or right based on key comparisons, just like in a regular BST.; Lesson 571 — Splay Tree Search
Perform the actual operation: Now modify the real file system structures; Lesson 1407 — Write-Ahead Logging and Recovery
Performance: Some processors handle certain sizes faster; Lesson 140 — Integer Data Types Lesson 159 — Short-Circuit Evaluation Lesson 228 — Converting Tail Recursion to Iteration Lesson 270 — What is Runtime Analysis?Lesson 868 — Recursive vs Iterative Tradeoffs Lesson 918 — Top-Down vs Bottom-Up Tradeoffs Lesson 1045 — Maximum Flow Algorithm Comparison Lesson 1239 — Thread-Local Storage (+7 more)
Performance at scale: Many NoSQL systems trade strict consistency for speed and availability (BASE instead of ACID), perfect for social media feeds or product catalogs where eventual consistency suffices.; Lesson 1708 — What is NoSQL and Why It Exists
Performance bottlenecks: If queries consistently timeout, strategic denormalization might be necessary; Lesson 1645 — Normal Form Trade-offs
performance guarantees: .; Lesson 545 — AVL Trees vs Unbalanced BSTs Lesson 808 — Standard Library Sort Functions
Performance per watt: has become as important as performance alone.; Lesson 1192 — Power and Energy Efficiency Metrics
Performance trade-offs: Strict ACID guarantees slowed down systems needing extreme speed; Lesson 1708 — What is NoSQL and Why It Exists
Performance-critical code: When every clock cycle counts (video codecs, cryptography, game engines), programmers write assembly to squeeze out maximum speed.; Lesson 1091 — Assembly Language Overview and Purpose
Performance-critical paths: Sometimes you need a specific algorithm or memory layout that declarative abstractions hide.; Lesson 2156 — Benefits and Trade-offs of Declarative Style
Performance-critical systems: When building a database or real-time system, knowing an operation is Θ(n log n) tells you *exactly* how it scales.; Lesson 301 — Practical Applications of Tight Bounds
Performing a new action: If you make a new change after undoing, the redo stack gets cleared (you can't redo something you've moved past).; Lesson 371 — Undo/Redo Functionality
Periodic sync: Each replica regularly picks random peers; Lesson 2704 — Anti-Entropy and Gossip Protocols
Permanent branches: Lesson 2197 — Gitflow Workflow
permission bits: that specify what operations are allowed on that page.; Lesson 1348 — Memory Protection with Virtual Memory Lesson 1381 — Segmentation with Protection and Sharing
permissions: .; Lesson 1381 — Segmentation with Protection and Sharing Lesson 1388 — File Attributes and Metadata Lesson 1397 — File Control Blocks and Inodes Lesson 2525 — Access Control Lists (ACLs)
permutation: problem—you're selecting *and ordering* items from a larger set, where each item can only be used once.; Lesson 99 — Permutations: Arrangements Without Repetition Lesson 737 — What is Sorting?Lesson 858 — Generating All Permutations
Permutation (ShiftRows): Shift rows of the data block in different amounts; Lesson 2401 — AES: The Advanced Encryption Standard
Permutations: Arrangements Without Repetition: (the previous lesson), order *mattered*—ABC was different from BAC.; Lesson 100 — Combinations: Selections Without Order
Persistence: Data survives after your program exits or the machine reboots; Lesson 1386 — File Abstraction and Basic Operations Lesson 2713 — Queue Persistence and Durability
Persistent data structures: solve this by sharing unchanged parts between versions.; Lesson 2145 — Persistent Data Structures
Personal information: Names, birthdays, pet names are in attacker dictionaries; Lesson 2511 — Password Strength and Entropy
phantom read: occurs when Transaction A runs the same query twice, but the second time sees *additional rows* (or fewer rows) because Transaction B inserted or deleted rows that match A's query criteria.; Lesson 1661 — Read and Write Conflicts Lesson 1671 — Phantom Reads Problem
Phantom reads: Transaction A queries rows matching a condition twice, but Transaction B inserted new matching rows in between; Lesson 1660 — Isolation: Concurrent Transaction Independence Lesson 1666 — Read Uncommitted Isolation Level Lesson 1672 — Serializable Isolation Level
Phase 1 - Prepare: Coordinator asks all participants if they can commit (same as 2PC); Lesson 2654 — Three-Phase Commit Improvements
Phase 1 (Prepare): Coordinator asks all participants "Can you commit?; Lesson 2720 — Three-Phase Commit (3PC)
Phase 1 Skipping: As long as no failures occur, this leader can skip Phase 1 for subsequent decisions and jump straight to Phase 2 (accept/accepted); Lesson 2681 — Multi-Paxos: Optimizing for Multiple Decisions
Phase 1: Mark: Lesson 2096 — Mark-and-Sweep Collection
Phase 1: Push zeros: Lesson 1833 — Designing PDAs for Simple Languages
Phase 1a: Prepare Request: .; Lesson 2675 — Phase 1a: Prepare Request
Phase 2 - Pre-Commit: If all vote YES, coordinator sends "prepare-to-commit" to all participants.; Lesson 2654 — Three-Phase Commit Improvements
Phase 2 (Pre-Commit): If all vote YES, the coordinator sends PRE-COMMIT to all participants.; Lesson 2720 — Three-Phase Commit (3PC)
Phase 2: Sweep: Lesson 2096 — Mark-and-Sweep Collection
Phase 3 - Commit: Coordinator sends final commit instruction; Lesson 2654 — Three-Phase Commit Improvements
Phase 3 (Commit): Coordinator sends the final COMMIT message.; Lesson 2720 — Three-Phase Commit (3PC)
Phase 3: Verify completion: Lesson 1833 — Designing PDAs for Simple Languages
Phase Modulation (PM): Shift the wave's phase.; Lesson 1443 — Signal Encoding and Modulation
Phishable: Social engineering can trick users into revealing them; Lesson 2517 — Knowledge Factors (Something You Know)
Phishing: Attackers trick you into revealing the code on fake login pages; Lesson 2521 — SMS and Email-Based MFA
Phishing susceptibility: Same risk as SMS; Lesson 2521 — SMS and Email-Based MFA
Phrase-Level Recovery: Lesson 1972 — LR Parser Error Recovery
physical address: in actual RAM—say, `0x4A3000`.; Lesson 1339 — What is Virtual Memory?Lesson 1342 — Virtual vs Physical Address Spaces Lesson 1354 — Address Translation in Paging
Physical addressing: Using MAC (Media Access Control) addresses to identify source and destination on the local network segment; Lesson 1434 — OSI Layer 2: Data Link Layer
Physical component: The actual wall-clock time (e.; Lesson 2636 — Hybrid Logical Clocks
Physical connectors: The shape and pin layout of network jacks (like RJ-45 Ethernet ports); Lesson 1441 — Physical Layer Overview
Physical distance: Data must travel shorter distances for faster access; you can't fit as much storage physically close to the CPU; Lesson 1108 — Speed vs Capacity Tradeoff
Physical Layer: – Transmits raw bits over physical media (cables, radio waves); Lesson 1432 — The OSI Model: Seven-Layer Overview Lesson 1433 — OSI Layer 1: Physical Layer Lesson 1440 — Encapsulation and Layer Communication
Physical operations: are involved (imagine sorting physical packages on a conveyor belt—minimizing movements saves time and energy); Lesson 746 — Selection Sort: Minimizing Swaps
Physical topology: How devices are physically connected (star, bus, ring); Lesson 1433 — OSI Layer 1: Physical Layer
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
PINs (Personal Identification Numbers): Short numeric codes (like your ATM code); Lesson 2517 — Knowledge Factors (Something You Know)
Pipeline efficiency: tells you how close your real-world performance is to the ideal case where every stage is always busy.; Lesson 1189 — Pipeline Efficiency and Utilization
Pipeline hazards: are conditions that prevent the next instruction from executing in its designated clock cycle.; Lesson 1160 — Introduction to Pipeline Hazards
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
pipeline stall: (also called a **pipeline bubble**) is an intentional delay inserted into the pipeline.; Lesson 1168 — Pipeline Stalls and Bubbles Lesson 1170 — Forwarding Paths and Limitations
pipeline stalls: .; Lesson 1169 — Data Forwarding (Bypassing)Lesson 1172 — Control Hazards: Branch Impact
Pipeline stalls from hazards: Data hazards, structural hazards, and control hazards all force the pipeline to insert bubbles, wasting cycles; Lesson 1186 — Cycles Per Instruction (CPI)
Pipeline utilization: measures what percentage of your pipeline stages are doing useful work in each clock cycle.; Lesson 1189 — Pipeline Efficiency and Utilization
pivot: (often the last element, first element, or middle one).; Lesson 257 — Partitioning Arrays Around a Pivot Lesson 763 — The Partition Operation: Core of Quicksort
PKCE: (Proof Key for Code Exchange, pronounced "pixy") extends the Authorization Code Grant for public clients.; Lesson 2537 — OAuth 2.0 Grant Types: Implicit and PKCE
PKCS#7: (Public-Key Cryptography Standards #7) is one of the earliest formats for packaging signed data.; Lesson 2440 — Digital Signature Standards and Formats
Place at correct index: For each node at position `i`, store its value at `array[i]`; Lesson 467 — Converting Between Representations
Place the new value: at index `n` (the next open spot); Lesson 587 — Implementing Heap Insert
Plain English: Any set of attributes functionally determines its own subsets.; Lesson 1626 — Armstrong's Axioms: Reflexivity, Augmentation, Transitivity Lesson 1627 — Additional Inference Rules: Union, Decomposition, Pseudotransitivity
Plain-English example: Lesson 170 — Nested Conditionals
Plaintext storage: means saving passwords exactly as users type them, unprotected in your database.; Lesson 2504 — Password Storage Fundamentals
Plan A: Full table scan (cost: 1000 disk reads if table has 100,000 rows); Lesson 1699 — Cost-Based Query Optimization
Plan B: Hash index lookup (cost: 3 disk reads if statistics show high selectivity); Lesson 1699 — Cost-Based Query Optimization
Platform Independent: LLVM IR abstracts away machine-specific details, letting the same IR run through optimizations regardless of whether you're targeting x86, ARM, or another architecture.; Lesson 2045 — LLVM IR Overview
Playlist: Songs play in the order they were added; Lesson 375 — Queue ADT Definition and FIFO Principle
Playwright: is Microsoft's modern contender, offering cross-browser testing (Chrome, Firefox, Safari) with one API.; Lesson 2249 — E2E Testing Tools and Frameworks
Ply: is a single move by one player.; Lesson 2765 — Game Trees and Ply Depth
pointer: , you work with the *address* of where data lives.; Lesson 317 — Pointers vs Direct Variables Lesson 322 — Dynamic Memory Allocation Basics Lesson 324 — Introduction to Linked Lists
Pointer overhead: Often 50-75% of total memory goes to structural pointers rather than data; Lesson 525 — Space Complexity of BSTs
Pointers to data blocks: the disk addresses where the file's actual content lives; Lesson 1397 — File Control Blocks and Inodes
Policies: are written in a declarative language (like XACML or Rego); Lesson 2529 — Policy-Based Access Control
Polymorphism: (literally "many forms") means you can treat objects of different classes uniformly if they share a common parent.; Lesson 2127 — Method Overriding and Polymorphism
Polynomial algorithms: (in P): O(n), O(n²), O(n³), O(n log n); Lesson 1899 — The Class P: Polynomial Time
Polynomial Features: Create interactions like `x1 * x2` or powers like `x1²` to capture non-linear relationships.; Lesson 2836 — Feature Engineering for Logistic Regression
Polynomial Hierarchy: generalizes NP and coNP by allowing *multiple alternations* of existential ( ∃) and universal ( ∀) quantifiers.; Lesson 1910 — Beyond NP: The Polynomial Hierarchy
Polynomial rolling hash: solves this by making *position matter*.; Lesson 412 — Polynomial Rolling Hash for Strings
polynomial time: relative to the DFA size and input length.; Lesson 1811 — Decision Properties of Regular Languages Lesson 1889 — The Class P (Polynomial Time)
Pooling small integers: (-5 to 256) and short strings—they're never deallocated, avoiding count operations entirely; Lesson 2110 — Reference Counting in Practice
Poor cache locality: (following pointers jumps around memory); Lesson 639 — Burst Tries
Poor example: Lesson 2173 — Committing Changes
Poor hash function: If your hash function maps all keys to the same bucket (or a few buckets), you've essentially created a linked list.; Lesson 434 — Worst-Case Time Complexity Scenarios
Poor key choice: Using sequential IDs as hash keys when most writes are recent records; Lesson 2690 — Handling Data Skew and Hotspots
Poor Naming: Variables or functions with unclear purposes; Lesson 2329 — Introduction to Code Smells
Poor scalability: Searching through thousands of files in one flat list becomes painfully slow; Lesson 1412 — Single-Level Directory Structure
Poor spatial locality: (not processing nearby elements together); Lesson 805 — Cache-Friendly Sorting Techniques
pop: Remove and return the element from the top of the stack; Lesson 356 — The Stack ADT Definition Lesson 358 — Pop Operation Lesson 360 — IsEmpty Operation Lesson 362 — Array-Based Stack Implementation Lesson 363 — Linked List-Based Stack Implementation Lesson 365 — Expression Evaluation: Infix, Prefix, Postfix Lesson 370 — Backtracking with Stacks Lesson 480 — Iterative Preorder with Stack (+3 more)
Pops the return address: from the stack; Lesson 1103 — Function Calls and the CALL Instruction
Port: Lesson 1455 — Switch Learning and Forwarding Lesson 1562 — Database Connection and Basic Structure
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 Lesson 1542 — TCP Socket Creation and Binding
port numbers: to identify specific applications—think of the IP address as a building's street address, and the port as the apartment number inside.; Lesson 1436 — OSI Layer 4: Transport Layer Lesson 1483 — TCP Port Numbers and Multiplexing Lesson 1488 — UDP Port Numbers and Multiplexing
Portability: Bytecode runs on any platform with the appropriate VM ("write once, run anywhere"); Lesson 2033 — Bytecode Compilation: The Hybrid Approach Lesson 2037 — What is an Intermediate Representation (IR)?
Position beyond list length: Check bounds or handle gracefully (some implementations insert at the tail).; Lesson 331 — Inserting at a Specific Position
Position-sensitive: The string's order matters naturally; Lesson 411 — Hashing Strings: Basic Approach
Positive demand: (`d(v) > 0`): the node *needs* that much flow delivered; Lesson 1054 — Circulation with Demands
Positive infinity: (`+∞`): Results from operations like `1.; Lesson 1068 — Special Floating-Point Values: Infinity and NaN
possession factor: is the second type of authentication factor in multi-factor authentication (MFA).; Lesson 2518 — Possession Factors (Something You Have)Lesson 2522 — Push Notification-Based MFA
POST: is used to *submit* data to the server, typically to create or update a resource.; Lesson 1516 — HTTP Methods: GET and POST Lesson 1517 — HTTP Methods: PUT, DELETE, and Others Lesson 1528 — RESTful API Design with HTTP
Post-pruning: takes the opposite approach: let the tree grow to full depth, then systematically *remove* branches that don't improve performance on validation data.; Lesson 2850 — Pruning: Pre-pruning vs Post-pruning
Postfix: (`x++` or `x--`): Use the current value in the expression *first*, then modify the variable; Lesson 161 — Increment and Decrement Operators
Postfix (Reverse Polish notation): operator comes *after* operands → `3 4 +`; Lesson 365 — Expression Evaluation: Infix, Prefix, Postfix
Postfix evaluation: is beautifully suited for stacks:; Lesson 365 — Expression Evaluation: Infix, Prefix, Postfix
PostgreSQL: supports hash indexes explicitly with `CREATE INDEX USING hash`, though B-trees remain the default.; Lesson 1696 — Hash Indexes in Practice
Power consumption: Faster memory requires more energy, limiting how much you can deploy; Lesson 1108 — Speed vs Capacity Tradeoff Lesson 1134 — Comparing Associativity Tradeoffs Lesson 1136 — Associativity Impact on Conflict Misses
power set: of a set is the set that contains every possible subset of the original set, including the empty set and the set itself.; Lesson 61 — Power Sets Lesson 859 — Generating All Subsets
Practical concern: We've all encountered frozen programs.; Lesson 1878 — What is the Halting Problem?
Practical performance: Most real CPUs use 4-way, 8-way, or 16-way set-associative caches in their L1, L2, and L3 levels; Lesson 1132 — Set-Associative Caches
Practical speed: On random data, randomized quicksort typically runs 2-3× faster than mergesort due to lower constant factors and better cache behavior.; Lesson 774 — Quicksort vs Mergesort: Practical Comparison
Practical validity: It accurately describes what real computers can and cannot do; Lesson 1867 — Implications and Universal Acceptance
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-image resistant: Given a hash, it should be computationally infeasible to find the original input; Lesson 2420 — What is a Hash Function?
Pre-pruning: (also called "early stopping") means you stop the recursive partitioning process *before* the tree is fully grown.; Lesson 2850 — Pruning: Pre-pruning vs Post-pruning
Precedence: determines which operators are evaluated first when multiple operators appear in the same expression.; Lesson 155 — Operator Precedence and Associativity
Precise: in pinpointing failures; Lesson 2224 — What is Unit Testing?Lesson 2321 — Rename Variable/Method: Improving Semantic Clarity
Precision: Lesson 1070 — Hardware Trade-offs in Number Representation Lesson 2804 — Performance Metrics Selection Lesson 2835 — Evaluating Logistic Regression Models
Precision Time Protocol (PTP): , defined in IEEE 1588, achieves synchronization in the **microsecond or even nanosecond range** within a local network.; Lesson 2635 — Precision Time Protocol (PTP)
Precompute: the prefix function for the pattern (O(m) time); Lesson 835 — KMP: Pattern Matching Algorithm
Predecessor: The largest key in the left subtree (rightmost value if you went left); Lesson 1684 — Deletion from Internal Nodes
predictability: over maximum inference.; Lesson 2016 — Type Inference in Modern Languages Lesson 2116 — Sequential Control Flow
Predictability depends on consistency: When teams work at a sustainable pace, velocity becomes stable and planning becomes reliable.; Lesson 2368 — Sustainable Development Pace
Predictable: No hidden state changes; Lesson 2132 — Pure Functions and Immutability
Predictable behavior: No risk of stack overflow on large inputs; Lesson 760 — Bottom-Up Mergesort
Predictable file paths: `/invoices/user_123_invoice.; Lesson 2484 — Insecure Direct Object References (IDOR)
Predictable height: A complete binary tree with *n* nodes always has height ⌊log₂ n⌋, keeping operations fast; Lesson 576 — Complete Binary Tree Property
Predictable identifiers: Your account page is `/account?; Lesson 2488 — Broken Access Control
Predictable maximum wait: approximately one full scan cycle; Lesson 1426 — C-SCAN (Circular SCAN)
Predictable parse tree height: A string of length *n* has derivations with exactly *2n - 1* steps; Lesson 1820 — Chomsky Normal Form (CNF)
Predictable performance: When you absolutely cannot tolerate worst-case slowdowns (real-time systems, embedded devices), mergesort's consistency wins.; Lesson 774 — Quicksort vs Mergesort: Practical Comparison Lesson 777 — Heapsort Overview and Motivation Lesson 2121 — Imperative Style Tradeoffs
Predictable space: you allocate the entire table upfront; Lesson 917 — Tabulation (Bottom-Up DP)
Predictable substitutions: "P@ssw0rd" adds minimal entropy because attackers check these patterns; Lesson 2511 — Password Strength and Entropy
Predictable worst-case performance: Heapsort guarantees O(n log n) time complexity *always*, unlike quicksort which can degrade to O(n²).; Lesson 608 — Practical Considerations for Heapsort
Prediction: Based on the high-order bit (0 = predict not taken, 1 = predict taken); Lesson 1179 — Two-Bit Saturating Counter Predictor Lesson 1846 — Earley Parsing Algorithm
Prediction phase: O(n) — all the heavy lifting happens here; Lesson 2869 — Computational Complexity of KNN
predictive parsing: (like LL(1) parsers), which make decisions based on a limited lookahead.; Lesson 1842 — Left Factoring Lesson 1958 — LL(1) Grammars
Preemptive: A teacher can tap the student on the shoulder after their time is up and give someone else a turn, ensuring fairness.; Lesson 1243 — Preemptive vs Non-Preemptive Scheduling Lesson 1244 — Scheduling Decision Points Lesson 1253 — Shortest Job First (SJF) Scheduling Lesson 1256 — Priority Scheduling Fundamentals Lesson 1257 — Priority Scheduling: Preemptive vs Non-Preemptive
Preemptive priority scheduling: is more aggressive.; Lesson 1257 — Priority Scheduling: Preemptive vs Non-Preemptive
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
Prefer eventual consistency patterns: like Sagas or event sourcing when you can tolerate temporary inconsistency.; Lesson 2726 — Best Practices for Distributed Transactions
Prefer local placement: Try to schedule on a CPU in the same NUMA node as the process's memory; Lesson 1268 — NUMA-Aware Scheduling
Prefer prime numbers: (like 7, 13, 101): Primes distribute keys more evenly and reduce patterns that cause collisions; Lesson 408 — The Division Method
Prefetching Awareness: Lesson 805 — Cache-Friendly Sorting Techniques
Prefix: (`++x` or `--x`): Modify the variable *first*, then use the new value in the expression; Lesson 161 — Increment and Decrement Operators
Prefix (Polish notation): operator comes *before* operands → `+ 3 4`; Lesson 365 — Expression Evaluation: Infix, Prefix, Postfix
Prefix evaluation: works similarly to postfix, but you scan right-to-left instead.; Lesson 365 — Expression Evaluation: Infix, Prefix, Postfix
prefix function: (also called the "failure function") is an array that stores, for each position in the pattern, the length of the longest proper prefix that is also a suffix.; Lesson 834 — Knuth-Morris-Pratt: Prefix Function Lesson 835 — KMP: Pattern Matching Algorithm
Prefix operations are natural: Finding all words starting with "cat" means traversing to that prefix once, then collecting everything below it.; Lesson 619 — What is a Trie? Motivation and Use Cases
Prefix-Based Enumeration: Lesson 627 — Trie Traversal Patterns
Preimage resistance: protects password storage—attackers can't reverse hashes; Lesson 2421 — Properties of Cryptographic Hash Functions Lesson 2422 — Preimage Resistance (One- Wayness)Lesson 2423 — Second Preimage Resistance Lesson 2427 — SHA-2 Family Lesson 2505 — Cryptographic Hash Functions for Passwords
Premature Optimization Anti-Pattern: occurs when developers focus on making code faster or more efficient *before* knowing where the actual performance bottlenecks are.; Lesson 2305 — Premature Optimization Anti-Pattern
Prenex Normal Form (PNF): does something similar with logical formulas—it pulls all quantifiers to the front in one neat bundle.; Lesson 57 — Prenex Normal Form
Preprocessing: Lesson 839 — Multiple Pattern Matching: Aho-Corasick
Prerequisite operations: Many graph and database algorithms require sorted input; Lesson 737 — What is Sorting?
Presentation Layer: – Handles data formatting, encryption, and compression; Lesson 1432 — The OSI Model: Seven-Layer Overview Lesson 1437 — OSI Upper Layers: Session, Presentation, Application
Preserve information: Every decomposition must be lossless—joins should reconstruct original data; Lesson 1644 — Practical Normalization Process
Preserve the subtree: That child represents an entire subtree that must remain in the tree; Lesson 509 — BST Deletion: One Child Case
Pressure and deadlines: "We'll fix it later" becomes never; Lesson 2301 — Introduction to Anti-Patterns
Pretends: to grant the request (temporary state); Lesson 1324 — The Banker's Algorithm
Prevent leaks: Ensure every allocation eventually gets freed, even when errors occur; Lesson 2084 — Manual Memory Management Overview
Prevent starvation: – Don't always pick the same victim; Lesson 1327 — Deadlock Recovery Strategies
Prevention: (breaking Coffman conditions): restricts resource usage patterns, often reducing concurrency; Lesson 1328 — Ostrich Algorithm and Practical Approaches
Previous best move: from iterative deepening; Lesson 2769 — Move Ordering in Alpha-Beta
Previous pointer: Points to the previous node in the list; Lesson 339 — Doubly Linked List Structure and Node Design
Price Manipulation: An e-commerce site sends the product price to the client-side form.; Lesson 2493 — Business Logic Vulnerabilities
Prim's: Each edge crosses from the growing tree to unexplored vertices (another cut); Lesson 1013 — Cut Property and MST Correctness
Prim's algorithm: grows the MST from a single vertex, always adding the cheapest edge that extends the current tree.; Lesson 1020 — Comparing Kruskal's and Prim's Algorithms
Primality testing: (checking if a number is prime); Lesson 1890 — Examples of Problems in P
primary clustering: .; Lesson 424 — Linear Probing: Clustering Problem Lesson 436 — Open Addressing Performance Characteristics Lesson 437 — Primary and Secondary Clustering Effects
primary key: is a special column (or combination of columns) in a database table that uniquely identifies every single row.; Lesson 1555 — Primary Keys Lesson 1556 — Foreign Keys and References Lesson 1614 — Key Attributes and Identifiers Lesson 1630 — Using FDs to Identify Candidate Keys Lesson 1744 — Apache Cassandra: Architecture and Use Cases
Primary keys: → `PRIMARY KEY` constraint; Lesson 1560 — From Relational Model to SQL
Primary node: receives the write; Lesson 1733 — Replication in Key-Value Stores
Primitive Obsession: occurs when you use basic data types like `int`, `string`, or `float` to represent domain concepts that deserve their own small classes or types.; Lesson 2335 — Primitive Obsession Smell
primitive operations: the simplest, indivisible actions a computer performs.; Lesson 271 — Counting Primitive Operations Lesson 273 — Input Size as a Variable
Primitive recursion: Define functions using "previous values" (like factorial: n!; Lesson 1863 — Alternative Models: Recursive Functions
primitive types: (also called *basic types* or *built-in types*) are the simplest, most fundamental data types provided directly by the language.; Lesson 1986 — Primitive Types Lesson 1987 — Composite Types: Products
Principal: The user or group (e.; Lesson 2525 — Access Control Lists (ACLs)
Principle of Locality: explains a fundamental pattern in how programs access memory: they tend to reuse the same data items repeatedly and access data stored near each other.; Lesson 1118 — Principle of Locality Lesson 1120 — Cache Lines and Blocks
Print: all elements in a meaningful order; Lesson 468 — What is Tree Traversal?
Printer queue: Documents sent to a printer are processed in the order they arrive; Lesson 375 — Queue ADT Definition and FIFO Principle
Prioritize critical paths: Not every integration scenario deserves a test.; Lesson 2245 — Integration Test Maintenance and CI
priority: .; Lesson 1259 — Multilevel Queue Scheduling Lesson 1505 — DNS Record Types: CNAME and MX
Priority conventions: vary by system:; Lesson 1256 — Priority Scheduling Fundamentals
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 Lesson 2566 — Introduction to Lock-Free Programming
Priority inversion matters: Lock-free prevents lower-priority threads from blocking higher-priority ones; Lesson 2574 — Performance Characteristics of Lock-Free Algorithms
priority queue: is a data structure where each element has an associated priority, and elements are dequeued in order of their priority, not their arrival time.; Lesson 389 — Priority Queues Introduction Lesson 609 — Priority Queue ADT Overview Lesson 610 — Heap as Priority Queue Implementation Lesson 2746 — Uniform-Cost Search
Priority queues: (when implemented as balanced BSTs); Lesson 502 — BST Advantages and Use Cases
Priority Scheduling: , every process is assigned a **priority number** (often an integer), and the CPU scheduler always selects the process with the highest priority to run next.; Lesson 1256 — Priority Scheduling Fundamentals Lesson 1259 — Multilevel Queue Scheduling Lesson 1261 — Comparing Scheduling Algorithm Performance
private: , reserved exclusively for use within local networks (your home, office, or campus network).; Lesson 1465 — Private and Public IP Address Ranges Lesson 2517 — Knowledge Factors (Something You Know)
Private constructor: prevents outside code from creating new instances with `new`; Lesson 2265 — Singleton Pattern: Ensuring Single Instance
private key: that must be kept secret; Lesson 2405 — Public Key Cryptography Concept Lesson 2408 — RSA Algorithm: Key Generation Lesson 2409 — RSA Algorithm: Encryption and Decryption Lesson 2435 — RSA Digital Signature Scheme
Private key (x): a random integer between 1 and q-1; Lesson 2437 — DSA (Digital Signature Algorithm)
Private keys: Alice picks a secret number `a`, Bob picks secret number `b`; Lesson 2411 — Diffie-Hellman Key Exchange
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
Probability: 10/100 = 0.; Lesson 110 — Computing Basic Probabilities Lesson 433 — Average-Case Time Complexity Analysis Lesson 685 — Weighted and Unweighted Graphs Lesson 2827 — The Sigmoid Function
Probability Mass Function (PMF): is a function that tells you the probability of each possible value for a discrete random variable.; Lesson 122 — Probability Mass Functions (PMF)Lesson 124 — Bernoulli Distribution
Problem: This gives us two representations of zero (`00000` and `10000`), which is awkward for calculations.; Lesson 10 — Signed Integer Representation Lesson 1870 — Examples of Decidable Problems Lesson 1891 — The Class NP (Nondeterministic Polynomial)Lesson 1893 — Examples of Problems in NP Lesson 1901 — Verifiers and Certificates Lesson 2734 — Search Problem Formulation
Problem without mutex: Between checking the condition and waiting, another thread could change the state and signal— but you'd miss that signal and wait forever.; Lesson 1307 — Condition Variables with Mutexes
Proceed: when condition is true, still holding the lock; Lesson 1306 — The Wait-Signal Pattern Lesson 2621 — Consistency vs Availability Tradeoffs
Process: the current node (print it, add to a list, etc.; Lesson 470 — Implementing Preorder Recursively Lesson 481 — Iterative Inorder with Stack Lesson 696 — BFS with Adjacency List Lesson 723 — Kahn's Algorithm: Implementation Lesson 1199 — Core OS Services: Process Management Lesson 1215 — What is a Process?Lesson 1216 — Process Components: Memory Layout Lesson 1231 — Threads vs Processes (+1 more)
Process A: performs `wait()` on the semaphore → immediately blocks (because the value is 0); Lesson 1297 — Signaling and Event Notification Lesson 2612 — Sequential Consistency
Process B: does its work, then calls `signal()` → increments the semaphore to 1; Lesson 1297 — Signaling and Event Notification Lesson 2612 — Sequential Consistency
Process C: reads X twice; Lesson 2612 — Sequential Consistency
Process chronologically: Extract the minimum event, handle it (update system state), and potentially insert new future events; Lesson 612 — Event-Driven Simulation
Process Control: Lesson 1206 — System Call Categories
process control block (PCB): storing the process's state (like an ID card with vital info); Lesson 1199 — Core OS Services: Process Management Lesson 1217 — Process Control Block (PCB)
Process current node: do whatever you need (print, store, etc.; Lesson 473 — Implementing Inorder Recursively
process ID (PID): Lesson 1199 — Core OS Services: Process Management Lesson 1217 — Process Control Block (PCB)Lesson 1228 — Process IDs and Identification
Process in topological order: For each node `u`:; Lesson 950 — DP on DAGs: Longest Path
Process isolation: comes naturally: Process A's page table simply doesn't contain entries mapping to Process B's physical frames.; Lesson 1348 — Memory Protection with Virtual Memory
Process iteratively: Remove a vertex from the queue, add it to your sorted result, and decrease the in-degree of all its neighbors by 1; Lesson 722 — Kahn's Algorithm: Basic Idea
Process nodes: (circles): Represent active processes in the system; Lesson 1316 — Resource Allocation Graphs
Process requests fail: even when aggregate free space is sufficient; Lesson 1336 — Fragmentation in Contiguous Allocation
Process state: Whether the process is running, ready, waiting, etc.; Lesson 1217 — Process Control Block (PCB)
Process the current node: Access or print the data stored in `current`.; Lesson 327 — Traversing a Linked List Lesson 469 — Preorder Traversal: Root-Left-Right
Processes: are isolated from each other.; Lesson 1231 — Threads vs Processes
Processing: The ALU's internal circuits execute the operation on the binary inputs; Lesson 1072 — The Arithmetic Logic Unit (ALU)Lesson 2268 — Factory Method: Parameterized Creation
Processing speed: CPUs handle smaller data faster; Lesson 152 — Memory and Variable Storage
Processor A: reads a value from memory address X into its cache (value = 5); Lesson 1124 — Cache Coherence Problem
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 Lesson 1268 — NUMA-Aware Scheduling
Processor B: also reads the same address X into its cache (value = 5); Lesson 1124 — Cache Coherence Problem
Produce the final result: in a designated location; Lesson 2054 — Code Generation for Expressions
Produce unintelligible error messages: When inference fails deep in a chain of unifications, pinpointing the programmer's actual mistake becomes difficult; Lesson 2014 — Type Inference Limitations
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
Producer-consumer coordination: Tracking empty and full slots in a bounded buffer; Lesson 1292 — Semaphore Definition and Purpose
Producers: generate data and place it into a fixed-size buffer; Lesson 1298 — Producer-Consumer Problem with Semaphores
Product (interface): common interface for all objects the factory creates; Lesson 2267 — Factory Method Pattern Basics
product backlog: an ordered list of everything that might be needed in the product.; Lesson 2374 — Scrum Roles: Product Owner Lesson 2377 — Scrum Artifacts: Product Backlog
Product construction: solves this by creating a new DFA whose states are **ordered pairs** `(q₁, q₂)`, where `q₁` is a state from the first DFA and `q₂` is a state from the second.; Lesson 1784 — Combining Conditions with Product Construction Lesson 1805 — Closure Properties: Intersection
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 Lesson 2381 — Sprint Review
Product Rule: Sequential decisions (this AND then that); Lesson 98 — Counting Principles: Sum and Product Rules
Product SKU searches: `WHERE sku = 'WIDGET-42'`; Lesson 1696 — Hash Indexes in Practice
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
Production: "Is it safe to show customers?; Lesson 2391 — Deployment Pipelines and Stages
Production builds: Use `-O2` or `-O3` for maximum performance; Lesson 2073 — Optimization Levels and Pragmas
Products: (ProductID, ProductName); Lesson 1636 — Achieving Second Normal Form
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 Address Lesson 1217 — Process Control Block (PCB)Lesson 1230 — What is a Thread?
Program Counter (PC): is a special-purpose register inside the CPU that holds the memory address of the next instruction the processor should fetch and execute.; Lesson 1074 — Program Counter (PC)Lesson 1075 — Instruction Register (IR)Lesson 1086 — The Execute Stage Lesson 1182 — Local History Predictors
Program semantics: Same results for all valid inputs; Lesson 2060 — Optimization Phases and Safety
Progress: means that if no process is currently executing in its critical section, and some processes want to enter, *only those processes actively trying to enter* can participate in deciding who goes next.; Lesson 1276 — Progress and No Deadlock Lesson 1277 — Bounded Waiting Property
Prohibiting cycles entirely: (stay acyclic); Lesson 1420 — General Graph Directories and Cycle Issues
Project selection: Choosing which projects maximize profit given dependencies; Lesson 1032 — Applications of Maximum Flow
Projection functions: Select one input from many (like picking the 2nd argument); Lesson 1863 — Alternative Models: Recursive Functions
Projection-Join Normal Form (PJ/NF): , addresses a subtle form of redundancy that occurs when a table contains **join dependencies**.; Lesson 1643 — Fifth Normal Form (5NF) Overview
Projects with inexperienced teams: who benefit from structured, phase-by-phase guidance; Lesson 2354 — Waterfall Strengths and Limitations
Promises: not to accept any future proposals with numbers less than `n`; Lesson 2676 — Phase 1b: Promise Response
Promote the median: up to the parent node; Lesson 561 — Node Splitting During Insertion Lesson 1681 — Node Splitting During Insertion
Promote the middle key: upward; Lesson 562 — Splitting Root Nodes
Proof sketch: Given an NFA for `L`, we construct a new NFA for `L*` by:; Lesson 1804 — Closure Properties: Star and Complement
Proof strategy: Build an NFA that runs both original NFAs "in parallel" using nondeterminism.; Lesson 1803 — Closure Properties: Union and Concatenation
Propagate if needed: – If the parent is also full, repeat the split process upward; Lesson 1681 — Node Splitting During Insertion
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 Lesson 1837 — DPDA Limitations and Language Classes
properties: .; Lesson 69 — Properties of Relations: Reflexivity Lesson 1746 — Graph Database Model and Use Cases Lesson 1748 — Nodes and Properties Lesson 2150 — CSS: Declarative Styling
proposal number: (which you learned earlier must be unique and ordered) and sends a `PREPARE(n)` message to a majority of acceptors, where `n` is that proposal number.; Lesson 2675 — Phase 1a: Prepare Request Lesson 2677 — Phase 2a: Accept Request
proposer: sends a proposal → **acceptors** vote using majority quorums → **learners** discover the chosen value.; Lesson 2673 — Paxos Roles: Proposers, Acceptors, and Learners Lesson 2675 — Phase 1a: Prepare Request
Proposers: initiate the consensus process by suggesting values.; Lesson 2673 — Paxos Roles: Proposers, Acceptors, and Learners
Pros: Lesson 1398 — Directory Implementation Strategies Lesson 1470 — Static vs Dynamic Routing Protocols Lesson 1538 — Certificate Revocation: CRL and OCSP Lesson 1651 — Using Triggers and Application Logic Lesson 2581 — Concurrent Stack Implementations Lesson 2646 — Replication Topologies Lesson 2695 — Routing Requests to Shards Lesson 2721 — Saga Pattern for Long-Running Transactions
Protection: Process A cannot accidentally (or maliciously) read or write Process B's memory.; Lesson 1331 — The Address Space Abstraction Lesson 1340 — Address Translation Overview Lesson 1386 — File Abstraction and Basic Operations
protection fault: , stopping the rogue access before it corrupts another process's data.; Lesson 1333 — Memory Protection with Address Spaces Lesson 1348 — Memory Protection with Virtual Memory
Protection natural: Mark the code segment read-only, the stack no-execute; Lesson 1383 — Segmentation vs Paging Trade-offs
Protection Proxy: Control access based on permissions or credentials; Lesson 2280 — Proxy Pattern: Controlling Access to Objects
Protocol compatibility: Different versions might speak different "dialects"; Lesson 2596 — Heterogeneity of Hardware and Software
Prototype: Use when creating new instances by cloning is more efficient than construction from scratch, or when you need to avoid tight coupling to concrete classes.; Lesson 2273 — Choosing the Right Creational Pattern
Prototype Pattern: solves this by letting you copy (clone) an already-configured object instead of re-initializing everything.; Lesson 2272 — Prototype Pattern and Cloning
Provide actionable information: Tell the developer what values caused the problem and what values would be acceptable.; Lesson 2317 — Error Handling and Exception Messages
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 Lesson 2283 — Structural Pattern Trade-offs Lesson 2284 — Combining Structural Patterns
prune: branches we know won't contain any valid values.; Lesson 514 — Range Query in BST Lesson 2768 — Alpha-Beta Pruning
Pruning: means cutting off these dead-end branches *before* you fully explore them.; Lesson 865 — Pruning and Optimization Lesson 2850 — Pruning: Pre-pruning vs Post-pruning
Pseudo-header: Borrowed from the IP layer, it includes source IP, destination IP, protocol number, and UDP length.; Lesson 1489 — UDP Checksum Calculation and Verification
Pseudocode concept: Lesson 651 — Fenwick Tree Construction
PSPACE: contains problems solvable with polynomial space.; Lesson 1896 — Savitch's Theorem
PSPACE = NPSPACE: polynomial nondeterministic space equals polynomial deterministic space.; Lesson 1896 — Savitch's Theorem
PSPACE vs. EXP: Lesson 1897 — Complexity Class Hierarchy
Pthread mutexes: (mutual exclusion objects) are the most common way to implement locks in C programs using the POSIX threads library.; Lesson 1283 — Pthread Mutex Basics
PTP: provide physical time, but they can't guarantee causal ordering when clock skew exists.; Lesson 2636 — Hybrid Logical Clocks
Public exchange: Lesson 2411 — Diffie-Hellman Key Exchange
Public Key: The server's public key for asymmetric encryption; Lesson 1532 — Digital Certificates Fundamentals Lesson 2405 — Public Key Cryptography Concept Lesson 2408 — RSA Algorithm: Key Generation Lesson 2409 — RSA Algorithm: Encryption and Decryption Lesson 2435 — RSA Digital Signature Scheme Lesson 2439 — Signature Verification Process Lesson 2445 — Digital Certificates and Certificate Authorities
Public key (y): computed as g^x mod p; Lesson 2437 — DSA (Digital Signature Algorithm)
Public parameters: Alice and Bob agree on a large prime number `p` and a base `g` (these can be public); Lesson 2411 — Diffie-Hellman Key Exchange
Public static access method: a method like `getInstance()` returns the single instance, creating it only if it doesn't exist yet; Lesson 2265 — Singleton Pattern: Ensuring Single Instance
Pull migration: An idle processor *pulls* a waiting process from a busy processor's queue.; Lesson 1263 — Load Balancing Concepts Lesson 1264 — Push vs Pull Migration
Pull often: Sync with the remote branch regularly to catch conflicts early when they're easier to resolve; Lesson 2200 — Handling Merge Conflicts in Teams
Pull quantifiers outward: one by one until they're all at the front; Lesson 57 — Prenex Normal Form
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 Lesson 2198 — Forking Workflow
Pull request opened/updated: Run full test suite and code quality checks; Lesson 2385 — Version Control Integration
Pulls the latest code: from the repository; Lesson 2383 — What is Continuous Integration?
Pump: Consider xy²z = x(yy)z.; Lesson 1807 — Using the Pumping Lemma to Prove Non-Regularity
Pumping Lemma by contradiction: to formally prove that certain languages—like {0^n 1^n}—cannot be recognized by any DFA or regular expression.; Lesson 1807 — Using the Pumping Lemma to Prove Non-Regularity
Punctuation: (statement terminator); Lesson 1940 — Token Classification
Puppeteer: is Google's Node.; Lesson 2249 — E2E Testing Tools and Frameworks
Pure node: All 10 samples are class A → `p_A = 1.; Lesson 2842 — Impurity Measures: Entropy
Pure simplicity: This constraint enables blazing-fast lookups (often O(1)) and massive horizontal scalability.; Lesson 1728 — Key-Value Store Data Model
Purpose: One sentence describing what the function does; Lesson 192 — Function Documentation Lesson 1516 — HTTP Methods: GET and POST
push: Add an element to the top of the stack; Lesson 356 — The Stack ADT Definition Lesson 362 — Array-Based Stack Implementation Lesson 363 — Linked List-Based Stack Implementation Lesson 365 — Expression Evaluation: Infix, Prefix, Postfix Lesson 370 — Backtracking with Stacks Lesson 480 — Iterative Preorder with Stack Lesson 1043 — Push-Relabel Algorithm Basics Lesson 1044 — Push-Relabel Operations (+2 more)
Push Down: Before using any node, check its lazy value and apply pending updates to its children; Lesson 646 — Range Update with Lazy Propagation
Push migration: The OS periodically checks processor loads and actively *pushes* processes from overloaded cores to idle ones.; Lesson 1263 — Load Balancing Concepts Lesson 1264 — Push vs Pull Migration
Push negations inward: using De Morgan's Laws and quantifier negation rules; Lesson 57 — Prenex Normal Form
Push opening symbols: (`(`, `[`, `{`) onto the stack as you encounter them; Lesson 368 — Balanced Parentheses Checking
Push the left child: (if it exists); Lesson 480 — Iterative Preorder with Stack
Push the right child: (if it exists); Lesson 480 — Iterative Preorder with Stack
Push to any branch: Run basic tests; Lesson 2385 — Version Control Integration
Push your feature branch: to the remote repository; Lesson 2196 — Pull Requests and Code Review
Push-Relabel algorithm: takes a fundamentally different approach.; Lesson 1043 — Push-Relabel Algorithm Basics
Pushdown Automaton (PDA): is a computational model that recognizes context-free languages—the languages generated by context-free grammars.; Lesson 1828 — Introduction to Pushdown Automata
PUT: Updates or creates a resource at a specific URL.; Lesson 1517 — HTTP Methods: PUT, DELETE, and Others Lesson 1528 — RESTful API Design with HTTP
Puzzle solving: Finding minimum moves in games; Lesson 694 — BFS Overview and Applications
Python: Lesson 233 — Array Declaration and Initialization Lesson 2033 — Bytecode Compilation: The Hybrid Approach
Python Web Frameworks: Flask and Django use decorators (`@login_required`, `@cache_page`) to add authentication, caching, or logging to view functions without modifying them.; Lesson 2285 — Real-World Structural Pattern Examples
Python's `sorted()` and `list.sort()`: Use Timsort (a hybrid of mergesort and insertion sort), guaranteeing O(n log n) worst-case time and stability; Lesson 808 — Standard Library Sort Functions

Q

Q4.4 format: (4 integer bits, 4 fractional bits).; Lesson 1063 — Fixed-Point Number Representation
Quadratic: `n²` — quadruples when input doubles; Lesson 278 — Growth Rates and Dominant Terms
Quadratic probing: solves this by checking slots at *increasing* distances rather than just moving one slot at a time.; Lesson 425 — Quadratic Probing Lesson 436 — Open Addressing Performance Characteristics Lesson 437 — Primary and Secondary Clustering Effects Lesson 1691 — Collision Handling in Hash Indexes
Quality assurance: Ensuring the software maintains acceptable standards; Lesson 2214 — What is Software Testing?
Quality checks: How many rows have missing data?; Lesson 1592 — COUNT Function
Quantum computers change everything: In 1994, mathematician Peter Shor developed an algorithm that allows quantum computers to factor large numbers and solve discrete logarithms in polynomial time—turning a problem that takes millennia into one solvable in hours or days.; Lesson 2419 — Quantum Threats to Asymmetric Crypto
Queries return correct results: from actual tables; Lesson 2243 — Database Integration Testing
Query: data efficiently (retrieval); Lesson 1561 — SQL Introduction and Purpose
Query efficiently: for each new state, find the optimal line on the hull (binary search or amortized O(1) if queries are monotonic); Lesson 958 — Convex Hull Trick for DP
query optimizer: tries to pick the best join order automatically by:; Lesson 1585 — Join Order and Performance Lesson 1702 — Index Selection for Queries
Query patterns: Queries filtering by the partition key can go directly to one partition.; Lesson 2685 — Partition Keys and Shard Keys
Query Routing: Use metadata about partition keys to identify exactly which shards hold relevant data, querying only those shards.; Lesson 2692 — Cross-Shard Queries and Joins
Query side: Maintains materialized views optimized for reads, updated asynchronously from events; Lesson 2725 — Alternatives: Event Sourcing and CQRS
Query SSTables on disk: older data lives in one or more immutable files; Lesson 1741 — Read and Write Operations in Column Families
Query the directory: with the key; Lesson 2689 — Directory-Based Partitioning
Query Time: When querying, push down lazy updates along your path, ensuring accurate results; Lesson 646 — Range Update with Lazy Propagation
queue: is an abstract data type (ADT) that stores a collection of elements with a specific ordering rule: **First-In-First-Out (FIFO)**.; Lesson 375 — Queue ADT Definition and FIFO Principle Lesson 395 — Deque: Double-Ended Queue Fundamentals Lesson 399 — Deque vs Stack vs Queue Lesson 694 — BFS Overview and Applications Lesson 695 — BFS Algorithm Structure Lesson 698 — BFS Time and Space Complexity Lesson 723 — Kahn's Algorithm: Implementation Lesson 988 — SPFA: Shortest Path Faster Algorithm (+4 more)
Queue and schedule: Commands in a list can be executed sequentially, in batch, or scheduled for later.; Lesson 2291 — Command Pattern Fundamentals
Queue behavior: Enqueue at the back, dequeue from the front; Lesson 391 — Double-Ended Queue (Deque) Introduction
Queue/Stack: Stores vertices temporarily — at most V vertices; Lesson 727 — Time and Space Complexity
QUIC: (Quick UDP Internet Connections) is a transport protocol that runs on top of **UDP** instead of TCP.; Lesson 1527 — HTTP/3 and QUIC
Quick fixes: piled on quick fixes without refactoring; Lesson 2303 — Spaghetti Code Anti-Pattern
quicksort: achieve O(n log n) time by cleverly combining:; Lesson 286 — O(n log n): Linearithmic Time Lesson 607 — Heapsort vs Quicksort vs Mergesort Lesson 777 — Heapsort Overview and Motivation Lesson 784 — Heapsort vs Quicksort Comparison Lesson 799 — When to Use Which Sorting Algorithm Lesson 800 — Hybrid Sorting Strategies Lesson 806 — Parallel Sorting Algorithms Lesson 841 — Divide and Conquer Paradigm Overview
QUORUM: Majority of replicas must agree (balanced); Lesson 1743 — Consistency and Replication in Column Stores Lesson 2620 — Quorum-Based Consistency Lesson 2656 — Quorums and Majority Voting Lesson 2679 — Quorums and Majority Requirements
Quorum-based consistency: gives you a flexible answer.; Lesson 2620 — Quorum-Based Consistency

R

R (read quorum): How many replicas must participate in a read; Lesson 2620 — Quorum-Based Consistency
Rabin-Karp: Minimal preprocessing (compute pattern hash), simple to implement; Lesson 840 — String Searching Applications and Tradeoffs
race condition: occurs when two or more threads read and write shared data at the same time, and the final result depends on the unpredictable timing of their execution.; Lesson 1240 — Threading Challenges: Race Conditions Lesson 1241 — Threading Challenges: Synchronization Needs Lesson 1270 — What is a Race Condition?Lesson 2555 — Race Conditions
race conditions: .; Lesson 1275 — Mutual Exclusion Explained Lesson 1280 — Mutual Exclusion Problem Lesson 2493 — Business Logic Vulnerabilities Lesson 2554 — What is Thread Safety?Lesson 2561 — Synchronized Blocks and Methods
Radix Sort: achieve O(n) time.; Lesson 799 — When to Use Which Sorting Algorithm
Radix Trees (Compressed Tries): dramatically reduce node count by merging chains of single-child nodes into edges with string labels.; Lesson 640 — Trie Variant Performance Comparison
rainbow tables: precomputed lists of hashes for common passwords.; Lesson 2430 — Hash Function Applications: Password Storage Lesson 2505 — Cryptographic Hash Functions for Passwords Lesson 2506 — Salt: Defending Against Rainbow Tables
Raise an error/exception: (covered later, but the concept is signaling "I can't continue"); Lesson 205 — Parameter Type Checking and Validation
Raises exceptions: if something goes wrong (invalid address, permission violation); Lesson 1343 — Memory Management Unit (MMU)
RAM: (main memory where active programs live); Lesson 1112 — Volatile vs Non-Volatile Memory
Random: is the simplest but unpredictable, though it avoids worst-case scenarios that can trap other policies.; Lesson 1123 — Cache Replacement Policies Overview Lesson 1391 — Sequential vs Random Access Lesson 1453 — CSMA/CD Protocol
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 access patterns: (touching distant array elements); Lesson 805 — Cache-Friendly Sorting Techniques
Random data: Standard **Quicksort** typically performs best.; Lesson 799 — When to Use Which Sorting Algorithm
Random forests: solve this by introducing an additional layer of randomness: at each split in each tree, the algorithm only considers a *random subset* of features rather than all available features.; Lesson 2855 — Random Forests: Bagging with Decision Trees
Random guessing: Predict classes according to their distribution in training data; Lesson 2784 — Baseline Models and Evaluation
Random input: → balanced-ish tree → O(log n) operations; Lesson 527 — Impact of Insertion Order Lesson 770 — Average-Case Analysis: Expected Performance
Random number generators: (each thread needs independent state); Lesson 2559 — Thread-Local Storage
Random scatter around zero: Good—your model captures the pattern; Lesson 2825 — Evaluating Linear Regression Models
Random testing: Multiple independent test cases give you straightforward combined probabilities; Lesson 116 — Independent Events
Randomized approaches: trading certainty for speed; Lesson 1911 — Practical Impact of P vs NP
Randomized QuickSelect: chooses pivots randomly, making it extremely unlikely to hit the worst case repeatedly.; Lesson 824 — QuickSelect Analysis and Performance
Randomized Quicksort: doesn't change the algorithm itself—it simply picks the pivot *randomly* from the current subarray before partitioning.; Lesson 771 — Randomized Quicksort: Avoiding Worst Case
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 Lesson 1058 — One's Complement Representation Lesson 1070 — Hardware Trade-offs in Number Representation
Range Queries: Finding all values between two numbers becomes efficient—traverse inorder and collect values within your range.; Lesson 474 — Inorder and Binary Search Trees Lesson 502 — BST Advantages and Use Cases Lesson 2686 — Range-Based Partitioning
Range queries and ordering: Need to find all values between 50 and 100?; Lesson 530 — When to Use BSTs
Range sum/min/max queries: with frequent updates (stock prices, sensor data); Lesson 641 — Segment Tree Motivation and Use Cases
Range Update: When updating [L, R], propagate down only as far as needed, leaving lazy marks on relevant nodes; Lesson 646 — Range Update with Lazy Propagation
Range updates: (increase all elements in a range by a value); Lesson 641 — Segment Tree Motivation and Use Cases Lesson 654 — Range Query and Range Update
Range-based transitions: (min/max over intervals): Check if Knuth's quadrangle inequality holds.; Lesson 964 — Choosing the Right Optimization
ranges: "What's P(2 ≤ X ≤ 3)?; Lesson 127 — Continuous Random Variables and PDF Lesson 1773 — Character Classes and Ranges
Rare failure scenarios: are the killers.; Lesson 2599 — Testing and Debugging Difficulties
Rate limiting: Restrict reset requests per email/IP to prevent spam or enumeration attacks; Lesson 2513 — Password Reset Security Lesson 2514 — Credential Stuffing and Breach Detection
Rationale: This counterintuitive approach assumes that pages with low counts were probably just brought in and will be used more soon.; Lesson 1374 — Counting-Based Algorithms
Raw SQL queries: Many ORMs let you execute custom SQL.; Lesson 2481 — ORM and SQL Injection Protection
RBAC: (which assigns permissions based on roles), capabilities are:; Lesson 2532 — Capability-Based Security Lesson 2533 — Authorization Model Tradeoffs
RBAC hierarchies: let you define inheritance relationships between roles.; Lesson 2527 — RBAC Hierarchies
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?
React: , using JSX expressions like `{userInput}` automatically escapes content.; Lesson 2462 — XSS Prevention in Modern Frameworks
Read: the current value of `counter` from memory; Lesson 1271 — Demonstrating Race Conditions with Shared Counters Lesson 1299 — Readers-Writers Problem with Semaphores Lesson 1721 — CRUD Operations in Document Databases Lesson 2030 — Interpreter Execution Cycle: Parse and Execute
Read (r): View file contents or list directory contents; Lesson 1392 — File Permissions and Access Control
Read bit: Can the process read from this page?; Lesson 1348 — Memory Protection with Virtual Memory
Read Committed: isolation level, which prevents dirty reads but doesn't lock rows you've already read.; Lesson 1669 — Nonrepeatable Reads Problem Lesson 1674 — Isolation Level Trade-offs
Read from memory: The CPU sends the address stored in the PC to memory via the **Memory Address Register (MAR)**.; Lesson 1082 — The Fetch Stage
Read locks: (shared): Multiple threads can hold read locks simultaneously *as long as no writer holds the lock*.; Lesson 2563 — Read-Write Locks
Read optimization: Some designs use read-write locks per bucket, allowing multiple concurrent readers when no writes occur.; Lesson 2582 — Concurrent Hash Map: Basics
Read pointer: scans through every box, left to right; Lesson 255 — Removing Duplicates from Sorted Arrays
Read ports: Allow the CPU to fetch data from two (or more) registers at once.; Lesson 1080 — Register File Architecture
Read quorum (R): Must read from R nodes; Lesson 2656 — Quorums and Majority Voting
Read Repair: fixes inconsistencies opportunistically during read operations.; Lesson 2643 — Read Repair and Anti-Entropy Lesson 2705 — Read Repair and Hinted Handoff Lesson 2706 — Eventual Consistency in Practice: Dynamo and Cassandra
Read requests: can be handled by the leader *or* followers (depending on consistency requirements); Lesson 2639 — Leader-Based Replication
Read scalability: Followers can serve read traffic, distributing load; Lesson 2639 — Leader-Based Replication
Read the first symbol: Look at the leftmost character of your input string; Lesson 1780 — DFA Computation and Acceptance
Read Uncommitted: Fastest, but allows dirty reads—your data might be wrong.; Lesson 1674 — Isolation Level Trade-offs
Read-After-Write (RAW) hazard: also called a *data dependency* — happens when one instruction needs to read a register that a previous instruction hasn't finished writing to yet.; Lesson 1165 — Data Hazards: Read-After-Write (RAW)Lesson 1169 — Data Forwarding (Bypassing)
Read-committed across partitions: Each read might hit a different node at a different time.; Lesson 2723 — Distributed Transaction Isolation Levels
Read-heavy applications: If you query far more often than you update, some redundancy speeds up reads dramatically; Lesson 1645 — Normal Form Trade-offs
Read-heavy reporting queries: (dashboard metrics, analytics); Lesson 1653 — Hybrid Normalization Strategies
Read-heavy workloads: Your application performs far more SELECT queries than INSERT/UPDATE operations; Lesson 1646 — Introduction to Denormalization Lesson 1650 — OLTP vs OLAP Database Design Lesson 2563 — Read-Write Locks
Read-only files: Multiple processes can read the same file concurrently without interfering with each other; Lesson 1319 — Deadlock Prevention: Breaking Mutual Exclusion
Read-write dependency: If you read a value, then write based on it, there's a causal link; Lesson 2613 — Causal Consistency
Read-Your-Writes: (seeing your own writes).; Lesson 2617 — Monotonic Write Consistency Lesson 2623 — Measuring and Testing Consistency
Read-Your-Writes Consistency: (also called "read-after-write consistency") is a guarantee that focuses on a single client or process: after you successfully write a value, any read **you** perform afterward will reflect that write or something newer.; Lesson 2615 — Read-Your-Writes Consistency Lesson 2616 — Monotonic Read Consistency
Read/Write: Get or set a value atomically; Lesson 2557 — Atomic Operations
Readability: Code looks like regular variable access; Lesson 321 — Reference Parameters in Functions Lesson 868 — Recursive vs Iterative Tradeoffs Lesson 1610 — Common Table Expressions (CTEs)Lesson 2134 — Function Composition Lesson 2141 — Pattern Matching Lesson 2270 — Builder Pattern for Complex Objects Lesson 2319 — Extract Method: Breaking Down Complex Functions
readable: and **maintainable**.; Lesson 192 — Function Documentation Lesson 2348 — Reviewing Tests and Documentation
Reader logic: Lesson 1299 — Readers-Writers Problem with Semaphores Lesson 1311 — Reader-Writer Problem with CVs
Readers: Multiple readers can hold the lock simultaneously.; Lesson 1289 — Reader-Writer Locks Introduction
Reading immutable data: Safe, no critical section; Lesson 2556 — Critical Sections
Reading without writing: Usually safe (with caveats); Lesson 2556 — Critical Sections
README/design docs: Can someone new to the codebase understand how to use or modify this component?; Lesson 2348 — Reviewing Tests and Documentation
Reads: Lightning fast—no locks, no waiting, no contention.; Lesson 2585 — Copy-On-Write Collections Lesson 2693 — Secondary Indexes in Partitioned Systems
Ready: state.; Lesson 1218 — Process States: New and Ready Lesson 1219 — Process States: Running and Waiting
Ready → Running: Lesson 1221 — Process State Transitions
ready queue: .; Lesson 1247 — Waiting Time Lesson 1263 — Load Balancing Concepts
Real-time checks: During login or password change, query breach databases; Lesson 2514 — Credential Stuffing and Breach Detection
Real-time or database servers: Deadline (latency bounds critical); Lesson 1430 — I/O Schedulers in Operating Systems
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
Real-world analogy: Think of a power plug adapter when traveling abroad.; Lesson 2274 — Adapter Pattern: Converting Interfaces
Real-world programs: Code people actually run (web browsers, compilers, games); Lesson 1191 — Benchmark Programs and Performance Testing
Real-world use cases: Lesson 1713 — Graph Database Fundamentals
Reality check: MFU is rarely used in practice because this assumption often doesn't hold true.; Lesson 1374 — Counting-Based Algorithms
rear: is (where we add new items).; Lesson 378 — Array-Based Queue Implementation Lesson 382 — Linked List-Based Queue Implementation
Rear (or Tail): Where elements are added; Lesson 375 — Queue ADT Definition and FIFO Principle
Rear pointer: Points to the node at the tail of the queue (where we enqueue to); Lesson 382 — Linked List-Based Queue Implementation
Reasoning: Pure functions with no side effects compose predictably; Lesson 2134 — Function Composition Lesson 2144 — Referential Transparency
Rebalance: Keep heaps equal in size (or differ by 1) by moving the top element from one heap to the other; Lesson 615 — Median Maintenance with Two Heaps Lesson 2691 — Rebalancing Partitions
Rebalancing operations: when a node drops below minimum keys, you either **borrow** a key from a sibling (if possible) or **merge** with a sibling; Lesson 1682 — B-Tree Deletion Overview
Recalculate height: `height = 1 + max(left_child_height, right_child_height)`; Lesson 540 — Updating Heights After Insertion
Recalculate its balance factor: (height of left subtree minus height of right subtree); Lesson 539 — AVL Insertion Algorithm
Recall: Of all actual positives, how many did we catch?; Lesson 2804 — Performance Metrics Selection Lesson 2835 — Evaluating Logistic Regression Models
Receive a message: set your counter to `max(your_counter, message_counter) + 1`; Lesson 2628 — Lamport Timestamps
Receive buffer size: Limits how much data can be buffered; Lesson 1485 — TCP Performance Considerations
Receive message: Take the element-wise maximum of your vector and received vector, then increment your own counter; Lesson 2631 — Vector Clocks Fundamentals
Receive the shard location: from the directory; Lesson 2689 — Directory-Based Partitioning
Receiver verification: The receiver divides the received frame (data + CRC) by the same generator.; Lesson 1448 — Cyclic Redundancy Check (CRC)
Receives a virtual address: from the CPU during program execution; Lesson 1343 — Memory Management Unit (MMU)
Reclaim everything: left behind in the old from-space — it's all garbage; Lesson 2097 — Copying Collection
Recolor: after rotation:; Lesson 551 — Insertion Case 3: Uncle is Black, Line Configuration Lesson 553 — Deletion Cases: Red Sibling
Recoloring: Flipping node colors (red ↔ black) adjusts the tree without changing structure.; Lesson 548 — Red-Black Tree Insertion Overview Lesson 549 — Insertion Case 1: Uncle is Red
Recommendation systems: where finding "similar" users or items is the core task; Lesson 2872 — KNN in Practice: Applications and Limitations
Recompute hash values: for all existing elements (the hash function output depends on table size!; Lesson 428 — Load Factor and Rehashing
Recompute the hash: for each key using the new table size; Lesson 429 — Rehashing Process
Reconcile: Transfer missing or conflicting updates; Lesson 2704 — Anti-Entropy and Gossip Protocols
Reconnect: Link the deleted node's parent directly to this child; Lesson 509 — BST Deletion: One Child Case
Reconstruct the path: Walk backwards from destination to source using parent pointers, then reverse to get the forward path; Lesson 716 — Path Finding with DFS
Recovery: Balancing security with the ability to restore access; Lesson 2417 — Key Distribution and Management Lesson 2712 — Dead Letter Queues and Poison Messages
Rectangular matrix: (e.; Lesson 311 — Analyzing Multi-Dimensional Space
Recurrence: Lesson 929 — Coin Change: Number of Ways Lesson 932 — Subset Sum Problem Lesson 949 — Path Sums and Tree DP
recurrence relation: is a formula that defines each term of a sequence based on one or more previous terms.; Lesson 84 — Recurrence Relations Lesson 992 — Floyd-Warshall Dynamic Programming Formulation
recurrence relations: .; Lesson 842 — Recurrence Relations for Divide and Conquer Lesson 843 — Master Theorem Introduction
Recurse: Recursively sort the left part (elements smaller than pivot); Lesson 767 — Quicksort Recursive Implementation Lesson 2847 — Recursive Partitioning Algorithm
Recurse left: Call the function on the left child; Lesson 470 — Implementing Preorder Recursively Lesson 473 — Implementing Inorder Recursively
Recurse right: Call the function on the right child; Lesson 470 — Implementing Preorder Recursively Lesson 473 — Implementing Inorder Recursively
Recursion: is when a function calls *itself* during its own execution.; Lesson 217 — What is Recursion?Lesson 223 — Recursion vs Iteration Lesson 629 — Wildcard Matching in Tries
Recursion is advantageous when: Lesson 868 — Recursive vs Iterative Tradeoffs
Recursive algorithms: (e.; Lesson 84 — Recurrence Relations
Recursive approach: Say "5!; Lesson 223 — Recursion vs Iteration
Recursive calls: Solve the problem for left and right children (or all children in general trees); Lesson 853 — Divide and Conquer on Trees
Recursive case: Formula using previous term(s); Lesson 84 — Recurrence Relations Lesson 217 — What is Recursion?Lesson 218 — Base Case and Recursive Case Lesson 225 — Recursive Problem Decomposition Lesson 506 — BST Insertion: Recursive Approach Lesson 643 — Building a Segment Tree Lesson 755 — Implementing Mergesort Recursively Lesson 951 — DP on DAGs: Counting Paths (+4 more)
Recursive exploration: Call DFS on each unvisited neighbor; Lesson 710 — DFS Recursive Implementation
Recursive factorial function: Each call uses stack memory, up to n calls deep → **O(n)** space for the call stack.; Lesson 302 — What is Space Complexity?
recursive functions: Lesson 1860 — The Quest for a Formal Definition of Algorithm Lesson 1863 — Alternative Models: Recursive Functions Lesson 1864 — Equivalence of Computational Models
Recursive relation: `factorial(n) = n * factorial(n-1)`; Lesson 869 — Building Recursive Solutions from Scratch
Recursive step: Calculate metric for left and right subtrees; Lesson 492 — Calculating Tree Metrics Lesson 946 — Tree Diameter via DP
Recursively build: Process each valid index, creating nodes and linking them; Lesson 467 — Converting Between Representations
Recursively continue: until subarrays are empty; Lesson 520 — BST from Sorted Array
Recursively evaluate: these smaller polynomials at carefully chosen points; Lesson 854 — Fast Fourier Transform (FFT) Overview
Recursively find: the median of all those medians; Lesson 825 — Median of Medians: Deterministic Selection
Recursively sort: Apply quicksort to the left and right subarrays; Lesson 762 — Quicksort: The Divide-and-Conquer Sorting Strategy
red: , you have the simplest case to handle.; Lesson 549 — Insertion Case 1: Uncle is Red Lesson 551 — Insertion Case 3: Uncle is Black, Line Configuration Lesson 553 — Deletion Cases: Red Sibling
Red flags: Lesson 2312 — Comments: When and How to Use Them
Red-black trees: allow more height variation, using their color rules to ensure height is at most 2 log n.; Lesson 555 — Red-Black vs AVL Trees: Tradeoffs Lesson 575 — Splay Trees vs Other Balanced Trees
Redirect transitions: to point to the appropriate equivalence class representatives; Lesson 1790 — Constructing the Minimal DFA
Redis: (REmote DIctionary Server) stores all data in RAM, making it exceptionally fast—operations typically complete in microseconds.; Lesson 1737 — Popular Key-Value Stores: Redis and DynamoDB Lesson 2622 — Consistency in Practice: Examples
Redo: all committed transactions found in the log after that checkpoint; Lesson 1664 — Recovery Mechanisms and Durability Lesson 2292 — Command Pattern for Undo/Redo
Redo Stack: Starts empty.; Lesson 371 — Undo/Redo Functionality
Reduce: the heap size by one (the max is now in its final sorted position); Lesson 603 — The Sorting Phase: Extract-Max Repeatedly Lesson 779 — The Heapsort Algorithm Steps Lesson 1960 — Bottom-Up Parsing Overview Lesson 1962 — Shift-Reduce Parsing Actions Lesson 2136 — Map, Filter, and Reduce
Reduce boundary: Decrement `heapSize` by 1 (the sorted element is now "outside" the heap); Lesson 604 — In-Place Heapsort Implementation
Reduce complexity: by treating clusters as single units; Lesson 2789 — Clustering Fundamentals
Reduce r: Apply production rule r and pop corresponding symbols; Lesson 1966 — LR(0) Parsing Tables
Reduce repetition: Write the command sequence once, use it many times; Lesson 2118 — Procedural Abstraction
Reduce risk: Problems surface when they're cheaper to fix; Lesson 2366 — Iterative and Incremental Development
reduce-reduce conflicts: situations where multiple reductions are possible in the same state.; Lesson 1967 — SLR(1) Parsing Lesson 1970 — LALR(1) Parsing
Reduced Broadcast Traffic: Remember broadcast domains from the previous lesson?; Lesson 1457 — VLANs (Virtual LANs)
Reduced bugs: Less explicit state mutation means fewer opportunities for inconsistent state or race conditions.; Lesson 2156 — Benefits and Trade-offs of Declarative Style
Reduced lock contention: Each CPU locks only its own queue; Lesson 1266 — Per-CPU Run Queues
Reduced Risk: Smaller releases mean smaller failures.; Lesson 2369 — Continuous Delivery of Value
Reduced throughput: The whole pipeline stalls waiting for the slowest stage; Lesson 1155 — Balancing Pipeline Stages
reduces: the two-children problem to a simpler case (leaf or one child), which you already know how to handle.; Lesson 510 — BST Deletion: Two Children Case Lesson 1963 — LR Parsing Introduction
Reduces cognitive load: readers see intent, not mechanics; Lesson 2151 — Declarative Data Transformation
Reduces coupling: Clients depend on the facade, not the entire subsystem; Lesson 2278 — Facade Pattern: Simplifying Complex Subsystems
Reduces program size: (smaller executables); Lesson 2063 — Dead Code Elimination
Reduces redundancy: No need to duplicate common permissions; Lesson 2527 — RBAC Hierarchies
Reducing Complexity: consolidation eliminates repetitive structure and communicates intent through naming.; Lesson 2324 — Consolidate Conditional Expressions
Reducing sensitivity to noise: Small random fluctuations in training data don't get "learned"; Lesson 2810 — Introduction to Regularization
reduction: .; Lesson 1885 — Reductions from the Halting Problem Lesson 1928 — Introduction to Reductions Lesson 1932 — Proving NP-Completeness via Reduction
Redundancy: If one physical link fails, the others keep working seamlessly—no downtime.; Lesson 1460 — Link Aggregation Lesson 1625 — Transitive Functional Dependencies Lesson 1634 — Second Normal Form (2NF) Definition Lesson 1635 — Partial Dependencies Explained
Redundancy accepted: to avoid expensive joins during analysis; Lesson 1650 — OLTP vs OLAP Database Design
Redundancy elimination: is normalization's core benefit—it prevents update anomalies and saves storage.; Lesson 1645 — Normal Form Trade-offs
Redundant FDs: Dependencies that can be inferred from others; Lesson 1629 — Minimal Cover and Canonical Cover
Redundant Load/Store Elimination: Lesson 2058 — Peephole Optimization in Code Generation
Redundant loads and stores: Lesson 2071 — Peephole Optimization
Reentrant code: Code sections that multiple threads can execute at once safely; Lesson 1319 — Deadlock Prevention: Breaking Mutual Exclusion
Refactoring: Rename variables, extract functions, change code structure; Lesson 1982 — AST Manipulation and Transformation
Refactoring confidence: change a type, and the compiler tells you everywhere that needs updating; Lesson 2002 — Early Error Detection in Static Typing
Refactoring safety: – Change implementation details confidently, knowing tests will catch breaks; Lesson 2224 — What is Unit Testing?
reference: is essentially a nickname or alternate name for an existing variable.; Lesson 320 — References as Aliases Lesson 1228 — Process IDs and Identification
reference bit: in each page table entry when accessed.; Lesson 1371 — LRU Implementation Techniques Lesson 1372 — LRU Approximation Algorithms Lesson 1373 — Enhanced Second-Chance Algorithm
Reference parameters: offer a cleaner alternative: you pass a variable "by reference," creating an alias inside the function that directly accesses the original variable—without needing `&` or `*` operators everywhere.; Lesson 321 — Reference Parameters in Functions
Reference standards: "Our team convention prefers guard clauses over nested conditionals for error handling.; Lesson 2344 — Providing Constructive Feedback
referential integrity: , meaning the database ensures that relationships remain valid.; Lesson 1556 — Foreign Keys and References Lesson 1557 — Relational Integrity Constraints
Refill the heap: When you extract an element from list `i`, immediately insert the next element from list `i` (if any remain) into the heap.; Lesson 616 — Merging K Sorted Lists
reflexive: if every element relates to itself.; Lesson 69 — Properties of Relations: Reflexivity Lesson 72 — Equivalence Relations Lesson 74 — Partial Orders Lesson 75 — Total Orders and Chains
reflexivity: .; Lesson 69 — Properties of Relations: Reflexivity Lesson 73 — Equivalence Classes and Partitions
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
Refrigerator: (RAM): A few steps away, holds much more; Lesson 1108 — Speed vs Capacity Tradeoff
Region Servers: Store and serve data regions (horizontal partitions of tables); Lesson 1745 — HBase and Other Column-Family Systems
Register allocation: in compilers (variables are vertices, conflicts are edges); Lesson 1925 — Graph Coloring Problem Lesson 2049 — Introduction to Code Generation Lesson 2052 — Register Allocation Basics Lesson 2070 — Register Allocation
Register file ports: Multiple stages trying to read or write registers when there aren't enough access ports; Lesson 1162 — Structural Hazards: Definition Lesson 1163 — Detecting Structural Hazards
Register set: (CPU register values); Lesson 1230 — What is a Thread?
Register to Memory (Store): Lesson 1095 — MOV and Data Transfer Instructions
Register to Register: Lesson 1095 — MOV and Data Transfer Instructions
Register usage: Complex instructions might require more registers, complicating register allocation; Lesson 2053 — Instruction Selection
Registers: are tiny, ultra-fast storage locations built directly into the CPU.; Lesson 1071 — CPU Components Overview Lesson 1092 — Instruction Set Architecture (ISA)Lesson 1094 — Register-Based Operations Lesson 1104 — Function Parameters and Calling Conventions Lesson 1106 — The Memory Hierarchy Concept Lesson 1107 — Storage Pyramid Levels Lesson 1111 — Cost Per Byte Analysis Lesson 1112 — Volatile vs Non-Volatile Memory (+1 more)
Registration Authorities (RAs): Organizations that verify certificate requests before forwarding them to CAs.; Lesson 1535 — Public Key Infrastructure (PKI)
Regression: problems predict **continuous numerical values**.; Lesson 2781 — Classification vs Regression Problems Lesson 2786 — Supervised Learning: Learning from Labeled Examples Lesson 2787 — Classification vs Regression Tasks Lesson 2839 — Classification vs Regression Trees Lesson 2846 — Choosing the Best Split
Regression outputs: Lesson 2787 — Classification vs Regression Tasks
Regression Trees: predict continuous values (like house prices or temperatures).; Lesson 2839 — Classification vs Regression Trees
Regular audits: Password managers can identify weak or reused passwords; Lesson 2515 — Password Managers and Best Practices
Regular cleanup: Periodically delete merged branches and prune remote references; Lesson 2193 — Branch Management Best Practices
regular languages: those that don't require unbounded counting or memory.; Lesson 1791 — DFA Limitations and Non-Regular Languages Lesson 1801 — NFA-DFA Equivalence Theorem
Regular Queue: First in, first out; Lesson 389 — Priority Queues Introduction
Regulated domains: (medical devices, aerospace, government contracts) where documentation and formal sign-offs are mandatory; Lesson 2354 — Waterfall Strengths and Limitations
rehash: .; Lesson 428 — Load Factor and Rehashing Lesson 438 — Dynamic Resizing and Rehashing Cost
rehashing: .; Lesson 429 — Rehashing Process Lesson 1694 — Hash Index Insertion and Deletion
Rehashing frequency: The amortized O(1) cost hides occasional expensive O(n) pauses; Lesson 441 — Benchmarking and Practical Performance
Reinforcement learning: , where an agent learns through trial-and-error interactions.; Lesson 2793 — Choosing the Right Learning Paradigm
Reinsert: Put the updated server back in the heap (it will bubble down to maintain heap order); Lesson 617 — Load Balancing Systems
Reject: a string (halt in rejecting state) → string is not in L(M); Lesson 1859 — Languages Recognized by Turing Machines Lesson 2669 — Leader Election Restriction for Safety Lesson 2674 — Proposal Numbers and Ordering
Reject the request: if neither header is present or they indicate an untrusted source; Lesson 2470 — Origin and Referer Header Validation
rejects: a string if:; Lesson 1780 — DFA Computation and Acceptance Lesson 1856 — Accepting and Rejecting States Lesson 1875 — Recognizable vs. Decidable
Rejects or loops forever: on strings not in the language; Lesson 1875 — Recognizable vs. Decidable
Relabel: If no lower neighbors exist, increase the vertex's height; Lesson 1043 — Push-Relabel Algorithm Basics Lesson 1044 — Push-Relabel Operations
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: Might require self-joining a massive `friendships` table multiple times, potentially scanning billions of rows; Lesson 1747 — Graph Database vs Relational Joins
Relational algebra operations: (select, project, join) → `SELECT` queries with `WHERE`, specific columns, and `JOIN` clauses; Lesson 1560 — From Relational Model to SQL
Relational approach: Lesson 1747 — Graph Database vs Relational Joins
Relational integrity constraints: are the rules that databases enforce automatically to maintain data quality.; Lesson 1557 — Relational Integrity Constraints
Relational tables: store data in rows with fixed columns:; Lesson 1718 — Document Database Model
Relations: (tables) → `CREATE TABLE` statements; Lesson 1560 — From Relational Model to SQL
Relationships: They model real-world connections between entities (employees work in departments, orders contain products, etc.; Lesson 1556 — Foreign Keys and References Lesson 1611 — Introduction to Entity-Relationship (ER) Modeling Lesson 1749 — Relationships and Edge Properties Lesson 1750 — Cypher Query Language Basics
Relationships are central: social networks, recommendation engines, fraud detection; Lesson 1746 — Graph Database Model and Use Cases
Relative: start from CWD (`documents/reports`); Lesson 1414 — Tree-Structured Directories
relative path: specifies location starting from your **current working directory**.; Lesson 1390 — File Paths: Absolute vs Relative Lesson 1415 — Absolute vs Relative Paths
Relatively fast: Neighbor lookup is O(degree) with good locality; Lesson 683 — Hybrid and Compressed Representations
Relax: all its outgoing edges (update neighbors' distances if you found a shorter path); Lesson 972 — Dijkstra's with Array-Based Priority Queue
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: means unlocking and leaving—the next person waiting can now enter and lock it behind them.; Lesson 1281 — Lock Semantics and Acquire/Release Lesson 1283 — Pthread Mutex Basics
Release branches: `release/v2.; Lesson 2193 — Branch Management Best Practices Lesson 2197 — Gitflow Workflow
Release condition: Only released when count reaches zero; Lesson 1288 — Recursive Locks (Reentrant Mutexes)
Release resources: in any order (ordering only matters for acquisition); Lesson 1322 — Deadlock Prevention: Breaking Circular Wait
Relevance: Updated regularly to match current usage patterns; Lesson 1191 — Benchmark Programs and Performance Testing
Reliability: Lesson 1471 — TCP Overview and Key Features Lesson 1654 — Introduction to Database Transactions Lesson 2168 — Git vs Other Version Control Systems
reliable delivery: by:; Lesson 1436 — OSI Layer 4: Transport Layer Lesson 1476 — TCP Reliability: Retransmission
Relocation: is the mechanism that makes this flexibility possible.; Lesson 1334 — Relocation and Dynamic Loading
remainder: tells you whether that number has a "1" or "0" in the current position.; Lesson 4 — Converting Decimal to Binary Lesson 408 — The Division Method
Remaining input: – what part of the input string hasn't been read yet; Lesson 1829 — PDA Configurations and Instantaneous Descriptions
Remote code execution: In severe cases, attackers can execute arbitrary code on the server; Lesson 2489 — Path Traversal and File Inclusion
Remote File Inclusion (RFI): Including files from external URLs, potentially loading malicious scripts; Lesson 2489 — Path Traversal and File Inclusion
Remote Proxy: Represent an object in a different address space (like a network service); Lesson 2280 — Proxy Pattern: Controlling Access to Objects
Remove: that element from the stack; Lesson 358 — Pop Operation Lesson 947 — Rerooting Technique
Remove all conflict markers: completely; Lesson 2188 — Resolving Merge Conflicts
Remove from front: (`pop_front` or `removeFirst`); Lesson 395 — Deque: Double-Ended Queue Fundamentals
Remove from rear: (`pop_back` or `removeLast`); Lesson 395 — Deque: Double-Ended Queue Fundamentals
Remove from the front: If the front element is outside the current window, remove it; Lesson 401 — Sliding Window Problems with Deques
Remove highest priority: O(n) — must search entire array; Lesson 390 — Priority Queue Array Implementation
Remove Parameter: help eliminate speculative code.; Lesson 2340 — Speculative Generality Smell
Remove redundant FDs: If an FD can be inferred from the others using Armstrong's axioms, delete it; Lesson 1629 — Minimal Cover and Canonical Cover
Remove the last position: (shrink the heap size); Lesson 591 — Implementing Extract Operation
Remove ε-productions: delete all `A → ε` rules; Lesson 1823 — Eliminating ε-Productions
RemoveBack (pop_back): Save the tail's data, move `tail` to `tail->prev`, update the new tail's `next` to `NULL`, and deallocate the old node.; Lesson 398 — Linked List Deque Implementation
Removed (syntactic clutter): Lesson 1977 — From Parse Tree to AST
RemoveFront (pop_front): Save the head's data, move `head` to `head->next`, update the new head's `prev` to `NULL`, and deallocate the old node.; Lesson 398 — Linked List Deque Implementation
Removing a node: Only that node's keys move to its successor.; Lesson 1732 — Consistent Hashing
Rename variables: if needed to avoid conflicts when quantifiers are moved; Lesson 57 — Prenex Normal Form
Reordering: Messages sent in sequence A → B→ C might arrive as C → A→ B due to different network paths, queueing delays, or packet fragmentation; Lesson 2592 — Message Loss and Ordering
Repeat: Keep halving the search space until you find the target or run out of elements; Lesson 284 — O(log n): Logarithmic Time Lesson 327 — Traversing a Linked List Lesson 603 — The Sorting Phase: Extract-Max Repeatedly Lesson 604 — In-Place Heapsort Implementation Lesson 613 — Dijkstra's Algorithm with Priority Queue Lesson 722 — Kahn's Algorithm: Basic Idea Lesson 779 — The Heapsort Algorithm Steps Lesson 892 — Minimum Number of Coins Problem (+12 more)
Repeat if needed: Check each resulting table for BCNF violations and decompose again if necessary; Lesson 1641 — Achieving BCNF
Repeat step 2-3: until either:; Lesson 1325 — Banker's Algorithm: Safety Check
Repeat steps 2–4: until only one node remains (the root); Lesson 614 — Huffman Coding Tree Construction
Repeat the entire process: for the remaining unsorted portion; Lesson 741 — Bubble Sort: Algorithm
Repeat the process: at the new node until you either find the key or reach a leaf without finding it; Lesson 559 — B-Tree Search Operation
Repeat until done: Continue until the queue is empty or simulation time ends; Lesson 612 — Event-Driven Simulation
Repeatable Read: isolation level solves this problem.; Lesson 1670 — Repeatable Read Isolation Level Lesson 1674 — Isolation Level Trade-offs
Repeated digits: `[0-9]*` matches any sequence of digits or nothing at all; Lesson 1770 — Kleene Star and Repetition
Repeated Dijkstra: runs Dijkstra from each vertex.; Lesson 999 — Floyd-Warshall vs Repeated Dijkstra
Repeated logic: Same operation in multiple places?; Lesson 2319 — Extract Method: Breaking Down Complex Functions
Repeated sub-expressions: If `order.; Lesson 2322 — Extract Variable: Explaining Complex Expressions
Repeated values: used in multiple places; Lesson 2323 — Replace Magic Numbers with Named Constants
Repeatedly extract the maximum: element and place it at the end of the array; Lesson 601 — Heapsort Overview and Basic Idea Lesson 777 — Heapsort Overview and Motivation
Repeatedly extract the minimum: Pull the smallest element from the heap and add it to the result.; Lesson 616 — Merging K Sorted Lists
Repeats: until the data dependency is resolved; Lesson 1168 — Pipeline Stalls and Bubbles
Replace: the old table with the new one; Lesson 429 — Rehashing Process Lesson 927 — Edit Distance (Levenshtein Distance)
Replace drivers: as real higher-level modules become ready; Lesson 2239 — Bottom-Up Integration Testing
Replace each hex digit: with its 4-bit binary equivalent; Lesson 8 — Converting Between Binary and Hexadecimal
Replace the old table: with the new one; Lesson 428 — Load Factor and Rehashing
Replace the parent key: with a key from the generous sibling; Lesson 565 — Borrowing Keys from Siblings
Replace the root: with the last element in the heap; Lesson 591 — Implementing Extract Operation
Replace unit productions: For each unit pair `(A, B)` where `A` reaches `B`, add new productions `A → α` for every non- unit production `B → α`.; Lesson 1824 — Eliminating Unit Productions
Replacement logic: Deciding which of N ways to evict becomes more complex (LRU becomes expensive with high associativity); Lesson 1136 — Associativity Impact on Conflict Misses
replaces: the entire memory contents of the calling process with a new program.; Lesson 1224 — Process Execution: exec() Family Lesson 2127 — Method Overriding and Polymorphism
Replay attacks: reuse legitimate signatures.; Lesson 2441 — Digital Signature Security Considerations
Replica A: `"alice@old.; Lesson 2701 — Last-Write-Wins (LWW) Conflict Resolution
Replica B: `"alice@new.; Lesson 2701 — Last-Write-Wins (LWW) Conflict Resolution
Replication: solves this by maintaining **multiple copies** of each key-value pair across different nodes.; Lesson 1733 — Replication in Key-Value Stores Lesson 2616 — Monotonic Read Consistency Lesson 2637 — Introduction to Replication Lesson 2638 — Replication vs. Partitioning
Replication answers: "How do I survive failures and serve more read requests?; Lesson 2638 — Replication vs. Partitioning
replication lag: for reads.; Lesson 2639 — Leader-Based Replication Lesson 2645 — Handling Replication Lag
Reporting databases: Denormalized "fact tables" with repeated dimension data let analytics queries run faster; Lesson 1645 — Normal Form Trade-offs
Reporting needs: Aggregated data is calculated repeatedly instead of pre-computed; Lesson 1646 — Introduction to Denormalization
Reports results: immediately to the team; Lesson 2383 — What is Continuous Integration?
Repository: (committed state) — where Git permanently stores snapshots; Lesson 2171 — The Three States of Git
Reproduce the bug: Write a test that exercises the exact scenario where the bug occurs.; Lesson 2262 — TDD for Bug Fixes
Reproducibility: Same benchmark always produces comparable results; Lesson 1191 — Benchmark Programs and Performance Testing
Request edge: An arrow from a process to a resource means that process is *requesting* that resource (process → resource); Lesson 1316 — Resource Allocation Graphs
Require pull request reviews: No one merges their own code without at least one (or more) teammate approving it.; Lesson 2201 — Branch Protection and Policies
Required fields: Ensure critical data (like `userId` or `email`) is always present; Lesson 1725 — Schema Validation and Flexibility
Requirements: Your array *must* be sorted first.; Lesson 251 — Binary Search: Efficient Searching in Sorted Arrays Lesson 2355 — The V-Model: Verification and Validation
Requirements change frequently: – going back to an earlier phase is expensive and disruptive; Lesson 2354 — Waterfall Strengths and Limitations
Requirements for secure salts: Lesson 2506 — Salt: Defending Against Rainbow Tables
Requirements Gathering: Capture all user needs and system specifications upfront; Lesson 2353 — The Waterfall Model: Sequential Phases
Requirements get missed: or change unexpectedly mid-project; Lesson 2351 — What is a Software Development Lifecycle (SDLC)?
requires: a `Host` header in every request, specifying the target domain name.; Lesson 1523 — HTTP/1.0 vs HTTP/1.1 Improvements Lesson 1822 — Greibach Normal Form
residual capacity: the maximum additional flow it can handle.; Lesson 1029 — Residual Capacity of a Path Lesson 1036 — Residual Networks Lesson 1038 — Ford- Fulkerson Method
residual network: is a transformed version of your original flow network that answers both questions.; Lesson 1027 — Residual Networks Lesson 1036 — Residual Networks
Resizing complexity: When the map grows, you must coordinate rehashing without corrupting ongoing operations— often requiring careful lock acquisition ordering or a global lock momentarily.; Lesson 2582 — Concurrent Hash Map: Basics
Resolution: Keep `"alice@new.; Lesson 2701 — Last-Write-Wins (LWW) Conflict Resolution
Resolver queries authoritative nameserver: The `.; Lesson 1507 — DNS Resolution Process: Recursive Queries
Resolver queries root nameserver: The resolver asks a root nameserver, "Who handles `.; Lesson 1507 — DNS Resolution Process: Recursive Queries
Resolver queries TLD nameserver: Root responds with the `.; Lesson 1507 — DNS Resolution Process: Recursive Queries
Resource: What's being protected (e.; Lesson 2525 — Access Control Lists (ACLs)
Resource Allocation Graph (RAG): is a visual tool that helps us understand and detect deadlock conditions in a system.; Lesson 1316 — Resource Allocation Graphs
Resource attributes: classification level, owner, creation date, file type; Lesson 2528 — Attribute-Based Access Control (ABAC)
Resource constraints: Embedded systems or real-time applications may need deterministic memory/CPU usage that declarative layers obscure.; Lesson 2156 — Benefits and Trade-offs of Declarative Style
Resource counting: (how many are free?; Lesson 1301 — Resource Counting with Counting Semaphores Lesson 1303 — Semaphores vs Mutexes vs Condition Variables
Resource deallocation: The OS begins reclaiming memory, closing open files, releasing network connections, and freeing other resources the process held.; Lesson 1220 — Process States: Terminated
Resource Duplication: Lesson 1164 — Resolving Structural Hazards
Resource failures: (file not found, network timeout); Lesson 2231 — Testing Exception Handling
Resource identifier: (what you can access); Lesson 2532 — Capability-Based Security
Resource Manager: – The OS controls and allocates hardware resources (CPU time, memory space, disk access) to different programs, ensuring they don't interfere with each other and that resources are used efficiently.; Lesson 1193 — What is an Operating System?
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 nodes: (rectangles): Represent resource types, with dots inside showing how many instances exist; Lesson 1316 — Resource Allocation Graphs
Resource Owner: (you, the user); Lesson 2534 — OAuth 2.0 Overview and Use Cases 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.; Lesson 301 — Practical Applications of Tight Bounds
Resource pooling: is the classic use case.; Lesson 394 — Queue Variant Applications
Resource Server: (holds your protected data); Lesson 2534 — OAuth 2.0 Overview and Use Cases Lesson 2535 — OAuth 2.0 Roles: Resource Owner, Client, Authorization Server
Resource-efficient: Requires fewer test environments and less scaffolding code; Lesson 2236 — Big Bang Integration Strategy
Respect instruction constraints: Some CPUs require operands in specific registers or formats; Lesson 2051 — Three-Address Code Translation
Responding to change: over following a plan; Lesson 2361 — The Agile Manifesto
Responds: with:; Lesson 2676 — Phase 1b: Promise Response
Response time: measures the interval from when a process is submitted (or becomes ready) until it **first begins executing** on the CPU.; Lesson 1248 — Response Time Lesson 1249 — Scheduling Criteria Trade-offs Lesson 1261 — Comparing Scheduling Algorithm Performance
Responsibility assignment: Which object should handle which task?; Lesson 2286 — Introduction to Behavioral Patterns
Restore: the heap property by letting the new root "sink down" to its correct position; Lesson 779 — The Heapsort Algorithm Steps Lesson 1251 — Context Switch Overhead
Restore heap property: using the appropriate bubbling operation; Lesson 594 — Increase/Decrease Key Operations Lesson 604 — In-Place Heapsort Implementation
Restore new process state: Load the selected process's saved register values and program counter from its PCB; Lesson 1229 — Context Switching Between Processes
Restrict who can push: Only designated maintainers can force-push or bypass rules, preventing accidental overwrites.; Lesson 2201 — Branch Protection and Policies
Result: (x + y)³ = x³ + 3x²y + 3xy² + y³; Lesson 105 — The Binomial Theorem Lesson 950 — DP on DAGs: Longest Path Lesson 1464 — Subnetting Fundamentals Lesson 1478 — TCP Congestion Control: Slow Start Lesson 1628 — Closure of Attribute Sets Lesson 2025 — Function Call Semantics Lesson 2720 — Three-Phase Commit (3PC)
Result list: Stores the sorted order — exactly V vertices; Lesson 727 — Time and Space Complexity
Result: 3.25: Lesson 1063 — Fixed-Point Number Representation
Result: 48: Lesson 367 — Evaluating Postfix Expressions
Resume: Task B continues exactly where it left off; Lesson 2547 — Single-Core Concurrency Through Time-Slicing
Resume execution: The CPU continues where the new process left off; Lesson 1229 — Context Switching Between Processes Lesson 1346 — Page Faults and Demand Paging
Resumes: the processes; Lesson 1337 — Memory Compaction
Retransmission Timeout (RTO): as:; Lesson 1481 — TCP Round-Trip Time Estimation
Retrieve: the value of the top element; Lesson 358 — Pop Operation Lesson 1380 — Logical Address Translation in Segmentation
Retrieve the mapping: The page table entry (PTE) containing the physical frame number is located; Lesson 1363 — TLB Miss Handling
Retry the access: The memory access completes using the newly cached translation; Lesson 1363 — TLB Miss Handling
Return: the retrieved value; Lesson 358 — Pop Operation Lesson 506 — BST Insertion: Recursive Approach Lesson 873 — Recursion with Memoization Integration Lesson 917 — Tabulation (Bottom-Up DP)Lesson 2025 — Function Call Semantics
Return a result: give back an answer you can use; Lesson 185 — What is a Function?
return address: (where to resume after the function completes); Lesson 374 — Stack-Based Memory Management Lesson 2056 — Function Call Code Generation Lesson 2076 — Stack Frames and Activation Records
Return an error value: (like `-1` or `None`); Lesson 205 — Parameter Type Checking and Validation
return statement: is how a function sends a value back to its caller.; Lesson 189 — Return Statements Lesson 199 — Return Statements and Values
Return status: The process provides an exit code (like "0" for success or another number for errors) to inform the parent process or OS how things went.; Lesson 1220 — Process States: Terminated
Return to: `factorial(2)` → computes `2 × 1 = 2`, returns `2`; Lesson 221 — Computing Factorials Recursively
Return Type: A type annotation node; Lesson 1980 — AST Representation of Function Definitions
Return types: `function compute() -> float`; Lesson 1995 — Type Annotations and Signatures
Return value: What the function gives back (or note "returns nothing" for void functions); Lesson 192 — Function Documentation Lesson 1208 — System Call Parameters and Return Values
Return values: State what type the function produces; Lesson 2000 — Type Annotations in Static Languages
Returning a value: `return result`; Lesson 283 — O(1): Constant Time
Returns: success/failure or constructs a parse tree node; Lesson 1952 — Implementing Recursive Descent Functions
Reusability: The function works with any compatible type; Lesson 2012 — Principal Types and Most General Unifiers Lesson 2134 — Function Composition Lesson 2319 — Extract Method: Breaking Down Complex Functions Lesson 2326 — Decompose Conditional: Simplifying Complex If Statements
Reusability loss: Useful logic buried deep inside cannot be easily reused elsewhere.; Lesson 2330 — Long Method Smell
Reusability suffers: You can't extract useful functionality without dragging along all the unrelated baggage; Lesson 2302 — God Object Anti-Pattern
Reusable across sites: One breach exposes multiple accounts (credential stuffing attacks); Lesson 2517 — Knowledge Factors (Something You Know)
Reuse: – Single-purpose functions fit more scenarios; Lesson 2310 — Function Length and Single Responsibility
Reuse addresses: Thousands of companies can all use `10.; Lesson 1465 — Private and Public IP Address Ranges
Reverse engineering and security: Analyzing compiled programs, finding vulnerabilities, or understanding malware requires reading assembly.; Lesson 1091 — Assembly Language Overview and Purpose
Reverse the collected vertices: to get the path from source to destination; Lesson 975 — Path Reconstruction from Predecessor Array
Reverse the list: at the end—this gives you the topological order; Lesson 724 — DFS-Based Topological Sort
Reversing a string: – swap characters from both ends moving inward; Lesson 268 — Common String Algorithms
Review and merge: Maintainers review the pull request, discuss changes, and merge if acceptable.; Lesson 2198 — Forking Workflow
Review Checklist Approach: solves this by providing a repeatable, systematic method.; Lesson 2343 — The Review Checklist Approach
Review fatigue: Important security flaws get lost in a sea of nitpicks about variable names; Lesson 2345 — Distinguishing Critical vs Stylistic Issues
Revision Tracking: When you respond to review feedback and push new commits, the platform automatically shows what changed between review rounds.; Lesson 2350 — Code Review Tools and Workflow
Revocable: Destroying or expiring the capability removes access; Lesson 2532 — Capability-Based Security
Revocation: Invalidating compromised keys and distributing revocation lists; Lesson 2417 — Key Distribution and Management
Revocation Status: The browser may check if the certificate has been revoked before expiration (using mechanisms like CRL or OCSP).; Lesson 2450 — Certificate Validation and Common Errors
Rewards confident correct predictions: (predicting 0.; Lesson 2830 — Cross-Entropy Loss Function
Rewrite the grammar: to eliminate ambiguity (preferred); Lesson 1971 — Conflict Resolution in LR Parsing
Rich context: Shows when/where/what device is trying to authenticate; Lesson 2522 — Push Notification-Based MFA
Ridge regression: , adds a penalty term to your loss function that punishes large weights.; Lesson 2812 — L2 Regularization (Ridge)
right: subtree; Lesson 476 — Implementing Postorder Recursively Lesson 519 — Floor and Ceiling Operations Lesson 638 — Ternary Search Tree Operations Lesson 1774 — Precedence and Parentheses in Regular Expressions Lesson 1812 — Regular Language Identities and Algebraic Laws
right child: , establishing a clear distinction between the two positions.; Lesson 457 — Binary Tree Definition Lesson 461 — Array-Based Complete Binary Trees Lesson 462 — Array Index Formulas Lesson 481 — Iterative Inorder with Stack Lesson 517 — Validating BST Property Lesson 534 — Identifying Imbalance Cases Lesson 579 — Array Representation of Binary Heaps Lesson 580 — Parent-Child Index Formulas (+1 more)
Right child index: `2 * i + 1`; Lesson 580 — Parent-Child Index Formulas
Right Child Pointer: A reference to the right subtree's root node.; Lesson 497 — BST Node Structure
RIGHT OUTER JOIN: (often shortened to just `RIGHT JOIN`) is the mirror image of a left outer join.; Lesson 1580 — Right Outer Join
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 Lesson 537 — Left-Right Double Rotation Lesson 550 — Insertion Case 2: Uncle is Black, Triangle Configuration Lesson 551 — Insertion Case 3: Uncle is Black, Line Configuration Lesson 553 — Deletion Cases: Red Sibling
Right Shift (`>>`): Moves all bits right, discarding rightmost bits.; Lesson 163 — Bitwise Operators
Right side (ascending): After implementation, you execute the tests in reverse order, validating that each level meets its corresponding design phase.; Lesson 2355 — The V-Model: Verification and Validation
Right subtree: contains all larger values; Lesson 493 — What is a Binary Search Tree?Lesson 515 — Counting Nodes in a BST Lesson 534 — Identifying Imbalance Cases
Right-half inversions: Count recursively in the right half; Lesson 852 — Count Inversions in Array
Right-hand side inspection: If you have `A → αBβ`, add FIRST(β) - {ε} to FOLLOW(B); Lesson 1957 — FOLLOW Sets
Right-Left imbalance: the tree leans too far right (right child is taller), but within that right subtree, the problem is on the *left* side.; Lesson 538 — Right-Left Double Rotation
Right-Right (RR) imbalance: .; Lesson 536 — Single Left Rotation
Rightmost column: 1 + 0 = 1; Lesson 5 — Binary Addition
Rights: (read, write, execute, etc.; Lesson 2532 — Capability-Based Security
RIP: (Routing Information Protocol): Simple, uses hop count as metric; Lesson 1470 — Static vs Dynamic Routing Protocols
RIP (Routing Information Protocol): use Bellman-Ford principles.; Lesson 989 — Bellman-Ford Applications
RISC-V: An open-source ISA gaining popularity; Lesson 1092 — Instruction Set Architecture (ISA)
Risk level: What happens if this breaks?; Lesson 2248 — Test Scenarios and User Journeys
Risk mitigation: Identifying potential failures early when they're cheaper to fix; Lesson 2214 — What is Software Testing?
Robotics: Autonomous robots use A* to navigate warehouse floors, avoiding obstacles while finding efficient paths.; Lesson 1011 — A* Applications and Variants
ROC curve: plots true positive rate (recall) against false positive rate across *all possible thresholds*.; Lesson 2835 — Evaluating Logistic Regression Models
ROC-AUC: to evaluate threshold-independent performance.; Lesson 2835 — Evaluating Logistic Regression Models
Rollback: – Return the victim to a safe earlier state (before it acquired the resource); Lesson 1327 — Deadlock Recovery Strategies Lesson 1656 — Commit and Rollback Operations Lesson 1657 — Transaction Logs and Write-Ahead Logging
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
rolls back: all changes, restoring the original state as if nothing happened.; Lesson 1655 — Atomicity: All-or-Nothing Execution Lesson 1667 — Dirty Reads Problem
root: at the top.; Lesson 450 — What is a Tree? Definition and Motivation Lesson 451 — Root, Parent, Child, and Sibling Nodes Lesson 454 — Node Depth and Height Lesson 1390 — File Paths: Absolute vs Relative Lesson 1503 — DNS Hierarchy and Namespace Structure Lesson 1797 — Computation Trees in NFAs Lesson 1950 — Introduction to Top-Down Parsing Lesson 2765 — Game Trees and Ply Depth (+1 more)
Root certificate: Self-signed certificate from the root CA, pre-installed in your browser or operating system; Lesson 1533 — Certificate Authorities and Trust Chains
Root exception: The root may have as few as 1 key (if it's not a leaf); Lesson 556 — B-Tree Definition and Properties Lesson 558 — B-Tree Invariants Lesson 1677 — B-Tree Structure and Properties
Root level: Merge n elements → O(n) work; Lesson 756 — Mergesort Time Complexity Analysis
root node: is special—it's your entry point to the entire tree.; Lesson 460 — Node-Based Tree Structure Lesson 2838 — Decision Tree Intuition and Structure Lesson 2840 — Tree Terminology: Nodes, Edges, and Leaves
Root-Left-Right: order, relying on the call stack to remember where to go next.; Lesson 480 — Iterative Preorder with Stack
Roster notation: lists all elements explicitly inside curly braces:; Lesson 58 — Set Fundamentals and Notation
Rotate: at the grandparent in the opposite direction of the line; Lesson 551 — Insertion Case 3: Uncle is Black, Line Configuration Lesson 553 — Deletion Cases: Red Sibling
Rotate if needed: If imbalanced, determine the rotation type (single right, single left, left-right, or right-left) based on the heavier subtree; Lesson 541 — AVL Deletion Overview
Rotate keys: through the parent: move a parent key down to the underfull node; Lesson 565 — Borrowing Keys from Siblings
Rotating left: means taking books from the left end and moving them to the right end.; Lesson 254 — Array Rotation: Shifting Elements Circularly
Rotating right: does the opposite.; Lesson 254 — Array Rotation: Shifting Elements Circularly
Rotational latency: Waiting for the disk to spin to the right sector (half a rotation on average); Lesson 1421 — Why Disk Scheduling Matters
Rotations: When recoloring alone won't work (uncle is black), rotations restructure the tree while preserving BST order and allowing proper recoloring.; Lesson 548 — Red-Black Tree Insertion Overview
Rotting oranges: Fresh oranges adjacent to rotten ones rot simultaneously each minute; Lesson 702 — Multi-Source BFS
Round Robin: for good response time; Lesson 1259 — Multilevel Queue Scheduling Lesson 1261 — Comparing Scheduling Algorithm Performance
Round-Trip Time (RTT): how long it takes for a segment to reach the destination and for its acknowledgment to return.; Lesson 1481 — TCP Round-Trip Time Estimation
Route the operation: – Send the request to that specific node; Lesson 1729 — Hash-Based Key Distribution
Routers: operate at Layer 3.; Lesson 1435 — OSI Layer 3: Network Layer
routing table: a map of known networks and the best next hop toward each one.; Lesson 1435 — OSI Layer 3: Network Layer Lesson 1468 — Routing Table Fundamentals
row: , fix the first index and iterate through the second:; Lesson 245 — Common 2D Array Operations Lesson 1552 — Tables, Rows, and Columns
Row 1: identifies which nonterminals can generate each single character; Lesson 1845 — CYK Parsing Algorithm
Row 2: identifies which nonterminals can generate each two-character substring; Lesson 1845 — CYK Parsing Algorithm
Row counts: for tables; Lesson 1704 — Statistics and Histograms
Row i: identifies which nonterminals can generate each substring of length i; Lesson 1845 — CYK Parsing Algorithm
Row key: A unique identifier (like a primary key); Lesson 1738 — Introduction to Column-Family Databases
Row-key: A unique identifier for each row (like a filing cabinet drawer label); Lesson 1739 — Column-Family Data Model: Rows and Column Families
rows: and **columns**.; Lesson 1551 — What is the Relational Model?Lesson 1559 — Relational Algebra Basics Lesson 1598 — WHERE vs HAVING Lesson 1783 — DFA Transition Tables Lesson 1943 — Building a Transition Table Lesson 2683 — Horizontal vs Vertical Partitioning
Rows Estimates: The `rows=1000` value shows expected row counts at each step.; Lesson 1705 — Reading and Analyzing EXPLAIN Output
RSA is vulnerable: A sufficiently powerful quantum computer could factor your 2048-bit RSA key; Lesson 2419 — Quantum Threats to Asymmetric Crypto
Ruby on Rails: `protect_from_forgery` adds token verification to controllers; Lesson 2473 — Implementing CSRF Protection
Rule: `a(n) = a(n-1) + a(n-2)` (each term is the sum of the two before it); Lesson 84 — Recurrence Relations Lesson 2158 — Prolog Syntax: Facts and Rules Lesson 2656 — Quorums and Majority Voting
Rule 1 (Condition False): If the boolean expression evaluates to false in the current state, the loop terminates immediately without changing the state.; Lesson 2024 — Operational Semantics of While Loops
Rule 2 (Condition True): If the boolean expression evaluates to true, execute the body statement `S` to get a new state `σ'`, then *recursively* evaluate the entire while loop again in that new state.; Lesson 2024 — Operational Semantics of While Loops
Rule 2: Send Event: Lesson 2629 — Lamport Clock Algorithm Implementation
Rule 2: Zero Compression: Lesson 1467 — IPv6 Addressing Basics
Rule 3: Receive Event: Lesson 2629 — Lamport Clock Algorithm Implementation
Rule of thumb: Anything worse than O(n²) is usually impractical for large datasets.; Lesson 291 — Comparing Growth Rates
rules: , and **queries** based on formal logic.; Lesson 2157 — What is Logic Programming?Lesson 2158 — Prolog Syntax: Facts and Rules
Rules for moving: between states (allowed transitions); Lesson 705 — BFS with State Space Representation
Run all tests: to establish a green baseline; Lesson 2261 — Refactoring with Confidence
Run DFS: on your graph; Lesson 721 — DAG Detection and Prerequisites Lesson 724 — DFS-Based Topological Sort Lesson 730 — Component Finding with DFS
Run Ford-Fulkerson: (or Edmonds-Karp, Dinic's, etc.; Lesson 1047 — Maximum Bipartite Matching Algorithm
Run tests again: immediately after each change; Lesson 2261 — Refactoring with Confidence
Running: state—it's actively executing instructions on the processor.; Lesson 1219 — Process States: Running and Waiting Lesson 1221 — Process State Transitions
Running → Ready: Lesson 1221 — Process State Transitions
Running → Terminated: Lesson 1221 — Process State Transitions
Running → Waiting: Lesson 1221 — Process State Transitions
Runs automated tests: to verify functionality; Lesson 2383 — What is Continuous Integration?
Runtime Analysis: is the study of how long an algorithm takes to run as the input size grows.; Lesson 270 — What is Runtime Analysis?
Runtime checking: A dynamically typed language like Python checks types during execution and raises errors when operations don't make sense for the given types.; Lesson 1985 — What is a Type System?
Runtime computation: fewer instructions to execute; Lesson 2061 — Constant Folding
Runtime monitoring: Track memory usage over time—steadily increasing usage suggests leaks.; Lesson 2087 — Memory Leaks: Causes and Detection

S

S → ε: where S is the start symbol, and S cannot appear on the right side of any production.; Lesson 1820 — Chomsky Normal Form (CNF)Lesson 1843 — Chomsky Normal Form
Safe first move: Making the greedy choice always leaves you with a smaller, similar subproblem.; Lesson 879 — The Greedy Choice Property
Safe methods: like `GET` and `HEAD` should only *retrieve* information—never create, modify, or delete data.; Lesson 2472 — State-Changing Operations and Safe Methods
Safe reclamation: Periodically, threads scan all active hazard pointers.; Lesson 2573 — Hazard Pointers for Memory Reclamation
safe state: where deadlock is impossible.; Lesson 1323 — Deadlock Avoidance: Safe States Lesson 1325 — Banker's Algorithm: Safety Check
Safer to merge: fewer moving parts reduce risk of introducing bugs; Lesson 2342 — Preparing Code for Review
Safety: They prevent accidental changes to values that should stay the same (like mathematical constants, configuration settings, or fixed rules); Lesson 148 — Constants and Immutability Lesson 159 — Short-Circuit Evaluation Lesson 204 — Const Parameters and Immutability Lesson 228 — Converting Tail Recursion to Iteration Lesson 321 — Reference Parameters in Functions Lesson 1239 — Thread-Local Storage Lesson 1241 — Threading Challenges: Synchronization Needs Lesson 1306 — The Wait-Signal Pattern (+9 more)
Saga pattern: solves this by splitting one big transaction into a sequence of **local transactions**, each updating a single service.; Lesson 2721 — Saga Pattern for Long-Running Transactions Lesson 2722 — Compensating Transactions
salt: is a random string added to each password before hashing: `hash(password + salt)`.; Lesson 2430 — Hash Function Applications: Password Storage Lesson 2506 — Salt: Defending Against Rainbow Tables Lesson 2510 — Pepper: Additional Secret Layer
same: color as the current vertex, you've found an **odd cycle**—the graph is not bipartite; Lesson 703 — BFS for Bipartiteness Testing Lesson 2796 — Training Set vs Test Set
Same complexity: Still O(n log n) time, O(n) space; Lesson 760 — Bottom-Up Mergesort
Same logic: The traversal order matches recursive DFS; Lesson 373 — Depth-First Search with Explicit Stack
Same process: A occurs before B on the same node (local execution order); Lesson 2627 — Happens-Before Relation
Same type: Every element must be the same data type (all integers, all floats, all characters, etc.; Lesson 232 — What is an Array?
Same-origin policy: prevents JavaScript from reading pages across domains; Lesson 2467 — CSRF Token Defense
Same-thread only: Only the owning thread can lock it multiple times; Lesson 1288 — Recursive Locks (Reentrant Mutexes)
SameSite cookies: (`SameSite=Strict` or `SameSite=Lax`) to block cross-site requests; Lesson 2473 — Implementing CSRF Protection
sample space: is the set of all possible outcomes of a random experiment or process.; Lesson 108 — Sample Spaces and Events Lesson 119 — Probability in Algorithm Analysis
Sandbox/Test Environments: Lesson 2244 — Testing External Dependencies
Sanitization: (or escaping) means transforming potentially dangerous input into a safe form.; Lesson 2459 — Input Validation and Sanitization
Sanitize before output: When displaying user input in HTML, escape special characters.; Lesson 2459 — Input Validation and Sanitization
SAT: → 3-SAT → Independent Set → Vertex Cover → Clique; Lesson 1936 — Reduction Chains
Satisfiability Problem (SAT): asks a fundamental question: Given a Boolean formula made up of variables, ANDs, ORs, and NOTs, does there exist an assignment of TRUE/FALSE values to the variables that makes the entire formula evaluate to TRUE?; Lesson 1915 — The Satisfiability Problem (SAT)
Saturating push: sends as much flow as the edge capacity allows; Lesson 1044 — Push-Relabel Operations
Save current process state: The OS stores all register values, program counter, and process state into the current process's PCB; Lesson 1229 — Context Switching Between Processes
Save state: Store Task A's current instruction pointer, register values, and memory state; Lesson 2547 — Single-Core Concurrency Through Time-Slicing
Save the root: (the element to return); Lesson 591 — Implementing Extract Operation
Saved registers: Previous register values that must be restored; Lesson 2076 — Stack Frames and Activation Records
Saves the return address: It automatically pushes the address of the next instruction (the one after `CALL`) onto the stack; Lesson 1103 — Function Calls and the CALL Instruction
Scalability: The system can adjust the number of kernel threads based on processor availability; Lesson 1236 — Multithreading Models: Many-to-Many Lesson 1266 — Per-CPU Run Queues Lesson 1414 — Tree-Structured Directories Lesson 2500 — Token-Based Authentication Lesson 2526 — Role-Based Access Control (RBAC)Lesson 2638 — Replication vs. Partitioning Lesson 2682 — Introduction to Data Partitioning Lesson 2684 — Sharding Fundamentals (+2 more)
Scalar subqueries: (returning single values) in the SELECT or WHERE clause are often fine for small datasets or when executed once.; Lesson 1609 — Subquery Performance Considerations
Scaling (`×a`): If you double every value, the distances between points also double.; Lesson 136 — Variance of Linear Transformations
Scaling squares the effect: Multiplying `X` by `a` multiplies the variance by `a²`, not just `a`; Lesson 136 — Variance of Linear Transformations
Scan: the text with two pointers:; Lesson 835 — KMP: Pattern Matching Algorithm
SCAN algorithm: (also called the Elevator algorithm) solves the problem of inefficient disk head movement by treating the disk arm like an elevator: it moves in one direction servicing all requests along the way, then reverses direction when it reaches the end an...; Lesson 1425 — SCAN (Elevator) Algorithm
Scan incrementally: Pick a gray object, scan its references, and color any white objects it points to as gray.; Lesson 2099 — Tri-Color Marking
Scan operators: Read data from storage; Lesson 1698 — Query Execution Plans and Operators
Scanning: When the dot precedes a terminal that matches the next input symbol, advance the dot; Lesson 1846 — Earley Parsing Algorithm
Scatter-Gather: Send the query to all relevant shards, collect results, and merge them at a coordinator node.; Lesson 2692 — Cross-Shard Queries and Joins
Scheduling information: Priority, scheduling queue pointers, CPU time used; Lesson 1217 — Process Control Block (PCB)
Schema: is the **structure definition** of your database.; Lesson 1553 — Schemas and Instances Lesson 1623 — Identifying Functional Dependencies from Data
Schema rigidity: Fixed table structures became bottlenecks when data formats evolved rapidly; Lesson 1708 — What is NoSQL and Why It Exists
Scientific simulations: Modeling 3D space (x, y, z coordinates); Lesson 247 — 3D Arrays and Higher Dimensions Lesson 249 — Practical Applications of Multidimensional Arrays
scope: .; Lesson 53 — Quantifier Scope and Binding Lesson 207 — What is Scope?Lesson 212 — Variable Lifetime Basics Lesson 215 — Scope and Lifetime: The Key Difference
Scope resolution: traverses nodes to bind identifiers to declarations; Lesson 2039 — Abstract Syntax Trees (ASTs) as IR
Search: Treat tombstones like occupied slots—keep probing.; Lesson 427 — Deletion in Open Addressing Lesson 468 — What is Tree Traversal?Lesson 513 — BST Deletion: Complete Implementation Lesson 522 — Best-Case BST Analysis Lesson 523 — Worst-Case BST Analysis Lesson 544 — AVL Operation Complexity Lesson 545 — AVL Trees vs Unbalanced BSTs Lesson 626 — Time Complexity of Trie Operations (+3 more)
Search all cache lines: in parallel; Lesson 1130 — Fully Associative Caches
Search from a corner: (row-sorted, column-sorted): Start at the top-right or bottom-left corner.; Lesson 819 — Binary Search in 2D Matrices
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
Search strategy: With explicit spaces, you could precompute distances or relationships; implicit spaces require runtime generation using your successor function; Lesson 2736 — Explicit vs Implicit State Spaces
Search the free list: to find a suitable block of memory large enough for your request; Lesson 2080 — Stack vs Heap: Allocation Speed
search tree: of possibilities.; Lesson 865 — Pruning and Optimization Lesson 2729 — State Space Graphs vs Search Trees Lesson 2737 — Redundant Paths and Graph Search
Search/Lookup: Find a value by key or check if an element exists; Lesson 442 — Dictionary and Set Implementations
Searches: its database for facts and rules that could match; Lesson 2159 — Queries and Unification
Searching: is checking each mailbox until you find what you need.; Lesson 239 — Common Array Operations Lesson 555 — Red-Black vs AVL Trees: Tradeoffs Lesson 622 — Trie Search: Exact Match Queries Lesson 839 — Multiple Pattern Matching: Aho-Corasick
Second column: 1 + 1 = 0, carry 1; Lesson 5 — Binary Addition
Second pass: Merge adjacent sorted subarrays of size 2 into sorted subarrays of size 4.; Lesson 760 — Bottom-Up Mergesort
Second preimage resistance: prevents document forgery—can't substitute a malicious file for a legitimate one with the same hash; Lesson 2421 — Properties of Cryptographic Hash Functions Lesson 2423 — Second Preimage Resistance Lesson 2424 — Collision Resistance Lesson 2427 — SHA-2 Family
Second-order injection: If an ORM retrieves malicious data from the database and later uses it unsafely in another query, injection can still occur.; Lesson 2481 — ORM and SQL Injection Protection
secondary clustering: can still occur when different keys share the same initial hash.; Lesson 436 — Open Addressing Performance Characteristics Lesson 437 — Primary and Secondary Clustering Effects
Secondary Storage (SSD/HDD): Much lower bandwidth (0.; Lesson 1113 — Memory Bandwidth Considerations
Secret: Lesson 2530 — Mandatory Access Control (MAC)
Secrets management: (API keys, credentials); Lesson 2394 — CI/CD Tools and Infrastructure
Secure Communication: All HTTP data is encrypted using fast **symmetric algorithms** (like AES) and authenticated with **hash functions** (via MACs) to prevent tampering.; Lesson 2442 — TLS: The Security Layer Behind HTTPS
Secure storage: Protecting private keys from theft (hardware security modules help here); Lesson 2417 — Key Distribution and Management
security: .; Lesson 415 — Cryptographic vs Non-Cryptographic Hash Functions Lesson 1457 — VLANs (Virtual LANs)Lesson 1530 — Symmetric vs Asymmetric Encryption in TLS Lesson 2500 — Token-Based Authentication Lesson 2519 — Inherence Factors (Something You Are)
Security exploits: Attackers can carefully overwrite metadata to redirect program execution to malicious code; Lesson 2090 — Memory Corruption and Buffer Overflows
Security questions: Answers to personal questions ("What street did you grow up on?; Lesson 2517 — Knowledge Factors (Something You Know)
Seeding: means populating your test database with known data before tests run.; Lesson 2253 — Test Data Management
Seek time: Moving the read/write head to the correct track (the slowest part, often 5-10ms); Lesson 1421 — Why Disk Scheduling Matters Lesson 1423 — First-Come, First-Served (FCFS) Scheduling
segment: Lesson 1440 — Encapsulation and Layer Communication Lesson 2789 — Clustering Fundamentals
Segment number (s): Identifies which segment the address belongs to; Lesson 1380 — Logical Address Translation in Segmentation
Segment trees: require more code: building the tree recursively, handling left and right children, managing lazy propagation for range updates.; Lesson 655 — Fenwick Tree vs Segment Tree Trade-offs
Segmentation: is a memory management scheme that divides the address space according to the program's **logical structure**.; Lesson 1378 — Segmentation Basics and Motivation
Select: the first activity (it finishes earliest); Lesson 882 — Activity Selection Problem Lesson 1559 — Relational Algebra Basics
Select a victim: – Which process loses resources?; Lesson 1327 — Deadlock Recovery Strategies
Select next process: The scheduler chooses which process runs next; Lesson 1229 — Context Switching Between Processes
Select quantifiers: Universal ( ∀) for "all/every" and existential (∃) for "some/there exists"; Lesson 51 — Translating English to Predicate Logic
Selecting top-k performers: from a leaderboard without full sorting; Lesson 821 — The Selection Problem Definition
selection problem: asks: *Given an unsorted array of n elements, how do you efficiently find the k-th smallest element?; Lesson 821 — The Selection Problem Definition Lesson 822 — Naive Selection via Sorting
Selection Sort: Unstable (the swap operation can move equal elements past each other); Lesson 751 — Comparing Elementary Sorts
selective: joins first—those that filter out the most rows early.; Lesson 1701 — Join Order Selection Lesson 2016 — Type Inference in Modern Languages
Selector: which elements this applies to (declarative query); Lesson 2150 — CSS: Declarative Styling
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-Describing: Each document carries its own field names and structure, making it human-readable and adaptable to change without schema migrations.; Lesson 1710 — Document Store Fundamentals Lesson 1719 — JSON and BSON Data Formats
Self-documenting code: type signatures show what functions expect and return; Lesson 2002 — Early Error Detection in Static Typing
Self-organizing teams: (a concept you've learned) can only truly self-organize when they control their workload and pace.; Lesson 2368 — Sustainable Development Pace
Self-Signed Certificate: The certificate wasn't issued by a recognized CA—the server signed it itself.; Lesson 2450 — Certificate Validation and Common Errors
Self-supervised learning: goes further by creating its own labels from unlabeled data, bridging the gap between supervised and unsupervised paradigms.; Lesson 2795 — Transfer Learning and Self-Supervised Learning
Self-training: Train on labeled data, predict labels for unlabeled data, add high-confidence predictions to training set, repeat; Lesson 2791 — Semi-Supervised Learning
Semantic Analysis: Lesson 2029 — The Translation Pipeline: Source to Machine Code
Semantic comparison: Application-level logic examines whether updates actually conflict (e.; Lesson 2700 — Conflict Detection in Eventual Consistency
Semantic rules: use **inference notation** to express judgments—statements about what's true during program evaluation.; Lesson 2019 — Semantic Rules and Judgments
Semantic undo: Don't literally reverse bits; apply business logic (e.; Lesson 2722 — Compensating Transactions
Semantic validation: ensures function calls have correct argument counts; Lesson 2039 — Abstract Syntax Trees (ASTs) as IR
Semantic violations: Breaking language rules before execution begins; Lesson 2032 — Error Detection: Compile-Time vs Runtime
semaphore: is a synchronization primitive built around an integer counter.; Lesson 1292 — Semaphore Definition and Purpose Lesson 1303 — Semaphores vs Mutexes vs Condition Variables
Semaphores: Control access to a limited number of resources; Lesson 1241 — Threading Challenges: Synchronization Needs Lesson 1303 — Semaphores vs Mutexes vs Condition Variables
Semi-automated: Model-assisted labeling where humans verify predictions; Lesson 2794 — Label Quality and Acquisition
Semi-supervised learning: lets you leverage both.; Lesson 2793 — Choosing the Right Learning Paradigm
SEMICOLON: (pattern: exactly the character `;`); Lesson 1939 — Tokens, Lexemes, and Patterns
Send a message: include your current counter value; Lesson 2628 — Lamport Timestamps
Send message: Increment your counter, attach entire vector to message; Lesson 2631 — Vector Clocks Fundamentals
Sends a value back: to wherever the function was called; Lesson 189 — Return Statements Lesson 199 — Return Statements and Values
Sensitive data exposure: Access to configuration files, credentials, source code; Lesson 2489 — Path Traversal and File Inclusion
Sensitivity to outliers: Extreme values can distort the fitted boundary, especially without regularization.; Lesson 2837 — Assumptions and Limitations of Logistic Regression
Sentinel Values: Store a special value (like `-1`, `null`, or `None`) at array positions where nodes don't exist.; Lesson 466 — Representing Null Children
Separate chaining: is one of the most straightforward solutions.; Lesson 419 — Separate Chaining: Concept Lesson 420 — Separate Chaining: Implementation Lesson 428 — Load Factor and Rehashing Lesson 430 — Comparing Collision Strategies Lesson 431 — Collision Resolution in Practice Lesson 433 — Average-Case Time Complexity Analysis Lesson 439 — Cache Performance and Memory Locality
Separate memories: Standard in modern pipelined processors; Lesson 1164 — Resolving Structural Hazards
Separation of Concerns: Lesson 2244 — Testing External Dependencies Lesson 2287 — Strategy Pattern Fundamentals
sequence: is simply an ordered list of elements.; Lesson 82 — Sequence Fundamentals and Notation Lesson 83 — Arithmetic and Geometric Sequences
Sequence Number: (32 bits): Marks the position of this segment's first data byte in the stream.; Lesson 1472 — TCP Segment Structure Lesson 1475 — Sequence Numbers and Acknowledgments
sequence numbers: that track bytes sent in each direction.; Lesson 1473 — TCP Three-Way Handshake Lesson 2592 — Message Loss and Ordering
Sequence of Decisions: The same leader coordinates consensus for instance 1, 2, 3, and so on, sending only accept requests; Lesson 2681 — Multi-Paxos: Optimizing for Multiple Decisions
Sequential: Log files, video streaming, batch processing, backups; Lesson 1391 — Sequential vs Random Access Lesson 2113 — Command-Based Execution Model Lesson 2859 — Gradient Boosting Fundamentals
Sequential Access: Lesson 805 — Cache-Friendly Sorting Techniques Lesson 1391 — Sequential vs Random Access
Sequential access patterns: When work naturally serializes, locks add less overhead; Lesson 2574 — Performance Characteristics of Lock-Free Algorithms
sequential consistency: all operations appear to execute in program order, as if on a single processor.; Lesson 2569 — Memory Ordering and Happens-Before Lesson 2612 — Sequential Consistency Lesson 2621 — Consistency vs Availability Tradeoffs
Sequential data: Matching consecutive records (e.; Lesson 1583 — Self Join
Sequential ID enumeration: Trying `id=1`, `id=2`, `id=3` to harvest all user accounts; Lesson 2484 — Insecure Direct Object References (IDOR)
Sequential ordering: All nodes agree on the order of operations; Lesson 2601 — Consistency in Distributed Systems
Sequential Scan: Read every row in a table (like reading a book page-by-page); Lesson 1698 — Query Execution Plans and Operators
Sequential statements: that execute one after another; Lesson 2112 — What is Imperative Programming?
Serial Number: Unique identifier for tracking; Lesson 1532 — Digital Certificates Fundamentals
Serializable: isolation level is the strongest of the four standard isolation levels.; Lesson 1672 — Serializable Isolation Level Lesson 1674 — Isolation Level Trade-offs Lesson 2723 — Distributed Transaction Isolation Levels
Serializable in distributed systems: The gold standard requires ensuring no two transactions conflict in ways that create cycles.; Lesson 2723 — Distributed Transaction Isolation Levels
Serialization differences: The same data might encode differently across platforms; Lesson 2596 — Heterogeneity of Hardware and Software
Server: (web server hosting content) processes the request and sends back an HTTP response; Lesson 1514 — HTTP Overview and Client-Server Model Lesson 1541 — Socket Fundamentals and Client- Server Model
Server Certificate: The actual certificate for `example.; Lesson 2446 — The Certificate Chain of Trust
Server Hello: The server picks a TLS version and cipher from the client's list, then responds with its choice and its **digital certificate** (containing its public key).; Lesson 1525 — HTTPS Handshake Process Lesson 2448 — Cipher Suites: Negotiating Encryption Algorithms
Server recognizes you: The server reads the cookie value and retrieves your session data (cart contents, login status, preferences, etc.; Lesson 1522 — HTTP Cookies and State Management
Server sets cookie: In an HTTP response header, the server includes:; Lesson 1522 — HTTP Cookies and State Management
Server-side hooks: run on the remote repository during push operations:; Lesson 2210 — Git Hooks
Server-Side Request Forgery (SSRF): External entities can reference URLs, forcing the server to make requests to internal resources or external sites, potentially bypassing firewalls.; Lesson 2486 — XML External Entity (XXE) Injection
Server's IP address: – where the server is located on the network; Lesson 1544 — TCP Client: Connect to Server
Server's port number: – which application on that server to reach; Lesson 1544 — TCP Client: Connect to Server
ServerHello: Lesson 2443 — The TLS Handshake: Establishing Secure Connections
Service Virtualization: Lesson 2244 — Testing External Dependencies
Service-to-service: one backend system accessing another's API resources; Lesson 2534 — OAuth 2.0 Overview and Use Cases
session: and issues a unique **session token** (or session ID)—a random, unpredictable string that acts like a temporary badge.; Lesson 2497 — Session Management Basics Lesson 2501 — Cookie-Based Authentication Lesson 2619 — Session Consistency Models
session consistency: offers a middle ground: instead of guaranteeing consistency globally, you guarantee it *per client session*.; Lesson 2619 — Session Consistency Models Lesson 2624 — Choosing the Right Consistency Model
Session establishment and teardown: (starting and ending conversations); Lesson 1437 — OSI Upper Layers: Session, Presentation, Application
Session hijacking: Lesson 2458 — XSS Attack Vectors and Payloads
Session ID lookups: `WHERE session_id = 'abc123'`; Lesson 1696 — Hash Indexes in Practice
Session Keys Created: Both sides independently derive the same symmetric encryption keys from the pre-master secret.; Lesson 1525 — HTTPS Handshake Process
Session Keys Generation: Lesson 2443 — The TLS Handshake: Establishing Secure Connections
Session Layer: – Manages connections and sessions between applications; Lesson 1432 — The OSI Model: Seven-Layer Overview Lesson 1437 — OSI Upper Layers: Session, Presentation, Application
Session resumption: solves this by allowing clients and servers to skip most of the handshake on subsequent connections.; Lesson 2452 — HTTPS Performance: Session Resumption
Session storage: Minor staleness rarely matters; Lesson 1734 — Eventual Consistency Trade-offs
Session tickets: flip the storage burden to the client.; Lesson 2452 — HTTPS Performance: Session Resumption
Session-level (most common): Lesson 1675 — Setting Isolation Levels in Practice
set: is simply a collection of distinct objects, called **elements** (or members).; Lesson 58 — Set Fundamentals and Notation Lesson 442 — Dictionary and Set Implementations Lesson 1132 — Set-Associative Caches Lesson 1571 — UPDATE Statement for Modifying Data
Set `head` to `NULL`: there's no first node; Lesson 340 — Doubly Linked List Initialization and Empty List
Set `tail` to `NULL`: there's no last node; Lesson 340 — Doubly Linked List Initialization and Empty List
Set current index: `i = n`; Lesson 587 — Implementing Heap Insert
set index: to select one specific set; Lesson 1133 — Set-Associative Address Mapping Lesson 1135 — Cache Placement Example Calculations
Set index bits: – determine which set the block maps to; Lesson 1133 — Set-Associative Address Mapping
Set k = m: We look for an independent set of size *m* (the number of clauses).; Lesson 1934 — 3-SAT to Independent Set Reduction
Set up auxiliary space: Create a temporary array to hold the merged result; Lesson 754 — The Merge Operation
Set-associative: (2-way, 4-way, 8-way, etc.; Lesson 1134 — Comparing Associativity Tradeoffs
Set-builder notation: describes sets using a rule or condition, similar to how we used predicates:; Lesson 58 — Set Fundamentals and Notation
Sets: are precise for definitions; Lesson 68 — Representing Relations Lesson 442 — Dictionary and Set Implementations Lesson 1132 — Set- Associative Caches Lesson 1133 — Set-Associative Address Mapping
Setup: and **teardown** methods let you define this preparation and cleanup logic *once* and have it automatically run before and after each test (or once per test suite).; Lesson 2229 — Test Fixtures and Setup
SHA-1: Google demonstrated a practical collision in 2017, proving it violated collision resistance—one of the fundamental properties you learned earlier.; Lesson 2426 — Common Hash Functions: MD5 and SHA-1
SHA-224: , **SHA-256**, **SHA-384**, **SHA-512**, **SHA-512/224**, and **SHA-512/256**.; Lesson 2427 — SHA-2 Family
SHA-256: , **SHA-384**, **SHA-512**, **SHA-512/224**, and **SHA-512/256**.; Lesson 2427 — SHA-2 Family
SHA-3: in 2015.; Lesson 2428 — SHA-3 and Keccak
SHA-384: , **SHA-512**, **SHA-512/224**, and **SHA-512/256**.; Lesson 2427 — SHA-2 Family
SHA-512: , **SHA-512/224**, and **SHA-512/256**.; Lesson 2427 — SHA-2 Family
SHA-512/224: , and **SHA-512/256**.; Lesson 2427 — SHA-2 Family
SHA-512/256: .; Lesson 2427 — SHA-2 Family
Shadowing: occurs when you declare a local variable with the same name as a global variable.; Lesson 211 — Shadowing: When Names Collide
shallow copy: creates a new array and copies the values from the original.; Lesson 240 — Array Copying and Cloning Lesson 2272 — Prototype Pattern and Cloning
Shape: Is every level filled left-to-right?; Lesson 582 — Heap Shape vs Heap Order
Shape rule: "Books must fill shelves left-to-right, top-to-bottom, no gaps.; Lesson 582 — Heap Shape vs Heap Order
shard key: a field used to determine which shard holds each record.; Lesson 2684 — Sharding Fundamentals Lesson 2685 — Partition Keys and Shard Keys
sharding: ).; Lesson 2682 — Introduction to Data Partitioning Lesson 2683 — Horizontal vs Vertical Partitioning
shareable: , we break a fundamental requirement for deadlock.; Lesson 1319 — Deadlock Prevention: Breaking Mutual Exclusion Lesson 2517 — Knowledge Factors (Something You Know)
Shared + Exclusive: Incompatible (reader blocks writer, writer blocks reader); Lesson 1662 — Locking Mechanisms for Isolation
Shared + Shared: Compatible (multiple readers coexist); Lesson 1662 — Locking Mechanisms for Isolation
Shared accountability: Success and setbacks belong to everyone, not individuals; Lesson 2367 — Self-Organizing Teams
Shared hosting providers: serving thousands of HTTPS sites from limited IP addresses; Lesson 2449 — Server Name Indication (SNI)
Shared libraries: Standard library code segments can be shared across all processes using them.; Lesson 1381 — Segmentation with Protection and Sharing
Shared locks: (read locks) allow multiple processes to read a file simultaneously.; Lesson 1393 — File Locking Mechanisms
Shared Locks (Read Locks): Lesson 1662 — Locking Mechanisms for Isolation
Shared physical memory: One table for the entire system, not per-process; Lesson 1360 — Inverted Page Tables
Shared responsibility: Both sides commit to the project's success, not just fulfilling contractual obligations; Lesson 2364 — Customer Collaboration Over Contract Negotiation
Shared secret: Lesson 2411 — Diffie-Hellman Key Exchange
Sharing: Multiple processes can map the same file for efficient inter-process communication; Lesson 1394 — Memory-Mapped Files
Sharing easier: Multiple processes can share the same code segment; Lesson 1383 — Segmentation vs Paging Trade-offs
shift: all elements between that position and where your element currently sits.; Lesson 749 — Insertion Sort: Binary Search Optimization Lesson 1960 — Bottom-Up Parsing Overview Lesson 1962 — Shift-Reduce Parsing Actions
Shift Left: (`SHL reg, count`): Moves all bits left, filling with zeros on the right.; Lesson 1097 — Logical and Bitwise Instructions
Shift n: Push the current token and move to state n; Lesson 1966 — LR(0) Parsing Tables
Shift Right: (`SHR reg, count`): Moves bits right.; Lesson 1097 — Logical and Bitwise Instructions
Shifting (`+b`): If you add 10 to every value in a dataset, the values all move together.; Lesson 136 — Variance of Linear Transformations
Shifting does nothing: Adding a constant `b` has **zero effect** on variance; Lesson 136 — Variance of Linear Transformations
Shopping cart contents: Lost carts are annoying but not catastrophic.; Lesson 1665 — ACID Tradeoffs and Real-World Implications
Shopping cart services: Let you add items even during backend issues; Lesson 2606 — AP Systems: Availability and Partition Tolerance
Short critical sections: The work protected is minimal anyway; Lesson 2574 — Performance Characteristics of Lock-Free Algorithms
Short timeouts: Risk declaring healthy-but-slow nodes as failed, potentially cascading failures; Lesson 2591 — Partial Failures and Fault Detection
Short-circuit evaluation: means the language stops checking as soon as it knows the final answer.; Lesson 159 — Short-Circuit Evaluation Lesson 173 — Short-Circuit Evaluation
Short-circuit potential: Combined with higher-order functions like `filter` or `map`, lazy evaluation can stop processing early once a condition is met, rather than transforming entire collections upfront.; Lesson 2139 — Lazy Evaluation
Short-term thinking: Solving today's problem while creating tomorrow's crisis; Lesson 2301 — Introduction to Anti-Patterns
Shortest path: All black nodes (no reds allowed between blacks on this minimal route); Lesson 547 — Red-Black Tree Height Guarantees Lesson 699 — Shortest Path in Unweighted Graphs
Shortest path + unweighted: → BFS; Lesson 708 — BFS Applications and Problem Patterns
Shortest path in maze: BFS finds the minimum steps from start to exit; Lesson 704 — BFS in Grid Graphs
Shortest paths: BFS naturally finds shortest paths while discovering the component; Lesson 731 — Component Finding with BFS
Shotgun Surgery: is exactly this problem in code.; Lesson 2337 — Shotgun Surgery Smell
Show: this exchange doesn't worsen the solution (maintains optimality); Lesson 906 — Proof by Exchange Argument Lesson 1807 — Using the Pumping Lemma to Prove Non- Regularity Lesson 1885 — Reductions from the Halting Problem
Show the inequality holds: for all n beyond that threshold; Lesson 294 — Proving Big-Theta Bounds
Shrink: (optional) when the queue becomes mostly empty (e.; Lesson 381 — Dynamic Array-Based Queue Lesson 1457 — VLANs (Virtual LANs)
Shrinking Range: After each pass, the largest unsorted element "bubbles" to its final position at the end.; Lesson 743 — Bubble Sort: Optimization
Siblings: are nodes that share the same parent.; Lesson 451 — Root, Parent, Child, and Sibling Nodes
side effect: happens when evaluating an expression *changes something* beyond just producing a value.; Lesson 164 — Expression Evaluation and Side Effects Lesson 201 — Void Functions and Side Effects Lesson 2115 — Assignment and Side Effects
Side effects: Memory writes, I/O operations happen in the correct order; Lesson 2060 — Optimization Phases and Safety
Side effects multiply: Functions that modify global state create hidden dependencies between distant code sections; Lesson 2121 — Imperative Style Tradeoffs
sign: (positive or negative); Lesson 1064 — Floating-Point Representation Overview Lesson 2438 — ECDSA (Elliptic Curve Digital Signature Algorithm)
sign bit: Lesson 1057 — Signed Integers: Sign-Magnitude Representation Lesson 1064 — Floating-Point Representation Overview
Sign-magnitude representation: solves this by dedicating the leftmost bit (the most significant bit) as a **sign bit**:; Lesson 1057 — Signed Integers: Sign-Magnitude Representation
Signal: (sometimes called V or up): Increments the counter and potentially wakes a waiting thread.; Lesson 1292 — Semaphore Definition and Purpose Lesson 1304 — Condition Variable Basics
Signal encoding: How to convert bits into physical signals that can travel long distances with minimal errors; Lesson 1441 — Physical Layer Overview Lesson 1443 — Signal Encoding and Modulation
Signal Operation: (also called **V**, from Dutch "verhogen" = to increment, or **up**):; Lesson 1294 — Wait (P) and Signal (V) Operations
Signal-Wait Inversion: Lesson 1302 — Semaphore Pitfalls and Common Errors
Signal/V: Return your ticket when done.; Lesson 1294 — Wait (P) and Signal (V) Operations
Signaling between threads: One thread can signal another that an event occurred; Lesson 1292 — Semaphore Definition and Purpose
Signals flow through: Binary values (0s and 1s) travel through the circuit from inputs to outputs; Lesson 21 — Building Complex Circuits from Basic Gates
Signature Verification: Each signature in the chain is cryptographically verified using the issuer's public key.; Lesson 2450 — Certificate Validation and Common Errors
signed: integer can represent values from -128 to 127; Lesson 150 — Signed vs Unsigned Integers Lesson 1062 — Integer Width and Range Tradeoffs
Signed integers: can be positive, negative, or zero.; Lesson 150 — Signed vs Unsigned Integers
Significand (or mantissa) field: The actual significant digits in binary; Lesson 1064 — Floating-Point Representation Overview
Signing: Lesson 2435 — RSA Digital Signature Scheme
Silent corruption: Sometimes the program continues running with corrupted data, causing unpredictable bugs much later; Lesson 2090 — Memory Corruption and Buffer Overflows
SIM swapping attacks: Attackers convince your carrier to transfer your number to their SIM card; Lesson 2521 — SMS and Email-Based MFA
Simple: to implement; Lesson 878 — What Makes an Algorithm Greedy?
Simple access patterns: without complex JOINs; Lesson 1717 — NoSQL vs SQL: Complementary Approaches
Simple addressing: Finding any byte requires minimal calculation—just offset from the starting block.; Lesson 1399 — File Allocation Methods: Contiguous
Simple and fast: , but disastrous on already-sorted or reverse-sorted data—it creates the worst case every time.; Lesson 764 — Choosing a Pivot: Strategies and Tradeoffs
Simple arithmetic calculations: Adding numbers, computing averages with running totals; Lesson 305 — Constant Space: O(1)
Simple attribute lookups: (session data, cache entries) → **Key-Value stores**; Lesson 1715 — Choosing the Right NoSQL Category
Simple conceptually: Two clear, separate phases; Lesson 2096 — Mark-and-Sweep Collection
Simple encryption: XORing data with a secret key scrambles it; XORing again with the same key unscrambles it (because A XOR B XOR B = A); Lesson 17 — The XOR Gate (Exclusive OR)
simple graph: is the most restricted type: between any pair of vertices, there can be *at most one edge*, and vertices cannot have edges to themselves (no loops).; Lesson 660 — Simple Graphs and Multigraphs Lesson 686 — Simple Graphs and Multigraphs
Simple graphs: are cleaner mathematically and more memory-efficient.; Lesson 686 — Simple Graphs and Multigraphs Lesson 687 — Self-Loops and Their Implications Lesson 688 — Complete Graphs
Simple implementation: The thread library runs entirely in user space with no kernel support needed.; Lesson 1234 — Multithreading Models: Many-to-One Lesson 2097 — Copying Collection
Simple links: Clicking an innocent-looking URL executes the request; Lesson 2472 — State-Changing Operations and Safe Methods
Simpler design: Easier to implement in hardware and analyze for security; Lesson 2428 — SHA-3 and Keccak
Simpler operations: Insertion just increments a counter; deletion decrements (remove node when count hits zero); Lesson 528 — BST with Duplicate Keys
Simpler syntax: No need for dereference operators; use them like normal variables; Lesson 320 — References as Aliases
Simpler to process: in automated reasoning systems; Lesson 57 — Prenex Normal Form
SimpleStrategy: Copies to adjacent nodes (development only); Lesson 1743 — Consistency and Replication in Column Stores
Simplicity: Lesson 987 — Bellman-Ford vs Dijkstra Comparison Lesson 1339 — What is Virtual Memory?Lesson 2040 — Three-Address Code (TAC)Lesson 2116 — Sequential Control Flow Lesson 2123 — Encapsulation and Information Hiding Lesson 2236 — Big Bang Integration Strategy Lesson 2639 — Leader-Based Replication Lesson 2851 — Cost-Complexity Pruning
Simplicity vs. Safety: First/last pivots are trivial to implement but risky.; Lesson 764 — Choosing a Pivot: Strategies and Tradeoffs
Simplification: Programmers write code assuming their program starts at address 0 and has a predictable memory layout (code, data, heap, stack).; Lesson 1331 — The Address Space Abstraction
Simplifies management: Update junior role permissions once, and they propagate upward; Lesson 2527 — RBAC Hierarchies
Simplify: complex expressions into shorter, clearer forms; Lesson 1776 — Regular Expression Equivalence
Simplify Boolean expressions: in circuits and code; Lesson 41 — De Morgan's Laws
Simplify operations: Move infrequently-used logic out of the critical path; Lesson 1155 — Balancing Pipeline Stages
Simulate: Run *M* on *w* step-by-step, tracking the current state as you read each symbol; Lesson 1871 — The Acceptance Problem for DFAs
Simulate that process finishing: Add its currently allocated resources back to `work` (as if it released them).; Lesson 1325 — Banker's Algorithm: Safety Check
Simulates: whether a safe sequence exists where all processes can finish; Lesson 1324 — The Banker's Algorithm
simultaneously: .; Lesson 1459 — Switch Performance Metrics Lesson 1526 — HTTP/2 Protocol Improvements
Since C₁ < C₂: , we have f(n) ≤ C₁ < C₂ = f(goal), meaning A* should have expanded n before selecting the suboptimal goal — **contradiction!; Lesson 2753 — A* Optimality and Admissibility
Single character `a`: Two states connected by an edge labeled `a`; Lesson 1942 — From Regular Expressions to Finite Automata
Single column: Group by genre (all Fiction together, all Science together); Lesson 1599 — Grouping by Multiple Columns
Single elements: Arrays with one item, strings with one character—minimal valid inputs often expose logic errors.; Lesson 2228 — Testing Edge Cases and Boundaries
Single field: Queries filtering on one attribute; Lesson 1723 — Indexing Document Fields
Single Instruction, Multiple Data: .; Lesson 2550 — Parallel Without Concurrent: SIMD Operations
Single lock: protecting both operations (simpler, less concurrent); Lesson 2578 — Concurrent Queue: Array-Based Implementation
Single node: That node is the middle; Lesson 337 — Finding the Middle Node Lesson 345 — Deleting from the Tail of a Doubly Linked List
single point of failure: .; Lesson 2637 — Introduction to Replication Lesson 2639 — Leader-Based Replication
single responsibility: for tests—each test validates one specific behavior.; Lesson 2225 — Anatomy of a Unit Test Lesson 2267 — Factory Method Pattern Basics Lesson 2296 — Chain of Responsibility Pattern
Single Responsibility Principle: states that every function should have one well-defined task or responsibility.; Lesson 193 — Single Responsibility Principle Lesson 194 — Function Composition Basics Lesson 2302 — God Object Anti-Pattern Lesson 2338 — Divergent Change Smell
Single Responsibility Principle (SRP): , which states that a class should have only one reason to change.; Lesson 2331 — Large Class Smell
single source of truth: during recovery.; Lesson 1407 — Write-Ahead Logging and Recovery Lesson 2529 — Policy-Based Access Control
Single value per cell: – Each intersection of row and column holds exactly one value; Lesson 1632 — First Normal Form (1NF) Definition
Single Zero: There's only one representation for zero (`0000`), unlike the previous methods.; Lesson 1059 — Two's Complement: The Standard for Signed Integers
Single-element heaps: Both insert and extract must handle the case where your heap has only one item (or will have one after the operation).; Lesson 600 — Practical Heap Implementation Considerations
Single-level: `AMAT = HitTime_L1 + MissRate_L1 × MissPenalty_L1`; Lesson 1147 — Multi-Level Cache Performance Analysis
Single-line comments: (e.; Lesson 1945 — Handling Whitespace and Comments
Single-pass array traversals: are the classic example:; Lesson 285 — O(n): Linear Time
Singleton: Use when you need exactly one instance accessible globally (database connections, configuration managers).; Lesson 2273 — Choosing the Right Creational Pattern
Singleton pattern: might try to make everything a singleton, even objects that should naturally have multiple instances.; Lesson 2304 — Golden Hammer Anti-Pattern
Singly Linked Lists: Lesson 348 — Doubly vs Singly Linked Lists: Tradeoffs
sink: (where it exits).; Lesson 1023 — Flow Conservation Constraint Lesson 1026 — Maximum Flow Problem Statement Lesson 1051 — Image Segmentation with Min-Cut Lesson 1054 — Circulation with Demands
Sink (t): Suburbs where everyone goes; Lesson 1022 — Flow Networks and Definitions Lesson 1053 — Baseball Elimination Problem
sink node: (where flow terminates); Lesson 1034 — Maximum Flow Problem Definition Lesson 1052 — Project Selection Problem
size: .; Lesson 235 — Array Length and Bounds Lesson 356 — The Stack ADT Definition Lesson 362 — Array- Based Stack Implementation Lesson 456 — Subtrees and Their Properties Lesson 1107 — Storage Pyramid Levels Lesson 1388 — File Attributes and Metadata Lesson 1722 — Querying Nested Fields Lesson 2715 — Message Queue Performance Considerations (+1 more)
Size the array: Calculate the maximum index you'll need based on tree height; Lesson 467 — Converting Between Representations
Size Tracking: Lesson 386 — Queue Invariants and Correctness
SJF/SRTF: minimize average waiting time theoretically, but can starve long processes and require predicting burst times.; Lesson 1261 — Comparing Scheduling Algorithm Performance
Skip an edge: if both endpoints are already connected (would create a cycle); Lesson 1014 — Kruskal's Algorithm: Overview
Skip count: how many bits/characters to jump forward; Lesson 633 — Patricia Tries (PATRICIA)
Skip merge when sorted: Before merging, check if `array[mid] <= array[mid+1]`.; Lesson 759 — Optimizing Mergesort
Skip sentinel values: If `array[index]` is null/sentinel, don't create that child; Lesson 467 — Converting Between Representations
Slave nodes: synchronize to the master; Lesson 2635 — Precision Time Protocol (PTP)
Sliding window minimums: Monotonic queue optimization.; Lesson 964 — Choosing the Right Optimization
Slightly further away: but still on-chip; Lesson 1121 — Cache Levels: L1, L2, L3
Slightly impure: 8 samples class A, 2 samples class B → `p_A = 0.; Lesson 2842 — Impurity Measures: Entropy
Sloppy quorums: relax this requirement during network partitions.; Lesson 2644 — Quorums and Sloppy Quorums
Slow execution: E2E tests interact with the full application stack (UI, APIs, databases), making them 10–100× slower than unit tests.; Lesson 2254 — E2E Testing Challenges and Best Practices
Slow node: Processing your request but taking 10 seconds instead of 100ms; Lesson 2591 — Partial Failures and Fault Detection
Slow pointer: moves one node at a time; Lesson 338 — Detecting Cycles in a List
Slower reads: Join operations take time, especially with large datasets; Lesson 1645 — Normal Form Trade-offs
Slower than L1: (10-20 CPU cycles); Lesson 1121 — Cache Levels: L1, L2, L3
Slower than L2: (40-75 CPU cycles); Lesson 1121 — Cache Levels: L1, L2, L3
Slower, more complex writes: Now when a customer changes their name, you must update *every* order record, not just one customer row.; Lesson 1647 — Read Performance vs Write Complexity
SLR(1): stands for "Simple LR with 1 token lookahead.; Lesson 1967 — SLR(1) Parsing
Small datasets: For tiny collections, even a simple array might be faster due to cache locality and simplicity.; Lesson 530 — When to Use BSTs Lesson 2801 — Holdout Method Limitations
Small datasets (<1,000): Consider 60-40 or use k-fold cross-validation instead.; Lesson 2800 — Train-Test Split Ratios
Small k (e.g., k=1): Lesson 2865 — Choosing the Value of K
Small numbers (0-127): one byte, looks like ASCII; Lesson 27 — UTF-8 Encoding
Small subarrays: Mergesort's recursive overhead becomes wasteful on tiny subarrays (typically 10-20 elements).; Lesson 759 — Optimizing Mergesort
Small tables: Reading the whole table is faster than index overhead; Lesson 1702 — Index Selection for Queries
Small to medium datasets: where the training set fits comfortably in memory; Lesson 2872 — KNN in Practice: Applications and Limitations
Small Working Sets: Lesson 805 — Cache-Friendly Sorting Techniques
Small α: Penalizes complexity weakly → larger trees survive; Lesson 2851 — Cost-Complexity Pruning
Small-step: "First, we see `3 + 4 × 2`.; Lesson 2018 — Small-Step vs Big-Step Semantics
Small-step semantics: (also called *structural operational semantics* or *transition semantics*) models computation as a sequence of individual reduction steps.; Lesson 2018 — Small-Step vs Big-Step Semantics
Small, frequent commits: Breaking work into smaller chunks reduces overlap chances; Lesson 2200 — Handling Merge Conflicts in Teams
Smaller: Recursively search the left subtree; Lesson 503 — BST Search: Finding a Node Lesson 558 — B-Tree Invariants Lesson 595 — Delete Arbitrary Element
Smaller initial size: Uses less memory upfront, but may require frequent resizing and rehashing as items are added.; Lesson 440 — Space-Time Tradeoffs in Hash Tables
Smallest capacity: (typically 32-64 KB per core); Lesson 1121 — Cache Levels: L1, L2, L3
Smart Reference: Add extra behavior like reference counting or thread synchronization; Lesson 2280 — Proxy Pattern: Controlling Access to Objects
Smart teams combine tools: Lesson 1755 — Graph Database Limitations and Tradeoffs
snake_case: `first_name`, `total_score` (common in Python); Lesson 147 — Variable Naming Conventions Lesson 191 — Function Naming Conventions
Snapshot Isolation: Interesting hybrid—good consistency without as much locking, but uses more memory and storage for version tracking.; Lesson 1674 — Isolation Level Trade-offs Lesson 2723 — Distributed Transaction Isolation Levels
Snapshot isolation distributed: All nodes must agree on what "snapshot timestamp" means.; Lesson 2723 — Distributed Transaction Isolation Levels
Snapshot-at-the-beginning barriers: Record the *old* value being overwritten; Lesson 2102 — Write Barriers
Snapshots: Since old data isn't destroyed, you can keep references to previous versions essentially "for free" — just don't reclaim those blocks.; Lesson 1408 — Copy-on-Write File Systems
Social connections and recommendations: Use a graph database for relationship queries; Lesson 1716 — Polyglot Persistence Strategy
Social login: ("Sign in with Google/Facebook") - apps obtain your profile info without your password; Lesson 2534 — OAuth 2.0 Overview and Use Cases
Social media: You update your profile picture, but friends see the old photo for minutes or hours—confusing and frustrating.; Lesson 2610 — What is Consistency in Distributed Systems?
Social media feeds: A few seconds' delay in seeing likes is acceptable; Lesson 1734 — Eventual Consistency Trade-offs Lesson 2606 — AP Systems: Availability and Partition Tolerance
Social networks: Someone might have a relationship with themselves (e.; Lesson 687 — Self-Loops and Their Implications Lesson 694 — BFS Overview and Applications
Sockets: Endpoints for network or local process communication; Lesson 1389 — File Types and Classification
Soft affinity: The scheduler *tries* to keep a process on the same CPU when possible, but may migrate it for load balancing.; Lesson 1265 — Processor Affinity
Soft State: System state may change over time without new input, as updates propagate asynchronously across nodes; Lesson 2699 — The BASE Model: Basically Available, Soft State, Eventual
Softmax: is more elegant mathematically, directly models class probabilities, and often performs better when classes are mutually exclusive.; Lesson 2834 — Multiclass Logistic Regression
Software Development Lifecycle (SDLC): is a structured framework that defines the complete journey of building software—from the initial spark of an idea through planning, design, implementation, testing, deployment, and ongoing maintenance.; Lesson 2351 — What is a Software Development Lifecycle (SDLC)?
Software distribution: Verify downloads haven't been modified by attackers; Lesson 2429 — Hash Function Applications: Data Integrity
Solid-State Drive (SSD): ~100,000 nanoseconds (0.; Lesson 1110 — Access Time and Latency
Solid-state drives (SSD): flash memory storage; Lesson 1112 — Volatile vs Non-Volatile Memory
Solution: Use a **Harvard architecture** with physically separate instruction and data memories (or separate caches).; Lesson 1164 — Resolving Structural Hazards Lesson 2722 — Compensating Transactions
Solve advanced problems: like topological sorting and finding strongly connected components; Lesson 715 — DFS Discovery and Finish Times
solving: the puzzle from scratch might take hours, but **checking** whether someone else's completed puzzle is correct?; Lesson 1891 — The Class NP (Nondeterministic Polynomial)Lesson 1914 — Verification vs Solution
Solving that subproblem optimally: combines with your choice to form the optimal solution; Lesson 880 — Optimal Substructure in Greedy Problems
Some: student failed," you disprove it by showing **every** student passed.; Lesson 49 — Negating Quantified Statements Lesson 1607 — ANY, ALL, and SOME Operators
Some labeled, mostly unlabeled: ?; Lesson 2793 — Choosing the Right Learning Paradigm
Some proxies and firewalls: remove or modify them; Lesson 2470 — Origin and Referer Header Validation
Something you are: – Biometric data such as fingerprints, facial recognition, iris scans, or voice patterns; Lesson 2516 — What Is Multi-Factor Authentication (MFA)?
Something you have: – Physical devices like smartphones, security keys, smart cards, or one-time password generators; Lesson 2516 — What Is Multi-Factor Authentication (MFA)?
something you know: authentication (one factor).; Lesson 2496 — Username and Password Authentication Lesson 2516 — What Is Multi-Factor Authentication (MFA)?
sort: each bucket individually (often using insertion sort since buckets tend to be small).; Lesson 796 — Bucket Sort: Implementation Lesson 882 — Activity Selection Problem
Sort all edges: by weight (cost) from smallest to largest; Lesson 1014 — Kruskal's Algorithm: Overview
Sort arrival times: in one array; Lesson 896 — Minimum Platforms Problem
Sort buckets: Sort each bucket individually (often using insertion sort for small buckets); Lesson 795 — Bucket Sort: Partitioning the Range
Sort departure times: in another array; Lesson 896 — Minimum Platforms Problem
Sort items: by this ratio in descending order (highest first); Lesson 889 — Fractional Knapsack Problem
Sort jobs by profit: (highest first); Lesson 891 — Job Sequencing with Deadlines
sorted array: .; Lesson 390 — Priority Queue Array Implementation Lesson 526 — Comparing BST to Array and Linked List Lesson 610 — Heap as Priority Queue Implementation Lesson 809 — Review: Standard Binary Search
Sorted keys: Keys within a node are stored in ascending order; Lesson 556 — B-Tree Definition and Properties
sorted order: (left to right); Lesson 558 — B-Tree Invariants Lesson 1693 — Range Query Limitations
Sorted Output: Need all elements in order?; Lesson 474 — Inorder and Binary Search Trees
Sorted portion: the leftmost part, grows one element at a time; Lesson 744 — Selection Sort: Algorithm
Sorted region: (at the back); Lesson 780 — In-Place Sorting with Heapsort
Sorted String Table (SSTable): a sorted file of key-value pairs.; Lesson 1740 — Physical Storage: SSTables and Log-Structured Merge Trees
Sorted/reverse-sorted input: → linear chain → O(n) operations; Lesson 527 — Impact of Insertion Order
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?
Sorting edges: O(E log E) dominates; Lesson 1016 — Kruskal's Algorithm: Implementation and Analysis
Sorting first: by position gives us a natural left-to-right order; Lesson 900 — Policemen Catch Thieves Problem
Sorting happens by swapping: – we repeatedly swap the root (largest element) with the last unsorted position; Lesson 782 — Heapsort Space Complexity
Sound: but incomplete (never wrong, but miss cases), or; Lesson 1886 — Practical Approximations
Sounds: (music, voices); Lesson 1 — What is Binary and Why It Matters
source: (where water enters) to a **sink** (where it exits).; Lesson 1023 — Flow Conservation Constraint Lesson 1026 — Maximum Flow Problem Statement Lesson 1051 — Image Segmentation with Min-Cut Lesson 1054 — Circulation with Demands
Source (s): City center where all traffic starts; Lesson 1022 — Flow Networks and Definitions Lesson 1053 — Baseball Elimination Problem
Source registers: of instructions in early stages (Decode); Lesson 1174 — Hazard Detection Unit Design
Source/Destination Port: (16 bits each): Identify sending and receiving applications; Lesson 1472 — TCP Segment Structure
Space: 32 (`0100000`); Lesson 24 — ASCII: The Foundation Lesson 400 — Deque Time Complexity Analysis Lesson 839 — Multiple Pattern Matching: Aho-Corasick Lesson 1888 — Introduction to Complexity Classes
Space = O(n): Lesson 525 — Space Complexity of BSTs
Space complexity: measures how much memory (RAM) an algorithm requires relative to the size of its input.; Lesson 302 — What is Space Complexity?Lesson 308 — Recursion and Call Stack Space Lesson 504 — BST Search: Iterative Implementation Lesson 616 — Merging K Sorted Lists Lesson 618 — Top-K Elements Problem Lesson 625 — Memory Analysis of Tries Lesson 831 — String Search Problem and Naive Approach Lesson 2748 — Comparing Uninformed Strategies
Space Complexity: O(b^d): Lesson 2741 — BFS Implementation and Complexity
Space concerns: ?; Lesson 808 — Standard Library Sort Functions
Space Cost: Lesson 761 — Mergesort Applications and Tradeoffs
Space efficiency: Fewer nodes, especially for sparse dictionaries; Lesson 631 — Compressed Tries (Radix Trees)Lesson 1360 — Inverted Page Tables
Space efficiency through sharing: Common prefixes are stored only once.; Lesson 619 — What is a Trie? Motivation and Use Cases
Space overhead: More nodes mean more memory for pointers; Lesson 528 — BST with Duplicate Keys
Space Usage: Memoization uses space for the recursion call stack *plus* the cache.; Lesson 918 — Top-Down vs Bottom-Up Tradeoffs
Space: O(1): Lesson 748 — Insertion Sort: Analysis
Spanning Tree Protocol: ?; Lesson 1460 — Link Aggregation
sparse: (few edges relative to possible connections); Lesson 673 — Adjacency List: Structure with Linked Lists Lesson 675 — Adjacency List: Memory Efficiency Lesson 693 — Graph Density and Sparsity Lesson 999 — Floyd-Warshall vs Repeated Dijkstra Lesson 1020 — Comparing Kruskal's and Prim's Algorithms
Sparse Graph: `E << V²` (far fewer edges than possible); Lesson 680 — Choosing Representation by Graph Density Lesson 976 — Dijkstra's on Dense vs Sparse Graphs
sparse graphs: (few edges), you're paying for V² storage but only using a fraction of it.; Lesson 671 — Adjacency Matrix: Space-Time Tradeoffs Lesson 693 — Graph Density and Sparsity
Sparse memory usage: (many pointers point to null); Lesson 639 — Burst Tries
Sparse Storage: Only store actual nodes and track valid indices separately, though this complicates the simple parent-child index formulas you rely on (`2i+1`, `2i+2`).; Lesson 466 — Representing Null Children
spatial locality: .; Lesson 529 — Cache Performance and BSTs Lesson 682 — Memory Layout and Cache Performance Lesson 1118 — Principle of Locality Lesson 1120 — Cache Lines and Blocks Lesson 1146 — Impact of Block Size on Performance
Special case: If merging happens at the root and the root becomes empty (no keys left), the merged child becomes the new root, **decreasing the tree's height by one**.; Lesson 566 — Merging Nodes in B-Trees Lesson 1823 — Eliminating ε-Productions
Special Constraints: Lesson 799 — When to Use Which Sorting Algorithm
Special values: Zero, negative numbers, very large numbers, special characters, or format-breaking inputs (like `"O'Reilly"` in a name field with single quotes).; Lesson 2228 — Testing Edge Cases and Boundaries
Specific hot paths: Use pragmas to force inline a critical function even at `-O1`, or disable vectorization where it causes issues; Lesson 2073 — Optimization Levels and Pragmas
Specific performance hotspots: One critical query dominates your performance profile; Lesson 1646 — Introduction to Denormalization
speed: .; Lesson 415 — Cryptographic vs Non-Cryptographic Hash Functions Lesson 1070 — Hardware Trade-offs in Number Representation Lesson 1107 — Storage Pyramid Levels Lesson 1195 — Monolithic Kernel Architecture Lesson 1973 — Parser Generators and YACC/Bison Lesson 2168 — Git vs Other Version Control Systems Lesson 2236 — Big Bang Integration Strategy Lesson 2240 — Sandwich Integration Testing (+2 more)
Speed vs Compilation Time: Advanced loop optimizations take minutes to analyze but save microseconds per iteration.; Lesson 2059 — Optimization Goals and Tradeoffs
Speed vs Memory: Memoization speeds up repeated calculations but stores results in memory.; Lesson 2059 — Optimization Goals and Tradeoffs
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
Speed-critical applications: Choose larger tables and low load factors; Lesson 440 — Space-Time Tradeoffs in Hash Tables
Speedup: measures how much faster a system becomes after an optimization.; Lesson 1188 — Speedup and Amdahl's Law Lesson 2552 — Parallelism Benefits: Speed and Throughput
Spell checkers: Quickly verify if a word exists; Lesson 619 — What is a Trie? Motivation and Use Cases
SPFA: "Let me only check edges from vertices that just got better distances!; Lesson 988 — SPFA: Shortest Path Faster Algorithm
Spin lock: Keep trying repeatedly in a tight loop (busy-waiting); Lesson 1287 — Spin Locks vs Blocking Locks
Spin locks: Low overhead, but waste CPU during wait; Lesson 1287 — Spin Locks vs Blocking Locks
Splay the target key: to make it the root (or splay the closest key if `k` doesn't exist); Lesson 573 — Splay Tree Deletion
Splay to Root: Once inserted as a leaf, apply the splaying operation to move this new node to the root position using the appropriate rotation cases (zig-zig, zig-zag, or zig); Lesson 572 — Splay Tree Insertion
splay trees: take a completely different approach: they automatically restructure themselves during every access operation.; Lesson 568 — Splay Trees: Self-Adjusting BSTs Lesson 575 — Splay Trees vs Other Balanced Trees
splaying operation: is the heart of splay trees.; Lesson 569 — The Splaying Operation Lesson 571 — Splay Tree Search
split: the node into two smaller nodes and push the middle key up to the parent.; Lesson 561 — Node Splitting During Insertion Lesson 854 — Fast Fourier Transform (FFT) Overview Lesson 1681 — Node Splitting During Insertion Lesson 1807 — Using the Pumping Lemma to Prove Non- Regularity
Split complex stages: Break a heavy Execute stage into Execute1 and Execute2; Lesson 1155 — Balancing Pipeline Stages
Split inversions: When merging, if we pick an element from the right subarray before exhausting the left, all remaining left elements form inversions with it (they're larger and appear earlier in the original array); Lesson 852 — Count Inversions in Array
Split on a feature: Divide data into subsets based on feature values; Lesson 2843 — Information Gain
Split the full root: into two nodes, just like any node split; Lesson 562 — Splitting Root Nodes
splits: ; when it underflows (too few), nodes **merge** or **borrow** keys.; Lesson 1677 — B-Tree Structure and Properties Lesson 1820 — Chomsky Normal Form (CNF)
Splitting criteria differ: Classification uses information gain; regression uses variance reduction; Lesson 2839 — Classification vs Regression Trees
Splitting ranges optimally: Divide and conquer optimization if constraints satisfy monotonicity.; Lesson 964 — Choosing the Right Optimization
Spreadsheet formulas: calculate cell dependencies; Lesson 720 — Topological Sort Applications
Spring Framework: `HandlerAdapter` interface allows different controller types (annotated methods, `Controller` implementations) to work uniformly with the dispatcher servlet.; Lesson 2285 — Real-World Structural Pattern Examples
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
Spurious wakeups: Wait can return even when not signaled; Lesson 1306 — The Wait-Signal Pattern
SQL: (Structured Query Language) is a *declarative* programming language designed specifically for working with relational databases.; Lesson 1561 — SQL Introduction and Purpose
SQL Injection: or **XSS**, which target specific layers, insecure deserialization can compromise the entire application server.; Lesson 2490 — Insecure Deserialization
Square footage: ranges from 500 to 5000 (large numbers); Lesson 2868 — Feature Scaling in KNN
Square matrices: (n × n) simplify to **O(n²)** because both dimensions are the same.; Lesson 311 — Analyzing Multi-Dimensional Space
Squeezing phase: Output is extracted from the state by applying the same permutation repeatedly; Lesson 2428 — SHA-3 and Keccak
SS: (Stack Segment): points to the stack; Lesson 1385 — Segmentation in x86 Architecture
SS7 protocol weaknesses: Telecom infrastructure vulnerabilities allow message interception; Lesson 2521 — SMS and Email-Based MFA
SSA Form: LLVM IR uses Static Single Assignment form by default—each variable is assigned exactly once.; Lesson 2045 — LLVM IR Overview
SSD Storage: Lower cost—hundreds of gigabytes to terabytes; Lesson 1111 — Cost Per Byte Analysis
SSDs: NOOP or simpler schedulers (no seek penalty); Lesson 1430 — I/O Schedulers in Operating Systems
SSDs changed everything: They have no moving parts.; Lesson 1429 — Disk Scheduling in Modern Systems
SSH keys: Modern SSH implementations support ECDSA alongside RSA; Lesson 2438 — ECDSA (Elliptic Curve Digital Signature Algorithm)
SSL (Secure Sockets Layer): in the mid-1990s, developed by Netscape.; Lesson 2447 — TLS Protocol Versions: SSL to TLS 1.3
SSTable: (Sorted String Table).; Lesson 1741 — Read and Write Operations in Column Families
SSTables (Disk): When the MemTable fills up, it's flushed to disk as an immutable **Sorted String Table (SSTable)**—a sorted file of key-value pairs.; Lesson 1740 — Physical Storage: SSTables and Log-Structured Merge Trees
Stability: Mergesort preserves the relative order of equal elements; quicksort typically doesn't.; Lesson 774 — Quicksort vs Mergesort: Practical Comparison Lesson 808 — Standard Library Sort Functions
Stability Matters: Lesson 761 — Mergesort Applications and Tradeoffs
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
Stability: Stable: Lesson 748 — Insertion Sort: Analysis
stable: if it preserves the relative order of equal elements.; Lesson 606 — Heapsort Space Complexity and Stability Lesson 783 — Heapsort Stability Lesson 785 — Heapsort vs Mergesort Comparison Lesson 790 — Counting Sort: Stability Lesson 792 — Radix Sort: Digit- by-Digit Sorting Lesson 794 — Radix Sort: Implementation and Analysis Lesson 802 — Timsort: Python's Default Sorting Algorithm
stable sort: guarantees that when two elements compare as equal, they appear in the output in the same relative order as they did in the input.; Lesson 738 — Stability in Sorting Lesson 758 — Mergesort Stability
stack: .; Lesson 213 — Stack-Based Lifetime for Local Variables Lesson 322 — Dynamic Memory Allocation Basics Lesson 356 — The Stack ADT Definition Lesson 395 — Deque: Double-Ended Queue Fundamentals Lesson 399 — Deque vs Stack vs Queue Lesson 1102 — The Stack: PUSH and POP Operations Lesson 1230 — What is a Thread?Lesson 1371 — LRU Implementation Techniques (+5 more)
Stack alphabet: The symbols that can be pushed onto or popped from the stack; Lesson 1828 — Introduction to Pushdown Automata Lesson 1836 — Converting CFGs to PDAs
Stack behavior: Push and pop from one end (say, the back); Lesson 391 — Double-Ended Queue (Deque) Introduction
Stack contents: – what symbols are currently on the stack; Lesson 1829 — PDA Configurations and Instantaneous Descriptions
stack frame: and pushed onto the **call stack** — yes, literally using the Stack ADT you just learned!; Lesson 369 — Function Call Stack and Recursion Lesson 2075 — Stack Memory Fundamentals Lesson 2076 — Stack Frames and Activation Records
Stack overflow: Count how deep the recursion goes—maybe it's too deep for the input.; Lesson 230 — Debugging Recursive Functions Lesson 308 — Recursion and Call Stack Space Lesson 2077 — Stack Growth and Limitations Lesson 2082 — Stack vs Heap: Size Considerations
Stack segment: Lesson 1378 — Segmentation Basics and Motivation
Stack symbol to pop: from the top (or ε if no pop needed); Lesson 1830 — PDA Transition Functions
Stacking: shines when you have:; Lesson 2862 — Ensemble Selection and Hyperparameters
Stage the resolved file: with `git add filename`; Lesson 2188 — Resolving Merge Conflicts
Staged files: (also called "changes to be committed") are files you've added to the staging area with `git add`.; Lesson 2174 — Checking Repository Status
Staging: "Does it work with real services?; Lesson 2391 — Deployment Pipelines and Stages
Staging Area: (also called "Index") — where you prepare changes for commit; Lesson 2171 — The Three States of Git
Stakeholders: , including customers, executives, or end users, observe, ask questions, and provide honest reactions.; Lesson 2381 — Sprint Review
stall: the entire pipeline must wait.; Lesson 1158 — Multi-Cycle Instructions in Pipelines Lesson 1162 — Structural Hazards: Definition Lesson 1163 — Detecting Structural Hazards Lesson 1175 — Introduction to Branch Prediction
Stall the pipeline: when multi-cycle instructions appear; Lesson 1158 — Multi-Cycle Instructions in Pipelines
Stalling: Used when conflicts are rare; Lesson 1164 — Resolving Structural Hazards
Stalling (Pipeline Bubble): Lesson 1164 — Resolving Structural Hazards
Standard binary search: Once you've bounded the problem, run regular binary search between `left` and `right`.; Lesson 818 — Binary Search on Infinite Arrays
Standard deviation: solves this by taking the square root of the variance, bringing us back to the original units.; Lesson 135 — Standard Deviation
Standard Deviation = √(Variance): Lesson 135 — Standard Deviation
Standard Tries: use the most memory—each node may have an array of 26+ pointers (for alphabet letters), many unused.; Lesson 640 — Trie Variant Performance Comparison
Standardization: (zero mean, unit variance):; Lesson 2824 — Feature Scaling and Normalization
Standardization (z-score): Centers features around mean=0, std=1; Lesson 2868 — Feature Scaling in KNN
star: and **complement**.; Lesson 1804 — Closure Properties: Star and Complement Lesson 1826 — CFG Closure Properties
Star Pattern: One central "fact" table connects to multiple "dimension" tables via foreign keys.; Lesson 1587 — Multi-Table Join Patterns
Star properties: `(r*)* = r*` and `r*r* = r*`; Lesson 1776 — Regular Expression Equivalence
Start: Mark the starting vertex as visited and enqueue it; Lesson 696 — BFS with Adjacency List Lesson 894 — Meeting Room Scheduling Lesson 1017 — Prim's Algorithm: Overview Lesson 1969 — Canonical LR(1) Parsing
Start at index 0: of both strings; Lesson 267 — String Comparison: Character-by-Character
Start at root: Create the root node from `array[0]`; Lesson 467 — Converting Between Representations Lesson 621 — Trie Insertion: Adding Words
Start at the beginning: of your array; Lesson 741 — Bubble Sort: Algorithm
Start at the head: Create a pointer variable (often called `current`) and set it to the head pointer.; Lesson 327 — Traversing a Linked List Lesson 329 — Inserting at the Tail
Start at the leaf: node representing that index; Lesson 645 — Point Update Operations
Start at the root: with a pointer to track your current position; Lesson 507 — BST Insertion: Iterative Approach Lesson 622 — Trie Search: Exact Match Queries Lesson 623 — Prefix Search and StartsWith Operations Lesson 644 — Range Query Operations Lesson 2847 — Recursive Partitioning Algorithm
Start at the tail: – You already have direct access via your tail pointer; Lesson 345 — Deleting from the Tail of a Doubly Linked List
Start at the top: Test the main module or entry point of your system; Lesson 2238 — Top-Down Integration Testing
Start BFS: from the initial state; Lesson 705 — BFS with State Space Representation
Start by identifying uncertainty: Where in the input does something important happen that you'd need complex logic to track in a DFA?; Lesson 1798 — Designing NFAs: Exploiting Nondeterminism
Start from main: Create a new branch from the latest `main` branch; Lesson 2195 — Feature Branch Workflow
Start position: The index where your substring begins; Lesson 266 — Substring Extraction
Start simple: Use KNN as a strong baseline before trying complex models; Lesson 2872 — KNN in Practice: Applications and Limitations
Start small: Use 2-3 elements; Lesson 911 — Counterexamples: When Greedy Fails
Start stack symbol: An initial marker on the stack; Lesson 1828 — Introduction to Pushdown Automata
start state: gets a special **arrow pointing to it from nowhere** — this shows where the DFA begins reading input.; Lesson 1779 — DFA State Diagrams Lesson 1784 — Combining Conditions with Product Construction Lesson 1786 — DFAs for Union of Languages Lesson 1800 — Subset Construction: NFA to DFA Conversion Lesson 1828 — Introduction to Pushdown Automata Lesson 1851 — Components of a Turing Machine
Start symbol: Add `$` (end-of-input) to FOLLOW(S); Lesson 1957 — FOLLOW Sets
Start with a threshold: equal to the heuristic value of the start state: `f(start) = g(start) + h(start)`; Lesson 2761 — IDA* (Iterative Deepening A*)
Start with attribute combinations: – Begin with single attributes, then pairs, then triples, etc.; Lesson 1630 — Using FDs to Identify Candidate Keys
Start with quicksort: – Use randomized quicksort for its excellent average-case speed; Lesson 801 — Introsort: The Best of Both Worlds
Starting block address: (where the file begins); Lesson 1399 — File Allocation Methods: Contiguous
starvation: efficient but unfair.; Lesson 1249 — Scheduling Criteria Trade-offs Lesson 1254 — Shortest Remaining Time First (SRTF)Lesson 1258 — Priority Inversion and Aging Lesson 1318 — Deadlock vs Livelock vs Starvation Lesson 1424 — Shortest Seek Time First (SSTF)Lesson 1428 — Comparing Disk Scheduling Algorithms
Starvation risk: processes needing many resources may wait indefinitely; Lesson 1320 — Deadlock Prevention: Breaking Hold and Wait
state: is a snapshot of the problem at a specific point.; Lesson 920 — State Definition and Transitions Lesson 928 — Coin Change: Minimum Coins Lesson 939 — Maximum Subarray Sum (Kadane's as DP)Lesson 943 — Tree DP Fundamentals Lesson 948 — DP on Binary Trees Lesson 954 — Tree DP with Multiple States per Node Lesson 2023 — Semantics of Variable Assignment and State Lesson 2113 — Command-Based Execution Model (+2 more)
State `q₀`, reading `0`: Mark this `0` as `X`, move right, go to state `q₁`; Lesson 1858 — Computing with a Turing Machine
State `q₁`, reading `0`: Skip over remaining 0s, move right, stay in `q₁`; Lesson 1858 — Computing with a Turing Machine
State `q₁`, reading `1`: Found a `1` to match, mark it `Y`, move left, go to `q₂`; Lesson 1858 — Computing with a Turing Machine
State definition: Let `dp[i]` = length of the longest increasing subsequence that *ends at index i*.; Lesson 926 — Longest Increasing Subsequence (LIS)Lesson 937 — Matrix Chain Multiplication Lesson 941 — Minimum Path Sum in Grid Lesson 992 — Floyd-Warshall Dynamic Programming Formulation
State Inconsistencies: A checkout flow expects users to go: Add to Cart → Apply Discount → Payment.; Lesson 2493 — Business Logic Vulnerabilities
State machine replication: Ensuring all replicas execute operations in the same order; Lesson 2647 — The Consensus Problem Definition
State Machine Safety Property: states: *if a server has applied a log entry at a given index to its state machine, no other server will ever apply a different command for that same log index.; Lesson 2670 — Raft Safety Proof: State Machine Safety Property
State machines: A system might remain in the same state under certain inputs.; Lesson 687 — Self-Loops and Their Implications Lesson 875 — Mutual Recursion
State management: How do you handle objects that change behavior based on their state?; Lesson 2286 — Introduction to Behavioral Patterns
State Pattern: encapsulates state-specific behavior into separate state objects.; Lesson 2295 — State Pattern
State q_even: (start, accept): Seen even number of 1s (including zero); Lesson 1781 — Designing Simple DFAs
State q_odd: Seen odd number of 1s; Lesson 1781 — Designing Simple DFAs
State q₀: (start): Haven't seen anything useful yet; Lesson 1781 — Designing Simple DFAs
State q₀ (start): Guess when "101" begins.; Lesson 1799 — NFA Example: Substring Recognition
State q₁: Just saw a '0'; Lesson 1781 — Designing Simple DFAs Lesson 1799 — NFA Example: Substring Recognition
State q₂: (accept): Just saw '01'; Lesson 1781 — Designing Simple DFAs Lesson 1799 — NFA Example: Substring Recognition
State q₃ (accept): Saw complete "101", stay here forever (anything after is fine); Lesson 1799 — NFA Example: Substring Recognition
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 Lesson 2732 — Action Space and Successor Functions Lesson 2735 — State Space Size and Complexity Lesson 2736 — Explicit vs Implicit State Spaces
State Space Graph: This is the complete, abstract representation of every possible state your problem can reach and every transition between them.; Lesson 2729 — State Space Graphs vs Search Trees
State Stack Inspection: Lesson 1972 — LR Parser Error Recovery
State transition logic: Lesson 935 — Longest Palindromic Subsequence
State-based CRDTs (CvRDTs): Replicas exchange entire states and merge them using a commutative, associative, idempotent merge function.; Lesson 2703 — Conflict-Free Replicated Data Types (CRDTs)
Stateful authentication: stores session data on the server.; Lesson 2498 — Stateful vs Stateless Authentication
Stateful cons: Server memory/storage overhead, difficult to scale horizontally without session replication or sticky sessions.; Lesson 2498 — Stateful vs Stateless Authentication
Stateful pros: Easy revocation (delete the session), centralized control, smaller client-side data.; Lesson 2498 — Stateful vs Stateless Authentication
stateless: , meaning each request contains all the information needed to authenticate and process it—no server-side session cookies.; Lesson 2471 — CSRF in REST APIs Lesson 2500 — Token-Based Authentication
Stateless authentication: stores nothing on the server.; Lesson 2498 — Stateful vs Stateless Authentication
Stateless cons: Cannot revoke before expiration without additional infrastructure (like a token blacklist, which reintroduces state), larger tokens sent with each request.; Lesson 2498 — Stateful vs Stateless Authentication
Stateless pros: Highly scalable (any server can verify), no server storage, works across services.; Lesson 2498 — Stateful vs Stateless Authentication
Statement delimiters: Skip until `;` or `}`; Lesson 1947 — Error Detection and Recovery in Lexing
Statement Sequences: A `BlockNode` or `SequenceNode` contains an ordered list of child statement nodes, representing sequential execution.; Lesson 1979 — AST Representation of Statements
statements: the building blocks that *do things* in your program: assignments, conditionals, loops, and sequences of actions.; Lesson 1979 — AST Representation of Statements Lesson 2119 — Statement-Oriented Syntax
states: as connections open, transfer data, and close.; Lesson 1482 — TCP States and State Machine Lesson 1779 — DFA State Diagrams Lesson 1784 — Combining Conditions with Product Construction Lesson 1786 — DFAs for Union of Languages Lesson 1805 — Closure Properties: Intersection Lesson 1828 — Introduction to Pushdown Automata Lesson 1836 — Converting CFGs to PDAs Lesson 2734 — Search Problem Formulation
Static analysis tools: look for suspicious patterns (infinite loops with no exit conditions, recursive calls with no base case); Lesson 1886 — Practical Approximations Lesson 1887 — Philosophical and Practical Impact Lesson 2087 — Memory Leaks: Causes and Detection Lesson 2463 — Testing and Detecting XSS Vulnerabilities
Static branch prediction: makes this decision at compile time using simple, fixed rules that never change during program execution.; Lesson 1176 — Static Branch Prediction
Static instance variable: the class stores its one instance as a static member; Lesson 2265 — Singleton Pattern: Ensuring Single Instance
Static languages: can:; Lesson 2004 — Performance Implications of Type Systems
Static lifetime variables: persist from program start to program end.; Lesson 214 — Static Lifetime Variables
Static members: (also called class members) are shared across all instances of a class.; Lesson 2130 — Static Members and Class Methods
Static relocation: happens at load time.; Lesson 1334 — Relocation and Dynamic Loading
Static typing: means types are checked **before the program runs** — typically during compilation.; Lesson 1997 — Static vs Dynamic Typing Overview Lesson 2006 — Choosing Between Static and Dynamic Typing
Statically: (before execution): The compiler checks types during compilation.; Lesson 1990 — Type Checking
Statistics: building histograms to visualize data distributions; Lesson 447 — Frequency Counting and Histograms Lesson 1700 — Cardinality Estimation
Statistics are outdated: and cardinality estimates are wildly inaccurate; Lesson 1706 — Query Hints and Plan Forcing
Status bits: like valid/invalid, present/absent, read/write permissions; Lesson 1353 — Page Tables
Status codes: or enumerated values; Lesson 2323 — Replace Magic Numbers with Named Constants
Status Line: Contains the HTTP version, a numeric status code, and a brief reason phrase (e.; Lesson 1518 — HTTP Response Structure and Status Codes
Staying balanced automatically: , ensuring consistent performance even after many inserts and deletes; Lesson 1676 — B-Tree Index Overview
Step 0 (Initialization): Lesson 969 — Dijkstra's Algorithm Step-by-Step Execution
Step 1: Victim Authentication: Lesson 2465 — How CSRF Attacks Work
Step 2: Bidirectional Bubbling: Lesson 595 — Delete Arbitrary Element
Step 3: Check capacity: Lesson 1680 — B-Tree Insertion Basics
Step-by-step execution: Lesson 1858 — Computing with a Turing Machine
Steps: Lesson 1327 — Deadlock Recovery Strategies Lesson 1823 — Eliminating ε-Productions
Stochastic: Ask one random person, take a step, repeat.; Lesson 2822 — Batch vs Stochastic Gradient Descent
Stochastic gradient descent: updates weights after *each* sample.; Lesson 2822 — Batch vs Stochastic Gradient Descent
Stop: when heap order is satisfied or you reach the root (`i == 0`); Lesson 587 — Implementing Heap Insert Lesson 1014 — Kruskal's Algorithm: Overview Lesson 2847 — Recursive Partitioning Algorithm
Stop climbing: once you've rotated (the tree above is now balanced); Lesson 539 — AVL Insertion Algorithm
Stop the recursion early: at that depth; Lesson 2771 — Depth-Limited Minimax
Stop when: you make a complete pass with zero swaps; Lesson 741 — Bubble Sort: Algorithm
Stop when goal found: BFS guarantees the shortest path in these unweighted implicit graphs; Lesson 705 — BFS with State Space Representation
Stop-the-World (STW) collection: halts all application threads during garbage collection.; Lesson 2100 — Stop-the-World vs Incremental Collection
Stops the world: The program must pause during collection (marking ensures no objects become unreachable mid- scan); Lesson 2096 — Mark-and-Sweep Collection
Storage: Undirected edges can be stored once (edge between A and B), while directed edges must specify source and destination; Lesson 684 — Directed vs Undirected Graphs Lesson 2790 — Dimensionality Reduction Concepts
Storage costs: Less memory means cheaper cloud hosting and faster load times; Lesson 152 — Memory and Variable Storage
Storage efficiency: `CHAR(2)` for US state codes vs.; Lesson 1554 — Domains and Data Types
Storage or Reflection: The script either gets stored in the website's database or reflected back immediately in a response; Lesson 2454 — What is Cross-Site Scripting (XSS)?
Storage room: (disk): Requires walking, but can store inventory for months; Lesson 1108 — Speed vs Capacity Tradeoff
Store: result in cache; Lesson 873 — Recursion with Memoization Integration
Store compensation data: Save enough context during the forward step to enable accurate compensation later; Lesson 2722 — Compensating Transactions
Store events by timestamp: Each event has a time (e.; Lesson 612 — Event-Driven Simulation
Store instructions: Copying data from a register to a memory address; Lesson 1087 — Memory Access Stage Lesson 1090 — Instruction Cycle Variations
Store-and-forward latency: Entire frame received before forwarding; Lesson 1459 — Switch Performance Metrics
Stored alongside hash: The salt isn't secret—store it plainly in your database next to the hash; Lesson 2506 — Salt: Defending Against Rainbow Tables
Stored server-side: (in the session); Lesson 2467 — CSRF Token Defense
Storing Metadata: The symbol table entry typically includes:; Lesson 1946 — Symbol Tables and Identifiers
Strangler Fig Pattern: (refactoring piece-by-piece), enforcing module boundaries, and establishing design standards going forward.; Lesson 2308 — Big Ball of Mud Anti-Pattern
Strategy: Lesson 1799 — NFA Example: Substring Recognition Lesson 2303 — Spaghetti Code Anti-Pattern
Strategy Pattern: you learned earlier exemplifies this: rather than switching between algorithms, you pass in strategy objects that handle their own execution.; Lesson 2336 — Switch Statement Smell
Stratified sampling: ensures that each split (train, validation, test) maintains the same class proportions as the original dataset.; Lesson 2799 — Stratified Sampling Lesson 2801 — Holdout Method Limitations
Stratify productions: Break one ambiguous non-terminal into multiple specialized non-terminals, each handling a specific case.; Lesson 1839 — Resolving Ambiguity: Grammar Rewriting
Stratum 0: Atomic clocks or GPS receivers (reference clocks); Lesson 2634 — Network Time Protocol (NTP)
Stratum 1: Servers directly connected to Stratum 0; Lesson 2634 — Network Time Protocol (NTP)
Stratum 2: Servers syncing from Stratum 1; Lesson 2634 — Network Time Protocol (NTP)
Streaming Media: Encrypted video streams need real-time decryption—symmetric crypto makes this feasible without buffering delays.; Lesson 2404 — Symmetric Crypto in Practice: Performance and Use Cases
Strength: Social networks where weights represent interaction frequency; Lesson 659 — Weighted vs Unweighted Graphs
Strength Reduction: Lesson 2058 — Peephole Optimization in Code Generation Lesson 2071 — Peephole Optimization
string: is a data type that represents text as a sequence of characters.; Lesson 144 — String Basics Lesson 1756 — Alphabets and Strings
String exponentiation: uses the notation `x^n` to represent string `x` concatenated with itself `n` times.; Lesson 1759 — Powers of Strings and Kleene Star
String transformations: States are intermediate strings; Lesson 705 — BFS with State Space Representation
String traversal: processing each character in a string one time; Lesson 285 — O(n): Linear Time
Strings: `w`, `x`, `y`, `z` (often with subscripts); Lesson 1765 — Language Specifications and Notation
Striped locking: partitions your hash map into multiple regions (often called "stripes" or "segments"), each protected by its own lock.; Lesson 2583 — Striped Locking for Hash Maps
Strong consistency: Wait for all replicas to confirm the write before responding (slower, less available); Lesson 1734 — Eventual Consistency Trade-offs Lesson 2601 — Consistency in Distributed Systems Lesson 2614 — Eventual Consistency Overview Lesson 2615 — Read-Your-Writes Consistency Lesson 2616 — Monotonic Read Consistency Lesson 2620 — Quorum-Based Consistency Lesson 2621 — Consistency vs Availability Tradeoffs Lesson 2623 — Measuring and Testing Consistency (+1 more)
Strong consistency guarantees: (ACID transactions); Lesson 1717 — NoSQL vs SQL: Complementary Approaches
Strong induction: gives you more to work with: you assume the statement is true for *all* values from the base case up through *k*, then prove it for *k + 1*.; Lesson 93 — Strong Induction
Stronger authentication: Possession of the private key (something you have) proves identity, often combined with device protection like PINs (something you know).; Lesson 2502 — Certificate-Based Authentication
Strongly Connected Component (SCC): is a maximal subset of vertices where:; Lesson 665 — Strongly Connected Components in Directed Graphs Lesson 734 — Strongly Connected Components in Directed Graphs
Strongly Not Taken: (00); Lesson 1179 — Two-Bit Saturating Counter Predictor
Strongly Taken: (11); Lesson 1179 — Two-Bit Saturating Counter Predictor
strongly typed: .; Lesson 146 — Type Safety and Strong Typing Lesson 149 — Type Inference Lesson 2045 — LLVM IR Overview
Structs: or **records** are named products.; Lesson 1987 — Composite Types: Products
Structural equivalence: says two types are the same if they have the same *shape*—the same structure of fields, parameters, and return types, regardless of what they're called.; Lesson 1991 — Type Equivalence: Structural vs Nominal
Structural induction: extends the induction principle to these structures.; Lesson 94 — Structural Induction
Structural protection: Hash functions destroy patterns in the original message that might be exploited; Lesson 2436 — Hash-then-Sign Paradigm
Structural typing: offers flexibility and duck typing (if it walks like a duck.; Lesson 1991 — Type Equivalence: Structural vs Nominal
Structure: `(A ∨ B) ∧ (C ∨ D ∨ E) ∧ (F)`; Lesson 45 — Normal Forms: CNF and DNF Lesson 2297 — Mediator Pattern
Structures/Objects: You can define a custom data type that holds multiple fields, then return one instance of that type.; Lesson 200 — Multiple Return Values
stubs: simplified placeholder implementations that simulate their behavior with minimal logic.; Lesson 2238 — Top-Down Integration Testing Lesson 2241 — Test Doubles: Stubs and Mocks
STUDENT: is an entity set containing all student entities (Alice, Bob, Carol, etc.; Lesson 1612 — Entities and Entity Sets Lesson 1615 — Relationships and Relationship Sets
Style and Readability: Lesson 2343 — The Review Checklist Approach
Stylistic issues: affect readability, consistency, or personal preference but don't break the code.; Lesson 2345 — Distinguishing Critical vs Stylistic Issues
Subject: Who owns this certificate (e.; Lesson 1532 — Digital Certificates Fundamentals Lesson 2289 — Observer Pattern Fundamentals Lesson 2530 — Mandatory Access Control (MAC)
Submit a pull request: The contributor requests that maintainers review and merge their changes from their fork into the main project.; Lesson 2198 — Forking Workflow
Submitted with every request: that changes data (POST, PUT, DELETE); Lesson 2467 — CSRF Token Defense
subquery: (also called an *inner query* or *nested query*) is a `SELECT` statement embedded inside another SQL statement.; Lesson 1601 — Introduction to Subqueries Lesson 1604 — IN and NOT IN Operators
Subsequent Requests: Client includes the token in HTTP headers (typically `Authorization: Bearer <token>`); Lesson 2500 — Token-Based Authentication
Subset Enumeration: If you have a set of *n* items, how many subsets exist?; Lesson 107 — Counting Problems in Computer Science
Subset Sum: .; Lesson 1926 — Partition Problem
Subset Sum Problem: you already know!; Lesson 933 — Partition Equal Subset Sum
Substitute: Once `α = Int` is determined, replace `α` with `Int` everywhere; Lesson 2010 — Type Variables and Unification
Substitute directly: Plug that starting value into your statement.; Lesson 87 — Base Case: Starting the Proof
Substitution (SubBytes): Replace each byte using a fixed lookup table (like Caesar cipher on steroids); Lesson 2401 — AES: The Advanced Encryption Standard
Substitution boxes (S-boxes): that replace bit patterns with different ones; Lesson 2400 — DES: The Data Encryption Standard
Subtract: that coin's value from what's left; Lesson 892 — Minimum Number of Coins Problem
Subtraction (`-`): Subtracts the second number from the first; Lesson 154 — Arithmetic Operators
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 Lesson 2211 — Advanced Merge Strategies
subtree independence: each subtree rooted at a child node represents a completely separate subproblem that can be solved on its own.; Lesson 944 — Subtree Independence in Tree DP Lesson 946 — Tree Diameter via DP
Subtyping with polymorphism: The interaction between type hierarchies and generic types creates exponentially complex inference problems; Lesson 2014 — Type Inference Limitations
Suburbs: Another set of intersections with mutual connectivity (another SCC); Lesson 734 — Strongly Connected Components in Directed Graphs
Success (0): You got the lock!; Lesson 1285 — Trylock and Nonblocking Lock Attempts
Success with data: Return a non-negative value (e.; Lesson 1208 — System Call Parameters and Return Values
Successor: The smallest key in the right subtree (leftmost value if you went right); Lesson 1684 — Deletion from Internal Nodes
Successor function: Adds 1 to a number; Lesson 1863 — Alternative Models: Recursive Functions Lesson 2732 — Action Space and Successor Functions
Sudoku Solver: Fill one cell, recursively solve the remaining empty cells; Lesson 866 — Problem Decomposition in Recursion
Sufficient length: At least 16 bytes (128 bits) to prevent brute-force enumeration; Lesson 2506 — Salt: Defending Against Rainbow Tables
Sufficient sample size: You need enough examples relative to your number of features.; Lesson 2837 — Assumptions and Limitations of Logistic Regression
Suffix links: Special pointers that let you "jump" between related positions in the tree, avoiding redundant work; Lesson 635 — Suffix Tree Construction Overview
Suffix Trees: are memory-heavy but lightning-fast for advanced string operations.; Lesson 640 — Trie Variant Performance Comparison
Suggest alternatives: "What if we extracted this into a parameter object to reduce the argument list?; Lesson 2344 — Providing Constructive Feedback
Suggestion: Hints for fixing the issue; Lesson 1996 — Type Errors and Error Messages
Suite-level setup/teardown: Runs once before/after all tests in a group; Lesson 2229 — Test Fixtures and Setup
Sum: Each node stores the sum of its range.; Lesson 647 — Segment Tree Variants and Functions Lesson 1593 — SUM and AVG Functions Lesson 2759 — Combining Heuristics: Max and Sum
Sum Rule: Mutually exclusive options (this OR that); Lesson 98 — Counting Principles: Sum and Product Rules
Sum these decreases: across all trees; Lesson 2856 — Random Forest Feature Importance
Summing values: Total sales per region?; Lesson 1590 — Using Joins with Aggregations
Superficial assertions: Does the test verify meaningful behavior, or just that methods don't crash?; Lesson 2348 — Reviewing Tests and Documentation
Superpipelining: takes this idea to the extreme by breaking down each traditional pipeline stage into multiple sub- stages, allowing the processor to run at a significantly higher clock frequency.; Lesson 1157 — Superpipelining
Supervised learning: is your go-to.; Lesson 2793 — Choosing the Right Learning Paradigm
Supply Chain: Minimizing shipping costs from a warehouse to multiple stores; Lesson 965 — Introduction to Single-Source Shortest Path Problems
Support undo/redo: Each command object can remember its previous state and provide a reverse operation.; Lesson 2291 — Command Pattern Fundamentals
Supporting branches: Lesson 2197 — Gitflow Workflow
Supporting code: – helper functions; Lesson 1973 — Parser Generators and YACC/Bison
surjective: (or **onto**) when every single element in the codomain has at least one element from the domain mapping to it.; Lesson 78 — Function Properties: Surjective (Onto)Lesson 79 — Function Properties: Bijective
Surjective (onto): Every possible output value is actually produced by some input.; Lesson 81 — Inverse Functions
Surjective test: Every possible output is actually produced by some input; Lesson 79 — Function Properties: Bijective
swap: them; Lesson 586 — Heap Insert: Upward Bubbling Concept Lesson 603 — The Sorting Phase: Extract-Max Repeatedly Lesson 604 — In-Place Heapsort Implementation Lesson 779 — The Heapsort Algorithm Steps
Swap the accept states: F' = Q - F (all non-accepting states become accepting, all accepting states become non-accepting); Lesson 1785 — Complementing DFAs
Swap the roles: of the two spaces (to-space becomes the new from-space); Lesson 2097 — Copying Collection
Swapping: Moving memory contents to disk when RAM is full; Lesson 1340 — Address Translation Overview Lesson 1347 — Swapping and Backing Store
Swapping large objects: is costly; Lesson 746 — Selection Sort: Minimizing Swaps
Swapping two variables: Uses a fixed amount of memory (a temporary variable) no matter the input size → **O(1)** space.; Lesson 302 — What is Space Complexity?
Swapping values: You can swap two variables without a temporary variable using XOR operations; Lesson 35 — Exclusive OR (XOR)
Sweep: All remaining white objects are unreachable garbage and can be reclaimed.; Lesson 2099 — Tri-Color Marking
Switch branches: `HEAD` moves to point to the latest commit on that branch; Lesson 2184 — The HEAD Pointer
Switch products: without changing every workstation; Lesson 2264 — Introduction to Creational Patterns
Switch to heapsort: – If recursion exceeds a threshold (usually 2 × log n), switch to heapsort to guarantee O(n log n); Lesson 801 — Introsort: The Best of Both Worlds
switches: physically connect multiple devices, but they handle incoming frames very differently.; Lesson 1454 — Network Switches vs Hubs Lesson 1456 — Broadcast and Collision Domains
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 Compilers Lesson 1946 — Symbol Tables and Identifiers
Symbol table construction: happens naturally as you visit declaration nodes; Lesson 2039 — Abstract Syntax Trees (ASTs) as IR
Symbol Table Insertion: If it's not a keyword, the lexer treats it as an identifier and either:; Lesson 1946 — Symbol Tables and Identifiers
Symbol tables: in compilers that must maintain sorted identifiers; Lesson 502 — BST Advantages and Use Cases
Symbolic links: Lesson 1419 — Hard Links vs Symbolic Links
Symbols: punctuation and special characters; Lesson 24 — ASCII: The Foundation
Symmetric: A relation R is **symmetric** if whenever (a, b) is in R, then (b, a) must also be in R.; Lesson 70 — Properties of Relations: Symmetry Lesson 72 — Equivalence Relations Lesson 1058 — One's Complement Representation
Symmetric encryption: uses the same secret key for both encryption and decryption.; Lesson 1530 — Symmetric vs Asymmetric Encryption in TLS Lesson 1531 — The TLS Handshake Process
Symmetric encryption cipher: (e.; Lesson 2448 — Cipher Suites: Negotiating Encryption Algorithms
Symmetry: means if `a` is in `[b]`, then `b` is in `[a]` — they share the same class; Lesson 73 — Equivalence Classes and Partitions
Symmetry exploitation: If states `(a,b)` and `(b,a)` always give the same answer, store only one; Lesson 955 — State Space Reduction
SYN and ACK flags: set.; Lesson 1473 — TCP Three-Way Handshake
SYN flag: set and includes an **initial sequence number** (ISN).; Lesson 1473 — TCP Three-Way Handshake
SYN_RECEIVED: Server received SYN, sent SYN-ACK, awaiting ACK; Lesson 1482 — TCP States and State Machine
SYN_SENT: Client sent a SYN and is waiting for SYN-ACK; Lesson 1482 — TCP States and State Machine
Sync: message with precise departure time; Lesson 2635 — Precision Time Protocol (PTP)
synchronization: one process must wait until another process completes a specific task before proceeding.; Lesson 1297 — Signaling and Event Notification Lesson 1437 — OSI Upper Layers: Session, Presentation, Application Lesson 2565 — Thread Safety Strategies
Synchronized blocks: Unlocking a monitor happens-before every subsequent lock of that same monitor; Lesson 2564 — Happens-Before Relationship
Synchronous: You hand it to your teacher and wait for them to file it in their cabinet before you leave.; Lesson 2640 — Synchronous vs. Asynchronous Replication
Synchronous systems: make consensus solvable even with failures.; Lesson 2652 — Synchronous vs Asynchronous Models
Syntax: Lesson 1604 — IN and NOT IN Operators
Syntax Analysis (Parsing): Lesson 2029 — The Translation Pipeline: Source to Machine Code
Syntax errors: Mismatched parentheses, missing semicolons; Lesson 2032 — Error Detection: Compile-Time vs Runtime
system call: a controlled request that switches the CPU temporarily into kernel mode so the OS can safely perform the operation on the program's behalf.; Lesson 1194 — OS Kernel and User Space Lesson 1195 — Monolithic Kernel Architecture Lesson 1209 — What Are Interrupts?Lesson 1214 — System Calls vs Interrupts: Comparison
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 Lesson 1416 — Directory Operations and System Calls
System compromise: Combined with other vulnerabilities, can lead to complete server takeover; Lesson 2489 — Path Traversal and File Inclusion
System Design: → paired with **System Testing**; Lesson 2355 — The V-Model: Verification and Validation
System processes: (highest priority); Lesson 1259 — Multilevel Queue Scheduling
System resources: open files, network connections, allocated memory; Lesson 1215 — What is a Process?
System Testing: Lesson 2355 — The V-Model: Verification and Validation

T

T(≤ 7n/10): Lesson 827 — Median of Medians: Complexity Proof
T(n): = time to solve a problem of size n; Lesson 842 — Recurrence Relations for Divide and Conquer
T(n/5): Lesson 827 — Median of Medians: Complexity Proof
T²: ), hashing collisions, and variance calculations all rely on computing expectations of functions.; Lesson 131 — Expected Value of Functions
Table 1: Contains `X` and `Y` (the problematic FD becomes safe here because `X` becomes a key); Lesson 1641 — Achieving BCNF
Table 2: Contains `X` and all remaining attributes (excluding `Y`, but keeping `X` as a foreign key); Lesson 1641 — Achieving BCNF
Table cardinality: How many rows are in each table; Lesson 1699 — Cost-Based Query Optimization Lesson 1700 — Cardinality Estimation
Table size: Your actual array capacity (maybe 10, 100, or 1000 slots); Lesson 407 — Hash Function Output Range and Table Size
Tabular Data: Spreadsheets, datasets, and matrices are naturally 2D.; Lesson 249 — Practical Applications of Multidimensional Arrays
Tabulation (Bottom-Up): Lesson 918 — Top-Down vs Bottom-Up Tradeoffs
tag: , **index**, and **offset**.; Lesson 1127 — Cache Address Breakdown Lesson 1128 — Direct-Mapped Cache Lookup Lesson 1130 — Fully Associative Caches Lesson 1135 — Cache Placement Example Calculations
Tag bits: – uniquely identify the block; Lesson 1133 — Set-Associative Address Mapping
Tag creation: Trigger release builds; Lesson 2385 — Version Control Integration
Tagged unions: or **discriminated unions** (C, C++); Lesson 1988 — Composite Types: Sums
tail: Lesson 353 — Circular Doubly Linked Lists Lesson 2571 — Lock-Free Queue: The Michael-Scott Algorithm
tail-recursive: when the recursive call is the *final operation* before returning—nothing happens after it comes back.; Lesson 227 — Tail Recursion Lesson 872 — Tail Recursion Optimization
Tail-recursive version: Lesson 227 — Tail Recursion
Take the underfull node: (with too few keys); Lesson 566 — Merging Nodes in B-Trees
Take too long: Some inference problems have exponential worst-case complexity; Lesson 2014 — Type Inference Limitations
taken: loops usually branch backward; Lesson 1176 — Static Branch Prediction Lesson 1178 — One-Bit Branch Predictor
Tangible feedback: Users interact with real features, revealing what works and what doesn't; Lesson 2363 — Working Software Over Comprehensive Documentation
Tangible Progress: Stakeholders see working features regularly, building trust and allowing budget adjustments based on real value delivered, not promises.; Lesson 2369 — Continuous Delivery of Value
Tape contents: – All symbols written on the tape (usually we only show the relevant portion); Lesson 1854 — Turing Machine Configuration
Tape Storage: (bottom tier); Lesson 1107 — Storage Pyramid Levels
Target Interface: What your client code expects; Lesson 2274 — Adapter Pattern: Converting Interfaces
Target leakage: A feature wouldn't actually be available at prediction time (e.; Lesson 2805 — Data Leakage Prevention
Task arrives: Extract the minimum (least-loaded server); Lesson 617 — Load Balancing Systems
Task dependencies: A recursive process where a task can trigger itself creates a self-loop in a dependency graph.; Lesson 687 — Self-Loops and Their Implications
Task scheduling: dominates here.; Lesson 394 — Queue Variant Applications Lesson 663 — Cycles and Acyclic Graphs
Tautologies: represent logical laws that always hold—useful for proving equivalences and validating reasoning; Lesson 43 — Tautologies and Contradictions
Tautology example: `p OR NOT p`; Lesson 43 — Tautologies and Contradictions
TCP: (reliable) and **UDP** (fast); Lesson 1438 — The TCP/IP Model Lesson 1471 — TCP Overview and Key Features Lesson 1498 — Overhead and Header Size Comparison Lesson 1514 — HTTP Overview and Client-Server Model
TCP header: minimum 20 bytes (often 40+ with options); Lesson 1498 — Overhead and Header Size Comparison
TCP segment: is the fundamental unit of data transmission in TCP.; Lesson 1472 — TCP Segment Structure
TCP state machine: is a formal model with approximately 11 states that govern every TCP connection.; Lesson 1482 — TCP States and State Machine
TCP three-way handshake: you learned earlier (SYN → SYN-ACK → ACK).; Lesson 1544 — TCP Client: Connect to Server
TCP/IP model: is the actual four-layer architecture that the Internet runs on.; Lesson 1438 — The TCP/IP Model
Team A: has expensive project management software, detailed process documents, and standardized templates.; Lesson 2362 — Individuals and Interactions Over Processes and Tools
Team B: uses simple tools (whiteboards, sticky notes, basic chat) but has daily conversations, quick problem-solving huddles, and strong trust between developers, testers, and stakeholders.; Lesson 2362 — Individuals and Interactions Over Processes and Tools
Team cohesion: Daily face-to-face interaction builds collaboration (a core Agile value: individuals and interactions over processes); Lesson 2380 — Daily Scrum (Stand-up)
Team friction: Developers resent reviewers who block PRs over tabs-vs-spaces; Lesson 2345 — Distinguishing Critical vs Stylistic Issues
Team members review: your code, leaving comments and suggestions; Lesson 2196 — Pull Requests and Code Review
Team visibility increases: everyone sees progress in real-time; Lesson 2199 — Trunk-Based Development
Teams work in silos: , creating integration nightmares; Lesson 2351 — What is a Software Development Lifecycle (SDLC)?
Teardown: (cleanup after Assert), but AAA remains the core.; Lesson 2225 — Anatomy of a Unit Test Lesson 2229 — Test Fixtures and Setup
Technology constraints: SRAM (fast) uses 6+ transistors per bit, while DRAM (slower) uses 1 transistor + capacitor; Lesson 1108 — Speed vs Capacity Tradeoff
Temperature: Heat makes crystals vibrate faster or slower; Lesson 2626 — Clock Skew and Clock Drift
template method: (usually `final` or non-overridable) that defines the algorithm's sequence; Lesson 2293 — Template Method Pattern Lesson 2303 — Spaghetti Code Anti-Pattern
Template Method Pattern: defines the high-level structure of an algorithm in a base class, leaving certain steps abstract or overridable.; Lesson 2293 — Template Method Pattern Lesson 2294 — Iterator Pattern
Temporal data: For time-series, you might reserve recent data as test (not random splits); Lesson 2800 — Train-Test Split Ratios
Temporal features: Extracting useful time components from timestamps (hour, day, month, season).; Lesson 2783 — Feature Engineering Basics
Temporal leakage: Using future information to predict the past in time series data; Lesson 2805 — Data Leakage Prevention
Temporal locality: means "nearby in time.; Lesson 1118 — Principle of Locality Lesson 1123 — Cache Replacement Policies Overview Lesson 1370 — Least Recently Used (LRU)
Temporal patterns: Everyone shops during lunch hour; all requests funnel to partitions storing "recent" data; Lesson 2690 — Handling Data Skew and Hotspots
Temporary inconsistencies: are tolerated—different replicas may return different values for a short period; Lesson 2614 — Eventual Consistency Overview
term: (logical clock); Lesson 2661 — Raft RPCs: RequestVote and AppendEntries Lesson 2667 — Handling Log Inconsistencies
Terminate: when a goal is reached; Lesson 2761 — IDA* (Iterative Deepening A*)
Terminates: by producing a single terminal symbol; Lesson 1820 — Chomsky Normal Form (CNF)
Termination: When the loop ends, the invariant proves the algorithm is correct; Lesson 97 — Induction in Algorithm Analysis Lesson 1008 — A* Correctness and Optimality
Terms below were extracted from bolded phrases in lesson content. Click a lesson reference to jump
Ternary Search Trees: balance space and time beautifully.; Lesson 640 — Trie Variant Performance Comparison
TEST: instructions come in.; Lesson 1098 — Comparison and Test Instructions Lesson 1818 — Designing CFGs for Simple Languages Lesson 2329 — Introduction to Code Smells Lesson 2384 — The CI Pipeline: Build, Test, Report
Test after each integration: Verify the system still works correctly with the real module; Lesson 2238 — Top-Down Integration Testing
Test data: A completely separate dataset held back during training.; Lesson 2777 — Training Data vs Test Data Lesson 2784 — Baseline Models and Evaluation
Test doubles: are stand-ins that replace these dependencies during tests—like stunt doubles in movies.; Lesson 2230 — Mocking and Test Doubles Lesson 2241 — Test Doubles: Stubs and Mocks
Test low-level modules: individually (essentially unit testing); Lesson 2239 — Bottom-Up Integration Testing
Test Optimization: Run the fastest tests first (unit tests), defer slower integration tests, and only run tests affected by recent changes when possible.; Lesson 2388 — CI Best Practices: Fast Feedback
Test results more reliable: Final evaluation isn't skewed by sampling luck; Lesson 2799 — Stratified Sampling
Test Set: Fresh data the model has never seen, used only to evaluate final performance; Lesson 2796 — Training Set vs Test Set Lesson 2797 — The Validation Set
Test thoroughly: After resolving, ensure the merged code works as both authors intended; Lesson 2200 — Handling Merge Conflicts in Teams Lesson 2310 — Function Length and Single Responsibility
Test with international characters: early (accents, emoji, non-Latin scripts); Lesson 30 — Common Encoding Issues
Testability: Test small units independently; Lesson 2134 — Function Composition Lesson 2319 — Extract Method: Breaking Down Complex Functions Lesson 2326 — Decompose Conditional: Simplifying Complex If Statements
Testable: Easy to verify behavior; Lesson 2132 — Pure Functions and Immutability
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 Lesson 2342 — Preparing Code for Review Lesson 2353 — The Waterfall Model: Sequential Phases
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
Testing happens too late: , making bugs expensive to fix; Lesson 2351 — What is a Software Development Lifecycle (SDLC)?
Testing hypotheses: about why a query is slow; Lesson 1706 — Query Hints and Plan Forcing
Testing Implementation Details: The biggest mistake is tying tests to *how* code works internally rather than *what* it produces.; Lesson 2263 — TDD Benefits and Common Pitfalls
Testing mindset: Destructive and skeptical.; Lesson 2216 — Testing vs Debugging
Testing over proving: Since we can't verify all properties, we rely on extensive testing and heuristics; Lesson 1887 — Philosophical and Practical Impact
Testing with cross-origin requests: (should be blocked); Lesson 2473 — Implementing CSRF Protection
Text analysis: counting word frequencies in documents (word clouds, keyword extraction); Lesson 447 — Frequency Counting and Histograms
Text editors: (find feature): Boyer-Moore works well because searches are infrequent, and natural language has many mismatches that Boyer-Moore exploits.; Lesson 840 — String Searching Applications and Tradeoffs
theirs: strategy (used via options like `git merge -X theirs`) prefers the *incoming branch's* changes during conflicts.; Lesson 2191 — Merge Strategies Lesson 2211 — Advanced Merge Strategies
then: Q must hold.; Lesson 55 — Quantifiers Over Restricted Domains Lesson 167 — The if Statement Lesson 2524 — Authorization vs Authentication
Theorem: A language is context-free if and only if some pushdown automaton recognizes it.; Lesson 1835 — Equivalence of PDAs and Context-Free Grammars
Theoretical analysis: gives us the big picture: how operations scale as data grows.; Lesson 441 — Benchmarking and Practical Performance
Theoretical elegance: It provides a stable foundation for reasoning about algorithms and complexity; Lesson 1867 — Implications and Universal Acceptance
Theoretical proofs: Simplifies reasoning about context-free languages; Lesson 1820 — Chomsky Normal Form (CNF)
Theoretical significance: This problem defines a fundamental boundary of computation—something even Turing machines (and by the Church-Turing Thesis, all computers) cannot solve in general.; Lesson 1878 — What is the Halting Problem?
There are no obstacles: , or you're measuring optimistic distance ignoring them; Lesson 2757 — Euclidean Distance Heuristic
there.
Thieves: (idle processors looking for work) steal from the opposite end (the tail) using `pop_back()`; Lesson 403 — Work-Stealing with Deques
Think like this: If you need the *shortest path guaranteed* and have memory, use A*.; Lesson 2763 — Heuristic Search in Practice
Think of it like: Instead of blindly picking a pivot (which might be terrible), you're pre-screening candidates by organizing them into small committees, finding each committee's representative, then choosing the most "middle" representative.; Lesson 826 — Median of Medians: Partitioning Strategy Lesson 987 — Bellman-Ford vs Dijkstra Comparison
Third column: 0 + 1 + 1(carry) = 0, carry 1; Lesson 5 — Binary Addition
Third Normal Form (3NF): when:; Lesson 1637 — Third Normal Form (3NF) Definition
Third pass: Merge subarrays of size 4 into size 8.; Lesson 760 — Bottom-Up Mergesort
Thompson's Construction: , each regex operator gets translated into a small NFA fragment:; Lesson 1942 — From Regular Expressions to Finite Automata
thrashing: ) can grind the system to a halt when the disk becomes the bottleneck.; Lesson 1347 — Swapping and Backing Store Lesson 1377 — Thrashing and Prevention
thread: is a lightweight execution unit that runs *within* a process.; Lesson 1230 — What is a Thread?Lesson 1231 — Threads vs Processes
Thread A: reads balance: $100; Lesson 1241 — Threading Challenges: Synchronization Needs
Thread B: reads balance: $100 (before Thread A writes); Lesson 1241 — Threading Challenges: Synchronization Needs
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?
Thread start: Calling `thread.; Lesson 2564 — Happens-Before Relationship
Thread termination: All actions in a thread happen-before another thread detects that thread has terminated (via `join()`); Lesson 2564 — Happens-Before Relationship
Thread-Local Storage (TLS): is a mechanism that provides each thread with its own private copy of a variable.; Lesson 1239 — Thread-Local Storage
Thread-safe lazy: Best of both worlds, but slightly more complex code; Lesson 2266 — Singleton Thread Safety and Lazy Initialization
Threads: within the same process share almost everything:; Lesson 1231 — Threads vs Processes
three: regions:; Lesson 772 — Three-Way Partitioning for Duplicate Keys Lesson 1359 — Two-Level Page Tables Lesson 1489 — UDP Checksum Calculation and Verification Lesson 1827 — Limitations of Context-Free Grammars
three nested loops: one for result rows, one for result columns, and one for the calculation across the shared dimension.; Lesson 248 — Matrix Representation and Operations Lesson 288 — O(n³) and Higher Polynomial Time Lesson 993 — Floyd-Warshall Algorithm Implementation
Three outcomes per comparison: Lesson 559 — B-Tree Search Operation
Three-level: L2's miss penalty becomes accessing L3:; Lesson 1147 — Multi-Level Cache Performance Analysis
Three-Phase Commit: (which you've already seen).; Lesson 2655 — Leader Election Basics
Three-way Quicksort: avoids redundant comparisons.; Lesson 799 — When to Use Which Sorting Algorithm
threshold: (commonly 10-20 elements).; Lesson 775 — Hybrid Quicksort: Insertion Sort for Small Subarrays Lesson 2829 — Interpreting Probabilities and Decision Boundaries
throughput: by keeping all parts of the CPU busy simultaneously, rather than leaving stages idle while waiting.; Lesson 1148 — Introduction to Instruction Pipelining Lesson 1151 — Pipeline Throughput and Latency Lesson 1156 — Deeper Pipelines: Benefits and Costs Lesson 1184 — Branch Prediction Performance Impact Lesson 1187 — Instructions Per Cycle (IPC) and Throughput Lesson 1245 — CPU Utilization and Throughput Lesson 1249 — Scheduling Criteria Trade-offs Lesson 1261 — Comparing Scheduling Algorithm Performance (+5 more)
Throughput vs Response Time: Running long jobs to completion without interruption maximizes throughput (more total jobs done), but users with short interactive tasks will wait forever for their first response.; Lesson 1249 — Scheduling Criteria Trade-offs
Tie-breaking: When classes tie, common strategies include:; Lesson 2866 — KNN Classification: Voting Mechanisms
tight bound: on an algorithm's growth rate.; Lesson 292 — Introduction to Big-Theta Notation Lesson 304 — Space Complexity Notation
Tight coupling: Every module depends on the God Object, making changes ripple unpredictably through your system; Lesson 2302 — God Object Anti-Pattern
Time: Routes where weights represent travel duration; Lesson 659 — Weighted vs Unweighted Graphs Lesson 685 — Weighted and Unweighted Graphs Lesson 839 — Multiple Pattern Matching: Aho-Corasick Lesson 1888 — Introduction to Complexity Classes Lesson 2715 — Message Queue Performance Considerations Lesson 2761 — IDA* (Iterative Deepening A*)
time complexity: how the number of steps grows as the data grows.; Lesson 383 — Queue Operation Complexity Analysis Lesson 504 — BST Search: Iterative Implementation Lesson 616 — Merging K Sorted Lists Lesson 618 — Top-K Elements Problem Lesson 670 — Adjacency Matrix: Operations and Complexity Lesson 831 — String Search Problem and Naive Approach Lesson 2748 — Comparing Uninformed Strategies
Time Complexity: O(b^d): Lesson 2741 — BFS Implementation and Complexity
Time cost: (iterations): How many passes through memory; Lesson 2508 — Password Hashing with Argon2
TIME_WAIT: Connection closed, waiting to ensure remote received final ACK; Lesson 1482 — TCP States and State Machine
Time-based: Uses database sleep functions to detect true conditions by measuring response delays; Lesson 2476 — Types of SQL Injection Attacks
Time-consuming debugging: You might waste days hunting bugs across multiple modules; Lesson 2236 — Big Bang Integration Strategy
Time-series sensor data: Use a column family store for efficient aggregation; Lesson 1716 — Polyglot Persistence Strategy
Time-to-market matters: – waiting for complete delivery means competitors may ship first; Lesson 2354 — Waterfall Strengths and Limitations
Time: O(1): no traversal needed!; Lesson 382 — Linked List-Based Queue Implementation
Time: O(m): where m = pattern length, regardless of text size!; Lesson 636 — Suffix Tree Applications
Time/Space complexity: O(b^(C*/ε)) where C* is the optimal cost and ε is the minimum step cost; Lesson 2746 — Uniform-Cost Search
Timeout: Operations taking too long (if timeouts are configured); Lesson 1550 — Error Handling and Socket Shutdown Lesson 1886 — Practical Approximations
Timeout Value: TCP dynamically calculates how long to wait based on network conditions (round-trip time); Lesson 1476 — TCP Reliability: Retransmission
timeouts: and **retransmission**.; Lesson 1476 — TCP Reliability: Retransmission Lesson 2592 — Message Loss and Ordering
Timestamp: (for aging out stale entries); Lesson 1455 — Switch Learning and Forwarding
Timestamps: Events can always be ordered chronologically; Lesson 75 — Total Orders and Chains Lesson 1388 — File Attributes and Metadata Lesson 1397 — File Control Blocks and Inodes Lesson 1660 — Isolation: Concurrent Transaction Independence
Timing dependencies: make bugs vanish when you add logging or slow things down to debug.; Lesson 2599 — Testing and Debugging Difficulties
Timing-sensitive: More likely under certain loads or on faster/slower hardware; Lesson 2555 — Race Conditions
Timsort: (Python, Java) achieve stability by design:; Lesson 803 — Stability in Production Sorting Lesson 805 — Cache-Friendly Sorting Techniques
TLB access time: (very fast, usually 1-2 ns); Lesson 1364 — Effective Access Time with Paging
TLB Hit: If the translation is in the TLB, the physical address is retrieved instantly (nanoseconds); Lesson 1345 — Translation Lookaside Buffer (TLB)Lesson 1350 — Virtual Memory Performance Considerations Lesson 1362 — Translation Lookaside Buffer (TLB)Lesson 1364 — Effective Access Time with Paging
TLB hit ratio: (percentage of TLB hits, often 80-99%); Lesson 1364 — Effective Access Time with Paging
TLB hit time: = TLB access + one memory access; Lesson 1364 — Effective Access Time with Paging
TLB lookup fails: The requested virtual address isn't found in the TLB; Lesson 1363 — TLB Miss Handling
TLB Miss: If not found, the MMU must walk the page table in memory (slower), then caches the result in the TLB for next time; Lesson 1345 — Translation Lookaside Buffer (TLB)Lesson 1350 — Virtual Memory Performance Considerations Lesson 1362 — Translation Lookaside Buffer (TLB)Lesson 1363 — TLB Miss Handling Lesson 1364 — Effective Access Time with Paging
TLB miss time: = TLB access + page table access + memory access; Lesson 1364 — Effective Access Time with Paging
TLB Reach: Lesson 1365 — Paging Performance Considerations
TLD servers: .; Lesson 1510 — Root Nameservers and TLD Servers
TLS (Transport Layer Security): emerged as SSL's successor.; Lesson 2447 — TLS Protocol Versions: SSL to TLS 1.3
TLS 1.3: (2018) represents a major overhaul.; Lesson 2447 — TLS Protocol Versions: SSL to TLS 1.3
TLS handshake: is this negotiation process.; Lesson 1525 — HTTPS Handshake Process
TLS/SSL certificates: Many websites use ECDSA certificates for HTTPS; Lesson 2438 — ECDSA (Elliptic Curve Digital Signature Algorithm)
TLS/SSL encryption is established: before any HTTP data is exchanged; Lesson 1524 — Introduction to HTTPS
Together: , the owner's primary key + the weak entity's partial key form the weak entity's full identifier.; Lesson 1619 — Weak Entities and Identifying Relationships
Toggling bits: XORing any bit with 1 flips it (0 becomes 1, 1 becomes 0); Lesson 17 — The XOR Gate (Exclusive OR)
Token: = the category (letter, postcard, package); Lesson 1939 — Tokens, Lexemes, and Patterns Lesson 2500 — Token-Based Authentication Lesson 2534 — OAuth 2.0 Overview and Use Cases
Token Exchange: The client's backend server sends this code to the authorization server along with the client secret, receiving an access token in return; Lesson 2536 — OAuth 2.0 Grant Types: Authorization Code Grant
Token Issuance: Server verifies credentials and generates a token (often a JWT—JSON Web Token—or similar); Lesson 2500 — Token-Based Authentication
Token Storage: Client stores the token (usually in memory, local storage, or secure cookie); Lesson 2500 — Token-Based Authentication
Token Validation: Server verifies the token's signature and expiration, extracts user identity, and processes the request; Lesson 2500 — Token-Based Authentication
tokens: (keywords, identifiers, numbers, operators).; Lesson 1792 — Practical Applications of DFAs Lesson 1939 — Tokens, Lexemes, and Patterns
Tokens are cryptographically random: and change per-session; Lesson 2467 — CSRF Token Defense
tombstone: (or "deleted marker").; Lesson 427 — Deletion in Open Addressing Lesson 1731 — DELETE and Tombstones
Too high: (> 65): Test with one value, say 70; Lesson 2221 — Equivalence Partitioning
Too large: The working set includes "cold" pages that won't be reused, wasting memory; Lesson 1375 — Working Set Model Lesson 2821 — Learning Rate and Convergence
Too loose: Easy recovery = attackers can bypass MFA; Lesson 2523 — Backup Codes and MFA Recovery
Too low: (< 18): Test with one value, say 10; Lesson 2221 — Equivalence Partitioning
Too many fields: The class tracks dozens of instance variables; Lesson 2331 — Large Class Smell
Too many methods: Scrolling through hundreds of lines to find what you need; Lesson 2331 — Large Class Smell
Too small: The working set misses important pages the process will need soon; Lesson 1375 — Working Set Model Lesson 2821 — Learning Rate and Convergence
Too strict: No recovery = users permanently locked out; Lesson 2523 — Backup Codes and MFA Recovery
Tool support: – IDEs can offer better autocomplete and error detection; Lesson 2000 — Type Annotations in Static Languages
top: ): View the top element without removing it; Lesson 356 — The Stack ADT Definition Lesson 359 — Peek (or Top) Operation Lesson 1950 — Introduction to Top-Down Parsing
Top (narrowest): End-to-end tests — few comprehensive tests simulating real user scenarios; Lesson 2217 — The Testing Pyramid
Top Secret: Lesson 2530 — Mandatory Access Control (MAC)
top-down: (solving as needed and remembering results).; Lesson 913 — What is Dynamic Programming?Lesson 943 — Tree DP Fundamentals Lesson 1974 — Bottom-Up vs Top-Down Tradeoffs Lesson 2237 — Incremental Integration Approach
Top-Down (Pre-order with Memoization): Start at the root and recurse down, storing results as you go.; Lesson 943 — Tree DP Fundamentals
top-down parsers: (the kind that start from the start symbol and try to predict which production to use).; Lesson 1840 — Left Recursion and Its Problems Lesson 1974 — Bottom-Up vs Top-Down Tradeoffs
Top-down team: starts at the UI layer, using stubs for middle-layer functions, testing downward; Lesson 2240 — Sandwich Integration Testing
Top-Level Domains (TLDs): these are the familiar suffixes like `.; Lesson 1503 — DNS Hierarchy and Namespace Structure
Topological sorting: (ordering tasks with dependencies); Lesson 718 — DFS Applications and Use Cases
Total: 3 × 3 = 9 operations; Lesson 275 — Analyzing Nested Loops Lesson 717 — DFS Time Complexity Analysis Lesson 1016 — Kruskal's Algorithm: Implementation and Analysis
Total complexity: O(m) preprocessing + O(n) searching = **O(n + m)** guaranteed.; Lesson 835 — KMP: Pattern Matching Algorithm
Total complexity: O(VE²): predictable and polynomial, unlike vanilla Ford-Fulkerson.; Lesson 1039 — Edmonds-Karp Algorithm
Total nodes: = 2^(h+1) - 1; Lesson 487 — Node Count Formulas
Total operations: (V-1) × E ≈ **O(VE)**; Lesson 986 — Bellman-Ford Time Complexity
Total ordering: Any two proposal numbers can be compared (n₁ < n₂ or n₁ > n₂); Lesson 2674 — Proposal Numbers and Ordering
Total outcomes: 100 (the numbers 1 through 100); Lesson 110 — Computing Basic Probabilities
Total participation: (mandatory): Every entity in the set *must* participate in the relationship.; Lesson 1618 — Participation Constraints: Total vs Partial Lesson 1619 — Weak Entities and Identifying Relationships
Total participation example: Lesson 1618 — Participation Constraints: Total vs Partial
Total profit = 7: (you captured every upward swing); Lesson 902 — Buy Maximum Stocks with K Transactions
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
Total work: O(n) work across O(log n) levels = **O(n log n)** total time.; Lesson 768 — Best-Case Analysis: Balanced Partitions
Total: 4 coins: (1 quarter, 1 dime, 1 nickel, 1 penny); Lesson 892 — Minimum Number of Coins Problem
Total: O(n log n): in all cases (best, average, and worst); Lesson 601 — Heapsort Overview and Basic Idea
Total: O(V + E): Lesson 727 — Time and Space Complexity
Totality (Comparability): For any `a` and `b`, either `a ≤ b` or `b ≤ a`; Lesson 75 — Total Orders and Chains
Track every split: that uses that feature across all trees in the forest; Lesson 2856 — Random Forest Feature Importance
Track finish times: when DFS completely finishes exploring a vertex (after visiting all its neighbors), add it to a list; Lesson 724 — DFS-Based Topological Sort
Track global: Update the overall best as you traverse; Lesson 949 — Path Sums and Tree DP
Track ownership: Know which part of your code is responsible for freeing memory; Lesson 2084 — Manual Memory Management Overview
Track parents during traversal: When visiting a neighbor `v` from vertex `u`, record that `u` is the parent of `v`; Lesson 716 — Path Finding with DFS
Track the minimum: `f`-value that exceeded the threshold during the search; Lesson 2761 — IDA* (Iterative Deepening A*)
Track vertex states: unvisited, visiting (in current path), or visited (fully explored); Lesson 721 — DAG Detection and Prerequisites
Track visited states: Use a set or hash table to avoid revisiting the same configuration; Lesson 705 — BFS with State Space Representation
Tracking state becomes hard: What is the value of `x` at line 500?; Lesson 2121 — Imperative Style Tradeoffs
Trade-off: No cache coherence headaches, but programmers must explicitly coordinate data sharing.; Lesson 1262 — Multiprocessor Architecture Fundamentals Lesson 2643 — Read Repair and Anti-Entropy
trade-offs: between four key factors:; Lesson 1070 — Hardware Trade-offs in Number Representation Lesson 2577 — Lock-Based vs Lock-Free Approaches Lesson 2583 — Striped Locking for Hash Maps Lesson 2687 — Hash-Based Partitioning
Trade-offs in static analysis: Tools that *attempt* to find bugs must either:; Lesson 1883 — Implications for Program Verification
Tradeoff: Costs more in chip area and power, but maintains maximum throughput.; Lesson 1164 — Resolving Structural Hazards Lesson 1430 — I/O Schedulers in Operating Systems Lesson 2565 — Thread Safety Strategies
Trading Space for Time: Lesson 307 — Space-Time Tradeoffs
Trading Time for Space: Lesson 307 — Space-Time Tradeoffs
Traditional locks: Only one person can hold the pen at a time; others wait.; Lesson 1291 — Lock-Free vs Wait-Free Alternatives
Train a weak learner: Build a simple classifier on the weighted dataset; Lesson 2858 — AdaBoost Algorithm
Train base models: Train diverse models (e.; Lesson 2861 — Stacking: Meta-Learning
Train the meta-model: Treat the base models' predictions as *new features* and train a second-level model to predict the actual target; Lesson 2861 — Stacking: Meta-Learning
Train-test contamination: Preprocessing steps (like normalization or imputation) use statistics computed on the entire dataset including the test set, rather than training set only; Lesson 2805 — Data Leakage Prevention
Training data: The dataset the model learns from.; Lesson 2777 — Training Data vs Test Data
Training loss: typically decreases continuously; Lesson 2815 — Early Stopping
Training more stable: The model sees representative data; Lesson 2799 — Stratified Sampling
Training phase: O(1) — it just stores the data, no real computation; Lesson 2869 — Computational Complexity of KNN
Training Set: The data used to teach the model patterns, adjust weights, and optimize the objective function; Lesson 2796 — Training Set vs Test Set Lesson 2797 — The Validation Set
Training too briefly: Stopping optimization before the model converges; Lesson 2809 — What is Underfitting?
Transaction A: Lesson 1667 — Dirty Reads Problem
Transaction B: Lesson 1667 — Dirty Reads Problem
transaction logs: and **write-ahead logging (WAL)** come in.; Lesson 1657 — Transaction Logs and Write-Ahead Logging Lesson 1664 — Recovery Mechanisms and Durability
Transaction-level (per-transaction control): Lesson 1675 — Setting Isolation Levels in Practice
Transactional consistency: Either a write completes fully (new blocks written, metadata updated) or it doesn't happen at all.; Lesson 1408 — Copy-on-Write File Systems
Transactional coordination: between delivery and processing; Lesson 2710 — At-Most-Once, At-Least-Once, Exactly-Once Delivery
Transactional data: (orders, payments, user accounts); Lesson 1653 — Hybrid Normalization Strategies
Transfer learning: lets you take a model pre-trained on one task (often with huge datasets) and adapt it to your specific problem with far less data.; Lesson 2795 — Transfer Learning and Self-Supervised Learning
Transfer time: Actually reading/writing the data (usually negligible); Lesson 1421 — Why Disk Scheduling Matters
Transferable: You can delegate access by passing the capability; Lesson 2532 — Capability-Based Security
transition: is the rule for moving from one state to another.; Lesson 920 — State Definition and Transitions Lesson 926 — Longest Increasing Subsequence (LIS)Lesson 927 — Edit Distance (Levenshtein Distance)Lesson 928 — Coin Change: Minimum Coins Lesson 936 — Longest Palindromic Substring Lesson 937 — Matrix Chain Multiplication Lesson 939 — Maximum Subarray Sum (Kadane's as DP)Lesson 940 — Unique Paths in Grid (+1 more)
Transition function: For each DFA state S (a set of NFA states) and each alphabet symbol a:; Lesson 1800 — Subset Construction: NFA to DFA Conversion Lesson 1830 — PDA Transition Functions Lesson 1851 — Components of a Turing Machine Lesson 1853 — States and Transition Functions
Transition gradually: Start by changing passwords for financial and email accounts first; Lesson 2515 — Password Managers and Best Practices
transition table: provides an alternative, tabular representation of exactly the same information.; Lesson 1783 — DFA Transition Tables Lesson 1943 — Building a Transition Table
Transition to C-new: Once C-old,new commits, the leader appends a C-new entry; Lesson 2671 — Cluster Membership Changes in Raft
Transitions: are **arrows** connecting states.; Lesson 1779 — DFA State Diagrams Lesson 1784 — Combining Conditions with Product Construction Lesson 1786 — DFAs for Union of Languages Lesson 1799 — NFA Example: Substring Recognition Lesson 1805 — Closure Properties: Intersection Lesson 1836 — Converting CFGs to PDAs
transitive: if whenever element `a` is related to `b`, and `b` is related to `c`, then `a` must also be related to `c`.; Lesson 71 — Properties of Relations: Transitivity Lesson 72 — Equivalence Relations Lesson 74 — Partial Orders Lesson 75 — Total Orders and Chains Lesson 2564 — Happens-Before Relationship
transitive dependencies: .; Lesson 1639 — Achieving Third Normal Form Lesson 1644 — Practical Normalization Process
Transitivity: ensures classes are "complete" — if `a` relates to `b` and `b` relates to `c`, then `a` and `c` are in the same class; Lesson 73 — Equivalence Classes and Partitions Lesson 1936 — Reduction Chains Lesson 2613 — Causal Consistency Lesson 2627 — Happens-Before Relation
Translation: For every spot in your pattern, it tells you "how much of the beginning of the pattern also appears at the end, right before this spot.; Lesson 834 — Knuth-Morris-Pratt: Prefix Function
Translation Lookaside Buffer (TLB): is a small, ultra-fast hardware cache inside the CPU that stores recently-used address translations.; Lesson 1345 — Translation Lookaside Buffer (TLB)Lesson 1362 — Translation Lookaside Buffer (TLB)
Translation Lookaside Buffers (TLBs): where the flexibility justifies the cost.; Lesson 1130 — Fully Associative Caches
Transmission Control Protocol (TCP): and **Internet Protocol (IP)**.; Lesson 1438 — The TCP/IP Model
Transmission media: Copper wire, fiber optic cable, or wireless spectrum; Lesson 1441 — Physical Layer Overview
Transmission medium: Copper cables, fiber optic cables, radio waves, etc.; Lesson 1433 — OSI Layer 1: Physical Layer
Transmit if clear: Start sending if nobody else is transmitting; Lesson 1450 — Medium Access Control (MAC)
Transparency: Everyone on the Scrum team and stakeholders can see the backlog.; Lesson 2377 — Scrum Artifacts: Product Backlog Lesson 2380 — Daily Scrum (Stand-up)
Transport Layer: – Ensures reliable data delivery, breaks data into segments; Lesson 1432 — The OSI Model: Seven-Layer Overview Lesson 1436 — OSI Layer 4: Transport Layer Lesson 1438 — The TCP/IP Model Lesson 1440 — Encapsulation and Layer Communication
Transport Layer (TCP/IP): = OSI Layer 4; Lesson 1439 — Mapping OSI to TCP/IP
Transport Layer Security (TLS): is a cryptographic protocol that provides secure communication over a computer network.; Lesson 1529 — TLS Overview and Purpose Lesson 2442 — TLS: The Security Layer Behind HTTPS
Transposition: swaps rows and columns—row 0 becomes column 0.; Lesson 245 — Common 2D Array Operations
TRAP: Lesson 1332 — Base and Limit Registers
Traveling Salesman Problem: .; Lesson 290 — O(n!): Factorial Time
Traversability: (efficient indexing and querying); Lesson 1719 — JSON and BSON Data Formats
Traversal: Following edges respects direction in directed graphs; Lesson 684 — Directed vs Undirected Graphs
Traverse the chain: O(α) on average; Lesson 433 — Average-Case Time Complexity Analysis Lesson 435 — Chaining Performance with Load Factor
traverse the entire list: from head to tail, then update the last node's `next` pointer to point to your new node.; Lesson 329 — Inserting at the Tail Lesson 330 — Maintaining a Tail Pointer
Traverse the expression tree: (usually the AST) to determine evaluation order; Lesson 2054 — Code Generation for Expressions
Traverse the list: Start at the head and move forward until you reach the node whose `next` pointer points to the tail; Lesson 333 — Deleting from the Tail
Traversing: means visiting each node in a structured way and performing operations on it.; Lesson 1981 — Traversing Abstract Syntax Trees
Tree edges: Edges that connect a parent to its child in the BFS tree.; Lesson 700 — BFS Tree and Parent Tracking
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: is the process of visiting each node in a tree exactly once, in a specific, systematic order.; Lesson 468 — What is Tree Traversal?
Tree traversals: visiting each child node of a tree; Lesson 226 — Multiple Recursive Calls
Tree/graph traversals: (in-order, pre-order, post-order); Lesson 718 — DFS Applications and Use Cases
Trees provide balanced performance: Well-designed trees can guarantee logarithmic time complexity for insertions, deletions, and searches — combining the best aspects of arrays and linked lists.; Lesson 450 — What is a Tree? Definition and Motivation
Treiber's algorithm: , which uses atomic compare-and-swap (CAS) operations:; Lesson 2581 — Concurrent Stack Implementations
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
trie: (pronounced "try," from re**TRIE**val) is a tree-based data structure designed specifically for storing strings.; Lesson 619 — What is a Trie? Motivation and Use Cases Lesson 630 — Tries vs Hash Tables for String Storage
Trigger: OS finishes creating the process and admits it to the ready queue.; Lesson 1221 — Process State Transitions
Triggers: Automated checks that fire on data changes; Lesson 1658 — Consistency: Maintaining Database Invariants
Trivial: if it's true for *all* programs or *no* programs; Lesson 1884 — Rice's Theorem Introduction
Trivial dependencies: are always true but useless for design.; Lesson 1622 — Functional Dependency Notation and Terminology
TRUE: or **FALSE**.; Lesson 13 — Boolean Values and Truth Tables Lesson 33 — Logical Conjunction (AND)Lesson 34 — Logical Disjunction (OR)Lesson 38 — Biconditional Statements Lesson 46 — Predicates and Propositional Functions Lesson 48 — Existential Quantifier (∃)Lesson 1605 — EXISTS and NOT EXISTS
True case: If `e ⇓ true` and `s₁ ⇓ v`, then `if e then s₁ else s₂ ⇓ v`; Lesson 2022 — Operational Semantics of Conditionals
True Concurrency: Since each user thread maps to a separate kernel thread, the operating system can schedule them on different CPU cores simultaneously.; Lesson 1235 — Multithreading Models: One-to-One Lesson 1236 — Multithreading Models: Many-to-Many
True median: (finding the actual middle value) would guarantee optimal splits but costs O(n) time—defeating Quicksort's efficiency.; Lesson 764 — Choosing a Pivot: Strategies and Tradeoffs
Truly Invalid Example: Lesson 496 — Valid vs Invalid BSTs
Trust: Don't mentally trace `factorial(3) → factorial(2) → factorial(1).; Lesson 869 — Building Recursive Solutions from Scratch
Trust and collaboration: between developers, testers, and users produces better software than following a script.; Lesson 2362 — Individuals and Interactions Over Processes and Tools
Trust over legal protection: The relationship is built on mutual trust and transparency; Lesson 2364 — Customer Collaboration Over Contract Negotiation
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 Lesson 18 — NAND and NOR Gates Lesson 34 — Logical Disjunction (OR)
Truth Table for Negation: Lesson 32 — Logical Negation
Try: each possible value for that variable; Lesson 864 — Constraint Satisfaction Problems
TTL value: (in seconds) that tells caching systems how long they can trust the stored answer before checking again.; Lesson 1509 — DNS Caching and Time-to-Live (TTL)
tuples: Lesson 66 — Cartesian Products Lesson 200 — Multiple Return Values Lesson 1560 — From Relational Model to SQL Lesson 1987 — Composite Types: Products
Tuples/Immutable structures: When states need hashing for visited sets; Lesson 2731 — State Representation Strategies
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?
Turing machines: (which you've just learned!; Lesson 1860 — The Quest for a Formal Definition of Algorithm Lesson 1864 — Equivalence of Computational Models
Turing reduction: shows that problem A can be solved using problem B's oracle: you write an algorithm for A that can call the oracle for B multiple times, adapting its strategy based on the oracle's answers.; Lesson 1930 — Turing Reductions
Turing-recognizable language: (also called *recursively enumerable*) is simply the set of all strings that some Turing Machine accepts.; Lesson 1859 — Languages Recognized by Turing Machines
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 Lesson 1249 — Scheduling Criteria Trade-offs Lesson 1261 — Comparing Scheduling Algorithm Performance
Turnaround Time vs Fairness: Always running the shortest job first minimizes average turnaround time mathematically, but a very long job might wait indefinitely while short jobs keep arriving.; Lesson 1249 — Scheduling Criteria Trade-offs
Twisted-pair: (like Ethernet cables) and **coaxial** cables transmit electrical signals; Lesson 1442 — Transmission Media Types
two: regions (less than pivot, greater-or-equal to pivot), three-way partitioning creates **three** regions:; Lesson 772 — Three-Way Partitioning for Duplicate Keys Lesson 1827 — Limitations of Context-Free Grammars
Two disjoint sets: The vertices are partitioned into two groups with no overlap; Lesson 689 — Bipartite Graphs
Two key operations: Lesson 1015 — Kruskal's Algorithm: Union-Find Data Structure
Two locks: (one for head, one for tail) allowing simultaneous enqueue/dequeue; Lesson 2578 — Concurrent Queue: Array-Based Implementation Lesson 2579 — Concurrent Queue: Linked List Implementation
two pointers: , one pointing to the next node and another pointing to the previous node.; Lesson 339 — Doubly Linked List Structure and Node Design Lesson 525 — Space Complexity of BSTs
Two recursive calls: 2 × T(n/2) — sorting each half; Lesson 756 — Mergesort Time Complexity Analysis
Two requirements for purity: Lesson 2132 — Pure Functions and Immutability
Two variants: Lesson 1327 — Deadlock Recovery Strategies
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
Two-level: The L1 miss penalty *is* accessing L2:; Lesson 1147 — Multi-Level Cache Performance Analysis
two-level page table: Lesson 1358 — Hierarchical Page Tables Lesson 1359 — Two-Level Page Tables
Two-phase approach: Lesson 818 — Binary Search on Infinite Arrays
Two-Phase Commit: and **Three-Phase Commit** (which you've already seen).; Lesson 2655 — Leader Election Basics
Two-Phase Querying: First query one shard set, then use those results to query other shards with specific keys.; Lesson 2692 — Cross-Shard Queries and Joins
two's complement: for these reasons—but understanding sign-magnitude builds your foundation for why other representations evolved.; Lesson 1057 — Signed Integers: Sign-Magnitude Representation Lesson 1058 — One's Complement Representation Lesson 1059 — Two's Complement: The Standard for Signed Integers
Type annotations: are the syntax you use to explicitly declare these types in your source code.; Lesson 1995 — Type Annotations and Signatures Lesson 2000 — Type Annotations in Static Languages
type checking: before runtime, catching mismatches early.; Lesson 1995 — Type Annotations and Signatures Lesson 1996 — Type Errors and Error Messages Lesson 2039 — Abstract Syntax Trees (ASTs) as IR
Type constraints: Enforce that `age` is a number, not a string; Lesson 1725 — Schema Validation and Flexibility
Type errors: Assigning a string to an integer variable (in statically typed languages); Lesson 2032 — Error Detection: Compile-Time vs Runtime
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 Inference Lesson 2007 — What is Type Inference?
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 markers: (explicit integer vs string vs date); Lesson 1719 — JSON and BSON Data Formats
type safety: , and languages that strictly enforce it are called **strongly typed**.; Lesson 146 — Type Safety and Strong Typing Lesson 1989 — Type Safety and Type Soundness Lesson 1993 — Parametric Polymorphism Lesson 2335 — Primitive Obsession Smell
Type Safety (Soundness): "Well-typed programs don't go wrong.; Lesson 2026 — Proving Semantic Properties
Type soundness: (or "soundness" for short) is the formal property that guarantees this safety.; Lesson 1989 — Type Safety and Type Soundness
Type systems: deliberately restrict what you can express to maintain decidability; Lesson 1887 — Philosophical and Practical Impact
Type variables: It starts by assigning unknown type variables (like `α`, `β`) to expressions whose types aren't immediately obvious.; Lesson 2009 — Hindley-Milner Type System Lesson 2010 — Type Variables and Unification
TypeScript: is the most prominent example.; Lesson 2005 — Gradual Typing Systems
Typical impact: TLB hit rates of 99% are common, but that remaining 1% can still cost you 10-20% performance if page table walks are expensive.; Lesson 1350 — Virtual Memory Performance Considerations

U

UDP: (fast); Lesson 1438 — The TCP/IP Model Lesson 1498 — Overhead and Header Size Comparison Lesson 1527 — HTTP/3 and QUIC
UDP (User Datagram Protocol): is a *connectionless*, *unreliable* transport protocol that strips away all the guarantees TCP provides.; Lesson 1486 — UDP Protocol Overview and Design Philosophy
UDP Client: Lesson 1546 — UDP Socket Programming Basics
UDP header: All fields including source port, destination port, length, and the checksum field itself (set to zero during calculation).; Lesson 1489 — UDP Checksum Calculation and Verification Lesson 1498 — Overhead and Header Size Comparison
UDP port 53: (occasionally TCP for larger responses).; Lesson 1512 — DNS Protocol and Message Format
UDP Server: Lesson 1546 — UDP Socket Programming Basics
Unacknowledged Data: TCP tracks which segments haven't been ACKed yet; Lesson 1476 — TCP Reliability: Retransmission
unbalanced BST: leans heavily to one side.; Lesson 521 — BST Height and Balance Lesson 545 — AVL Trees vs Unbalanced BSTs
Unbalanced trees: (like a chain) have high IPL because most nodes are far from the root.; Lesson 490 — Path Length Properties
Unbounded Knapsack: variant removes that restriction—now you can select each item *unlimited times* as long as your knapsack capacity allows.; Lesson 931 — Unbounded Knapsack Problem
Uncertainty from opposition: You cannot simply plan a path to victory—you must consider how your opponent will respond to every move you make; Lesson 2764 — Adversarial Search Overview
Unchoose: Remove the choice and try the next option; Lesson 857 — Backtracking Template Pattern
Unchoose (Backtrack): Swap back to restore the original state; Lesson 858 — Generating All Permutations
Unclassified: Lesson 2530 — Mandatory Access Control (MAC)
Unclear intent: Future readers (including yourself) must guess what the number represents; Lesson 2323 — Replace Magic Numbers with Named Constants
unconditional jumps: come in.; Lesson 1099 — Unconditional Jumps and Labels Lesson 2055 — Control Flow Code Generation
Uncorrelated subqueries: that run independently of the outer query typically perform well because they execute just once and the result is reused.; Lesson 1609 — Subquery Performance Considerations
undecidable: , we're showing it lies beyond that boundary forever.; Lesson 1877 — Decidability as a Fundamental Limit Lesson 1882 — The Contradiction Emerges Lesson 2014 — Type Inference Limitations
Undeclared identifiers: Using variables that don't exist; Lesson 2032 — Error Detection: Compile-Time vs Runtime
Underflow: Attempting `dequeue` or `peek` on an empty queue; Lesson 377 — Queue Interface and Specification Lesson 1683 — Deletion from Leaf Nodes
underfull: .; Lesson 563 — B-Tree Deletion: Leaf Node Cases Lesson 566 — Merging Nodes in B-Trees
Understand: Other developers (including future you) struggle to grasp what the code does; Lesson 2329 — Introduction to Code Smells
Understand at a glance: – You grasp what it does without scrolling; Lesson 2310 — Function Length and Single Responsibility
Understand both sides: Review what changed in both branches—use `git diff` and commit history to understand intent; Lesson 2200 — Handling Merge Conflicts in Teams
Understand data relationships: – They formally describe how attributes connect; Lesson 1621 — Introduction to Functional Dependencies
Understanding: why simply checking parent-child pairs isn't enough; Lesson 500 — BST Range Property
Understanding computers deeply: Learning assembly reveals exactly how your CPU executes instructions, manages memory, and handles data—knowledge that makes you a better programmer in *any* language.; Lesson 1091 — Assembly Language Overview and Purpose
Underutilization: happens when many deletions leave buckets mostly empty, wasting memory.; Lesson 1694 — Hash Index Insertion and Deletion
Undirected: The matrix is *symmetric* across the diagonal.; Lesson 678 — Directed vs Undirected Graph Storage Lesson 684 — Directed vs Undirected Graphs
undirected graph: , edges represent **bidirectional** relationships.; Lesson 658 — Directed vs Undirected Graphs Lesson 661 — Degree of a Vertex Lesson 663 — Cycles and Acyclic Graphs Lesson 669 — Adjacency Matrix: Structure and Memory Lesson 678 — Directed vs Undirected Graph Storage Lesson 679 — Incidence Matrix Representation Lesson 684 — Directed vs Undirected Graphs
undirected graphs: , a cycle exists if during DFS you encounter an edge leading to an already-visited node *that isn't your immediate parent*.; Lesson 713 — Cycle Detection with DFS Lesson 714 — DFS on Directed vs Undirected Graphs
Undo: the assignment and try the next value; Lesson 864 — Constraint Satisfaction Problems Lesson 1664 — Recovery Mechanisms and Durability Lesson 2292 — Command Pattern for Undo/Redo Lesson 2722 — Compensating Transactions
Undo Stack: Stores every state or action as you work.; Lesson 371 — Undo/Redo Functionality
Undoing a rebase: Find the pre-rebase HEAD position and reset to it.; Lesson 2207 — Reflog and Recovery
Unforgeable signature: or cryptographic proof; Lesson 2532 — Capability-Based Security
Unification: It solves these equations to find the most general type that satisfies all constraints.; Lesson 2009 — Hindley-Milner Type System Lesson 2010 — Type Variables and Unification
uniform distribution: .; Lesson 128 — Uniform Distribution Lesson 797 — Bucket Sort: When It Works Best
Uniform input size: The signature algorithm always receives predictable-length input; Lesson 2436 — Hash-then-Sign Paradigm
Uniform-Cost Search: recognizes that edges can have different *costs* (weights).; Lesson 2746 — Uniform-Cost Search
Unify types: The unification algorithm matches these patterns together; Lesson 2010 — Type Variables and Unification
Uninitialized data (BSS): variables declared but not yet assigned; Lesson 1216 — Process Components: Memory Layout
Union: `A ∪ B = B ∪ A`; Lesson 65 — Set Identities and Laws Lesson 111 — Union and Intersection of Events Lesson 1015 — Kruskal's Algorithm: Union-Find Data Structure Lesson 1559 — Relational Algebra Basics Lesson 1761 — Language Operations: Union and Concatenation Lesson 1764 — The Empty Language vs Empty String Lesson 1803 — Closure Properties: Union and Concatenation Lesson 1812 — Regular Language Identities and Algebraic Laws (+2 more)
Union ( ): brings sets *together*.; Lesson 62 — Set Union and Intersection
Union (A B): Shade everything covered by either circle; Lesson 64 — Venn Diagrams
Union `|`: – has the lowest precedence, splits broadly; Lesson 1774 — Precedence and Parentheses in Regular Expressions
Union types: (TypeScript, though less strict); Lesson 1988 — Composite Types: Sums
Union-based: Uses the `UNION` operator to append malicious query results to legitimate ones; Lesson 2476 — Types of SQL Injection Attacks
Union-Find (Disjoint Set Union): data structure comes in handy, though we'll explore that implementation detail separately.; Lesson 1014 — Kruskal's Algorithm: Overview
Union-find operations: E operations × α(V) ≈ O(E) where α is the inverse Ackermann function (practically constant); Lesson 1016 — Kruskal's Algorithm: Implementation and Analysis
unique: (use all four operations as needed); Lesson 395 — Deque: Double-Ended Queue Fundamentals Lesson 1787 — Minimizing States in DFAs
Unique Constraints: guarantee no duplicates in specified columns.; Lesson 1659 — Integrity Constraints and Consistency
Unique password enforcement: by rejecting passwords found in breach databases; Lesson 2514 — Credential Stuffing and Breach Detection
Unique passwords everywhere: Generate cryptographically random passwords like `7$mQ9#xP2!; Lesson 2515 — Password Managers and Best Practices
Unique per password: Generate a fresh salt for every user, every time they set a password; Lesson 2506 — Salt: Defending Against Rainbow Tables
Unique per-password: Add randomness (salts) so identical passwords produce different hashes; Lesson 2504 — Password Storage Fundamentals
Uniqueness: No two running processes share the same PID at the same time; Lesson 1228 — Process IDs and Identification Lesson 1555 — Primary Keys Lesson 2012 — Principal Types and Most General Unifiers Lesson 2434 — Digital Signature Properties Lesson 2655 — Leader Election Basics Lesson 2674 — Proposal Numbers and Ordering Lesson 2731 — State Representation Strategies
Unit: One function/method at a time; Lesson 2235 — Integration Testing vs 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?Lesson 2355 — The V-Model: Verification and Validation
Unit tests: are cheap, run in milliseconds, and pinpoint exact failures.; Lesson 2217 — The Testing Pyramid Lesson 2235 — Integration Testing vs Unit Testing Lesson 2386 — Automated Testing in CI
Universal: No special hardware or biometric readers needed; Lesson 2517 — Knowledge Factors (Something You Know)
Universal hashing: solves this by picking a hash function *randomly* from a large family of functions every time you initialize a hash table.; Lesson 414 — Universal Hashing
universal set: contains *all* elements under consideration in a particular context.; Lesson 59 — Special Sets and Set Equality Lesson 64 — Venn Diagrams
Unix/Linux: `/home/alice/documents/report.; Lesson 1390 — File Paths: Absolute vs Relative Lesson 1397 — File Control Blocks and Inodes
Unlabeled data only: ?; Lesson 2793 — Choosing the Right Learning Paradigm
Unlock and leave: = exiting the critical section; Lesson 1275 — Mutual Exclusion Explained
Unlock the mutex: when done; Lesson 1306 — The Wait-Signal Pattern
Unmark current cell: (backtrack); Lesson 863 — Maze and Path Finding
Unmarking during backtracking: allows the cell to be part of a *different* path attempt later; Lesson 863 — Maze and Path Finding
Unnecessary complexity: Patterns designed for specific problems become dead weight when misapplied; Lesson 2306 — Cargo Cult Programming Anti-Pattern
Unnecessary merges: Sometimes after dividing, the two halves are already in order relative to each other.; Lesson 759 — Optimizing Mergesort
Unpredictable latency is unacceptable: No worst-case blocking scenarios; Lesson 2574 — Performance Characteristics of Lock-Free Algorithms
Unreachable: A symbol that can never appear in any derivation starting from the start symbol; Lesson 1825 — Removing Useless Symbols Lesson 2095 — Reachability and the Root Set
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
Unreachable code: Lesson 2071 — Peephole Optimization
Unsafe state: No such guarantee exists; deadlock *might* occur (though it's not inevitable yet).; Lesson 1323 — Deadlock Avoidance: Safe States Lesson 1325 — Banker's Algorithm: Safety Check
unsigned: versions (only non-negative numbers), which double the positive range.; Lesson 140 — Integer Data Types Lesson 150 — Signed vs Unsigned Integers Lesson 1056 — Unsigned Binary Integers in Hardware Lesson 1062 — Integer Width and Range Tradeoffs
Unsigned integers: can only be zero or positive.; Lesson 150 — Signed vs Unsigned Integers
unsorted array: or a **sorted array**.; Lesson 390 — Priority Queue Array Implementation Lesson 610 — Heap as Priority Queue Implementation
Unsorted heap region: (at the front); Lesson 780 — In-Place Sorting with Heapsort
Unsorted portion: everything to the right, shrinks as we go; Lesson 744 — Selection Sort: Algorithm
unstable: .; Lesson 745 — Selection Sort: Analysis Lesson 803 — Stability in Production Sorting
unsupervised learning: works with unlabeled data—no targets, no correct answers given in advance.; Lesson 2788 — Unsupervised Learning: Finding Patterns Without Labels Lesson 2789 — Clustering Fundamentals Lesson 2790 — Dimensionality Reduction Concepts Lesson 2793 — Choosing the Right Learning Paradigm
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
Unvisited: not yet explored; Lesson 726 — Detecting Cycles During Topological Sort
Unweighted graph: A map showing which cities have direct flights between them.; Lesson 659 — Weighted vs Unweighted Graphs Lesson 669 — Adjacency Matrix: Structure and Memory Lesson 685 — Weighted and Unweighted Graphs
unweighted graphs: the edge's existence is all that matters.; Lesson 659 — Weighted vs Unweighted Graphs Lesson 685 — Weighted and Unweighted Graphs Lesson 699 — Shortest Path in Unweighted Graphs
up: toward the root, just like insertion.; Lesson 594 — Increase/Decrease Key Operations Lesson 595 — Delete Arbitrary Element Lesson 1294 — Wait (P) and Signal (V) Operations Lesson 1432 — The OSI Model: Seven-Layer Overview
Update: the variable inside the loop body; Lesson 177 — Loop Control Variables Lesson 179 — The For Loop Lesson 180 — Loop Initialization, Condition, and Update Lesson 358 — Pop Operation Lesson 1571 — UPDATE Statement for Modifying Data Lesson 1721 — CRUD Operations in Document Databases Lesson 2114 — Mutable State and Variables
Update all references: to point to the new locations; Lesson 2097 — Copying Collection
Update anomalies: If a major moves buildings, you must update many student records; Lesson 1625 — Transitive Functional Dependencies Lesson 1634 — Second Normal Form (2NF) Definition Lesson 1635 — Partial Dependencies Explained Lesson 1637 — Third Normal Form (3NF) Definition Lesson 1638 — Transitive Dependencies Explained Lesson 1648 — Data Redundancy and Consistency Risks
Update anomaly: Changing one copy but forgetting others creates inconsistency; Lesson 1631 — Introduction to Normal Forms
Update heights: Recalculate each ancestor's height using its children; Lesson 541 — AVL Deletion Overview
Update metadata: tracking which blocks are free and which are in use; Lesson 2080 — Stack vs Heap: Allocation Speed
Update neighbors: For each neighbor, calculate new potential distances; if improved, update the distance and insert/decrease-key in the priority queue; Lesson 613 — Dijkstra's Algorithm with Priority Queue
Update page table: The page table entry is updated with the new physical address and marked as "present"; Lesson 1346 — Page Faults and Demand Paging
Update pointers: so the parent links to both new child nodes; Lesson 561 — Node Splitting During Insertion
Update process state: Mark the old process as Ready or Waiting (it's no longer Running); Lesson 1229 — Context Switching Between Processes
Update tail pointer: (if you're maintaining one): Point it to the new last node; Lesson 333 — Deleting from the Tail
Update that node's `next`: to point to your new node; Lesson 329 — Inserting at the Tail
Update the head pointer: to point to your new node; Lesson 328 — Inserting at the Head Lesson 341 — Inserting at the Head of a Doubly Linked List
Update the leaf: with the new value; Lesson 645 — Point Update Operations
Update the parent's pointer: (either `left` or `right`) to `null`; Lesson 508 — BST Deletion: Leaf Node Case
Update the pointer: Set that second-to-last node's `next` to `NULL`; Lesson 333 — Deleting from the Tail
Update the Program Counter: The PC is incremented to point to the next instruction in sequence (usually PC = PC + instruction size).; Lesson 1082 — The Fetch Stage
Update the tail pointer: – Move it backward to point at the new last node; Lesson 345 — Deleting from the Tail of a Doubly Linked List
Update the TLB: The new translation is loaded into the TLB, possibly evicting an old entry; Lesson 1363 — TLB Miss Handling
Update weights: Lesson 2858 — AdaBoost Algorithm
updated: to a different address—jumping to a new location in memory rather than just moving forward.; Lesson 1083 — Program Counter and Instruction Address Lesson 1177 — Dynamic Branch Prediction Basics
Updates: each process's base register to reflect its new location; Lesson 1337 — Memory Compaction
Updates propagate asynchronously: in the background; Lesson 2614 — Eventual Consistency Overview
Updating: simply replaces the contents of one mailbox.; Lesson 239 — Common Array Operations
upper bound: .; Lesson 85 — Summation Notation and Series Lesson 280 — What is Big-O Notation?Lesson 292 — Introduction to Big-Theta Notation Lesson 294 — Proving Big-Theta Bounds Lesson 304 — Space Complexity Notation Lesson 500 — BST Range Property Lesson 811 — Upper Bound Search
Upper bound search: finds the *last* position—or more precisely, the position *after* the last occurrence of the target value.; Lesson 811 — Upper Bound Search
Upper threshold: If page faults happen too frequently, the process doesn't have enough frames—it's thrashing.; Lesson 1376 — Page Fault Frequency
Uppercase: "A" is 65, "B" is 66.; Lesson 24 — ASCII: The Foundation
URI: specifies the exact resource path on the server.; Lesson 1515 — HTTP Request Structure
URL context: Use URL encoding (percent-encoding) for special characters; Lesson 2460 — Output Encoding and Escaping
URL parameters: Query strings like `?; Lesson 2458 — XSS Attack Vectors and Payloads Lesson 2497 — Session Management Basics
Use a max-heap: when you frequently need the *largest* element (e.; Lesson 599 — Heap Operation Trade-offs
Use a min-heap: when you frequently need the *smallest* element (e.; Lesson 599 — Heap Operation Trade-offs Lesson 612 — Event-Driven Simulation
Use algebraic manipulation: Transform the k+1 case using the k case assumption; Lesson 89 — Inductive Step: The Core Argument
Use as pivot: This "median of medians" becomes your partition pivot; Lesson 826 — Median of Medians: Partitioning Strategy
Use asymmetric crypto once: to securely exchange or encrypt a random symmetric key (often called a "session key"); Lesson 2416 — Hybrid Cryptosystems
Use binary semaphores when: Lesson 1293 — Binary Semaphores vs Counting Semaphores
Use case: Finding degrees of separation between people, or the minimum number of flights between airports.; Lesson 1752 — Path Finding Algorithms
Use cases: Lesson 2538 — OAuth 2.0 Grant Types: Client Credentials and Resource Owner Password Lesson 2708 — Point-to-Point vs Publish-Subscribe Models
Use concurrency when: Lesson 2553 — Choosing Between Concurrency and Parallelism
Use consensus protocols: Require majority agreement before acting (like requiring 2 of 3 nodes to agree); Lesson 2589 — Network Partitions and Split-Brain
Use counting semaphores when: Lesson 1293 — Binary Semaphores vs Counting Semaphores
Use cross-validation: to tune K carefully; Lesson 2872 — KNN in Practice: Applications and Limitations
Use debugging tools: Valgrind and AddressSanitizer detect use-after-free bugs during testing.; Lesson 2088 — Dangling Pointers and Use-After-Free Lesson 2089 — Double-Free Errors
Use default values: when possible; Lesson 205 — Parameter Type Checking and Validation
Use Dynamic Programming when: Lesson 912 — Greedy vs Dynamic Programming Decision
Use feature flags: to hide incomplete work in production rather than isolating it in branches; Lesson 2199 — Trunk-Based Development
Use Floyd-Warshall when: Lesson 999 — Floyd-Warshall vs Repeated Dijkstra
Use Greedy when: Lesson 912 — Greedy vs Dynamic Programming Decision
Use Iteration when: Lesson 223 — Recursion vs Iteration
Use joins when: you need columns from multiple tables in your result.; Lesson 1588 — Join vs Subquery Trade-offs
Use parallelism when: Lesson 2553 — Choosing Between Concurrency and Parallelism
Use pronounceable names: `gen_ymdhms` becomes `generate_timestamp`; Lesson 2309 — Meaningful Names for Variables and Functions
Use Read Uncommitted: (rarely):; Lesson 1675 — Setting Isolation Levels in Practice
Use Recursion when: Lesson 223 — Recursion vs Iteration
Use Repeatable Read: when you need:; Lesson 1675 — Setting Isolation Levels in Practice
Use Repeated Dijkstra when: Lesson 999 — Floyd-Warshall vs Repeated Dijkstra
Use Serializable: when you need:; Lesson 1675 — Setting Isolation Levels in Practice
Use stable selectors: Avoid brittle CSS classes (`<button class="btn-primary-v2">`).; Lesson 2254 — E2E Testing Challenges and Best Practices
Use stubs: Replace calls to lower-level modules with stubs that return predictable, hard-coded values; Lesson 2238 — Top-Down Integration Testing
Use subqueries when: you're filtering based on another table but don't need its columns, or when the logic feels more "step-by-step":; Lesson 1588 — Join vs Subquery Trade-offs
Use symmetric crypto: with that session key to encrypt the actual message data; Lesson 2416 — Hybrid Cryptosystems
Use that: as your pivot for partitioning; Lesson 825 — Median of Medians: Deterministic Selection
Use three pointers: One for each input subarray and one for the output position; Lesson 754 — The Merge Operation
Used: The path goes `i → k → j`, so we combine the shortest path from `i` to `k` with the shortest path from `k` to `j`; Lesson 992 — Floyd-Warshall Dynamic Programming Formulation
User attributes: job title, department, security clearance, employee ID; Lesson 2528 — Attribute-Based Access Control (ABAC)
User Authorization: The client redirects the user to the authorization server with a request containing client ID, requested scopes, and a redirect URI; Lesson 2536 — OAuth 2.0 Grant Types: Authorization Code Grant
User frequency: How often do users follow this path?; Lesson 2248 — Test Scenarios and User Journeys
User input fields: Search boxes, comment forms, profile fields; Lesson 2458 — XSS Attack Vectors and Payloads
User mode: is a restricted execution environment where most application programs run.; Lesson 1194 — OS Kernel and User Space Lesson 1204 — User Mode vs Kernel Mode
User profiles and sessions: Use a key-value store for fast lookups; Lesson 1716 — Polyglot Persistence Strategy
User Threads: are created, scheduled, and managed entirely by thread libraries in user space—outside the OS kernel.; Lesson 1233 — User Threads vs Kernel Threads
User/Supervisor bit: Is this accessible from user mode?; Lesson 1348 — Memory Protection with Virtual Memory
Username authentication: `WHERE username = 'johndoe'`; Lesson 1696 — Hash Indexes in Practice
Usernames: If you have 1,001 users and only 1,000 available usernames, at least two users must share a username pattern (collision inevitable).; Lesson 103 — The Pigeonhole Principle
Uses all characters: Every character contributes to the final value; Lesson 411 — Hashing Strings: Basic Approach
Using a count field: Lesson 528 — BST with Duplicate Keys
Using a cycle detector: that runs periodically to catch reference cycles that pure counting can't handle; Lesson 2110 — Reference Counting in Practice
Using automated security scanners: (OWASP ZAP, Burp Suite); Lesson 2473 — Implementing CSRF Protection
UTF-16: and **UTF-32** take different approaches:; Lesson 28 — UTF-16 and UTF-32
UTF-32: take different approaches:; Lesson 28 — UTF-16 and UTF-32
UTF-8: Best for web/English, complex indexing; Lesson 28 — UTF-16 and UTF-32

V

V - 1: edges (where V is the number of vertices) and contains no cycles.; Lesson 1012 — Minimum Spanning Tree Definition and Properties
V iterations: (one per vertex added) → O(V²) total; Lesson 1019 — Prim's Algorithm: Time Complexity Analysis
V phases: .; Lesson 1042 — Dinic's Algorithm Implementation
V vertices: and **E edges**, the algorithm visits every vertex once and explores every edge once.; Lesson 698 — BFS Time and Space Complexity
V-1 iterations: (where V is the number of vertices), and in each iteration it attempts to **relax every single edge** in the graph.; Lesson 981 — Bellman-Ford Algorithm Structure
V-1 times: (where V is the number of vertices).; Lesson 986 — Bellman-Ford Time Complexity
V²: operations; Lesson 717 — DFS Time Complexity Analysis
Valgrind: A powerful tool that tracks every allocation and reports leaks when your program exits.; Lesson 2087 — Memory Leaks: Causes and Detection
Valid complete tree: Levels filled top-to-bottom, last level filled left-to-right; Lesson 576 — Complete Binary Tree Property
valid flow: in a flow network is an assignment of flow values to each edge that obeys two critical rules you've already learned:; Lesson 1025 — Valid Flows and Flow Value Lesson 1034 — Maximum Flow Problem Definition
Valid inputs: (18-65): Test with one value, say 30; Lesson 2221 — Equivalence Partitioning
Valid range: -1, 0, or +1; Lesson 532 — Height-Balance Invariant
Validate: that the offset `d` is less than the segment's limit (bounds checking); Lesson 1380 — Logical Address Translation in Segmentation
Validate early: Check that email addresses look like emails, numbers are actually numbers, and dates are valid dates.; Lesson 2459 — Input Validation and Sanitization
Validating: whether a binary tree is actually a BST; Lesson 500 — BST Range Property
Validation: "Is the top element what I expect before I pop it?; Lesson 359 — Peek (or Top) Operation Lesson 474 — Inorder and Binary Search Trees Lesson 2214 — What is Software Testing?Lesson 2215 — Verification vs Validation Lesson 2270 — Builder Pattern for Complex Objects Lesson 2335 — Primitive Obsession Smell Lesson 2355 — The V-Model: Verification and Validation Lesson 2459 — Input Validation and Sanitization
Validation loss: decreases, then plateaus, then *increases*; Lesson 2815 — Early Stopping
Validation more meaningful: Performance metrics reflect true class balance; Lesson 2799 — Stratified Sampling
Validity Period: Start and expiration dates (typically 1-2 years); Lesson 1532 — Digital Certificates Fundamentals
Value: The data currently stored (like `42` or `"Alice"`); Lesson 138 — What is a Variable?Lesson 443 — Caching and Memoization Lesson 444 — Symbol Tables in Compilers Lesson 447 — Frequency Counting and Histograms Lesson 1547 — Socket Options and Configuration Lesson 1728 — Key-Value Store Data Model Lesson 2677 — Phase 2a: Accept Request
Value range needed: Use `byte` for small counters (0–100), but `long` for timestamps or large calculations; Lesson 140 — Integer Data Types
Value ranges: Validate that `quantity` is positive or `status` is one of a few allowed values; Lesson 1725 — Schema Validation and Flexibility
values: .; Lesson 1562 — Database Connection and Basic Structure Lesson 1711 — Key-Value Store Fundamentals Lesson 2133 — First-Class and Higher-Order Functions
Variability is real: The network partition scenario you learned earlier often stems from latency spikes that cause timeouts, not just hard failures.; Lesson 2590 — Network Latency and Bandwidth Constraints
Variable assignment: `x = 10` takes one operation; Lesson 283 — O(1): Constant Time
Variable-depth queries: "Find all managers above this employee, regardless of levels"; Lesson 1746 — Graph Database Model and Use Cases
variables: that describe:; Lesson 920 — State Definition and Transitions Lesson 1844 — Greibach Normal Form Lesson 1862 — Alternative Models: Lambda Calculus Lesson 1995 — Type Annotations and Signatures Lesson 2000 — Type Annotations in Static Languages Lesson 2112 — What is Imperative Programming?Lesson 2155 — Constraint Programming Basics
Variance: measures how far outcomes tend to deviate from the mean.; Lesson 133 — Variance: Measuring Spread Lesson 135 — Standard Deviation Lesson 137 — Expected Value and Variance in Algorithm Analysis Lesson 1428 — Comparing Disk Scheduling Algorithms Lesson 2782 — The Bias-Variance Tradeoff Lesson 2808 — The Bias-Variance Tradeoff Lesson 2839 — Classification vs Regression Trees
variance reduction: .; Lesson 2845 — Splitting Criteria for Regression Trees Lesson 2853 — Introduction to Ensemble Learning
Variant types: (OCaml); Lesson 1988 — Composite Types: Sums
vector clock: is a list of counters, one per node in the system.; Lesson 1735 — Vector Clocks and Conflict Resolution Lesson 2631 — Vector Clocks Fundamentals
Vector clocks: handle causality purely logically, but they lose real-world time information.; Lesson 2636 — Hybrid Logical Clocks Lesson 2706 — Eventual Consistency in Practice: Dynamo and Cassandra
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
Verification: Simply plug in the values and evaluate—takes polynomial time in the formula's size.; Lesson 1893 — Examples of Problems in NP Lesson 1904 — Examples of Problems in NP Lesson 1918 — The Clique Problem Lesson 2214 — What is Software Testing?Lesson 2215 — Verification vs Validation Lesson 2355 — The V-Model: Verification and Validation Lesson 2435 — RSA Digital Signature Scheme
Verification (receiver side): Lesson 1489 — UDP Checksum Calculation and Verification
Verification is easy: If someone claims a subset works, you can quickly add those numbers to check (polynomial time); Lesson 1923 — Subset Sum Problem
Verification without recovery: Compare hashes during login, never decrypt; Lesson 2504 — Password Storage Fundamentals
verifier: is an algorithm that checks whether a given certificate is valid, confirming the solution in polynomial time.; Lesson 1901 — Verifiers and Certificates Lesson 1902 — The Class NP: Nondeterministic Polynomial Time
Verifier → Nondeterministic TM: The TM nondeterministically guesses the certificate, then runs the verifier deterministically to check it.; Lesson 1903 — Alternative NP Definition: Nondeterministic TMs
Verify: If you've processed all vertices, you have a valid topological sort.; Lesson 723 — Kahn's Algorithm: Implementation Lesson 1776 — Regular Expression Equivalence Lesson 1902 — The Class NP: Nondeterministic Polynomial Time Lesson 2262 — TDD for Bug Fixes Lesson 2438 — ECDSA (Elliptic Curve Digital Signature Algorithm)
Verify after guessing: Let subsequent states confirm whether the guess was correct.; Lesson 1798 — Designing NFAs: Exploiting Nondeterminism
Verify character-by-character: that the substring actually equals the pattern; Lesson 833 — Rabin-Karp: Collision Handling
Verify improvements: by measuring again; Lesson 2305 — Premature Optimization Anti-Pattern
Verify it's true: Use direct calculation or logic to confirm the statement holds.; Lesson 87 — Base Case: Starting the Proof
Verify minimality: – Remove one attribute at a time.; Lesson 1630 — Using FDs to Identify Candidate Keys
Verifying: a proposed subset: just add the numbers and check—takes polynomial time!; Lesson 1891 — The Class NP (Nondeterministic Polynomial)Lesson 1914 — Verification vs Solution
Version control systems: (VCS) are tools that track every change made to files over time.; Lesson 2167 — What is Version Control?Lesson 2429 — Hash Function Applications: Data Integrity
Version Counters (Tagged Pointers): Pair each pointer with a counter that increments on every modification.; Lesson 2586 — ABA Problem in Lock-Free Structures
Version vectors: (tracking causality like vector clocks); Lesson 2641 — Multi-Leader Replication
vertex cover: of a graph is a set of vertices such that every edge in the graph has at least one of its endpoints in the set.; Lesson 1920 — The Vertex Cover Problem Lesson 1935 — Vertex Cover and Clique Reductions
Vertex Cover Problem: asks: what is the *smallest* such set of vertices that covers all edges?; Lesson 1920 — The Vertex Cover Problem
Vertical Partitioning: splits data by **columns**.; Lesson 2683 — Horizontal vs Vertical Partitioning
Vertical privilege escalation: Regular users performing admin actions; Lesson 2488 — Broken Access Control
Vertices: (also called nodes): Individual points or entities; Lesson 657 — What is a Graph? Vertices and Edges
Vertices (V): Each vertex is processed once—either enqueued and dequeued (Kahn's) or visited during traversal (DFS).; Lesson 727 — Time and Space Complexity
Videos: (yes, even cat videos!; Lesson 1 — What is Binary and Why It Matters
Vigenère Cipher: is the most famous polyalphabetic cipher.; Lesson 2398 — Polyalphabetic Ciphers and the Vigenère Cipher
virtual address: in the process's virtual address space.; Lesson 1339 — What is Virtual Memory?Lesson 1354 — Address Translation in Paging
Virtual Page Number (VPN): Used as an index into the page table; Lesson 1353 — Page Tables
Virtual Proxy: Delay creating expensive objects until actually needed; Lesson 2280 — Proxy Pattern: Controlling Access to Objects
Visibility: Engineers can inspect DLQ messages to diagnose issues—was it bad data, a code bug, or a temporary external dependency failure?; Lesson 2712 — Dead Letter Queues and Poison Messages
Visit a function application: (`f arg`):; Lesson 2011 — Algorithm W
Visit a lambda: (`λx.; Lesson 2011 — Algorithm W
Visit a literal: (like `42`): instantly know its type (`Int`); Lesson 2011 — Algorithm W
Visit a variable: (`x`): look up its type in the environment; Lesson 2011 — Algorithm W
Visit new page: Push onto back stack, empty forward stack; Lesson 372 — Browser History Navigation
Visit the current node: (process its value); Lesson 475 — Postorder Traversal: Left-Right-Root
Visited: completely finished; Lesson 726 — Detecting Cycles During Topological Sort
Visited set/array: You must track which vertices you've seen to avoid cycles—this always takes O(V) space.; Lesson 698 — BFS Time and Space Complexity
Visiting: currently in the recursive call stack; Lesson 726 — Detecting Cycles During Topological Sort
Visiting a new page: Add it to the back stack and clear the forward stack (because you took a new path); Lesson 372 — Browser History Navigation
Visitor: to add operations without modifying expression classes.; Lesson 2300 — Interpreter Pattern
Visualization: You can't plot 100-dimensional data, but you can plot 2D or 3D projections; Lesson 2790 — Dimensionality Reduction Concepts
void function: (sometimes called a *procedure*) performs an action—like printing text, modifying data, or updating a display—but doesn't give anything back to the code that called it.; Lesson 190 — Void Functions Lesson 201 — Void Functions and Side Effects
Volatile variables: A write to a `volatile` field happens-before every subsequent read of that field; Lesson 2564 — Happens-Before Relationship
Voltage fluctuations: Power supply variations affect timing; Lesson 2626 — Clock Skew and Clock Drift
vulnerable: to well-funded adversaries with modern computing power; Lesson 2410 — RSA Security and Key Sizes Lesson 2501 — Cookie-Based Authentication
Vulnerable stored procedure example: Lesson 2482 — Stored Procedures and SQL Injection

W

W (write quorum): How many replicas must acknowledge a write before it's considered successful; Lesson 2620 — Quorum-Based Consistency
wait: (creating a stall); Lesson 1160 — Introduction to Pipeline Hazards Lesson 1292 — Semaphore Definition and Purpose Lesson 1304 — Condition Variable Basics Lesson 1307 — Condition Variables with Mutexes Lesson 2621 — Consistency vs Availability Tradeoffs
Wait for log commit: Ensure the log entry is safely on disk (the write completes); Lesson 1407 — Write-Ahead Logging and Recovery
Wait Operation: (also called **P**, from Dutch "proberen" = to test, or **down**):; Lesson 1294 — Wait (P) and Signal (V) Operations
wait-free: approaches rely on special atomic operations provided by hardware.; Lesson 1291 — Lock-Free vs Wait-Free Alternatives Lesson 2575 — Lock-Free vs Wait-Free Guarantees
Wait/P: Try to grab a ticket.; Lesson 1294 — Wait (P) and Signal (V) Operations
Waiting: (or **Blocked**) state.; Lesson 1219 — Process States: Running and Waiting Lesson 1221 — Process State Transitions
Waiting → Ready: Lesson 1221 — Process State Transitions
waiting time: the total amount of time a process spends sitting in the ready queue before it gets to run on the CPU.; Lesson 1247 — Waiting Time Lesson 1249 — Scheduling Criteria Trade-offs Lesson 1261 — Comparing Scheduling Algorithm Performance
Walk the page table: The MMU (or OS) traverses the page table structure in main memory to find the correct translation; Lesson 1363 — TLB Miss Handling
Walk to the end: by following `next` pointers until you find a node whose `next` is `NULL` (that's the current tail); Lesson 329 — Inserting at the Tail
Walk upward: Starting from the parent of the deleted node, move toward the root; Lesson 541 — AVL Deletion Overview
Warnings: Alert maintainers about gotchas or performance implications; Lesson 2312 — Comments: When and How to Use Them
Wasted bandwidth: If your program has poor spatial locality (jumping around memory randomly), you're fetching lots of data you'll never use.; Lesson 1146 — Impact of Block Size on Performance
Wasted silicon: Fast stages contain hardware that's underutilized; Lesson 1155 — Balancing Pipeline Stages
Wasted space: – Fragmentation leaves unusable gaps; Lesson 1338 — Motivation for Virtual Memory
Water jug problems: States are (jugA, jugB) fill levels; Lesson 705 — BFS with State Space Representation
Weak second factor: Email is often protected by.; Lesson 2521 — SMS and Email-Based MFA
Weaker consistency: If `R + W ≤ N`, you get eventual consistency with better availability; Lesson 2620 — Quorum-Based Consistency
Weakly Not Taken: (01); Lesson 1179 — Two-Bit Saturating Counter Predictor
Weakly Taken: (10); Lesson 1179 — Two-Bit Saturating Counter Predictor
Wear leveling: matters more — spreading writes evenly across memory cells to prevent premature failure; Lesson 1429 — Disk Scheduling in Modern Systems
Web crawlers: Discovering pages level by level from a starting URL; Lesson 694 — BFS Overview and Applications
Web search engines: Need to index billions of pages—use suffix trees or other advanced structures beyond basic pattern matching.; Lesson 840 — String Searching Applications and Tradeoffs
Web vulnerability scanners: like OWASP ZAP and Burp Suite automatically inject XSS payloads and detect successful execution by monitoring responses.; Lesson 2463 — Testing and Detecting XSS Vulnerabilities
WebRTC: (Web Real-Time Communication) uses UDP with selective reliability:; Lesson 1501 — Hybrid Approaches and Custom Protocols
weight: that represents some meaningful quantity.; Lesson 659 — Weighted vs Unweighted Graphs Lesson 2817 — The Linear Model Equation Lesson 2858 — AdaBoost Algorithm
Weight by size: Multiply each child's entropy by the fraction of samples it contains; Lesson 2843 — Information Gain
Weight formula: `weight = 1 / distance` (or `1 / distance²` for steeper decay); Lesson 2866 — KNN Classification: Voting Mechanisms
Weighted A: * modifies this to:; Lesson 1010 — Weighted A* and Suboptimality Lesson 2760 — Weighted A* and Speed-Accuracy Tradeoffs
Weighted adjacency list: Space-efficient for sparse graphs, supports easy iteration over actual edges.; Lesson 677 — Weighted Graph Representations
Weighted adjacency matrix: Fast weight lookups for dense graphs, but wastes space storing many `∞` values.; Lesson 677 — Weighted Graph Representations
Weighted graph: The same map, but now each flight edge shows the distance in miles, ticket price, or flight duration.; Lesson 659 — Weighted vs Unweighted Graphs Lesson 669 — Adjacency Matrix: Structure and Memory Lesson 677 — Weighted Graph Representations Lesson 685 — Weighted and Unweighted Graphs
weighted graphs: come in.; Lesson 659 — Weighted vs Unweighted Graphs Lesson 685 — Weighted and Unweighted Graphs
Weights: represent travel time, distance, or fuel consumption; Lesson 979 — Practical Applications of Dijkstra's Algorithm Lesson 2816 — What is Linear Regression?
Well-defined schemas: that benefit from normalization; Lesson 1717 — NoSQL vs SQL: Complementary Approaches
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
Well-Ordering Principle (WOP): states that every non-empty set of natural numbers contains a **least element**.; Lesson 96 — Well-Ordering Principle
What: the function accomplishes; Lesson 192 — Function Documentation Lesson 1562 — Database Connection and Basic Structure Lesson 2112 — What is Imperative Programming?Lesson 2173 — Committing Changes Lesson 2175 — Viewing Commit History Lesson 2321 — Rename Variable/Method: Improving Semantic Clarity Lesson 2342 — Preparing Code for Review
What can we deliver: defining the sprint goal and selecting items; Lesson 2379 — Sprint Planning
What data to use: (which registers or memory addresses); Lesson 1085 — Instruction Formats and Opcodes
What didn't go well: Surface pain points, blockers, and frustrations without blame; Lesson 2382 — Sprint Retrospective
What happens: Lesson 176 — The While Loop Lesson 1226 — Orphan and Zombie Processes
What operation: to perform (add, subtract, multiply, divide); Lesson 1096 — Arithmetic Instructions: ADD, SUB, MUL, DIV
What operation to perform: (add, subtract, load, jump, etc.; Lesson 1085 — Instruction Formats and Opcodes
What parameters: it needs (and what they represent); Lesson 192 — Function Documentation
What Remains Open: Lesson 1897 — Complexity Class Hierarchy
What to pass in: How many parameters, what types; Lesson 206 — Function Signatures and Contracts
What value: it returns (if any); Lesson 192 — Function Documentation
What went well: Celebrate successes and identify practices to continue; Lesson 2382 — Sprint Retrospective
What will we improve: Select 1-3 actionable improvements to implement next sprint; Lesson 2382 — Sprint Retrospective
What you'll get back: The return type; Lesson 206 — Function Signatures and Contracts
What's Actually Proven: Lesson 1897 — Complexity Class Hierarchy
What's the cost structure: Are false positives and false negatives equally bad?; Lesson 2804 — Performance Metrics Selection
when: should it stop and decide which process gets the processor?; Lesson 1244 — Scheduling Decision Points Lesson 1997 — Static vs Dynamic Typing Overview Lesson 2175 — Viewing Commit History
When a partition occurs: , do you sacrifice Consistency (respond with potentially stale data) or Availability (stop responding until the partition heals)?; Lesson 2603 — Partition Tolerance Explained
When awakened, recheck: the condition (the while loop does this); Lesson 1306 — The Wait-Signal Pattern
When branch is taken: Counter increments (saturates at 11); Lesson 1179 — Two-Bit Saturating Counter Predictor
When DFS completes: , all marked vertices form one complete connected component; Lesson 730 — Component Finding with DFS
When to embed: Lesson 1724 — Embedding vs Referencing
When to reference: Lesson 1724 — Embedding vs Referencing
When to use: Small graphs, educational purposes, integer capacities only; Lesson 1045 — Maximum Flow Algorithm Comparison
When to use it: Almost never in new systems!; Lesson 2538 — OAuth 2.0 Grant Types: Client Credentials and Resource Owner Password
When to use which: LSD works well for fixed-length keys and is easier to implement.; Lesson 793 — Radix Sort: LSD vs MSD
When UDP's speed wins: Live video streaming, online gaming, DNS queries, VoIP calls—scenarios where old data becomes worthless (a dropped video frame is history), or where the application can handle occasional loss better than TCP's retransmission delays.; Lesson 1497 — Reliability vs Speed Tradeoffs
When you see '(': Push it onto the stack (recording that we need a matching close); Lesson 1834 — PDAs for Balanced Parentheses
When you see ')': Pop from the stack (matching it with the most recent open); Lesson 1834 — PDAs for Balanced Parentheses
Where: Lesson 1140 — Average Memory Access Time (AMAT)Lesson 1562 — Database Connection and Basic Structure Lesson 1571 — UPDATE Statement for Modifying Data Lesson 1597 — HAVING Clause for Filtering Groups Lesson 1598 — WHERE vs HAVING Lesson 2124 — Access Modifiers and Visibility
Where the operands are: (which registers or memory locations); Lesson 1096 — Arithmetic Instructions: ADD, SUB, MUL, DIV
Where we are: (current state); Lesson 2727 — State Space Definition and Components
Where we can go: (successor states); Lesson 2727 — State Space Definition and Components
while loop: , it jumps back to check the loop condition; Lesson 183 — The Continue Statement Lesson 1310 — Producer-Consumer with Condition Variables
White: Not yet visited; *candidates for collection*; Lesson 2099 — Tri-Color Marking Lesson 2102 — Write Barriers
White box: excels at:; Lesson 2218 — Black Box vs White Box Testing
White box testing: (also called glass box or clear box testing) is the opposite.; Lesson 2218 — Black Box vs White Box Testing
Whitelist allowed files: rather than trying to blacklist dangerous patterns; Lesson 2489 — Path Traversal and File Inclusion
Whitespace: `[ \t\n]+`; Lesson 1941 — Lexical Specification with Regular Expressions Lesson 1947 — Error Detection and Recovery in Lexing
Why: A CFG's memory is its stack of nonterminals during derivation.; Lesson 1827 — Limitations of Context-Free Grammars Lesson 2173 — Committing Changes Lesson 2321 — Rename Variable/Method: Improving Semantic Clarity Lesson 2342 — Preparing Code for Review Lesson 2632 — Vector Clock Operations
Why "Product": Lesson 1987 — Composite Types: Products
Why does this work: The median-of-medians is guaranteed to be "good enough"—at least 30% of elements will be smaller and 30% larger.; Lesson 825 — Median of Medians: Deterministic Selection
Why heapsort is unstable: During the heapify-down operations and extract-max phase, elements are moved based solely on their values, not their original positions.; Lesson 606 — Heapsort Space Complexity and Stability
Why it happens: Lesson 1118 — Principle of Locality
Why it matters: Zombies consume process table entries.; Lesson 1226 — Orphan and Zombie Processes Lesson 1755 — Graph Database Limitations and Tradeoffs Lesson 2233 — Unit Testing Best Practices
Why it works: If `fast` moves twice as quickly and they start together, by the time `fast` reaches the last node (or falls off the end), `slow` has covered exactly half the distance.; Lesson 337 — Finding the Middle Node Lesson 1870 — Examples of Decidable Problems Lesson 2759 — Combining Heuristics: Max and Sum Lesson 2830 — Cross-Entropy Loss Function
Why it's best: Only one zero, and regular binary addition works naturally with negative numbers—no special cases needed!; Lesson 10 — Signed Integer Representation
Why it's discouraged: The client sees the user's actual password, defeating OAuth's primary security benefit of keeping credentials isolated.; Lesson 2538 — OAuth 2.0 Grant Types: Client Credentials and Resource Owner Password
Why it's faster: You compute each state only once during the divide-and-conquer recursion, and each split computation touches only a subset of states.; Lesson 959 — Divide and Conquer Optimization
Why O(1): You only need a constant amount of extra memory for variables like loop counters and temporary swap storage.; Lesson 606 — Heapsort Space Complexity and Stability
Why separate metrics: Integer-heavy workloads (databases, web servers) care about MIPS.; Lesson 1190 — MIPS and FLOPS Metrics
Why they excel: Balanced structure + wide nodes = minimal disk accesses + guaranteed performance even with billions of records.; Lesson 567 — B-Tree Performance and Applications
Why this prevents deadlock: If thread A acquires L1 and thread B also needs L1, thread B must *wait* for A to release it.; Lesson 1290 — Lock Ordering and Deadlock Prevention
Why this works: By processing nodes bottom-up, when we heapify-down at position `i`, both child subtrees are already valid heaps.; Lesson 596 — Build Heap: Bottom-Up Construction Lesson 1819 — CFGs for Arithmetic Expressions
Why work backward: By processing from bottom to top, you ensure that when you heapify a node, its subtrees are already valid heaps.; Lesson 602 — Building a Max Heap for Sorting
Why, not what: Explain *why* a non-obvious decision was made, not what the code does; Lesson 2312 — Comments: When and How to Use Them
wide rows: single rows with thousands of columns.; Lesson 1742 — Schema Design in Column-Family Stores Lesson 1744 — Apache Cassandra: Architecture and Use Cases
Wider integers: = more range but consume more:; Lesson 1062 — Integer Width and Range Tradeoffs
Win: +1 (or +∞); Lesson 2767 — Terminal States and Utility Functions
Window Size: (16 bits): Flow control—how many bytes the receiver can accept; Lesson 1472 — TCP Segment Structure Lesson 1477 — TCP Flow Control: Sliding Window Lesson 1485 — TCP Performance Considerations
Windows: `C:\Users\Alice\Documents\report.; Lesson 1390 — File Paths: Absolute vs Relative Lesson 2169 — Installing and Configuring Git
Windows (NTFS): uses a Master File Table (MFT) entry; Lesson 1397 — File Control Blocks and Inodes
Windows NT: (and its descendants: Windows 2000, XP, Vista, 7, 10, 11) is the classic hybrid kernel.; Lesson 1197 — Hybrid Kernel Designs
Wireless: enables mobility but trades some reliability and security.; Lesson 1442 — Transmission Media Types
With 3 frames (FIFO): 9 page faults; Lesson 1369 — Belady's Anomaly
With 4 frames (FIFO): 10 page faults; Lesson 1369 — Belady's Anomaly
With accumulator: (builds result going down):; Lesson 871 — Accumulator Pattern in Recursion
With adjacency list: You iterate through a pre-built list of neighbors (fast, proportional to actual edges); Lesson 697 — BFS with Adjacency Matrix
With adjacency matrix: You scan the entire row for that vertex, checking each column to see if `matrix[vertex][col] !; Lesson 697 — BFS with Adjacency Matrix
With index on User.email: Uses the index to find the node instantly (O(log n) or O(1)); Lesson 1753 — Graph Indexes and Performance
With min-heap priority queue: Extract-min is O(log V), and you perform O(E) edge relaxations → O((V + E) log V) total time; Lesson 613 — Dijkstra's Algorithm with Priority Queue
With parent: Makes traversing upward easier and simplifies certain algorithms (like deletion), but adds complexity and memory overhead.; Lesson 497 — BST Node Structure
With parent pointers: add another 4-8 bytes per node; Lesson 525 — Space Complexity of BSTs
With values immediately: Lesson 233 — Array Declaration and Initialization
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
Without accumulator: (builds result on return):; Lesson 871 — Accumulator Pattern in Recursion
Without index: Scans all User nodes checking each email property (O(n)); Lesson 1753 — Graph Indexes and Performance
Without parent: Simpler, uses less memory.; Lesson 497 — BST Node Structure
Without priority queue: Each iteration scans O(V) vertices → O(V²) total time; Lesson 613 — Dijkstra's Algorithm with Priority Queue
Word is completely unique: (e.; Lesson 624 — Trie Deletion: Removing Words
Work: on it actively—frequent small commits are better than rare large ones; Lesson 2193 — Branch Management Best Practices
Work per level: At each recursion level, every element gets examined once during partitioning.; Lesson 768 — Best-Case Analysis: Balanced Partitions
Work-stealing schedulers: in parallel computing use deques per thread—workers take tasks from their own end while idle threads "steal" from the opposite end, minimizing contention.; Lesson 404 — Deque Applications and Use Cases
Workflow Bypass: A password reset that sends a token via email, but doesn't verify the token belongs to the requesting user, allowing account takeover.; Lesson 2493 — Business Logic Vulnerabilities
Working Directory: where you actively edit files; Lesson 2171 — The Three States of Git
working set: is the collection of memory locations your program accesses frequently during a particular time window.; Lesson 1143 — Types of Cache Misses: Capacity Lesson 1350 — Virtual Memory Performance Considerations Lesson 1375 — Working Set Model
Working software: over comprehensive documentation; Lesson 2361 — The Agile Manifesto
workload patterns: .; Lesson 2574 — Performance Characteristics of Lock-Free Algorithms Lesson 2587 — Performance Trade- offs and Selection
Worst case: O(n) — all keys hash to the same bucket, creating one long linked list; Lesson 421 — Separate Chaining: Analysis Lesson 592 — Extract Time Complexity Lesson 674 — Adjacency List: Operations and Complexity Lesson 838 — Boyer-Moore: Combined Algorithm
Worst case (skewed): O(n) stack space; Lesson 525 — Space Complexity of BSTs
Worst case gets worse: If you insert the same value repeatedly, you create a long chain in one direction (like a linked list), degrading search/insertion from O(log n) to O(n); Lesson 528 — BST with Duplicate Keys
Worst Case: O(n²): Lesson 748 — Insertion Sort: Analysis
Worst-Case: The person is in the last seat, or not in the room at all.; Lesson 272 — Best-Case, Worst-Case, and Average-Case Lesson 300 — Best-Case, Worst-Case, and Average- Case Analysis Lesson 568 — Splay Trees: Self-Adjusting BSTs Lesson 781 — Heapsort Time Complexity Analysis
Worst-case space: O(n); Lesson 773 — Space Complexity and Tail Recursion
Worst-Case Time Complexity: O(n²): Lesson 824 — QuickSelect Analysis and Performance
Worst-case total: 1 + max(2, 1) + 1 = **4 operations**; Lesson 277 — Analyzing Conditional Statements
Wrapping: a plain value into the context; Lesson 2143 — Monads and Effect Management
Write: the new value back to memory; Lesson 1271 — Demonstrating Race Conditions with Shared Counters
Write (w): Modify file contents or create/delete files in a directory; Lesson 1392 — File Permissions and Access Control
Write amplification: becomes a concern — internal operations that multiply the actual data written; Lesson 1429 — Disk Scheduling in Modern Systems
Write bit: Can the process write to this page?; Lesson 1348 — Memory Protection with Virtual Memory
Write drivers: to exercise these clusters as if higher-level code were calling them; Lesson 2239 — Bottom-Up Integration Testing
Write intent to journal: Before modifying the file system, write a description of the planned changes to the journal (e.; Lesson 1406 — File System Consistency and Journaling
Write locks: (exclusive): Only one thread can hold the write lock, and *no readers can hold read locks at the same time*.; Lesson 2563 — Read-Write Locks
Write pointer: marks where the next unique box should go; Lesson 255 — Removing Duplicates from Sorted Arrays
write policies: .; Lesson 1122 — Write-Through vs Write-Back Policies Lesson 1409 — Buffer Cache and Write Policies
Write ports: Allow storing results back into a register while reads happen in parallel.; Lesson 1080 — Register File Architecture
Write productions: Encode each pattern as a rule; Lesson 1818 — Designing CFGs for Simple Languages
Write quorum (W): Must get acknowledgment from W nodes; Lesson 2656 — Quorums and Majority Voting
Write requests: go exclusively to the leader; Lesson 2639 — Leader-Based Replication
Write-After-Read (WAR): hazard happens when a later instruction wants to write to a register that an earlier instruction still needs to read from.; Lesson 1166 — Data Hazards: Write-After-Read (WAR)
Write-After-Write (WAW): hazard happens when two instructions in the pipeline both write to the same destination register, and due to pipeline overlap, they might complete out of order.; Lesson 1167 — Data Hazards: Write-After-Write (WAW)
Write-Ahead Logging (WAL): follows a simple but powerful rule: **always write what you're *about* to do to a log *before* doing it**.; Lesson 1407 — Write-Ahead Logging and Recovery Lesson 1657 — Transaction Logs and Write-Ahead Logging
Write-Back: typically takes 1 cycle to update a register; Lesson 1089 — Instruction Cycle Timing Lesson 1122 — Write-Through vs Write-Back Policies Lesson 1148 — Introduction to Instruction Pipelining Lesson 1409 — Buffer Cache and Write Policies
Write-Back (WB): Lesson 1149 — The Classic Five-Stage Pipeline
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 Lesson 1169 — Data Forwarding (Bypassing)
Write-heavy workloads: (IoT sensor data, time-series metrics); Lesson 1744 — Apache Cassandra: Architecture and Use Cases
write-through: , every write to cache is *immediately* propagated to main memory.; Lesson 1122 — Write-Through vs Write-Back Policies Lesson 1409 — Buffer Cache and Write Policies
Writer logic: Lesson 1299 — Readers-Writers Problem with Semaphores Lesson 1311 — Reader-Writer Problem with CVs
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 Lesson 1299 — Readers-Writers Problem with Semaphores
writes: (updates a record), no one else should be reading or writing at the same time.; Lesson 1299 — Readers-Writers Problem with Semaphores Lesson 2585 — Copy-On-Write Collections Lesson 2693 — Secondary Indexes in Partitioned Systems
Writes succeed immediately: on one or more nodes without waiting for all replicas; Lesson 2614 — Eventual Consistency Overview
wrong: .; Lesson 1172 — Control Hazards: Branch Impact Lesson 1175 — Introduction to Branch Prediction Lesson 1184 — Branch Prediction Performance Impact Lesson 1774 — Precedence and Parentheses in Regular Expressions
Wrong recursive case: Follow the math/logic step-by-step.; Lesson 230 — Debugging Recursive Functions

X

X → Y: , read as "X functionally determines Y" or "Y depends on X.; Lesson 1622 — Functional Dependency Notation and Terminology
X.509: defines the format for digital certificates—documents that bind a public key to an identity (person, organization, server).; Lesson 2440 — Digital Signature Standards and Formats
X²: or **2X + 3**?; Lesson 131 — Expected Value of Functions
XOR: (`XOR reg1, reg2`): Sets each bit to 1 only if the bits *differ*.; Lesson 1097 — Logical and Bitwise Instructions
XOR (`^`): Returns 1 if bits are *different*.; Lesson 163 — Bitwise Operators
XOR gate: short for "eXclusive OR" — is pickier: it outputs TRUE *only when exactly one input is TRUE*.; Lesson 17 — The XOR Gate (Exclusive OR)
XSS: Malicious JavaScript injected via form inputs, URL parameters, or stored data; Lesson 2466 — CSRF vs XSS Lesson 2490 — Insecure Deserialization
XSS (Cross-Site Scripting): exploits a user's trust in a website.; Lesson 2466 — CSRF vs XSS
XSS targets: Input validation weaknesses, improper output encoding, lack of sanitization; Lesson 2466 — CSRF vs XSS

Y

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
YAML: are Domain-Specific Languages (DSLs) designed specifically for configuration.; Lesson 2152 — Configuration Files and DSLs
Yes: Lesson 48 — Existential Quantifier (∃)Lesson 78 — Function Properties: Surjective (Onto)Lesson 443 — Caching and Memoization Lesson 563 — B-Tree Deletion: Leaf Node Cases Lesson 1624 — Full vs Partial Functional Dependencies
you: need to force a conversion using type casting (which you learned about in Type Casting Fundamentals).; Lesson 162 — Type Conversion in Expressions Lesson 2615 — Read-Your-Writes Consistency
You address feedback: by pushing additional commits to the same branch; Lesson 2196 — Pull Requests and Code Review
You can predict: how much memory it truly needs right now; Lesson 1375 — Working Set Model
You can prevent thrashing: if the system can't hold the entire working set in physical memory, page faults skyrocket; Lesson 1375 — Working Set Model
You fundamentally cannot know: without waiting longer, but how long is long enough?; Lesson 2594 — Impossibility of Perfect Failure Detection
You present your certificate: (containing your public key and identity); Lesson 2502 — Certificate-Based Authentication
You sign the challenge: with your private key; Lesson 2502 — Certificate-Based Authentication
Young generation (nursery): Newly allocated objects live here; Lesson 2098 — Generational Garbage Collection
Your greedy choice: reduces the problem to a smaller subproblem; Lesson 880 — Optimal Substructure in Greedy Problems
Your loss function: Classification typically uses cross-entropy or hinge loss; regression uses mean squared error or mean absolute error; Lesson 2781 — Classification vs Regression Problems
Your transaction: Lesson 1671 — Phantom Reads Problem

Z

Zero Connection Setup Time: Lesson 1493 — UDP Performance Characteristics
Zero demand: (`d(v) = 0`): the node is just a transit point; Lesson 1054 — Circulation with Demands
Zero flag (Z): Set if the result was zero; Lesson 1077 — Accumulator and Status Registers
Zero Flag (ZF): is set to 1.; Lesson 1098 — Comparison and Test Instructions
Zero function: Always returns 0; Lesson 1863 — Alternative Models: Recursive Functions
zero-based indexing: , meaning the first element is at position 0, the second at position 1, and so on.; Lesson 234 — Array Indexing and Access Lesson 243 — Indexing and Accessing 2D Arrays Lesson 261 — Character Access and Indexing
Zig (terminal case): This happens when your target node is one step away from the root—it's a direct child of the root.; Lesson 570 — Zig, Zig-Zig, and Zig-Zag Cases
Zig-Zag (triangle case): Your target node zig-zags relative to its ancestors—for example, it's a left child of a right child, or vice versa.; Lesson 570 — Zig, Zig-Zig, and Zig-Zag Cases
Zig-Zig (line case): Your target node, its parent, and its grandparent form a straight line—all three are either left children or all right children.; Lesson 570 — Zig, Zig-Zig, and Zig-Zag Cases
Zig-zig rotations: (the most common case) reduce tree depth dramatically.; Lesson 574 — Amortized Analysis of Splay Trees
zombie process: (also called a "defunct" process) is the opposite problem: a child process has *finished executing* and called `exit()`, but its parent hasn't yet called `wait()` to read its exit status.; Lesson 1226 — Orphan and Zombie Processes Lesson 1227 — Process Waiting: wait() and waitpid()
Zombie state (temporary): Until the parent process acknowledges the termination (using system calls we've covered), the terminated process exists as a "zombie"—its PCB lingers even though execution has stopped.; Lesson 1220 — Process States: Terminated
ZooKeeper: Manages coordination and failover; Lesson 1745 — HBase and Other Column-Family Systems Lesson 2605 — CP Systems: Consistency and Partition Tolerance