Tech Glossary

Every core term we've explained, A to Z — 782 plain-English definitions, each linking to a full explainer with examples and context.

#

: :has() is CSS's relational pseudo-class — it lets a selector match an element based on what's inside or after it, finally enabling a parent selector.

K

10-K Filing: A 10-K is a public company's audited annual report to regulators, covering financials, risk factors, and management discussion in far more detail than a press release.
401(k): A 401(k) is an employer-sponsored retirement account with pre-tax or Roth contributions, tax-advantaged growth, and often a matching contribution.
Kimi: Kimi is Moonshot AI's assistant and open-weight model family, known for huge context and agentic coding. Here's what Kimi is and what the K2 models can do.
KMP Algorithm: The Knuth-Morris-Pratt algorithm finds a pattern inside a text in linear time by never re-examining characters it has already matched.
Knowledge Graph: A knowledge graph stores facts as entities and labeled relationships instead of rows or documents, letting queries traverse connections directly.
Kubernetes: Kubernetes (K8s) is the open-source system for deploying, scaling, and managing containers. A plain-English definition, core concepts, and when to use it.
Kubernetes Admission Controllers: Admission controllers intercept requests to the Kubernetes API server after authentication, validating or mutating objects before they're persisted.
Kubernetes CRDs: A Kubernetes CRD (CustomResourceDefinition) extends the API with new resource types, letting the cluster manage custom objects like native ones.
Kubernetes DaemonSets Explained: A Kubernetes DaemonSet runs exactly one copy of a pod on every node in the cluster, automatically, for tasks like logging and monitoring agents.
Kubernetes Init Containers Explained: Init containers run to completion before a pod's main containers start, making them the standard way to handle setup steps and startup ordering.
Kubernetes Namespace: A Kubernetes namespace is a virtual cluster partition that scopes names, quotas, and access so teams and environments can share one cluster safely.
Kubernetes Network Policies Explained: Kubernetes NetworkPolicies control which pods can talk to which, at the network layer. Here's how they work and why pods are open by default.
Kubernetes Operator: A Kubernetes operator encodes operational knowledge into software, automating tasks a human admin would otherwise do by hand for a specific application.
Kubernetes PV vs PVC: A Kubernetes PersistentVolume is real storage; a PersistentVolumeClaim is a pod's request for it. How the two connect and why they're separate.
Kubernetes RBAC Explained: Kubernetes RBAC controls who can do what in a cluster using Roles, ClusterRoles, and bindings. How the pieces fit together, with a worked example.
Kubernetes Resource Requests vs Limits: Requests reserve CPU and memory for scheduling; limits cap what a container can use. Getting the two wrong causes throttling or evictions.
Kubernetes Service Types: Kubernetes offers four Service types for exposing pods on the network. How ClusterIP, NodePort, LoadBalancer, and ExternalName each route traffic.
Kubernetes Taints and Tolerations: Taints repel pods from a node; tolerations let specific pods ignore that repulsion. How the two work together to control scheduling.
KV Cache: A KV cache stores past attention keys and values during LLM inference so each new token reuses prior work instead of recomputing it from scratch.

E

1031 Exchange: A 1031 exchange lets an investor defer capital gains tax on real estate by rolling proceeds into a like-kind property instead of cashing out.
Earnout: An earnout is a deal structure where part of an acquisition's price is paid later, contingent on the acquired company hitting agreed targets.
EBITDA: EBITDA strips out interest, taxes, depreciation, and amortization to show core operating profit. How it's calculated, why investors use it, and its limits.
eBPF: eBPF runs sandboxed programs inside the Linux kernel without recompiling it. How it works and why it reshaped observability, networking, and security.
ECC Memory: ECC memory detects and corrects single-bit errors in RAM automatically, using extra parity bits — critical for servers where silent corruption is costly.
Economic Moat: An economic moat is a durable competitive advantage that protects a company's profits from competitors over the long run. The main types, explained.
Edge Computing: Edge computing runs code and stores data near where it's generated instead of in a centralized data center, cutting latency and bandwidth costs.
Edge Functions: Edge functions run application code on servers near the visitor instead of a single origin region, cutting latency for auth, redirects, and personalization.
EDR: EDR continuously monitors laptops and servers for suspicious behavior, catching threats signature-based antivirus misses, and gives responders tools to act.
Efficient Market Hypothesis: The efficient market hypothesis holds that asset prices already reflect available information, making it hard to consistently beat the market by picking stocks.
Envelope Encryption: Envelope encryption encrypts data with a data key, then encrypts that key with a master key held in a KMS. How it works, why clouds use it, and key rotation.
EPS (Earnings Per Share) and How Is It Calculated: EPS divides net income by outstanding shares to show profit per share. How basic and diluted EPS differ, and why EPS alone can mislead.
Equity Dilution: Equity dilution is the reduction in existing shareholders' ownership percentage when a company issues new shares. How it happens and what to watch for.
Escrow: Escrow is a neutral third party that holds money or assets until agreed conditions are met. How it works in real estate, M&A, and startup deals.
ESPP: An ESPP lets employees buy company stock through payroll deductions, often at a discount — here's how the mechanics and the tax treatment work.
ETF: An ETF is a basket of securities that trades on an exchange like a stock. How creation and redemption work, and how ETFs differ from mutual funds.
ETL vs ELT: ETL transforms data before loading it into a warehouse; ELT loads raw data first and transforms it inside the destination. How the two approaches differ.
EUV Lithography: EUV lithography uses 13.5nm-wavelength light to etch the finest features on modern chips. How it works and why it's a chokepoint in chip manufacturing.
Event Sourcing: Event sourcing stores every state change as an immutable event instead of overwriting current state. How it works, and when CQRS pairs with it.
Eventual Consistency in Distributed Systems: Eventual consistency guarantees that replicas converge over time, not instantly. How it differs from strong consistency and when it's acceptable.
Expense Ratio: An expense ratio is the annual percentage of a fund's assets taken out to cover management costs — how it's calculated and why it compounds over decades.
Exponential Backoff and Retry Strategies Explained: Exponential backoff spaces retries further apart after each failure so clients stop hammering a struggling service. How it works, and why it needs jitter.

B

403(b) Plan: A 403(b) is a tax-advantaged retirement plan for public school, nonprofit, and religious-sector employees. How it compares to a 401(k).
83(b) Election: An 83(b) election lets you pay tax on restricted stock at grant instead of at vesting, locking in a low valuation while the risk is high.
B-Tree: A B-tree is a self-balancing tree that keeps data sorted with logarithmic search, insert, and delete time — the structure behind most database indexes.
backdrop-filter: backdrop-filter blurs, darkens, or otherwise adjusts whatever sits behind an element, powering frosted-glass UI without extra markup or JavaScript.
Backpressure: Backpressure is how a slow consumer signals a fast producer to hold off, preventing memory exhaustion in streams, queues, and network protocols.
Backtracking Algorithms Explained: Backtracking solves problems by building candidate solutions incrementally and abandoning any path that can't lead to a valid answer. How it works, with examples.
Bastion Host: A bastion host is a hardened server that acts as the single controlled entry point into a private network, shrinking the attack surface for admins.
Batch vs Real-Time Inference: Batch inference processes large volumes of input on a schedule; real-time inference answers one request as fast as possible. How the two serving modes differ.
Beacon API: The Beacon API lets a page send one last async request as it unloads, without blocking navigation or racing the browser's page teardown.
Beam Search: Beam search keeps the top-k most likely sequences at each decoding step instead of just one, trading compute for better output than greedy decoding.
Beta: Beta measures how much a stock moves relative to the overall market — above 1 means more volatile, below 1 means less. How it's calculated and its limits.
bfcache: The bfcache stores a full, running snapshot of a page in memory so back and forward navigation is instant instead of a fresh load. How it works.
Bid-Ask Spread: The bid-ask spread is the gap between the highest price buyers will pay and the lowest price sellers will accept. What sets its width and why it matters.
Big O Notation: Big O notation describes how an algorithm's time or memory grows as input grows. The common classes, what they mean, and how to reason about them.
BigInt in JavaScript: BigInt is JavaScript's built-in type for whole numbers beyond Number's safe limit. How the syntax works, what it can't do, and when you actually need it.
Binary Search Algorithm Explained: Binary search finds a value in a sorted array in O(log n) time by repeatedly halving the search space. How it works, why it needs sorted input, and common pitfalls.
Binary Search Trees: A binary search tree keeps every left descendant smaller and every right descendant larger than its parent. How lookups, inserts, and balance work.
Biome: Biome is a Rust-based linter and formatter that replaces ESLint and Prettier with one faster tool, one config file, and no plugin ecosystem to manage.
Biometric Authentication Explained: Biometric authentication verifies identity using fingerprints, faces, or other traits — here's how enrollment, matching, and liveness checks work.
Bitmap Index: A bitmap index uses a bit array per distinct value to speed up queries on low-cardinality columns, and combines multiple filters with fast bitwise AND/OR.
Blameless Postmortem: A blameless postmortem examines an incident's causes without assigning fault, so teams surface real fixes instead of hiding mistakes.
Bloom Filter: A Bloom filter is a compact data structure that tests whether an item might be in a set, using far less memory than storing the set itself.
Blue Chip Stock: A blue chip stock is shares in a large, well-established, financially sound company with a long record of stable performance and often a dividend.
Bond: A bond is a loan you make to a government or company in exchange for regular interest and repayment of principal at maturity. How pricing and yield work.
Bond Covenant: A bond covenant is a contractual promise a borrower makes to bondholders — a rule that protects lenders by restricting what the issuer can do.
Bond Duration: Bond duration measures how much a bond's price moves when interest rates change, expressed in years. Higher duration means more interest-rate risk.
Bond Ladder: A bond ladder splits an investment across bonds with staggered maturities, reducing interest-rate risk while keeping cash flowing back at regular intervals.
Book Value: Book value is a company's total assets minus total liabilities — its net worth on the balance sheet. How it's calculated and where it falls short.
Branch Prediction and Out-of-Order Execution Explained: Branch prediction guesses which way an if-statement will go before the CPU knows, and out-of-order execution reorders instructions to keep pipelines full.
Bridge Loan: A bridge loan is short-term financing that covers the gap between an immediate cash need and a longer-term source of funds, at a higher interest rate.
BroadcastChannel API: The BroadcastChannel API lets same-origin tabs, windows, and workers pass messages to each other instantly, with no server round trip or polling.
Buffer Overflow: A buffer overflow happens when a program writes past the end of a fixed-size memory buffer, corrupting adjacent data. How it works and how modern systems defend against it.
Bug Bounty Program: A bug bounty program pays independent researchers for responsibly reporting security vulnerabilities before attackers find and exploit them.
Bulkhead Pattern: The bulkhead pattern isolates resources per dependency so one failing service can't exhaust the pools that healthy services depend on.
Burn Rate and Runway: Burn rate is how fast a startup spends cash; runway is how long its cash lasts at that rate. How the two numbers are calculated and why they matter.
Business Email Compromise Attack: Business email compromise (BEC) is a scam where attackers impersonate an executive or vendor by email to trick employees into wiring money or data.
Byzantine Fault Tolerance Explained: Byzantine fault tolerance lets a distributed system keep working correctly even when some nodes fail arbitrarily or actively lie, not just crash cleanly.

A

409A Valuation: A 409A valuation sets the fair market value of a private company's common stock, setting the strike price for employee stock options. How it works.
AbortController: AbortController lets JavaScript cancel an in-flight fetch or async task on demand, preventing stale responses from overwriting newer state.
Abstract Syntax Tree (AST): An abstract syntax tree represents source code's grammatical structure as nodes a compiler, linter, or formatter can walk and transform programmatically.
Accredited Investor: An accredited investor meets income, net-worth, or professional thresholds that unlock access to private placements, hedge funds, and venture deals.
ACID Transactions: ACID — atomicity, consistency, isolation, durability — defines the guarantees a database transaction makes so concurrent, failure-prone operations stay correct.
AI Agent: An AI agent is an LLM-powered system that pursues a goal across steps — planning, calling tools, observing results, and repeating until the job is done.
AI Agent Sandboxing: Agent sandboxing isolates the code an AI agent executes from the host system, limiting what a compromised or misbehaving agent can actually reach.
AI Alignment: AI alignment is the effort to make an AI system's behavior match human intent and values, not just its training objective. Why it's harder than it sounds.
AI Guardrails: AI guardrails are checks that filter or steer an LLM's inputs and outputs to block unsafe, off-topic, or policy-violating content. How they work in practice.
AI Model Card: A model card is a standardized document describing an AI model's intended use, training data, evaluation results, and limitations before deployment.
AI Red Teaming: AI red teaming is the practice of deliberately attacking a model or AI system to find failures before real adversaries do. Here's how it works.
Alpha in Investing: Alpha measures return in excess of what a portfolio's risk level predicts; beta measures that risk itself. Together they separate skill from market exposure.
Amdahl's Law: Amdahl's Law says a program's speedup from parallelizing is capped by the fraction that must stay sequential — no matter how many cores you add.
Amortized Analysis: Amortized analysis measures the average cost of an operation over a sequence of calls, not its worst case. How dynamic array resizing gets O(1) amortized inserts.
Annuity: An annuity is a contract with an insurer that converts a lump sum into a stream of payments, often for life. How the main types differ.
Apache Kafka: Apache Kafka is a distributed event-streaming platform built on a durable, append-only log. How topics, partitions, and consumers power real-time pipelines.
API: An API is a defined contract that lets one piece of software talk to another. Learn what APIs are, how they work, and why modern software runs on them.
API Versioning Strategies Explained: URI paths, custom headers, and content negotiation are the three common ways to version an API. Tradeoffs of each, and how to avoid breaking clients.
Arbitrage: Arbitrage is profiting from a price gap for the same asset in different markets, buying low and selling high nearly simultaneously with minimal risk.
ASIC: An ASIC is a chip custom-built for one task, trading flexibility for speed and power efficiency. How ASICs differ from GPUs and FPGAs, and when to use one.
Asset Allocation: Asset allocation is how a portfolio is split across stocks, bonds, and cash — the mix that drives most of a portfolio's long-run risk and return.
Astro Content Collections: Astro content collections give markdown and MDX files a type-safe schema and a query API, catching bad frontmatter at build time instead of runtime.
Astro Islands Architecture Explained: Astro's islands architecture ships static HTML by default and hydrates only the interactive components that need JavaScript. Here's how it works.
Availability Zone: An availability zone is an isolated data center (or cluster of them) within a cloud region, designed so one zone's failure doesn't take down another.

P

529 Plan: A 529 plan is a tax-advantaged investment account for education costs — contributions grow tax-free and qualified withdrawals aren't taxed at all.
P vs NP: P is problems solvable quickly; NP is problems whose solutions are quickly checkable. Whether P equals NP is one of computing's open questions.
P/E Ratio: The P/E ratio divides a stock's price by its earnings per share — a quick gauge of how much investors pay per dollar of profit. How to read it and its limits.
PACELC Theorem: PACELC extends CAP theorem by adding a tradeoff that applies even when there's no partition: latency versus consistency. Here's how it works.
Padding Oracle Attack: A padding oracle attack exploits error messages during decryption to recover plaintext byte by byte, without ever breaking the cipher itself.
Page Visibility API Explained: The Page Visibility API tells JavaScript when a tab is hidden or visible, so you can pause polling, animations, and timers the user can't see.
Passive Event Listeners: Passive event listeners tell the browser a handler won't call preventDefault(), so scrolling starts at once. How { passive: true } works and when to use it.
Path Traversal Attack: A path traversal attack manipulates file paths like ../../etc/passwd to read files outside a web app's intended directory. How it works and how to stop it.
PCI DSS: PCI DSS is the security standard that governs how businesses store, process, and transmit card data. Its 12 requirements and who has to comply.
PCIe: PCIe (PCI Express) is the high-speed serial bus connecting GPUs, SSDs, and network cards to a CPU. How lanes, generations, and bandwidth work.
PEG Ratio: The PEG ratio divides a stock's P/E by its expected earnings growth rate, giving a quick read on whether a high multiple is actually justified.
PgBouncer and Postgres Pooling Modes Explained: PgBouncer sits between clients and Postgres, reusing a small pool of real connections. Session, transaction, and statement modes trade features for scale.
PKI: PKI is the system of keys, certificates, and certificate authorities that lets strangers trust each other's public keys online. How it actually works.
Point-in-Time Recovery: Point-in-time recovery restores a database to any moment between backups by replaying transaction logs, undoing bad deploys and accidental deletes.
Poison Pill: A poison pill lets shareholders buy discounted shares once an acquirer crosses an ownership threshold, diluting that stake to deter hostile takeovers.
Polyfill in JavaScript: A polyfill is code that implements a missing browser feature so older environments behave as if they supported it natively.
Popover API: The Popover API gives HTML a built-in popover element with the popover attribute — top-layer rendering, light-dismiss, and no JavaScript required.
Portfolio Rebalancing: Portfolio rebalancing sells winners and buys laggards to restore target allocations, keeping risk in check as markets move holdings out of line.
Positional Encoding in Transformers: Positional encoding gives transformers word order by adding position signals to token embeddings, since self-attention alone is order-blind.
Postgres Logical Replication Explained: Logical replication streams row-level changes between Postgres databases instead of copying raw disk blocks — enabling selective sync, upgrades, and CDC.
PostgreSQL: PostgreSQL is a powerful, open-source relational database known for reliability and extensibility. Learn how Postgres works and why developers love it.
PostgreSQL Full-Text Search: PostgreSQL's built-in full-text search uses tsvector documents and tsquery queries matched with @@, indexed with GIN for speed at scale.
PostgreSQL JSONB Explained: JSONB stores JSON in PostgreSQL as a parsed, indexable binary format instead of raw text. How it works, and when to reach for it.
Precision vs Recall: Precision measures how many of a model's positive predictions were correct; recall measures how many actual positives it found. Why you can't max both.
prefers-reduced-motion: The prefers-reduced-motion media query detects a user's OS-level motion setting so CSS animations can be toned down or removed for people who need it.
Price-to-Book Ratio: The price-to-book ratio compares a company's market price to its net asset value on the balance sheet, a classic value-investing screen. How it's calculated, and where it misleads.
Principle of Least Privilege Explained: The principle of least privilege limits every user, service, and process to only the access it needs, cutting the blast radius of a breach.
Privilege Escalation: Privilege escalation is when an attacker gains higher-level access than they were granted — vertically to admin rights, or horizontally to a peer account.
Privileged Access Management (PAM): Privileged access management controls, monitors, and time-limits who can use admin credentials, reducing the blast radius of a breach.
Pro Rata Rights: Pro rata rights let an investor buy enough of a startup's next funding round to keep their ownership percentage from shrinking as new shares are issued.
Producer-Consumer Problem: The producer-consumer problem is a classic concurrency pattern: coordinating producers and consumers around a shared, bounded buffer safely.
Progressive Enhancement: Progressive enhancement builds a working page with HTML first, then layers CSS and JavaScript on top — so a slow network or failed script never breaks the core experience.
Prompt Chaining: Prompt chaining splits a task into a sequence of smaller LLM calls, each one feeding the next, instead of asking one giant prompt to do everything.
Prompt Engineering: Prompt engineering is the practice of structuring instructions to get reliable, accurate output from an LLM. Core techniques and common pitfalls.
Prompt Injection: Prompt injection is when attacker-controlled text hijacks an LLM's instructions instead of its data. How the attack works and what actually mitigates it.
Protocol Buffers: Protocol Buffers (protobuf) are a binary serialization format with strict schemas — smaller and faster to parse than JSON. How it works.
Proxy Statement: A proxy statement (DEF 14A) is the SEC filing that discloses executive pay, board nominees, and shareholder votes ahead of a company's annual meeting.
Pub/Sub Pattern Explained: Publish-subscribe decouples senders from receivers through a message broker, letting services communicate without knowing who's listening.
PWA: A PWA is a website built to behave like a native app — installable, offline-capable, and fast — using standard web technologies, not app-store code.
Python: Python is a high-level, readable general-purpose programming language that dominates data science, AI, and web backends. Here's why it became so popular.

C

Cache Associativity: Cache associativity determines where a memory block can be placed in a CPU cache. How direct-mapped, fully associative, and set-associative caches compare.
Cache Coherence and the MESI Protocol: Cache coherence keeps each CPU core's private cache consistent with the others. The MESI protocol is the classic mechanism that makes it work.
Caching: Caching keeps a copy of expensive data somewhere faster. How cache-aside, write-through, and TTLs work — and why invalidation is the hard part.
Callable Bond: A callable bond lets the issuer repay the principal early, before maturity. It pays a higher yield than a comparable bond to compensate for that risk.
Canary Token: A canary token is a fake credential or file that alerts you the moment it's touched — a trip wire for detecting breaches rather than preventing them.
Cap Table: A cap table is the ledger of who owns what percentage of a company. How it tracks founders, investors, and options, and why it gets messy fast.
CAP Theorem: CAP theorem says a distributed system can't guarantee consistency, availability, and partition tolerance all at once. What the trade-off means in practice.
CAPTCHA: A CAPTCHA is a challenge designed to be easy for humans and hard for automated scripts. How image, text, and invisible CAPTCHAs actually distinguish the two.
Carried Interest: Carried interest is the share of a fund's profits its managers keep, typically 20%, paid only after investors get their capital back. Here's how it works.
Catastrophic Forgetting in AI Fine-Tuning: Catastrophic forgetting is when training a model on new data erases skills it already had. Why it happens during fine-tuning, and how teams work around it.
CDN: A CDN caches your content on servers around the world so users load it from nearby. How CDNs cut latency, protect origins, and power dynamic apps.
Certificate of Deposit (CD): A CD locks up cash for a fixed term in exchange for a fixed interest rate, usually higher than a savings account. How CDs work and their trade-offs.
Certificate Pinning: Certificate pinning hardcodes which certificate or public key an app should trust, blocking attacks that rely on a rogue but validly signed certificate.
Certificate Transparency: Certificate Transparency is a public, tamper-evident log of every TLS certificate issued, letting anyone detect mis-issued or rogue certificates.
Cgroups and Namespaces: Linux namespaces isolate what a process can see; cgroups limit what it can use. Together they're the kernel primitives that make a container a container.
Chain-of-Thought Prompting Explained: Chain-of-thought prompting asks an LLM to reason step by step before answering, improving accuracy on multi-step problems by making its work explicit.
Change Data Capture (CDC): Change data capture streams row-level inserts, updates, and deletes out of a database in real time, powering sync pipelines, caches, and event-driven systems.
Chaos Engineering: Chaos engineering deliberately injects failures into production-like systems to find weaknesses before real outages do. How it works in practice.
Chip Binning: Binning sorts identical die designs by how well each one actually performs after manufacturing, turning natural process variation into a full product lineup.
Chiplet: A chiplet is a small, self-contained die that's packaged together with others to form one chip. How chiplets work and why the industry moved to them.
CI/CD: CI/CD automates building, testing, and shipping code on every change. How continuous integration and continuous delivery/deployment fit together.
CIDR Notation and Subnetting: CIDR notation like 10.0.0.0/24 packs an IP range and its mask into one string. How prefix length maps to host count, and how subnetting splits a network.
Circuit Breaker Pattern in Software: The circuit breaker pattern stops a service from hammering a failing dependency, failing fast instead and giving the downstream system room to recover.
Clawback Provision: A clawback provision lets a company reclaim already-paid compensation or equity when specific conditions, like fraud or a restatement, are triggered.
Clickjacking: Clickjacking tricks a user into clicking something they can't see, hidden inside an invisible iframe. How the attack works and how to stop it.
Clipboard API: The Clipboard API lets web pages read and write the system clipboard asynchronously, replacing the old execCommand copy/paste hacks with a real API.
Clock Gating vs Power Gating Explained: Clock gating and power gating both cut chip energy use by disabling idle circuit blocks, but one stops the clock while the other cuts power entirely.
Clock Speed vs. IPC: Clock speed measures cycles per second; IPC measures work done per cycle. Real CPU performance is the product of both, not either one alone.
Cloud Landing Zone: A cloud landing zone is a pre-configured, secure baseline environment for provisioning new cloud accounts and workloads at scale. How it works.
Clustered vs Non-Clustered Index Explained: A clustered index determines the physical row order on disk; a non-clustered index is a separate lookup structure. How they differ and when to use each.
Code Splitting: Code splitting breaks one large JavaScript bundle into smaller chunks loaded on demand. How bundlers do it, the main strategies, and the trade-offs.
Composite Index in a Database: A composite index spans multiple columns in a fixed order, speeding up queries that filter or sort on that combination. How column order changes everything.
Compound Interest: Compound interest earns returns on both your original principal and previously earned interest, causing growth to accelerate rather than stay flat.
Confidential Computing: Confidential computing uses hardware-isolated enclaves to keep data encrypted even while it's being processed, not just at rest or in transit.
Connection Pooling: Connection pooling reuses a fixed set of open database connections instead of opening a new one per request. How pools work and why they prevent overload.
Consistent Hashing Explained: Consistent hashing maps keys and nodes onto the same ring so adding or removing a server only reshuffles a small fraction of keys, not all of them.
Constitutional AI: Constitutional AI trains language models to critique and revise their own outputs against a written set of principles, reducing reliance on human labels.
Constrained Decoding: Constrained decoding masks invalid tokens at each step so an LLM can only emit output matching a grammar, regex, or JSON Schema. How it works and its limits.
Container Escape: A container escape is when code running inside a container breaks out to access the host system, defeating the isolation containers are meant to provide.
Container Image Scanning: Container image scanning checks a container's layers for known vulnerabilities and secrets before it ships. How it works and where to run it.
Container Query Units: Container query units like cqw and cqi size elements relative to their containing element, not the viewport — here's how and when to use them.
Container Registry, and How Do Image Pulls Work: A container registry stores and distributes container images by content-addressed layers, letting Docker and Kubernetes pull only what's changed.
Content Security Policy (CSP): A Content Security Policy is an HTTP header that restricts what scripts and resources a page can load, blocking most XSS attacks by default.
Context Engineering: Context engineering is the discipline of deciding what an LLM sees at inference time — retrieved documents, tool outputs, memory, and history.
Context Rot in LLMs: Context rot is the drop in an LLM's accuracy and reliability as the amount of text in its context window grows, even when the window technically fits it.
Context Window: An LLM's context window is the maximum text it can consider at once — prompt plus response, measured in tokens. Why it matters and how to work within it.
Continuous Batching in LLM Inference Explained: Continuous batching lets an LLM server add and remove requests from a batch mid-generation, instead of waiting for a fixed group to finish together.
Conventional Commits: Conventional Commits structures commit messages as type(scope): description so tools can auto-generate changelogs and version bumps from git history.
Convertible Bond: A convertible bond pays interest like ordinary debt but lets the holder exchange it for a fixed number of shares — trading some yield for upside if the stock rallies.
Convertible Note: A convertible note is short-term debt that converts to equity at a future funding round — how it works and how it differs from a SAFE.
Copy-on-Write: Copy-on-write shares data until someone modifies it, then copies only what changed. How CoW powers fork(), snapshots, containers, and immutable data.
CORS: CORS lets a server opt in to cross-origin browser requests, relaxing the same-origin policy in a controlled way. Why it exists and how to fix CORS errors.
Cost Basis: Cost basis is what you paid for an investment, adjusted for fees and reinvested dividends — it's the number capital gains tax is calculated from.
Count-Min Sketch: A Count-Min Sketch is a probabilistic data structure that estimates item frequencies in a stream using fixed memory, trading exactness for space.
Covered Call: A covered call is an options strategy where you sell a call against stock you already own, collecting premium in exchange for capping your upside.
Covering Index: A covering index holds every column a query needs, letting the database answer from the index alone without a lookup back to the table.
CPU Cache: L1, L2, and L3 CPU caches sit between the processor and main memory, trading capacity for speed at each level. How the hierarchy actually works.
CPU Instruction Pipelining Explained: Instruction pipelining overlaps a CPU's fetch, decode, and execute stages so multiple instructions are in flight at once. How it works.
CQRS: CQRS separates the code paths that change data from the code paths that read it. How it works, why teams adopt it, and when it's overkill.
CRDT: A CRDT is a data structure that merges concurrent edits from multiple replicas automatically, without coordination or conflicts, using math instead of locks.
Credential Stuffing: Credential stuffing tests stolen username-password pairs against other sites, exploiting reused passwords. How it works and the defenses that actually stop it.
Credit Default Swap: A credit default swap is insurance against a bond issuer defaulting: the buyer pays a premium, the seller pays out if the underlying debt fails.
Credit Rating: A credit rating is a letter-grade opinion on how likely a borrower is to repay debt, set by agencies like S&P, Moody's, and Fitch.
Critical Rendering Path: The critical rendering path is the sequence a browser follows from HTML bytes to painted pixels — DOM, CSSOM, render tree, layout, paint.
Cron Job: A cron job runs a command automatically on a fixed schedule defined by a five-field expression. How cron syntax works and where it's still used today.
CSRF: CSRF tricks a logged-in user's browser into sending an unwanted authenticated request. Cookies, tokens, and SameSite settings are the defense.
CSS: The :focus-within pseudo-class styles a parent element when any descendant has focus — perfect for highlighting a form field's container.
CSS: CSS :target styles the element whose ID matches the URL fragment, enabling tabs, modals, and highlights with zero JavaScript. How it works, with examples.
CSS: The CSS :not() selector excludes elements matching an argument list from a rule, letting you style everything except specific cases without extra classes.
CSS: How ::before and ::after generate content without extra markup, which properties they need, and common patterns like icons and counters.
CSS: :is() and :where() group selector lists into one rule. Same matching logic, different specificity — here's when to reach for each.
CSS: CSS is the language that styles every web page. Learn how selectors, the cascade, the box model, and modern layout tools like flexbox and grid work.
CSS @property: @property registers a CSS custom property with a type, initial value, and inheritance rule — unlocking smooth animation and real error checking.
CSS @scope: CSS @scope limits selectors to a subtree of the DOM, giving native scoped styling without the specificity wars of global stylesheets.
CSS @supports: CSS @supports lets a stylesheet test whether a browser supports a property or selector before using it. How feature queries work and when to reach for them.
CSS accent-color Explained: The CSS accent-color property recolors native checkboxes, radios, and range inputs without replacing them with custom-built controls.
CSS Anchor Positioning Explained: CSS anchor positioning lets an element attach to another element's edges without JavaScript. How anchor(), position-anchor, and fallbacks work.
CSS aspect-ratio: The CSS aspect-ratio property locks a box's width-to-height ratio in one line, replacing the old padding-top percentage trick. Syntax, gotchas, and use cases.
CSS Blend Modes: CSS blend modes combine an element's colors with what's behind it, using mix-blend-mode and background-blend-mode instead of extra markup or canvas tricks.
CSS Box Model: The CSS box model defines how every element is sized — content, padding, border, and margin. Here's how the layers stack and why box-sizing matters.
CSS Cascade Layers: CSS cascade layers let you group styles into named layers with explicit priority order, so specificity fights between resets, components, and overrides disappear.
CSS clip-path and Masking Explained: clip-path and mask-image clip or fade elements into custom shapes in pure CSS, replacing image editors and SVG sprites for cropping.
CSS Color Functions: oklch(), lch(), and color-mix() let CSS describe color perceptually and blend it directly in the browser. How each works and when to reach for them.
CSS color-mix(): CSS color-mix() blends two colors in a chosen color space right in a stylesheet, replacing the color math Sass and JavaScript used to handle.
CSS color-scheme Property: CSS color-scheme tells the browser which themes a page supports so native form controls, scrollbars, and UI render in dark mode without extra CSS.
CSS content-visibility: content-visibility lets the browser skip layout, style, and paint for off-screen content, cutting rendering cost on long pages without JavaScript.
CSS Counters: CSS counters auto-number elements with counter-reset, counter-increment, and the counter() function — no JavaScript or manual list numbers required.
CSS Custom Properties: CSS custom properties are native variables that cascade, inherit, and update live at runtime. How they work, why they beat preprocessor variables.
CSS field-sizing Property Explained: The CSS field-sizing property lets form controls like textareas grow to fit their content automatically, without JavaScript resize listeners.
CSS filter Property: The CSS filter property applies blur, brightness, contrast, grayscale, and other graphical effects directly to an element, no image editor required.
CSS Flexbox: How flex-grow, flex-shrink, and flex-basis actually distribute space in a flex container, with the flex shorthand values worth memorizing.
CSS Form Validation Pseudo-Classes Explained: CSS pseudo-classes like :valid, :invalid, :required, and :user-invalid style form feedback natively, without JavaScript watching every keystroke.
CSS Gradients: CSS gradients render smooth color transitions directly in the browser — no image files. How linear, radial, and conic gradients work, with practical examples.
CSS Grid repeat() and minmax() Explained: repeat() and minmax() let CSS Grid build responsive layouts without media queries. How the two functions combine, and common patterns.
CSS grid-auto-flow: grid-auto-flow: dense reorders grid items to fill leftover gaps automatically — how it works, when to use it, and the accessibility tradeoff it hides.
CSS Grid-Template-Areas: grid-template-areas lets you name grid regions and place items by name instead of row and column numbers, turning your CSS into a visual map of the layout.
CSS Houdini: CSS Houdini is a set of low-level browser APIs that let JavaScript hook into the CSS rendering pipeline itself, instead of working around it.
CSS line-clamp: The line-clamp property truncates text to a fixed number of lines and adds an ellipsis, without JavaScript or a fixed-height container.
CSS Logical Properties: CSS logical properties like margin-inline and padding-block size and space elements relative to writing direction, not fixed physical sides.
CSS Media Queries: CSS media queries apply styles conditionally based on viewport size, device features, and user preferences like color scheme or reduced motion.
CSS Nesting: Native CSS nesting lets you nest selectors inside a parent rule without a preprocessor. How the syntax works, the & selector, and specificity gotchas.
CSS Overflow: The overflow property controls what happens when content doesn't fit its box. A rundown of visible, hidden, scroll, auto, and clip — and when to use each.
CSS overscroll-behavior Explained: overscroll-behavior stops scroll chaining and pull-to-refresh bounce at a container's edge. How the property works and when to use it.
CSS position: position: sticky toggles between relative and fixed based on scroll position within its containing block — no JavaScript scroll listener required.
CSS Relative Color Syntax: Relative color syntax lets CSS derive a new color from an existing one by adjusting its channels directly, no preprocessor or JS required.
CSS Scroll Snap Explained: CSS scroll snap locks scrolling to fixed positions using scroll-snap-type and scroll-snap-align, no JavaScript required. Here's how it works.
CSS Scrollbar Styling: CSS now styles scrollbars natively with scrollbar-color and scrollbar-width, replacing years of vendor-prefixed hacks. Here's how they work.
CSS shape-outside: shape-outside lets text wrap around circles, polygons, and image silhouettes instead of a floated element's rectangular box. How it works, with examples.
CSS Specificity: CSS specificity is the scoring system that decides which rule wins when several target the same element. How the weights work and how to keep them low.
CSS Stacking Contexts and Z-Index Explained: Z-index only compares elements within the same stacking context. What creates a new context, how they nest, and why z-index: 9999 sometimes fails.
CSS Subgrid: CSS subgrid lets a nested grid item inherit its parent's track sizing, so children can align to the same columns or rows across unrelated containers.
CSS Subgrid: CSS subgrid lets a nested grid item inherit its parent's row and column tracks, so child elements line up across unrelated components.
CSS text-wrap: text-wrap: balance evens out line lengths in headlines using the browser's own layout engine, no JavaScript required. How it works and when to use it.
CSS Transforms: CSS transforms move, resize, and rotate elements without triggering layout. How translate, scale, rotate, and skew work, and why they're fast.
CSS Trigonometric Functions: CSS trig functions like sin(), cos(), and atan2() let you compute angles and coordinates directly in stylesheets, no JavaScript required. How they work.
CSS will-change: The CSS will-change property hints the browser to prepare an element for an upcoming change, moving it to its own compositor layer. When to use it and when not to.
CSS Writing-Mode: The CSS writing-mode property switches text flow between horizontal and vertical, and it's the foundation logical properties like margin-inline build on.
CTE: A CTE is a named, temporary result set defined with WITH that you can reference elsewhere in a SQL query. How they work and when to use one.
CVSS: CVSS scores a vulnerability's severity from 0 to 10 using exploitability and impact metrics. How the score is built, read, and misapplied.
CXL (Compute Express Link): CXL is an interconnect standard that lets CPUs, GPUs, and memory devices share coherent memory over PCIe, enabling memory pooling and expansion.

D

Dark Pools: A dark pool is a private venue where buy and sell orders are matched without being shown publicly beforehand. Why they exist and who actually uses them.
Data Lakehouse: A data lakehouse combines a data lake's cheap object storage with a data warehouse's transactional guarantees and schema. How the architecture works.
Data Loss Prevention (DLP): Data loss prevention (DLP) is a set of tools and policies that detect and block sensitive data from leaving an organization's control improperly.
Database Cursor: A database cursor is a pointer that lets you fetch a query's result set one row at a time instead of all at once. How cursors work and when to use them.
Database Deadlocks: A database deadlock happens when two transactions each wait on a lock the other holds. Why deadlocks occur, how databases detect them, and how to avoid them.
Database Indexing: A database index is a sorted data structure that lets the engine find rows without scanning the whole table. How indexes work, and when they help or hurt.
Database Isolation Levels: Isolation levels control how much of a concurrent transaction's uncommitted work another transaction can see, trading consistency for concurrency.
Database Migrations: A database migration is a version-controlled script that changes a schema incrementally. How migration tools track state and apply changes safely.
Database Normalization: Database normalization organizes tables to eliminate redundant data and update anomalies. The normal forms explained with a worked example.
Database Replication: Database replication keeps copies of data on multiple servers for redundancy and read scaling, at the cost of consistency and lag tradeoffs.
Database Sharding: Database sharding splits one dataset across many servers so no single machine holds it all. How sharding works, how to pick a shard key, and the trade-offs.
Database Trigger: A database trigger is a procedure that runs automatically on an insert, update, or delete — enforcing rules the application layer can't guarantee.
Database Vacuuming: Vacuuming reclaims space left by deleted and updated rows in databases like PostgreSQL, preventing bloat and transaction ID wraparound.
Database View: A database view is a saved SQL query that behaves like a table — simplifying complex joins and restricting access, without storing the data twice.
DCF: A DCF values a company by projecting its future free cash flows and discounting them to present value — the core method behind most valuations.
DDoS Attack: A DDoS attack floods a target with traffic from many sources at once, overwhelming it until real users can't get through. How it works, and how defenses respond.
DDR vs GDDR Memory: DDR and GDDR are both DRAM, but optimized for opposite goals: DDR minimizes latency for CPUs, GDDR maximizes bandwidth for GPUs. Here's how they diverge.
DDR4 vs DDR5: DDR5 raises transfer rates, splits each module into two independent sub-channels, and moves voltage regulation onto the module itself. Here's what that buys you.
Dead Letter Queue: A dead letter queue holds messages a system couldn't process after repeated retries, isolating failures so they don't block or silently vanish. How it works.
Debt-to-Equity Ratio Explained: The debt-to-equity ratio compares a company's total liabilities to shareholder equity to gauge financial leverage. How to read it.
Deferred Revenue: Deferred revenue is cash a company has received for goods or services it has not yet delivered. How it is recorded, recognized, and read by investors.
Dennard Scaling: Dennard scaling held that shrinking transistors kept power density constant, letting clock speeds rise for free. Its breakdown reshaped chip design.
Dependency Confusion Attack: A dependency confusion attack publishes a malicious public package with the same name as an internal one, tricking installs into pulling the wrong code.
Dependency Injection: Dependency injection passes an object's dependencies in from outside rather than letting it construct them, making code easier to test and swap.
Design Token: A design token is a named, platform-agnostic value — a color, spacing unit, font size — that keeps design and code in sync across a product.
Devcontainer: A devcontainer defines a project's dev environment as code — tools, extensions, and dependencies — so every contributor gets an identical setup.
Diffusion Model: Diffusion models generate images by learning to reverse a gradual noising process. How they work, what powers Stable Diffusion, and how they compare to GANs.
Dining Philosophers Problem: The dining philosophers problem is a classic model of deadlock and starvation: five philosophers, five forks, and a resource-sharing rule that can lock up.
Direct Listing: A direct listing lets a company's existing shares start trading publicly without issuing new stock or using underwriters to set the price.
Distributed Lock: A distributed lock coordinates exclusive access to a shared resource across multiple processes or machines, preventing race conditions in distributed systems.
Distributed Tracing: Distributed tracing follows a single request as it crosses service boundaries, using spans and trace IDs to reconstruct the full call path and find where time goes.
Diversification: Diversification spreads money across uncorrelated holdings so no single loss sinks a portfolio — it cuts risk without necessarily cutting return.
Divide and Conquer Algorithms Explained: Divide and conquer solves problems by splitting them into smaller subproblems, solving each recursively, and combining the results.
Dividend: A dividend is a portion of a company's profit paid directly to shareholders, typically in cash per share. How payouts, yield, and reinvestment work.
DMA (Direct Memory Access) and Why It Matters: DMA lets peripherals move data to and from memory without the CPU copying every byte, freeing the processor to do other work during transfers.
DNS: DNS translates domain names into IP addresses. How DNS resolution works, the common record types, and why it underpins everything on the web.
DNS Cache Poisoning: DNS cache poisoning tricks a resolver into storing a forged IP address for a domain, silently redirecting anyone who queries that resolver afterward.
DNS over HTTPS (DoH): DNS over HTTPS encrypts domain name lookups inside HTTPS traffic, hiding queries from network eavesdroppers. How DoH works and how it differs from DNSSEC.
DNS Rebinding: DNS rebinding tricks a browser into treating an attacker's server as same-origin with an internal service, bypassing network boundaries. How the attack works.
DNS Tunneling: DNS tunneling encodes data inside DNS queries and responses to smuggle traffic past firewalls, since DNS is almost always allowed through unfiltered.
DNSSEC: DNSSEC adds cryptographic signatures to DNS records so resolvers can verify responses weren't forged or tampered with in transit.
Docker Compose: Docker Compose defines multiple containers, networks, and volumes in one YAML file so you can start a whole application stack with a single command.
Docker Image Layers and Caching Explained: Docker images are stacks of read-only layers cached by content hash. How layer order affects build speed, cache hits, and final image size.
Docker Multi-Stage Builds Explained: Multi-stage builds let a Dockerfile use one stage to compile code and a separate, minimal stage to ship it — cutting image size and attack surface.
Docker Networking Modes: Docker's default bridge network isolates containers with NAT; host mode shares the host's network stack; overlay connects containers across hosts.
Dollar-Cost Averaging: Dollar-cost averaging means investing a fixed amount on a regular schedule regardless of price. How it works, and its real tradeoffs versus lump sum.
DOM: The DOM is the live in-memory tree browsers build from your HTML, which JavaScript reads and manipulates. Learn how it works and why it matters.
Down Round: A down round is a funding round priced below a startup's prior valuation, diluting existing shareholders and resetting terms.
DPO: DPO tunes a language model on human preference data directly, without training a separate reward model or running reinforcement learning.
DPU (Data Processing Unit): A DPU is a specialized chip that offloads networking, storage, and security tasks from the CPU. How data processing units fit alongside CPUs and GPUs.
DRIP: A DRIP automatically reinvests cash dividends into more shares, often commission-free, compounding returns without a manual trade each time.
Dual-Class Share Structure: A dual-class share structure gives some shares more votes than others, so founders keep control with a minority stake. How it works and the trade-offs.
DuckDB: DuckDB is an embedded, columnar SQL database built for fast analytical queries directly inside your application process. How it works.
Dutch Auction: A Dutch auction starts at a high price and descends until a buyer accepts — used in IPO pricing, treasury auctions, and some token sales.
Dynamic import() in JavaScript: JavaScript's dynamic import() loads a module on demand and returns a promise, letting you split bundles and defer code until it's actually needed.
Dynamic Programming: Dynamic programming solves complex problems by breaking them into overlapping subproblems and caching results, avoiding redundant recomputation.
Dynamic Viewport Units: dvh, svh, and lvh fix the classic mobile vh bug where browser toolbars cut off full-height layouts. Here's what each unit measures and when to use it.

F

Factor Investing: Factor investing targets specific, historically persistent drivers of stock returns — value, size, momentum, quality — instead of picking individual names.
False Sharing: False sharing happens when threads on different cores write to unrelated variables that share one cache line, silently wrecking performance.
FDIC Insurance: FDIC insurance protects up to $250,000 per depositor, per bank, per ownership category if an insured bank fails. How the coverage actually works.
Feature Flag: A feature flag is a runtime switch that turns functionality on or off without a deploy, used for gradual rollouts, A/B tests, and instant kill switches.
Feature Store: A feature store centralizes how machine learning features are computed, stored, and served — keeping training and production predictions consistent.
Federated Learning: Federated learning trains a shared model across many devices without moving their raw data, sending only model updates back to a central server.
Fenwick Trees (Binary Indexed Trees): A Fenwick tree, or binary indexed tree, answers prefix-sum queries and point updates in O(log n) with far less memory than a segment tree.
Fetch API: The Fetch API is JavaScript's built-in interface for making HTTP requests. How it works, its promise-based flow, and where it trips people up.
Fetch Priority: fetchpriority lets you tell the browser which resources matter most, overriding its default heuristics to load critical assets sooner.
FIDO2: FIDO2 is the open authentication standard that makes passkeys and hardware security keys work, using public-key cryptography instead of shared secrets.
Finding and Fixing Memory Leaks in JavaScript: A JavaScript memory leak happens when a reference outlives its usefulness and the garbage collector can't reclaim it. Common causes and how to find them.
Fine-Tuning: Fine-tuning continues training a pretrained model on a task-specific dataset. How it works, when to use it over prompting or RAG, and what can go wrong.
Finite State Machine: A finite state machine models a system as a fixed set of states and the transitions between them. How FSMs work and where they show up in real software.
FinOps: FinOps is the practice of making engineering, finance, and business teams jointly accountable for cloud spend. How it works and what it actually changes.
Firewall: A firewall filters network traffic against a ruleset, blocking connections that don't match. How packet filters, stateful inspection, and NGFWs differ.
Floyd-Warshall: Floyd-Warshall finds shortest paths between every pair of nodes in a weighted graph using dynamic programming — how the recurrence works and when to use it.
font-display: The CSS font-display property controls whether text waits for a web font or renders in a fallback first. Here's how swap, block, and optional differ.
Foreign Key Constraint: A foreign key constraint ties a column to a row in another table and blocks changes that would break that link. How referential integrity works in SQL.
Foundation Model in AI: A foundation model is a large model pretrained on broad data, then adapted for many downstream tasks via fine-tuning, RAG, or prompting alone.
FPGA: An FPGA is a chip whose logic circuits can be reconfigured after manufacturing, sitting between fixed-function ASICs and general-purpose CPUs in flexibility.
Free Cash Flow: Free cash flow is the cash a company generates after covering the capital spending needed to run its business. Why investors weight it over reported profit.
Function Calling in LLMs: Function calling lets an LLM emit a structured request to run a specific function, turning free-form text generation into reliable tool use.

G

GANs: A GAN pits a generator against a discriminator in a training loop that produces realistic synthetic data. How the adversarial setup works.
Git: Git is a distributed version control system that tracks changes to code and enables collaboration. Learn the core concepts and everyday workflow.
Git Bisect: git bisect finds the exact commit that introduced a bug by binary-searching your commit history, cutting the search space in half each step.
Git Cherry-Pick: Git cherry-pick applies one commit's changes onto a different branch without merging the whole branch. How it works, and when to use it instead of merging.
Git Hooks: Git hooks are scripts that run automatically at points in the Git workflow, like before a commit or push. How they work and when to use them.
Git Reflog: Git reflog records every place HEAD and branch tips have pointed, letting you recover commits that look lost after a reset, rebase, or deleted branch.
Git Stash: Git stash saves uncommitted work to a hidden stack so you can switch branches cleanly. How stash, pop, apply, and stash branches actually work.
Git Worktree: A git worktree lets you check out several branches at once in separate folders, sharing one .git history without cloning the repo again.
GitOps: GitOps uses a Git repository as the single source of truth for infrastructure state, with an automated agent reconciling the live system to match it.
GLM 5.2: GLM 5.2 is Zhipu/Z.ai's open-weight flagship: a one-million-token context window, top-tier open coding, MIT-licensed weights. What it is and how to run it.
Go: Go is a compiled language from Google built for simplicity, fast builds, and easy concurrency — the language behind Docker and Kubernetes.
Golden Parachute: A golden parachute is a contract guaranteeing an executive a large payout if they're terminated after a merger or takeover, even without cause.
Golden Share: A golden share is a special class of stock that gives its holder veto power over key corporate decisions, regardless of how small its economic stake is.
Goodwill: Goodwill is the premium a buyer pays over a target's net identifiable assets — brand, talent, and customer relationships an acquirer can't itemize.
GPU: A GPU packs thousands of small cores built for parallel arithmetic. Originally for graphics, it's now the engine behind training and running AI models.
Gradient Descent: Gradient descent is the optimization algorithm that trains neural networks, nudging weights downhill along the loss function's gradient.
Graph Database: A graph database stores data as nodes and relationships instead of tables, making deeply connected queries fast instead of a chain of costly joins.
GraphQL: GraphQL is a query language for APIs where clients request exactly the data they need. Learn how it works, when to use it, and how it compares to REST.
Green Bond: A green bond is debt whose proceeds are earmarked for environmentally beneficial projects. How it works and how it differs from a regular bond.
Greenshoe Option (Over-Allotment): A greenshoe option lets IPO underwriters sell up to 15% more shares than planned, giving them a tool to stabilize the stock price after listing.
gRPC: gRPC is a high-performance RPC framework from Google that uses HTTP/2 and Protocol Buffers for fast, typed, cross-language service communication.

H

Halting Problem: The halting problem proves no algorithm can determine, for every program and input, whether that program eventually stops. Why this limit is unavoidable.
Hardware Security Module (HSM): A hardware security module is a dedicated device that generates, stores, and uses cryptographic keys so private keys never leave secure hardware.
Hash Table: A hash table maps keys to array slots with a hash function for near O(1) lookups. How hashing, collisions, and resizing actually work under the hood.
HBM: HBM stacks DRAM dies vertically and connects them through a wide interface, trading capacity per chip for far higher bandwidth than standard DRAM.
HBM: High-Bandwidth Memory stacks DRAM dies vertically beside the processor, delivering far more bandwidth than DDR5 or GDDR — and AI hardware depends on it.
HBM vs GDDR: HBM stacks DRAM vertically next to the chip for extreme bandwidth per watt; GDDR spreads fast chips around the board. How the two approaches differ.
Head-of-Line Blocking: Head-of-line blocking is when one stalled item holds up everything queued behind it. How it affects HTTP/1.1, HTTP/2 over TCP, and how QUIC fixes it.
Headless CMS: A headless CMS stores and serves content through an API, with no built-in templating or frontend. Why teams split content management from presentation.
Health Savings Account (HSA): A Health Savings Account (HSA) is a triple-tax-advantaged account for medical expenses, paired with a high-deductible health plan. How HSAs work.
Heap: A heap is a tree-based structure that keeps the smallest or largest element at the root, enabling priority queues and heap sort in logarithmic time.
Hedge Fund: A hedge fund is a pooled investment vehicle for accredited investors that uses leverage, derivatives, and short selling to chase absolute returns.
Helm Charts: A Helm chart bundles a Kubernetes application's manifests into a templated, versioned package you can install, upgrade, and roll back as one unit.
HELOC: A HELOC is a revolving credit line secured by home equity, with a draw period for borrowing and a separate repayment period that follows it.
HMAC: HMAC combines a secret key with a hash function to prove a message wasn't altered and came from someone who holds the key. Here's how it works.
Hoisting in JavaScript: Hoisting moves variable and function declarations to the top of their scope before code runs, which explains some of JavaScript's most confusing bugs.
Homomorphic Encryption: Homomorphic encryption lets you compute on encrypted data without ever decrypting it, so a third party can process data it can never actually read.
Honeypot in Cybersecurity: A honeypot is a decoy system built to look like a real target, luring attackers so defenders can observe their techniques and catch intrusions early.
How Garbage Collection Works in JavaScript: JavaScript frees memory automatically by tracking reachability, not reference counts. How the mark-and-sweep algorithm works and what causes leaks anyway.
How LLM Streaming Responses Work (Server-Sent Events): LLM chat interfaces stream tokens as they're generated using Server-Sent Events, so users see text appear immediately instead of waiting for the full reply.
How Regular Expressions Work Under the Hood: Regular expressions are matched by finite automata or backtracking engines. How regex engines parse patterns, and why some patterns run slowly.
How the TLS Handshake Works: The TLS handshake is how a browser and server agree on encryption and verify identity before any data is exchanged. Here's each step explained.
HSTS: HSTS is a response header that tells browsers to only ever connect to a site over HTTPS, closing the gap that lets attackers strip encryption.
HTML: HTML is the standard markup language that structures every web page. Learn how elements, tags, and semantic HTML shape the web.
HTML dialog Element Explained: The native dialog element gives you modals and popovers with built-in focus trapping and accessibility, no JavaScript library required. Here's how it works.
HTML inert Attribute: The inert attribute removes an element and its children from focus, click handling, and screen reader access in one line, without hiding it visually.
HTTP Content Negotiation Explained: Content negotiation lets a client and server agree on a response's format, language, or encoding using Accept headers, before any body is sent.
HTTP Methods: HTTP methods signal intent — read, create, replace, update, or remove — and that intent determines caching, idempotency, and safety guarantees.
HTTP Range Requests and Partial Content: HTTP range requests let a client ask for just part of a resource, enabling video seeking, resumable downloads, and partial file fetches over HTTP.
HTTP Status Codes: HTTP status codes are three-digit responses that tell a client what happened to its request. A practical tour of the codes that actually matter.
HTTP/3: HTTP/3 runs over QUIC instead of TCP, cutting head-of-line blocking and speeding up connections with built-in TLS 1.3. What changed and why it matters.
HTTPS: HTTPS is HTTP run over TLS — an encrypted, authenticated tunnel that gives web traffic confidentiality, integrity, and proof you're talking to the right server.
Hydration: Hydration is how JavaScript wakes up server-rendered HTML so static markup becomes interactive. The cost, the tradeoffs, and the modern alternatives.
Hydration vs Resumability: Hydration re-runs a framework's JS to attach interactivity after render; resumability serializes state so the browser can skip that work.
HyperLogLog: HyperLogLog is a probabilistic algorithm that estimates the number of distinct items in a huge dataset using only a few kilobytes of memory.

I

Idempotency: An idempotent operation produces the same result no matter how many times it runs. Why that matters for retries, payments, and reliable APIs.
IDN Homograph Attack: An IDN homograph attack registers a lookalike domain using Unicode characters that resemble Latin letters. How it works, how browsers react, and defenses.
IDOR: IDOR is an access control flaw where an app trusts a user-supplied ID to fetch a record without checking the requester actually owns it.
IDS vs IPS: An IDS watches network traffic and alerts on threats; an IPS sits inline and blocks them automatically. How the two compare and when to use each.
Immutable Infrastructure: Immutable infrastructure replaces servers instead of patching them in place — every change ships as a new, versioned artifact. How it works and why.
Import Maps: Import maps let browsers resolve bare module specifiers like "react" to real URLs, enabling native ES module imports without a bundler.
Incident Severity Levels Explained (SEV1-SEV4): Incident severity levels rank outages by impact so teams respond proportionally. What SEV1 through SEV4 typically mean and how to set the scale.
Incremental Static Regeneration (ISR): ISR lets a static page be rebuilt in the background after deploy, on a timer or on demand, without a full site rebuild. How it works and its tradeoffs.
Index Cardinality: Cardinality is how many distinct values a column has. Low-cardinality columns make poor index candidates because the database still scans most of the table.
IndexedDB: IndexedDB is a browser API for storing large amounts of structured data client-side, with indexes, transactions, and no size limit like localStorage.
Inflation: Inflation is the rate at which prices rise and purchasing power falls over time, typically measured by the Consumer Price Index. How CPI is calculated.
Infrastructure as Code: Infrastructure as code defines servers, networks, and services in version-controlled files instead of manual setup. How IaC works and why teams use it.
Infrastructure Drift: Infrastructure drift is when a system's real-world state diverges from what its infrastructure-as-code declares. Causes, detection, and how to prevent it.
Insecure Deserialization: Insecure deserialization lets attackers turn a trusted object format into remote code execution. How the attack works and how to prevent it.
Insider Trading: Insider trading means trading on material, nonpublic information. Some of it is legal and disclosed; trading on secret information to gain an edge is not.
Instruction Tuning: Instruction tuning trains a language model on prompt-response pairs so it follows directions instead of just predicting text. How it works and where it fits.
Interaction to Next Paint (INP) Explained: INP measures how long a page takes to visually respond to a click, tap, or keypress. What it counts, how it's scored, and how to bring it down.
Internal Developer Platform (IDP): An internal developer platform packages infrastructure into self-service tools so developers ship without filing tickets or learning Kubernetes.
Intersection Observer API Explained: The Intersection Observer API tells you when an element enters or leaves the viewport, without scroll-event polling. How it works and where to use it.
IPO: An IPO is when a private company sells shares to the public for the first time and lists on an exchange. How the process works, and what changes after.
IPO Lock-Up Period: An IPO lock-up period bars insiders and early investors from selling shares for a set window after the offering, usually 90 to 180 days.

J

JavaScript: JavaScript is the programming language that makes web pages interactive. Learn how it works alongside HTML and CSS, and why it runs nearly everywhere.
JavaScript Array.sort() Pitfalls (and How to Fix Them): Array.sort() converts elements to strings by default, so numbers sort out of order. Here's why, and how a compare function fixes it.
JavaScript Closures Explained, With Examples: A JavaScript closure is a function that remembers the variables from where it was defined. How closures work, why they matter, and the classic loop gotcha.
JavaScript Currying: Currying transforms a multi-argument function into a chain of single-argument functions. How currying and partial application work in JavaScript.
JavaScript Destructuring: JavaScript destructuring unpacks values from arrays and objects into variables in one expression. How it works, with the rest and spread operators.
JavaScript Event Delegation Explained: Event delegation attaches one listener to a parent instead of one per child, using event bubbling to catch clicks from elements added after page load.
JavaScript Event Loop: The event loop is the scheduler that lets single-threaded JavaScript juggle timers, network responses, and user input without freezing the page.
JavaScript flat() and flatMap() Explained: flat() flattens nested arrays by a given depth; flatMap() maps then flattens one level in a single pass. How each works and when to pick one.
JavaScript Generators and Iterators: Generators are functions that pause and resume with the yield keyword, producing values lazily on demand instead of computing them all at once.
JavaScript Import Attributes Explained: Import attributes let JavaScript modules declare a resource's expected type at import time, such as JSON — catching mismatches before code runs.
JavaScript Intl API: The Intl API formats dates, numbers, and currency using a user's locale without a library. How Intl.DateTimeFormat and Intl.NumberFormat work.
JavaScript Iterator Helpers Explained: JavaScript's iterator helper methods bring map, filter, and take directly to iterators, so lazy sequences no longer need a library or a manual loop.
JavaScript Map and Set: JavaScript's Map and Set are built-in collections with cleaner semantics than plain objects and arrays. Here's how each works and when to reach for one.
JavaScript Private Class Fields Explained: JavaScript private class fields use a # prefix to enforce true encapsulation at the language level, hiding state that closures and underscores never could.
JavaScript Prototypal Inheritance Explained: Prototypal inheritance means JavaScript objects inherit properties directly from other objects via a prototype chain, not from classes. How it works.
JavaScript Proxy Objects Explained: A JavaScript Proxy wraps an object and intercepts operations like get and set through traps. How traps work, with practical examples and Reflect.
JavaScript Spread vs Rest Operators: The spread operator (...) expands an iterable into individual elements; the rest operator collects elements back into an array. Same syntax, opposite jobs.
JavaScript Strict Mode Explained: Strict mode turns silent JavaScript mistakes into thrown errors and closes off unsafe legacy behavior. Modules and classes use it by default.
JavaScript Symbols: A JavaScript Symbol is a guaranteed-unique primitive used for collision-free object keys. How Symbols work, well-known Symbols, and when to use them.
JavaScript Temporal API: The Temporal API is JavaScript's built-in replacement for Date — immutable, timezone-aware objects for dates, times, and durations.
JavaScript Typed Arrays and ArrayBuffer: ArrayBuffer allocates raw binary memory; typed arrays like Uint8Array give it a numeric type and view. How JavaScript handles binary data directly.
JavaScript's this Keyword: How JavaScript determines what this refers to: default, implicit, explicit, and new binding, plus why arrow functions behave differently.
JIT Compilation: Just-in-time (JIT) compilation translates code to native machine instructions while a program runs, trading startup time for peak execution speed.
JSON: JSON is a lightweight text format for structured data — the default for APIs and config files. Syntax, examples, common mistakes, and why it beat XML.
JSON Schema: JSON Schema is a vocabulary for describing and validating the shape of JSON data. How schemas work, where they show up, and the keywords that matter.
JWT: A JWT is a compact, signed token that carries JSON claims — identity and authorization without a session lookup. How it works and what to watch out for.

L

Lazy Loading Images: Lazy loading defers offscreen images until they near the viewport. Comparing the native loading attribute against Intersection Observer-based approaches.
Letta AI: Letta (formerly MemGPT) builds stateful AI agents with long-term memory that persists across sessions. Here's what Letta is and how its memory model works.
Leveraged Buyout (LBO): A leveraged buyout uses borrowed money, secured against the target company's own assets, to fund most of an acquisition's purchase price.
Leveraged ETF: A leveraged ETF uses swaps and futures to deliver a multiple of an index's daily return — and daily resets mean long-term returns can diverge sharply.
Leveraged Loan: A leveraged loan is a floating-rate loan to a company that already carries significant debt or a below-investment-grade credit rating, priced accordingly.
Linked List: A linked list stores elements as nodes linked by pointers rather than contiguous memory, trading fast random access for cheap insertion and removal.
Liquidation Preference: A liquidation preference sets who gets paid first, and how much, when a startup is sold — often the term that most shapes investor and founder payouts.
Little's Law: Little's Law relates the number of requests in a system, their arrival rate, and how long each one takes — a simple formula for sizing capacity.
LLM Eval: An LLM eval is a structured test suite that scores a model's outputs against a standard, letting you compare models and catch regressions systematically.
LLM Grounding: Grounding connects an LLM's output to verifiable external data instead of relying on what it memorized during training, reducing hallucinations. How it works.
LLM Logprobs: Logprobs are the log probabilities an LLM assigns to each token it generates. What they mean, how to read them, and practical uses like classification.
LLM Router: An LLM router sends each request to the cheapest or fastest model that can handle it, instead of routing every call to one model regardless of difficulty.
LLM Temperature: Temperature controls how random an LLM's token choices are. How it works alongside top-p and top-k, and how to pick a value for your use case.
LLM-as-a-Judge: LLM-as-a-judge uses one language model to score another model's outputs against a rubric, replacing slow human review for large-scale evaluation.
LLMs: What are LLMs and how do they work? A plain-English guide to large language models: tokens, training, real examples, and what they still get wrong.
Load Balancer: A load balancer distributes traffic across servers to prevent overload and downtime. Layer 4 vs Layer 7, routing algorithms, health checks, and TLS.
Load Testing: Load testing measures how a system behaves under expected and peak traffic, revealing bottlenecks and capacity limits before real users do.
Lockfile: A lockfile records the exact dependency versions your package manager resolved, so every install — from your laptop to CI — reproduces the same tree.
Log Aggregation: Log aggregation collects logs from every service into one searchable system, so debugging a distributed app doesn't mean SSHing into a dozen machines.
Logit Bias: Logit bias nudges an LLM's token probabilities up or down before sampling, letting you ban, force, or discourage specific words without a prompt.
Long Polling: Long polling holds an HTTP request open until new data arrives, faking real-time updates without a persistent connection. How it works and when to use it.
LoRA: LoRA fine-tunes a large model by training small low-rank matrices instead of its full weights. How it works, why it's cheap, and where it falls short.
LRU Cache: An LRU cache evicts the least recently used item first when it runs out of room, keeping the most useful data in memory. Here's how it's built.
LSM Tree: An LSM tree batches writes in memory and flushes them as sorted files on disk, trading read complexity for the fast, sequential writes many databases rely on.

M

Makefile: A Makefile defines targets, dependencies, and shell commands so `make` only rebuilds what changed. Here's how the rule syntax and dependency graph work.
Man-in-the-Browser Attack: A man-in-the-browser attack uses malware inside the browser itself to alter what a user sees and submits, bypassing HTTPS and session protections entirely.
Man-in-the-Middle Attack: A man-in-the-middle attack secretly intercepts traffic between two parties. How MITM attacks work, common variants, and the defenses that stop them.
Manacher's Algorithm Explained: Manacher's algorithm finds the longest palindromic substring in linear time by reusing symmetry from palindromes already found, avoiding redundant checks.
Margin Call: A margin call is a broker's demand for more cash or securities after a leveraged position loses value. How maintenance margin works and how it gets triggered.
Market Cap: Market cap is share price times shares outstanding — the market's total price tag on a company. What it measures, what it misses, and why it matters.
Market Circuit Breaker: A market circuit breaker is an automatic trading halt triggered when an index falls a set percentage, giving markets a pause during extreme volatility.
Market Liquidity: Liquidity is how easily an asset can be bought or sold without moving its price. High-liquidity markets have tight spreads; low-liquidity ones don't.
Market Maker: A market maker quotes buy and sell prices continuously, profiting from the spread while providing the liquidity that keeps markets tradeable.
Master Theorem: The master theorem gives a direct formula for the time complexity of divide-and-conquer recurrences, skipping recursion-tree analysis by hand.
Materialized View: A materialized view stores a query's result as physical data instead of recomputing it on every read. How it differs from a view, and when to use one.
Memoization: Memoization caches a function's return value by its input, skipping recomputation on repeat calls. How it works and when it actually helps.
Memory Controller: A memory controller is the circuit that manages every read and write between the CPU and main memory, setting the ceiling on bandwidth and latency.
Memory Interleaving: Memory interleaving spreads consecutive addresses across multiple memory banks so the system can access them in parallel instead of one at a time.
Memory-Mapped I/O: Memory-mapped I/O maps device registers into the CPU's address space, letting hardware be read and written with ordinary load and store instructions.
Merkle Tree: A Merkle tree hashes data in pairs up to a single root hash, letting huge datasets be verified for integrity without downloading all of them.
Message Queue: A message queue holds tasks between producers and consumers so work happens asynchronously and reliably. How queues work and when to use one.
MFA: MFA requires two or more independent proofs of identity to log in. How the factor categories work, common methods, and why MFA stops most account takeovers.
Micro-Frontends: Micro-frontends split one web app into independently deployable pieces owned by separate teams. How the pattern works, and its real tradeoffs.
Mixture of Experts (MoE): Mixture of Experts (MoE) scales LLMs by activating only a few experts per token. How routing, sparse activation, and load balancing actually work.
Model Collapse: Model collapse is the degradation that happens when a generative model is repeatedly trained on data produced by earlier generations of itself.
Model Context Protocol (MCP): The Model Context Protocol (MCP) is the USB-C of AI — one open standard that lets any model plug into your tools and data. How it works and why it won.
Model Distillation: Model distillation trains a small student model to mimic a larger teacher. How it works, how it differs from quantization and pruning, and its limits.
Monad: A monad is a wrapper type with rules for chaining operations that might fail, be async, or carry extra context — like Promise or Optional, generalized.
Money Market Fund: A money market fund is a mutual fund that holds short-term, high-quality debt to preserve cash while paying interest. How it works and its risks.
Monorepo: A monorepo holds multiple projects in one repository with shared tooling and atomic commits. How it compares to splitting projects across separate repos.
Monotonic Stack Technique Explained: A monotonic stack keeps elements in strictly increasing or decreasing order, solving next-greater-element and range problems in linear time.
Moore's Law: Moore's Law is the observation that transistor density on a chip roughly doubles every couple of years. Why it drove decades of gains, and why it's slowing.
Moving Average: A moving average smooths out price noise by averaging recent data points over a rolling window. How simple and exponential moving averages work.
mTLS: mTLS is TLS where both client and server present certificates, so each side cryptographically proves its identity before any data is exchanged.
Multi-Agent System: A multi-agent system splits a task across several specialized AI agents that coordinate instead of one agent doing everything. How they're structured.
Multi-Factor Authentication (MFA): MFA requires two or more independent proofs of identity — something you know, have, or are — to stop stolen passwords from being enough to break in.
Multi-Tenancy: Multi-tenancy lets one system serve many customers from shared infrastructure. The isolation models that keep tenants' data and performance separate.
Multimodal AI: A multimodal AI model processes and generates more than one type of data — text, images, audio — in a single unified system. Here's how it works.
MutationObserver API Explained: The MutationObserver API watches for changes to the DOM — attributes, child nodes, and text — without polling. How it works and when to use it.
Mutual Fund: A mutual fund pools money from many investors into one managed portfolio. How mutual funds work, their fees, and how they compare to ETFs.
MVCC: MVCC lets readers and writers work on a database concurrently without blocking each other, by keeping multiple versions of each row instead of locking it.

N

NAT Gateway: A NAT gateway lets private-subnet resources reach the internet outbound while staying unreachable from it, translating private IPs to a public one.
Navigation API: The Navigation API gives JavaScript a structured way to intercept and control browser navigations — a modern alternative to the History API.
Net Revenue Retention (NRR): Net revenue retention measures how much recurring revenue a company keeps and grows from existing customers over a year. Formula, examples, and NRR vs GRR.
Network Ingress vs. Egress: Ingress is traffic entering a network or system; egress is traffic leaving it. The distinction shapes firewall rules, cloud billing, and security posture.
Network Segmentation: Network segmentation splits a network into isolated zones so a breach in one part can't freely reach the rest. How it works and where it fits alongside zero trust.
Neural Network: A neural network is layers of weighted connections that learn patterns from data. How neurons, activation functions, and training actually work.
Neural Network Pruning Explained: Neural network pruning removes redundant weights or neurons after training to shrink a model without retraining from scratch. How it works.
Next.js Server Actions: Server Actions let Next.js run server-side functions directly from client components and forms, without hand-written API routes. How they work.
Node.js Buffer: Node's Buffer class holds raw binary data outside the V8 heap, letting Node handle files, sockets, and streams efficiently. Here's how it works.
Node.js Streams: Node.js streams process data in chunks instead of loading it all into memory. How readable, writable, and transform streams work, and when to reach for them.
Node.js Worker Threads: Node.js worker threads run JavaScript on real OS threads in parallel, letting CPU-heavy work run without blocking the event loop.
Northbridge and Southbridge: The northbridge and southbridge were the two chips that routed data between a CPU, memory, and peripherals before modern SoCs absorbed their jobs.
npm and pnpm Workspaces: Workspaces let npm and pnpm manage multiple packages in one repository, sharing a single dependency tree and letting packages reference each other locally.
NPU: An NPU is a processor built for one job: running AI models fast at very low power. What TOPS numbers actually mean and why every new laptop ships with one.
NUMA: NUMA gives each CPU its own local memory bank, so access speed depends on which processor is asking. How NUMA nodes and remote access latency work.

O

OAuth: OAuth 2.0 lets apps access your data without your password. How the authorization flow works, what PKCE adds, and how OAuth differs from authentication.
OAuth 2.0 Grant Types: OAuth 2.0 grant types are the flows apps use to get access tokens. Authorization code with PKCE, client credentials, device flow — and when to use each.
OAuth PKCE Flow Explained: PKCE hardens the OAuth authorization code flow against interception, and is now recommended for every client type, not just mobile and single-page apps.
Object.groupBy() in JavaScript: Object.groupBy() buckets array items by a key you compute, replacing the reduce() boilerplate developers have written for years. How it works.
Observability: Observability is the ability to understand a system's internal state from its external outputs — built from logs, metrics, and traces working together.
OffscreenCanvas API Explained: OffscreenCanvas lets you render canvas graphics off the main thread, in a web worker, so heavy drawing work stops blocking scrolling, input, and animation.
Ollama: Ollama is a free, open-source tool for running LLMs locally — pull a model with one command and chat privately, offline, at no per-token cost. How it works.
On-Call Rotations and Incident Response Explained: On-call rotations spread responsibility for production incidents across a team on a schedule, paired with a defined incident response process for when alerts fire.
OpenTelemetry: OpenTelemetry is a vendor-neutral standard for instrumenting apps with traces, metrics, and logs — one API, any observability backend.
Operating Leverage: Operating leverage measures how much a company's operating profit changes when revenue changes, driven by its fixed costs. How it works and why it matters.
Options Contract: An options contract gives the holder the right, not the obligation, to buy or sell a stock at a set price by a set date. Calls and puts explained.
ORM: An ORM lets you query a database using your programming language's objects instead of raw SQL. How they work, what they trade off, and when to skip one.
Outbox Pattern in Microservices: The outbox pattern writes an event to the same database transaction as a state change, then publishes it reliably — solving the dual-write problem.
Overclocking: Overclocking runs a CPU, GPU, or memory beyond its rated clock speed for more performance, trading power, heat, and stability margin to get it.
OWASP Top 10: The OWASP Top 10 is a ranked list of the most critical web application security risks. What's on it, why it matters, and how teams use it.

Q

QSBS (Qualified Small Business Stock): QSBS lets founders and early employees exclude a large share of capital gains from federal tax when they sell qualifying startup stock. How it works.
Qualified Dividend: A qualified dividend is taxed at the lower long-term capital gains rate instead of ordinary income rates, if the payer and holding period tests are met.
Quantization: Quantization reduces the numeric precision of a model's weights — e.g. FP16 to INT8 or INT4 — to shrink memory use and speed up inference with minimal accuracy loss.
Quantum Computer: A quantum computer uses qubits in superposition and entanglement to explore many possible states at once, rather than one bit value at a time.
Quorum Consensus: Quorum consensus lets distributed databases tune consistency and availability by requiring reads and writes to touch overlapping subsets of replicas.

R

Rabin-Karp and Rolling Hashes: The Rabin-Karp algorithm finds substrings by hashing, sliding a window in O(1) time per step instead of rehashing from scratch. Here's how it works.
Race Condition: A race condition occurs when a program's correctness depends on the unpredictable timing of concurrent operations. Why they happen and how to prevent them.
Radix Sort and Counting Sort Explained: Radix sort and counting sort can beat comparison sorts by never comparing elements at all — sorting integers in linear time under the right conditions.
Raft Consensus Algorithm: Raft is a consensus algorithm that lets a cluster of servers agree on a shared state even when some nodes fail. How leader election and log replication work.
RAG Chunking Strategies Explained: How you split documents into chunks determines what a RAG system can retrieve. Fixed-size, semantic, and recursive chunking compared, with tradeoffs.
RAID: RAID combines multiple drives into one logical unit for redundancy, speed, or both. How RAID 0, 1, 5, 6, and 10 trade off capacity, speed, and safety.
Rainbow Table: A rainbow table is a precomputed lookup of hash chains that speeds up cracking unsalted password hashes. How it works and why salting defeats it.
Rate Limiting: Rate limiting caps how many requests a client can make in a given window, protecting APIs from abuse and overload. Common algorithms compared.
React Compiler: The React Compiler automatically memoizes components and values at build time, cutting most manual useMemo, useCallback, and React.memo calls.
React Context API Explained: React's Context API passes data through the component tree without manually threading props at every level — and where it stops being the right tool.
ReAct Pattern: ReAct interleaves an LLM's reasoning with tool calls and their results, letting an agent adjust its plan after each observation instead of reasoning blind.
React Server Components: React Server Components render exclusively on the server and stream a serialized result — no client JS shipped for that component. Here's what that actually means.
React Suspense: React Suspense lets components pause rendering while they wait on async data, showing a fallback UI instead of manual loading-state juggling.
Read Replica: A read replica is a synced copy of a database that serves read queries, taking load off the primary. How replication lag and failover actually work.
Read-Your-Writes Consistency Explained: Read-your-writes consistency guarantees a client sees its own writes immediately, even when other clients might not yet. How it's implemented.
Reasoning Models: Reasoning models 'think' before they answer, trading inference time for accuracy on hard problems. Here's how test-time compute, adaptive thinking, and effort work.
Recursion vs. Iteration: Recursion solves a problem by calling itself on smaller inputs; iteration solves it with a loop. Same results, different trade-offs in memory and clarity.
Redis: Redis is an in-memory key-value store used as a cache, database, and message broker. How it works, why it's sub-millisecond fast, and when to use it.
Reflect API in JavaScript: JavaScript's Reflect object mirrors fundamental object operations as functions, designed to pair with Proxy traps and simplify metaprogramming.
Reflow vs Repaint: Reflow recalculates layout; repaint just redraws pixels. Why the difference matters for animation performance and how to avoid triggering reflow.
REIT: A REIT is a company that owns income-producing real estate and must pay out most of its taxable income as dividends, letting investors buy in like a stock.
Replay Attack: A replay attack resends a captured, valid message to trick a system into repeating an action — and why timestamps, nonces, and signatures stop it.
Replication Lag: Replication lag is the delay between a write on the primary database and its arrival on a replica. What causes it, how to measure it, and how to reduce it.
Reproducible Builds: Reproducible builds produce bit-for-bit identical output from the same source, so anyone can verify a binary. Why they matter and how to achieve them.
Repurchase Agreement (Repo): A repurchase agreement, or repo, is a short-term loan collateralized by securities — the plumbing behind overnight cash markets.
requestAnimationFrame: requestAnimationFrame schedules a callback right before the browser repaints, syncing JavaScript animation to the display's refresh rate. How it works.
requestIdleCallback Explained: requestIdleCallback runs low-priority JavaScript when the browser is idle, without blocking rendering, input, or the main thread.
Reranker: A reranker re-scores a retriever's candidate results with a slower, more accurate model, fixing the precision gap that pure vector search leaves behind.
Reservoir Sampling: Reservoir sampling picks a uniform random sample from a stream of unknown length using constant memory, without knowing the size in advance.
ResizeObserver API: The ResizeObserver API lets JavaScript watch an element's box size and react without polling or resize-event hacks. How it works and when to use it.
Responsive Images: Responsive images use srcset and sizes to let the browser pick the right file for each screen, cutting wasted bytes without extra JavaScript.
REST API: A REST API is a web API that follows a set of conventions built on HTTP. Learn how URLs, HTTP methods, status codes, and JSON fit together.
Retrieval-Augmented Generation (RAG): Retrieval-augmented generation (RAG) grounds an LLM in your own data — cutting hallucinations and adding citations without retraining. Here's how RAG actually works.
Return on Assets (ROA): ROA measures how efficiently a company turns its total assets into profit, dividing net income by average total assets. How to read it and its limits.
Return on Equity (ROE): Return on equity measures how much profit a company generates for every dollar of shareholder equity, a core gauge of how efficiently it's run.
Return on Invested Capital (ROIC): ROIC measures the after-tax return a company earns on all the capital — debt and equity — invested in its operations, a core test of capital efficiency.
Reverse ETL Explained: Reverse ETL moves data out of the warehouse and into operational tools like a CRM, flipping the direction of a traditional ETL pipeline. How it works.
Reverse Merger: A reverse merger lets a private company go public by merging into an existing public shell company, skipping a traditional IPO. How the deal works.
Reverse Proxy: A reverse proxy sits in front of servers, forwarding client requests and hiding backend topology. TLS termination, caching, and load balancing explained.
Reward Hacking in AI Systems: Reward hacking is when an AI system optimizes its literal reward signal in ways that satisfy the metric but violate what the designer actually wanted.
Rights Offering: A rights offering lets existing shareholders buy new shares at a discount before anyone else, raising capital while giving current investors first refusal.
Ring Buffer: A ring buffer is a fixed-size array that wraps its read and write pointers around, giving O(1) enqueue and dequeue without ever resizing.
RLHF: RLHF trains a language model to match human preferences using a reward model and reinforcement learning. How the training pipeline actually works.
Roaring Bitmap: A roaring bitmap is a compressed bitmap format that splits data into chunks and picks the best internal representation for each — fast and space-efficient.
Robo-Advisor: A robo-advisor builds and rebalances a diversified portfolio automatically based on your risk profile, usually for lower fees than a human advisor.
Rootkit: A rootkit is malware that gains privileged access and then hides itself, and often other malware, from the operating system and security tools.
Rope Data Structure: A rope is a binary tree of string chunks that makes inserting, deleting, and slicing huge strings fast, which is why text editors use it over plain arrays.
Row-Level Security (RLS): Row-level security lets a database restrict which rows a query can see or modify, per user, enforced at the engine — not the application layer.
Rule of 72: The Rule of 72 estimates how many years it takes an investment to double: divide 72 by the annual return rate. How accurate it is, and its limits.
Runbook: A runbook is a step-by-step document for handling a specific operational task or incident, turning tribal knowledge into a repeatable procedure.

S

SAFE: A SAFE is a simple agreement for future equity — cash now in exchange for shares later, without setting a valuation or accruing interest like a note.
SAFE: A SAFE is a startup funding contract that converts an investor's cash into equity at a future priced round, without interest or a maturity date.
Saga Pattern: The saga pattern coordinates a multi-step transaction across services using local commits and compensating actions instead of a distributed lock.
Same-Origin Policy: The same-origin policy stops a script from one site reading data loaded from another. How origins are compared, and how CORS and cookies fit in.
SBOM: An SBOM is a complete inventory of every component in a piece of software, including its dependencies. Why it matters for tracking vulnerabilities at scale.
SCIM: SCIM is a standard protocol for automatically creating, updating, and deactivating user accounts across apps as an identity provider's directory changes.
Secondary Offering: A secondary offering is new or existing stock sold to the public after a company's IPO — how it differs from an IPO, and why it can dilute shareholders.
Secrets Management: Secrets management stores API keys, passwords, and certificates in a dedicated system instead of config files, with access control, rotation, and audit logs.
Segment Trees: A segment tree answers range queries — sum, min, max — over an array in logarithmic time, and supports updates without rebuilding the whole structure.
Self-Attention: Self-attention lets each token in a sequence weigh every other token when building its representation, which is how transformers understand context.
Semantic HTML Elements Explained: Semantic HTML elements like nav, article, and main describe meaning, not just appearance, improving accessibility and SEO. How to use them.
Semantic Versioning (SemVer): Semantic versioning encodes compatibility into a version number's three parts — major, minor, patch — so dependents know what a version bump might break.
Semaphore: A semaphore is a counter that limits how many threads can access a resource at once. How they work, semaphores vs mutexes, and common pitfalls.
Semiconductor Process Node: A process node like '5nm' or '3nm' names a chipmaker's manufacturing generation, not a literal measurement anymore. Here's what the number means.
Semiconductor Yield: Yield is the share of chips on a wafer that work. It's the single biggest driver of chip cost, and why new process nodes start out expensive.
SerDes: SerDes converts parallel data to a serial stream for transmission and back, letting chips move data over fewer, faster wires with less overhead.
Server-Sent Events (SSE): Server-Sent Events stream real-time updates over a single HTTP connection. How SSE works, when to use it, and how it compares to WebSockets.
Server-Timing Header Explained: The Server-Timing HTTP header exposes backend performance metrics — database time, cache hits — directly in the browser's DevTools network panel.
Serverless: Serverless means deploying code without managing servers — the platform scales it and you pay per use. How it works and where it fits.
Service Mesh: A service mesh is a dedicated infrastructure layer that handles service-to-service traffic, retries, and encryption without changing app code.
Service Worker: A service worker is a script that runs separately from your page, intercepting network requests to enable offline access, caching, and push notifications.
Session Fixation: Session fixation tricks a victim into using an attacker-known session ID, so logging in hands the attacker an authenticated session too.
Session Hijacking Explained: Session hijacking steals a valid session token to impersonate a logged-in user without a password. How attackers do it and how to stop it.
Shadow DOM: Shadow DOM attaches an isolated DOM tree to an element so a component's styles and markup can't leak in or out. Here's how it actually works.
SharedWorker: A SharedWorker runs one script shared across every tab and window of the same origin — a single background thread they can all connect to and message.
Sharpe Ratio: The Sharpe ratio measures return earned per unit of risk taken, letting investors compare two investments with different volatility on equal footing.
Short Selling: Short selling means borrowing shares to sell now, hoping to buy them back cheaper later — a bet on a falling price with theoretically unlimited risk.
Short Squeeze: A short squeeze happens when rising prices force short sellers to buy back shares to cover, driving the price up further in a feedback loop.
Side-Channel Attack: A side-channel attack recovers secrets from a system's physical behavior — timing, power draw, cache access — rather than breaking its algorithm directly.
Sidecar Pattern: The sidecar pattern runs a helper container alongside your app in the same pod, adding logging, proxying, or security without touching app code.
SIEM: A SIEM collects logs from across an organization, correlates them, and alerts on suspicious patterns. How it works and what feeds it.
Silicon Photonics: Silicon photonics moves data with light instead of electrical signals on standard chip manufacturing lines. How it works and why AI data centers need it.
SIMD and Vectorization Explained: SIMD lets a CPU apply one instruction to multiple data points at once. How vectorization works, why compilers auto-vectorize loops, and its limits.
Simultaneous Multithreading (SMT): Simultaneous multithreading lets one physical CPU core run two instruction streams at once, filling idle execution units to raise throughput.
Sinking Fund: A sinking fund sets aside money on a regular schedule to pay off a future debt or expense, reducing default risk and smoothing out a large future cost.
Site Reliability Engineering (SRE): Site reliability engineering applies software engineering to operations — error budgets, SLOs, and automating incident response at scale.
Skip List: A skip list is a layered linked list with shortcut pointers giving O(log n) search, insert, and delete — a simpler alternative to balanced trees.
Sliding Window Technique Explained: The sliding window technique tracks a moving subrange of an array or string, turning many O(n²) brute-force problems into a single O(n) linear pass.
Small Language Model (SLM): A small language model runs cheaply on-device, trading some capability for speed, privacy, and cost. When SLMs beat frontier models and how they're built.
Source Map: A source map is a file that maps minified, bundled, or transpiled code back to its original source, so debuggers and stack traces stay readable.
SPAC: A SPAC is a shell company that raises money in an IPO, then merges with a private company to take it public without a traditional IPO process.
Special Dividend: A special dividend is a one-time cash payout to shareholders, separate from a company's regular dividend. Why companies pay them and how they affect the stock price.
Speculation Rules API Explained: The Speculation Rules API lets browsers prerender pages before a click, making navigation feel instant. How it works and how it differs from prefetch.
Speculative Decoding: Speculative decoding speeds up LLM text generation by having a small draft model guess tokens the large model verifies in one pass. Here's how it works.
Speculative Execution: Speculative execution lets a CPU guess ahead and run instructions before it knows they're needed, buying speed at the cost of the timing side channels behind Spectre and Meltdown.
SPF, DKIM, and DMARC: SPF authorizes sending servers, DKIM signs message content, and DMARC ties both together with a policy — the three DNS records that stop email spoofing.
Splay Tree: A splay tree is a self-adjusting binary search tree that rotates recently accessed nodes to the root, giving fast amortized access to hot data.
SQL: SQL is the standard language for querying and managing relational databases. Learn the core statements, how joins work, and when SQL is the right tool.
SQL Injection: SQL injection lets attackers run arbitrary database queries by smuggling SQL into user input. Parameterized queries close the hole. Here's how it works.
SQL Joins: A SQL join combines rows from two tables based on a related column. How inner, left, right, and full outer joins differ, with examples.
SQL Window Functions Explained (With Examples): SQL window functions compute values across a set of rows without collapsing them, unlike GROUP BY. How OVER, PARTITION BY, and ranking work.
SQLite: SQLite is a serverless, file-based SQL database compiled directly into an application. How it works, why it's everywhere, and when to reach for it.
SSO: SSO lets a user log in once with one identity provider and access multiple apps without re-entering credentials. How the trust relationship works.
SSRF: SSRF tricks a server into requesting unintended destinations, reaching internal systems attackers couldn't otherwise touch. How it works and how to stop it.
Stacks vs Queues: Stacks remove the most recent item first (LIFO); queues remove the oldest first (FIFO). How each works, their operations, and where they show up.
Stale-While-Revalidate: Stale-while-revalidate serves a cached response instantly while fetching a fresh one in the background, so no request waits on the network.
Stock Buyback: A stock buyback is a company using cash to repurchase its own shares, shrinking the share count. How buybacks work, why firms do them, and the trade-offs.
Stock Index: A stock index tracks a basket of stocks with a single number, using a construction methodology that determines what moves it. Here's how it works.
Stock Split: A stock split increases a company's share count and lowers its price proportionally, leaving total market value and each investor's stake unchanged.
Stock Warrant: A stock warrant gives the holder the right to buy shares directly from the company at a set price before expiration — issued by the company, not traded exchanges.
Stop-Loss Order: A stop-loss order automatically sells a security once it falls to a set trigger price, capping downside without watching the market all day.
Stored Procedure: A stored procedure is precompiled SQL saved inside the database and invoked by name, cutting network round trips and centralizing business logic.
Strangler Fig Pattern: The strangler fig pattern replaces a legacy system incrementally by routing traffic to new services piece by piece, until nothing old remains.
structuredClone(): structuredClone() is a built-in JavaScript function for deep-copying values, including cycles and typed arrays, without the workarounds JSON tricks require.
Subdomain Takeover: A subdomain takeover happens when a DNS record points to a service you no longer control, letting an attacker claim it and serve their own content.
Subresource Integrity (SRI): Subresource Integrity lets a browser verify a fetched script or stylesheet matches an expected hash, blocking a tampered CDN asset from running.
Suffix Arrays: A suffix array sorts every suffix of a string into one compact index, enabling binary-search pattern matching without a full suffix tree.
Sum-of-the-Parts Valuation Explained: Sum-of-the-parts valuation values each business segment of a diversified company separately, then adds them up — often revealing value a single blended multiple misses.
Svelte 5 Runes Explained: Svelte 5 runes like $state and $derived replace the old reactive-assignment magic with explicit function calls that work anywhere in a file.
Synthetic Data: Synthetic data is artificially generated training data that mimics real-world patterns without exposing actual records. How it's made and used.
System on Chip (SoC): A system on chip packs a CPU, GPU, memory controller, and other components onto one die — the design behind phones, laptops, and most modern chips.
System Prompt: A system prompt is the hidden instruction set that shapes an LLM's persona, tone, and boundaries before any user message arrives — how it works.
Systolic Array: A systolic array is a grid of processing elements that pass data to their neighbors in rhythm, built to accelerate matrix multiplication in AI chips like TPUs.

T

Tagged Template Literals in JavaScript: Tagged template literals let a function intercept a template string's parts before interpolation — the mechanism behind safe SQL, styled-components, and i18n.
Tail Call Optimization Explained: Tail call optimization reuses a function's stack frame for its final call instead of pushing a new one, turning some recursion into constant stack space.
Tail Latency: Tail latency is the response time of your slowest requests, measured as p99 or p999. Why averages hide it, what causes it, and how to reduce it.
Target-Date Fund: A target-date fund is a single fund that shifts from stocks to bonds automatically as a chosen year approaches, following a preset glide path.
Tax-Loss Harvesting: Tax-loss harvesting sells losing investments to offset capital gains and up to $3,000 of ordinary income each year, then reinvests the proceeds.
TCP Congestion Control: TCP congestion control decides how fast a sender transmits without overloading the network. Slow start, AIMD, CUBIC, and BBR explained.
Tender Offer: A tender offer is a public bid to buy shares directly from shareholders at a set price, bypassing the board — often used in takeovers and buybacks.
Term Sheet: A term sheet outlines a proposed investment's key terms — valuation, ownership, control — before lawyers draft the binding legal agreements.
Terraform: Terraform lets you declare cloud infrastructure as code and provision it reproducibly across AWS, GCP, and Azure. How plan/apply, state, and modules work.
Terraform State File: Terraform's state file maps your config to real infrastructure. How it works, why remote state and locking matter, and what causes state drift.
Test-Time Compute: Test-time compute is extra computation an AI model spends while answering, not while training — trading latency and cost for better answers.
Thermal Design Power (TDP): TDP is the amount of heat a cooling system must dissipate for a chip, not a hard limit on its power draw. Why TDP and actual power draw often diverge.
Thermal Interface Materials Explained: Thermal interface material fills microscopic gaps between a chip and its heatsink so heat can actually transfer to the cooler.
Thermal Throttling: Thermal throttling automatically reduces a chip's clock speed when it gets too hot, trading performance for safety. How it works and how to spot it.
Threat Modeling: Threat modeling is a structured process for finding security weaknesses before code ships, by asking what could go wrong and how an attacker would exploit it.
Three Financial Statements: The income statement, balance sheet, and cash flow statement each answer a different question about a company. How they connect and what each one shows.
Thundering Herd Problem (Cache Stampede) Explained: The thundering herd problem hits when a cached value expires and every waiting request floods the backend at once. Here's why it happens and how to stop it.
Time to First Byte (TTFB) Explained: TTFB measures the delay between a browser's request and the first byte of the response — a signal for server, network, and routing latency.
Time-Series Databases Explained: A time-series database is optimized for timestamped data — metrics, sensor readings, prices. How it differs from general-purpose databases.
Timing Attack: A timing attack infers secret data by measuring how long an operation takes to run. How timing side channels leak information and how to close them.
TLB: A TLB is a small CPU cache that stores recent virtual-to-physical address translations, avoiding a slow page-table walk on every memory access.
Tokenization in LLMs: Tokenization is how a language model chops text into tokens — the units it actually reads and bills. How it works, why words split oddly, and why it matters.
Top-Level Await in JavaScript: Top-level await lets a JavaScript module pause at import time without wrapping code in an async function. How it works and when it bites.
Topological Sort Explained: Topological sort orders the nodes of a directed acyclic graph so every dependency comes before what depends on it. How it works and where it's used.
toSorted, toReversed, with(): toSorted(), toReversed(), toSpliced(), and with() copy an array instead of mutating it, fixing a long-standing footgun in JavaScript's Array API.
TOTP: TOTP generates a new six-digit code every 30 seconds from a shared secret and the current time. How authenticator apps use it, and where it falls short.
TPM: A TPM is a dedicated chip that generates and stores cryptographic keys in hardware, isolated from the operating system. Here's what it actually does.
TPU: A TPU is a chip built specifically for the matrix math behind neural networks, using a systolic array instead of a general-purpose GPU pipeline.
Transformer: The transformer is the architecture behind modern LLMs. How attention, tokens, and stacked layers combine to make today's AI work.
Traveling Salesman Problem: The traveling salesman problem asks for the shortest route visiting every city once — a classic NP-hard problem with major real-world stakes.
Treasury Bills (T-Bills): Treasury bills are short-term government debt sold at a discount to face value, with the difference functioning as the interest paid to the holder.
Treasury Stock: Treasury stock is a company's own shares it has repurchased and holds rather than retired, recorded as a contra-equity line that reduces shareholders' equity.
Tree Shaking: Tree shaking removes unused exports from a JavaScript bundle at build time, shrinking file size by relying on ES module static structure.
Trie: A trie stores strings by sharing common prefixes across tree branches, making prefix lookups and autocomplete fast. How it compares to hash tables and BSTs.
tRPC: tRPC lets TypeScript clients call server functions with full type inference and no schema or codegen step. How it works and where it fits.
Trusted Types API: The Trusted Types API blocks DOM-based XSS by forcing risky DOM sinks like innerHTML to accept only vetted objects instead of raw strings.
tsconfig.json: tsconfig.json controls how TypeScript checks and compiles your code. Here are the options that actually change behavior, and the ones you can leave alone.
Turing Machine: A Turing machine is a simple abstract model of computation — a tape, a head, and a set of rules — that defines what it means for something to be computable.
Twelve-Factor App Methodology Explained: The twelve-factor app is a set of principles for building portable, scalable cloud software. Each factor explained, and why they still hold up today.
Two Pointers Technique Explained: Two pointers walk a sorted array or string from both ends (or in tandem) to solve problems in one linear pass instead of nested loops.
Two-Phase Commit (2PC): Two-phase commit coordinates a transaction across multiple databases with a prepare phase and a commit phase, trading availability for strong consistency.
TypeScript Abstract Classes: Abstract classes in TypeScript define shared implementation plus methods subclasses must fill in. How they differ from interfaces and when to reach for them.
TypeScript Branded Types Explained: Branded types attach a compile-time-only tag to a primitive so TypeScript rejects mixing values that share a shape but not a meaning.
TypeScript Conditional Types Explained: Conditional types let TypeScript pick a type based on another type, using T extends U ? X : Y — the foundation of most advanced type utilities.
TypeScript Declaration Files (.d.ts) Explained: A .d.ts file describes a library's types without its implementation. How TypeScript declaration files work, and how to write one for an untyped JS package.
TypeScript Declaration Merging Explained: Declaration merging lets TypeScript combine multiple declarations of the same name into one — the mechanism behind extending interfaces and global types.
TypeScript Decorators: TypeScript decorators attach reusable behavior to classes and members with an @ syntax. How class, method, and field decorators work, with real examples.
TypeScript Discriminated Unions Explained: A discriminated union tags each variant of a type with a shared literal field, letting TypeScript narrow the type automatically inside a switch or if check.
TypeScript Enums Explained (and When to Avoid Them): TypeScript enums group named constants under one type. How numeric, string, and const enums compile, and when a union type is the better choice.
TypeScript Function Overloads Explained: TypeScript function overloads let one function name accept multiple call signatures with different types. How overload signatures work and when to use them.
TypeScript Generics Explained: TypeScript generics let functions and types work with any type while preserving the specific type used at each call site, avoiding both duplication and any.
TypeScript Index Signatures Explained: An index signature lets a TypeScript type describe objects whose keys aren't known in advance. How the syntax works, and when to reach for a Record instead.
TypeScript Mapped Types Explained: Mapped types transform one type into another by iterating over its keys — the mechanism behind Partial, Readonly, Record, and Pick under the hood.
TypeScript Module Resolution Explained: TypeScript's moduleResolution setting decides how import paths map to files. How node10, node16, and bundler resolution differ, and which to pick.
TypeScript readonly Modifiers Explained: TypeScript's readonly keyword blocks reassignment at compile time for properties, arrays, and tuples — with no runtime enforcement at all.
TypeScript satisfies Operator: TypeScript's satisfies operator checks a value against a type without widening or erasing its inferred literal type. Here's when to reach for it.
TypeScript Template Literal Types Explained: Template literal types let TypeScript build string types from other types, like JavaScript template strings. How they work, with practical patterns.
TypeScript Tuple Types Explained: A TypeScript tuple is a fixed-length array where each position has its own type. How tuples work, labeled elements, and when to use them over arrays.
TypeScript Type Guards: Type guards are functions and checks that narrow a TypeScript union to a specific type at runtime. How typeof, instanceof, in, and custom guards work.
TypeScript Utility Types: TypeScript utility types like Partial, Pick, Omit, and Record transform existing types instead of redeclaring them. How the common ones work, with examples.
TypeScript Variance Explained: Variance decides when TypeScript accepts Array<Dog> where Array<Animal> is expected — covariant, contravariant, or invariant, explained with examples.
TypeScript's `as const`: TypeScript's as const assertion locks a value to its literal, readonly type instead of widening it. How it works and when to reach for it.
TypeScript's never Type: never represents values that can't exist — it marks unreachable code, exhaustive switches, and functions that always throw or loop forever.
Typosquatting: Typosquatting publishes malicious packages under names that look like popular ones, hoping developers mistype an install command. How it works.

U

UCIe: UCIe is an open standard for wiring chiplets from different vendors into one package, defining the physical layer, protocols, and packaging it needs.
UEFI: UEFI is the firmware that initializes hardware and boots the OS on modern computers, replacing BIOS with faster boot times, larger disk support, and Secure Boot.
Unicorn Startup: A unicorn is a privately held startup valued at $1 billion or more, based on its most recent funding round — not its revenue or profit.
Union-Find (Disjoint Set) Explained: Union-find tracks a collection of disjoint sets and answers 'are these two items connected?' in near-constant time. How it works and where it's used.
URL API in JavaScript: The URL API parses, builds, and validates URLs natively in JavaScript — no regex needed. How URL and URLSearchParams work, with practical examples.

V

Variable Fonts: A variable font packs every weight, width, and style into a single file, controlled with CSS — cutting requests and enabling fluid typography.
Vector Clocks: A vector clock is a per-node counter array that lets distributed systems tell whether one event happened before another, without a shared clock.
Vector Database: A vector database stores embeddings and finds information by meaning, not keywords — the backbone of AI search and RAG. Here's how vector databases work.
Vector Embeddings: A vector embedding turns text, images, or audio into numbers where similar meanings land close together — the foundation of semantic search and RAG.
Vector Quantization: Vector quantization compresses high-dimensional embeddings into compact codes, shrinking memory and search cost with a small accuracy trade-off.
Venture Debt: Venture debt is a loan for VC-backed startups that adds runway without diluting equity, usually paired with a recent funding round.
Vesting: Vesting is the schedule by which an employee earns full ownership of granted equity over time. How cliffs, vesting periods, and acceleration work.
Virtual DOM: The virtual DOM is an in-memory copy of the UI tree that frameworks diff against the previous version to batch and minimize real DOM updates.
Virtual Memory: Virtual memory gives every process its own private address space, mapped to physical RAM by the OS and CPU — enabling isolation, swapping, and overcommit.
Virtual Scrolling: Virtual scrolling renders only the rows visible in the viewport, keeping the DOM small so lists with tens of thousands of items stay smooth.
Vision Transformer (ViT): A Vision Transformer applies the transformer architecture to images by splitting them into patches processed with self-attention instead of convolutions.
Vision-Language Model (VLM): A vision-language model processes images and text together, jointly grounding visual content in language. How VLMs are trained and what they're used for.
Vite: Vite serves source over native ES modules in development and bundles with Rollup for production. Why it replaced Webpack for most front-end projects.
VPC: A VPC is an isolated, software-defined network inside a public cloud. How subnets, routing, and security groups fit together to keep resources private.
VPC Endpoint: A VPC endpoint gives a private network direct access to a cloud service without routing traffic through the public internet or a NAT gateway.
VPC Peering: VPC peering connects two virtual private clouds so resources in each can talk over private IPs, without traffic ever touching the public internet.
VPN: A VPN encrypts traffic between your device and a remote server, tunneling it through an untrusted network. How VPN tunneling and encryption work.

W

WACC: WACC blends a company's cost of equity and cost of debt into one discount rate, used to value cash flows and judge whether a project clears its hurdle.
WAF: A WAF is a filter sitting in front of a web app that inspects HTTP traffic for attack patterns like SQL injection and blocks malicious requests.
Wafer-Scale Integration Explained: Wafer-scale integration builds one giant chip from an entire silicon wafer instead of cutting it into dies. How it works and its tradeoffs.
Wash Sale: A wash sale disallows a tax loss when you rebuy a substantially identical security within 30 days before or after selling it at a loss.
Watering Hole Attack: A watering hole attack compromises a site its targets already trust, then waits for victims to visit — rather than phishing them directly.
WeakMap and WeakRef in JavaScript: A WeakMap holds object keys without blocking garbage collection, unlike a regular Map. How WeakMap and WeakRef work and when to reach for them.
Web Animations API: The Web Animations API lets JavaScript create and control animations natively, combining CSS-animation performance with imperative, scriptable control.
Web Components: Web Components are browser-native APIs for building reusable, encapsulated custom elements that work in any framework, or none at all.
Web Locks API: The Web Locks API lets JavaScript acquire named locks shared across tabs, so only one tab does work like a token refresh or a write at a time.
Web Push Notifications: The Push API lets a web app send notifications through a service worker, even when the site isn't open in a browser tab. Here's the full flow.
Web Share API: The Web Share API lets a web page open the device's native share sheet to send text, links, or files to other apps, no clipboard hack required.
Web Streams API: The Streams API lets JavaScript process data as chunks arrive instead of buffering it all in memory. How ReadableStream, WritableStream, and pipes work.
Web Worker: A web worker runs JavaScript on a background thread, freeing the main thread to keep the UI responsive. How workers communicate and when to use one.
Webhook: A webhook is an HTTP callback that notifies your server the moment something happens — no polling. How webhooks work and how to use them safely.
WebRTC: WebRTC lets browsers stream audio, video, and data directly between peers — no plugins. How getUserMedia, RTCPeerConnection, and ICE/STUN/TURN fit together.
WebSocket: A WebSocket is a protocol for full-duplex, persistent communication over a single TCP connection. Learn how it works, when to use it, and what the alternatives are.
WebTransport: WebTransport is a browser API for low-latency, bidirectional client-server messaging over HTTP/3. How it works and when to reach for it.
Why 0.1 + 0.2 Doesn't Equal 0.3: Floating-point numbers can't represent most decimals exactly in binary — that's why 0.1 + 0.2 gives 0.30000000000000004, and what IEEE 754 actually stores.
Why LLMs Hallucinate, and How to Reduce It: An LLM hallucination is a fluent, confident output that is factually wrong — a byproduct of next-token prediction, not a bug you can simply patch.
Wi-Fi 6E vs Wi-Fi 7 Explained: Wi-Fi 6E opened the 6 GHz band; Wi-Fi 7 adds Multi-Link Operation and wider channels on top of it. How the two standards actually differ.
Wide-Column Database: A wide-column database stores data in column families keyed by row, built for massive write throughput and horizontal scale across many machines.
Working Capital: Working capital is current assets minus current liabilities — a measure of whether a company can cover its near-term bills without raising new cash.
World Model in AI: A world model is an AI system's internal simulation of how its environment changes, letting it predict outcomes before acting.
Write Amplification: Write amplification is when a system writes more data physically than the logical write requested, wearing out storage faster and hurting throughput.
Write-Ahead Logging (WAL): Write-ahead logging records changes to a log before applying them to a database, making crash recovery and replication possible. Here's how it works.

X

XSS: Cross-site scripting (XSS) injects malicious scripts into pages other users view. How stored, reflected, and DOM-based XSS work, and how to prevent them.

Y

Yield Curve: A yield curve plots bond yields against their maturities, and its shape signals what investors expect about growth, inflation, and interest rates.

Z

Z-Algorithm for String Matching: The Z-algorithm builds a Z-array in linear time to find every occurrence of a pattern in a text — a fast alternative to naive string search.
Z.ai: Z.ai is the global brand of Zhipu AI, the Chinese lab behind the open-weight GLM models. Here's what Z.ai is, the GLM lineup, and why it matters.
Zero Trust Security: Zero trust security treats every user, device, and request as untrusted until verified. Core principles, ZTNA vs VPN, and a practical adoption path.
Zero-Coupon Bond: A zero-coupon bond pays no periodic interest — it's sold at a discount to face value and pays that full face value at maturity instead.
Zero-Day Vulnerability: A zero-day vulnerability is a software flaw attackers can exploit before the vendor knows it exists or has shipped a fix. How zero-days are found and closed.
Zero-Knowledge Proof: A zero-knowledge proof lets one party prove a statement is true without revealing why — the basis of privacy-preserving verification systems.

Missing a term you expected? Try the site search — or suggest it and we'll add it to the explainer queue.