Tech Glossary

Every core term we've explained, A to Z — 440 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 Operator: A Kubernetes operator encodes operational knowledge into software, automating tasks a human admin would otherwise do by hand for a specific application.
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.

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.
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.
Poison Pill: A poison pill lets shareholders buy discounted shares once an acquirer crosses an ownership threshold, diluting that stake to deter hostile takeovers.
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.
PostgreSQL: PostgreSQL is a powerful, open-source relational database known for reliability and extensibility. Learn how Postgres works and why developers love it.
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.
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.
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.

A

AbortController: AbortController lets JavaScript cancel an in-flight fetch or async task on demand, preventing stale responses from overwriting newer state.
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 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 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.
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.
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 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.

B

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.
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.
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.
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.
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 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.
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.
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.

C

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.
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.
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.
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.
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.
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.
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.
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.
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 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.
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.
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.
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.
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: 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 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 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 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 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-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 Logical Properties: CSS logical properties like margin-inline and padding-block size and space elements relative to writing direction, not fixed physical sides.
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 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 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 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 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.
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.
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

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.
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.
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.
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.
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.
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.
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.
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.
DNSSEC: DNSSEC adds cryptographic signatures to DNS records so resolvers can verify responses weren't forged or tampered with in transit.
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.
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.
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.
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.

E

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.
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.
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.
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.

F

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.
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.
Firewall: A firewall filters network traffic against a ruleset, blocking connections that don't match. How packet filters, stateful inspection, and NGFWs differ.
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.
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

Git: Git is a distributed version control system that tracks changes to code and enables collaboration. Learn the core concepts and everyday workflow.
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.
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.
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.
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

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: High-Bandwidth Memory stacks DRAM dies vertically beside the processor, delivering far more bandwidth than DDR5 or GDDR — and AI hardware depends on it.
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.
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.
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 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.
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.

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.
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.
IndexedDB: IndexedDB is a browser API for storing large amounts of structured data client-side, with indexes, transactions, and no size limit like localStorage.
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.
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.

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 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 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 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 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 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 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's this Keyword: How JavaScript determines what this refers to: default, implicit, explicit, and new binding, plus why arrow functions behave differently.
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.
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.
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 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.
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.
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.
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

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.
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 Maker: A market maker quotes buy and sell prices continuously, profiting from the spread while providing the liquidity that keeps markets tradeable.
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 Interleaving: Memory interleaving spreads consecutive addresses across multiple memory banks so the system can access them in parallel instead of one at a time.
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.
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 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.
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.
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.
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.
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.
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.
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.
Observability: Observability is the ability to understand a system's internal state from its external outputs — built from logs, metrics, and traces working together.
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.
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.
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

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.

R

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.
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.
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 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.
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.
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.
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.
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.
Reverse Proxy: A reverse proxy sits in front of servers, forwarding client requests and hiding backend topology. TLS termination, caching, and load balancing explained.
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.
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 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
structuredClone(): structuredClone() is a built-in JavaScript function for deep-copying values, including cycles and typed arrays, without the workarounds JSON tricks require.
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.
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.
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.
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.
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 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.
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.
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.
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.
Transformer: The transformer is the architecture behind modern LLMs. How attention, tokens, and stacked layers combine to make today's AI work.
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.
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.
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.
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 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 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 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 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 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'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

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.
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.

V

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.
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.
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.
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

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.
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 Components: Web Components are browser-native APIs for building reusable, encapsulated custom elements that work in any framework, or none at all.
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 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.
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.
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.
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.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-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.