Developer Glossary
Plain-English definitions of programming terms — variables, functions, the DOM, promises, and more. Search, browse by topic, or jump to a letter.
600 terms total
600 / 600
Browse by Topic
Terms grouped by concept area.
Programming Basics
60 terms
Programming terminology
-
Variable
A variable is a named container for storing data that can change while your program runs.
-
Constant
A constant is a named value that, once set, cannot be changed while the program runs.
-
Data Type
A data type tells the computer what kind of value a variable holds — text, number, true/false, and so on.
-
String
A string is a sequence of characters — text — enclosed in quotes, like "hello" or "Ada Lovelace".
-
Integer
An integer is a whole number — positive, negative, or zero — with no fractional or decimal part.
-
Boolean
A boolean is a value that can only be true or false — used for making decisions in code.
-
Function
A function is a reusable block of code that performs a task, optionally taking inputs and returning a result.
-
Parameter
A parameter is a named placeholder in a function definition that receives a value when the function is called.
-
Argument
An argument is the actual value you pass into a function when you call it, filling the parameter's slot.
-
Array
An array is an ordered list of values stored under a single name, accessed by their position (index).
-
Loop
A loop is a construct that repeats a block of code multiple times, either a fixed number or until a condition is met.
-
Scope
Scope is the region of your program where a variable is visible and can be used.
-
Object
An object is a collection of key-value pairs that groups related data and behavior under a single name.
-
Condition
A condition is an expression that evaluates to true or false, determining which branch of code executes.
-
Iteration
Iteration is the process of repeating a block of code multiple times, typically to process each item in a collection.
-
Recursion
Recursion is when a function calls itself to solve a smaller version of the same problem until a base case is reached.
-
Module
A module is a self-contained unit of code that can be imported and reused by other parts of a program.
-
Comment
A comment is text in your code that is ignored by the computer — it exists to explain the code to human readers.
-
Operator
An operator is a symbol that performs an operation on one or more values, like + for addition or === for comparison.
-
Expression
An expression is any piece of code that evaluates to a single value, like 2 + 3 or x * 10.
-
Statement
A statement is a single instruction that the computer executes, like assigning a variable or calling a function.
-
Keyword
A keyword is a reserved word that has special meaning in the language and cannot be used as a variable name.
-
Compiler
A compiler is a program that translates source code into machine code all at once, before the program runs.
-
Interpreter
An interpreter is a program that reads and executes source code directly, line by line, at runtime.
-
Algorithm
An algorithm is a finite sequence of well-defined steps that solve a specific problem or perform a task.
-
Debugging
Debugging is the process of finding, understanding, and fixing errors (bugs) in your code.
-
Syntax
Syntax is the set of grammar rules that define the correct structure of code in a programming language.
-
Pseudocode
Pseudocode is an informal, human-readable description of an algorithm that uses code-like structure without strict syntax.
-
Flowchart
A flowchart is a visual diagram that represents the flow of control in an algorithm using shapes and arrows.
-
Time Complexity
Time complexity describes how an algorithm's runtime grows as the input size increases, expressed in Big O notation.
-
Memory
Memory is the temporary storage where a program keeps its data and instructions while running.
-
Pointer
A pointer is a variable that stores the memory address of another value, rather than the value itself.
-
Programming Paradigm
A programming paradigm is a style or philosophy of writing code, like imperative, declarative, or object-oriented.
-
Encapsulation
Encapsulation is the practice of bundling data and the methods that operate on it together, while hiding internal details.
-
Inheritance
Inheritance is a mechanism where a new class derives properties and methods from an existing class.
-
Polymorphism
Polymorphism means the same operation can behave differently depending on the type of object it is applied to.
-
Abstraction
Abstraction is the practice of hiding complex implementation details behind a simple, easy-to-use interface.
-
API
An API (Application Programming Interface) is a set of rules that defines how different software components communicate with each other.
-
Exception
An exception is an error that occurs during program execution and can be caught and handled with try/catch.
-
Callback
A callback is a function passed as an argument to another function, to be called later when an event or operation completes.
-
Design Pattern
A design pattern is a proven, reusable solution to a commonly occurring problem in software design.
-
Singleton Pattern
The Singleton pattern restricts a class to a single instance and provides a global access point to it.
-
Factory Pattern
The Factory pattern defines an interface for creating objects without specifying their concrete class at the call site.
-
Observer Pattern
The Observer pattern lets one object (subject) notify a list of dependents (observers) automatically when its state changes.
-
Decorator Pattern
The Decorator pattern wraps an object to add new behavior without modifying the original object's code.
-
Strategy Pattern
The Strategy pattern defines a family of interchangeable algorithms and lets the client choose one at runtime.
-
Linked List
A linked list is a linear data structure where each element (node) points to the next, instead of using contiguous memory.
-
Stack
A stack is a LIFO (Last-In-First-Out) data structure: the last item added is the first one removed.
-
Queue
A queue is a FIFO (First-In-First-Out) data structure: the first item added is the first one removed.
-
Tree
A tree is a hierarchical data structure where each node has one parent and zero or more children, starting from a root.
-
Graph
A graph is a data structure of nodes (vertices) connected by edges, modeling relationships between entities.
-
Hash Table
A hash table stores key-value pairs and uses a hash function to compute an index, enabling fast O(1) average lookup.
-
Sorting Algorithm
A sorting algorithm rearranges elements of a collection into a defined order (ascending, descending, or custom).
-
Searching Algorithm
A searching algorithm finds the position (or existence) of a target value within a collection of data.
-
Dynamic Programming
Dynamic programming solves complex problems by breaking them into overlapping sub-problems and caching their results.
-
Greedy Algorithm
A greedy algorithm makes the best local choice at each step, hoping to find a globally optimal solution.
-
Big O Notation
Big O notation describes how an algorithm's runtime or memory grows relative to input size, ignoring constants.
-
Memoization
Memoization caches the result of expensive function calls and returns the cached value on repeated inputs.
-
Tail Call Optimization
Tail call optimization (TCO) reuses the current stack frame when a function's last action is a recursive call, preventing stack overflow.
-
Immutability
Immutability means an object's state cannot be modified after it is created; changes produce a new object instead.
Web Development
60 terms
Web terminology
-
HTML
HTML (HyperText Markup Language) is the standard language used to structure the content of web pages.
-
CSS
CSS (Cascading Style Sheets) is the language used to style and lay out HTML content on a web page.
-
DOM
The DOM (Document Object Model) is a tree-like representation of an HTML document that JavaScript can read and modify.
-
Element
An HTML element is a piece of a web page defined by a start tag, content, and an end tag, like <p>Hello</p>.
-
Attribute
An HTML attribute is a name-value pair on an element tag that configures or adds extra information to it.
-
Selector
A CSS selector is a pattern that matches one or more HTML elements so you can apply styles to them.
-
Class (HTML)
The class attribute assigns a label to an HTML element so it can be styled or selected together with others.
-
ID (HTML)
The id attribute gives an HTML element a unique identifier on the page, used for styling, scripting, and anchoring.
-
HTTP
HTTP (HyperText Transfer Protocol) is the set of rules browsers and servers use to request and send web resources.
-
URL
A URL (Uniform Resource Locator) is the address that identifies a specific resource on the web.
-
Flexbox
Flexbox is a CSS layout module designed for arranging elements in one dimension (row or column) with powerful alignment capabilities.
-
CSS Grid
CSS Grid is a layout module for creating two-dimensional grids with rows and columns.
-
Box Model
The box model describes how every HTML element is a rectangular box with content, padding, border, and margin.
-
Media Query
A media query is a CSS feature that applies styles only when specific conditions about the device or viewport are met.
-
Semantic HTML
Semantic HTML uses tags that convey the meaning and purpose of content, rather than just its appearance.
-
Accessibility (a11y)
Web accessibility means designing websites so that people with disabilities can perceive, understand, navigate, and interact with them.
-
Fetch API
The Fetch API is a modern JavaScript interface for making HTTP requests to retrieve or send data from servers.
-
Event Listener
An event listener is a function that runs when a specific event (like a click or keypress) occurs on an HTML element.
-
localStorage
localStorage is a browser API that stores key-value pairs persistently on the client, surviving page reloads and browser restarts.
-
Cookie
A cookie is a small piece of data that a server sends to the browser, which is included in subsequent requests to the same server.
-
CORS
CORS is a browser security mechanism that controls which cross-origin requests are allowed from web pages.
-
XSS
XSS (Cross-Site Scripting) is a security vulnerability where an attacker injects malicious scripts into a web page viewed by other users.
-
Service Worker
A service worker is a JavaScript file that runs in the background, enabling offline support, push notifications, and caching for web apps.
-
Responsive Design
Responsive design is an approach where a website's layout and content adapt to the screen size of the device viewing it.
-
SEO
SEO (Search Engine Optimization) is the practice of improving a website to increase its visibility in search engine results.
-
REST API
A REST API is a way of designing web APIs where resources are accessed via standard HTTP methods on URLs.
-
JSON
JSON (JavaScript Object Notation) is a lightweight text format for storing and exchanging structured data.
-
Viewport
The viewport is the visible area of a web page in the browser window where content is displayed.
-
DNS
DNS (Domain Name System) is the internet's phonebook — it translates human-readable domain names into IP addresses.
-
SSL/TLS
SSL/TLS is the encryption protocol that secures communication between a browser and a server, enabling HTTPS.
-
WebSocket
WebSocket is a communication protocol that provides a persistent, bidirectional connection between a browser and a server.
-
Cache
A cache is a temporary storage that keeps frequently accessed data so it can be served faster without re-fetching from the original source.
-
Content Security Policy (CSP)
CSP is an HTTP header that restricts which resources (scripts, styles, images) a browser can load on a page, preventing XSS attacks.
-
PWA
A PWA (Progressive Web App) is a web app that uses modern APIs to provide a native-app-like experience, including offline support and installability.
-
CSS Specificity
CSS specificity is a scoring system that determines which CSS rule wins when multiple rules target the same element.
-
CSS Transition
A CSS transition smoothly interpolates a property from one value to another over a specified duration.
-
CSS Variable
A CSS variable (custom property) is a reusable value defined with --name and accessed with var(), enabling theming and DRY CSS.
-
HTTP Header
An HTTP header is a key-value pair that sends metadata about a request or response, such as content type, caching, and authentication.
-
Web Performance
Web performance is the practice of optimizing how fast a website loads and how smoothly it responds to user interaction.
-
CSRF
CSRF (Cross-Site Request Forgery) is an attack where a malicious website tricks a user's browser into making an unwanted request to a site where they are logged in.
-
WebAssembly
WebAssembly (Wasm) is a binary instruction format that runs in the browser at near-native speed, alongside JavaScript.
-
Web Worker
A Web Worker lets you run JavaScript in a background thread, keeping the main UI thread responsive.
-
IndexedDB
IndexedDB is a browser API for storing large volumes of structured, queryable data persistently on the client.
-
WebRTC
WebRTC enables real-time peer-to-peer audio, video, and arbitrary data communication directly between browsers.
-
Canvas API
The Canvas API lets you draw 2D graphics — shapes, text, images — pixel by pixel on an HTML canvas element.
-
SVG
SVG (Scalable Vector Graphics) is an XML-based format for describing two-dimensional graphics that scale without losing quality.
-
Web Components
Web Components are a set of browser standards for creating reusable, encapsulated custom HTML elements with their own behavior.
-
Shadow DOM
Shadow DOM attaches a hidden, isolated DOM subtree to an element so its styles and markup do not leak out or in.
-
Custom Elements
Custom Elements is a browser API for registering new HTML element types with custom behavior via a JavaScript class.
-
Intersection Observer
The Intersection Observer API efficiently watches elements and calls back when they enter or leave a target (usually the viewport).
-
Mutation Observer
A Mutation Observer watches a DOM subtree and reports when nodes are added, removed, or attributes change.
-
Resize Observer
The Resize Observer API calls a callback when an element's content rectangle changes size, without polling.
-
Session Storage
Session storage is a key-value store scoped to the current tab and cleared when the tab or browser is closed.
-
History API
The History API lets you read and modify the browser's session history stack, enabling SPA navigation without full reloads.
-
URL API
The URL API provides a built-in URL object for parsing, reading, and modifying the components of a URL.
-
Fetch API (Advanced)
The Fetch API is the modern interface for making HTTP requests, returning promises and supporting streams, abort, and credentials.
-
AbortController
AbortController provides a signal you pass to async operations (like fetch) so you can cancel them later.
-
Page Visibility API
The Page Visibility API lets you know when the page tab is hidden (switched away or minimized) so you can pause work.
-
Web Audio API
The Web Audio API is a graph-based system for generating, processing, and playing audio entirely in the browser.
-
Geolocation API
The Geolocation API lets the browser request the user's geographic position (latitude, longitude) with their permission.
JavaScript Basics
60 terms
JavaScript terminology
-
JavaScript
JavaScript is the programming language that runs in web browsers to make web pages interactive and dynamic.
-
Callback
A callback is a function passed into another function as an argument, to be called later when something happens.
-
Event
An event is a signal the browser sends when something happens — a click, a key press, a page load, and so on.
-
Event Listener
An event listener is a function registered to run when a specific event occurs on a specific element.
-
Object
An object is a collection of key-value pairs that groups related data and functions under a single name.
-
Promise
A promise is an object representing the eventual result of an asynchronous operation — success or failure.
-
async
The async keyword declares a function that always returns a promise, enabling await inside it.
-
await
The await keyword pauses an async function until a promise settles, then resumes with the resolved value.
-
Module
A module is a self-contained file of code that can export values and import them from other modules.
-
Expression
An expression is any piece of code that evaluates to a single value, like 2 + 3 or "Hi, " + name.
-
Variable
A variable is a named container for storing a value that can be referenced and changed later.
-
Scope
Scope is the region of code where a variable is accessible — it determines what variables you can see from a given point.
-
Function
A function is a reusable block of code that takes inputs (parameters), performs a task, and optionally returns a value.
-
Array
An array is an ordered list of values, accessed by numeric index starting at 0.
-
String
A string is a sequence of characters used to represent text, enclosed in single, double, or backtick quotes.
-
Number
A number is a numeric value — JavaScript has one number type for both integers and floating-point values.
-
Boolean
A boolean is a value that is either true or false, used for logical operations and conditionals.
-
null vs undefined
undefined means a variable has been declared but not assigned a value; null is an intentional absence of value.
-
Hoisting
Hoisting is JavaScript's behavior of moving variable and function declarations to the top of their scope before code execution.
-
Closure
A closure is a function that retains access to variables from its enclosing scope, even after the outer function has returned.
-
Prototype
A prototype is an object that other objects inherit properties and methods from, forming the prototype chain.
-
this
`this` is a keyword that refers to the object that is currently executing the code — its value depends on how the function is called.
-
Class
A class is a blueprint for creating objects with predefined properties and methods, introduced in ES6 as syntactic sugar over prototypes.
-
Destructuring
Destructuring is a syntax that unpacks values from arrays or properties from objects into distinct variables.
-
Spread / Rest
The ... syntax is 'spread' when it expands an iterable into individual elements, and 'rest' when it collects multiple elements into an array.
-
Template Literal
A template literal is a string enclosed in backticks that supports multi-line text and ${expression} interpolation.
-
Arrow Function
An arrow function is a compact function syntax using => that does not have its own this or arguments binding.
-
Map
A Map is a collection of key-value pairs where keys can be of any type, maintaining insertion order.
-
Set
A Set is a collection of unique values — duplicates are automatically removed.
-
Symbol
A Symbol is a primitive value that is guaranteed to be unique, often used as object property keys to avoid collisions.
-
Iterator
An iterator is an object that provides a sequence of values one at a time via a next() method.
-
Generator
A generator is a function declared with function* that can pause execution with yield and resume later, producing a sequence of values.
-
Event Loop
The event loop is the mechanism that lets JavaScript perform non-blocking async operations despite being single-threaded.
-
Microtask
A microtask is a short function that runs after the current task completes but before the next macrotask — primarily Promise callbacks.
-
JSON
JSON (JavaScript Object Notation) is a lightweight text format for storing and exchanging data, based on JavaScript object syntax.
-
Regular Expression
A regular expression (regex) is a pattern used to match, search, and replace text.
-
Error
An Error is an object thrown when something goes wrong, containing a message and stack trace.
-
try/catch
try/catch is a construct that lets you attempt code that may throw an error and handle it gracefully instead of crashing.
-
Module Pattern
The module pattern uses closures to create private variables and public methods, encapsulating implementation details.
-
Strict Mode
Strict mode is an opt-in mode that makes JavaScript stricter, catching common mistakes as errors instead of silent failures.
-
Proxy
A Proxy wraps an object and lets you intercept fundamental operations like get, set, and has via handler traps.
-
Reflect
Reflect is a built-in object providing static methods that correspond to the fundamental object operations interceptable by Proxy.
-
WeakMap
A WeakMap is a collection of key-value pairs where keys are objects and weakly held, allowing garbage collection.
-
WeakSet
A WeakSet is a collection of unique objects held weakly, so entries can be garbage collected.
-
FinalizationRegistry
FinalizationRegistry lets you register a callback that runs when a registered object is garbage collected.
-
ArrayBuffer
An ArrayBuffer is a fixed-length chunk of raw binary memory, accessed through typed array views.
-
SharedArrayBuffer
A SharedArrayBuffer is a binary buffer whose memory can be shared between the main thread and Web Workers simultaneously.
-
Atomics
Atomics provides static methods for thread-safe, atomic read-modify-write operations on SharedArrayBuffer.
-
BigInt
BigInt is a numeric type for integers of arbitrary size, beyond the safe limit of the Number type.
-
Numeric Separator
Numeric separators (underscores) let you group digits in number literals for readability without changing the value.
-
Optional Chaining
Optional chaining (?.) accesses a property only if the left side is not null or undefined, otherwise returns undefined.
-
Nullish Coalescing
The nullish coalescing operator (??) returns the right side when the left is null or undefined, otherwise the left.
-
Logical Assignment
Logical assignment operators (||=, &&=, ??=) combine a logical check with assignment in one operator.
-
Top-level Await
Top-level await lets you use the await keyword at the top level of an ES module, without wrapping it in an async function.
-
Dynamic Import
Dynamic import() is an expression that loads an ES module on demand at runtime, returning a promise.
-
Tagged Template
A tagged template applies a function (tag) to a template literal, receiving the string parts and interpolated values separately.
-
Symbol.iterator
Symbol.iterator is the well-known symbol that defines an object's default iterator, enabling for...of and spread syntax.
-
Promise.all
Promise.all takes an iterable of promises and resolves with an array of results when all fulfill, or rejects on the first rejection.
-
Promise.race
Promise.race takes an iterable of promises and settles (resolves or rejects) as soon as the first one settles.
-
AggregateError
AggregateError is an Error subclass that holds an array of multiple errors, used by Promise.any when all promises reject.
Git Basics
60 terms
Git terminology
-
Repository
A repository (repo) is a folder Git tracks — it stores your project's files and the full history of changes.
-
Commit
A commit is a snapshot of your project's files at a moment in time, saved to the repository history.
-
Branch
A branch is an independent line of development that lets you work on changes without affecting the main history.
-
Merge
Merging combines the changes from one branch into another, uniting two lines of development.
-
Clone
Cloning downloads a remote repository to your local machine, including its full history and remote link.
-
Remote
A remote is a named reference to a repository hosted elsewhere (e.g. on GitHub) that you can push to and pull from.
-
Push
Pushing uploads your local commits to a remote repository so others can see and pull them.
-
Pull
Pulling downloads commits from a remote repository and merges them into your current local branch.
-
HEAD
HEAD is a pointer to the currently checked-out commit — it tells Git where you are in the history.
-
Staging Area
The staging area (index) is a middle ground where you place changes before committing them — it lets you choose exactly what to include in each commit.
-
Working Directory
The working directory is the folder on your disk where you see and edit your project files — it is your live workspace.
-
Fetch
Fetching downloads commits and updates from a remote without merging them into your working branch — it is a safe, read-only sync.
-
Rebase
Rebasing replays your branch's commits on top of another branch, creating a linear history without merge commits.
-
Cherry-pick
Cherry-picking applies the changes from one specific commit to your current branch, without merging the entire source branch.
-
Stash
Stashing temporarily saves your uncommitted changes in a stack, cleaning your working directory so you can switch context.
-
Tag
A tag is a named pointer to a specific commit, typically used to mark release versions like v1.0.0.
-
Diff
A diff shows the exact lines that were added, removed, or changed between two versions of your files.
-
Revert
Reverting creates a new commit that undoes the changes of a specified commit, preserving the original history.
-
Reset
Reset moves the current branch pointer to a different commit, effectively rewinding history. The three modes control what happens to staged and working files.
-
Fork
A fork is a server-side copy of a repository under your own account, linked to the original for pull requests.
-
Pull Request
A pull request (PR) is a proposal to merge changes from one branch into another, with code review and discussion before the merge.
-
Origin
Origin is the conventional name for the default remote repository — it is the remote that git clone sets up automatically.
-
Upstream
Upstream is the conventional name for the remote pointing to the original repository you forked from.
-
Fast-forward
A fast-forward merge happens when the target branch has not advanced since the source branch was created — Git simply moves the pointer forward without a merge commit.
-
Detached HEAD
Detached HEAD means HEAD points directly to a commit instead of a branch — commits you make will not belong to any branch and could be lost.
-
.gitignore
A .gitignore file lists patterns for files and directories that Git should intentionally not track.
-
Bare Repository
A bare repository has no working directory — it only contains the .git data. It is used as a remote for pushing and pulling.
-
Hash (SHA-1)
A hash is a unique 40-character SHA-1 checksum that identifies a commit, tree, or blob in Git.
-
Master vs Main
Main and master are both conventional names for the default branch. Main is the modern standard, replacing master for inclusive language.
-
Merge Conflict
A merge conflict occurs when two branches change the same lines of the same file and Git cannot decide which version to keep.
-
Hook
Git hooks are custom scripts that Git automatically executes at specific points in the workflow, like before a commit or after a merge.
-
Submodule
A submodule is a repository embedded inside another repository — it lets you include a foreign repo as a subdirectory while keeping it as its own repo.
-
Reflog
The reflog is a local log of every HEAD and branch pointer movement — it is your safety net for recovering "lost" commits.
-
Bisect
Bisect uses binary search to find the exact commit that introduced a bug, by testing commits between a known-good and known-bad state.
-
Blame
Git blame shows the commit and author for each line of a file — it answers 'who wrote this line and when?'
-
Worktree
A worktree is an additional working directory linked to the same repository, letting you work on multiple branches simultaneously without cloning.
-
Force Push
Force pushing overwrites the remote branch with your local history, potentially destroying commits that others have pushed.
-
Squash
Squashing combines multiple commits into a single commit, often used before merging to keep history clean.
-
Amend
Amending modifies the last commit — it can add forgotten changes or change the commit message without creating a new commit.
-
Git Flow
Git Flow is a branching model with dedicated branches for features, releases, and hotfixes, providing a structured workflow for releases.
-
Git Config
git config sets Git options at system, global (user), or repository level, controlling identity, aliases, and behavior.
-
Git Alias
A git alias is a custom shortcut defined in git config that expands to a longer Git command or sequence.
-
Git Attributes
The .gitattributes file assigns attributes to paths, controlling line endings, diff, merge, and export behavior per file.
-
Git LFS
Git LFS (Large File Storage) replaces large files in the repo with text pointers, storing the actual content on a separate server.
-
Conventional Commits
Conventional Commits is a specification for structured commit messages that enable automated changelogs and semantic versioning.
-
Semantic Versioning
Semantic Versioning (SemVer) numbers releases as MAJOR.MINOR.PATCH, where each segment signals the kind of change.
-
Pre-commit Hook
A pre-commit hook is a script Git runs before creating a commit, able to reject the commit if checks fail.
-
Commit Message Convention
A commit message convention is a set of rules for structuring commit messages so history is readable and automatable.
-
Git Stash Pop
git stash pop reapplies the most recent stashed changes to the working tree and removes them from the stash list.
-
Git Clean
git clean removes untracked files and directories from the working directory, complementing git reset for tracked files.
-
Git Restore
git restore discards uncommitted changes in the working tree or restores files from a specific commit, replacing git checkout for this purpose.
-
Git Switch
git switch is the modern (Git 2.23+) command for changing or creating branches, replacing git checkout for branch operations.
-
Sparse Checkout
A sparse checkout populates the working tree with only a subset of the repo's files, based on path patterns.
-
Partial Clone
A partial clone downloads the repo's structure but omits some file contents (blobs), fetching them on demand.
-
Git Bundle
git bundle packs commits and refs into a single binary file that can be cloned or fetched from, useful offline.
-
Git Notes
git notes attaches extra content to existing commits via a separate ref, leaving the original commit untouched.
-
Git Describe
git describe produces a human-readable name for the current commit based on the nearest annotated tag.
-
Git Archive
git archive exports a tree (commit, branch, or path) as a tar or zip file, without the .git directory.
-
Git Refspec
A refspec is a mapping that tells Git which local and remote refs correspond during push and fetch operations.
-
Git Worktree Add
git worktree add creates a linked working tree for another branch, letting you work on multiple branches in parallel without cloning.
Python Basics
60 terms
Python terminology
-
Python
Python is a high-level, readable programming language known for its simple syntax and broad use.
-
List
A list is an ordered, mutable collection of items in Python, written as [1, 2, 3].
-
Tuple
A tuple is an ordered, immutable collection of items in Python, written as (1, 2, 3).
-
Dictionary
A dictionary is a collection of key-value pairs in Python, written as {"key": value}, for fast lookups by key.
-
Python Module
A module is a .py file containing Python code that can be imported and reused in other files.
-
Package
A package is a folder of Python modules with an __init__.py file, letting you import them as a group.
-
Exception
An exception is an error that occurs while your program runs, which you can catch and handle with try/except.
-
Indentation
Indentation is the leading whitespace before a line of code. In Python, it defines code blocks instead of braces.
-
Variable
A variable is a named reference to a value stored in memory, created with the = assignment operator.
-
Function
A function is a reusable block of code defined with def that takes inputs (parameters) and returns an output.
-
Parameter
A parameter is a named variable in a function definition that receives a value (argument) when the function is called.
-
String
A string is an immutable sequence of characters in Python, written with single or double quotes.
-
Integer
An integer (int) is a whole number without a decimal point, like 42 or -7.
-
Float
A float (floating-point number) is a number with a decimal point, like 3.14 or -0.5.
-
Boolean
A boolean (bool) is a type with two values: True or False, used for logic and conditions.
-
Loop
A loop is a control structure that repeats a block of code, either a fixed number of times (for) or while a condition is true (while).
-
Condition
A condition is an expression that evaluates to True or False, used to control which branch of code executes.
-
Class
A class is a blueprint for creating objects, defined with the class keyword, that bundles data (attributes) and behavior (methods).
-
Object
An object is a specific instance of a class, containing its own data (attributes) and behavior (methods).
-
Method
A method is a function defined inside a class that operates on an instance of that class via self.
-
Attribute
An attribute is a named value stored on an object, accessed with dot notation (obj.attribute).
-
Scope
Scope is the region of code where a variable name is visible and accessible.
-
Argument
An argument is the actual value passed to a function when calling it, filling the function's parameters.
-
Return
The return statement sends a value back to the caller and ends the function. Without it, the function returns None.
-
Iterator
An iterator is an object that produces values one at a time using __next__(), enabling lazy evaluation of sequences.
-
Comprehension
A comprehension is a compact syntax for creating lists, dicts, or sets from an iterable in a single expression.
-
Decorator
A decorator is a function that takes another function and returns a modified version, applied with the @ syntax.
-
Generator
A generator is a function that produces values lazily using yield, pausing between each value until the next is requested.
-
Lambda
A lambda is a small anonymous function defined in a single expression, written as lambda params: expression.
-
Virtual Environment
A virtual environment is an isolated Python environment with its own packages, separate from the system Python.
-
PIP
pip is Python's package installer, used to install and manage third-party packages from PyPI.
-
F-string
An f-string is a string prefixed with f that embeds expressions in curly braces for inline formatting.
-
Slice
A slice extracts a portion of a sequence using [start:stop:step] syntax.
-
None
None is Python's null value — a singleton representing the absence of a value.
-
Global
Global refers to variables defined at module level, and the global keyword lets functions modify them.
-
Docstring
A docstring is a string literal as the first statement in a module, function, or class, used for documentation.
-
Assertion
An assertion (assert) checks a condition at runtime and raises AssertionError if it is false, used for debugging.
-
Context Manager
A context manager is an object that manages setup and teardown (cleanup) around a block of code, used with the with statement.
-
Type Hint
Type hints are optional annotations that declare the expected types of variables, parameters, and return values.
-
Garbage Collection
Garbage collection is Python's automatic memory management that frees memory occupied by objects no longer in use.
-
Metaclass
A metaclass is a class whose instances are classes. It controls class creation and behavior.
-
Dataclass
@dataclass auto-generates boilerplate methods (__init__, __repr__, __eq__) for data-heavy classes.
-
Async/Await
async/await lets you write non-blocking concurrent code that looks like sequential code using coroutines.
-
Coroutine
A coroutine is a function defined with 'async def' that can pause at 'await' and resume later.
-
asyncio
asyncio is the stdlib module providing the event loop and primitives for async programming.
-
Threading
threading runs multiple threads in one process — good for I/O-bound work, limited for CPU-bound due to GIL.
-
Multiprocessing
multiprocessing runs separate processes with independent memory, enabling true multi-core CPU parallelism.
-
GIL (Global Interpreter Lock)
The GIL is a lock in CPython ensuring only one thread runs Python bytecode at a time, limiting threading parallelism.
-
Pickle
pickle converts Python objects to bytes (and back) for saving to files or sending over networks.
-
Enum
Enum creates named constants — replacing magic numbers/strings with readable, type-safe symbolic names.
-
Named Tuple
namedtuple creates immutable, indexable records with named fields — lightweight alternative to dataclass.
-
Abstract Base Class (ABC)
An ABC is a class with @abstractmethod decorators that cannot be instantiated until all abstract methods are implemented.
-
Magic Method
Magic methods are __dunder__ methods that let your objects work with Python operators (+, len(), str(), etc.).
-
Property
@property lets you access a method like an attribute, enabling validation, computation, or encapsulation.
-
Static Method
@staticmethod is a class method that takes no self/cls — just a function grouped inside a class for organization.
-
Class Method
@classmethod receives cls (the class) instead of self — ideal for alternative constructors and factory methods.
-
__slots__
__slots__ declares fixed attributes, eliminating __dict__ and saving ~40-50% memory per instance.
-
yield from
'yield from sub_gen' yields every value from sub_gen, enabling clean generator delegation and composition.
-
Walrus Operator
:= (walrus operator) assigns a value to a variable AND returns it in the same expression — saves a line.
-
Match Statement
match/case is Python's pattern matching (3.10+) — like switch/case but with destructuring, type checks, and guards.
React Fundamentals
60 terms
React Fundamentals terminology
-
Component
A component is a reusable, self-contained piece of UI written as a JavaScript function that returns JSX.
-
JSX
JSX is a syntax extension for JavaScript that lets you write HTML-like markup directly inside your JavaScript code.
-
Props
Props (properties) are read-only inputs passed from a parent component to a child component to configure its behavior or content.
-
State
State is internal data a component owns and can change over time. When state changes, React re-renders the component.
-
Hook
A Hook is a special function that lets you 'hook into' React features like state and lifecycle from a function component.
-
Virtual DOM
The Virtual DOM is a lightweight in-memory representation of the real DOM that React uses to calculate the minimal set of changes before touching the browser.
-
Reconciliation
Reconciliation is the process React uses to compare the previous and next virtual DOM trees and determine the minimal set of DOM changes needed.
-
useState
useState is a Hook that lets a function component hold and update local state, returning the current value and a setter function.
-
useEffect
useEffect is a Hook that lets you perform side effects — data fetching, subscriptions, DOM manipulation — after the component renders.
-
useContext
useContext is a Hook that lets a component read and subscribe to a Context value without manually passing props through every level.
-
useReducer
useReducer is a Hook that manages state using a reducer function (like Redux) — ideal for complex state logic with multiple sub-values.
-
useRef
useRef is a Hook that returns a mutable ref object whose .current property persists across renders without causing re-renders.
-
Custom Hook
A custom Hook is a user-defined function starting with 'use' that extracts and reuses stateful logic across components.
-
Event Handler
An event handler is a function that runs in response to a user action (click, type, submit) — attached to elements via props like onClick.
-
Conditional Rendering
Conditional rendering means showing different JSX based on a condition — using if statements, ternary operators, or logical &&.
-
List Rendering
List rendering means transforming an array of data into an array of JSX elements using the .map() method.
-
Key
A key is a special string prop that uniquely identifies a list item, helping React match elements across re-renders for efficient updates.
-
Fragment
A Fragment is a special React element that groups multiple children without adding an extra wrapper DOM node.
-
Ref
A ref is an object with a .current property that holds a reference to a DOM element or a mutable value that persists across renders.
-
Context
Context is a React feature for passing data through the component tree without manually passing props at every level.
-
Portal
A portal lets you render a component's children into a DOM node that exists outside the parent's DOM hierarchy.
-
Error Boundary
An error boundary is a class component that catches JavaScript errors anywhere in its child component tree and displays a fallback UI.
-
Memoization
Memoization is an optimization technique that caches the result of expensive computations or component renders to avoid repeating work.
-
React.memo
React.memo is a higher-order component that memoizes a component, re-rendering it only when its props change.
-
useMemo
useMemo is a Hook that caches (memoizes) a computed value, recomputing it only when its dependencies change.
-
useCallback
useCallback is a Hook that returns a memoized version of a callback function, keeping the same function instance across renders.
-
Lazy Loading
Lazy loading means deferring the loading of a component until it is actually rendered, reducing the initial bundle size.
-
Suspense
Suspense is a React component that shows a fallback UI while its children are loading — used with lazy loading and data fetching.
-
React Router
React Router is a library that enables navigation between different pages/views in a React single-page application.
-
Lifecycle
Lifecycle refers to the sequence of phases a component goes through: mounting (added to DOM), updating (state/props change), and unmounting (removed from DOM).
-
Render
Render is the process of a component evaluating its props and state to produce the JSX (virtual DOM) that describes the UI.
-
Re-render
A re-render occurs when a component's state or props change, or when a parent re-renders — causing the component function to run again.
-
Pure Component
A pure component is a class component that implements shouldComponentUpdate with a shallow prop and state comparison to skip unnecessary re-renders.
-
Higher-Order Component
A higher-order component is a function that takes a component and returns a new enhanced component — a pattern for sharing logic.
-
Render Props
Render props is a pattern where a component takes a function as a prop and calls it to determine what to render — a way to share rendering logic.
-
Controlled Component
A controlled component is a form input whose value is controlled by React state — the input always reflects the state, and changes update the state.
-
Uncontrolled Component
An uncontrolled component is a form input where the DOM holds the value, and React reads it via a ref — typically on submit.
-
Side Effect
A side effect is any operation that affects something outside the component — data fetching, DOM manipulation, subscriptions, logging.
-
Dependency Array
The dependency array is the second argument to useEffect/useMemo/useCallback that tells React when to re-run or recompute.
-
Strict Mode
Strict Mode is a development-only wrapper component that intentionally double-invokes certain functions to surface hidden bugs.
-
useTransition
useTransition marks state updates as low priority so the UI stays responsive during heavy renders.
-
useDeferredValue
useDeferredValue lets you defer a prop/value so the UI stays responsive during expensive recomputations.
-
useId
useId creates a unique ID for linking label/input, aria attributes — SSR-safe and hydration-safe.
-
useSyncExternalStore
useSyncExternalStore connects React to external state (Redux, Zustand) with concurrent-safe subscriptions.
-
useInsertionEffect
useInsertionEffect fires before any DOM mutation — use it for CSS-in-JS style injection, not general logic.
-
Concurrent Features
Concurrent features let React work on multiple UI updates at once, interrupting low-priority work for urgent updates.
-
Suspense List
Suspense List controls the reveal order of multiple Suspense boundaries — prevents layout jumps.
-
Server Components
Server Components run on the server, never ship to the client — reducing bundle size and enabling direct backend access.
-
Hydration
Hydration turns static server-rendered HTML into a fully interactive React app by attaching event handlers.
-
useImperativeHandle
useImperativeHandle lets a child component expose specific methods to a parent via ref, hiding internal details.
-
forwardRef
forwardRef passes a ref through a component to its child — needed for ref forwarding in function components.
-
Lazy Component
React.lazy + Suspense enables code-splitting — components load on demand, reducing initial bundle size.
-
Batch Updates
React batches multiple setState calls into one re-render — automatic in React 18, even in async code.
-
Reconciliation Algorithm
Reconciliation compares old and new virtual DOM trees to find the minimum set of DOM mutations needed.
-
Fiber Architecture
Fiber is React's internal tree structure that supports pausing, resuming, and prioritizing rendering work.
-
Synthetic Event
SyntheticEvent wraps native events to provide consistent cross-browser behavior and pooling.
-
React DevTools
React DevTools browser extension lets you inspect component hierarchies, hooks state, and profile renders.
-
Profiler
<Profiler> measures render cost of its subtree — use the DevTools Profiler or the Profiler API for optimization.
-
Strict Mode Effects
Strict Mode double-invokes effects (mount, cleanup, remount) to catch missing cleanup logic.
-
Concurrent Mode
Concurrent Mode enables React to interrupt rendering for urgent updates — enabled by default with createRoot.
TypeScript Basics
60 terms
TypeScript Basics terminology
-
TypeScript
TypeScript is a strongly typed programming language that builds on JavaScript by adding static type definitions, catching errors before the code runs.
-
Type Annotation
A type annotation is an explicit declaration of a variable's or parameter's type using a colon followed by the type name.
-
Type Inference
Type inference is TypeScript's ability to automatically figure out the type of a variable or expression from its usage, without requiring an explicit annotation.
-
Interface
An interface is a TypeScript construct that defines the shape of an object — which properties it has and their types — without containing any implementation code.
-
Type Alias
A type alias is a name for a type, created with the `type` keyword. It can alias primitives, unions, intersections, tuples, and object types.
-
Union Type
A union type (A | B) represents a value that can be either type A or type B. The pipe symbol | reads as 'or'.
-
Intersection Type
An intersection type (A & B) represents a value that has all properties of both type A and type B. The ampersand & reads as 'and'.
-
Generic
A generic is a type variable (like T) that lets you write functions, classes, and types that work with any type while preserving type safety.
-
Type Guard
A type guard is a check (like typeof or a user-defined function) that narrows a value's type within a conditional block, enabling type-safe access to type-specific properties.
-
Type Narrowing
Type narrowing is the process by which TypeScript refines a value's type to a more specific type within a code block, based on checks like typeof, instanceof, or truthiness.
-
Enum
An enum is a TypeScript feature that defines a set of named constants, either numeric or string-based, making code more readable and self-documenting.
-
Tuple
A tuple is an array type with a fixed number of elements where each position has a specific, potentially different type.
-
Utility Type
Utility types are built-in TypeScript types that transform existing types in common ways: Partial, Required, Readonly, Pick, Omit, Record, and more.
-
Mapped Type
A mapped type is a TypeScript construct that iterates over the properties of an existing type and produces a new type with transformed properties.
-
Conditional Type
A conditional type (T extends U ? X : Y) selects type X if T is assignable to U, otherwise type Y. It enables type-level programming.
-
Template Literal Type
A template literal type uses template literal syntax at the type level to create string types that match a specific pattern.
-
Decorator
A decorator is a TypeScript feature (experimental) that modifies or enhances classes, methods, properties, or parameters using a @decorator syntax.
-
Namespace
A namespace is a TypeScript construct (largely superseded by ES modules) that groups related declarations under a single name to avoid global scope pollution.
-
Declaration File
A declaration file (.d.ts) provides TypeScript type information for JavaScript code that doesn't include types, enabling type checking for the entire JS ecosystem.
-
tsconfig
tsconfig.json is the configuration file that tells the TypeScript compiler how to compile: target, strictness, module system, file inclusion/exclusion, and more.
-
Strict Mode
Strict mode (strict: true in tsconfig) enables a family of strict type-checking options including noImplicitAny, strictNullChecks, and more.
-
Type Assertion
A type assertion (value as Type or <Type>value) tells TypeScript to treat a value as a different type. It is a compile-time hint with no runtime effect.
-
Type Compatibility
Type compatibility is the rules TypeScript uses to determine if a value of one type can be assigned to a variable of another type, based on structural typing.
-
Structural Typing
Structural typing is a type system where compatibility is determined by the structure (properties) of types, not by their names or declarations.
-
Type Widening
Type widening occurs when TypeScript generalizes a literal type (like 5) to its base type (like number) during type inference, typically for mutable variables.
-
Type Erasure
Type erasure is the process by which the TypeScript compiler removes all type annotations, interfaces, and type aliases, producing plain JavaScript with no type information.
-
Keyof Operator
The keyof operator takes an object type and returns a union of its property names (keys), enabling type-safe property access.
-
Indexed Access Type
An indexed access type (T[K]) extracts the type of a property K from type T, enabling type-level property lookup.
-
Readonly
The readonly modifier prevents assignment to a property or mutation of an array, enforcing immutability at the type level.
-
Optional Property
An optional property (prop?: Type) is a property that can be absent or undefined. The question mark before the colon marks it as optional.
-
Void Type
The void type indicates that a function's return value should not be used. It is the return type for functions that don't return anything meaningful.
-
Never Type
The never type represents a value that never occurs — no value can have type never. It is used for functions that always throw and for exhaustiveness checking.
-
Unknown Type
The unknown type accepts any value but requires type narrowing before use, making it a type-safe alternative to any.
-
Any Type
The any type opts out of type checking entirely — a variable of type any can hold any value and perform any operation without compiler errors.
-
Null and Undefined
null and undefined are distinct types in TypeScript. With strictNullChecks enabled, they are not assignable to other types, preventing null reference errors.
-
Optional Chaining
Optional chaining (?.) safely accesses nested properties, returning undefined instead of throwing when the left side is null or undefined.
-
Nullish Coalescing
The nullish coalescing operator (??) returns the right side only if the left is null or undefined, unlike || which checks all falsy values.
-
Discriminated Union
A discriminated union is a union of object types that share a common property (the discriminant), enabling type narrowing via switch statements.
-
Satisfies Operator
The satisfies operator (x satisfies T) checks that a value matches type T without widening the value's type, preserving more precise literal types.
-
Const Assertion
A const assertion (as const) tells TypeScript to infer the narrowest possible types — literal types instead of widened base types, and readonly arrays/tuples.
-
Type Predicate
'x is T' is a type guard return type that tells TypeScript to narrow the type in if/else branches.
-
Infer
infer declares a type variable inside conditional types to extract and capture types from matched patterns.
-
Recursive Type
Recursive types reference themselves — useful for trees, JSON, nested menus, and fractal data structures.
-
Tuple Rest
Tuple rest (...T[]) enables tuples with fixed leading elements and a variable number of trailing elements.
-
Variance
Variance determines if T→U means G<T>→G<U> (covariant), G<U>→G<T> (contravariant), or neither (invariant).
-
Module Augmentation
Module augmentation uses declare module to add types/methods to existing modules like library types.
-
Ambient Module
Ambient modules (declare module) describe JS libraries' types without implementation — used in .d.ts files.
-
Triple Slash Directive
/// directives are single-line comments that instruct the TypeScript compiler — used for type references and path aliases.
-
Type-Only Import
'import type' imports only types — erased at runtime, preventing accidental inclusion of type-only modules in bundles.
-
Branded Type
Branded types add a phantom field to distinguish types that have the same structure — preventing UserId/UserEmail mixups.
-
Result Type
Result<T, E> is a union of Ok<T> or Err<E> — explicit error handling without try/catch, inspired by Rust.
-
Option Type
Option<T> is Some<T> | None — explicit representation of optional values without null/undefined pitfalls.
-
Newtype Pattern
Newtype creates a distinct type from an existing one — same runtime value, different compile-time type.
-
Phantom Type
Phantom types are unused type parameters that add compile-time distinctions without runtime cost.
-
Type-Level Programming
Type-level programming computes types using conditional types, infer, and recursion — no runtime code needed.
-
String Manipulation Types
TypeScript can transform string types at compile time: uppercase, capitalize, replace, split, template literals.
-
Awaited Type
Awaited<T> unwraps nested Promises — Awaited<Promise<Promise<number>>> is number.
-
NoInfer
NoInfer<T> stops TypeScript from using a parameter position to infer T — useful for controlling inference.
-
Array Manipulation Types
TypeScript can manipulate tuple types at compile time: append, prepend, filter, reverse, flatten.
-
Const Type Parameter
<const T> makes type parameter inference use literal types instead of widening — like as const for generics.
Databases & SQL
60 terms
Databases & SQL terminology
-
Database
A database is an organized collection of data stored so it can be accessed, managed, and updated efficiently.
-
DBMS
A DBMS (Database Management System) is the software that creates, reads, updates, and manages a database.
-
Relational Database
A relational database stores data in tables (rows and columns) linked by relationships, and uses SQL to query it.
-
NoSQL
NoSQL databases store data without a fixed table schema — as documents, key-value pairs, wide columns, or graphs — prioritizing flexibility and horizontal scale.
-
Table
A table is a structure in a relational database that holds data in rows and columns — like a spreadsheet with strict rules.
-
Row
A row (also called a record or tuple) is a single data entry in a table — one value for each column.
-
Column
A column is a named field in a table that stores one specific type of data (text, number, date) for every row.
-
Primary Key
A primary key is a column whose value uniquely identifies each row — no two rows share the same primary key value, and it cannot be NULL.
-
Foreign Key
A foreign key is a column in one table that references the primary key of another table, creating a link between the two.
-
Unique Key
A unique key is a constraint that prevents duplicate values in a column — every value must be different.
-
Index
An index is a data structure that makes finding rows by a column much faster, like a book's index for quick lookup.
-
SQL
SQL (Structured Query Language) is the language used to create, read, update, and delete data in relational databases.
-
Query
A query is a statement written in SQL (or another query language) that asks the database to perform an operation.
-
SELECT
SELECT is the SQL command that reads data from a database — it specifies which columns to return and from which table.
-
WHERE Clause
The WHERE clause filters rows in a query — only rows where the condition is true are included in the result.
-
JOIN
A JOIN combines rows from two or more tables based on a condition — usually matching a foreign key to a primary key.
-
INNER JOIN
INNER JOIN returns only the rows where the join condition matches in both tables — non-matching rows are excluded.
-
LEFT JOIN
LEFT JOIN returns every row from the left table; for rows with no match in the right table, the right columns are NULL.
-
Aggregation
Aggregation is the process of computing a single summary value from many rows using functions like COUNT, SUM, AVG, MIN, MAX.
-
GROUP BY
GROUP BY groups rows that share the same value in specified columns, so aggregate functions compute a result per group.
-
ORDER BY
ORDER BY sorts the query results by specified columns, either ascending (ASC) or descending (DESC).
-
HAVING
HAVING filters groups created by GROUP BY — it is like WHERE, but applied after aggregation rather than before.
-
Subquery
A subquery is a SELECT statement nested inside another SQL statement — its result is used by the outer query.
-
Transaction
A transaction is a sequence of database operations that are treated as one unit — either all succeed or all are rolled back.
-
ACID
ACID stands for Atomicity, Consistency, Isolation, and Durability — the four properties that guarantee reliable database transactions.
-
COMMIT
COMMIT is the SQL command that permanently saves all changes made during the current transaction.
-
ROLLBACK
ROLLBACK is the SQL command that cancels the current transaction and undoes all uncommitted changes.
-
Normalization
Normalization is the process of structuring tables to minimize data duplication and avoid update anomalies.
-
Denormalization
Denormalization is the intentional process of duplicating data across tables to speed up reads by avoiding joins.
-
View
A view is a named, saved SQL query that behaves like a virtual table — it does not store data itself.
-
Stored Procedure
A stored procedure is a named block of SQL code stored in the database that can be called with parameters.
-
Trigger
A trigger is a stored procedure that fires automatically when INSERT, UPDATE, or DELETE occurs on a table.
-
Constraint
A constraint is a rule enforced by the database — it rejects any data that violates the rule.
-
Schema
A schema is the blueprint of a database — it defines the tables, columns, data types, constraints, and relationships.
-
Migration
A migration is a script that modifies the database schema — creating tables, adding columns, etc. — tracked in version control.
-
Connection Pool
A connection pool maintains a set of open database connections that are reused across requests, avoiding the cost of opening new connections.
-
MongoDB
MongoDB is a NoSQL document database that stores data as flexible JSON-like documents (BSON) in collections.
-
Redis
Redis is an in-memory key-value database — it stores data as key-value pairs in RAM for sub-millisecond access.
-
Document
A document is a NoSQL record — a flexible JSON-like object with any fields, stored in a collection.
-
Key-Value Store
A key-value store is a NoSQL database where every item is a unique key mapped to a value — no schema, no relations.
-
Cursor
A cursor iterates over query results one row at a time — useful for large datasets that don't fit in memory.
-
Prepared Statement
Prepared statements pre-compile SQL with placeholders — faster for repeated execution and immune to SQL injection.
-
EXPLAIN
EXPLAIN reveals the query plan: which indexes are used, join order, estimated costs — for optimization.
-
Query Plan
A query plan is the optimizer's chosen execution strategy — the sequence of operations to run a query.
-
B-Tree Index
B-Tree indexes keep data sorted in a balanced tree — fast for lookups, ranges, and ORDER BY.
-
Hash Index
Hash indexes use hash tables for O(1) equality lookups — fastest for = queries but can't do ranges or sorting.
-
Composite Index
Composite indexes cover multiple columns — speed up queries filtering on several columns at once.
-
Covering Index
A covering index has all columns a query needs — the database answers from the index without reading the table.
-
Partitioning
Partitioning divides a table into smaller pieces by range/list/hash — improves query speed and maintenance.
-
Sharding
Sharding splits data across multiple database servers — horizontal scaling for datasets too large for one machine.
-
Replication
Replication copies data to multiple servers — read scaling, failover, and disaster recovery.
-
Isolation Levels
Isolation levels determine transaction visibility: Read Uncommitted, Read Committed, Repeatable Read, Serializable.
-
Deadlock
A deadlock is when two transactions wait for each other's locks — neither can proceed, one must be rolled back.
-
Optimistic Locking
Optimistic locking: read without locking, check version before update — fail if someone else changed the row.
-
Pessimistic Locking
Pessimistic locking holds locks on rows — blocks other transactions from modifying them until commit/rollback.
-
N+1 Problem
N+1 problem: 1 query loads N records, then N queries load each record's relations — should be 1 query with a join.
-
ORM (Object-Relational Mapper)
ORM maps database tables to objects — write code in your language instead of SQL, with automatic query generation.
-
SQL Injection
SQL injection inserts malicious SQL via user input — prevented by parameterized queries/prepared statements.
-
CAP Theorem
CAP theorem: in a distributed system, you can have at most 2 of Consistency, Availability, Partition tolerance — not all 3.
-
Eventual Consistency
Eventual consistency: replicas may be temporarily inconsistent but will eventually converge — AP systems like Cassandra.
Testing & Debugging
60 terms
Testing & Debugging terminology
-
Unit Test
A unit test checks one small piece of code — typically a single function — independently, with all external dependencies replaced by mocks or stubs.
-
Integration Test
An integration test checks that two or more parts of your system work correctly when connected, catching issues that unit tests miss.
-
End-to-End Test (E2E)
An E2E test drives a real browser through your application just like a user would, verifying the complete flow works from UI to database and back.
-
Test Suite
A test suite is a group of related tests. For example, all tests for a Calculator class form one suite.
-
Test Case
A test case is one individual test — it checks one specific thing, like 'add(2, 3) returns 5'.
-
Assertion
An assertion is the 'check' part of a test — it verifies that the actual result matches the expected result.
-
Matcher
A matcher is the method that defines how to compare values in an assertion, e.g., toBe for equality, toContain for membership.
-
Mock
A mock is a stand-in for a real dependency (like a database or API) that lets you control what it returns and verify how it was called.
-
Stub
A stub is a simplified replacement that just returns canned responses — it doesn't verify how it was called.
-
Spy
A spy watches a real function and records its calls (arguments, return values, call count) while still running the original behavior.
-
Test-Driven Development (TDD)
TDD means writing the test first, watching it fail (red), writing code to pass it (green), then improving the code (refactor).
-
Behavior-Driven Development (BDD)
BDD uses natural language (Given-When-Then) to describe expected behavior, making tests readable by non-technical people.
-
Red-Green-Refactor
The TDD cycle: Red (failing test), Green (passing test), Refactor (improve code while tests pass).
-
Code Coverage
Code coverage measures how much of your code is exercised by tests — e.g., '85% of lines were executed during tests.'
-
Branch Coverage
Branch coverage checks that every if/else branch (both true and false paths) was tested, not just the lines.
-
Line Coverage
Line coverage is the simplest coverage metric — what percentage of your code lines were executed by tests.
-
Test Runner
A test runner is the tool that runs your tests, collects results, and shows pass/fail output. Examples: Jest, Mocha, Vitest.
-
Jest
Jest is the most popular JavaScript testing framework — it includes everything: test runner, assertions, mocks, snapshots, and coverage.
-
Mocha
Mocha is a lightweight test runner that lets you choose your own assertion library (Chai) and mocking library (Sinon).
-
Vitest
Vitest is a fast test runner built on Vite, with a Jest-compatible API — easy migration from Jest with better performance.
-
Snapshot Testing
Snapshot testing saves a 'snapshot' of output on first run, then compares future runs against it — flagging any changes.
-
Test Pyramid
The test pyramid says: lots of unit tests (fast, cheap), some integration tests (medium), few E2E tests (slow, expensive).
-
Setup and Teardown
Setup (beforeEach/beforeAll) prepares the environment before tests; teardown (afterEach/afterAll) cleans up after.
-
Parameterized Test
A parameterized test runs one test logic against many input/output pairs, reducing duplication. Jest uses test.each().
-
Flaky Test
A flaky test is unreliable — it passes and fails randomly without code changes, eroding trust in the test suite.
-
Playwright
Playwright is a modern E2E testing tool by Microsoft — fast, reliable, cross-browser, with auto-waiting built in.
-
Cypress
Cypress is an E2E testing tool known for its excellent developer experience, time-travel debugging, and in-browser execution.
-
Arrange-Act-Assert (AAA)
AAA is a test pattern: Arrange (set up data), Act (call the code), Assert (check the result). It improves test readability.
-
Test Double
Test double is the umbrella term for all replacement objects in testing: mocks, stubs, spies, fakes, and dummies.
-
Fake
A fake is a test double with real but simplified behavior — e.g., an in-memory database instead of a real PostgreSQL instance.
-
Continuous Integration (CI)
CI automatically builds and tests code on every push, preventing broken code from merging into the main branch.
-
Test Isolation
Test isolation means each test is self-contained — it doesn't depend on other tests' results or shared mutable state.
-
Regression
A regression is when code that used to work stops working after a change. Tests exist to catch regressions.
-
Test Coverage Threshold
Coverage thresholds are minimum coverage percentages configured in your test runner — if coverage drops below, the build fails.
-
DOM Testing
DOM testing verifies code that manipulates the web page structure, using a simulated DOM (jsdom) in Node.js or a real browser.
-
jsdom
jsdom is a fake DOM implemented in JavaScript — it lets you test DOM code in Node.js without launching a real browser.
-
React Testing Library
React Testing Library tests components like a user would — querying by role and text, not by implementation details.
-
userEvent
userEvent simulates real user interactions (click, type, etc.) more realistically than fireEvent, with proper event sequences.
-
Shallow Rendering
Shallow rendering shows a component without its children — useful for isolating a component's logic from its children.
-
Given-When-Then
Given-When-Then is the BDD scenario format: Given some state, When an action occurs, Then this should result.
-
Mutation Testing
Mutation testing changes your code in small ways (mutants) — if tests still pass, your tests have gaps.
-
Property-Based Testing
Property-based testing checks universal properties with random inputs — instead of testing specific cases, you test that rules always hold.
-
Contract Testing
Contract testing ensures API providers and consumers agree on the interface — without needing full integration tests.
-
Load Testing
Load testing simulates real user traffic to check if the system handles expected load — response times, throughput, error rates.
-
Stress Testing
Stress testing increases load beyond expected limits to find when and how the system breaks — and if it recovers.
-
Soak Testing
Soak testing applies normal load for hours/days — catches memory leaks, resource leaks, and gradual performance degradation.
-
Spike Testing
Spike testing hits the system with sudden massive traffic spikes — checks if it degrades gracefully or crashes.
-
Smoke Testing
Smoke testing runs basic tests to check the system is 'alive' — if smoke tests fail, skip deeper testing.
-
Exploratory Testing
Exploratory testing is unscripted, simultaneous learning and testing — testers explore the app creatively to find unexpected bugs.
-
A/B Testing
A/B testing splits users between two versions and measures which performs better — data-driven decision making for features.
-
Visual Regression Testing
Visual regression testing screenshots your UI and compares to baseline — catches unintended visual changes automatically.
-
Accessibility Testing
Accessibility testing ensures your app works with screen readers, keyboard-only navigation, and meets WCAG standards for users with disabilities.
-
Performance Testing
Performance testing measures speed and responsiveness — load times, latency, FPS — to ensure the app meets performance requirements.
-
Benchmark Testing
Benchmark testing measures how fast specific code runs — operations per second, execution time — for comparing implementations.
-
Fuzz Testing
Fuzz testing bombards your code with random/malformed inputs — finds crashes and security issues that normal tests miss.
-
Mock Server
A mock server fakes an API backend — returns predefined responses, lets you test frontend/integration without the real server.
-
Test Fixture
A test fixture is the known starting state for tests — setup data, objects, config — ensuring tests are consistent and repeatable.
-
Test Data Factory
A test data factory creates test objects with default values — tests override only what matters, keeping test data DRY and maintainable.
-
Code Review
Code review is peer review of code before merge — catches bugs, improves quality, shares knowledge, enforces standards.
-
Static Analysis
Static analysis scans code without running it — finds type errors, bugs, security issues, and style violations automatically.
DevOps & Deployment
60 terms
DevOps & Deployment terminology
-
CI/CD
CI/CD is the practice of automatically building, testing, and deploying code every time a change is pushed.
-
Container
A container is a lightweight, portable package that bundles an application with everything it needs to run.
-
Docker
Docker is a platform that lets you build, ship, and run applications in containers.
-
Kubernetes
Kubernetes (K8s) is a platform that automates deploying, scaling, and managing containerized applications across clusters of machines.
-
Pod
A Pod is the smallest unit in Kubernetes that can be created and deployed, containing one or more containers.
-
Deployment
A Deployment is a Kubernetes resource that manages a set of Pods, enabling scaling, updates, and rollbacks.
-
Service
A Service is a Kubernetes resource that provides a stable network identity for a set of Pods, even as Pods are created and destroyed.
-
Ingress
An Ingress is a Kubernetes resource that routes external HTTP/HTTPS traffic to Services based on host and path rules.
-
ConfigMap
A ConfigMap is a Kubernetes resource that stores non-confidential configuration data in key-value pairs, separate from container images.
-
Secret
A Secret is a Kubernetes resource that stores sensitive data such as passwords, tokens, and keys, encoded in base64.
-
Namespace
A Namespace is a Kubernetes feature that groups resources into a named, isolated virtual cluster within a physical cluster.
-
Helm
Helm is the package manager for Kubernetes that uses Charts to define, install, and upgrade complex applications.
-
Terraform
Terraform is an Infrastructure as Code (IaC) tool that lets you define and provision cloud infrastructure using declarative configuration files.
-
Ansible
Ansible is an open-source automation tool that configures servers and deploys software using simple YAML playbooks.
-
Jenkins
Jenkins is an open-source automation server that helps build, test, and deploy code through configurable pipelines.
-
GitHub Actions
GitHub Actions is GitHub's built-in CI/CD platform that automates workflows triggered by repository events.
-
GitLab CI
GitLab CI is GitLab's integrated CI/CD service that runs pipelines defined in a .gitlab-ci.yml file.
-
Pipeline
A pipeline is an automated sequence of steps (build, test, deploy) that code passes through from commit to production.
-
Artifact
An artifact is a file or set of files produced by a build pipeline, such as a binary, package, or Docker image.
-
Registry
A registry is a storage and distribution service for container images and build artifacts.
-
Image
An image is a read-only, layered template that contains everything needed to run a containerized application.
-
Volume
A Volume is a storage mechanism that lets containers persist data even when the container is stopped or recreated.
-
Network
Container networking defines how containers communicate with each other, the host, and external networks.
-
Load Balancer
A load balancer distributes incoming network traffic across multiple servers to ensure reliability and performance.
-
Reverse Proxy
A reverse proxy is a server that receives client requests and forwards them to backend servers, then returns the response.
-
Nginx
Nginx is a popular open-source web server, reverse proxy, and load balancer known for high performance and low resource usage.
-
SSL/TLS
SSL/TLS is a security protocol that encrypts data between a client and server, enabling HTTPS.
-
Monitoring
Monitoring is the practice of collecting and analyzing metrics, logs, and traces to understand system health and performance.
-
Prometheus
Prometheus is an open-source monitoring and alerting system that collects metrics as time-series data using a pull model.
-
Grafana
Grafana is an open-source analytics and visualization platform that creates dashboards from multiple data sources.
-
Logging
Logging is the practice of recording application events and errors to centralized storage for debugging and analysis.
-
ELK Stack
The ELK Stack is a logging platform combining Elasticsearch (search), Logstash (collection), and Kibana (visualization).
-
Alerting
Alerting is the practice of automatically notifying the team when metrics cross thresholds or errors occur.
-
Health Check
A health check is a periodic test that verifies a service is running and ready to serve requests.
-
Liveness Probe
A liveness probe checks if a container is still running properly; if it fails, Kubernetes restarts the container.
-
Readiness Probe
A readiness probe checks if a container is ready to handle requests; if it fails, the container is removed from the Service's endpoints.
-
Auto Scaling
Auto scaling automatically adjusts the number of running instances (pods, servers) based on current load.
-
Horizontal Pod Autoscaler
The HPA is a Kubernetes resource that automatically scales the number of Pods in a Deployment based on CPU, memory, or custom metrics.
-
Rolling Update
A rolling update gradually replaces old instances with new ones, ensuring zero downtime during deployment.
-
Blue-Green Deployment
Blue-green deployment maintains two identical environments (blue and green) and switches traffic from old to new in one step.
-
Canary Deployment
Canary deployment routes a small percentage of traffic to the new version first, increasing gradually to limit blast radius.
-
Infrastructure as Code
IaC defines infrastructure in code files — versioned, reusable, and automated instead of manual clicking.
-
Service Mesh
A service mesh manages inter-service communication — traffic routing, retries, encryption, and monitoring without code changes.
-
Sidecar Pattern
Sidecar pattern: a helper container runs alongside the main app — handles logging, monitoring, proxying without coupling.
-
Observability
Observability lets you understand internal system state from external outputs — metrics, logs, and traces (the three pillars).
-
Distributed Tracing
Distributed tracing tracks a request across services — shows the full path, timing, and causality of each step.
-
Log Aggregation
Log aggregation centralizes logs from all services into one searchable store — for debugging, analysis, and alerting.
-
Service Discovery
Service discovery finds service instances dynamically — essential when containers scale up and down constantly.
-
Circuit Breaker
Circuit breaker trips when a service fails repeatedly — stops calling it to prevent cascading failures and allow recovery.
-
Chaos Engineering
Chaos engineering injects failures on purpose — discovers weaknesses before real incidents happen.
-
Feature Flag
Feature flags toggle features on/off at runtime — decouple deploy from release, enable A/B testing and instant rollback.
-
Immutable Infrastructure
Immutable infrastructure: never modify running servers — replace them entirely on any change. Ensures consistency and trivial rollback.
-
GitOps
GitOps uses Git as the source of truth — changes in Git automatically sync to the cluster. Git history IS the deployment history.
-
Runbook
A runbook documents step-by-step procedures for operating and troubleshooting a system — guides on-call responders.
-
Incident Response
Incident response is the structured process of handling outages — detect, contain, resolve, and learn from incidents.
-
Postmortem
A postmortem is a blameless retrospective after an incident — documents root cause, impact, and action items to prevent recurrence.
-
SLO (Service Level Objective)
SLO is a reliability target (e.g., 99.9% uptime) that guides how much effort to spend on reliability vs new features.
-
SLI (Service Level Indicator)
SLI is the measurement of service health (e.g., success rate, latency p99) — the raw data that SLOs are evaluated against.
-
Error Budget
Error budget = 1 - SLO. It is the allowed failures. Under budget → ship features. Over budget → focus on reliability.
-
Infrastructure Drift
Infrastructure drift is when real infrastructure diverges from its config — manual changes create untracked differences.
No terms found.